3 #define YYLTYPE Location
6 extern External curExternal;
7 static Statement curCompound;
8 static Statement createInstancesBody;
9 static Statement destroyInstancesBody;
11 static void CreateInstancesBody()
13 if(inCompiler && !createInstancesBody)
15 char registerName[1024], moduleName[MAX_FILENAME];
17 Declarator declarator;
19 createInstancesBody = MkCompoundStmt(null, MkList());
20 createInstancesBody.compound.context = Context { parent = globalContext };
22 specifiers = MkList();
23 ListAdd(specifiers, MkSpecifier(VOID));
25 //strcpy(moduleName, outputFile);
26 GetLastDirectory(outputFile, moduleName);
27 StripExtension(moduleName);
28 ChangeCh(moduleName, ' ', '_');
29 ChangeCh(moduleName, '.', '_');
30 ChangeCh(moduleName, '-', '_');
31 sprintf(registerName, "__ecereCreateModuleInstances_%s", moduleName);
33 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), null);
36 FunctionDefinition function = MkFunction(specifiers, declarator, null);
37 ProcessFunctionBody(function, createInstancesBody);
38 ListAdd(ast, MkExternalFunction(function));
41 // Destroy Instances Body
42 destroyInstancesBody = MkCompoundStmt(null, MkList());
43 destroyInstancesBody.compound.context = Context { parent = globalContext };
45 specifiers = MkList();
46 ListAdd(specifiers, MkSpecifier(VOID));
48 sprintf(registerName, "__ecereDestroyModuleInstances_%s", moduleName);
50 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), null);
53 FunctionDefinition function = MkFunction(specifiers, declarator, null);
54 ProcessFunctionBody(function, destroyInstancesBody);
55 ListAdd(ast, MkExternalFunction(function));
60 // ***************** EXPRESSION PROCESSING ***************************
61 static void ProcessMemberInitData(MemberInit member)
63 if(member.initializer)
64 ProcessInitializer(member.initializer);
67 static void ProcessInstantiation(Instantiation inst)
69 if(inst.members && inst.members->first)
72 for(members = inst.members->first; members; members = members.next)
74 if(members.type == dataMembersInit)
76 if(members.dataMembers)
79 for(member = members.dataMembers->first; member; member = member.next)
80 ProcessMemberInitData(member);
83 else if(members.type == methodMembersInit)
85 ProcessFunction((FunctionDefinition)members.function);
91 // ADDED TO SUPPORT NESTED UNNAMED STRUCTURES
92 static bool ProcessInstMembers_SimpleMemberEnsure(DataMember parentMember, Instantiation inst, Expression instExp, OldList list, bool zeroOut)
94 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
96 // For simple classes, ensure all members are initialized
98 DataMember dataMember;
99 for(dataMember = parentMember.members.first; dataMember; dataMember = dataMember.next)
101 if(!dataMember.isProperty)
103 if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
105 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
110 bool memberFilled = false;
111 if(inst.members && inst.members->first)
113 Class curClass = null;
114 DataMember curMember = null;
115 DataMember subMemberStack[256];
116 int subMemberStackPos = 0;
119 for(members = inst.members->first; members; members = members.next)
121 if(members.type == dataMembersInit)
123 MemberInit member = null;
124 for(member = members.dataMembers->first; member; member = member.next)
126 if(member.identifiers)
128 Identifier firstID = member.identifiers->first;
129 DataMember _subMemberStack[256];
130 int _subMemberStackPos = 0;
131 DataMember thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
134 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
137 if(thisMember && thisMember.memberAccess == publicAccess)
139 curMember = thisMember;
140 curClass = curMember._class;
141 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
142 subMemberStackPos = _subMemberStackPos;
144 if(!firstID.next && thisMember == dataMember)
152 BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
155 curMember = link.data;
156 if(!firstID.next && curMember == dataMember)
166 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
167 if(curMember == dataMember)
174 curMember = curMember.next;
176 curMember = parentMember.members.first;
180 // curMember = curMember.next;
183 if(memberFilled) break;
185 if(memberFilled) break;
192 Expression instExpCopy = CopyExpression(instExp);
193 Expression memberExp;
195 Expression value = MkExpConstant("0");
197 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember.name));
198 memberExp.member.memberType = MemberType::dataMember;
200 value.usage.usageGet = true;
201 setExp = MkExpOp(memberExp, '=', value);
203 value.loc = inst.loc;
206 setExp.loc = inst.loc;
208 FreeType(instExpCopy.expType);
209 instExpCopy.expType = instExp.expType;
210 if(instExp.expType) instExp.expType.refCount++;
212 ProcessExpressionType(setExp);
213 ProcessExpression(setExp);
215 ListAdd(list, setExp);
222 if(parentMember.type == unionMember)
229 // Returns if all members are set
230 static bool ProcessInstMembers(Instantiation inst, Expression instExp, OldList list, bool zeroOut)
233 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
234 bool fullSet = true, convert = false;
235 if(classSym && classSym.registered && classSym.registered.type == bitClass)
237 Expression exp = null;
238 if(inst.members && inst.members->first)
240 // Ensure all members are initialized only once
242 while(_class != classSym.registered)
244 BitMember bitMember = null;
245 Class lastClass = _class;
247 for(_class = classSym.registered; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
249 for(bitMember = _class.membersAndProperties.first; bitMember; bitMember = bitMember.next)
251 BitMember curMember = null;
252 Class curClass = null;
253 DataMember subMemberStack[256];
254 int subMemberStackPos = 0;
255 MemberInit member = null;
257 for(members = inst.members->first; members; members = members.next)
259 if(members.type == dataMembersInit)
261 for(member = members.dataMembers->first; member; member = member.next)
263 if(member.identifiers)
265 Identifier firstID = member.identifiers->first;
266 DataMember _subMemberStack[256];
267 int _subMemberStackPos = 0;
270 BitMember thisMember = (BitMember)eClass_FindDataMember(_class, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
273 // WARNING: Brackets needed here, awaiting precomp fix
274 thisMember = (BitMember)eClass_FindProperty(_class, firstID.string, privateModule);
276 if(thisMember && thisMember.memberAccess == publicAccess)
278 curMember = thisMember;
279 curClass = curMember._class;
280 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
281 subMemberStackPos = _subMemberStackPos;
283 if(thisMember == bitMember)
291 eClass_FindNextMember(classSym.registered, &curClass, (DataMember *)&curMember, subMemberStack, &subMemberStackPos);
292 if(curMember == bitMember)
305 if(!bitMember.isProperty)
307 Expression part = null;
308 OldList * specs = MkList();
310 //decl = SpecDeclFromString(bitMember.dataTypeString, specs, null);
311 decl = SpecDeclFromString(_class.dataTypeString, specs, null);
313 ProcessInitializer(member.initializer);
315 if(member.initializer && member.initializer.type == expInitializer)
320 sprintf(pos, "%d", bitMember.pos);
321 // (((type) value) << bitPos)
322 part = MkExpBrackets(MkListOne(MkExpOp(MkExpBrackets(MkListOne(MkExpCast(
323 MkTypeName(specs, decl), MkExpBrackets(MkListOne(member.initializer.exp))))), LEFT_OP, MkExpConstant(pos))));
326 part = MkExpBrackets(MkListOne(MkExpCast(MkTypeName(specs, decl),
327 MkExpBrackets(MkListOne(member.initializer.exp)))));
329 member.initializer.exp = null;
330 FreeInitializer(member.initializer);
331 member.initializer = null;
335 exp = MkExpOp(exp,'|', part);
339 // Clean this up... should only be used for Conversion properties...
342 char setName[1024], getName[1024];
343 DeclareProperty((Property)bitMember, setName, getName);
344 if(member.initializer && member.initializer.type == expInitializer)
346 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)),
347 MkListOne(member.initializer.exp));
350 member.initializer.exp = null;
351 FreeInitializer(member.initializer);
352 member.initializer = null;
360 exp = MkExpBrackets(MkListOne(exp));
362 exp = MkExpConstant("0");
364 // Just added this one...
365 exp.expType = MkClassType(classSym.string);
367 ProcessExpression(exp);
371 else if(classSym && classSym.registered && classSym.registered.type == unitClass)
373 Class _class = classSym.registered;
374 Expression exp = null;
375 if(inst.members && inst.members->first)
377 MemberInit member = null;
378 Property prop = null;
380 for(members = inst.members->first; members; members = members.next)
382 if(members.type == dataMembersInit)
384 for(member = members.dataMembers->first; member; member = member.next)
386 if(member.identifiers)
388 Identifier firstID = member.identifiers->first;
389 prop = eClass_FindProperty(_class, firstID.string, privateModule);
411 char setName[1024], getName[1024];
412 DeclareProperty(prop, setName, getName);
413 if(member.initializer && member.initializer.type == expInitializer)
415 exp = MkExpCall(MkExpIdentifier(MkIdentifier(setName)), MkListOne(member.initializer.exp));
418 member.initializer.exp = null;
419 FreeInitializer(member.initializer);
420 member.initializer = null;
425 ProcessInitializer(member.initializer);
426 if(member.initializer && member.initializer.type == expInitializer)
428 //exp = MkExpBrackets(MkListOne(MkExpCast(QMkClass(_class.fullName, null), member.exp)));
429 exp = MkExpCast(QMkClass(_class.fullName, null), MkExpBrackets(MkListOne(member.initializer.exp)));
432 member.initializer.exp = null;
433 FreeInitializer(member.initializer);
434 member.initializer = null;
440 exp = MkExpBrackets(MkListOne(exp));
442 exp = MkExpConstant("0");
444 ProcessExpression(exp);
448 else if(classSym && classSym.registered)
450 if(classSym.registered.type == structClass)
452 // For simple classes, ensure all members are initialized
454 while(_class != classSym.registered)
456 DataMember dataMember;
457 Class lastClass = _class;
459 for(_class = classSym.registered; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
461 if(_class.structSize != _class.memberOffset)
464 for(dataMember = _class.membersAndProperties.first; dataMember; dataMember = dataMember.next)
466 if(!dataMember.isProperty)
468 if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
470 if(!ProcessInstMembers_SimpleMemberEnsure(dataMember, inst, instExp, list, zeroOut))
475 bool memberFilled = false;
476 if(inst.members && inst.members->first)
478 Class curClass = null;
479 DataMember curMember = null;
480 DataMember subMemberStack[256];
481 int subMemberStackPos = 0;
483 for(members = inst.members->first; members; members = members.next)
485 if(members.type == dataMembersInit && members.dataMembers)
487 MemberInit member = null;
488 for(member = members.dataMembers->first; member; member = member.next)
490 if(member.identifiers)
492 DataMember _subMemberStack[256];
493 int _subMemberStackPos = 0;
494 Identifier firstID = member.identifiers->first;
495 DataMember thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
498 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
501 if(thisMember.memberAccess == publicAccess)
503 curMember = thisMember;
504 curClass = curMember._class;
505 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
506 subMemberStackPos = _subMemberStackPos;
508 if(!firstID.next && curMember == dataMember)
517 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
518 if(curMember == dataMember)
525 if(memberFilled) break;
527 if(memberFilled) break;
534 Expression instExpCopy = CopyExpression(instExp);
535 Expression memberExp;
537 Expression value = MkExpConstant("0");
539 memberExp = MkExpMember(instExpCopy, MkIdentifier(dataMember.name));
540 memberExp.member.memberType = MemberType::dataMember;
542 value.usage.usageGet = true;
543 setExp = MkExpOp(memberExp, '=', value);
545 value.loc = inst.loc;
548 setExp.loc = inst.loc;
550 FreeType(instExpCopy.expType);
551 instExpCopy.expType = instExp.expType;
552 if(instExp.expType) instExp.expType.refCount++;
554 ProcessExpressionType(setExp);
555 ProcessExpression(setExp);
557 ListAdd(list, setExp);
567 // THEN SET EVERYTHING IN THE ORDER IT IS SET
568 if(inst.members && inst.members->first)
570 Class curClass = null;
571 DataMember curMember = null;
572 DataMember subMemberStack[256];
573 int subMemberStackPos = 0;
575 for(members = inst.members->first; members; members = members.next)
577 if(members.type == dataMembersInit && members.dataMembers)
579 MemberInit member = null;
580 Method method = null;
582 for(member = members.dataMembers->first; member; member = member.next)
584 Identifier ident = null;
585 DataMember thisMember = null;
586 if(member.identifiers)
588 DataMember _subMemberStack[256];
589 int _subMemberStackPos = 0;
590 Identifier firstID = member.identifiers->first;
591 thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
594 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
598 if(thisMember.memberAccess == publicAccess)
600 curMember = thisMember;
601 curClass = curMember._class;
602 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
603 subMemberStackPos = _subMemberStackPos;
606 else if(classSym.registered.type != structClass)
608 method = eClass_FindMethod(classSym.registered, ident.string, privateModule);
609 if(!method || method.type != virtualMethod)
615 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
616 thisMember = curMember;
619 if(thisMember || method)
621 Expression instExpCopy = CopyExpression(instExp);
622 Expression setExp = null;
624 instExpCopy.tempCount = instExp.tempCount;
627 ident = MkIdentifier(thisMember.name);
630 Expression memberExp;
632 if(thisMember && thisMember.isProperty && ((Property)thisMember).conversion)
634 if(member.identifiers && member.identifiers->count > 1)
636 Identifier id = member.identifiers->first;
637 // TODO: Set the member types for those
638 memberExp = MkExpMember(instExpCopy, id);
639 for(id = id.next; id; id = id.next)
640 memberExp = MkExpMember(memberExp, id);
643 memberExp = MkExpMember(instExpCopy, ident);
645 if(member.initializer && member.initializer.type == expInitializer && member.initializer.exp)
647 member.initializer.exp.usage.usageGet = true;
648 setExp = MkExpOp(memberExp, '=', member.initializer.exp);
651 member.initializer.exp = null;
652 FreeInitializer(member.initializer);
653 member.initializer = null;
655 // TODO: list initializer not working...
657 memberExp.loc = inst.loc;
659 if(member.identifiers)
660 member.identifiers->Clear();
664 setExp.loc = inst.loc;
666 FreeType(instExpCopy.expType);
667 instExpCopy.expType = instExp.expType;
668 if(instExp.expType) instExp.expType.refCount++;
672 ProcessExpressionType(setExp);
673 ProcessExpression(setExp);
675 ListAdd(list, setExp);
684 return fullSet || convert;
687 public void DeclareClass(Symbol classSym, char * className)
689 /*if(classSym.registered.templateClass)
692 char className[1024];
693 strcpy(className, "__ecereClass_");
694 templateSym = FindClass(classSym.registered.templateClass.fullName);
695 FullClassNameCat(className, templateSym.string, true);
696 MangleClassName(className);
698 DeclareClass(templateSym, className);
700 if(classSym && classSym.id == MAXINT)
702 // Add Class declaration as extern
704 OldList * specifiers, * declarators;
707 if(!classSym._import)
709 // TESTING: DANGER HERE... CHECK FOR TEMPLATES ONLY? SET classSym.module ELSEWHERE?
710 // if(!classSym.module) return;
711 if(!classSym.module) classSym.module = mainModule;
712 if(!classSym.module) return;
713 classSym._import = ClassImport
715 isRemote = classSym.registered ? classSym.registered.isRemote : false;
716 name = CopyString(classSym.string);
718 classSym.module.classes.Add(classSym._import);
720 classSym._import.itself = true;
722 specifiers = MkList();
723 declarators = MkList();
725 ListAdd(specifiers, MkSpecifier(EXTERN));
726 ListAdd(specifiers, MkStructOrUnion(structSpecifier, MkIdentifier("__ecereNameSpace__ecere__com__Class"), null));
728 d = MkDeclaratorPointer(MkPointer(null, null),
729 MkDeclaratorIdentifier(MkIdentifier(className)));
731 ListAdd(declarators, MkInitDeclarator(d, null));
733 decl = MkDeclaration(specifiers, declarators);
737 ast->Insert(curExternal.prev, (classSym.pointerExternal = MkExternalDeclaration(decl)));
738 // classSym.id = curExternal.symbol.id;
741 classSym.id = curExternal.symbol ? curExternal.symbol.idCode : 0;
743 classSym.idCode = classSym.id;
746 else if(classSym && curExternal.symbol.idCode < classSym.id)
747 //else if(curExternal.symbol.id <= classSym.id)
749 // DANGER: (Moved here)
750 if(classSym.structExternal)
751 DeclareStruct(classSym.string, classSym.registered && classSym.registered.type == noHeadClass);
753 // Move _class declaration higher...
754 ast->Move(classSym.pointerExternal, curExternal.prev);
758 if(classSym.structExternal)
759 DeclareStruct(classSym.string, classSym.registered && classSym.registered.type == noHeadClass);
762 // TOFIX: For non simple classes, Class is in pointerExternal and actual struct in structExternal
763 if(classSym.structExternal)
764 ast->Move(classSym.structExternal, classSym.pointerExternal);
766 classSym.id = curExternal.symbol.idCode;
768 classSym.idCode = classSym.id;
772 void ProcessExpressionInstPass(Expression exp)
774 ProcessExpression(exp);
777 static void ProcessExpression(Expression exp)
780 char debugExpString[1024] = "";
781 PrintExpression(exp, debugExpString);
789 Instantiation inst = exp.instance;
790 if(inCompiler && inst._class)
792 char className[1024];
793 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
796 if(classSym && classSym.registered && classSym.registered.type == bitClass)
800 OldList list = { 0 };
802 ProcessInstMembers(inst, null, &list, false);
804 ProcessExpression(inst.exp);
806 //Why was this here twice? ProcessInstMembers(inst, null, &list);
809 exp.op.exp1 = inst.exp;
810 exp.op.exp2 = list.first;
812 // Take expression out... (Why was the comment alone?)
817 Type expType = exp.expType;
818 Expression prev = exp.prev, next = exp.next;
820 ProcessInstMembers(inst, null, &list, false);
823 FreeType(exp.destType);
825 *exp = *(Expression)list.first;
828 Expression firstExp = list.first;
832 FreeType(exp.destType);
833 exp.destType = expType;
834 //if(expType) expType.refCount++;
840 else if(classSym && classSym.registered && (classSym.registered.type == unitClass || classSym.registered.type == enumClass))
844 OldList list = { 0 };
847 ProcessInstMembers(inst, null, &list, false);
849 ProcessExpression(inst.exp);
851 //Why was this here twice? ProcessInstMembers(inst, null, &list);
854 exp.op.exp1 = inst.exp;
855 exp.op.exp2 = list.first;
857 // Take expression out... (Why was the comment alone?)
860 list.Remove(list.first);
861 while(e = list.first)
869 Expression prev = exp.prev, next = exp.next;
870 Type expType = exp.expType;
871 OldList list = { 0 };
872 ProcessInstMembers(inst, null, &list, false);
877 Expression e = list.first;
878 FreeType(exp.destType);
882 exp.expType = expType;
885 while(e = list.first)
893 exp.type = constantExp;
894 exp.constant = CopyString("0");
898 else if(classSym && classSym.registered && classSym.registered.type == structClass)
903 exp.type = bracketsExp;
906 ProcessInstMembers(inst, inst.exp, exp.list, false);
908 ProcessExpression(inst.exp);
912 exp.type = (ExpressionType)1000; // remove expression
915 // Take expression out...
921 Declaration dummyDecl;
922 // Unnamed instantiation
924 // Make a declaration in the closest compound statement
925 // (Do not reuse (since using address for function calls)...)
928 ListAdd(decls, MkInitDeclarator(
929 MkDeclaratorIdentifier(MkIdentifier(className)), null));
930 decl = MkDeclaration(specs, decls);
932 /* Never mind this... somebody might modify the values...
936 sprintf(className, "__simpleStruct%d", curContext.simpleID++);
937 inst.id = MkIdentifier(className);
938 decl = MkDeclarationInst(inst);
939 exp.type = ExpIdentifier;
940 exp.identifier = inst.id;
941 if(!curCompound.compound.declarations)
942 curCompound.compound.declarations = MkList();
943 curCompound.compound.declarations->Insert(null, decl);
944 ProcessDeclaration(decl);
950 //OldList * specs = MkList(), * decls = MkList();
951 //sprintf(className, "__ecereClassData_%s", inst._class.name);
952 //ListAdd(specs, MkStructOrUnion(SpecifierStruct, MkIdentifier(className), null));
955 // TRICKY STUFF, UGLY HACK FOR stateSizeAnchor = SizeAnchor { size.w = 10 };
956 dummyDecl = MkDeclaration(null,null);
957 if(!curCompound.compound.declarations)
958 curCompound.compound.declarations = MkList();
959 curCompound.compound.declarations->Insert(null, dummyDecl);
961 sprintf(className, "__simpleStruct%d", curContext.simpleID++);
964 OldList * list = MkList();
965 if(inst.isConstant && ProcessBracketInst(inst, list))
967 decl = MkDeclaration(MkList(), MkList());
969 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
970 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(className)),
971 MkInitializerList(list)));
973 exp.type = identifierExp;
974 exp.identifier = MkIdentifier(className);
981 decl = MkDeclarationInst(MkInstantiation(CopySpecifier(inst._class), MkExpIdentifier(MkIdentifier(className)), null));
984 // Set properties & data members in expression
985 // to handle jump and control statements
986 // Set unset data members to 0
987 exp.type = bracketsExp;
990 instExp = QMkExpId(className);
991 instExp.loc = exp.loc;
992 instExp.expType = MkClassType(inst._class.name);
994 // Mark the declarated instance as fullset so it doesn't need to be zeroed out
995 decl.inst.fullSet = ProcessInstMembers(inst, instExp, exp.list, false);
997 ListAdd(exp.list, instExp);
1001 FreeType(exp.expType);
1002 exp.expType = MkClassType(inst._class.name);
1004 // TRICKY STUFF, UGLY HACK FOR stateSizeAnchor = SizeAnchor { size.w = 10 };
1006 void * prev = dummyDecl.prev, * next = dummyDecl.next;
1008 dummyDecl.prev = prev;
1009 dummyDecl.next = next;
1013 ProcessDeclaration(decl);
1016 if(!curCompound.compound.declarations)
1017 curCompound.compound.declarations = MkList();
1018 curCompound.compound.declarations->Insert(null, decl);
1027 if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
1028 (classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
1031 sprintf(size, "%d", classSym.registered.templateClass ? classSym.registered.templateClass.structSize : classSym.registered.structSize);
1032 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(MkExpConstant(size)));
1033 newCall.byReference = true;
1037 strcpy(className, "__ecereClass_");
1038 if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
1040 classSym = FindClass(classSym.registered.templateClass.fullName);
1041 FullClassNameCat(className, classSym.string, true);
1044 FullClassNameCat(className, inst._class.name, true);
1046 MangleClassName(className);
1047 DeclareClass(classSym, className);
1048 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
1050 ProcessExpressionType(newCall);
1051 newCall.byReference = true;
1056 if(inst.members && inst.members->first)
1058 exp.type = bracketsExp;
1059 exp.list = MkList();
1063 ListAdd(exp.list, MkExpOp(inst.exp, '=', newCall));
1066 FreeExpression(newCall);
1068 ProcessInstMembers(inst, inst.exp, exp.list, false);
1071 FreeExpression(inst.exp);
1077 exp.op.exp1 = inst.exp;
1078 exp.op.exp2 = newCall;
1080 ProcessExpression(inst.exp);
1086 // Unnamed instantiation
1087 if(inst.members && inst.members->first)
1089 char ecereTemp[100];
1090 MembersInit members;
1091 int tempCount = exp.tempCount;
1094 // Check if members use temp count...
1095 for(members = inst.members->first; members; members = members.next)
1097 if(members.type == dataMembersInit && members.dataMembers)
1100 for(member = members.dataMembers->first; member; member = member.next)
1102 if(member.initializer && member.initializer.type == expInitializer)
1104 ProcessMemberInitData(member); // ADDED THIS TO HAVE PROPER tempCount ALREADY...
1105 tempCount = Max(tempCount, member.initializer.exp.tempCount);
1111 tempCount = Max(tempCount, declTempCount);
1114 curExternal.function.tempCount = Max(curExternal.function.tempCount, tempCount);
1115 sprintf(ecereTemp, "__ecereInstance%d", tempCount);
1116 exp.type = extensionCompoundExp;
1117 exp.compound = MkCompoundStmt(null, null);
1118 exp.compound.compound.context = PushContext();
1119 exp.compound.compound.context.simpleID = exp.compound.compound.context.parent.simpleID;
1120 exp.compound.compound.declarations = MkListOne(QMkDeclaration(inst._class.name, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(ecereTemp)),
1121 MkInitializerAssignment(newCall))));
1122 exp.compound.compound.statements = MkListOne(MkExpressionStmt((expList = MkList())));
1124 instExp = QMkExpId(ecereTemp);
1125 instExp.tempCount = tempCount;
1126 instExp.expType = MkClassType(inst._class.name);
1127 instExp.byReference = true;
1128 ProcessInstMembers(inst, instExp, expList, false);
1129 FreeExpression(instExp);
1133 Expression tmpExp = QMkExpId(ecereTemp);
1134 tmpExp.byReference = true;
1135 ListAdd(expList, tmpExp);
1137 exp.tempCount = tempCount;
1139 declTempCount = Max(declTempCount, tempCount);
1140 PopContext(exp.compound.compound.context);
1144 FreeType(newCall.destType);
1145 FreeType(newCall.expType);
1146 newCall.destType = exp.destType;
1147 newCall.expType = exp.expType;
1153 if(exp.type != instanceExp)
1157 ProcessInstantiation(inst);
1166 // if(exp._new.size) exp._new.size.usage.usageGet = true;
1167 ProcessExpression(exp._new.size);
1171 // if(exp._renew.size) exp._renew.size.usage.usageGet = true;
1172 ProcessExpression(exp._renew.size);
1173 // if(exp._renew.exp) exp._renew.exp.usage.usageGet = true;
1174 ProcessExpression(exp._renew.exp);
1178 bool assign = false;
1182 // Assignment Operators
1185 exp.op.exp2.usage.usageGet = true;
1187 exp.op.exp1.usage.usageSet = true;
1201 exp.op.exp2.usage.usageGet = true;
1204 exp.op.exp1.usage.usageSet = true;
1210 exp.op.exp1.usage.usageSet = true;
1215 if(exp.op.exp1 && exp.op.exp2)
1217 exp.op.exp1.usage.usageGet = true;
1218 exp.op.exp2.usage.usageGet = true;
1227 exp.op.exp1.usage.usageGet = true;
1232 exp.op.exp2.usage.usageGet = true;
1235 // Binary only operators
1251 exp.op.exp1.usage.usageGet = true;
1253 exp.op.exp2.usage.usageGet = true;
1259 // TEST: if(exp.op.exp2) exp.op.exp1.tempCount = Max(exp.op.exp1.tempCount, exp.op.exp2.tempCount);
1260 ProcessExpression(exp.op.exp1);
1261 // TEST: exp.tempCount = Max(exp.op.exp1.tempCount, exp.tempCount);
1266 // Don't use the temporaries used by the left side...
1268 // TEST: exp.op.exp2.tempCount = Max(exp.op.exp2.tempCount, exp.op.exp1.tempCount);
1269 exp.op.exp2.tempCount = exp.op.exp1.tempCount;
1270 ProcessExpression(exp.op.exp2);
1271 // TEST: exp.tempCount = Max(exp.op.exp2.tempCount, exp.tempCount);
1275 case extensionExpressionExp:
1279 for(e = exp.list->first; e; e = e.next)
1281 e.tempCount = Max(e.tempCount, exp.tempCount);
1284 e.usage |= (exp.usage & (ExpUsage { usageGet = true, usageArg = true }));
1286 ProcessExpression(e);
1287 exp.tempCount = Max(exp.tempCount, e.tempCount);
1295 exp.index.exp.usage.usageGet = true;
1296 ProcessExpression(exp.index.exp);
1297 for(e = exp.index.index->first; e; e = e.next)
1300 e.usage.usageGet = true;
1301 ProcessExpression(e);
1303 // Ignore temps in the index for now...
1304 exp.tempCount = exp.index.exp.tempCount;
1306 if(exp.index.exp.expType)
1308 Type source = exp.index.exp.expType;
1309 if(source.kind == classType && source._class && source._class.registered && source._class.registered != containerClass &&
1310 eClass_IsDerived(source._class.registered, containerClass))
1312 Class _class = source._class.registered;
1313 // __extension__({ Iterator<type> i { container }; i.Index(e, [ exp.usage.usageSet ]; i.value; });
1315 char iteratorType[1024];
1316 OldList * declarations = MkList();
1317 OldList * statements = MkList();
1318 OldList * args = MkList();
1319 OldList * instMembers = MkList();
1321 Context context = PushContext();
1323 sprintf(iteratorType, "Iterator<%s, %s >", _class.templateArgs[2].dataTypeString, _class.templateArgs[1].dataTypeString);
1325 ListAdd(instMembers, MkMemberInit(null, MkInitializerAssignment(exp.index.exp)));
1327 ListAdd(declarations, MkDeclarationInst(MkInstantiationNamed(MkListOne(MkSpecifierName(iteratorType)),
1328 MkExpIdentifier(MkIdentifier("__internalIterator")), MkListOne(MkMembersInitList(instMembers)))));
1330 ListAdd(args, MkExpBrackets(exp.index.index));
1331 ListAdd(args, exp.usage.usageSet ? MkExpIdentifier(MkIdentifier("true")) : MkExpIdentifier(MkIdentifier("false")));
1333 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")),
1334 MkIdentifier("Index")), args))));
1336 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(null, '&', MkExpIdentifier(MkIdentifier("__internalIterator"))))));
1338 exp.type = bracketsExp;
1339 exp.list = MkListOne(MkExpPointer(expExt = (MkExpExtensionCompound(MkCompoundStmt(declarations, statements))), MkIdentifier("data")));
1340 expExt.compound.compound.context = context;
1341 PopContext(context);
1342 expExt.usage = exp.usage;
1343 ProcessExpressionType(exp.list->first);
1344 ProcessExpression(exp.list->first);
1353 Method method = null;
1355 ProcessExpression(exp.call.exp);
1357 if(exp.call.arguments)
1359 for(e = exp.call.arguments->first; e; e = e.next)
1361 e.usage.usageGet = true;
1362 e.usage.usageArg = true;
1364 // TEST: e.tempCount = Max(e.tempCount, exp.tempCount);
1365 ProcessExpression(e);
1366 // TEST: exp.tempCount = Max(exp.tempCount, e.tempCount);
1373 exp.member.exp.usage.usageGet = true;
1374 ProcessExpression(exp.member.exp);
1376 // Must do this here so we can set the MemberType of deep properties inside instantiations
1377 if(!exp.member.memberType)
1379 Type type = exp.member.exp.expType;
1380 if((type && type.kind == classType && exp.member.member))
1382 // Check if it's an instance
1383 Class _class = (exp.member.member._class && exp.member.member.classSym) ? exp.member.member.classSym.registered : (type._class ? type._class.registered : null);
1384 Property prop = null;
1385 Method method = null;
1386 DataMember member = null;
1387 Property revConvert = null;
1389 // Prioritize data members over properties for "this"
1390 if(exp.member.thisPtr)
1392 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1394 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1396 // Prioritize properties over data members otherwise
1399 // Look for publicAccess Members first
1400 prop = eClass_FindProperty(_class, exp.member.member.string, null);
1402 member = eClass_FindDataMember(_class, exp.member.member.string, null, null, null);
1403 if(!prop && !member)
1405 method = eClass_FindMethod(_class, exp.member.member.string, null);
1408 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1410 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1414 if(!prop && !member)
1415 method = eClass_FindMethod(_class, exp.member.member.string, privateModule);
1416 if(!prop && !member && !method)
1418 Symbol classSym = FindClass(exp.member.member.string);
1421 Class convertClass = classSym.registered;
1423 revConvert = eClass_FindProperty(convertClass, _class.fullName, privateModule);
1429 exp.member.memberType = propertyMember;
1431 prop.dataType = ProcessTypeString(prop.dataTypeString, false);
1433 FreeType(exp.expType);
1434 exp.expType = prop.dataType;
1435 if(prop.dataType) prop.dataType.refCount++;
1439 exp.member.memberType = methodMember;
1440 if(!method.dataType)
1441 //method.dataType = ((Symbol)method.symbol).type;
1442 ProcessMethodType(method);
1444 FreeType(exp.expType);
1445 exp.expType = method.dataType;
1446 if(method.dataType) method.dataType.refCount++;
1450 exp.member.memberType = dataMember;
1451 DeclareStruct(_class.fullName, false);
1452 if(!member.dataType)
1453 member.dataType = ProcessTypeString(member.dataTypeString, false);
1455 FreeType(exp.expType);
1456 exp.expType = member.dataType;
1457 if(member.dataType) member.dataType.refCount++;
1461 exp.member.memberType = reverseConversionMember;
1463 FreeType(exp.expType);
1464 exp.expType = MkClassType(revConvert._class.fullName);
1467 printf($"Error: Couldn't find member %s in class %s\n",
1468 exp.member.member.string, _class.name);*/
1477 exp.cast.exp.usage.usageGet = true;
1478 ProcessExpression(exp.cast.exp);
1484 if(exp.usage.usageGet)
1485 exp.cond.cond.usage.usageGet = true;
1487 ProcessExpression(exp.cond.cond);
1488 for(e = exp.cond.exp->first; e; e = e.next)
1490 if(!e.next && exp.usage.usageGet) e.usage.usageGet = true;
1491 ProcessExpression(e);
1493 if(exp.cond.elseExp)
1495 if(exp.usage.usageGet) exp.cond.elseExp.usage.usageGet = true;
1496 ProcessExpression(exp.cond.elseExp);
1500 case extensionCompoundExp:
1502 if(exp.compound.compound.statements &&
1503 ((Statement)exp.compound.compound.statements->last).type == expressionStmt &&
1504 ((Statement)exp.compound.compound.statements->last).expressions &&
1505 ((Statement)exp.compound.compound.statements->last).expressions->last)
1507 ((Expression)((Statement)exp.compound.compound.statements->last).expressions->last).usage = exp.usage;
1509 ProcessStatement(exp.compound);
1514 ProcessExpression(exp.vaArg.exp);
1517 case extensionInitializerExp:
1519 ProcessInitializer(exp.initializer.initializer);
1523 CheckTemplateTypes(exp);
1526 static void ProcessInitializer(Initializer init)
1530 case expInitializer:
1531 init.exp.usage.usageGet = true;
1532 ProcessExpression(init.exp);
1534 case listInitializer:
1537 for(i = init.list->first; i; i = i.next)
1538 ProcessInitializer(i);
1544 static void ProcessSpecifier(Specifier spec)
1559 for(e = spec.list->first; e; e = e.next)
1562 ProcessExpression(e.exp);
1567 case structSpecifier:
1568 case unionSpecifier:
1571 if(spec.definitions)
1574 for(def = spec.definitions->first; def; def = def.next)
1576 if(def.type == declarationClassDef && def.decl && def.decl.type == structDeclaration)
1577 ProcessDeclaration(def.decl);
1583 case SpecifierClass:
1590 static bool ProcessBracketInst_DataMember(DataMember parentMember, Instantiation inst, OldList list)
1592 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1593 DataMember dataMember = null;
1594 bool someMemberSet = false;
1596 // For simple classes, ensure all members are initialized
1597 for(dataMember = parentMember.members.first; dataMember; dataMember = dataMember.next)
1599 MembersInit members;
1600 MemberInit member = null;
1602 if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1604 if(!ProcessBracketInst_DataMember(dataMember, inst, list))
1609 Class curClass = null;
1610 DataMember curMember = null;
1611 DataMember subMemberStack[256];
1612 int subMemberStackPos = 0;
1615 if(inst.members && inst.members->first)
1617 for(members = inst.members->first; members; members = members.next)
1619 if(members.type == dataMembersInit)
1621 for(member = members.dataMembers->first; member; member = member.next)
1623 if(member.identifiers)
1625 Identifier firstID = member.identifiers->first;
1627 DataMember _subMemberStack[256];
1628 int _subMemberStackPos = 0;
1629 DataMember thisMember;
1630 thisMember = firstID ? (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule) : null;
1631 // FILL MEMBER STACK
1632 if(!thisMember && firstID)
1633 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
1634 if(thisMember && thisMember.memberAccess == publicAccess)
1636 curMember = thisMember;
1637 curClass = curMember._class;
1638 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
1639 subMemberStackPos = _subMemberStackPos;
1642 BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
1645 curMember = link.data;
1648 // Choose the first specified member of the union...
1649 if(parentMember.type == unionMember)
1652 dataMember = curMember;
1656 if(dataMember == thisMember)
1658 // Look for another member of this one and merge them
1659 // into one instantiation...
1660 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
1662 OldList * partList = MkList();
1663 // TODO: We're assuming this is a simple class right now...
1666 MembersInit nextMembers;
1667 MemberInit next = member.next;
1669 if(!dataMember.dataType)
1670 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1671 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
1672 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
1675 OldList * identifiers = MkList();
1677 for(id = ((Identifier)member.identifiers->first).next; id; id = id.next)
1678 identifiers->Add(CopyIdentifier(id));
1680 // *** THE IDENTIFIERS WERE BEING REUSED, CAUSING A CRASH WITH EXPRESSION TEMPLATE CODE IN pass1.ec ***
1681 // members->Add(MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
1682 /*member.identifiers->Remove(firstID);*/
1684 MkMemberInit(/*member.identifiers*/identifiers, MkInitializerAssignment(member.initializer.exp)));
1687 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
1689 if(!nextMembers.dataMembers)
1692 if(members != nextMembers) next = nextMembers.dataMembers->first;
1694 if(nextMembers.type == dataMembersInit)
1696 MemberInit nextMember;
1698 for(nextMember = next; nextMember;
1699 nextMember = next, next = nextMember ? nextMember.next : null)
1701 Identifier nextID = nextMember.identifiers->first;
1702 if(nextMember.identifiers &&
1703 nextMember.identifiers->count > 1 &&
1704 !strcmp(firstID.string, nextID.string))
1706 nextMembers.dataMembers->Remove(nextMember);
1707 nextMember.identifiers->Remove(nextID);
1708 ListAdd(partList, nextMember);
1714 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
1715 MkListOne(MkMembersInitList(partList))));
1723 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1724 if(curMember == dataMember)
1732 curMember = curMember.next;
1734 curMember = parentMember.members.first;
1736 if(curMember == dataMember)
1749 if(member && member.initializer && member.initializer.type == expInitializer)
1751 Expression memberExp = null;
1752 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
1753 member.initializer.exp.expType._class.registered.type == structClass)
1755 OldList * subList = MkList();
1756 ProcessBracketInst(member.initializer.exp.instance, subList);
1757 FreeExpression(member.initializer.exp);
1758 ListAdd(list, MkInitializerList(subList));
1762 member.initializer.exp.usage.usageGet = true;
1763 ProcessExpression(member.initializer.exp);
1764 ListAdd(list, MkInitializerAssignment(member.initializer.exp));
1766 member.initializer.exp = null;
1767 FreeInitializer(member.initializer);
1768 member.initializer = null;
1769 someMemberSet = true;
1771 else if(member && member.initializer && member.initializer.type == listInitializer)
1773 ListAdd(list, member.initializer);
1774 member.initializer = null;
1775 someMemberSet = true;
1777 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/ && parentMember.type != unionMember)
1780 if(!dataMember.dataType)
1781 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1782 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1783 if(classSym && classSym.registered && classSym.registered.type == structClass)
1785 OldList * subList = MkList();
1786 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1787 Instantiation inst = MkInstantiation(spec, null, null);
1788 ProcessBracketInst(inst, subList);
1791 ListAdd(list, MkInitializerList(subList));
1794 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
1798 if(parentMember.type == unionMember)
1802 // TESTING THIS NEW CODE FOR ANCHORS...
1803 if(parentMember.type == unionMember && !someMemberSet)
1806 dataMember = parentMember.members.first;
1807 if(!dataMember.dataType && dataMember.dataTypeString)
1808 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1809 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1810 if(classSym && classSym.registered && classSym.registered.type == structClass)
1812 OldList * subList = MkList();
1813 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1814 Instantiation inst = MkInstantiation(spec, null, null);
1815 ProcessBracketInst(inst, subList);
1818 ListAdd(list, MkInitializerList(subList));
1821 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
1826 static bool ProcessBracketInst(Instantiation inst, OldList list)
1828 static int recursionCount = 0;
1829 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1830 Class _class = null;
1832 if(recursionCount > 500) return false;
1835 while(_class != classSym.registered)
1837 DataMember dataMember;
1838 Class lastClass = _class;
1840 for(_class = classSym.registered; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
1842 for(dataMember = _class.membersAndProperties.first; dataMember; dataMember = dataMember.next)
1844 if(!dataMember.isProperty && !dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1846 if(!ProcessBracketInst_DataMember(dataMember, inst, list))
1854 MembersInit members;
1855 MemberInit member = null;
1858 if(inst.members && inst.members->first)
1860 DataMember curMember = null;
1861 Class curClass = null;
1862 DataMember subMemberStack[256];
1863 int subMemberStackPos = 0;
1865 for(members = inst.members->first; members; members = members.next)
1867 if(members.type == dataMembersInit)
1869 for(member = members.dataMembers->first; member; member = member.next)
1871 Identifier firstID = member.identifiers ? member.identifiers->first : null;
1874 DataMember _subMemberStack[256];
1875 int _subMemberStackPos = 0;
1876 DataMember thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
1877 // FILL MEMBER STACK
1879 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
1882 curMember = thisMember;
1883 curClass = curMember._class;
1884 memcpy(subMemberStack, _subMemberStack, sizeof(int) * _subMemberStackPos);
1885 subMemberStackPos = _subMemberStackPos;
1888 if(curMember == dataMember)
1890 if(dataMember.isProperty)
1892 if(!((Property)dataMember).Set)
1894 Compiler_Error($"No set defined for property %s\n", dataMember.name);
1901 // Look for another member of this one and merge them
1902 // into one instantiation...
1903 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
1905 OldList * partList = MkList();
1906 // TODO: We're assuming this is a simple _class right now...
1908 MembersInit nextMembers;
1909 MemberInit next = member.next;
1911 if(!dataMember.dataType)
1912 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1913 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
1914 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
1916 member.identifiers->Remove(firstID);
1918 MkMemberInit(member.identifiers, MkInitializerAssignment(member.initializer.exp)));
1920 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
1922 if(!nextMembers.dataMembers) continue;
1924 if(members != nextMembers) next = nextMembers.dataMembers->first;
1926 if(nextMembers.type == dataMembersInit)
1928 MemberInit nextMember;
1930 for(nextMember = next; nextMember;
1931 nextMember = next, next = nextMember ? nextMember.next : null)
1933 Identifier nextID = nextMember.identifiers->first;
1934 if(nextMember.identifiers &&
1935 nextMember.identifiers->count > 1 &&
1936 !strcmp(firstID.string, nextID.string))
1938 nextMembers.dataMembers->Remove(nextMember);
1939 nextMember.identifiers->Remove(nextID);
1940 ListAdd(partList, nextMember);
1946 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
1947 MkListOne(MkMembersInitList(partList))));
1950 member.identifiers = null;
1958 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1959 if(curMember == dataMember)
1961 if(dataMember.isProperty)
1963 if(!((Property)dataMember).Set)
1965 Compiler_Error($"No set defined for property %s\n", dataMember.name);
1981 if(dataMember.isProperty) continue;
1982 if(member && member.initializer && member.initializer.type == expInitializer)
1984 Expression memberExp = null;
1985 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
1986 member.initializer.exp.expType._class && member.initializer.exp.expType._class.registered && member.initializer.exp.expType._class.registered.type == structClass)
1988 OldList * subList = MkList();
1989 ProcessBracketInst(member.initializer.exp.instance, subList);
1990 FreeExpression(member.initializer.exp);
1991 ListAdd(list, MkInitializerList(subList));
1995 member.initializer.exp.usage.usageGet = true;
1996 ProcessExpression(member.initializer.exp);
1997 ListAdd(list, MkInitializerAssignment(member.initializer.exp));
2001 // member.exp = null;
2002 member.takeOutExp = true;
2004 else if(member && member.initializer && member.initializer.type == listInitializer)
2006 ListAdd(list, member.initializer);
2007 member.initializer = null;
2009 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/)
2013 if(!dataMember.dataType)
2014 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
2015 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
2017 if(classSym && classSym.registered && classSym.registered.type == structClass)
2019 OldList * subList = MkList();
2020 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
2021 Instantiation inst = MkInstantiation(spec, null, null);
2022 ProcessBracketInst(inst, subList);
2024 ListAdd(list, MkInitializerList(subList));
2026 else if(dataMember.dataType.kind == arrayType)
2027 ListAdd(list, MkInitializerList(MkListOne(MkInitializerAssignment(MkExpConstant("0")))));
2029 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
2035 if(inst.members && inst.members->first)
2037 MembersInit members;
2038 MemberInit member = null;
2040 for(members = inst.members->first; members; members = members.next)
2042 if(members.type == dataMembersInit)
2044 for(member = members.dataMembers->first; member; member = member.next)
2046 if(member.takeOutExp)
2048 member.initializer.exp = null;
2049 FreeInitializer(member.initializer);
2050 member.initializer = null;
2060 static Declaration curDecl;
2061 static int declTempCount;
2063 static void ProcessDeclaration(Declaration decl)
2068 case initDeclaration:
2070 if(!curDecl) { curDecl = decl; declTempCount = 0; }
2074 for(s = decl.specifiers->first; s; s = s.next)
2076 ProcessSpecifier(s);
2079 if(decl.declarators)
2083 for(d = decl.declarators->first; d; d = d.next)
2086 ProcessInitializer(d.initializer);
2089 if(curDecl == decl) { curDecl = null; declTempCount = 0; }
2092 case instDeclaration:
2094 Instantiation inst = decl.inst;
2098 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
2103 if(!inst.isConstant || (classSym && classSym.registered && (classSym.registered.type == normalClass || classSym.registered.type == noHeadClass)))
2105 // If this instantiation is outside, turn it into a declaration plus an instantiation expression
2106 decl.type = initDeclaration;
2107 decl.specifiers = MkListOne(MkSpecifierName/*MkClassName*/(inst._class.name));
2108 if(decl.declMode == staticAccess)
2110 decl.specifiers->Insert(null, MkSpecifier(STATIC));
2112 decl.declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst.exp.identifier.string)), null));
2114 ProcessDeclaration(decl);
2115 CreateInstancesBody();
2118 Expression exp = MkExpInstance(inst);
2119 stmt = MkExpressionStmt(MkListOne(exp)); // MkExpOp(inst.exp, '=',
2120 ListAdd(createInstancesBody.compound.statements, stmt);
2121 ProcessExpressionType(exp);
2124 if(classSym && classSym.registered && (classSym.registered.type == normalClass))
2126 ListAdd(createInstancesBody.compound.statements,
2127 MkExpressionStmt(MkListOne(MkExpCall(
2128 MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")),
2129 MkListOne(CopyExpression(inst.exp))))));
2131 // We'd like the = 0 as well...
2133 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2134 ListAdd(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2135 ProcessExpressionType(exp);
2138 else if(classSym && classSym.registered && (classSym.registered.type == noHeadClass))
2140 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2141 ListAdd(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2142 ProcessExpressionType(exp);
2148 // Precompiler won't know if this isn't constant
2149 CreateInstancesBody();
2154 char className[1024];
2156 decl.type = initDeclaration;
2157 decl.specifiers = MkList();
2158 decl.declarators = MkList();
2160 // Replace instantiation here
2161 if(classSym && classSym.registered && classSym.registered.type == bitClass)
2163 OldList list = { 0 };
2165 // Put the instantiation in an InitDeclarator...
2166 ProcessInstMembers(inst, inst.exp, &list, false);
2167 ProcessExpression(inst.exp);
2169 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2170 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2171 MkInitializerAssignment(list.first)));
2172 inst.exp.identifier = null;
2174 else if(classSym && classSym.registered && classSym.registered.type == unitClass)
2176 OldList list = { 0 };
2178 // Put the instantiation in an InitDeclarator...
2179 ProcessInstMembers(inst, inst.exp, &list, false);
2180 ProcessExpression(inst.exp);
2182 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2183 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2184 MkInitializerAssignment(list.first)));
2186 inst.exp.identifier = null;
2188 else if(classSym && classSym.registered && classSym.registered.type == structClass)
2192 DeclareStruct(inst._class.name, false);
2194 strcpy(className, "__ecereClass_");
2195 FullClassNameCat(className, classSym.string, true);
2196 MangleClassName(className);
2197 DeclareClass(classSym, className);
2200 ProcessExpression(inst.exp);
2202 // Put the instantiation in an InitDeclarator...
2206 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2207 ListAdd(decl.declarators,
2208 MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier), null));
2209 inst.exp.identifier = null;
2213 OldList * list = MkList();
2214 if(ProcessBracketInst(inst, list))
2216 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2217 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2218 MkInitializerList(list)));
2219 inst.exp.identifier = null;
2223 // If bracket instantiation failed (property: for conversions only?)
2224 // TODO: (Fix this so it initializes members through brackets,
2225 // and then does properties)
2228 // TESTING THIS MEMORY LEAK FIX:
2229 FreeList(list, FreeInitializer);
2231 exp = MkExpBrackets(MkList());
2232 ProcessInstMembers(inst, inst.exp, exp.list, true);
2233 ListAdd(exp.list, CopyExpression(inst.exp));
2234 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2235 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2236 MkInitializerAssignment(exp)));
2237 inst.exp.identifier = null;
2246 if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
2247 (classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
2250 sprintf(size, "%d", classSym.registered.templateClass ? classSym.registered.templateClass.structSize : classSym.registered.structSize);
2251 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne(MkExpConstant(size)));
2255 strcpy(className, "__ecereClass_");
2257 if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
2259 classSym = FindClass(classSym.registered.templateClass.fullName);
2260 FullClassNameCat(className, classSym.string, true);
2263 FullClassNameCat(className, inst._class.name, true);
2264 MangleClassName(className);
2266 DeclareClass(classSym, className); // THIS WAS IN C VERSION BUT NOT IN eC VERSION?
2267 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
2268 ProcessExpressionType(newCall);
2269 newCall.byReference = true;
2273 DeclareClass(classSym, className);
2277 Expression exp, newExp;
2278 Identifier id = CopyIdentifier(inst.exp.identifier);
2280 // Put the instantiation in an InitDeclarator...
2281 if(inst.members && inst.members->first)
2283 newExp = MkExpOp(CopyExpression(inst.exp), '=', newCall);
2285 exp = MkExpBrackets(MkList());
2286 ListAdd(exp.list, newExp);
2287 ProcessInstMembers(inst, inst.exp, exp.list, false);
2288 ListAdd(exp.list, inst.exp);
2290 ProcessExpression(inst.exp);
2292 // Take it out since we're using it...
2298 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2299 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(id),
2300 MkInitializerAssignment(exp)));
2301 //inst.exp.identifier = null;
2304 FreeExpression(newCall);
2310 ProcessInstantiation(inst);
2313 case structDeclaration:
2318 for(spec = decl.specifiers->first; spec; spec = spec.next)
2319 ProcessSpecifier(spec);
2326 static void ProcessStatement(Statement stmt)
2332 if(stmt.labeled.stmt)
2333 ProcessStatement(stmt.labeled.stmt);
2336 if(stmt.caseStmt.exp)
2337 ProcessExpression(stmt.caseStmt.exp);
2338 if(stmt.caseStmt.stmt)
2339 ProcessStatement(stmt.caseStmt.stmt);
2343 if(stmt.compound.context)
2347 Statement prevCompound = curCompound;
2348 Context prevContext = curContext;
2350 if(!stmt.compound.isSwitch)
2353 curContext = stmt.compound.context;
2356 if(stmt.compound.declarations)
2358 for(decl = stmt.compound.declarations->first; decl; decl = decl.next)
2359 ProcessDeclaration(decl);
2361 if(stmt.compound.statements)
2363 for(s = stmt.compound.statements->first; s; s = s.next)
2365 ProcessStatement(s);
2369 curCompound = prevCompound;
2370 curContext = prevContext;
2374 case expressionStmt:
2377 if(stmt.expressions)
2379 for(exp = stmt.expressions->first; exp; exp = exp.next)
2381 ProcessExpression(exp);
2390 ((Expression)stmt.ifStmt.exp->last).usage.usageGet = true;
2391 for(exp = stmt.ifStmt.exp->first; exp; exp = exp.next)
2393 ProcessExpression(exp);
2395 if(stmt.ifStmt.stmt)
2396 ProcessStatement(stmt.ifStmt.stmt);
2397 if(stmt.ifStmt.elseStmt)
2398 ProcessStatement(stmt.ifStmt.elseStmt);
2404 ((Expression)stmt.switchStmt.exp->last).usage.usageGet = true;
2405 for(exp = stmt.switchStmt.exp->first; exp; exp = exp.next)
2406 ProcessExpression(exp);
2407 ProcessStatement(stmt.switchStmt.stmt);
2412 if(stmt.whileStmt.exp)
2416 ((Expression)stmt.whileStmt.exp->last).usage.usageGet = true;
2417 for(exp = stmt.whileStmt.exp->first; exp; exp = exp.next)
2419 ProcessExpression(exp);
2422 if(stmt.whileStmt.stmt)
2423 ProcessStatement(stmt.whileStmt.stmt);
2428 if(stmt.doWhile.exp)
2431 ((Expression)stmt.doWhile.exp->last).usage.usageGet = true;
2432 for(exp = stmt.doWhile.exp->first; exp; exp = exp.next)
2434 ProcessExpression(exp);
2437 if(stmt.doWhile.stmt)
2438 ProcessStatement(stmt.doWhile.stmt);
2444 if(stmt.forStmt.init)
2445 ProcessStatement(stmt.forStmt.init);
2447 if(stmt.forStmt.check && stmt.forStmt.check.expressions)
2449 ((Expression)stmt.forStmt.check.expressions->last).usage.usageGet = true;
2452 if(stmt.forStmt.check)
2453 ProcessStatement(stmt.forStmt.check);
2454 if(stmt.forStmt.increment)
2456 for(exp = stmt.forStmt.increment->first; exp; exp = exp.next)
2457 ProcessExpression(exp);
2459 if(stmt.forStmt.stmt)
2460 ProcessStatement(stmt.forStmt.stmt);
2472 if(stmt.expressions && stmt.expressions->last)
2474 ((Expression)stmt.expressions->last).usage.usageGet = true;
2475 for(exp = stmt.expressions->first; exp; exp = exp.next)
2477 ProcessExpression(exp);
2482 case badDeclarationStmt:
2484 ProcessDeclaration(stmt.decl);
2490 if(stmt.asmStmt.inputFields)
2492 for(field = stmt.asmStmt.inputFields->first; field; field = field.next)
2493 if(field.expression)
2494 ProcessExpression(field.expression);
2496 if(stmt.asmStmt.outputFields)
2498 for(field = stmt.asmStmt.outputFields->first; field; field = field.next)
2499 if(field.expression)
2500 ProcessExpression(field.expression);
2502 if(stmt.asmStmt.clobberedFields)
2504 for(field = stmt.asmStmt.clobberedFields->first; field; field = field.next)
2505 if(field.expression)
2506 ProcessExpression(field.expression);
2512 static void ProcessFunction(FunctionDefinition function)
2516 yylloc = function.loc;
2517 ProcessStatement(function.body);
2521 /////////// INSTANTIATIONS / DATA TYPES PASS /////////////////////////////////////////////
2522 public void ProcessInstantiations()
2525 // Is this still needed?
2526 //CreateInstancesBody();
2528 for(external = ast->first; external; external = external.next)
2530 curExternal = external;
2531 if(external.type == declarationExternal)
2533 //currentClass = external.function._class;
2534 if(external.declaration)
2535 ProcessDeclaration(external.declaration);
2537 else if(external.type == functionExternal)
2539 //currentClass = null;
2540 ProcessFunction(external.function);
2542 else if(external.type == classExternal)
2544 ClassDefinition _class = external._class;
2545 //currentClass = external.symbol.registered;
2546 if(_class.definitions)
2549 //Class regClass = _class.symbol.registered;
2551 // Process all functions
2552 for(def = _class.definitions->first; def; def = def.next)
2554 if(def.type == functionClassDef)
2556 curExternal = def.function.declarator ? def.function.declarator.symbol.pointerExternal : external;
2557 ProcessFunction((FunctionDefinition)def.function);
2559 else if(def.type == declarationClassDef && def.decl.type == instDeclaration)
2561 ProcessInstantiation(def.decl.inst);
2563 else if(def.type == defaultPropertiesClassDef && def.defProperties)
2565 MemberInit defProperty;
2567 // Add this to the context
2570 string = CopyString("this");
2571 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2573 globalContext.symbols.Add((BTNode)thisSymbol);
2575 for(defProperty = def.defProperties->first; defProperty; defProperty = defProperty.next)
2577 //thisClass = regClass;
2578 ProcessMemberInitData(defProperty); ///*, regClass, &id
2582 globalContext.symbols.Remove((BTNode)thisSymbol);
2583 FreeSymbol(thisSymbol);
2585 else if(def.type == propertyClassDef && def.propertyDef)
2587 PropertyDef prop = def.propertyDef;
2589 // Add this to the context
2592 string = CopyString("this");
2593 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2595 globalContext.symbols.Add((BTNode)thisSymbol);
2597 //thisClass = regClass;
2600 curExternal = prop.symbol ? prop.symbol.externalSet : null;
2601 ProcessStatement(prop.setStmt);
2605 curExternal = prop.symbol ? prop.symbol.externalGet : null;
2606 ProcessStatement(prop.getStmt);
2610 curExternal = prop.symbol ? prop.symbol.externalIsSet : null;
2611 ProcessStatement(prop.issetStmt);
2615 globalContext.symbols.Remove((BTNode)thisSymbol);
2616 FreeSymbol(thisSymbol);
2618 else if(def.type == propertyWatchClassDef && def.propertyWatch)
2620 PropertyWatch propertyWatch = def.propertyWatch;
2622 // Add this to the context
2625 string = CopyString("this");
2626 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2628 globalContext.symbols.Add((BTNode)thisSymbol);
2630 //thisClass = regClass;
2631 if(propertyWatch.compound)
2635 string = CopyString("this");
2636 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2638 propertyWatch.compound.compound.context.symbols.Add((BTNode)thisSymbol);
2640 ProcessStatement(propertyWatch.compound);
2642 // thisClass = null;
2644 //globalContext.symbols.Delete((BTNode)thisSymbol);
2645 globalContext.symbols.Remove((BTNode)thisSymbol);
2646 FreeSymbol(thisSymbol);