// #define MEMINFO
-// #define REDZONE 256
+#ifdef MEMINFO
+ #undef REDZONE
+ #define REDZONE 256
+#endif
+
#ifndef REDZONE
#define REDZONE 0
#endif
private:
#if defined(__ANDROID__)
+
+default const char * AndroidInterface_GetLibLocation();
+
#include <android/log.h>
+#include <android/native_activity.h>
#define printf(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "ecere-app", __VA_ARGS__))
#endif
// IMPLEMENTATION FOR THESE IN _instance.c:
bool Instance_LocateModule(char * name, char * fileName);
void Instance_COM_Initialize(int argc, char ** argv, char ** parsedCommand, int * argcPtr, char *** argvPtr);
-void * Instance_Module_Load(char * name, void ** Load, void ** Unload);
+void * Instance_Module_Load(const char * libLocation, const char * name, void ** Load, void ** Unload);
void Instance_Module_Free(void * library);
+#if defined(_DEBUG)
+void InternalModuleLoadBreakpoint();
+#endif
private:
Class dataTypeClass;
Type dataType;
- void (*Set)();
- int (*Get)();
- bool (*IsSet)();
+ void (*Set)(void *, int);
+ int (*Get)(void *);
+ bool (*IsSet)(void *);
void * data;
void * symbol;
int vid;
int typeSize;
int defaultAlignment;
void (*Initialize)();
- int memberOffset;
+ int memberOffset; // For structs, this includes all base classes structSize. Otherwise it restarts at for each class hierarchy level.
OldList selfWatchers;
char * designerClass;
bool noExpansion;
Class templateClass;
OldList templatized;
int numParams;
+ bool isInstanceClass;
+ bool byValueSystemClass;
property char *
{
void * param; // To attach to Compiler TemplateParameter
}
-/*
-public class Module : struct
+/* // Module inherits off the Instance class (_vTbl, _class, _refCount)
+public class Module
{
class_no_expansion
- Instance inst;
Application app;
public class Application : Module
{
- Module module;
-
int argc;
char ** argv;
int exitCode;
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;
static uint log1_5i(uint number)
{
uint pos;
- uint64 current = 4;
+ uint64 current = sizeof(void *);
for(pos=0; pos < NUM_POOLS; pos++)
{
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;
static uint pow1_5i(uint number)
{
uint pos;
- uint64 current = 4;
+ uint64 current = sizeof(void *);
for(pos=0; pos < NUM_POOLS; pos++)
{
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]);
{
unsigned int p = SIZE_POSITION(size);
if(!memoryInitialized) InitMemory();
- if(p < NUM_POOLS)
+ if(!poolingDisabled && p < NUM_POOLS)
{
block = pools[p].Add();
if(block)
TOTAL_MEM += sizeof(class MemBlock) + size;
OUTSIDE_MEM += sizeof(class MemBlock) + size;
block.part = null;
+ block.size = size;
}
}
}
static void * _mycalloc(int n, unsigned int size)
{
- void * pointer = _mymalloc(size);
+ void * pointer = _mymalloc(n*size);
if(pointer)
- memset(pointer, 0, size);
+ memset(pointer, 0, n*size);
return pointer;
}
{
// 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;
{
// 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;
memMutex.Wait();
#endif
- pointer = malloc(size + 2 * REDZONE);
+ pointer = size ? malloc(size + 2 * REDZONE) : null;
#ifdef MEMINFO
+ if(pointer)
{
MemInfo block;
MemStack stack = (MemStack)memStacks.Find(GetCurrentThreadID());
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;
#endif
#if REDZONE
- memset(pointer, 0xEC, REDZONE);
- memset((byte *)pointer + REDZONE + size, 0xEC, REDZONE);
- // ((byte *)pointer)[0] = 0x00;
+ if(pointer)
+ {
+ memset(pointer, 0xAB, REDZONE);
+ memset((byte *)pointer + REDZONE + size, 0xAB, REDZONE);
+ // ((byte *)pointer)[0] = 0x00;
+ }
#endif
- return (byte*)pointer + REDZONE;
+ return pointer ? ((byte*)pointer + REDZONE) : null;
}
static void * _calloc(int n, unsigned int size)
memMutex.Wait();
#endif
- pointer = calloc(n, size + 2 * REDZONE);
+ pointer = (n*size) ? calloc(1, n*size + 2 * REDZONE) : null;
#ifdef MEMINFO
-{
- MemStack stack;
- stack = (MemStack)memStacks.Find(GetCurrentThreadID());
- if(!stack)
- {
- stack = (MemStack)calloc(1, sizeof(class MemStack));
- stack.key = GetCurrentThreadID();
- memStacks.Add(stack);
- }
- if(!pointer)
+ if(pointer)
{
- int c;
- printf("Memory allocation of %d bytes failed\n", size);
- printf("Current Stack:\n");
- for(c = 0; c<stack.pos; c++)
- if(stack.frames[c])
- printf(" %s\n", stack.frames[c]);
- memoryErrorsCount++;
- memMutex.Release();
- return null;
- }
+ MemStack stack;
+ stack = (MemStack)memStacks.Find(GetCurrentThreadID());
+ if(!stack)
+ {
+ stack = (MemStack)calloc(1, sizeof(class MemStack));
+ stack.key = GetCurrentThreadID();
+ memStacks.Add(stack);
+ }
+ if(!pointer)
+ {
+ int c;
+ printf("Memory allocation of %d bytes failed\n", size);
+ printf("Current Stack:\n");
+ for(c = 0; c<stack.pos; c++)
+ if(stack.frames[c])
+ printf(" %s\n", stack.frames[c]);
+ memoryErrorsCount++;
+ memMutex.Release();
+ return null;
+ }
- if(!recurse && !stack.recurse)
- {
- MemInfo block;
-
- stack.recurse = true;
- block = MemInfo { size = size, key = (uint)((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;
+ if(!recurse && !stack.recurse)
+ {
+ MemInfo block;
+
+ stack.recurse = true;
+ block = MemInfo { size = (unsigned int)n*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;
+ }
}
-}
#endif
#if !defined(ECERE_BOOTSTRAP)
#endif
#if REDZONE
- memset(pointer, 0xEC, REDZONE);
- memset((byte *)pointer + REDZONE + size, 0xEC, REDZONE);
+ if(pointer)
+ {
+ memset(pointer, 0xAB, REDZONE);
+ memset((byte *)pointer + REDZONE + (unsigned int)n*size, 0xAB, REDZONE);
+ }
#endif
- return (byte*)pointer + REDZONE;
+ return pointer ? ((byte*)pointer + REDZONE) : null;
}
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");
memMutex.Release();
return null;
}
- memset(pointer, 0xEC, REDZONE);
- memset((byte *)pointer + REDZONE + size, 0xEC, REDZONE);
+ memset(pointer, 0xAB, REDZONE);
+ memset((byte *)pointer + REDZONE + size, 0xAB, REDZONE);
if(block)
{
{
memcpy(block.freeLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
memcpy((byte *)pointer + REDZONE, (byte *)block.key, Min(block.size, size));
- block.oldmem = (byte *)malloc(block.size + REDZONE * 2) + REDZONE;
- memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + 2 * REDZONE);
+ block.oldmem = (byte *)malloc(block.size + REDZONE * 2);
+ if(block.oldmem)
+ {
+ block.oldmem += REDZONE;
+ memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + 2 * REDZONE);
+ }
memset((byte *)block.key - REDZONE, 0xEC, block.size + REDZONE * 2);
block.freed = true;
}
{
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;
#if !defined(ECERE_BOOTSTRAP)
memMutex.Release();
#endif
- return (byte *)pointer + REDZONE;
+ return pointer ? ((byte *)pointer + REDZONE) : null;
}
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");
memMutex.Release();
return null;
}
- memset(pointer, 0xEC, REDZONE);
- memset((byte *)pointer + REDZONE + size, 0xEC, REDZONE);
+ memset(pointer, 0xAB, REDZONE);
+ memset((byte *)pointer + REDZONE + size, 0xAB, REDZONE);
if(block)
{
{
memcpy(block.freeLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
memcpy((byte *)pointer + REDZONE, (byte *)block.key, Min(block.size, size));
- block.oldmem = (byte *)malloc(block.size + REDZONE * 2) + REDZONE;
- memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + 2 * REDZONE);
+ block.oldmem = (byte *)malloc(block.size + REDZONE * 2);
+ if(block.oldmem)
+ {
+ block.oldmem += REDZONE;
+ memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + 2 * REDZONE);
+ }
memset((byte *)block.key - REDZONE, 0xEC, block.size + REDZONE * 2);
block.freed = true;
}
{
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;
#if !defined(ECERE_BOOTSTRAP)
memMutex.Release();
#endif
- return (byte *)pointer + REDZONE;
+ return pointer ? ((byte *)pointer + REDZONE) : null;
}
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;
address = (byte *)block.key;
for(c = 0; c<REDZONE; c++)
{
- if(address[-c-1] != 0xEC)
+ if(address[-c-1] != 0xAB)
{
printf("Buffer Underrun\n");
memoryErrorsCount++;
block.OutputStacks(block.freed);
}
- if(address[c + size] != 0xEC)
+ if(address[c + size] != 0xAB)
{
printf("Buffer Overrun\n");
memoryErrorsCount++;
}
block.freed = true;
- block.oldmem = (byte *)malloc(block.size + REDZONE * 2) + REDZONE;
- memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + REDZONE * 2);
+ block.oldmem = (byte *)malloc(block.size + REDZONE * 2);
+ if(block.oldmem)
+ {
+ block.oldmem += REDZONE;
+ memcpy(block.oldmem - REDZONE, (byte *)block.key - REDZONE, block.size + REDZONE * 2);
+ }
memset((byte *)block.key - REDZONE, 0xEC, block.size + REDZONE * 2);
memcpy(block.freeLoc, stack.frames + stack.pos - Min(stack.pos, MAX_MEMORY_LOC), Min(stack.pos, MAX_MEMORY_LOC) * sizeof(char *));
address = (byte *)block.key;
for(c = 0; c<REDZONE; c++)
{
- if(address[-c-1] != 0xEC)
+ if(address[-c-1] != 0xAB)
{
printf("Buffer Underrun\n");
memoryErrorsCount++;
block.OutputStacks(block.freed);
}
- if(address[c + size] != 0xEC)
+ if(address[c + size] != 0xAB)
{
printf("Buffer Overrun\n");
memoryErrorsCount++;
{
Class _class = derivative.data;
ClassType type = _class.type;
+ ClassType oldType = type;
int size = _class.structSize - _class.offset;
int oldSizeClass = _class.sizeClass;
int sizeClass = _class.sizeClass - _class.offsetClass;
Method method, next;
Class b;
bool needUpdate = (mod != (base.templateClass ? base.templateClass : base) || _class.vTblSize != mod.vTblSize;
+ int updateStart = -1, updateEnd = -1;
if(mod.base && mod.base.base && mod.base.vTblSize > baseClass.vTblSize && needUpdate)
{
// memmove(_class._vTbl + mod.base.vTblSize, _class._vTbl + baseClass.vTblSize, (mod.base.vTblSize - baseClass.vTblSize) * sizeof(void *));
memmove(_class._vTbl + mod.base.vTblSize, _class._vTbl + baseClass.vTblSize, (_class.vTblSize - mod.vTblSize) * sizeof(void *));
+ updateStart = baseClass.vTblSize;
+ updateEnd = updateStart + mod.base.vTblSize - baseClass.vTblSize;
+
for(method = (Method)_class.methods.first; method; method = next)
{
next = (Method)((BTNode)method).next;
method._class = vMethod._class;
}
}
- else if(needUpdate || _class._vTbl[vMethod.vid] == b._vTbl[vMethod.vid])
+ else if((vMethod.vid >= updateStart && vMethod.vid < updateEnd ) || _class._vTbl[vMethod.vid] == b._vTbl[vMethod.vid])
_class._vTbl[vMethod.vid] = _class.base._vTbl[vMethod.vid];
}
}
}
// if(mod.base.memberID)
{
- for(member = _class.membersAndProperties.first; member; member = member.next)
+ DataMember next;
+ for(member = _class.membersAndProperties.first; member; member = next)
{
int offsetDiff = _class.offset - offsetBefore;
- if(!member.isProperty && offsetDiff > 0)
+ next = member.next;
+ if(!member.isProperty)
{
- member.offset += offsetDiff;
- member.memberOffset += offsetDiff;
+ if(oldType == bitClass && type != bitClass)
+ {
+ DataMember prev = member.prev;
+ // Correcting a bitClass to be a non-bit class (This should really never be required)
+ _class.membersAndProperties.Remove(member);
+ member = (DataMember)renew0 member byte[sizeof (class DataMember)];
+ _class.membersAndProperties.Insert(prev, member);
+ }
+
+ if(offsetDiff > 0)
+ {
+ member.offset += offsetDiff;
+ member.memberOffset += offsetDiff;
+ }
}
member.id += mod.base.memberID;
}
{
int start = 0, c;
NameSpace * nameSpace = null;
+ bool force64Bits = (module.application.isGUIApp & 2) ? true : false;
+ bool force32Bits = (module.application.isGUIApp & 4) ? true : false;
+ bool inCompiler = (module.application.isGUIApp & 8) ? true : false;
+ bool crossBits = force32Bits || force64Bits;
+ bool fixed = false;
+ if(inCompiler && crossBits)
+ {
+ Class c = eSystem_FindClass(__thisModule.application, name);
+ if(c && c.fixed)
+ fixed = true;
+ else if(__thisModule.name && !strcmp(__thisModule.name, "ecereCOM"))
+ fixed = true;
+ }
{
nameSpace = (declMode == publicAccess) ? &module.publicNameSpace : &module.privateNameSpace;
Class enumBase = null;
Class base = (baseName && baseName[0]) ? eSystem_FindClass(module, baseName) : null;
bool refine = false;
+ Class prevBase = null;
if(base && !base.internalDecl && (base.type == noHeadClass || base.type == structClass || base.type == normalClass))
{
{
type = base.type;
}
- if(!base || base.type == systemClass)
+ if(!base || base.type == systemClass || base.isInstanceClass)
{
if(type == enumClass)
{
if((_class = eSystem_FindClass(module, name)))
{
- FreeTemplatesDerivatives(_class);
-
if(!_class.internalDecl)
{
if(declMode != baseSystemAccess)
return null;
}
+ FreeTemplatesDerivatives(_class);
+
classLink = (BTNamedLink)_class.nameSpace->classes.FindString(name + start);
_class.nameSpace->classes.Delete((BTNode)classLink);
{
}
_class.module = module;
+ prevBase = _class.base;
_class.base = base;
if(base)
{
}
_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 && inCompiler && fixed) ? 24 : (force32Bits && inCompiler && fixed) ? 12 : sizeof(class Instance)));
+
+ // For cross-bitness-compiling
+ if(crossBits)
+ {
+ // Ideally, the running library should be aware of the struct size of both 32 and 64 bit, since the compiler has no knowledge whatsoever of private members
+ if(strstr(name, "ecere::sys::EARHeader") ||
+ strstr(name, "AnchorValue") ||
+ !strcmp(name, "ecere::com::CustomAVLTree") ||
+ !strcmp(name, "ecere::com::Array") ||
+ !strcmp(name, "ecere::gui::Window") ||
+ !strcmp(name, "ecere::sys::Mutex")); // Never recompute these, they're always problematic (errors, crashes)
+ else
+ {
+ if(!strcmp(name, "ecere::sys::FileListing"))
+ {
+ 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
+ }
+ // 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::com::ClassProperty")) size = 0; // 80
+ else if(!strcmp(name, "ecere::com::NameSpace")) size = 0; // 176
+ 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(module != module.application && inCompiler)
+ {
+ // These we only want to recompute inside the compiler
+ if(fixed || type == structClass)
+ size = 0;
+ }
+ }
+ }
if(type == structClass)
{
_class.memberOffset = (base && base.structSize && base.type != systemClass) ? base.structSize : 0;
data.largest = ((EnumClassData)(base.data)).largest;
}
}
- if(base && base.vTblSize)
+ if(base)
{
- _class.vTblSize = base.vTblSize;
- // OK to scrap existing virtual table?
- delete _class._vTbl;
- _class._vTbl = _malloc(sizeof(int(*)()) * _class.vTblSize);
- memcpy(_class._vTbl, base._vTbl, sizeof(int(*)()) * _class.vTblSize);
+ int i;
+ uint oldSize = _class.vTblSize;
+ if(base.vTblSize && _class.vTblSize < base.vTblSize)
+ {
+ _class.vTblSize = base.vTblSize;
+ // OK to scrap existing virtual table?
+ //delete _class._vTbl;
+ //_class._vTbl = _malloc(sizeof(int(*)()) * _class.vTblSize);
+ // memcpy(_class._vTbl, base._vTbl, sizeof(int(*)()) * _class.vTblSize);
+ _class._vTbl = _realloc(_class._vTbl, sizeof(int(*)()) * _class.vTblSize);
+ }
+ if(!prevBase)
+ {
+ if(_class.type == normalClass && strcmp(_class.name, "ecere::com::Instance") && strcmp(_class.name, "enum") && strcmp(_class.name, "struct"))
+ prevBase = eSystem_FindClass(module, "ecere::com::Instance");
+ else
+ prevBase = eSystem_FindClass(module, "class");
+ }
+ for(i = 0; i < base.vTblSize; i++)
+ {
+ if(i >= oldSize || _class._vTbl[i] == prevBase._vTbl[i])
+ _class._vTbl[i] = base._vTbl[i];
+ }
}
if(_class.base)
delete template.fullName;
delete template.name;
delete template.templateArgs;
+ delete template.dataTypeString;
while((deriv = template.derivatives.first))
{
//if(_class.templateArgs)
//printf("Deleting Template args for %s\n", _class.name);
delete _class.templateArgs;
+ delete _class.dataTypeString;
while((template = _class.templatized.first))
{
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)
{
else if(ch == '-') { sign = -1; c++; };
if(!base)
{
- if(ch == 0 && string[c+1] == 'x')
+ if(ch == '0' && string[c+1] == 'x')
{
base = 16;
c+=2;
}
for( ;(ch = string[c]); c++)
{
- if(ch == '0')
- ch = 0;
- else if(ch >= '1' && ch <= '9')
- ch -= '1';
+ if(ch >= '0' && ch <= '9')
+ ch -= '0';
else if(ch >= 'a' && ch <= 'z')
- ch -= 'a';
+ ch -= ('a' - 10);
else if(ch >= 'A' && ch <= 'Z')
- ch -= 'A';
+ ch -= ('A'- 10);
else
{
- *endString = string + c;
+ if(endString)
+ *endString = string + c;
// Invalid character
break;
}
}
else
{
- *endString = string + c;
+ if(endString)
+ *endString = string + c;
// Invalid character
break;
}
else if(ch == '-') { sign = -1; c++; };
if(!base)
{
- if(ch == 0 && string[c+1] == 'x')
+ if(ch == '0' && string[c+1] == 'x')
{
base = 16;
c+=2;
}
for( ;(ch = string[c]); c++)
{
- if(ch == '0')
- ch = 0;
- else if(ch >= '1' && ch <= '9')
- ch -= '1';
+ if(ch >= '0' && ch <= '9')
+ ch -= '0';
else if(ch >= 'a' && ch <= 'z')
- ch -= 'a';
+ ch -= ('a' - 10);
else if(ch >= 'A' && ch <= 'Z')
- ch -= 'A';
+ ch -= ('A' - 10);
else
{
- *endString = string + c;
+ if(endString)
+ *endString = string + c;
// Invalid character
break;
}
}
else
{
- *endString = string + c;
+ if(endString)
+ *endString = string + c;
// Invalid character
break;
}
templatedClass.templateClass = _class;
//templatedClass.fullName = CopyString(name);
templatedClass.fullName = CopyString(className);
+ templatedClass.dataTypeString = CopyString(_class.dataTypeString);
templatedClass.name = CopyString(templatedClass.fullName + strlen(_class.fullName) - strlen(_class.name));
templatedClass.nameSpace->classes.Add((BTNode)BTNamedLink { name = templatedClass.name, data = templatedClass });
templatedClass.templateArgs = null;
if(expClass)
{
//if(expClass.type ==
- expClass._vTbl[__ecereVMethodID_class_OnGetDataFromString](expClass, &argument.expression, value);
+ ((bool (*)(void *, void *, const char *))(void *)expClass._vTbl[__ecereVMethodID_class_OnGetDataFromString])(expClass, &argument.expression, value);
}
// Expression should be pre simplified here
else if(value[0] == '\"')
}
else if(!strcmp(curParam.dataTypeString, "uint"))
{
- argument.expression.ui = strtoul(value, null, 0);
+ argument.expression.ui = (uint)strtoul(value, null, 0);
}
else if(!strcmp(curParam.dataTypeString, "char"))
{
}
else // if(!strcmp(curParam.dataTypeString, "int"))
{
- argument.expression.i = strtol(value, null, 0);
+ argument.expression.i = (int)strtol(value, null, 0);
}
break;
}
{
for(; _class && from; _class = _class.base)
{
- if(_class == from || _class.templateClass == from || (_class.type == systemClass && from.name && !strcmp(_class.name, from.name)))
+ if(_class == from || _class.templateClass == from || ((_class.type == systemClass || (_class.type == normalClass && _class.isInstanceClass)) && from.name && !strcmp(_class.name, from.name)))
return true;
}
}
public dllexport Method eClass_AddMethod(Class _class, char * name, char * type, void * function, AccessMode declMode)
{
- if(_class && name)
+ if(_class && !_class.comRedefinition && name)
{
Class base;
for(base = _class; base; base = base.base)
{
OldLink deriv;
void * oldFunction = _class._vTbl[method.vid];
- if(method.vid > _class.vTblSize)
- printf("error");
+ if(method.vid >= _class.vTblSize)
+ printf("error: virtual methods overriding failure\n");
else
_class._vTbl[method.vid] = function ? function : DefaultFunction;
for(deriv = _class.derivatives.first; deriv; deriv = deriv.next)
public dllexport Method eClass_AddVirtualMethod(Class _class, char * name, char * type, void * function, AccessMode declMode)
{
- if(_class && name)
+ if(_class && !_class.comRedefinition && name)
{
Class base;
for(base = _class; base; base = base.base)
{
// If this overides a virtual method
if(method.type == virtualMethod)
- _class._vTbl[method.vid] = function ? function : DefaultFunction;
+ {
+ if(method.vid >= _class.vTblSize)
+ printf("error: virtual methods overriding failure\n");
+ else
+ _class._vTbl[method.vid] = function ? function : DefaultFunction;
+ }
else
base = null;
return method;
{
Class _class = derivative.data;
Property prop;
- BTNamedLink link;
- link = (BTNamedLink)_class.prop.FindString(_property.name);
+ BTNamedLink link = (BTNamedLink)_class.prop.FindString(_property.name);
if(link)
{
prop = link.data;
Property _property = null;
if(_class)
{
- if(!_class.prop.FindString((name ? name : dataType)))
+ BTNamedLink link = (BTNamedLink)_class.prop.FindString(name ? name : dataType);
+ if(link)
+ _property = link.data;
+ if(!_property)
{
_property =
{
static void SetDelayedCPValues(Class _class, ClassProperty _property)
{
OldLink deriv;
- NamedLink value, next;
+ NamedLink64 value, next;
for(value = _class.delayedCPValues.first; value; value = next)
{
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);
}
}
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 });
}
}
#endif
#endif
- instance = _calloc(1, _class.structSize);
+ {
+ int size = _class.structSize;
+ int flags = _class.module.application.isGUIApp;
+ bool inCompiler = (flags & 8) ? true : false;
+ bool force32Bits = (flags & 4) ? true : false;
+ if(force32Bits && inCompiler)
+ {
+ // Allocate 64 bit sizes for these when cross-compiling for 32 bit to allow loaded libraries to work properly
+ if(!strcmp(_class.name, "Module"))
+ size = 560;
+ else if(_class.templateClass && !strcmp(_class.templateClass.name, "Map"))
+ size = 40;
+ else
+ size *= 3;
+ }
+ instance = _calloc(1, size);
+ }
#ifdef MEMINFO
allocateClass = null;
memMutex.Release();
bool ownVtbl;
#ifdef MEMINFO
- if(instance._class == (void *)0xecececec)
+ if(instance._class == (void *)0xecececececececec)
_free(instance);
#endif
base = _class.base;
- if(base && base.type == systemClass) base = null;
+ if(base && (base.type == systemClass || base.isInstanceClass)) base = null;
if(_class.Destructor)
_class.Destructor(instance);
#ifdef MEMINFO
{
DataMember dataMember = eClass_FindDataMember(_class, curMember->name, null, null, null);
if(!dataMember) dataMember = (DataMember)eClass_FindProperty(_class, curMember->name, null);
- if(dataMember && dataMember.memberAccess != privateAccess)
+ if(dataMember && dataMember.memberAccess != privateAccess && dataMember.id >= 0) // Skip _vTbl, _refCount and _class in Instance
{
*curMember = dataMember;
break;
public dllexport bool eMember_AddMember(DataMember addTo, DataMember dataMember)
{
- if(dataMember.name && addTo.membersAlpha.FindString(dataMember.name)) return false;
+ if(dataMember.name && addTo.membersAlpha.FindString(dataMember.name))
+ {
+ DataMember_Free(dataMember);
+ delete dataMember;
+ return false;
+ }
addTo.members.Add(dataMember);
if(dataMember.name)
public dllexport bool eClass_AddMember(Class _class, DataMember dataMember)
{
if(!_class || _class.comRedefinition || (dataMember.name && _class.members.FindString(dataMember.name)))
+ {
+ DataMember_Free(dataMember);
+ delete dataMember;
return false;
+ }
_class.membersAndProperties.Add(dataMember);
if(dataMember.name)
}
else
{
- library = Instance_Module_Load(name, &Load, &Unload);
+ char * libLocation = null;
+#if defined(__ANDROID__)
+ libLocation = AndroidInterface_GetLibLocation();
+#endif
+ library = Instance_Module_Load(libLocation, name, &Load, &Unload);
}
if(Load)
{
module.name = CopyString(name);
module.Unload = Unload;
module.origImportType = normalImport;
+
if(!Load(module))
{
eInstance_Delete((Instance)module);
module.library = null;
module.name = CopyString(name);
module.Unload = Unload;
+
if(!Load(module))
{
eInstance_Delete((Instance)module);
module = null;
}
+
fromModule.application.allModules.Add(module);
}
if(module)
}
incref module;
}
+#if defined(_DEBUG)
+ InternalModuleLoadBreakpoint();
+#endif
return module;
}
}
_class.module = null;
module.classes.Remove(_class);
- if(!_class.count || _class.type != normalClass)
+ if(_class.count <= 0 || _class.type != normalClass || _class.isInstanceClass)
eClass_Unregister(_class);
else
{
#endif
}
-static int GetEnumSize(Class _class)
+static int64 GetEnumSize(Class _class)
{
EnumClassData data = (EnumClassData)_class.data;
return data.largest+1;
{
if(instance && _property && _property.isWatchable)
{
- OldList * watchers = (OldList *)((byte *)instance + _property.watcherOffset);
- Watcher watcher, next;
-
- for(watcher = watchers->first; watcher; watcher = next)
+ Module module = instance._class ? instance._class.module : null;
+ Application application = module ? module.application : null;
+ int flags = application ? application.isGUIApp : 0;
+ bool inCompiler = (flags & 8) ? true : false;
+ bool force32Bits = (flags & 4) ? true : false;
+ if(!force32Bits || !inCompiler)
{
- next = watcher.next;
- watcher.callback(watcher.object, instance);
+ OldList * watchers = (OldList *)((byte *)instance + _property.watcherOffset);
+ Watcher watcher, next;
+
+ for(watcher = watchers->first; watcher; watcher = next)
+ {
+ next = watcher.next;
+ watcher.callback(watcher.object, instance);
+ }
}
}
}
}
}
base = _class.base;
- if(base && base.type == systemClass) base = null;
+ if(base && (base.type == systemClass || base.isInstanceClass)) base = null;
}
}
}
static void LoadCOM(Module module)
{
+ bool force64Bits = (module.application.isGUIApp & 2) ? true : false;
+ bool force32Bits = (module.application.isGUIApp & 4) ? true : false;
+ bool inCompiler = (module.application.isGUIApp & 8) ? true : false;
+ int pointerSize = force64Bits ? 8 : force32Bits ? 4 : sizeof(void *);
Class applicationClass;
Class enumClass, structClass, boolClass;
Class moduleClass;
{
Class instanceClass = eSystem_RegisterClass(normalClass, "ecere::com::Instance", null, 0, 0, null, null, module, baseSystemAccess, publicAccess);
- // Instance should really be a Normal class, but inheritance checks for systemClass to see if something has a non system ancestor
- instanceClass.type = systemClass;
+ instanceClass.type = normalClass;
+ instanceClass.isInstanceClass = true;
instanceClass.fixed = true;
instanceClass.memberOffset = 0;
instanceClass.offset = 0;
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 ? 40 : sizeof(class EnumClassData), null, null, module, baseSystemAccess, publicAccess);
eClass_AddClassProperty(enumClass, "enumSize", "int", null, GetEnumSize).constant = true;
enumClass.type = systemClass;
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 + 32 + 32 + 32 + 32 + 8 + 8 + 8 + 8 + 8 + 4 + 4 + (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 : force32Bits ? 20 : sizeof(OldList), pointerSize, publicAccess);
+ eClass_AddDataMember(moduleClass, "defines", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(OldList), pointerSize, publicAccess);
+ eClass_AddDataMember(moduleClass, "functions", "OldList", force64Bits ? 32 : force32Bits ? 20 : sizeof(OldList), pointerSize, publicAccess);
+ eClass_AddDataMember(moduleClass, "modules", "OldList", force64Bits ? 32 : force32Bits ? 20 : 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) : force32Bits ? (16 + 4 + 4 + 4*16) : sizeof(NameSpace), pointerSize, publicAccess);
+ eClass_AddDataMember(moduleClass, "publicNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4*32) : force32Bits ? (16 + 4 + 4 + 4*16) : sizeof(NameSpace), pointerSize, publicAccess);
moduleClass.fixed = true;
moduleClass.count++;
+ if(inCompiler && force32Bits)
+ moduleClass.structSize = 12 + 4 + 20 + 20 + 20 + 20 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + (16 + 4 + 4 + 4*16) + (16 + 4 + 4 + 4*16);
// 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+4+4 + 32 + 8 + 176) : sizeof(struct Application), 0, null, (void *)Application_Destructor, module, baseSystemAccess, publicAccess);
+ if(inCompiler && force32Bits)
+ {
+ applicationClass.offset = 12 + 4 + 20 + 20 + 20 + 20 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + (16 + 4 + 4 + 4*16) + (16 + 4 + 4 + 4*16);
+ applicationClass.structSize = applicationClass.offset + (4+4+4+4 + 20 + 4 + 88);
+ }
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 : force32Bits ? 20 : sizeof(OldList), pointerSize, publicAccess);
+ eClass_AddDataMember(applicationClass, "parsedCommand", "char *", pointerSize, pointerSize, publicAccess);
+ eClass_AddDataMember(applicationClass, "systemNameSpace", "NameSpace", force64Bits ? (32 + 8 + 8 + 4*32) : force32Bits ? (16 + 4 + 4 + 4*16) : sizeof(NameSpace), pointerSize, publicAccess);
applicationClass.fixed = true;
applicationClass.count++;
eSystem_RegisterFunction("exp", "double exp(double number)", exp, module, baseSystemAccess);
// --- Stdlib ---
- eSystem_RegisterFunction("qsort", "void qsort(void *, uint, uint, int (*)(void *, void *))", qsort, module, baseSystemAccess);
+ eSystem_RegisterFunction("qsort", "void qsort(void *, uintsize, uintsize, int (*)(void *, void *))", qsort, module, baseSystemAccess);
eSystem_RegisterFunction("strtod", "double strtod(char*, char**)", strtod, module, baseSystemAccess);
eSystem_RegisterFunction("strtol", "int strtol(char*, char**, int base)", strtol, 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", "float atof(const char*)", atof, module, baseSystemAccess);
+ eSystem_RegisterFunction("atof", "double atof(const char*)", atof, module, baseSystemAccess);
eSystem_RegisterFunction("tolower", "int tolower(int)", tolower, module, baseSystemAccess);
eSystem_RegisterFunction("toupper", "int toupper(int)", toupper, module, baseSystemAccess);
eSystem_RegisterFunction("isdigit", "bool isdigit(int)", isdigit, module, baseSystemAccess);
- eSystem_RegisterFunction("memset", "void memset(void * area, byte value, uint count)", memset, module, baseSystemAccess);
+ eSystem_RegisterFunction("memset", "void * memset(void * area, int value, uintsize count)", memset, module, baseSystemAccess);
eSystem_RegisterFunction("getenv", "char * getenv(const char * name)", getenv, module, baseSystemAccess);
eSystem_RegisterFunction("rename", "int rename(const char *oldpath, const char *newpath)", rename, module, baseSystemAccess);
// --- String --- (These might move to the string class)
- eSystem_RegisterFunction("strlen", "int strlen(const char *)", strlen, module, baseSystemAccess);
+ eSystem_RegisterFunction("strlen", "uintsize strlen(const char *)", strlen, module, baseSystemAccess);
eSystem_RegisterFunction("strcat", "char * strcat(char *, const char *)", strcat, module, baseSystemAccess);
- eSystem_RegisterFunction("strncat", "char * strncat(char *, const char *, int n)", strncat, module, baseSystemAccess);
- eSystem_RegisterFunction("strchr", "char * strchr(char *, int)", strchr, module, baseSystemAccess);
- eSystem_RegisterFunction("strstr", "char * strstr(char *, const char *)", strstr, module, baseSystemAccess);
+ eSystem_RegisterFunction("strncat", "char * strncat(char *, const char *, uintsize n)", strncat, module, baseSystemAccess);
+ eSystem_RegisterFunction("strchr", "char * strchr(const char *, int)", strchr, module, baseSystemAccess);
+ eSystem_RegisterFunction("strstr", "char * strstr(const char *, const char *)", strstr, module, baseSystemAccess);
eSystem_RegisterDefine("fstrcmp", "(GetRuntimePlatform() == win32) ? strcmpi : strcmp", module, baseSystemAccess);
eSystem_RegisterDefine("strcmpi", "strcasecmp", module, baseSystemAccess);
eSystem_RegisterDefine("strnicmp", "strncasecmp", module, baseSystemAccess);
eSystem_RegisterFunction("strcasecmp", "int strcasecmp(const char *, const char *)", strcmpi, module, baseSystemAccess);
- eSystem_RegisterFunction("strncasecmp", "int strncasecmp(const char *, const char *, int n)", strnicmp, module, baseSystemAccess);
+ eSystem_RegisterFunction("strncasecmp", "int strncasecmp(const char *, const char *, uintsize n)", strnicmp, module, baseSystemAccess);
/*
#else
eSystem_RegisterDefine("strcasecmp", "strcmpi", module, baseSystemAccess);
*/
eSystem_RegisterFunction("strcmp", "int strcmp(const char *, const char *)", strcmp, module, baseSystemAccess);
- eSystem_RegisterFunction("strncmp", "int strncmp(const char *, const char *, int n)", strncmp, module, baseSystemAccess);
+ eSystem_RegisterFunction("strncmp", "int strncmp(const char *, const char *, uintsize n)", strncmp, module, baseSystemAccess);
eSystem_RegisterFunction("strlwr", "char * strlwr(char *)", strlwr, module, baseSystemAccess);
eSystem_RegisterFunction("strupr", "char * strupr(char *)", strupr, module, baseSystemAccess);
eSystem_RegisterFunction("strcpy", "char * strcpy(char *, const char *)", strcpy, module, baseSystemAccess);
- eSystem_RegisterFunction("strncpy", "char * strncpy(char *, const char *, int n)", strncpy, module, baseSystemAccess);
- eSystem_RegisterFunction("memcpy", "void * memcpy(void *, const void *, uint size)", memcpy, module, baseSystemAccess);
- eSystem_RegisterFunction("memmove", "void * memmove(void *, const void *, uint size)", memmove, module, baseSystemAccess);
+ eSystem_RegisterFunction("strncpy", "char * strncpy(char *, const char *, uintsize n)", strncpy, module, baseSystemAccess);
+ eSystem_RegisterFunction("memcpy", "void * memcpy(void *, const void *, uintsize size)", memcpy, module, baseSystemAccess);
+ eSystem_RegisterFunction("memmove", "void * memmove(void *, const void *, uintsize size)", memmove, module, baseSystemAccess);
// --- Stdio ---
eSystem_RegisterFunction("sprintf", "int sprintf(char *, char *, ...)", sprintf, module, baseSystemAccess);
- // TODO: Replace int with size_t when eC recognizes it for 64 bit port
- eSystem_RegisterFunction("snprintf", "int sprintf(char *, int, char *, ...)", snprintf, module, baseSystemAccess);
+ eSystem_RegisterFunction("snprintf", "int sprintf(char *, uintsize, char *, ...)", snprintf, module, baseSystemAccess);
eSystem_RegisterFunction("printf", "int printf(char *, ...)", printf, module, baseSystemAccess);
eSystem_RegisterFunction("vsprintf", "int vsprintf(char*, const char*, __builtin_va_list)", vsprintf, module, baseSystemAccess);
- // TODO: Replace int with size_t when eC recognizes it for 64 bit port
- eSystem_RegisterFunction("vsnprintf", "int vsnprintf(char*, int, const char*, __builtin_va_list)", vsnprintf, module, baseSystemAccess);
+ eSystem_RegisterFunction("vsnprintf", "int vsnprintf(char*, uintsize, const char*, __builtin_va_list)", vsnprintf, module, baseSystemAccess);
eSystem_RegisterFunction("puts", "int puts(char *)", puts, module, baseSystemAccess);
eSystem_RegisterFunction("fputs", "int fputs(char *, void * stream)", fputs, module, baseSystemAccess);
{
void * first = base.templateParams.first;
int count = base.templateParams.count;
- base.templateParams.first = null;
- base.templateParams.count = 0;
FreeTemplateArgs(base);
delete base.templateArgs;
+
+ base.templateParams.first = null;
+ base.templateParams.count = 0;
+
FreeTemplatesDerivatives(base);
base.templateParams.first = first;
return activeDesigner;
}
+
+bool poolingDisabled;
+
+public dllexport void eSystem_SetPoolingDisabled(bool disabled)
+{
+ poolingDisabled = disabled;
+}
+
namespace sys;
// constants
for(c = 0; source[c]; c++)
{
unichar ch = ((byte *)source)[c];
+ switch(ch)
+ {
+ case 150: ch = (unichar)0x2012; break;
+ }
if(ch < 0x80)
{
if(d + 1 >= max) break;
return d;
}
+// NOTE: UTF8GetChar now returns 0 into numBytes for the null-terminating character ('\0')
public unichar UTF8GetChar(char * string, int * numBytes)
{
unichar ch;
byte b = ((byte *)string)[0];
int i;
byte mask = 0x7F;
- int nb = 1;
+ int nb = b ? 1 : 0;
ch = 0;
if(b & 0x80)
{
Ecere Software / sdk / blobdiff