import "ecdefs"
#define YYLTYPE Location
-#include "grammar.eh"
+#include "grammar.h"
extern External curExternal;
static Statement curCompound;
//strcpy(moduleName, outputFile);
GetLastDirectory(outputFile, moduleName);
StripExtension(moduleName);
- ChangeCh(moduleName, ' ', '_');
- ChangeCh(moduleName, '.', '_');
- ChangeCh(moduleName, '-', '_');
+ FixModuleName(moduleName);
sprintf(registerName, "__ecereCreateModuleInstances_%s", moduleName);
declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), null);
{
- FunctionDefinition function = MkFunction(specifiers, declarator, null);
+ FunctionDefinition function = _MkFunction(specifiers, declarator, null, false);
ProcessFunctionBody(function, createInstancesBody);
ListAdd(ast, MkExternalFunction(function));
}
declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), null);
{
- FunctionDefinition function = MkFunction(specifiers, declarator, null);
+ FunctionDefinition function = _MkFunction(specifiers, declarator, null, false);
ProcessFunctionBody(function, destroyInstancesBody);
ListAdd(ast, MkExternalFunction(function));
}
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
if(!firstID.next && thisMember == dataMember)
}
/*
- BTNamedLink link = parentMember.membersAlpha.Find((uint)firstID.string);
+ BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
if(link)
{
curMember = link.data;
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
if(thisMember == bitMember)
MkTypeName(specs, decl), MkExpBrackets(MkListOne(member.initializer.exp))))), LEFT_OP, MkExpConstant(pos))));
}
else
- part = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl),
+ part = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl),
MkExpBrackets(MkListOne(member.initializer.exp)))));
// Take it out
member.initializer.exp = null;
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
if(!firstID.next && curMember == dataMember)
- {
+ {
memberFilled = true;
break;
}
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
}
thisMember = curMember;
}
- if(thisMember || method)
+ if(instExp && (thisMember || method))
{
Expression instExpCopy = CopyExpression(instExp);
Expression setExp = null;
if(ident)
{
Expression memberExp;
+ bool freeMemberExp = false;
if(thisMember && thisMember.isProperty && ((Property)thisMember).conversion)
convert = true;
// TODO: Set the member types for those
memberExp = MkExpMember(instExpCopy, id);
for(id = id.next; id; id = id.next)
- memberExp = MkExpMember(memberExp, id);
+ memberExp = MkExpMember(memberExp, id);
}
else
memberExp = MkExpMember(instExpCopy, ident);
FreeInitializer(member.initializer);
member.initializer = null;
}
+ else
+ {
+ freeMemberExp = true;
+ // TOCHECK: WHat happens in here?
+ }
// TODO: list initializer not working...
-
memberExp.loc = inst.loc;
if(member.identifiers)
ListAdd(list, setExp);
}
+ if(freeMemberExp)
+ FreeExpression(memberExp);
}
}
}
return fullSet || convert;
}
-public void DeclareClass(Symbol classSym, char * className)
+public void DeclareClass(Symbol classSym, const char * className)
{
/*if(classSym.registered.templateClass)
{
if(!classSym.module) return;
classSym._import = ClassImport
{
- isRemote = classSym.registered ? classSym.registered.isRemote : false;
+ isRemote = classSym.registered ? classSym.registered.isRemote : 0;
name = CopyString(classSym.string);
};
classSym.module.classes.Add(classSym._import);
ListAdd(specifiers, MkStructOrUnion(structSpecifier, MkIdentifier("__ecereNameSpace__ecere__com__Class"), null));
d = MkDeclaratorPointer(MkPointer(null, null),
- MkDeclaratorIdentifier(MkIdentifier(className)));
+ MkDeclaratorIdentifier(MkIdentifier(className)));
ListAdd(declarators, MkInitDeclarator(d, null));
classSym.idCode = classSym.id;
}
}
- else if(classSym && curExternal.symbol.idCode < classSym.id)
+ else if(classSym && curExternal && curExternal.symbol.idCode < classSym.id)
//else if(curExternal.symbol.id <= classSym.id)
{
// DANGER: (Moved here)
OldList list = { 0 };
ProcessInstMembers(inst, null, &list, false);
-
+
ProcessExpression(inst.exp);
//Why was this here twice? ProcessInstMembers(inst, null, &list);
Expression e;
ProcessInstMembers(inst, null, &list, false);
-
+
ProcessExpression(inst.exp);
//Why was this here twice? ProcessInstMembers(inst, null, &list);
inst.exp = null;
list.Remove(list.first);
- while(e = list.first)
+ while((e = list.first))
{
list.Remove(e);
FreeExpression(e);
exp.expType = expType;
exp.prev = prev;
exp.next = next;
- while(e = list.first)
+ while((e = list.first))
{
list.Remove(e);
FreeExpression(e);
exp.list = MkList();
ProcessInstMembers(inst, inst.exp, exp.list, false);
-
+
ProcessExpression(inst.exp);
if(!exp.list->count)
{
- exp.type = (ExpressionType)1000; // remove expression
+ exp.type = dummyExp; // remove expression
+ delete exp.list;
}
- // Take expression out...
- inst.exp = null;
+ // Take expression out... -- It seems ProcessInstMembers() makes copies of it and it needs to be freed now
+ // inst.exp = null;
}
else
{
{
Expression newCall;
- if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
+ if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
(classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
{
char size[256];
char ecereTemp[100];
MembersInit members;
int tempCount = exp.tempCount;
- Expression tmpExp;
-
+ OldList * expList;
+
// Check if members use temp count...
for(members = inst.members->first; members; members = members.next)
{
}
}
if(curDecl)
- {
tempCount = Max(tempCount, declTempCount);
- }
-
+
tempCount++;
curExternal.function.tempCount = Max(curExternal.function.tempCount, tempCount);
- sprintf(ecereTemp, "__ecereTemp%d", tempCount);
-
- // (__ecereTemp = eInstance_New(_class), __ecerePropclass_Set( ), __ecereTemp)
-
- /*
- instExp = MkExpBrackets(MkListOne(MkExpCast(QMkClass(inst._class.name, null), (tmpExp = QMkExpId(ecereTemp), tmpExp.byReference = true, tmpExp))));
- //instExp = QMkExpId(ecereTemp);
+ sprintf(ecereTemp, "__ecereInstance%d", tempCount);
+ exp.type = extensionCompoundExp;
+ exp.compound = MkCompoundStmt(null, null);
+ exp.compound.compound.context = PushContext();
+ exp.compound.compound.context.simpleID = exp.compound.compound.context.parent.simpleID;
+ exp.compound.compound.declarations = MkListOne(QMkDeclaration(inst._class.name, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(ecereTemp)),
+ MkInitializerAssignment(newCall))));
+ exp.compound.compound.statements = MkListOne(MkExpressionStmt((expList = MkList())));
+
+ instExp = QMkExpId(ecereTemp);
instExp.tempCount = tempCount;
-
- exp.type = bracketsExp;
- exp.list = MkList();
-
- ListAdd(exp.list, MkExpOp(instExp, '=', newCall));
- */
-
- instExp = MkExpBrackets(MkListOne(MkExpCast(QMkClass(inst._class.name, null), (tmpExp = QMkExpId(ecereTemp), tmpExp.byReference = true, tmpExp))));
-
- instExp.tempCount = tempCount;
- exp.type = bracketsExp;
- exp.list = MkList();
-
- ListAdd(exp.list, MkExpOp((tmpExp = QMkExpId(ecereTemp), tmpExp.byReference = true, tmpExp), '=', newCall));
-
instExp.expType = MkClassType(inst._class.name);
-
- ProcessInstMembers(inst, instExp, exp.list, false);
-
+ instExp.byReference = true;
+ ProcessInstMembers(inst, instExp, expList, false);
FreeExpression(instExp);
- ProcessExpression(tmpExp);
-
- // TEST: exp.tempCount = Max(exp.tempCount, instExp.tempCount);
-
if(exp.usage)
- //ListAdd(exp.list, QMkExpId(ecereTemp));
- ListAdd(exp.list, MkExpBrackets(MkListOne(MkExpCast(QMkClass(inst._class.name, null), (tmpExp = QMkExpId(ecereTemp), tmpExp.byReference = true, tmpExp)))));
+ {
+ Expression tmpExp = QMkExpId(ecereTemp);
+ tmpExp.byReference = true;
+ ListAdd(expList, tmpExp);
+ }
exp.tempCount = tempCount;
if(curDecl)
- {
declTempCount = Max(declTempCount, tempCount);
- }
+ PopContext(exp.compound.compound.context);
}
else
{
break;
case opExp:
{
- bool assign = false;
+ //bool assign = false;
switch(exp.op.op)
{
// Assignment Operators
- case '=':
+ case '=':
if(exp.op.exp2)
exp.op.exp2.usage.usageGet = true;
if(exp.op.exp1)
exp.op.exp1.usage.usageSet = true;
- assign = true;
+ //assign = true;
break;
case MUL_ASSIGN:
case DIV_ASSIGN:
case OR_ASSIGN:
if(exp.op.exp2)
exp.op.exp2.usage.usageGet = true;
- assign = true;
+ //assign = true;
if(exp.op.exp1)
exp.op.exp1.usage.usageSet = true;
break;
case '|':
case '^':
case AND_OP:
- case OR_OP:
+ case OR_OP:
if(exp.op.exp1)
exp.op.exp1.usage.usageGet = true;
if(exp.op.exp2)
Context context = PushContext();
sprintf(iteratorType, "Iterator<%s, %s >", _class.templateArgs[2].dataTypeString, _class.templateArgs[1].dataTypeString);
-
+
ListAdd(instMembers, MkMemberInit(null, MkInitializerAssignment(exp.index.exp)));
-
+
ListAdd(declarations, MkDeclarationInst(MkInstantiationNamed(MkListOne(MkSpecifierName(iteratorType)),
MkExpIdentifier(MkIdentifier("__internalIterator")), MkListOne(MkMembersInitList(instMembers)))));
ListAdd(args, MkExpBrackets(exp.index.index));
ListAdd(args, exp.usage.usageSet ? MkExpIdentifier(MkIdentifier("true")) : MkExpIdentifier(MkIdentifier("false")));
-
- ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")),
+
+ ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")),
MkIdentifier("Index")), args))));
ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(null, '&', MkExpIdentifier(MkIdentifier("__internalIterator"))))));
case callExp:
{
Expression e;
- Method method = null;
+ //Method method = null;
ProcessExpression(exp.call.exp);
}
}
}
- if(!prop && !member)
+ if(!prop && !member && !method) // NOTE: Recently added the !method here, causes private methods to unprioritized
method = eClass_FindMethod(_class, exp.member.member.string, privateModule);
if(!prop && !member && !method)
{
revConvert = eClass_FindProperty(convertClass, _class.fullName, privateModule);
}
}
-
+
if(prop)
{
exp.member.memberType = propertyMember;
if(!method.dataType)
//method.dataType = ((Symbol)method.symbol).type;
ProcessMethodType(method);
-
+
FreeType(exp.expType);
exp.expType = method.dataType;
if(method.dataType) method.dataType.refCount++;
exp.expType = MkClassType(revConvert._class.fullName);
}/*
else
- printf("Error: Couldn't find member %s in class %s\n",
+ printf($"Error: Couldn't find member %s in class %s\n",
exp.member.member.string, _class.name);*/
}
}
case extensionCompoundExp:
{
if(exp.compound.compound.statements &&
- ((Statement)exp.compound.compound.statements->last).type == expressionStmt &&
+ ((Statement)exp.compound.compound.statements->last).type == expressionStmt &&
+ ((Statement)exp.compound.compound.statements->last).expressions &&
((Statement)exp.compound.compound.statements->last).expressions->last)
{
((Expression)((Statement)exp.compound.compound.statements->last).expressions->last).usage = exp.usage;
ProcessExpression(exp.vaArg.exp);
break;
}
+ case extensionInitializerExp:
+ {
+ ProcessInitializer(exp.initializer.initializer);
+ break;
+ }
}
CheckTemplateTypes(exp);
}
}
}
-static bool ProcessBracketInst_DataMember(DataMember parentMember, Instantiation inst, OldList list)
+static bool ProcessBracketInst_DataMember(DataMember parentMember, Instantiation inst, OldList list, DataMember namedParentMember, bool parentMemberSet)
{
Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
DataMember dataMember = null;
if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
{
- if(!ProcessBracketInst_DataMember(dataMember, inst, list))
+ OldList * subList = 0; //(dataMember.type == structMember) ? MkList() : null;
+
+ if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember.name ? dataMember : namedParentMember, someMemberSet || parentMemberSet))
+ {
+ if(subList)
+ FreeList(subList, FreeInitializer);
+
return false;
+ }
+ if(subList && subList->count)
+ {
+ ListAdd(list, MkInitializerList(subList));
+ someMemberSet = true;
+ }
+ else
+ {
+ if(list.count)
+ someMemberSet = true;
+ delete subList;
+ }
}
- else
+ else
{
Class curClass = null;
DataMember curMember = null;
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
/*
- BTNamedLink link = parentMember.membersAlpha.Find((uint)firstID.string);
+ BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
if(link)
{
curMember = link.data;
// *** THE IDENTIFIERS WERE BEING REUSED, CAUSING A CRASH WITH EXPRESSION TEMPLATE CODE IN pass1.ec ***
// members->Add(MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
/*member.identifiers->Remove(firstID);*/
- ListAdd(partList,
+ ListAdd(partList,
MkMemberInit(/*member.identifiers*/identifiers, MkInitializerAssignment(member.initializer.exp)));
}
-
+
for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
{
if(!nextMembers.dataMembers)
nextMember = next, next = nextMember ? nextMember.next : null)
{
Identifier nextID = nextMember.identifiers->first;
- if(nextMember.identifiers &&
+ if(nextMember.identifiers &&
nextMember.identifiers->count > 1 &&
!strcmp(firstID.string, nextID.string))
{
}
}
- member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
+ member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
MkListOne(MkMembersInitList(partList))));
}
found = true;
if(member && member.initializer && member.initializer.type == expInitializer)
{
- Expression memberExp = null;
+ Initializer init { loc = yylloc };
+ if(namedParentMember.type == unionMember && dataMember.name)
+ init.id = MkIdentifier(dataMember.name);
+
if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
member.initializer.exp.expType._class.registered.type == structClass)
{
OldList * subList = MkList();
ProcessBracketInst(member.initializer.exp.instance, subList);
FreeExpression(member.initializer.exp);
- ListAdd(list, MkInitializerList(subList));
+ if(subList->count)
+ {
+ init.type = listInitializer;
+ init.list = subList;
+ }
+ else
+ {
+ FreeInitializer(init);
+ init = null;
+ }
}
else
{
member.initializer.exp.usage.usageGet = true;
ProcessExpression(member.initializer.exp);
- ListAdd(list, MkInitializerAssignment(member.initializer.exp));
+ init.type = expInitializer;
+ init.exp = member.initializer.exp;
}
+ if(init)
+ ListAdd(list, init);
+
member.initializer.exp = null;
FreeInitializer(member.initializer);
member.initializer = null;
}
else if(member && member.initializer && member.initializer.type == listInitializer)
{
+ if(namedParentMember.type == unionMember && dataMember.name)
+ member.initializer.id = MkIdentifier(dataMember.name);
+
ListAdd(list, member.initializer);
member.initializer = null;
someMemberSet = true;
}
- else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/ && parentMember.type != unionMember)
+ else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/ && parentMember.type != unionMember && namedParentMember.type != unionMember)
{
Symbol classSym;
+ Initializer init { loc = yylloc };
+ if(namedParentMember.type == unionMember && dataMember.name)
+ init.id = MkIdentifier(dataMember.name);
+
if(!dataMember.dataType)
dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
if(classSym && classSym.registered && classSym.registered.type == structClass)
{
OldList * subList = MkList();
- Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
+ Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
Instantiation inst = MkInstantiation(spec, null, null);
ProcessBracketInst(inst, subList);
FreeInstance(inst);
- ListAdd(list, MkInitializerList(subList));
+ if(subList->count)
+ {
+ init.type = listInitializer;
+ init.list = subList;
+ }
+ else
+ {
+ FreeInitializer(init);
+ init = null;
+ }
}
else
- ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
+ {
+ init.type = expInitializer;
+ init.exp = MkExpConstant("0");
+ }
+ someMemberSet = true;
+ if(init)
+ ListAdd(list, init);
}
}
/*
*/
}
// TESTING THIS NEW CODE FOR ANCHORS...
- if(parentMember.type == unionMember && !someMemberSet)
+ if(parentMember.type == unionMember && !someMemberSet && !parentMemberSet)
{
Symbol classSym;
+ Initializer init { loc = yylloc };
+
dataMember = parentMember.members.first;
+ if(namedParentMember.type == unionMember && dataMember.name)
+ init.id = MkIdentifier(dataMember.name);
+
if(!dataMember.dataType && dataMember.dataTypeString)
dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
if(classSym && classSym.registered && classSym.registered.type == structClass)
{
OldList * subList = MkList();
- Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
+ Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
Instantiation inst = MkInstantiation(spec, null, null);
ProcessBracketInst(inst, subList);
FreeInstance(inst);
- ListAdd(list, MkInitializerList(subList));
+ init.type = listInitializer;
+ init.list = subList;
}
else
- ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
+ {
+ init.type = expInitializer;
+ init.exp = MkExpConstant("0");
+ }
+ ListAdd(list, init);
}
return true;
}
{
if(!dataMember.isProperty && !dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
{
- if(!ProcessBracketInst_DataMember(dataMember, inst, list))
+ OldList * subList = 0 /*(dataMember.type == structMember ? MkList() : null)*/;
+
+ if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, false))
{
+ if(subList)
+ FreeList(subList, FreeInitializer);
recursionCount--;
return false;
}
+ if(dataMember.type == structMember || (subList && subList->count))
+ ListAdd(list, MkInitializerList(subList));
+ else
+ delete subList;
}
- else
+ else
{
MembersInit members;
MemberInit member = null;
{
curMember = thisMember;
curClass = curMember._class;
- memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
+ memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
subMemberStackPos = _subMemberStackPos;
}
{
if(dataMember.isProperty)
{
- if(!((Property)dataMember).Set)
+ if(!((Property)dataMember).Set)
{
- Compiler_Error("No set defined for property %s\n", dataMember.name);
+ Compiler_Error($"No set defined for property %s\n", dataMember.name);
continue;
}
recursionCount--;
if(!dataMember.dataType)
dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
- spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
+ spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
member.identifiers->Remove(firstID);
- ListAdd(partList,
+ ListAdd(partList,
MkMemberInit(member.identifiers, MkInitializerAssignment(member.initializer.exp)));
for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
nextMember = next, next = nextMember ? nextMember.next : null)
{
Identifier nextID = nextMember.identifiers->first;
- if(nextMember.identifiers &&
+ if(nextMember.identifiers &&
nextMember.identifiers->count > 1 &&
!strcmp(firstID.string, nextID.string))
{
}
}
- member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
+ member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
MkListOne(MkMembersInitList(partList))));
// TESTING THIS
{
if(dataMember.isProperty)
{
- if(!((Property)dataMember).Set)
+ if(!((Property)dataMember).Set)
{
- Compiler_Error("No set defined for property %s\n", dataMember.name);
+ Compiler_Error($"No set defined for property %s\n", dataMember.name);
continue;
}
recursionCount--;
if(dataMember.isProperty) continue;
if(member && member.initializer && member.initializer.type == expInitializer)
{
- Expression memberExp = null;
if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
member.initializer.exp.expType._class && member.initializer.exp.expType._class.registered && member.initializer.exp.expType._class.registered.type == structClass)
{
OldList * subList = MkList();
ProcessBracketInst(member.initializer.exp.instance, subList);
FreeExpression(member.initializer.exp);
+ member.initializer.exp = null;
ListAdd(list, MkInitializerList(subList));
}
else
{
member.initializer.exp.usage.usageGet = true;
ProcessExpression(member.initializer.exp);
- ListAdd(list, MkInitializerAssignment(member.initializer.exp));
+ ListAdd(list, MkInitializerAssignment(CopyExpression(member.initializer.exp)));
}
// Take this out
if(classSym && classSym.registered && classSym.registered.type == structClass)
{
OldList * subList = MkList();
- Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
+ Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
Instantiation inst = MkInstantiation(spec, null, null);
ProcessBracketInst(inst, subList);
FreeInstance(inst);
{
if(member.takeOutExp)
{
- member.initializer.exp = null;
FreeInitializer(member.initializer);
member.initializer = null;
}
case instDeclaration:
{
Instantiation inst = decl.inst;
-
+
if(inCompiler)
{
Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
if(classSym && classSym.registered && (classSym.registered.type == normalClass))
{
- ListAdd(createInstancesBody.compound.statements,
+ ListAdd(createInstancesBody.compound.statements,
MkExpressionStmt(MkListOne(MkExpCall(
MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")),
MkListOne(CopyExpression(inst.exp))))));
CreateInstancesBody();
}
}
-
+
{
char className[1024];
-
+ className[0] = 0;
+
decl.type = initDeclaration;
decl.specifiers = MkList();
decl.declarators = MkList();
-
+
// Replace instantiation here
if(classSym && classSym.registered && classSym.registered.type == bitClass)
{
if(inst.fullSet)
{
ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
- ListAdd(decl.declarators,
+ ListAdd(decl.declarators,
MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier), null));
inst.exp.identifier = null;
}
- else
+ else
{
OldList * list = MkList();
if(ProcessBracketInst(inst, list))
{
Expression newCall;
- if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
+ strcpy(className, "__ecereClass_");
+
+ if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
+ {
+ classSym = FindClass(classSym.registered.templateClass.fullName);
+ FullClassNameCat(className, classSym.string, true);
+ }
+ else
+ FullClassNameCat(className, inst._class.name, true);
+ MangleClassName(className);
+
+ if(classSym)
+ DeclareClass(classSym, className);
+
+ if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
(classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
{
char size[256];
}
else
{
- strcpy(className, "__ecereClass_");
-
- if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
- {
- classSym = FindClass(classSym.registered.templateClass.fullName);
- FullClassNameCat(className, classSym.string, true);
- }
- else
- FullClassNameCat(className, inst._class.name, true);
- MangleClassName(className);
-
- DeclareClass(classSym, className); // THIS WAS IN C VERSION BUT NOT IN eC VERSION?
newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
ProcessExpressionType(newCall);
newCall.byReference = true;
}
- if(classSym)
- DeclareClass(classSym, className);
-
if(inst.exp)
{
Expression exp, newExp;
External external;
// Is this still needed?
//CreateInstancesBody();
-
+
for(external = ast->first; external; external = external.next)
{
curExternal = external;
type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
};
globalContext.symbols.Add((BTNode)thisSymbol);
-
+
for(defProperty = def.defProperties->first; defProperty; defProperty = defProperty.next)
{
//thisClass = regClass;
type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
};
globalContext.symbols.Add((BTNode)thisSymbol);
-
+
//thisClass = regClass;
if(prop.setStmt)
{
else if(def.type == propertyWatchClassDef && def.propertyWatch)
{
PropertyWatch propertyWatch = def.propertyWatch;
-
+
// Add this to the context
Symbol thisSymbol
{
type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
};
globalContext.symbols.Add((BTNode)thisSymbol);
-
+
//thisClass = regClass;
if(propertyWatch.compound)
{
+ /* This was already added in pass15:ProcessClass()
Symbol thisSymbol
{
string = CopyString("this");
type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
- };
+ };*/
propertyWatch.compound.compound.context.symbols.Add((BTNode)thisSymbol);
curExternal = null;
ProcessStatement(propertyWatch.compound);
Ecere Software / sdk / blobdiff