gemba 0.1.1 → 0.2.0

data/vendor/rcheevos/src/rc_libretro.h

@@ -0,0 +1,98 @@
+#ifndef RC_LIBRETRO_H
+#define RC_LIBRETRO_H
+
+#include "rc_export.h"
+
+#include "rc_hash.h"
+
+/* this file comes from the libretro repository, which is not an explicit submodule.
+ * the integration must set up paths appropriately to find it. */
+#include <libretro.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+RC_BEGIN_C_DECLS
+
+/*****************************************************************************\
+| Disallowed Settings                                                         |
+\*****************************************************************************/
+
+typedef struct rc_disallowed_setting_t
+{
+  const char* setting;
+  const char* value;
+} rc_disallowed_setting_t;
+
+RC_EXPORT const rc_disallowed_setting_t* RC_CCONV rc_libretro_get_disallowed_settings(const char* library_name);
+RC_EXPORT int RC_CCONV rc_libretro_is_setting_allowed(const rc_disallowed_setting_t* disallowed_settings, const char* setting, const char* value);
+RC_EXPORT int RC_CCONV rc_libretro_is_system_allowed(const char* library_name, uint32_t console_id);
+
+/*****************************************************************************\
+| Memory Mapping                                                              |
+\*****************************************************************************/
+
+/* specifies a function to call for verbose logging */
+typedef void (RC_CCONV *rc_libretro_message_callback)(const char*);
+RC_EXPORT void RC_CCONV rc_libretro_init_verbose_message_callback(rc_libretro_message_callback callback);
+
+#define RC_LIBRETRO_MAX_MEMORY_REGIONS 32
+typedef struct rc_libretro_memory_regions_t
+{
+  uint8_t* data[RC_LIBRETRO_MAX_MEMORY_REGIONS];
+  size_t size[RC_LIBRETRO_MAX_MEMORY_REGIONS];
+  size_t total_size;
+  uint32_t count;
+} rc_libretro_memory_regions_t;
+
+typedef struct rc_libretro_core_memory_info_t
+{
+  uint8_t* data;
+  size_t size;
+} rc_libretro_core_memory_info_t;
+
+typedef void (RC_CCONV *rc_libretro_get_core_memory_info_func)(uint32_t id, rc_libretro_core_memory_info_t* info);
+
+RC_EXPORT int RC_CCONV rc_libretro_memory_init(rc_libretro_memory_regions_t* regions, const struct retro_memory_map* mmap,
+                            rc_libretro_get_core_memory_info_func get_core_memory_info, uint32_t console_id);
+RC_EXPORT void RC_CCONV rc_libretro_memory_destroy(rc_libretro_memory_regions_t* regions);
+
+RC_EXPORT uint8_t* RC_CCONV rc_libretro_memory_find(const rc_libretro_memory_regions_t* regions, uint32_t address);
+RC_EXPORT uint8_t* RC_CCONV rc_libretro_memory_find_avail(const rc_libretro_memory_regions_t* regions, uint32_t address, uint32_t* avail);
+RC_EXPORT uint32_t RC_CCONV rc_libretro_memory_read(const rc_libretro_memory_regions_t* regions, uint32_t address, uint8_t* buffer, uint32_t num_bytes);
+
+/*****************************************************************************\
+| Disk Identification                                                         |
+\*****************************************************************************/
+
+typedef struct rc_libretro_hash_entry_t
+{
+  uint32_t                         path_djb2;
+  uint32_t                         game_id;
+  char                             hash[33];
+} rc_libretro_hash_entry_t;
+
+typedef struct rc_libretro_hash_set_t
+{
+  struct rc_libretro_hash_entry_t* entries;
+  uint16_t                         entries_count;
+  uint16_t                         entries_size;
+
+  rc_hash_callbacks_t              callbacks;
+} rc_libretro_hash_set_t;
+
+typedef int (RC_CCONV *rc_libretro_get_image_path_func)(uint32_t index, char* buffer, size_t buffer_size);
+
+RC_EXPORT void RC_CCONV rc_libretro_hash_set_init(struct rc_libretro_hash_set_t* hash_set,
+                               const char* m3u_path, rc_libretro_get_image_path_func get_image_path,
+                               const rc_hash_filereader_t* file_reader);
+RC_EXPORT void RC_CCONV rc_libretro_hash_set_destroy(struct rc_libretro_hash_set_t* hash_set);
+
+RC_EXPORT void RC_CCONV rc_libretro_hash_set_add(struct rc_libretro_hash_set_t* hash_set,
+                                                 const char* path, uint32_t game_id, const char hash[33]);
+RC_EXPORT const char* RC_CCONV rc_libretro_hash_set_get_hash(const struct rc_libretro_hash_set_t* hash_set, const char* path);
+RC_EXPORT int RC_CCONV rc_libretro_hash_set_get_game_id(const struct rc_libretro_hash_set_t* hash_set, const char* hash);
+
+RC_END_C_DECLS
+
+#endif /* RC_LIBRETRO_H */

data/vendor/rcheevos/src/rc_util.c

@@ -0,0 +1,199 @@
+#include "rc_util.h"
+
+#include "rc_compat.h"
+#include "rc_error.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#undef DEBUG_BUFFERS
+
+/* --- rc_buffer --- */
+
+void rc_buffer_init(rc_buffer_t* buffer)
+{
+  buffer->chunk.write = buffer->chunk.start = &buffer->data[0];
+  buffer->chunk.end = &buffer->data[sizeof(buffer->data)];
+  buffer->chunk.next = NULL;
+  /* leave buffer->data uninitialized */
+}
+
+void rc_buffer_destroy(rc_buffer_t* buffer)
+{
+  rc_buffer_chunk_t* chunk;
+#ifdef DEBUG_BUFFERS
+  int count = 0;
+  int wasted = 0;
+  int total = 0;
+#endif
+
+  /* first chunk is not allocated. skip it. */
+  chunk = buffer->chunk.next;
+
+  /* deallocate any additional buffers */
+  while (chunk)
+  {
+    rc_buffer_chunk_t* next = chunk->next;
+#ifdef DEBUG_BUFFERS
+    total += (int)(chunk->end - chunk->start);
+    wasted += (int)(chunk->end - chunk->write);
+    ++count;
+#endif
+#ifdef DEBUG_BUFFERS
+    printf("< free %p.%p\n", (void*)buffer, (void*)chunk);
+#endif
+    free(chunk);
+    chunk = next;
+  }
+
+#ifdef DEBUG_BUFFERS
+  printf("-- %d allocated buffers (%d/%d used, %d wasted, %0.2f%% efficiency)\n", count,
+    total - wasted, total, wasted, (float)(100.0 - (wasted * 100.0) / total));
+#endif
+}
+
+uint8_t* rc_buffer_reserve(rc_buffer_t* buffer, size_t amount)
+{
+  rc_buffer_chunk_t* chunk = &buffer->chunk;
+  size_t remaining;
+  while (chunk)
+  {
+    remaining = chunk->end - chunk->write;
+    if (remaining >= amount)
+      return chunk->write;
+
+    if (!chunk->next)
+    {
+      /* allocate a chunk of memory that is a multiple of 256-bytes. the first 32 bytes will be associated
+       * to the chunk header, and the remaining will be used for data.
+       */
+      const size_t chunk_header_size = sizeof(rc_buffer_chunk_t);
+      const size_t alloc_size = (chunk_header_size + amount + 0xFF) & ~0xFF;
+      chunk->next = (rc_buffer_chunk_t*)malloc(alloc_size);
+      if (!chunk->next)
+        break;
+
+#ifdef DEBUG_BUFFERS
+      printf("> alloc %p.%p\n", (void*)buffer, (void*)chunk->next);
+#endif
+
+      chunk->next->start = (uint8_t*)chunk->next + chunk_header_size;
+      chunk->next->write = chunk->next->start;
+      chunk->next->end = (uint8_t*)chunk->next + alloc_size;
+      chunk->next->next = NULL;
+    }
+
+    chunk = chunk->next;
+  }
+
+  return NULL;
+}
+
+void rc_buffer_consume(rc_buffer_t* buffer, const uint8_t* start, uint8_t* end)
+{
+  rc_buffer_chunk_t* chunk = &buffer->chunk;
+  do
+  {
+    if (chunk->write == start)
+    {
+      size_t offset = (end - chunk->start);
+      offset = (offset + 7) & ~7;
+      chunk->write = &chunk->start[offset];
+
+      if (chunk->write > chunk->end)
+        chunk->write = chunk->end;
+      break;
+    }
+
+    chunk = chunk->next;
+  } while (chunk);
+}
+
+void* rc_buffer_alloc(rc_buffer_t* buffer, size_t amount)
+{
+  uint8_t* ptr = rc_buffer_reserve(buffer, amount);
+  rc_buffer_consume(buffer, ptr, ptr + amount);
+  return (void*)ptr;
+}
+
+char* rc_buffer_strncpy(rc_buffer_t* buffer, const char* src, size_t len)
+{
+  uint8_t* dst = rc_buffer_reserve(buffer, len + 1);
+  memcpy(dst, src, len);
+  dst[len] = '\0';
+  rc_buffer_consume(buffer, dst, dst + len + 2);
+  return (char*)dst;
+}
+
+char* rc_buffer_strcpy(rc_buffer_t* buffer, const char* src)
+{
+  return rc_buffer_strncpy(buffer, src, strlen(src));
+}
+
+/* --- other --- */
+
+void rc_format_md5(char checksum[33], const uint8_t digest[16])
+{
+  snprintf(checksum, 33, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+    digest[0], digest[1], digest[2], digest[3], digest[4], digest[5], digest[6], digest[7],
+    digest[8], digest[9], digest[10], digest[11], digest[12], digest[13], digest[14], digest[15]
+  );
+}
+
+uint32_t rc_djb2(const char* input)
+{
+  uint32_t result = 5381;
+  char c;
+
+  while ((c = *input++) != '\0')
+    result = ((result << 5) + result) + c; /* result = result * 33 + c */
+
+  return result;
+}
+
+const char* rc_error_str(int ret)
+{
+  switch (ret) {
+    case RC_OK: return "OK";
+    case RC_INVALID_FUNC_OPERAND: return "Invalid function operand";
+    case RC_INVALID_MEMORY_OPERAND: return "Invalid memory operand";
+    case RC_INVALID_CONST_OPERAND: return "Invalid constant operand";
+    case RC_INVALID_FP_OPERAND: return "Invalid floating-point operand";
+    case RC_INVALID_CONDITION_TYPE: return "Invalid condition type";
+    case RC_INVALID_OPERATOR: return "Invalid operator";
+    case RC_INVALID_REQUIRED_HITS: return "Invalid required hits";
+    case RC_DUPLICATED_START: return "Duplicated start condition";
+    case RC_DUPLICATED_CANCEL: return "Duplicated cancel condition";
+    case RC_DUPLICATED_SUBMIT: return "Duplicated submit condition";
+    case RC_DUPLICATED_VALUE: return "Duplicated value expression";
+    case RC_DUPLICATED_PROGRESS: return "Duplicated progress expression";
+    case RC_MISSING_START: return "Missing start condition";
+    case RC_MISSING_CANCEL: return "Missing cancel condition";
+    case RC_MISSING_SUBMIT: return "Missing submit condition";
+    case RC_MISSING_VALUE: return "Missing value expression";
+    case RC_INVALID_LBOARD_FIELD: return "Invalid field in leaderboard";
+    case RC_MISSING_DISPLAY_STRING: return "Missing display string";
+    case RC_OUT_OF_MEMORY: return "Out of memory";
+    case RC_INVALID_VALUE_FLAG: return "Invalid flag in value expression";
+    case RC_MISSING_VALUE_MEASURED: return "Missing measured flag in value expression";
+    case RC_MULTIPLE_MEASURED: return "Multiple measured targets";
+    case RC_INVALID_MEASURED_TARGET: return "Invalid measured target";
+    case RC_INVALID_COMPARISON: return "Invalid comparison";
+    case RC_INVALID_STATE: return "Invalid state";
+    case RC_INVALID_JSON: return "Invalid JSON";
+    case RC_API_FAILURE: return "API call failed";
+    case RC_LOGIN_REQUIRED: return "Login required";
+    case RC_NO_GAME_LOADED: return "No game loaded";
+    case RC_HARDCORE_DISABLED: return "Hardcore disabled";
+    case RC_ABORTED: return "Aborted";
+    case RC_NO_RESPONSE: return "No response";
+    case RC_ACCESS_DENIED: return "Access denied";
+    case RC_INVALID_CREDENTIALS: return "Invalid credentials";
+    case RC_EXPIRED_TOKEN: return "Expired token";
+    case RC_INSUFFICIENT_BUFFER: return "Buffer not large enough";
+    case RC_INVALID_VARIABLE_NAME: return "Invalid variable name";
+    case RC_UNKNOWN_VARIABLE_NAME: return "Unknown variable name";
+    case RC_NOT_FOUND: return "Not found";
+    default: return "Unknown error";
+  }
+}

data/vendor/rcheevos/src/rc_version.c

@@ -0,0 +1,11 @@
+#include "rc_version.h"
+
+uint32_t rc_version(void)
+{
+  return RCHEEVOS_VERSION;
+}
+
+const char* rc_version_string(void)
+{
+  return RCHEEVOS_VERSION_STRING;
+}

data/vendor/rcheevos/src/rc_version.h

@@ -0,0 +1,32 @@
+#ifndef RC_VERSION_H
+#define RC_VERSION_H
+
+#include "rc_export.h"
+
+#include <stdint.h>
+
+RC_BEGIN_C_DECLS
+
+#define RCHEEVOS_VERSION_MAJOR 12
+#define RCHEEVOS_VERSION_MINOR 3
+#define RCHEEVOS_VERSION_PATCH 0
+
+#define RCHEEVOS_MAKE_VERSION(major, minor, patch) (major * 1000000 + minor * 1000 + patch)
+#define RCHEEVOS_VERSION RCHEEVOS_MAKE_VERSION(RCHEEVOS_VERSION_MAJOR, RCHEEVOS_VERSION_MINOR, RCHEEVOS_VERSION_PATCH)
+
+#define RCHEEVOS_MAKE_STRING(num) #num
+#define RCHEEVOS_MAKE_VERSION_STRING(major, minor, patch) RCHEEVOS_MAKE_STRING(major) "." RCHEEVOS_MAKE_STRING(minor) "." RCHEEVOS_MAKE_STRING(patch)
+#define RCHEEVOS_MAKE_VERSION_STRING_SHORT(major, minor) RCHEEVOS_MAKE_STRING(major) "." RCHEEVOS_MAKE_STRING(minor)
+
+#if RCHEEVOS_VERSION_PATCH > 0
+ #define RCHEEVOS_VERSION_STRING RCHEEVOS_MAKE_VERSION_STRING(RCHEEVOS_VERSION_MAJOR, RCHEEVOS_VERSION_MINOR, RCHEEVOS_VERSION_PATCH)
+#else
+ #define RCHEEVOS_VERSION_STRING RCHEEVOS_MAKE_VERSION_STRING_SHORT(RCHEEVOS_VERSION_MAJOR, RCHEEVOS_VERSION_MINOR)
+#endif
+
+RC_EXPORT uint32_t rc_version(void);
+RC_EXPORT const char* rc_version_string(void);
+
+RC_END_C_DECLS
+
+#endif /* RC_VERSION_H */

data/vendor/rcheevos/src/rcheevos/alloc.c

@@ -0,0 +1,312 @@
+#include "rc_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+void* rc_alloc_scratch(void* pointer, int32_t* offset, uint32_t size, uint32_t alignment, rc_scratch_t* scratch, uint32_t scratch_object_pointer_offset)
+{
+  void* data;
+
+  /* if we have a real buffer, then allocate the data there */
+  if (pointer)
+    return rc_alloc(pointer, offset, size, alignment, NULL, scratch_object_pointer_offset);
+
+  /* update how much space will be required in the real buffer */
+  {
+    const int32_t aligned_offset = (*offset + alignment - 1) & ~(alignment - 1);
+    *offset += (aligned_offset - *offset);
+    *offset += size;
+  }
+
+  /* find a scratch buffer to hold the temporary data */
+  data = rc_buffer_alloc(&scratch->buffer, size);
+  if (!data) {
+    *offset = RC_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  return data;
+}
+
+void* rc_alloc(void* pointer, int32_t* offset, uint32_t size, uint32_t alignment, rc_scratch_t* scratch, uint32_t scratch_object_pointer_offset) {
+  void* ptr;
+
+  *offset = (*offset + alignment - 1) & ~(alignment - 1);
+
+  if (pointer != 0) {
+    /* valid buffer, grab the next chunk */
+    ptr = (void*)((uint8_t*)pointer + *offset);
+  }
+  else if (scratch != 0 && scratch_object_pointer_offset < sizeof(scratch->objs)) {
+    /* only allocate one instance of each object type (indentified by scratch_object_pointer_offset) */
+    void** scratch_object_pointer = (void**)((uint8_t*)&scratch->objs + scratch_object_pointer_offset);
+    ptr = *scratch_object_pointer;
+    if (!ptr) {
+      int32_t used;
+      ptr = *scratch_object_pointer = rc_alloc_scratch(NULL, &used, size, alignment, scratch, -1);
+    }
+  }
+  else {
+    /* nowhere to get memory from, return NULL */
+    ptr = NULL;
+  }
+
+  *offset += size;
+  return ptr;
+}
+
+char* rc_alloc_str(rc_parse_state_t* parse, const char* text, size_t length) {
+  int32_t used = 0;
+  char* ptr;
+
+  rc_scratch_string_t** next = &parse->scratch.strings;
+  while (*next) {
+    int diff = strncmp(text, (*next)->value, length);
+    if (diff == 0) {
+      diff = (*next)->value[length];
+      if (diff == 0)
+        return (*next)->value;
+    }
+
+    if (diff < 0)
+      next = &(*next)->left;
+    else
+      next = &(*next)->right;
+  }
+
+  *next = (rc_scratch_string_t*)rc_alloc_scratch(NULL, &used, sizeof(rc_scratch_string_t), RC_ALIGNOF(rc_scratch_string_t), &parse->scratch, RC_OFFSETOF(parse->scratch.objs, __rc_scratch_string_t));
+  ptr = (char*)rc_alloc_scratch(parse->buffer, &parse->offset, (uint32_t)length + 1, RC_ALIGNOF(char), &parse->scratch, -1);
+
+  if (!ptr || !*next) {
+    if (parse->offset >= 0)
+      parse->offset = RC_OUT_OF_MEMORY;
+
+    return NULL;
+  }
+
+  memcpy(ptr, text, length);
+  ptr[length] = '\0';
+
+  (*next)->left = NULL;
+  (*next)->right = NULL;
+  (*next)->value = ptr;
+
+  return ptr;
+}
+
+void rc_init_preparse_state(rc_preparse_state_t* preparse)
+{
+  rc_init_parse_state(&preparse->parse, NULL);
+  rc_init_parse_state_memrefs(&preparse->parse, &preparse->memrefs);
+}
+
+void rc_destroy_preparse_state(rc_preparse_state_t* preparse)
+{
+  rc_destroy_parse_state(&preparse->parse);
+}
+
+void rc_preparse_alloc_memrefs(rc_memrefs_t* memrefs, rc_preparse_state_t* preparse)
+{
+  const uint32_t num_memrefs = rc_memrefs_count_memrefs(&preparse->memrefs);
+  const uint32_t num_modified_memrefs = rc_memrefs_count_modified_memrefs(&preparse->memrefs);
+
+  if (preparse->parse.offset < 0)
+    return;
+
+  if (memrefs) {
+    memset(memrefs, 0, sizeof(*memrefs));
+    preparse->parse.memrefs = memrefs;
+  }
+
+  if (num_memrefs) {
+    rc_memref_t* memref_items = RC_ALLOC_ARRAY(rc_memref_t, num_memrefs, &preparse->parse);
+
+    if (memrefs) {
+      memrefs->memrefs.capacity = num_memrefs;
+      memrefs->memrefs.items = memref_items;
+    }
+  }
+
+  if (num_modified_memrefs) {
+    rc_modified_memref_t* modified_memref_items =
+      RC_ALLOC_ARRAY(rc_modified_memref_t, num_modified_memrefs, &preparse->parse);
+
+    if (memrefs) {
+      memrefs->modified_memrefs.capacity = num_modified_memrefs;
+      memrefs->modified_memrefs.items = modified_memref_items;
+    }
+  }
+
+  /* when preparsing, this structure will be allocated at the end. when it's allocated earlier
+   * in the buffer, it could be followed by something aligned at 8 bytes. force the offset to
+   * an 8-byte boundary */
+  if (!memrefs) {
+    rc_alloc(preparse->parse.buffer, &preparse->parse.offset, 0, 8, &preparse->parse.scratch, 0);
+  }
+}
+
+static uint32_t rc_preparse_array_size(uint32_t needed, uint32_t minimum)
+{
+  while (minimum < needed)
+    minimum <<= 1;
+
+  return minimum;
+}
+
+void rc_preparse_reserve_memrefs(rc_preparse_state_t* preparse, rc_memrefs_t* memrefs)
+{
+  uint32_t num_memrefs = rc_memrefs_count_memrefs(&preparse->memrefs);
+  uint32_t num_modified_memrefs = rc_memrefs_count_modified_memrefs(&preparse->memrefs);
+  uint32_t available;
+
+  if (preparse->parse.offset < 0)
+    return;
+
+  if (num_memrefs) {
+    rc_memref_list_t* memref_list = &memrefs->memrefs;
+    while (memref_list->count == memref_list->capacity) {
+      if (!memref_list->next)
+        break;
+
+      memref_list = memref_list->next;
+    }
+
+    available = memref_list->capacity - memref_list->count;
+    if (available < num_memrefs) {
+      rc_memref_list_t* new_memref_list = (rc_memref_list_t*)calloc(1, sizeof(rc_memref_list_t));
+      if (!new_memref_list)
+        return;
+
+      new_memref_list->capacity = rc_preparse_array_size(num_memrefs - available, 16);
+      new_memref_list->items = (rc_memref_t*)malloc(new_memref_list->capacity * sizeof(rc_memref_t));
+      new_memref_list->allocated = 1;
+      memref_list->next = new_memref_list;
+    }
+  }
+
+  if (num_modified_memrefs) {
+    rc_modified_memref_list_t* modified_memref_list = &memrefs->modified_memrefs;
+    while (modified_memref_list->count == modified_memref_list->capacity) {
+      if (!modified_memref_list->next)
+        break;
+
+      modified_memref_list = modified_memref_list->next;
+    }
+
+    available = modified_memref_list->capacity - modified_memref_list->count;
+    if (available < num_modified_memrefs) {
+      rc_modified_memref_list_t* new_modified_memref_list = (rc_modified_memref_list_t*)calloc(1, sizeof(rc_modified_memref_list_t));
+      if (!new_modified_memref_list)
+        return;
+
+      new_modified_memref_list->capacity = rc_preparse_array_size(num_modified_memrefs - available, 8);
+      new_modified_memref_list->items = (rc_modified_memref_t*)malloc(new_modified_memref_list->capacity * sizeof(rc_modified_memref_t));
+      new_modified_memref_list->allocated = 1;
+      modified_memref_list->next = new_modified_memref_list;
+    }
+  }
+
+  preparse->parse.memrefs = memrefs;
+}
+
+static void rc_preparse_sync_operand(rc_operand_t* operand, rc_parse_state_t* parse, const rc_memrefs_t* memrefs)
+{
+  if (rc_operand_is_memref(operand) || rc_operand_is_recall(operand)) {
+    const rc_memref_t* src_memref = operand->value.memref;
+
+    if (src_memref->value.memref_type == RC_MEMREF_TYPE_MODIFIED_MEMREF) {
+      const rc_modified_memref_list_t* modified_memref_list = &memrefs->modified_memrefs;
+      for (; modified_memref_list; modified_memref_list = modified_memref_list->next) {
+        const rc_modified_memref_t* modified_memref = modified_memref_list->items;
+        const rc_modified_memref_t* modified_memref_end = modified_memref + modified_memref_list->count;
+
+        for (; modified_memref < modified_memref_end; ++modified_memref) {
+          if ((const rc_modified_memref_t*)src_memref == modified_memref) {
+            rc_modified_memref_t* dst_modified_memref = rc_alloc_modified_memref(parse, modified_memref->memref.value.size,
+              &modified_memref->parent, modified_memref->modifier_type, &modified_memref->modifier);
+
+            operand->value.memref = &dst_modified_memref->memref;
+            return;
+          }
+        }
+      }
+    }
+    else {
+      const rc_memref_list_t* memref_list = &memrefs->memrefs;
+      for (; memref_list; memref_list = memref_list->next) {
+        const rc_memref_t* memref = memref_list->items;
+        const rc_memref_t* memref_end = memref + memref_list->count;
+
+        for (; memref < memref_end; ++memref) {
+          if (src_memref == memref) {
+            operand->value.memref = rc_alloc_memref(parse, memref->address, memref->value.size);
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+void rc_preparse_copy_memrefs(rc_parse_state_t* parse, rc_memrefs_t* memrefs)
+{
+  const rc_memref_list_t* memref_list = &memrefs->memrefs;
+  const rc_modified_memref_list_t* modified_memref_list = &memrefs->modified_memrefs;
+
+  for (; memref_list; memref_list = memref_list->next) {
+    const rc_memref_t* memref = memref_list->items;
+    const rc_memref_t* memref_end = memref + memref_list->count;
+
+    for (; memref < memref_end; ++memref)
+      rc_alloc_memref(parse, memref->address, memref->value.size);
+  }
+
+  for (; modified_memref_list; modified_memref_list = modified_memref_list->next) {
+    rc_modified_memref_t* modified_memref = modified_memref_list->items;
+    const rc_modified_memref_t* modified_memref_end = modified_memref + modified_memref_list->count;
+
+    for (; modified_memref < modified_memref_end; ++modified_memref) {
+      rc_preparse_sync_operand(&modified_memref->parent, parse, memrefs);
+      rc_preparse_sync_operand(&modified_memref->modifier, parse, memrefs);
+
+      rc_alloc_modified_memref(parse, modified_memref->memref.value.size,
+        &modified_memref->parent, modified_memref->modifier_type, &modified_memref->modifier);
+    }
+  }
+}
+
+void rc_reset_parse_state(rc_parse_state_t* parse, void* buffer)
+{
+  parse->buffer = buffer;
+
+  parse->offset = 0;
+  parse->memrefs = NULL;
+  parse->existing_memrefs = NULL;
+  parse->variables = NULL;
+  parse->measured_target = 0;
+  parse->lines_read = 0;
+  parse->addsource_oper = RC_OPERATOR_NONE;
+  parse->addsource_parent.type = RC_OPERAND_NONE;
+  parse->indirect_parent.type = RC_OPERAND_NONE;
+  parse->remember.type = RC_OPERAND_NONE;
+  parse->is_value = 0;
+  parse->has_required_hits = 0;
+  parse->measured_as_percent = 0;
+  parse->ignore_non_parse_errors = 0;
+
+  parse->scratch.strings = NULL;
+}
+
+void rc_init_parse_state(rc_parse_state_t* parse, void* buffer)
+{
+  /* could use memset here, but rc_parse_state_t contains a 512 byte buffer that doesn't need to be initialized */
+  rc_buffer_init(&parse->scratch.buffer);
+  memset(&parse->scratch.objs, 0, sizeof(parse->scratch.objs));
+
+  rc_reset_parse_state(parse, buffer);
+}
+
+void rc_destroy_parse_state(rc_parse_state_t* parse)
+{
+  rc_buffer_destroy(&parse->scratch.buffer);
+}