#ifdef MEMINFO
import "Thread"
static define MAX_MEMORY_LOC = 40;
+static define MAX_STACK_FRAMES = 1000;
static class MemStack : BTNode
{
- const char * frames[1000];
+ const char * frames[MAX_STACK_FRAMES];
int pos;
bool recurse;
};
public class Angle : double;
-public class unichar : uint32
+public class ::unichar : uint32
{
const char * OnGetString(char * tempString, void * fieldData, bool * needClass)
};
+// Forward declarations to hook on to libec:
+class ::Type;
+class ::Instantiation;
+class ::ClassDefinition;
+
public class Property : struct
{
public:
stack.key = GetCurrentThreadID();
memStacks.Add(stack);
}
- if(stack.pos < 1000)
+ if(stack.pos < MAX_STACK_FRAMES)
stack.frames[stack.pos++] = loc;
- else
- printf("");
memMutex.Release();
#endif
}
{
stack.pos--;
}
- else
- printf("");
memMutex.Release();
#endif
}
{
class_fixed
SelfWatcher prev, next;
- void (*callback)(Instance);
+ void (*callback)(void *);
Property _property;
};
Class prev, next;
const char * name;
int offset, structSize;
- int (** _vTbl)();
+ void ** _vTbl;
int vTblSize;
- int (*Constructor)(Instance);
- void (*Destructor)(Instance);
+ bool (*Constructor)(void *);
+ void (*Destructor)(void *);
int offsetClass, sizeClass;
Class base;
bool internalDecl;
void * data;
bool computeSize;
- int structAlignment;
+ short structAlignment; short pointerAlignment;
int destructionWatchOffset;
bool fixed;
OldList delayedCPValues;
OldList members;
BinaryTree membersAlpha;
int memberOffset;
- int structAlignment;
+ short structAlignment; short pointerAlignment;
};
public class BitMember : struct
public:
class_fixed
OldList values;
- int largest;
+ int64 largest;
};
class Watcher : struct
{
class_fixed
Watcher prev, next;
- void (*callback)(Instance, Instance);
+ void (*callback)(void *, void *);
Instance object;
};
bool freed;
const char * _class;
uint id;
- const char * allocLoc[MAX_MEMORY_LOC];
- const char * freeLoc[MAX_MEMORY_LOC];
+ char * allocLoc[MAX_MEMORY_LOC];
+ char * freeLoc[MAX_MEMORY_LOC];
bool internal;
void OutputStacks(bool showFree)
bool recurse = false;
static int blockID;
//Class allocateClass;
-const char * allocateClass;
+char * allocateClass;
bool allocateInternal;
#endif
static uint TOTAL_MEM = 0;
+#ifndef MEMINFO
static uint OUTSIDE_MEM = 0;
+#endif
#if !defined(ECERE_BOOTSTRAP)
static Mutex memMutex { };
}
};
+#ifndef MEMINFO
static BlockPool * pools; //[NUM_POOLS];
/*static uint PosFibonacci(uint number)
}
}
*/
+
static uint log1_5i(uint number)
{
uint pos;
}
return (uint)current;
}
+#endif
// -- Math Helpers ---
public uint log2i(uint number)
return 1<<log2i(number);
}
+#ifndef MEMINFO
static bool memoryInitialized = false;
static void InitMemory()
{
pools[c].Expand(Max(1, expansion));
}
}
+#endif
+#ifndef MEMINFO
static void * _mymalloc(unsigned int size)
{
MemBlock block = null;
return pointer;
}
+
static void _myfree(void * pointer)
{
if(pointer)
}
return newPointer;
}
+#endif
#ifndef MEMINFO
#undef realloc
}
}
- while(block = (MemInfo)memBlocks.root)
+ while((block = (MemInfo)memBlocks.root))
{
byte * address;
int c;
printf("Memory Check Completed.\n");
#if defined(__WIN32__) && !defined(ECERE_BOOTSTRAP)
if(memoryErrorsCount)
- getch();
+ system("pause");
#endif
#endif
}
if(type == normalClass || type == noHeadClass)
_class.offset = (base && (base.templateClass ? base.templateClass.structSize : base.structSize) && base.type != systemClass) ? (base.templateClass ? base.templateClass.structSize : base.structSize) : ((type == noHeadClass) ? 0 : sizeof(class Instance));
+ else
+ _class.offset = 0; // Force set to 0
if(type == structClass)
{
}
public dllexport Class eSystem_RegisterClass(ClassType type, const char * name, const char * baseName, int size, int sizeClass,
- bool (* Constructor)(void *),void (* Destructor)(void *),
+ bool (* Constructor)(void *), void (* Destructor)(void *),
Module module, AccessMode declMode, AccessMode inheritanceAccess)
{
int start = 0, c;
_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 : ((force64Bits && inCompiler && fixed) ? 24 : (force32Bits && inCompiler && fixed) ? 12 : sizeof(class Instance)));
+ else
+ _class.offset = 0; // Force set to 0 for redefinitions
// For cross-bitness-compiling
if(crossBits)
{
size = 3*(force32Bits ? 4 : 8);
_class.structAlignment = force32Bits ? 4 : 8; // FileListing is problematic because it is a struct with private data that the user allocates
+ _class.pointerAlignment = 1;
}
// These we want to recompute inside the IDE to help the debugger
else if(!strcmp(name, "ecere::com::Class")) size = 0; // 616
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::NamedLink64")) 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;
}
_class.offsetClass = offsetClass;
_class.sizeClass = totalSizeClass;
- _class.Constructor = (void *)Constructor;
+ _class.Constructor = Constructor;
_class.Destructor = Destructor;
if(_class.type != systemClass)
_class.type = type;
}
}
-static void FreeEnumValue(NamedLink value)
+static void FreeEnumValue(NamedLink64 value)
{
delete value.name;
}
for(deriv = _class.derivatives.first; deriv; deriv = deriv.next)
FixOffsets(deriv.data);
}
-
+ // F000F000 will mean a pointer size alignment
public dllexport DataMember eClass_AddDataMember(Class _class, const char * name, const char * type, unsigned int size, unsigned int alignment, AccessMode declMode)
{
if(_class && name)
if(alignment)
{
+ bool pointerAlignment = alignment == 0xF000F000;
+
+ if(pointerAlignment) alignment = sizeof(void *);
+
+ if(pointerAlignment && _class.structAlignment <= 4)
+ _class.pointerAlignment = 1;
+ else if(!pointerAlignment && alignment >= 8)
+ _class.pointerAlignment = 0;
+
_class.structAlignment = Max(_class.structAlignment, alignment);
if(_class.memberOffset % alignment)
}
return null;
}
-
+ // F000F000 will mean a pointer size alignment
public dllexport DataMember eMember_AddDataMember(DataMember member, const char * name, const char * type, unsigned int size, unsigned int alignment, AccessMode declMode)
{
if(name && !member.membersAlpha.FindString(name))
if(alignment)
{
+ bool pointerAlignment = alignment == 0xF000F000;
+ if(pointerAlignment) alignment = sizeof(void *);
+
+ if(pointerAlignment && member.structAlignment <= 4)
+ member.pointerAlignment = 1;
+ else if(!pointerAlignment && alignment >= 8)
+ member.pointerAlignment = 0;
+
member.structAlignment = Max(member.structAlignment, alignment);
if(member.memberOffset % alignment)
else
addTo.memberID += dataMember.memberID;
+ if(dataMember.pointerAlignment && dataMember.structAlignment <= 4)
+ addTo.pointerAlignment = 1;
+ else if(!dataMember.pointerAlignment && dataMember.structAlignment >= 8)
+ addTo.pointerAlignment = 0;
+
addTo.structAlignment = Max(addTo.structAlignment, dataMember.structAlignment);
+
dataMember.offset = (addTo.type == unionMember) ? 0 : addTo.memberOffset;
if(dataMember.structAlignment)
{
- addTo.structAlignment = Max(addTo.structAlignment, dataMember.structAlignment);
-
if(addTo.memberOffset % dataMember.structAlignment)
addTo.memberOffset += dataMember.structAlignment - (addTo.memberOffset % dataMember.structAlignment);
}
//dataMember.id = _class.memberID++;
dataMember.id = _class.memberID;
+ if(dataMember.pointerAlignment && dataMember.structAlignment <= 4)
+ _class.pointerAlignment = 1;
+ else if(!dataMember.pointerAlignment && dataMember.structAlignment >= 8)
+ _class.pointerAlignment = 0;
+
_class.structAlignment = Max(_class.structAlignment, dataMember.structAlignment);
if(dataMember.type == unionMember)
_class.memberID += 1;
if(dataMember.structAlignment)
{
- _class.structAlignment = Max(_class.structAlignment, dataMember.structAlignment);
-
if(_class.memberOffset % dataMember.structAlignment)
_class.memberOffset += dataMember.structAlignment - (_class.memberOffset % dataMember.structAlignment);
}
{
name = !strcmp(module.name, "ecereCOM") ? "ecere" : "ecereCOM";
if((!Load && !strcmp(module.name, "ecereCOM")) ||
- (Load && (!__thisModule || !__thisModule.name || !strcmp(__thisModule.name, "ecereCOM")) && Load != COM_LOAD_FUNCTION))
+ (Load && (!__thisModule || !__thisModule.name || !strcmp(__thisModule.name, "ecereCOM")) && Load != (void *)COM_LOAD_FUNCTION))
{
Module module;
for(module = fromModule.application.allModules.first; module; module = module.next)
}
}
-public dllexport void eEnum_AddFixedValue(Class _class, const char * string, int value)
+public dllexport void eEnum_AddFixedValue(Class _class, const char * string, int64 value)
{
if(_class && _class.type == enumClass)
{
EnumClassData data = (EnumClassData)_class.data;
- NamedLink item;
+ NamedLink64 item;
for(item = data.values.first; item; item = item.next)
if(!strcmp(item.name, string))
break;
if(!item)
{
- data.values.Add(NamedLink { data = (void *)value, name = CopyString(string) });
+ data.values.Add(NamedLink64 { data = value, name = CopyString(string) });
if(value > data.largest)
data.largest = value;
}
}
}
-public dllexport int eEnum_AddValue(Class _class, const char * string)
+public dllexport int64 eEnum_AddValue(Class _class, const char * string)
{
if(_class && _class.type == enumClass)
{
EnumClassData data = (EnumClassData)_class.data;
- int value = ((int) data.largest) + 1;
- NamedLink item;
+ int64 value = data.largest + 1;
+ NamedLink64 item;
for(item = data.values.first; item; item = item.next)
if(!strcmp(item.name, string))
break;
if(!item)
{
- data.values.Add(NamedLink { data = (void *)value, name = CopyString(string) });
+ data.values.Add(NamedLink64 { data = value, name = CopyString(string) });
if(value > data.largest)
data.largest = value;
return value;
{
if(app.parsedCommand)
{
- delete app.argv;
+ delete (void *)app.argv;
delete app.parsedCommand;
}
}
}
}
-public dllexport void eInstance_WatchDestruction(Instance instance, Instance object, void (*callback)(Instance, Instance))
+public dllexport void eInstance_WatchDestruction(Instance instance, Instance object, void (*callback)(void *, void *))
{
OldList * watchers = (OldList *)((byte *)instance + instance._class.destructionWatchOffset);
watchers->Add(Watcher { callback = callback, object = object });
return Instance_LocateModule(name, fileName);
}
+/*
+#if (defined(__WORDSIZE) && __WORDSIZE == 8) || defined(__x86_64__)
+#define _64BIT 1
+#else
+#define _64BIT 0
+#endif
+
+#define arch_PointerSize sizeof(void *)
+#define structSize_Instance (_64BIT ? 24 : 12)
+#define structSize_Module (_64BIT ? 560 : 300)
+#define structSize_BinaryTree (_64BIT ? 32 : 16)
+#define structSize_OldList (_64BIT ? 32 : 20)
+#define structSize_NamedLink64 (_64BIT ? 32 : 24)
+#define structSize_ClassTemplateArgument (_64BIT ? 16 : 8)
+#define structSize_ClassTemplateParameter (_64BIT ? 64 : 40)
+#define structSize_OldLink (_64BIT ? 24 : 12)
+#define structSize_BTNamedLink (_64BIT ? 48 : 24)
+#define structSize_Application (_64BIT ? 800 : 428)
+#define structSize_Watcher (_64BIT ? 32 : 16)
+#define structSize_SelfWatcher (_64BIT ? 32 : 16)
+#define structSize_GlobalFunction (_64BIT ? 72 : 36)
+#define structSize_DefinedExpression (_64BIT ? 40 : 20)
+#define structSize_BitMember (_64BIT ? 96 : 64)
+#define structSize_DataMember (_64BIT ? 160 : 96)
+#define structSize_ClassProperty (_64BIT ? 80 : 40)
+#define structSize_Method (_64BIT ? 96 : 52)
+#define structSize_Property (_64BIT ? 152 : 88)
+#define structSize_Class (_64BIT ? 624 : 376)
+*/
+
static void LoadCOM(Module module)
{
bool force64Bits = (module.application.isGUIApp & 2) ? true : false;
instanceClass.memberID = -3;
instanceClass.startMemberID = -3;
- eClass_AddDataMember(instanceClass, "_vTbl", "int (**)()", pointerSize, pointerSize, publicAccess);
+ eClass_AddDataMember(instanceClass, "_vTbl", "void **", pointerSize, pointerSize, publicAccess);
eClass_AddDataMember(instanceClass, "_class", "ecere::com::Class", pointerSize, pointerSize, publicAccess);
eClass_AddDataMember(instanceClass, "_refCount", "int", sizeof(int), sizeof(int), publicAccess);
}
eSystem_RegisterFunction("qsort", "void qsort(void *, uintsize, uintsize, int (*)(void *, void *))", qsort, module, baseSystemAccess);
eSystem_RegisterFunction("strtod", "double strtod(const char*, char**)", strtod, module, baseSystemAccess);
eSystem_RegisterFunction("strtol", "int strtol(const char*, char**, int base)", strtol, module, baseSystemAccess);
+ eSystem_RegisterFunction("strtoul", "unsigned long strtoul(const char * nptr, char ** endptr, int base)", strtoul, module, baseSystemAccess);
+ eSystem_RegisterFunction("strtoll", "int64 strtoll(const char * nptr, char ** endptr, int base)", strtoll, module, baseSystemAccess);
+ eSystem_RegisterFunction("strtoull", "uint64 strtoull(const char * nptr, char ** endptr, int base)", strtoull, module, baseSystemAccess);
eSystem_RegisterFunction("system", "int system(const char*)", system, module, baseSystemAccess);
eSystem_RegisterFunction("atoi", "int atoi(const char*)", atoi, module, baseSystemAccess);
eSystem_RegisterFunction("atof", "double atof(const char*)", atof, module, baseSystemAccess);
eSystem_RegisterFunction("strcspn", "uintsize strcspn(const char *, const char *)", strcspn, module, baseSystemAccess);
eSystem_RegisterFunction("strpbrk", "char * strpbrk(const char *, const char *)", strpbrk, module, baseSystemAccess);
- eSystem_RegisterDefine("fstrcmp", "(GetRuntimePlatform() == win32) ? strcmpi : strcmp", module, baseSystemAccess);
+ eSystem_RegisterDefine("fstrcmp", "(__runtimePlatform == win32) ? strcmpi : strcmp", module, baseSystemAccess);
//#if defined(__GNUC__)
eSystem_RegisterDefine("strcmpi", "strcasecmp", module, baseSystemAccess);
eSystem_RegisterFunction("islower", "int islower(int c)", islower, module, baseSystemAccess);
eSystem_RegisterFunction("isupper", "int isupper(int c)", isupper, module, baseSystemAccess);
eSystem_RegisterFunction("isprint", "int isprint(int c)", isprint, module, baseSystemAccess);
- eSystem_RegisterFunction("strtoul", "unsigned long strtoul(const char * nptr, char ** endptr, int base)", strtoul, module, baseSystemAccess);
- eSystem_RegisterFunction("strtoll", "int64 strtoll(const char * nptr, char ** endptr, int base)", strtoul, module, baseSystemAccess);
- eSystem_RegisterFunction("strtoull", "uint64 strtoull(const char * nptr, char ** endptr, int base)", strtoul, module, baseSystemAccess);
}
Ecere Software / sdk / blobdiff