Work in progres, please take a look and give early feedback if this is the way we want to structure…

src/vm/object.h

 // Copyright (c) 2014, the Fletch project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 #ifndef SRC_VM_OBJECT_H_
 #define SRC_VM_OBJECT_H_
 
 #include <math.h>
 #include <string.h>
 
@@ skipping 52 matching lines @@
   inline bool IsString();
   inline bool IsFunction();
   inline bool IsLargeInteger();
   inline bool IsByteArray();
   inline bool IsDouble();
   inline bool IsBoxed();
   inline bool IsInitializer();
   inline bool IsStack();
   inline bool IsCoroutine();
   inline bool IsPort();
-  inline bool IsForeign();
+  inline bool IsForeignFunction();
+  inline bool IsForeignMemory();
 
   // - based on marker field in class.
   inline bool IsNull();
   inline bool IsTrue();
   inline bool IsFalse();
 
   // - based on complex heap object field in class.
   inline bool IsComplexHeapObject();
 
   // - based on the flags field in class ComplexHeapObject.
@@ skipping 64 matching lines @@
 //   [MSB...11] Contains the non variable size of the instance.
 //   [10]       Whether the object is a ComplexHeapObject.
 //   [9-7]      The marker of the instance.
 //   [6]        Tells whether all pointers are in the non variable part.
 //   [5]        Tells whether the object has a variable part.
 //   [4-1]      The type of the instance.
 //   [LSB]      Smi tag.
 class InstanceFormat {
  public:
   enum Type {
-    CLASS_TYPE           = 0,
-    INSTANCE_TYPE        = 1,
-    STRING_TYPE          = 2,
-    ARRAY_TYPE           = 3,
-    FUNCTION_TYPE        = 4,
-    LARGE_INTEGER_TYPE   = 5,
-    BYTE_ARRAY_TYPE      = 6,
-    DOUBLE_TYPE          = 7,
-    BOXED_TYPE           = 8,
-    STACK_TYPE           = 9,
-    INITIALIZER_TYPE     = 10,
-    IMMEDIATE_TYPE       = 15  // No instances.
+    CLASS_TYPE              = 0,
+    INSTANCE_TYPE           = 1,
+    STRING_TYPE             = 2,
+    ARRAY_TYPE              = 3,
+    FUNCTION_TYPE           = 4,
+    LARGE_INTEGER_TYPE      = 5,
+    BYTE_ARRAY_TYPE         = 6,
+    DOUBLE_TYPE             = 7,
+    BOXED_TYPE              = 8,
+    STACK_TYPE              = 9,
+    INITIALIZER_TYPE        = 10,
+    IMMEDIATE_TYPE          = 15  // No instances.
   };
 
   enum Marker {
-    NULL_MARKER          = 0,
-    TRUE_MARKER          = 1,
-    FALSE_MARKER         = 2,
-    COROUTINE_MARKER     = 3,
-    PORT_MARKER          = 4,
-    FOREIGN_MARKER       = 5,
-    NO_MARKER            = 7  // Else marker.
+    NULL_MARKER             = 0,
+    TRUE_MARKER             = 1,
+    FALSE_MARKER            = 2,
+    COROUTINE_MARKER        = 3,
+    PORT_MARKER             = 4,
+    FOREIGNFUNCTION_MARKER  = 5,

[ricow1, 2015/07/02 16:01:57]

I know to little about our structure to know if we really need this?, but I did
not see a way to create the Instances programatically without the split (since
one has one instance variable, the other two)

+    FOREIGNMEMORY_MARKER    = 6,
+    NO_MARKER               = 7  // Else marker.
   };
 
   // Factory functions.
   inline static const InstanceFormat instance_format(int number_of_fields,
                                                      Marker marker = NO_MARKER);
   inline static const InstanceFormat class_format();
   inline static const InstanceFormat num_format();
   inline static const InstanceFormat smi_format();
   inline static const InstanceFormat string_format();
   inline static const InstanceFormat array_format();
@@ skipping 990 matching lines @@
   HeapObject* h = HeapObject::cast(this);
   return h->format().marker() == InstanceFormat::COROUTINE_MARKER;
 }
 
 bool Object::IsPort() {
   if (IsSmi()) return false;
   HeapObject* h = HeapObject::cast(this);
   return h->format().marker() == InstanceFormat::PORT_MARKER;
 }
 
-bool Object::IsForeign() {
+bool Object::IsForeignFunction() {
   if (IsSmi()) return false;
   HeapObject* h = HeapObject::cast(this);
-  return h->format().marker() == InstanceFormat::FOREIGN_MARKER;
+  return h->format().marker() == InstanceFormat::FOREIGNFUNCTION_MARKER;
 }
 
+bool Object::IsForeignMemory() {
+  if (IsSmi()) return false;
+  HeapObject* h = HeapObject::cast(this);
+  return h->format().marker() == InstanceFormat::FOREIGNMEMORY_MARKER;
+}
+
+
 bool Object::IsNull() {
   if (IsSmi()) return false;
   HeapObject* h = HeapObject::cast(this);
   return h->format().marker() == InstanceFormat::NULL_MARKER;
 }
 
 bool Object::IsTrue() {
   if (IsSmi()) return false;
   HeapObject* h = HeapObject::cast(this);
   return h->format().marker() == InstanceFormat::TRUE_MARKER;
@@ skipping 614 matching lines @@
 }
 
 inline void Coroutine::set_caller(Coroutine* value) {
   at_put(kCallerOffset, value);
 }
 
 }  // namespace fletch
 
 
 #endif  // SRC_VM_OBJECT_H_