Merge branch 'master' into wip

Conflicts:
	makefile

include/avian/tools/object-writer/tools.h

@@ -12,6 +12,9 @@
 #define AVIAN_TOOLS_H_
 
 #include <stdlib.h>
+
+#include <avian/util/string.h>
+
 #include "environment.h"
 
 namespace avian {
@@ -38,24 +41,12 @@ public:
   virtual void write(uint8_t byte);
 };
 
-class String {
-public:
-  const char* text;
-  size_t length;
-
-  String(const char* text);
-  
-  inline String(const char* text, size_t length):
-    text(text),
-    length(length) {}
-};
-
 class SymbolInfo {
 public:
   unsigned addr;
-  String name;
+  util::String name;
 
-  inline SymbolInfo(uint64_t addr, const String& name):
+  inline SymbolInfo(uint64_t addr, const util::String& name):
     addr(addr),
     name(name) {}
 
@@ -78,7 +69,7 @@ public:
 
 class StringTable : public Buffer {
 public:
-  unsigned add(String str);
+  unsigned add(util::String str);
 };
 
 template<class T>

include/avian/util/runtime-array.h

@@ -32,9 +32,9 @@ class RuntimeArray {
 
 #else // not _MSC_VER
 
-#  define RUNTIME_ARRAY(type, name, size) type name[size];
+#  define RUNTIME_ARRAY(type, name, size) type name##_body[size];
-#  define RUNTIME_ARRAY_BODY(name) name
+#  define RUNTIME_ARRAY_BODY(name) name##_body
 
 #endif
 
-#endif // AVIAN_UTIL_RUNTIME_ARRAY_H
+#endif // AVIAN_UTIL_RUNTIME_ARRAY_H

include/avian/util/string.h

@@ -8,27 +8,37 @@
    There is NO WARRANTY for this software.  See license.txt for
    details. */
 
-#ifndef TOKENIZER_H
+#ifndef AVIAN_UTIL_STRING_H
-#define TOKENIZER_H
+#define AVIAN_UTIL_STRING_H
 
-namespace vm {
+#include <string.h>
+
+namespace avian {
+namespace util {
+
+class String {
+public:
+  const char* text;
+  size_t length;
+
+  String(const char* text):
+    text(text),
+    length(strlen(text)) {}
+  
+  inline String(const char* text, size_t length):
+    text(text),
+    length(length) {}
+};
 
 class Tokenizer {
  public:
-  class Token {
-   public:
-    Token(const char* s, unsigned length): s(s), length(length) { }
-
-    const char* s;
-    unsigned length;
-  };
 
   Tokenizer(const char* s, char delimiter):
     s(s), limit(0), delimiter(delimiter)
   { }
 
-  Tokenizer(const char* s, unsigned length, char delimiter):
+  Tokenizer(String str, char delimiter):
-    s(s), limit(s + length), delimiter(delimiter)
+    s(str.text), limit(str.text + str.length), delimiter(delimiter)
   { }
 
   bool hasMore() {
@@ -36,10 +46,10 @@ class Tokenizer {
     return s != limit and *s != 0;
   }
 
-  Token next() {
+  String next() {
     const char* p = s;
     while (s != limit and *s and *s != delimiter) ++s;
-    return Token(p, s - p);
+    return String(p, s - p);
   }
 
   const char* s;
@@ -47,6 +57,7 @@ class Tokenizer {
   char delimiter;
 };
 
-} // namespace
+} // namespace util
+} // namespace avain
 
-#endif//TOKENIZER_H
+#endif//AVIAN_UTIL_STRING_H

include/avian/vm/codegen/assembler.h

@@ -11,7 +11,7 @@
 #ifndef AVIAN_CODEGEN_ASSEMBLER_H
 #define AVIAN_CODEGEN_ASSEMBLER_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "zone.h"
 
 #include <avian/vm/codegen/lir.h>

include/avian/vm/codegen/compiler.h

@@ -11,7 +11,7 @@
 #ifndef AVIAN_CODEGEN_COMPILER_H
 #define AVIAN_CODEGEN_COMPILER_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "zone.h"
 #include "assembler.h"
 

include/avian/vm/heap/heap.h

@@ -11,7 +11,7 @@
 #ifndef HEAP_H
 #define HEAP_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "allocator.h"
 
 namespace vm {

makefile

@@ -939,10 +939,14 @@ generated-code = \
 	$(build)/type-name-initializations.cpp \
 	$(build)/type-maps.cpp
 
-vm-depends := $(generated-code) $(wildcard $(src)/*.h) $(wildcard $(src)/codegen/*.h)
+vm-depends := $(generated-code) \
+	$(wildcard $(src)/*.h) \
+	$(wildcard $(src)/codegen/*.h) \
+	$(wildcard $(src)/codegen/compiler/*.h) \
+	$(shell find src include -name '*.h' -or -name '*.inc.cpp')
 
 vm-sources = \
-	$(src)/$(system).cpp \
+	$(src)/vm/system/$(system).cpp \
 	$(src)/finder.cpp \
 	$(src)/machine.cpp \
 	$(src)/util.cpp \
@@ -1026,7 +1030,7 @@ heapwalk-sources = $(src)/heapwalk.cpp
 heapwalk-objects = \
 	$(call cpp-objects,$(heapwalk-sources),$(src),$(build))
 
-unittest-objects = $(call cpp-objects,$(unittest-sources),$(unittest),$(build)/unittest/)
+unittest-objects = $(call cpp-objects,$(unittest-sources),$(unittest),$(build)/unittest)
 
 ifeq ($(heapdump),true)
 	vm-sources += $(src)/heapdump.cpp
@@ -1043,7 +1047,8 @@ ifeq ($(continuations),true)
 	asmflags += -DAVIAN_CONTINUATIONS
 endif
 
-bootimage-generator-sources = $(src)/bootimage.cpp $(src)/util/arg-parser.cpp
+bootimage-generator-sources = $(src)/tools/bootimage-generator/main.cpp $(src)/util/arg-parser.cpp
+
 ifneq ($(lzma),)
 	bootimage-generator-sources += $(src)/lzma-encode.cpp
 endif
@@ -1078,8 +1083,8 @@ boot-object = $(build)/boot.o
 
 generator-depends := $(wildcard $(src)/*.h)
 generator-sources = \
-	$(src)/type-generator.cpp \
+	$(src)/tools/type-generator/main.cpp \
-	$(src)/$(build-system).cpp \
+	$(src)/vm/system/$(build-system).cpp \
 	$(src)/finder.cpp
 
 ifneq ($(lzma),)

src/alloc-vector.h

@@ -11,7 +11,7 @@
 #ifndef VECTOR_H
 #define VECTOR_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "target.h"
 
 #include <avian/util/math.h>

src/arm.h

@@ -206,7 +206,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
             ++ stackIndex;
           }
 
-          memcpy(stack + stackIndex, arguments + ai, 8);
+          memcpy(RUNTIME_ARRAY_BODY(stack) + stackIndex, arguments + ai, 8);
           stackIndex += 8 / BytesPerWord;
         }
         ai += 8 / BytesPerWord;
@@ -219,7 +219,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
       } else if (vfpIndex < VfpCount) {
         vfpTable[vfpIndex++] = arguments[ai];
       } else {
-        stack[stackIndex++] = arguments[ai];
+        RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai];
       }
       ++ ai;
       break;
@@ -231,7 +231,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
             and gprIndex + Alignment == GprCount)
         {
           gprTable[gprIndex++] = arguments[ai];
-          stack[stackIndex++] = arguments[ai + 1];
+          RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai + 1];
         } else {
           if (gprIndex % Alignment) {
             ++gprIndex;
@@ -246,7 +246,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
           ++stackIndex;
         }
 
-        memcpy(stack + stackIndex, arguments + ai, 8);
+        memcpy(RUNTIME_ARRAY_BODY(stack) + stackIndex, arguments + ai, 8);
         stackIndex += 8 / BytesPerWord;
       }
       ai += 8 / BytesPerWord;
@@ -256,7 +256,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
       if (gprIndex < GprCount) {
         gprTable[gprIndex++] = arguments[ai];
       } else {
-        stack[stackIndex++] = arguments[ai];
+        RUNTIME_ARRAY_BODY(stack)[stackIndex++] = arguments[ai];
       }
       ++ ai;
     } break;
@@ -274,7 +274,7 @@ dynamicCall(void* function, uintptr_t* arguments, uint8_t* argumentTypes,
 
   unsigned stackSize = stackIndex*BytesPerWord + ((stackIndex & 1) << 2);
   return vmNativeCall
-    (function, stackSize, stack, stackIndex * BytesPerWord,
+    (function, stackSize, RUNTIME_ARRAY_BODY(stack), stackIndex * BytesPerWord,
      (gprIndex ? gprTable : 0),
      (vfpIndex ? vfpTable : 0), returnType);
 }

src/bootimage.h

@@ -12,6 +12,7 @@
 #define BOOTIMAGE_H
 
 #include "common.h"
+#include "java-common.h"
 #include "target.h"
 #include "machine.h"
 

src/classpath-common.h

@@ -11,10 +11,11 @@
 #ifndef CLASSPATH_COMMON_H
 #define CLASSPATH_COMMON_H
 
-#include "tokenizer.h"
+#include <avian/util/string.h>
-
 #include <avian/util/runtime-array.h>
 
+using namespace avian::util;
+
 namespace vm {
 
 object
@@ -217,13 +218,13 @@ loadLibrary(Thread* t, const char* path, const char* name, bool mapName,
   for (Tokenizer tokenizer(path, t->m->system->pathSeparator());
        tokenizer.hasMore();)
   {
-    Tokenizer::Token token(tokenizer.next());
+    String token(tokenizer.next());
 
     unsigned fullNameLength = token.length + 1 + nameLength;
     THREAD_RUNTIME_ARRAY(t, char, fullName, fullNameLength + 1);
 
     snprintf(RUNTIME_ARRAY_BODY(fullName), fullNameLength + 1,
-             "%.*s/%s", token.length, token.s, name);
+             "%.*s/%s", token.length, token.text, name);
 
     lib = loadLibrary(t, RUNTIME_ARRAY_BODY(fullName));
     if (lib) break;

src/codegen/arm/assembler.cpp

@@ -2236,14 +2236,6 @@ class MyArchitecture: public Assembler::Architecture {
   virtual int framePointerOffset() {
     return 0;
   }
-
-  virtual lir::BinaryOperation hasBinaryIntrinsic(Thread*, object) {
-  	return lir::NoBinaryOperation;
-  }
-  
-  virtual lir::TernaryOperation hasTernaryIntrinsic(Thread*, object) {
-  	return lir::NoTernaryOperation;
-  }
   
   virtual bool alwaysCondensed(lir::BinaryOperation) {
     return false;

src/codegen/powerpc/assembler.cpp

@@ -2240,14 +2240,6 @@ class MyArchitecture: public Assembler::Architecture {
   virtual int framePointerOffset() {
     return 0;
   }
-
-  virtual lir::BinaryOperation hasBinaryIntrinsic(Thread*, object) {
-  	return lir::NoBinaryOperation;
-  }
-  
-  virtual lir::TernaryOperation hasTernaryIntrinsic(Thread*, object) {
-  	return lir::NoTernaryOperation;
-  }
   
   virtual bool alwaysCondensed(lir::BinaryOperation) {
     return false;

src/common.h

@@ -546,57 +546,6 @@ equal(const void* a, unsigned al, const void* b, unsigned bl)
   }
 }
 
-class Machine;
-class Thread;
-
-struct Object { };
-
-typedef Object* object;
-
-typedef uint8_t jboolean;
-typedef int8_t jbyte;
-typedef uint16_t jchar;
-typedef int16_t jshort;
-typedef int32_t jint;
-typedef int64_t jlong;
-typedef float jfloat;
-typedef double jdouble;
-
-typedef jint jsize;
-
-typedef object* jobject;
-
-typedef jobject jclass;
-typedef jobject jthrowable;
-typedef jobject jstring;
-typedef jobject jweak;
-
-typedef jobject jarray;
-typedef jarray jbooleanArray;
-typedef jarray jbyteArray;
-typedef jarray jcharArray;
-typedef jarray jshortArray;
-typedef jarray jintArray;
-typedef jarray jlongArray;
-typedef jarray jfloatArray;
-typedef jarray jdoubleArray;
-typedef jarray jobjectArray;
-
-typedef uintptr_t jfieldID;
-typedef uintptr_t jmethodID;
-
-union jvalue {
-  jboolean z;
-  jbyte    b;
-  jchar    c;
-  jshort   s;
-  jint     i;
-  jlong    j;
-  jfloat   f;
-  jdouble  d;
-  jobject  l;
-};
-
 } // namespace vm
 
-#endif//COMMON_H
+#endif // COMMON_H

src/finder.cpp

@@ -8,15 +8,17 @@
    There is NO WARRANTY for this software.  See license.txt for
    details. */
 
+#include <avian/vm/system/system.h>
+#include <avian/util/string.h>
+#include <avian/util/runtime-array.h>
+
 #include "zlib-custom.h"
-#include "system.h"
-#include "tokenizer.h"
 #include "finder.h"
 #include "lzma.h"
 
-#include <avian/util/runtime-array.h>
 
 using namespace vm;
+using namespace avian::util;
 
 namespace {
 
@@ -658,12 +660,12 @@ addTokens(System* s, Element** first, Element** last, Allocator* allocator,
           const char* jarName, unsigned jarNameBase, const char* tokens,
           unsigned tokensLength, const char* bootLibrary)
 {
-  for (Tokenizer t(tokens, tokensLength, ' '); t.hasMore();) {
+  for (Tokenizer t(String(tokens, tokensLength), ' '); t.hasMore();) {
-    Tokenizer::Token token(t.next());
+    String token(t.next());
 
     RUNTIME_ARRAY(char, n, jarNameBase + token.length + 1);
     memcpy(RUNTIME_ARRAY_BODY(n), jarName, jarNameBase);
-    memcpy(RUNTIME_ARRAY_BODY(n) + jarNameBase, token.s, token.length);
+    memcpy(RUNTIME_ARRAY_BODY(n) + jarNameBase, token.text, token.length);
     RUNTIME_ARRAY_BODY(n)[jarNameBase + token.length] = 0;
           
     add(s, first, last, allocator, RUNTIME_ARRAY_BODY(n),
@@ -813,9 +815,9 @@ parsePath(System* s, Allocator* allocator, const char* path,
   Element* first = 0;
   Element* last = 0;
   for (Tokenizer t(path, s->pathSeparator()); t.hasMore();) {
-    Tokenizer::Token token(t.next());
+    String token(t.next());
 
-    add(s, &first, &last, allocator, token.s, token.length, bootLibrary);
+    add(s, &first, &last, allocator, token.text, token.length, bootLibrary);
   }
 
   return first;

src/finder.h

@@ -12,7 +12,7 @@
 #define FINDER_H
 
 #include "common.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "allocator.h"
 
 namespace vm {

src/heap/heap.cpp

@@ -9,7 +9,7 @@
    details. */
 
 #include <avian/vm/heap/heap.h>
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "common.h"
 #include "arch.h"
 

src/heapwalk.h

@@ -12,6 +12,7 @@
 #define HEAPWALK_H
 
 #include "common.h"
+#include "java-common.h"
 
 namespace vm {
 

src/interpret.cpp

@@ -9,7 +9,7 @@
    details. */
 
 #include "common.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "constants.h"
 #include "machine.h"
 #include "processor.h"
@@ -2325,19 +2325,20 @@ interpret3(Thread* t, const int base)
 
     THREAD_RUNTIME_ARRAY(t, int32_t, counts, dimensions);
     for (int i = dimensions - 1; i >= 0; --i) {
-      counts[i] = popInt(t);
+      RUNTIME_ARRAY_BODY(counts)[i] = popInt(t);
-      if (UNLIKELY(counts[i] < 0)) {
+      if (UNLIKELY(RUNTIME_ARRAY_BODY(counts)[i] < 0)) {
         exception = makeThrowable
-          (t, Machine::NegativeArraySizeExceptionType, "%d", counts[i]);
+          (t, Machine::NegativeArraySizeExceptionType, "%d",
+           RUNTIME_ARRAY_BODY(counts)[i]);
         goto throw_;
       }
     }
 
-    object array = makeArray(t, counts[0]);
+    object array = makeArray(t, RUNTIME_ARRAY_BODY(counts)[0]);
     setObjectClass(t, array, class_);
     PROTECT(t, array);
 
-    populateMultiArray(t, array, counts, 0, dimensions);
+    populateMultiArray(t, array, RUNTIME_ARRAY_BODY(counts), 0, dimensions);
 
     pushObject(t, array);
   } goto loop;

src/java-common.h

@@ -0,0 +1,69 @@
+/* Copyright (c) 2008-2012, Avian Contributors
+
+   Permission to use, copy, modify, and/or distribute this software
+   for any purpose with or without fee is hereby granted, provided
+   that the above copyright notice and this permission notice appear
+   in all copies.
+
+   There is NO WARRANTY for this software.  See license.txt for
+   details. */
+
+#ifndef JAVA_COMMON_H
+#define JAVA_COMMON_H
+
+namespace vm {
+
+class Machine;
+class Thread;
+
+struct Object { };
+
+typedef Object* object;
+
+typedef uint8_t jboolean;
+typedef int8_t jbyte;
+typedef uint16_t jchar;
+typedef int16_t jshort;
+typedef int32_t jint;
+typedef int64_t jlong;
+typedef float jfloat;
+typedef double jdouble;
+
+typedef jint jsize;
+
+typedef object* jobject;
+
+typedef jobject jclass;
+typedef jobject jthrowable;
+typedef jobject jstring;
+typedef jobject jweak;
+
+typedef jobject jarray;
+typedef jarray jbooleanArray;
+typedef jarray jbyteArray;
+typedef jarray jcharArray;
+typedef jarray jshortArray;
+typedef jarray jintArray;
+typedef jarray jlongArray;
+typedef jarray jfloatArray;
+typedef jarray jdoubleArray;
+typedef jarray jobjectArray;
+
+typedef uintptr_t jfieldID;
+typedef uintptr_t jmethodID;
+
+union jvalue {
+  jboolean z;
+  jbyte    b;
+  jchar    c;
+  jshort   s;
+  jint     i;
+  jlong    j;
+  jfloat   f;
+  jdouble  d;
+  jobject  l;
+};
+
+} // namespace vm
+
+#endif // JAVA_COMMON_H

src/lzma-util.h

@@ -13,7 +13,7 @@
 
 #include "lzma.h"
 #include "C/Types.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "allocator.h"
 
 namespace vm {

src/lzma.h

@@ -11,7 +11,7 @@
 #ifndef LZMA_H
 #define LZMA_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "allocator.h"
 
 namespace vm {

src/machine.cpp

@@ -11,7 +11,7 @@
 #include "jnienv.h"
 #include "machine.h"
 #include "util.h"
-#include "stream.h"
+#include <avian/util/stream.h>
 #include "constants.h"
 #include "processor.h"
 #include "arch.h"
@@ -4777,13 +4777,13 @@ logTrace(FILE* f, const char* fmt, ...)
 
     RUNTIME_ARRAY(char, buffer, length + 1);
     va_start(a, fmt);
-    vsnprintf(&buffer[0], length + 1, fmt, a);
+    vsnprintf(RUNTIME_ARRAY_BODY(buffer), length + 1, fmt, a);
     va_end(a);
-    buffer[length] = 0;
+    RUNTIME_ARRAY_BODY(buffer)[length] = 0;
 
-    ::fprintf(f, "%s", &buffer[0]);
+    ::fprintf(f, "%s", RUNTIME_ARRAY_BODY(buffer));
 #ifdef PLATFORM_WINDOWS
-    ::OutputDebugStringA(&buffer[0]);
+    ::OutputDebugStringA(RUNTIME_ARRAY_BODY(buffer));
 #endif
 }
 

src/machine.h

@@ -12,7 +12,8 @@
 #define MACHINE_H
 
 #include "common.h"
-#include "system.h"
+#include "java-common.h"
+#include <avian/vm/system/system.h>
 #include <avian/vm/heap/heap.h>
 #include "finder.h"
 #include "processor.h"
@@ -1603,7 +1604,8 @@ class ThreadRuntimeArray: public Thread::Resource {
 
 #else // not _MSC_VER
 
-#  define THREAD_RUNTIME_ARRAY(thread, type, name, size) type name[size];
+#  define THREAD_RUNTIME_ARRAY(thread, type, name, size) \
+  type name##_body[size];
 
 #endif // not _MSC_VER
 

src/main.cpp

@@ -13,7 +13,7 @@
 #include "string.h"
 #include "jni.h"
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "finder.h"
 
 #include <avian/util/runtime-array.h>

src/process.h

@@ -12,7 +12,7 @@
 #define PROCESS_H
 
 #include "common.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "machine.h"
 #include "constants.h"
 

src/processor.h

@@ -12,7 +12,7 @@
 #define PROCESSOR_H
 
 #include "common.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include <avian/vm/heap/heap.h>
 #include "bootimage.h"
 #include "heapwalk.h"

src/tools/bootimage-generator/main.cpp

@@ -13,11 +13,12 @@
 #include "common.h"
 #include "machine.h"
 #include "util.h"
-#include "stream.h"
+#include <avian/util/stream.h>
 #include <avian/vm/codegen/assembler.h>
 #include <avian/vm/codegen/promise.h>
 #include "target.h"
 #include <avian/tools/object-writer/tools.h>
+#include <avian/util/runtime-array.h>
 #include "lzma.h"
 
 #include "util/arg-parser.h"
@@ -349,20 +350,20 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
         unsigned count = s.read2() - 1;
         if (count) {
           THREAD_RUNTIME_ARRAY(t, Type, types, count + 2);
-          types[0] = Type_object;
+          RUNTIME_ARRAY_BODY(types)[0] = Type_object;
-          types[1] = Type_intptr_t;
+          RUNTIME_ARRAY_BODY(types)[1] = Type_intptr_t;
 
           for (unsigned i = 2; i < count + 2; ++i) {
             switch (s.read1()) {
             case CONSTANT_Class:
             case CONSTANT_String:
-              types[i] = Type_object;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_object;
               s.skip(2);
               break;
 
             case CONSTANT_Integer:
             case CONSTANT_Float:
-              types[i] = Type_int32_t;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_int32_t;
               s.skip(4);
               break;
 
@@ -370,24 +371,24 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
             case CONSTANT_Fieldref:
             case CONSTANT_Methodref:
             case CONSTANT_InterfaceMethodref:
-              types[i] = Type_object;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_object;
               s.skip(4);
               break;
 
             case CONSTANT_Long:
-              types[i++] = Type_int64_t;
+              RUNTIME_ARRAY_BODY(types)[i++] = Type_int64_t;
-              types[i] = Type_int64_t_pad;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_int64_t_pad;
               s.skip(8);
               break;
 
             case CONSTANT_Double:
-              types[i++] = Type_double;
+              RUNTIME_ARRAY_BODY(types)[i++] = Type_double;
-              types[i] = Type_double_pad;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_double_pad;
               s.skip(8);
               break;
 
             case CONSTANT_Utf8:
-              types[i] = Type_object;
+              RUNTIME_ARRAY_BODY(types)[i] = Type_object;
               s.skip(s.read2());
               break;
 
@@ -407,7 +408,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
             map->targetFixedOffsets()[i * BytesPerWord]
               = i * TargetBytesPerWord;
 
-            init(new (map->fixedFields() + i) Field, types[i],
+            init(new (map->fixedFields() + i) Field, RUNTIME_ARRAY_BODY(types)[i],
                  i * BytesPerWord, BytesPerWord, i * TargetBytesPerWord,
                  TargetBytesPerWord);
           }
@@ -443,15 +444,15 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
           for (unsigned j = 0; j < map->fixedFieldCount; ++j) {
             Field* f = map->fixedFields() + j;
 
-            memberFields[memberIndex] = *f;
+            RUNTIME_ARRAY_BODY(memberFields)[memberIndex] = *f;
 
             targetMemberOffset = f->targetOffset + f->targetSize;
 
             ++ memberIndex;
           }
         } else {
-          init(new (&memberFields[0]) Field, Type_object, 0, BytesPerWord, 0,
+          init(new (RUNTIME_ARRAY_BODY(memberFields)) Field, Type_object, 0,
-               TargetBytesPerWord);
+               BytesPerWord, 0, TargetBytesPerWord);
 
           memberIndex = 1;
           buildMemberOffset = BytesPerWord;
@@ -462,14 +463,16 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
 
         THREAD_RUNTIME_ARRAY(t, Field, staticFields, count + StaticHeader);
         
-        init(new (&staticFields[0]) Field, Type_object, 0, BytesPerWord, 0,
+        init(new (RUNTIME_ARRAY_BODY(staticFields)) Field, Type_object, 0,
+             BytesPerWord, 0, TargetBytesPerWord);
+
+        init(new (RUNTIME_ARRAY_BODY(staticFields) + 1) Field, Type_intptr_t,
+             BytesPerWord, BytesPerWord, TargetBytesPerWord,
              TargetBytesPerWord);
 
-        init(new (&staticFields[1]) Field, Type_intptr_t, BytesPerWord,
+        init(new (RUNTIME_ARRAY_BODY(staticFields) + 2) Field, Type_object,
-             BytesPerWord, TargetBytesPerWord, TargetBytesPerWord);
+             BytesPerWord * 2, BytesPerWord, TargetBytesPerWord * 2,
-
+             TargetBytesPerWord);
-        init(new (&staticFields[2]) Field, Type_object, BytesPerWord * 2,
-             BytesPerWord, TargetBytesPerWord * 2, TargetBytesPerWord);
 
         unsigned staticIndex = StaticHeader;
         unsigned buildStaticOffset = BytesPerWord * StaticHeader;
@@ -518,8 +521,8 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
 
               buildStaticOffset = fieldOffset(t, field);
 
-              init(new (&staticFields[staticIndex]) Field, type,
+              init(new (RUNTIME_ARRAY_BODY(staticFields) + staticIndex) Field,
-                   buildStaticOffset, buildSize, targetStaticOffset,
+                   type, buildStaticOffset, buildSize, targetStaticOffset,
                    targetSize);
 
               targetStaticOffset += targetSize;
@@ -532,8 +535,8 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
 
               buildMemberOffset = fieldOffset(t, field);
 
-              init(new (&memberFields[memberIndex]) Field, type,
+              init(new (RUNTIME_ARRAY_BODY(memberFields) + memberIndex) Field,
-                   buildMemberOffset, buildSize, targetMemberOffset,
+                   type, buildMemberOffset, buildSize, targetMemberOffset,
                    targetSize);
 
               targetMemberOffset += targetSize;
@@ -555,7 +558,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
              ceilingDivide(targetMemberOffset, TargetBytesPerWord), memberIndex);
 
           for (unsigned i = 0; i < memberIndex; ++i) {
-            Field* f = &memberFields[i];
+            Field* f = RUNTIME_ARRAY_BODY(memberFields) + i;
 
             expect(t, f->buildOffset
                    < map->buildFixedSizeInWords * BytesPerWord);
@@ -579,7 +582,7 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code,
              TypeMap::SingletonKind);
 
           for (unsigned i = 0; i < staticIndex; ++i) {
-            Field* f = &staticFields[i];
+            Field* f = RUNTIME_ARRAY_BODY(staticFields) + i;
 
             expect(t, f->buildOffset
                    < map->buildFixedSizeInWords * BytesPerWord);
@@ -1342,8 +1345,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
 
       THREAD_RUNTIME_ARRAY(t, Field, fields, count);
 
-      init(new (&fields[0]) Field, Type_object, 0, BytesPerWord, 0,
+      init(new (RUNTIME_ARRAY_BODY(fields)) Field, Type_object, 0,
-           TargetBytesPerWord);
+           BytesPerWord, 0, TargetBytesPerWord);
 
       unsigned buildOffset = BytesPerWord;
       unsigned targetOffset = TargetBytesPerWord;
@@ -1420,8 +1423,8 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
             ++ targetOffset;
           }
 
-          init(new (&fields[j]) Field, type, buildOffset, buildSize,
+          init(new (RUNTIME_ARRAY_BODY(fields) + j) Field, type, buildOffset,
-               targetOffset, targetSize);
+               buildSize, targetOffset, targetSize);
 
           buildOffset += buildSize;
           targetOffset += targetSize;
@@ -1455,7 +1458,7 @@ writeBootImage2(Thread* t, OutputStream* bootimageOutput, OutputStream* codeOutp
          targetArrayElementSize, arrayElementType);
 
       for (unsigned j = 0; j < fixedFieldCount; ++j) {
-        Field* f = &fields[j];
+        Field* f = RUNTIME_ARRAY_BODY(fields) + j;
 
         expect(t, f->buildOffset
                < map->buildFixedSizeInWords * BytesPerWord);

src/tools/object-writer/elf.cpp

@@ -72,6 +72,7 @@
 namespace {
 
 using namespace avian::tools;
+using namespace avian::util;
 
 template<class AddrTy>
 struct ElfTypes {

src/tools/object-writer/mach-o.cpp

@@ -43,6 +43,7 @@
 namespace {
 
 using namespace avian::tools;
+using namespace avian::util;
 
 typedef int cpu_type_t;
 typedef int cpu_subtype_t;

src/tools/object-writer/pe.cpp

@@ -86,6 +86,7 @@ pad(unsigned n)
 }
 
 using namespace avian::tools;
+using namespace avian::util;
 
 template<unsigned BytesPerWord, PlatformInfo::Architecture Architecture>
 class WindowsPlatform : public Platform {

src/tools/object-writer/tools.cpp

@@ -15,14 +15,12 @@
 
 #include <avian/tools/object-writer/tools.h>
 
+using namespace avian::util;
+
 namespace avian {
 
 namespace tools {
 
-String::String(const char* text):
-  text(text),
-  length(strlen(text)) {}
-
 Buffer::Buffer():
   capacity(100),
   length(0),

src/tools/type-generator/io.h

@@ -0,0 +1,149 @@
+/* Copyright (c) 2008-2011, Avian Contributors
+
+   Permission to use, copy, modify, and/or distribute this software
+   for any purpose with or without fee is hereby granted, provided
+   that the above copyright notice and this permission notice appear
+   in all copies.
+
+   There is NO WARRANTY for this software.  See license.txt for
+   details. */
+   
+#include "assert.h"
+
+#ifndef AVIAN_TOOLS_TYPE_GENERATOR_IO_H
+#define AVIAN_TOOLS_TYPE_GENERATOR_IO_H
+
+namespace avian {
+namespace tools {
+namespace typegenerator {
+
+class Input {
+ public:
+  virtual ~Input() { }
+  
+  virtual void dispose() = 0;
+
+  virtual int peek() = 0;
+
+  virtual int read() = 0;
+
+  virtual unsigned line() = 0;
+
+  virtual unsigned column() = 0;
+
+  void skipSpace() {
+    bool quit = false;
+    while (not quit) {
+      int c = peek();
+      switch (c) {
+      case ' ': case '\t': case '\n':
+        read();
+        break;
+
+      default: quit = true;
+      }
+    }
+  }
+};
+
+class FileInput : public Input {
+ public:
+  const char* file;
+  FILE* stream;
+  unsigned line_;
+  unsigned column_;
+  bool close;
+
+  FileInput(const char* file, FILE* stream = 0, bool close = true):
+    file(file), stream(stream), line_(1), column_(1), close(close)
+  { }
+
+  virtual ~FileInput() {
+    dispose();
+  }
+
+  virtual void dispose() {
+    if (stream and close) {
+      fclose(stream);
+      stream = 0;
+    }
+  }
+
+  virtual int peek() {
+    int c = getc(stream);
+    ungetc(c, stream);
+    return c;
+  }
+
+  virtual int read() {
+    int c = getc(stream);
+    if (c == '\n') {
+      ++ line_;
+      column_ = 1;
+    } else {
+      ++ column_;
+    }
+    return c;
+  }
+
+  virtual unsigned line() {
+    return line_;
+  }
+
+  virtual unsigned column() {
+    return column_;
+  }
+};
+
+class Output {
+ public:
+  virtual ~Output() { }
+  
+  virtual void dispose() = 0;
+
+  virtual void write(const char* s) = 0;
+
+  void write(int i) {
+    static const int Size = 32;
+    char s[Size];
+    int c UNUSED = ::snprintf(s, Size, "%d", i);
+    assert(c > 0 and c < Size);
+    write(s);
+  }
+};
+
+class FileOutput : public Output {
+ public:
+  const char* file;
+  FILE* stream;
+  bool close;
+
+  FileOutput(const char* file, FILE* stream = 0, bool close = true):
+    file(file), stream(stream), close(close)
+  { }
+
+  virtual ~FileOutput() {
+    dispose();
+  }
+
+  virtual void dispose() {
+    if (stream and close) {
+      fclose(stream);
+      stream = 0;
+    }
+  }
+
+  virtual void write(const char* s) {
+    fputs(s, stream);
+  }
+
+  const char* filename() {
+    return file;
+  }
+};
+
+} // namespace typegenerator
+} // namespace tools
+} // namespace avian
+
+#endif // AVIAN_TOOLS_TYPE_GENERATOR_IO_H

src/tools/type-generator/main.cpp

@@ -16,7 +16,10 @@
 
 #include "constants.h"
 #include "finder.h"
-#include "stream.h"
+#include <avian/util/stream.h>
+
+#include "io.h"
+#include "sexpr.h"
 
 #include "assert.h"
 
@@ -29,6 +32,7 @@ inline void operator delete(void*) { abort(); }
 extern "C" void __cxa_pure_virtual(void) { abort(); }
 
 using namespace vm;
+using namespace avian::tools::typegenerator;
 
 namespace {
 
@@ -55,15 +59,6 @@ pad(unsigned n)
   return (extra ? n + BytesPerWord - extra : n);
 }
 
-template <class T>
-T*
-allocate()
-{
-  T* t = static_cast<T*>(malloc(sizeof(T)));
-  assert(t);
-  return t;
-}
-
 inline bool
 equal(const char* a, const char* b)
 {
@@ -88,214 +83,6 @@ take(unsigned n, const char* c)
   return r;
 }
 
-class Input {
- public:
-  virtual ~Input() { }
-  
-  virtual void dispose() = 0;
-
-  virtual int peek() = 0;
-
-  virtual int read() = 0;
-
-  virtual unsigned line() = 0;
-
-  virtual unsigned column() = 0;
-
-  void skipSpace() {
-    bool quit = false;
-    while (not quit) {
-      int c = peek();
-      switch (c) {
-      case ' ': case '\t': case '\n':
-        read();
-        break;
-
-      default: quit = true;
-      }
-    }
-  }
-};
-
-class FileInput : public Input {
- public:
-  const char* file;
-  FILE* stream;
-  unsigned line_;
-  unsigned column_;
-  bool close;
-
-  FileInput(const char* file, FILE* stream = 0, bool close = true):
-    file(file), stream(stream), line_(1), column_(1), close(close)
-  { }
-
-  virtual ~FileInput() {
-    dispose();
-  }
-
-  virtual void dispose() {
-    if (stream and close) {
-      fclose(stream);
-      stream = 0;
-    }
-  }
-
-  virtual int peek() {
-    int c = getc(stream);
-    ungetc(c, stream);
-    return c;
-  }
-
-  virtual int read() {
-    int c = getc(stream);
-    if (c == '\n') {
-      ++ line_;
-      column_ = 1;
-    } else {
-      ++ column_;
-    }
-    return c;
-  }
-
-  virtual unsigned line() {
-    return line_;
-  }
-
-  virtual unsigned column() {
-    return column_;
-  }
-};
-
-class Output {
- public:
-  virtual ~Output() { }
-  
-  virtual void dispose() = 0;
-
-  virtual void write(const char* s) = 0;
-
-  void write(int i) {
-    static const int Size = 32;
-    char s[Size];
-    int c UNUSED = ::snprintf(s, Size, "%d", i);
-    assert(c > 0 and c < Size);
-    write(s);
-  }
-};
-
-class FileOutput : public Output {
- public:
-  const char* file;
-  FILE* stream;
-  bool close;
-
-  FileOutput(const char* file, FILE* stream = 0, bool close = true):
-    file(file), stream(stream), close(close)
-  { }
-
-  virtual ~FileOutput() {
-    dispose();
-  }
-
-  virtual void dispose() {
-    if (stream and close) {
-      fclose(stream);
-      stream = 0;
-    }
-  }
-
-  virtual void write(const char* s) {
-    fputs(s, stream);
-  }
-
-  const char* filename() {
-    return file;
-  }
-};
-
-class Object {
- public:
-  typedef enum {
-    Scalar,
-    Array,
-    Method,
-    Type,
-    Pair,
-    Number,
-    Character,
-    String,
-    Eos
-  } ObjectType;
-
-  ObjectType type;
-};
-
-class Pair : public Object {
- public:
-  Object* car;
-  Object* cdr;
-
-  static Pair* make(Object* car, Object* cdr) {
-    Pair* o = allocate<Pair>();
-    o->type = Object::Pair;
-    o->car = car;
-    o->cdr = cdr;
-    return o;
-  }
-};
-
-Object*
-cons(Object* car, Object* cdr)
-{
-  return Pair::make(car, cdr);
-}
-
-Object*&
-car(Object* o)
-{
-  assert(o->type == Object::Pair);
-  return static_cast<Pair*>(o)->car;
-}
-
-void
-setCar(Object* o, Object* v)
-{
-  assert(o->type == Object::Pair);
-  static_cast<Pair*>(o)->car = v;
-}
-
-Object*&
-cdr(Object* o)
-{
-  assert(o->type == Object::Pair);
-  return static_cast<Pair*>(o)->cdr;
-}
-
-void
-setCdr(Object* o, Object* v)
-{
-  assert(o->type == Object::Pair);
-  static_cast<Pair*>(o)->cdr = v;
-}
-
-class List {
- public:
-  Object* first;
-  Object* last;
-
-  List(): first(0), last(0) { }
-
-  void append(Object* o) {
-    Object* p = cons(o, 0);
-    if (last) {
-      setCdr(last, p);
-      last = p;
-    } else {
-      first = last = p;
-    }
-  }
-};
-
 class Scalar : public Object {
  public:
   Object* owner;
@@ -2176,9 +1963,9 @@ main(int ac, char** av)
     fprintf(stderr, "unable to open %s: %s\n", av[2], strerror(errno));
     return -1;
   }
-  local::FileInput in(0, inStream, false);
+  FileInput in(0, inStream, false);
 
-  local::Object* declarations = local::parse(finder, &in);
+  Object* declarations = local::parse(finder, &in);
 
   finder->dispose();
   system->dispose();
@@ -2188,7 +1975,7 @@ main(int ac, char** av)
     fprintf(stderr, "unable to open %s: %s\n", av[3], strerror(errno));
     return -1;
   }
-  local::FileOutput out(0, outStream, false);
+  FileOutput out(0, outStream, false);
 
   if (local::equal(av[4], "enums")) {
     local::writeEnums(&out, declarations);

src/tools/type-generator/sexpr.h

@@ -0,0 +1,102 @@
+/* Copyright (c) 2008-2011, Avian Contributors
+
+   Permission to use, copy, modify, and/or distribute this software
+   for any purpose with or without fee is hereby granted, provided
+   that the above copyright notice and this permission notice appear
+   in all copies.
+
+   There is NO WARRANTY for this software.  See license.txt for
+   details. */
+   
+#ifndef AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
+#define AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H
+
+namespace avian {
+namespace tools {
+namespace typegenerator {
+
+template <class T>
+inline T* allocate() {
+  T* t = static_cast<T*>(malloc(sizeof(T)));
+  assert(t);
+  return t;
+}
+
+class Object {
+ public:
+  typedef enum {
+    Scalar,
+    Array,
+    Method,
+    Type,
+    Pair,
+    Number,
+    Character,
+    String,
+    Eos
+  } ObjectType;
+
+  ObjectType type;
+};
+
+class Pair : public Object {
+ public:
+  Object* car;
+  Object* cdr;
+
+  static Pair* make(Object* car, Object* cdr) {
+    Pair* o = allocate<Pair>();
+    o->type = Object::Pair;
+    o->car = car;
+    o->cdr = cdr;
+    return o;
+  }
+};
+
+inline Object* cons(Object* car, Object* cdr) {
+  return Pair::make(car, cdr);
+}
+
+inline Object*& car(Object* o) {
+  assert(o->type == Object::Pair);
+  return static_cast<Pair*>(o)->car;
+}
+
+inline void setCar(Object* o, Object* v) {
+  assert(o->type == Object::Pair);
+  static_cast<Pair*>(o)->car = v;
+}
+
+inline Object*& cdr(Object* o) {
+  assert(o->type == Object::Pair);
+  return static_cast<Pair*>(o)->cdr;
+}
+
+inline void setCdr(Object* o, Object* v) {
+  assert(o->type == Object::Pair);
+  static_cast<Pair*>(o)->cdr = v;
+}
+
+class List {
+ public:
+  Object* first;
+  Object* last;
+
+  List(): first(0), last(0) { }
+
+  void append(Object* o) {
+    Object* p = cons(o, 0);
+    if (last) {
+      setCdr(last, p);
+      last = p;
+    } else {
+      first = last = p;
+    }
+  }
+};
+
+} // namespace typegenerator
+} // namespace tools
+} // namespace avian
+
+#endif // AVIAN_TOOLS_TYPE_GENERATOR_SEXPR_H

src/vm/system/posix.cpp

@@ -49,7 +49,7 @@
 #include "dirent.h"
 #include "sched.h"
 #include "arch.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 
 #include <avian/util/math.h>
 

src/vm/system/windows.cpp

@@ -24,7 +24,7 @@
 #undef min
 
 #include "arch.h"
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include <avian/util/runtime-array.h>
 
 #if defined(WINAPI_FAMILY)
@@ -806,12 +806,12 @@ class MySystem: public System {
     Status status = 1;
     size_t nameLen = strlen(name) * 2;
     RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-    MultiByteToWideChar(CP_UTF8, 0, name, -1, wideName, nameLen + 1);
+    MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-    HANDLE file = CreateFileW(wideName, FILE_READ_DATA, FILE_SHARE_READ, 0,
+    HANDLE file = CreateFileW(RUNTIME_ARRAY_BODY(wideName), FILE_READ_DATA, FILE_SHARE_READ, 0,
     OPEN_EXISTING, 0, 0);
 #else
-    HANDLE file = CreateFile2(wideName, GENERIC_READ, FILE_SHARE_READ,
+    HANDLE file = CreateFile2(RUNTIME_ARRAY_BODY(wideName), GENERIC_READ, FILE_SHARE_READ,
                              OPEN_EXISTING, 0);
 #endif
     if (file != INVALID_HANDLE_VALUE) {
@@ -883,10 +883,10 @@ class MySystem: public System {
   virtual FileType stat(const char* name, unsigned* length) {
     size_t nameLen = strlen(name) * 2;
     RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-    MultiByteToWideChar(CP_UTF8, 0, name, -1, wideName, nameLen + 1);
+    MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
     WIN32_FILE_ATTRIBUTE_DATA data;
     if (GetFileAttributesExW
-        (wideName, GetFileExInfoStandard, &data))
+        (RUNTIME_ARRAY_BODY(wideName), GetFileExInfoStandard, &data))
     {
       if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
         return TypeDirectory;
@@ -935,12 +935,12 @@ class MySystem: public System {
     if (name) {
       size_t nameLen = nameLength * 2;
       RUNTIME_ARRAY(wchar_t, wideName, nameLen + 1);
-      MultiByteToWideChar(CP_UTF8, 0, name, -1, wideName, nameLen + 1);
+      MultiByteToWideChar(CP_UTF8, 0, name, -1, RUNTIME_ARRAY_BODY(wideName), nameLen + 1);
 
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-      handle = LoadLibraryW(wideName);
+      handle = LoadLibraryW(RUNTIME_ARRAY_BODY(wideName));
 #else
-      handle = LoadPackagedLibrary(wideName, 0);
+      handle = LoadPackagedLibrary(RUNTIME_ARRAY_BODY(wideName), 0);
 #endif
     } else {
 #if !defined(WINAPI_FAMILY) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

src/zone.h

@@ -11,7 +11,7 @@
 #ifndef ZONE_H
 #define ZONE_H
 
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "allocator.h"
 
 #include <avian/util/math.h>

unittest/codegen/assembler-test.cpp

@@ -12,7 +12,7 @@
 
 #include "common.h"
 #include <avian/vm/heap/heap.h>
-#include "system.h"
+#include <avian/vm/system/system.h>
 #include "target.h"
 
 #include <avian/vm/codegen/assembler.h>