static class MemStack : BTNode
{
- char * frames[1000];
+ const char * frames[1000];
int pos;
bool recurse;
};
default:
#define property _property
-#define bool _bool
-#define uint _uint
-#define true _true
-#define false _false
#include <stdlib.h>
#include <stdio.h>
#endif
#undef property
-#undef bool
-#undef uint
-#undef true
-#undef false
#undef CompareString
public define null = ((void *)0);
-dllexport Class eSystem_FindClass(Module module, char * name);
+dllexport Class eSystem_FindClass(Module module, const char * name);
dllexport void * eSystem_Renew(void * memory, unsigned int size);
dllexport void * eSystem_Renew0(void * memory, unsigned int size);
dllexport void * eSystem_New(unsigned int size);
extern int __ecereVMethodID_class_OnGetDataFromString;
// 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);
+bool Instance_LocateModule(const char * name, const char * fileName);
+void Instance_COM_Initialize(int argc, char ** argv, char ** parsedCommand, int * argcPtr, const char *** argvPtr);
void * Instance_Module_Load(const char * libLocation, const char * name, void ** Load, void ** Unload);
void Instance_Module_Free(void * library);
#if defined(_DEBUG)
private:
+public class Angle : double;
+
public class unichar : uint32
{
- char * OnGetString(char * tempString, void * fieldData, bool * needClass)
+ const char * OnGetString(char * tempString, void * fieldData, bool * needClass)
{
UTF32toUTF8Len(&this, 1, tempString, 5);
return tempString;
}
- bool OnGetDataFromString(char * string)
+ bool OnGetDataFromString(const char * string)
{
int nb;
this = UTF8GetChar(string, &nb);
class_fixed
class_no_expansion
Property prev, next;
- char * name;
+ const char * name;
bool isProperty;
AccessMode memberAccess;
int id;
Class _class;
- char * dataTypeString;
+ const char * dataTypeString;
Class dataTypeClass;
Type dataType;
int vid;
bool conversion;
uint watcherOffset;
- char * category;
+ const char * category;
bool compiled;
bool selfWatchable, isWatchable;
};
dllexport void eInstance_FireWatchers(Instance instance, Property _property);
-public dllexport void MemoryGuard_PushLoc(char * loc)
+public dllexport void MemoryGuard_PushLoc(const char * loc)
{
#ifdef MEMINFO
MemStack stack;
{
class_fixed
public:
- char * name;
+ const char * name;
BTNamedLink parent, left, right;
int depth;
void * data;
class_fixed
class_no_expansion
Class prev, next;
- char * name;
+ const char * name;
int offset, structSize;
int (** _vTbl)();
int vTblSize;
ClassType type;
Module module;
NameSpace * nameSpace;
- char * dataTypeString;
+ const char * dataTypeString;
Type dataType;
int typeSize;
int defaultAlignment;
void (*Initialize)();
int memberOffset; // For structs, this includes all base classes structSize. Otherwise it restarts at for each class hierarchy level.
OldList selfWatchers;
- char * designerClass;
+ const char * designerClass;
bool noExpansion;
- char * defaultProperty;
+ const char * defaultProperty;
bool comRedefinition;
int count; // DEBUGGING
- bool isRemote;
+ int isRemote; // TODO: Convert to an enum, can have values 0..3
bool internalDecl;
void * data;
bool computeSize;
bool fixed;
OldList delayedCPValues;
AccessMode inheritanceAccess;
- char * fullName;
+ const char * fullName;
void * symbol;
OldList conversions;
bool isInstanceClass;
bool byValueSystemClass;
- property char *
+ property const char *
{
get { return name; }
set
}
};
- char * OnGetString(char * tempString, void * fieldData, bool * needClass)
+ const char * OnGetString(char * tempString, void * fieldData, bool * needClass)
{
return name;
}
- bool OnGetDataFromString(char * string)
+ bool OnGetDataFromString(const char * string)
{
Class theClass;
theClass = eSystem_FindClass(__thisModule, string);
// For type
struct
{
- char * dataTypeString;
+ const char * dataTypeString;
Class dataTypeClass;
// Type dataType;
};
// For identifier
struct
{
- char * memberString;
+ const char * memberString;
union
{
DataMember member;
class_fixed
public:
ClassTemplateParameter prev, next;
- char * name;
+ const char * name;
TemplateParameterType type;
union
{
// Class baseClass; // For type
- char * dataTypeString; // For expression
+ const char * dataTypeString; // For expression
TemplateMemberType memberType; // For identifier
};
ClassTemplateArgument defaultArg;
OldList modules;
Module prev, next;
- char * name;
+ const char * name;
void * library;
void (stdcall * Unload)(Module module);
ImportType importType;
public class Application : Module
{
int argc;
- char ** argv;
+ const char ** argv;
int exitCode;
bool isGUIApp;
OldList allModules;
- char * parsedCommand;
+ const char * parsedCommand;
NameSpace systemNameSpace;
};
*/
{
public:
class_fixed
- char * name;
+ const char * name;
Method parent, left, right;
int depth;
int (*function)();
MethodType type;
Class _class;
void * symbol;
- char * dataTypeString;
+ const char * dataTypeString;
Type dataType;
AccessMode memberAccess;
};
public struct NameSpace
{
- char * name;
+ const char * name;
NameSpace * btParent, * left, * right;
int depth;
public:
class_fixed
DataMember prev, next;
- char * name;
+ const char * name;
bool isProperty;
AccessMode memberAccess;
int id;
Class _class;
- char * dataTypeString;
+ const char * dataTypeString;
Class dataTypeClass;
Type dataType;
public:
class_fixed
BitMember prev, next;
- char * name;
+ const char * name;
bool isProperty;
AccessMode memberAccess;
int id;
Class _class;
- char * dataTypeString;
+ const char * dataTypeString;
Class dataTypeClass;
Type dataType;
{
public:
class_fixed
- char * name;
+ const char * name;
ClassProperty parent, left, right;
int depth;
void (*Set)(Class, int64);
int64 (*Get)(Class);
- char * dataTypeString;
+ const char * dataTypeString;
Type dataType;
bool constant;
};
public:
class_fixed
DefinedExpression prev, next;
- char * name;
- char * value;
+ const char * name;
+ const char * value;
NameSpace * nameSpace;
};
public:
class_fixed
GlobalFunction prev, next;
- char * name;
+ const char * name;
int (*function)();
Module module;
NameSpace * nameSpace;
- char * dataTypeString;
+ const char * dataTypeString;
Type dataType;
void * symbol;
};
byte * oldmem;
uint size;
bool freed;
- char * _class;
+ const char * _class;
uint id;
- char * allocLoc[MAX_MEMORY_LOC];
- char * freeLoc[MAX_MEMORY_LOC];
+ const char * allocLoc[MAX_MEMORY_LOC];
+ const char * freeLoc[MAX_MEMORY_LOC];
bool internal;
void OutputStacks(bool showFree)
bool recurse = false;
static int blockID;
//Class allocateClass;
-char * allocateClass;
+const char * allocateClass;
bool allocateInternal;
#endif
#define SIZE_POSITION(s) log1_5i(s)
#define NTH_SIZE(p) pow1_5(p)
+#if 0
static int power15[] =
{
/*
466624,
699920
};
+#endif
private struct BlockPool
{
{
int c;
#ifdef _DEBUG
- uint totalAvailable = 0, totalAllocated = 0, totalBlocks = 0, totalUsed = 0;
- uint totalParts = 0;
+ /*uint totalAvailable = 0, totalAllocated = 0, totalBlocks = 0, totalUsed = 0;
+ uint totalParts = 0;*/
#endif
MemBlock block = (MemBlock)memory;
MemPart part = calloc(1, sizeof(class MemPart));
static BlockPool * pools; //[NUM_POOLS];
-static uint PosFibonacci(uint number)
+/*static uint PosFibonacci(uint number)
{
uint pos;
uint last = 1, prev = 0;
return current;
}
}
-
+*/
static uint log1_5i(uint number)
{
uint pos;
static void FixDerivativesBase(Class base, Class mod)
{
OldLink derivative;
- OldLink templateLink;
ComputeClassParameters(base, strchr(base.name, '<'), null);
int oldSizeClass = _class.sizeClass;
int sizeClass = _class.sizeClass - _class.offsetClass;
Class enumBase = null;
- char * dataTypeString = null;
+ const char * dataTypeString = null;
// NOTE: baseClass is class(class)
Class baseClass;
uint offsetBefore = _class.offset;
if(_class.type != systemClass)
_class.type = type;
- delete _class.dataTypeString;
+ delete (void *)_class.dataTypeString;
_class.dataTypeString = CopyString(dataTypeString);
if(totalSizeClass != oldSizeClass)
{
Method method, next;
Class b;
- bool needUpdate = (mod != (base.templateClass ? base.templateClass : base) || _class.vTblSize != mod.vTblSize;
+ 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)
if(method.function) _class._vTbl[vMethod.vid] = method.function;
if(!method.symbol)
{
- delete method.name;
- delete method.dataTypeString;
+ delete (void *)method.name;
+ delete (void *)method.dataTypeString;
_class.methods.Delete((BTNode)method);
}
else
{
- delete method.dataTypeString;
+ delete (void *)method.dataTypeString;
method.type = vMethod.type;
method.dataTypeString = CopyString(vMethod.dataTypeString);
method._class = vMethod._class;
}
_property.selfWatchable = true;
_class.prop.Delete((BTNode)link);
- delete prop.name;
- delete prop.dataTypeString;
+ delete (void *)prop.name;
+ delete (void *)prop.dataTypeString;
_class.membersAndProperties.Delete(prop); // Remove only was done before?
}
}
for(templateLink = base.templatized.first; templateLink; templateLink = templateLink.next)
{
Class template = templateLink.data;
- char * templateParams = strchr(template.name, '<');
+ //const char * templateParams = strchr(template.name, '<');
template.base = base.base;
template._vTbl = base._vTbl;
//ComputeClassParameters(template, templateParams, null);
}
}
-public dllexport Class eSystem_RegisterClass(ClassType type, char * name, char * baseName, int size, int sizeClass,
+public dllexport Class eSystem_RegisterClass(ClassType type, const char * name, const char * baseName, int size, int sizeClass,
bool (* Constructor)(void *),void (* Destructor)(void *),
Module module, AccessMode declMode, AccessMode inheritanceAccess)
{
int totalSizeClass;
BTNamedLink classLink = null;
Class _class = null;
- char * dataTypeString = null;
+ const char * dataTypeString = null;
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))
offsetClass = base ? base.sizeClass : (type == noHeadClass ? 0 : 0 /*sizeof(class Class)*/);
totalSizeClass = offsetClass + sizeClass;
- if((_class = eSystem_FindClass(module, name)))
+ _class = eSystem_FindClass(module, name);
+ if(!_class)
+ {
+ const char * colons = RSearchString(name, "::", strlen(name), true, false);
+ if(colons && colons)
+ {
+ _class = eSystem_FindClass(module, colons + 2);
+ if(_class)
+ {
+ if(_class.internalDecl)
+ {
+ delete (void *)_class.fullName;
+ _class.fullName = CopyString(name);
+ }
+ else
+ _class = null;
+ }
+ }
+ }
+ if(_class)
{
if(!_class.internalDecl)
{
ns = parent;
}
}
- refine = true;
}
else
{
}
}
- refine = true;
- delete _class.fullName;
+ delete (void *)_class.fullName;
_class.fullName = CopyString(name);
}
else
}
if(nameSpace)
{
- nameSpace->classes.Add((BTNode)BTNamedLink { name = _class.name, data = _class });
+ nameSpace->classes.Add((BTNode)BTNamedLink { name = (char *)_class.name, data = _class });
{
OldLink t;
for(t = _class.templatized.first; t; t = t.next)
{
Class template = t.data;
- nameSpace->classes.Add((BTNode)BTNamedLink { name = template.name, data = template });
+ nameSpace->classes.Add((BTNode)BTNamedLink { name = (char *)template.name, data = template });
}
}
memset((byte *)_class.data + offsetClass, 0, sizeClass);
}
- delete _class.dataTypeString;
+ delete (void *)_class.dataTypeString;
_class.dataTypeString = CopyString(dataTypeString);
_class.defaultAlignment = base ? base.defaultAlignment : 0;
{
DataMember member;
BTNamedLink namedLink;
- delete parentMember.name;
- delete parentMember.dataTypeString;
+ delete (void *)parentMember.name;
+ delete (void *)parentMember.dataTypeString;
while((member = parentMember.members.first))
{
switch(param.type)
{
case type:
- delete template.templateArgs[id].dataTypeString;
+ delete (void *)template.templateArgs[id].dataTypeString;
break;
case identifier:
- delete template.templateArgs[id].memberString;
+ delete (void *)template.templateArgs[id].memberString;
break;
case expression:
switch(param.type)
{
case type:
- delete template.templateArgs[id].dataTypeString;
+ delete (void *)template.templateArgs[id].dataTypeString;
break;
case identifier:
- delete template.templateArgs[id].memberString;
+ delete (void *)template.templateArgs[id].memberString;
break;
case expression:
// delete template.templateArgs[id].dataTypeString;
}
FreeTemplateArgs(template);
- delete template.fullName;
- delete template.name;
- delete template.templateArgs;
- delete template.dataTypeString;
+ delete (void *)template.fullName;
+ delete (void *)template.name;
+ delete (void *)template.templateArgs;
+ delete (void *)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;
+ delete (void *)_class.dataTypeString;
while((template = _class.templatized.first))
{
{
if(!member.isProperty && (member.type == unionMember || member.type == structMember))
DataMember_Free(member);
- delete member.name;
- delete member.dataTypeString;
+ delete (void *)member.name;
+ delete (void *)member.dataTypeString;
_class.membersAndProperties.Delete(member);
}
while((member = _class.conversions.first))
{
- delete member.name;
- delete member.dataTypeString;
+ delete (void *)member.name;
+ delete (void *)member.dataTypeString;
_class.conversions.Delete(member);
}
while((classProp = (ClassProperty)_class.classProperties.first))
{
- delete classProp.name;
- delete classProp.dataTypeString;
+ delete (void *)classProp.name;
+ delete (void *)classProp.dataTypeString;
_class.classProperties.Delete((BTNode)classProp);
}
while((method = (Method)_class.methods.first))
{
- delete method.name;
- delete method.dataTypeString;
+ delete (void *)method.name;
+ delete (void *)method.dataTypeString;
_class.methods.Delete((BTNode)method);
}
_class.nameSpace->classes.Delete((BTNode)link);
}
- delete _class.name;
- delete _class.fullName;
+ delete (void *)_class.name;
+ delete (void *)_class.fullName;
- delete _class.dataTypeString;
+ delete (void *)_class.dataTypeString;
delete _class.data;
switch(param.type)
{
case type:
- delete param.defaultArg.dataTypeString;
+ delete (void *)param.defaultArg.dataTypeString;
break;
case identifier:
- delete param.defaultArg.memberString;
+ delete (void *)param.defaultArg.memberString;
break;
case expression:
break;
}
- if(param.type != identifier) delete param.dataTypeString;
- delete param.name;
+ if(param.type != identifier) delete (void *)param.dataTypeString;
+ delete (void *)param.name;
_class.templateParams.Delete(param);
}
_free(_class);
}
-static BTNamedLink ScanNameSpace(NameSpace nameSpace, char * name, void * listOffset)
+static BTNamedLink ScanNameSpace(NameSpace nameSpace, const char * name, void * listOffset)
{
- BinaryTree * tree = (BinaryTree *)((byte *)nameSpace + (uint)listOffset);
+ BinaryTree * tree = (BinaryTree *)((byte *)nameSpace + (uintptr)listOffset);
BTNamedLink link = (BTNamedLink)tree->Find((uintptr)name);
NameSpace * child;
if(!link)
return link;
}
-static BTNamedLink SearchNameSpace(NameSpace nameSpace, char * name, void * listOffset)
+static BTNamedLink SearchNameSpace(NameSpace nameSpace, const char * name, void * listOffset)
{
int start = 0, c;
char ch;
return null;
}
-static BTNamedLink SearchModule(Module module, char * name, void * listOffset, bool searchPrivate)
+static BTNamedLink SearchModule(Module module, const char * name, void * listOffset, bool searchPrivate)
{
SubModule subModule;
BTNamedLink link;
return null;
}
-public int64 _strtoi64(char * string, char ** endString, int base)
+public int64 _strtoi64(const char * string, const char ** endString, int base)
{
int64 value = 0;
int sign = 1;
return sign*value;
}
-public uint64 _strtoui64(char * string, char ** endString, int base)
+public uint64 _strtoui64(const char * string, const char ** endString, int base)
{
uint64 value = 0;
int sign = 1;
return sign*value;
}
-public dllexport Class eSystem_FindClass(Module module, char * name)
+public dllexport Class eSystem_FindClass(Module module, const char * name)
{
if(name && module)
{
BTNamedLink link;
+ if(!strncmp(name, "const ", 6)) name += 6;
link = SearchNameSpace(&module.application.systemNameSpace, name, &((NameSpace *)0)->classes);
if(link) return link.data;
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.nameSpace->classes.Add((BTNode)BTNamedLink { name = (char *)templatedClass.name, data = templatedClass });
templatedClass.templateArgs = null;
templatedClass.numParams = 0;
templatedClass.derivatives = { };
}
}
-static void ComputeClassParameters(Class templatedClass, char * templateParams, Module findModule)
+static void ComputeClassParameters(Class templatedClass, const char * templateParams, Module findModule)
{
char ch;
- char * nextParamStart = templateParams ? (templateParams + 1) : null;
+ const char * nextParamStart = templateParams ? (templateParams + 1) : null;
ClassTemplateParameter curParam = null;
Class lastClass = null, sClass;
int curParamID = 0;
while(nextParamStart)
{
- char * paramStart = nextParamStart;
- char * paramEnd;
+ const char * paramStart = nextParamStart;
+ const char * paramEnd;
int level = 0;
while(*paramStart == ' ') paramStart++;
paramEnd = paramStart;
while(*paramEnd == ' ') paramEnd--;
if(paramEnd > paramStart)
{
- char * ptr, * equal = null;
+ const char * ptr, * equal = null;
for(ptr = paramStart; ptr <= paramEnd; ptr++)
{
if(*ptr == '=')
}
if(equal)
{
- char * end = equal - 1;
+ const char * end = equal - 1;
char ident[1024];
while(*end == ' ') end--;
}
}
{
- int len = strlen(templateString);
+ int len = (int)strlen(templateString);
if(templateString[len-1] == '>') templateString[len++] = ' ';
templateString[len++] = '>';
templateString[len++] = '\0';
if(param.type == identifier && arg->memberString)
{
Class memberClass = templatedClass;
- char * memberString = arg->memberString;
- char * colon = strstr(memberString, "::");
- char * memberName = memberString;
+ const char * memberString = arg->memberString;
+ const char * colon = strstr(memberString, "::");
+ const char * memberName = memberString;
if(colon) memberName = colon + 2;
if(!colon)
{
return false;
}
-static void FixDerivativeVirtualMethod(Class base, char * name, int vid, void * origFunction, char * type)
+static void FixDerivativeVirtualMethod(Class base, const char * name, int vid, void * origFunction, const char * type)
{
OldLink derivative;
for(derivative = base.derivatives.first; derivative; derivative = derivative.next)
if(!method.symbol)
{
- delete method.name;
- delete method.dataTypeString;
+ delete (void *)method.name;
+ delete (void *)method.dataTypeString;
_class.methods.Delete((BTNode)method);
}
else
{
- delete method.dataTypeString;
+ delete (void *)method.dataTypeString;
method.type = virtualMethod;
method.dataTypeString = CopyString(type);
method._class = base;
}
}
-public dllexport Method eClass_AddMethod(Class _class, char * name, char * type, void * function, AccessMode declMode)
+public dllexport Method eClass_AddMethod(Class _class, const char * name, const char * type, void * function, AccessMode declMode)
{
if(_class && !_class.comRedefinition && name)
{
Class base;
for(base = _class; base; base = base.base)
{
- Method method = (Method)base.methods.FindString(name);
+ Method method;
+ if(base.templateClass) base = base.templateClass;
+ method = (Method)base.methods.FindString(name);
if(method)
{
- // If this overides a virtual method
+ // If this overrides a virtual method
if(method.type == virtualMethod)
{
OldLink deriv;
return null;
}
-public dllexport Method eClass_AddVirtualMethod(Class _class, char * name, char * type, void * function, AccessMode declMode)
+public dllexport Method eClass_AddVirtualMethod(Class _class, const char * name, const char * type, void * function, AccessMode declMode)
{
if(_class && !_class.comRedefinition && name)
{
}
_property.selfWatchable = true;
- delete prop.name;
- delete prop.dataTypeString;
+ delete (void *)prop.name;
+ delete (void *)prop.dataTypeString;
_class.membersAndProperties.Delete(prop);
_class.prop.Delete((BTNode)link);
}
}
}
-public dllexport Property eClass_AddProperty(Class _class, char * name, char * dataType, void * setStmt, void * getStmt, AccessMode declMode)
+public dllexport Property eClass_AddProperty(Class _class, const char * name, const char * dataType, void * setStmt, void * getStmt, AccessMode declMode)
{
Property _property = null;
if(_class)
{
BTNamedLink link = (BTNamedLink)_class.prop.FindString(name ? name : dataType);
+ bool isConversion = name ? false : true;
+ if(!name && dataType && !strncmp(dataType, "const ", 6))
+ {
+ name = dataType + 6;
+ isConversion = true;
+ }
if(link)
_property = link.data;
if(!_property)
dataTypeString = CopyString(dataType);
_class = _class;
compiled = true;
- conversion = name ? false : true;
+ conversion = isConversion;
memberAccess = declMode;
};
- if(name)
+ if(!isConversion)
_class.membersAndProperties.Add(_property);
else
_class.conversions.Add(_property);
}
}
-public dllexport ClassProperty eClass_AddClassProperty(Class _class, char * name, char * dataType, void * setStmt, void * getStmt)
+public dllexport ClassProperty eClass_AddClassProperty(Class _class, const char * name, const char * dataType, void * setStmt, void * getStmt)
{
if(name && !_class.classProperties.FindString(name))
{
return classFindTotalTime;
}
*/
-public dllexport ClassProperty eClass_FindClassProperty(Class _class, char * name)
+public dllexport ClassProperty eClass_FindClassProperty(Class _class, const char * name)
{
//Time startTime = GetTime();
ClassProperty _property = null;
return _property;
}
-public dllexport int64 eClass_GetProperty(Class _class, char * name)
+public dllexport int64 eClass_GetProperty(Class _class, const char * name)
{
ClassProperty _property = eClass_FindClassProperty(_class, name);
if(_property && _property.Get && _property.Get != (void *)1)
return 0;
}
-public dllexport void eClass_SetProperty(Class _class, char * name, int64 value)
+public dllexport void eClass_SetProperty(Class _class, const char * name, int64 value)
{
ClassProperty _property = eClass_FindClassProperty(_class, name);
if(_property)
}
else
{
- _class.delayedCPValues.Add(NamedLink64 { name = name, value });
+ _class.delayedCPValues.Add(NamedLink64 { name = (char *)name, value });
}
}
-public dllexport Method eClass_FindMethod(Class _class, char * name, Module module)
+public dllexport Method eClass_FindMethod(Class _class, const char * name, Module module)
{
//Time startTime = GetTime();
if(_class && name)
}
}
-public dllexport Property eClass_FindProperty(Class _class, char * name, Module module)
+public dllexport Property eClass_FindProperty(Class _class, const char * name, Module module)
{
//Time startTime = GetTime();
if(_class && name)
{
+ if(!strncmp(name, "const ", 6))
+ name += 6;
+
for(; _class; _class = _class.base)
{
BTNamedLink link;
return null;
}
-static DataMember FindDataMember(OldList list, BinaryTree alist, char * name, uint * offset, int * id, bool searchPrivate, DataMember * subMemberStack, int * subMemberStackPos)
+static DataMember FindDataMember(OldList list, BinaryTree alist, const char * name, uint * offset, int * id, bool searchPrivate, DataMember * subMemberStack, int * subMemberStackPos)
{
BTNamedLink link;
DataMember dataMember;
return null;
}
-public dllexport DataMember eClass_FindDataMember(Class _class, char * name, Module module, DataMember * subMemberStack, int * subMemberStackPos)
+public dllexport DataMember eClass_FindDataMember(Class _class, const char * name, Module module, DataMember * subMemberStack, int * subMemberStackPos)
{
//Time startTime = GetTime();
DataMember dataMember = null;
return dataMember;
}
-public dllexport DataMember eClass_FindDataMemberAndOffset(Class _class, char * name, uint * offset, Module module, DataMember * subMemberStack, int * subMemberStackPos)
+public dllexport DataMember eClass_FindDataMemberAndOffset(Class _class, const char * name, uint * offset, Module module, DataMember * subMemberStack, int * subMemberStackPos)
{
//Time startTime = GetTime();
DataMember dataMember = null;
return dataMember;
}
-public dllexport DataMember eClass_FindDataMemberAndId(Class _class, char * name, int * id, Module module, DataMember * subMemberStack, int * subMemberStackPos)
+public dllexport DataMember eClass_FindDataMemberAndId(Class _class, const char * name, int * id, Module module, DataMember * subMemberStack, int * subMemberStackPos)
{
//Time startTime = GetTime();
DataMember dataMember = null;
}
}
-public dllexport void eInstance_SetMethod(Instance instance, char * name, void * function) // YET TO BE DECIDED: , Module module)
+public dllexport void eInstance_SetMethod(Instance instance, const char * name, void * function) // YET TO BE DECIDED: , Module module)
{
if(instance && name)
{
FixOffsets(deriv.data);
}
-public dllexport DataMember eClass_AddDataMember(Class _class, char * name, char * type, unsigned int size, unsigned int alignment, AccessMode declMode)
+public dllexport DataMember eClass_AddDataMember(Class _class, const char * name, const char * type, unsigned int size, unsigned int alignment, AccessMode declMode)
{
if(_class && name)
{
return null;
}
-public dllexport DataMember eMember_AddDataMember(DataMember member, char * name, char * type, unsigned int size, unsigned int alignment, AccessMode declMode)
+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))
{
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);
+ }
+
if(addTo.type == unionMember)
{
if(dataMember.memberOffset > addTo.memberOffset)
_class.memberID += 1;
else
_class.memberID += dataMember.memberID;
+
+ if(dataMember.structAlignment)
+ {
+ _class.structAlignment = Max(_class.structAlignment, dataMember.structAlignment);
+
+ if(_class.memberOffset % dataMember.structAlignment)
+ _class.memberOffset += dataMember.structAlignment - (_class.memberOffset % dataMember.structAlignment);
+ }
+
dataMember.offset = _class.memberOffset;
_class.memberOffset += dataMember.memberOffset;
return true;
}
-public dllexport BitMember eClass_AddBitMember(Class _class, char * name, char * type, int bitSize, int bitPos, AccessMode declMode)
+public dllexport BitMember eClass_AddBitMember(Class _class, const char * name, const char * type, int bitSize, int bitPos, AccessMode declMode)
{
if(_class && name && !_class.members.FindString(name))
{
return null;
}
-static Module Module_Load(Module fromModule, char * name, AccessMode importAccess, bool ensureCOM)
+static Module Module_Load(Module fromModule, const char * name, AccessMode importAccess, bool ensureCOM)
{
bool (stdcall * Load)(Module module) = null;
bool (stdcall * Unload)(Module module) = null;
StripExtension(moduleName);
if((!strcmpi(ext, "dylib") || !strcmpi(ext, "so")) && strstr(moduleName, "lib") == moduleName)
{
- int len = strlen(moduleName) - 3;
+ int len = (int)strlen(moduleName) - 3;
memmove(moduleName, moduleName + 3, len);
moduleName[len] = 0;
}
return module;
}
-public dllexport Module eModule_Load(Module fromModule, char * name, AccessMode importAccess)
+public dllexport Module eModule_Load(Module fromModule, const char * name, AccessMode importAccess)
{
return Module_Load(fromModule, name, importAccess, true);
}
-public dllexport Module eModule_LoadStrict(Module fromModule, char * name, AccessMode importAccess)
+public dllexport Module eModule_LoadStrict(Module fromModule, const char * name, AccessMode importAccess)
{
return Module_Load(fromModule, name, importAccess, false);
}
-public dllexport Module eModule_LoadStatic(Module fromModule, char * name, AccessMode importAccess, bool (* Load)(Module module), bool (* Unload)(Module module))
+public dllexport Module eModule_LoadStatic(Module fromModule, const char * name, AccessMode importAccess, bool (* Load)(Module module), bool (* Unload)(Module module))
{
Module module;
for(module = fromModule.application.allModules.first; module; module = module.next)
}
}
-public dllexport void eEnum_AddFixedValue(Class _class, char * string, int value)
+public dllexport void eEnum_AddFixedValue(Class _class, const char * string, int value)
{
if(_class && _class.type == enumClass)
{
}
}
-public dllexport int eEnum_AddValue(Class _class, char * string)
+public dllexport int eEnum_AddValue(Class _class, const char * string)
{
if(_class && _class.type == enumClass)
{
static void NameSpace_Free(NameSpace parentNameSpace)
{
NameSpace * nameSpace;
- delete parentNameSpace.name;
+ delete (void *)parentNameSpace.name;
while((nameSpace = (NameSpace *)parentNameSpace.nameSpaces.first))
{
break;
}
}
- delete def.name;
- delete def.value;
+ delete (void *)def.name;
+ delete (void *)def.value;
module.defines.Delete(def);
}
break;
}
}
- delete function.name;
- delete function.dataTypeString;
+ delete (void *)function.name;
+ delete (void *)function.dataTypeString;
module.functions.Delete(function);
}
- delete module.name;
+ delete (void *)module.name;
NameSpace_Free(module.privateNameSpace);
NameSpace_Free(module.publicNameSpace);
}
#endif
-public dllexport DefinedExpression eSystem_RegisterDefine(char * name, char * value, Module module, AccessMode declMode)
+public dllexport DefinedExpression eSystem_RegisterDefine(const char * name, const char * value, Module module, AccessMode declMode)
{
NameSpace * nameSpace = null;
}
}
else
- c = strlen(name);
+ c = (int)strlen(name);
if(c - start && !nameSpace->defines.FindString(name + start))
{
return null;
}
-public dllexport GlobalFunction eSystem_RegisterFunction(char * name, char * type, void * func, Module module, AccessMode declMode)
+public dllexport GlobalFunction eSystem_RegisterFunction(const char * name, const char * type, void * func, Module module, AccessMode declMode)
{
NameSpace * nameSpace = null;
int start = 0, c;
}
}
else
- c = strlen(name);
+ c = (int)strlen(name);
if(c - start && !nameSpace->functions.FindString(name + start))
{
return null;
}
-public dllexport DefinedExpression eSystem_FindDefine(Module module, char * name)
+public dllexport DefinedExpression eSystem_FindDefine(Module module, const char * name)
{
if(name && module)
{
return null;
}
-public dllexport GlobalFunction eSystem_FindFunction(Module module, char * name)
+public dllexport GlobalFunction eSystem_FindFunction(Module module, const char * name)
{
if(name && module)
{
}
}
-public dllexport void eProperty_SelfWatch(Class _class, char * name, void (*callback)(void *))
+public dllexport void eProperty_SelfWatch(Class _class, const char * name, void (*callback)(void *))
{
if(_class)
{
return null;
}
-public bool LocateModule(char * name, char * fileName)
+public bool LocateModule(const char * name, const char * fileName)
{
return Instance_LocateModule(name, fileName);
}
eClass_AddClassProperty(enumClass, "enumSize", "int", null, GetEnumSize).constant = true;
enumClass.type = systemClass;
- delete enumClass.dataTypeString;
+ delete (void *)enumClass.dataTypeString;
enumClass.dataTypeString = CopyString(/*"unsigned int"*/"int");
// Create Struct (simple) class
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, "Load", "Module(const char * name, AccessMode importAccess)", eModule_Load, publicAccess);
eClass_AddMethod(moduleClass, "Unload", "void(Module module)", eModule_Unload, 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, "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, "name", "const 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_AddVirtualMethod(applicationClass, "Main", "void()", null, publicAccess);
eClass_AddDataMember(applicationClass, "argc", "int", sizeof(int), 4, publicAccess);
- eClass_AddDataMember(applicationClass, "argv", "char **", pointerSize, pointerSize, publicAccess);
+ eClass_AddDataMember(applicationClass, "argv", "const 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", force64Bits ? 32 : force32Bits ? 20 : sizeof(OldList), pointerSize, publicAccess);
eSystem_RegisterFunction("asin", "Angle asin(double number)", asin, module, baseSystemAccess);
eSystem_RegisterFunction("acos", "Angle acos(double number)", acos, module, baseSystemAccess);
eSystem_RegisterFunction("atan", "Angle atan(double number)", atan, module, baseSystemAccess);
+ eSystem_RegisterFunction("asinh", "Angle asinh(double number)", asinh, module, baseSystemAccess);
+ eSystem_RegisterFunction("acosh", "Angle acosh(double number)", acosh, module, baseSystemAccess);
+ eSystem_RegisterFunction("atanh", "Angle atanh(double number)", atanh, module, baseSystemAccess);
eSystem_RegisterFunction("pow", "double pow(double number, double number2)", pow, module, baseSystemAccess);
eSystem_RegisterFunction("fmod", "double fmod(double x, double y)", fmod, module, baseSystemAccess);
eSystem_RegisterFunction("fabs", "double fabs(double number)", fabs, module, baseSystemAccess);
// --- Stdlib ---
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("strtod", "double strtod(const char*, char**)", strtod, module, baseSystemAccess);
+ eSystem_RegisterFunction("strtol", "int strtol(const 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", "double atof(const char*)", atof, 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_RegisterFunction("strspn", "uintsize strspn(const char *, const char *)", strspn, 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_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);
+ eSystem_RegisterFunction("memcmp", "int memcmp(const void *, const void *, uintsize size)", memcmp, module, baseSystemAccess);
// --- Stdio ---
- eSystem_RegisterFunction("sprintf", "int sprintf(char *, char *, ...)", sprintf, module, baseSystemAccess);
- eSystem_RegisterFunction("snprintf", "int sprintf(char *, uintsize, char *, ...)", snprintf, module, baseSystemAccess);
- eSystem_RegisterFunction("printf", "int printf(char *, ...)", printf, module, baseSystemAccess);
+ eSystem_RegisterFunction("sprintf", "int sprintf(char *, const char *, ...)", sprintf, module, baseSystemAccess);
+ eSystem_RegisterFunction("snprintf", "int sprintf(char *, uintsize, const char *, ...)", snprintf, module, baseSystemAccess);
+ eSystem_RegisterFunction("printf", "int printf(const char *, ...)", printf, module, baseSystemAccess);
eSystem_RegisterFunction("vsprintf", "int vsprintf(char*, const char*, __builtin_va_list)", vsprintf, 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);
+ eSystem_RegisterFunction("puts", "int puts(const char *)", puts, module, baseSystemAccess);
+ eSystem_RegisterFunction("fputs", "int fputs(const char *, void * stream)", fputs, module, baseSystemAccess);
// --- Ctype ---
eSystem_RegisterFunction("isalnum", "int isalnum(int c)", isalnum, module, baseSystemAccess);
Instance_COM_Initialize(argc, argv, &app.parsedCommand, &app.argc, &app.argv);
app.application = app;
- app.allModules.offset = sizeof(class Instance) + (uint)&((struct Module *)0)->prev;
+ app.allModules.offset = sizeof(class Instance) + (uint)(uintptr)&((struct Module *)0)->prev;
app.isGUIApp = guiApp;
LoadCOM(app);
return app;
}
-public dllexport ClassTemplateParameter eClass_AddTemplateParameter(Class _class, char * name, TemplateParameterType type, void * info, ClassTemplateArgument defaultArg)
+public dllexport ClassTemplateParameter eClass_AddTemplateParameter(Class _class, const char * name, TemplateParameterType type, const void * info, ClassTemplateArgument defaultArg)
{
if(_class && name)
{
{
if(base)
{
- OldLink derivative;
ClassTemplateParameter param;
{
void * first = base.templateParams.first;
if(param.type == identifier && param.defaultArg.memberString)
{
Class memberClass = base;
- char * colon = strstr(param.defaultArg.memberString, "::");
- char * memberName;
+ const char * colon = strstr(param.defaultArg.memberString, "::");
+ const char * memberName;
if(colon)
{
char className[1024];
{
unknown, win32, tux, apple;
- property char *
+ property const char *
{
get { return OnGetString(null, null, null); }
set
}
};
- char * OnGetString(char * tempString, void * fieldData, bool * needClass)
+ const char * OnGetString(char * tempString, void * fieldData, bool * needClass)
{
if(this >= firstPlatform && this <= lastPlatform)
{
return null;
}
- bool OnGetDataFromString(char * string)
+ bool OnGetDataFromString(const char * string)
{
this = string;
- return (bool)this;
+ return this != unknown;
}
};
OldList instances;
ClassDefinition classDefinition;
bool modified;
+ void * i18nStrings;
};
public class DesignerBase : Window
{
public:
- virtual bool FindObject(Instance * instance, char * string);
- virtual void RenameObject(ObjectInfo object, char * name);
+ virtual bool FindObject(Instance * instance, const char * string);
+ virtual void RenameObject(ObjectInfo object, const char * name);
virtual void SelectObjectFromDesigner(ObjectInfo object);
virtual void CodeAddObject(Instance instance, ObjectInfo * object);
virtual void SheetAddObject(ObjectInfo object);
virtual void UpdateProperties(void);
ClassDesignerBase classDesigner;
- char * objectClass;
+ const char * objectClass;
bool isDragging;
// FIX THIS WITH PUBLIC:
get { return classDesigner; }
set { classDesigner = value; }
};
- property char * objectClass
+ property const char * objectClass
{
get { return objectClass; }
set { objectClass = value; }
virtual void ::DroppedObject(Instance instance, ObjectInfo object, bool isClass, Instance _class);
virtual void ::DestroyObject(Instance object);
virtual void ::FixProperty(Property prop, Instance object);
- virtual void ::CreateNew(EditBox editBox, Size clientSize, char * name, char * inherit);
+ virtual void ::CreateNew(EditBox editBox, Size clientSize, const char * name, const char * inherit);
}
DesignerBase activeDesigner;
define LEAD_OFFSET = 0xD800 - (0x10000 >> 10);
define SURROGATE_OFFSET = 0x10000 - (0xD800 << 10) - 0xDC00;
-public bool UTF8Validate(char * source)
+public bool UTF8Validate(const char * source)
{
if(source)
{
return true;
}
-public int ISO8859_1toUTF8(char * source, char * dest, int max)
+public int ISO8859_1toUTF8(const char * source, char * dest, int max)
{
int c;
int d = 0;
return d;
}
-public char * UTF16toUTF8(uint16 * source)
+public char * UTF16toUTF8(const uint16 * source)
{
int c;
int d = 0;
return dest;
}
-public int UTF16toUTF8Buffer(uint16 * source, byte * dest, int max)
+public int UTF16toUTF8Buffer(const uint16 * source, char * dest, int max)
{
int c;
int d = 0;
}
// NOTE: UTF8GetChar now returns 0 into numBytes for the null-terminating character ('\0')
-public unichar UTF8GetChar(char * string, int * numBytes)
+public unichar UTF8GetChar(const char * string, int * numBytes)
{
unichar ch;
byte b = ((byte *)string)[0];
return ch;
}
-public int UTF8toUTF16Buffer(char * source, uint16 * dest, int max)
+public int UTF8toUTF16Buffer(const char * source, uint16 * dest, int max)
{
if(source)
{
return 0;
}
-public int UTF32toUTF8Len(unichar * source, int count, byte * dest, int max)
+public int UTF32toUTF8Len(const unichar * source, int count, char * dest, int max)
{
int c;
int d = 0;
return d;
}
-public uint16 * UTF8toUTF16(char * source, int * wordCount)
+public uint16 * UTF8toUTF16(const char * source, int * wordCount)
{
if(source)
{
- int len = strlen(source);
+ int len = (int)strlen(source);
uint16 * dest = new uint16[len + 1];
int c;
int d = 0;
Ecere Software / sdk / blobdiff