Ecere Software / sdk / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
compiler/bootstrap: Reverted to using 'uintptr' for bootstrap; Hardcoding FileListing...
[sdk] / ecere / src / com / instance.ec
diff --git a/ecere/src/com/instance.ec b/ecere/src/com/instance.ec
index 3359777..2f1dca8 100644 (file)
--- a/ecere/src/com/instance.ec
+++ b/ecere/src/com/instance.ec
@@ -561,8 +561,8 @@ public:
    char * name;
    ClassProperty parent, left, right;
    int depth;
-   void (*Set)(Class, int);
-   int (*Get)(Class);
+   void (*Set)(Class, int64);
+   int64 (*Get)(Class);
    char * dataTypeString;
    Type dataType;
    bool constant;
@@ -1089,7 +1089,7 @@ static uint NextFibonacci(uint number)
 static uint log1_5i(uint number)
 {
    uint pos;
-   uint64 current = 4;
+   uint64 current = sizeof(void *);
    
    for(pos=0; pos < NUM_POOLS; pos++)
    {
@@ -1104,7 +1104,7 @@ static uint log1_5i(uint number)
 static uint pow1_5(uint number)
 {
    uint pos;
-   uint64 current = 4;
+   uint64 current = sizeof(void *);
    for(pos=0; pos < number; pos++)
    {
       current = current * 3 / 2;
@@ -1116,7 +1116,7 @@ static uint pow1_5(uint number)
 static uint pow1_5i(uint number)
 {
    uint pos;
-   uint64 current = 4;
+   uint64 current = sizeof(void *);
    
    for(pos=0; pos < NUM_POOLS; pos++)
    {
@@ -1155,8 +1155,8 @@ static void InitMemory()
       int expansion;
       
       pools[c].blockSize = NTH_SIZE(c);
-      if(pools[c].blockSize % 4)
-         pools[c].blockSize += 4 - (pools[c].blockSize % 4);
+      if(pools[c].blockSize % sizeof(void *))
+         pools[c].blockSize += sizeof(void *) - (pools[c].blockSize % sizeof(void *));
       pools[c].blockSpace = pools[c].blockSize;
       pools[c].blockSpace += sizeof(class MemBlock);      
       // pools[c].Expand(initNumBlocks[c]);
@@ -1242,8 +1242,8 @@ static void * _myrealloc(void * pointer, unsigned int size)
       {
          // if((1 << pool) >= size && (pool - SIZE_POSITION(size)) <= 1)
          uint ns = NEXT_SIZE(size);
-         uint mod = ns % 4;
-         if(mod) ns += 4-mod;
+         uint mod = ns % sizeof(void *);
+         if(mod) ns += sizeof(void *)-mod;
          if(ns == pool->blockSize)
          {
             newPointer = pointer;
@@ -1290,8 +1290,8 @@ static void * _mycrealloc(void * pointer, unsigned int size)
       {
          // if((1 << pool) >= size && (pool - SIZE_POSITION(size)) <= 1)
          uint ns = NEXT_SIZE(size);
-         uint mod = ns % 4;
-         if(mod) ns += 4-mod;
+         uint mod = ns % sizeof(void *);
+         if(mod) ns += sizeof(void *)-mod;
          if(ns == pool->blockSize)
          {
             int extra = size - block.size;
@@ -1387,7 +1387,7 @@ static void * _malloc(unsigned int size)
       if(!recurse && !stack.recurse)
       {
          stack.recurse = true;
-         block = MemInfo { size = size, key = (uint)((byte *)pointer + REDZONE), id = blockID++ };
+         block = MemInfo { size = size, key = (uintptr)((byte *)pointer + REDZONE), id = blockID++ };
          memcpy(block.allocLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
          memBlocks.Add(block);
          stack.recurse = false;
@@ -1443,7 +1443,7 @@ static void * _calloc(int n, unsigned int size)
       MemInfo block;
       
       stack.recurse = true;
-      block = MemInfo { size = size, key = (uint)((byte *)pointer + REDZONE), _class = allocateClass, internal = allocateInternal, id = blockID++ };
+      block = MemInfo { size = size, key = (uintptr)((byte *)pointer + REDZONE), _class = allocateClass, internal = allocateInternal, id = blockID++ };
       memcpy(block.allocLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
       memBlocks.Add(block);
       stack.recurse = false;
@@ -1483,7 +1483,7 @@ static void * _realloc(void * pointer, unsigned int size)
 
    if(!recurse && !stack.recurse && pointer)
    {
-      block = (MemInfo)memBlocks.Find((uint)pointer);
+      block = (MemInfo)memBlocks.Find((uintptr)pointer);
       if(!block)
       {
          printf("Reallocating Bad Memory\n");
@@ -1534,7 +1534,7 @@ static void * _realloc(void * pointer, unsigned int size)
    {
       MemInfo block;
       stack.recurse = true;
-      block = MemInfo { size = size, key = (uint)((byte *)pointer + REDZONE), id = blockID++ };
+      block = MemInfo { size = size, key = (uintptr)((byte *)pointer + REDZONE), id = blockID++ };
       memcpy(block.allocLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
       memBlocks.Add(block);
       stack.recurse = false;
@@ -1571,7 +1571,7 @@ static void * _crealloc(void * pointer, unsigned int size)
 
    if(!recurse && !stack.recurse && pointer)
    {
-      block = (MemInfo)memBlocks.Find((uint)pointer);
+      block = (MemInfo)memBlocks.Find((uintptr)pointer);
       if(!block)
       {
          printf("Reallocating Bad Memory\n");
@@ -1622,7 +1622,7 @@ static void * _crealloc(void * pointer, unsigned int size)
    {
       MemInfo block;
       stack.recurse = true;
-      block = MemInfo { size = size, key = (uint)((byte *)pointer + REDZONE), id = blockID++ };
+      block = MemInfo { size = size, key = (uintptr)((byte *)pointer + REDZONE), id = blockID++ };
       memcpy(block.allocLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
       memBlocks.Add(block);
       stack.recurse = false;
@@ -1662,7 +1662,7 @@ static void _free(void * pointer)
       {
          MemInfo block;
          stack.recurse = true;
-         block = (MemInfo)memBlocks.Find((uint)pointer);
+         block = (MemInfo)memBlocks.Find((uintptr)pointer);
          if(!block)
          {
             int c;
@@ -2158,6 +2158,7 @@ public dllexport Class eSystem_RegisterClass(ClassType type, char * name, char *
 {
    int start = 0, c;
    NameSpace * nameSpace = null;
+   bool force64Bits = (module.application.isGUIApp & 2) ? true : false;
 
    {
       nameSpace = (declMode == publicAccess) ? &module.publicNameSpace : &module.privateNameSpace;
@@ -2552,7 +2553,24 @@ public dllexport Class eSystem_RegisterClass(ClassType type, char * name, char *
          }
          _class.memberID = _class.startMemberID = (base && (type == normalClass || type == noHeadClass || type == structClass)) ? base.memberID : 0;
          if(type == normalClass || type == noHeadClass)
-            _class.offset = (base && base.structSize && base.type != systemClass) ? base.structSize : ((type == noHeadClass) ? 0 : sizeof(class Instance));
+            _class.offset = (base && base.structSize && base.type != systemClass) ? base.structSize : ((type == noHeadClass) ? 0 : (force64Bits ? 24 : sizeof(class Instance)));
+         if(force64Bits)
+         {
+            // For 64 bit cross-compiling from 32 bit library:
+                 if(!strcmp(name, "ecere::com::Class"))           size = 0; // 616
+            else if(!strcmp(name, "ecere::com::ClassProperty"))   size = 0; // 80
+            else if(!strcmp(name, "ecere::sys::BufferedFile"))    size = 0;
+            else if(!strcmp(name, "ecere::sys::BTNode"))          size = 0;
+            else if(!strcmp(name, "ecere::sys::StringBTNode"))    size = 0;
+            else if(!strcmp(name, "ecere::sys::OldList"))         size = 0; // 32
+            else if(!strcmp(name, "ecere::sys::Item"))            size = 0;
+            else if(!strcmp(name, "ecere::sys::NamedLink"))       size = 0;
+            else if(!strcmp(name, "ecere::sys::OldLink"))         size = 0;
+            else if(!strcmp(name, "ecere::sys::NamedItem"))       size = 0;
+            else if(!strcmp(name, "ecere::sys::NamedItem64"))     size = 0;
+            else if(!strcmp(name, "ecere::sys::BinaryTree"))      size = 0;
+            else if(!strcmp(name, "ecere::sys::FileListing"))     size = 3*8;
+         }
          if(type == structClass)
          {
             _class.memberOffset = (base && base.structSize && base.type != systemClass) ? base.structSize : 0;
@@ -2877,7 +2895,7 @@ public dllexport void eClass_Unregister(Class _class)
 static BTNamedLink ScanNameSpace(NameSpace nameSpace, char * name, void * listOffset)
 {
    BinaryTree * tree = (BinaryTree *)((byte *)nameSpace + (uint)listOffset);
-   BTNamedLink link = (BTNamedLink)tree->Find((uint)name);
+   BTNamedLink link = (BTNamedLink)tree->Find((uintptr)name);
    NameSpace * child;
    if(!link)
    {
@@ -4086,7 +4104,7 @@ public dllexport Property eClass_AddProperty(Class _class, char * name, char * d
 static void SetDelayedCPValues(Class _class, ClassProperty _property)
 {
    OldLink deriv;
-   NamedLink value, next;
+   NamedLink64 value, next;
 
    for(value = _class.delayedCPValues.first; value; value = next)
    {
@@ -4094,7 +4112,7 @@ static void SetDelayedCPValues(Class _class, ClassProperty _property)
       if(!strcmp(value.name, _property.name))
       {
          // eClass_SetProperty(_class, _property.name, value.data);
-         _property.Set(_class, (int)value.data);
+         _property.Set(_class, value.data);
          _class.delayedCPValues.Delete(value);
       }
    }
@@ -4163,28 +4181,28 @@ public dllexport ClassProperty eClass_FindClassProperty(Class _class, char * nam
    return _property;
 }
 
-public dllexport int eClass_GetProperty(Class _class, char * name)
+public dllexport int64 eClass_GetProperty(Class _class, char * name)
 {
    ClassProperty _property = eClass_FindClassProperty(_class, name);
    if(_property && _property.Get && _property.Get != (void *)1)
    {
-      int result = _property.Get(_class);
+      int64 result = _property.Get(_class);
       return result;
    }
    return 0;
 }
 
-public dllexport void eClass_SetProperty(Class _class, char * name, int value)
+public dllexport void eClass_SetProperty(Class _class, char * name, int64 value)
 {
    ClassProperty _property = eClass_FindClassProperty(_class, name);
    if(_property)
    {
       if(_property.Set)
-         _property.Set(_class, value);
+         ((void(*)(void *, int64))_property.Set)(_class, value);
    }
    else
    {
-      _class.delayedCPValues.Add(NamedLink { name = name, (void *)value });
+      _class.delayedCPValues.Add(NamedLink64 { name = name, value });
    }
 }
 
@@ -5813,6 +5831,8 @@ public bool LocateModule(char * name, char * fileName)
 
 static void LoadCOM(Module module)
 {
+   bool force64Bits = (module.application.isGUIApp & 2) ? true : false;
+   int pointerSize = force64Bits ? 8 : sizeof(void *);
    Class applicationClass;
    Class enumClass, structClass, boolClass;
    Class moduleClass;
@@ -5836,16 +5856,15 @@ static void LoadCOM(Module module)
       instanceClass.memberID = -3;
       instanceClass.startMemberID = -3;
 
-      // eClass_AddDataMember(instanceClass, "_vTbl", "void **", sizeof(int (**)()), 4, publicAccess);
-      eClass_AddDataMember(instanceClass, "_vTbl", "int (**)()", sizeof(int (**)()), 4, publicAccess);
-      eClass_AddDataMember(instanceClass, "_class", "ecere::com::Class", sizeof(Class), 4, publicAccess);
-      eClass_AddDataMember(instanceClass, "_refCount", "int", sizeof(int (**)()), 4, publicAccess);
+      eClass_AddDataMember(instanceClass, "_vTbl", "int (**)()", pointerSize, pointerSize, publicAccess);
+      eClass_AddDataMember(instanceClass, "_class", "ecere::com::Class", pointerSize, pointerSize, publicAccess);
+      eClass_AddDataMember(instanceClass, "_refCount", "int", sizeof(int), sizeof(int), publicAccess);
    }
 
    InitializeDataTypes1(module);
 
    // Create Enum class
-   enumClass = eSystem_RegisterClass(normalClass, "enum", null, 0, sizeof(class EnumClassData), null, null, module, baseSystemAccess, publicAccess);
+   enumClass = eSystem_RegisterClass(normalClass, "enum", null, 0, force64Bits ? 32 : sizeof(class EnumClassData), null, null, module, baseSystemAccess, publicAccess);
    eClass_AddClassProperty(enumClass, "enumSize", "int", null, GetEnumSize).constant = true;
    enumClass.type = systemClass;
    
@@ -5872,38 +5891,39 @@ static void LoadCOM(Module module)
    eEnum_AddFixedValue(boolClass, "false", bool::false);
 
    // Create Module class
-   moduleClass = eSystem_RegisterClass(normalClass, "ecere::com::Module", null, sizeof(struct Module), 0, (void *)Module_Constructor, (void *)Module_Destructor, module, baseSystemAccess, publicAccess);
+   moduleClass = eSystem_RegisterClass(normalClass, "ecere::com::Module", null, force64Bits ? 8 + 8 + 32 + 32 + 32 + 32 + 8 + 8 + 8 + 8 + 8 + 8 + (32 + 8 + 8 + 4*32) + (32 + 8 + 8 + 4*32)
+                                                                                           : sizeof(struct Module), 0, (void *)Module_Constructor, (void *)Module_Destructor, module, baseSystemAccess, publicAccess);
    eClass_AddVirtualMethod(moduleClass, "OnLoad", "bool()", null, publicAccess);
    eClass_AddVirtualMethod(moduleClass, "OnUnload", "void()", null, publicAccess);
    eClass_AddMethod(moduleClass, "Load", "Module(char * name, AccessMode importAccess)", eModule_Load, publicAccess);
    eClass_AddMethod(moduleClass, "Unload", "void(Module module)", eModule_Unload, publicAccess);
-   eClass_AddDataMember(moduleClass, "application", "Application", sizeof(Application), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "classes", "OldList", sizeof(OldList), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "defines", "OldList", sizeof(OldList), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "functions", "OldList", sizeof(OldList), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "modules", "OldList", sizeof(OldList), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "prev", "Module", sizeof(Module), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "next", "Module", sizeof(Module), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "name", "char *", sizeof(char *), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "library", "void *", sizeof(void *), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "Unload", "void *", sizeof(void *), 4, publicAccess);
+   eClass_AddDataMember(moduleClass, "application", "Application", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "classes", "OldList", force64Bits ? 32 : sizeof(OldList), pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "defines", "OldList", force64Bits ? 32 : sizeof(OldList), pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "functions", "OldList", force64Bits ? 32 : sizeof(OldList), pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "modules", "OldList", force64Bits ? 32 : sizeof(OldList), pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "prev", "Module", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "next", "Module", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "name", "char *", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "library", "void *", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "Unload", "void *", pointerSize, pointerSize, publicAccess);
    eClass_AddDataMember(moduleClass, "importType", "ImportType", sizeof(ImportType), 4, publicAccess);
    eClass_AddDataMember(moduleClass, "origImportType", "ImportType", sizeof(ImportType), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "privateNameSpace", "NameSpace", sizeof(NameSpace), 4, publicAccess);
-   eClass_AddDataMember(moduleClass, "publicNameSpace", "NameSpace", sizeof(NameSpace), 4, publicAccess);
+   eClass_AddDataMember(moduleClass, "privateNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4*32) : sizeof(NameSpace), pointerSize, publicAccess);
+   eClass_AddDataMember(moduleClass, "publicNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4*32) : sizeof(NameSpace), pointerSize, publicAccess);
    moduleClass.fixed = true;
    moduleClass.count++;
    
    // Create Application class
-   applicationClass = eSystem_RegisterClass(normalClass, "ecere::com::Application", "Module", sizeof(struct Application), 0, null, (void *)Application_Destructor, module, baseSystemAccess, publicAccess);
+   applicationClass = eSystem_RegisterClass(normalClass, "ecere::com::Application", "Module", force64Bits ? (8+8+8+8 + 32 + 8 + 176) : sizeof(struct Application), 0, null, (void *)Application_Destructor, module, baseSystemAccess, publicAccess);
    eClass_AddVirtualMethod(applicationClass, "Main", "void()", null, publicAccess);
    eClass_AddDataMember(applicationClass, "argc", "int", sizeof(int), 4, publicAccess);
-   eClass_AddDataMember(applicationClass, "argv", "char **", sizeof(char **), 4, publicAccess);
+   eClass_AddDataMember(applicationClass, "argv", "char **", pointerSize, pointerSize, publicAccess);
    eClass_AddDataMember(applicationClass, "exitCode", "int", sizeof(int), 4, publicAccess);
    eClass_AddDataMember(applicationClass, "isGUIApp", "bool", sizeof(bool), 4, publicAccess);
-   eClass_AddDataMember(applicationClass, "allModules", "OldList", sizeof(OldList), 4, publicAccess);
-   eClass_AddDataMember(applicationClass, "parsedCommand", "char *", sizeof(char *), 4, publicAccess);
-   eClass_AddDataMember(applicationClass, "systemNameSpace", "NameSpace", sizeof(NameSpace), 4, publicAccess);
+   eClass_AddDataMember(applicationClass, "allModules", "OldList", force64Bits ? 32: sizeof(OldList), pointerSize, publicAccess);
+   eClass_AddDataMember(applicationClass, "parsedCommand", "char *", pointerSize, pointerSize, publicAccess);
+   eClass_AddDataMember(applicationClass, "systemNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4*32) : sizeof(NameSpace), pointerSize, publicAccess);
    applicationClass.fixed = true;
    applicationClass.count++;
 
The Ecere SDK