thisMember = curMember;
}
- if(thisMember || method)
+ if(instExp && (thisMember || method))
{
Expression instExpCopy = CopyExpression(instExp);
Expression setExp = null;
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);
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);
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
{
break;
case opExp:
{
- bool assign = false;
+ //bool assign = false;
switch(exp.op.op)
{
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 callExp:
{
Expression e;
- Method method = null;
+ //Method method = null;
ProcessExpression(exp.call.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
{
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);
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);
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
{
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)
{
{
char className[1024];
+ className[0] = 0;
decl.type = initDeclaration;
decl.specifiers = MkList();
{
Expression newCall;
+ 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))
{
}
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;