3 #define YYLTYPE Location
6 extern External curExternal;
7 static Statement curCompound;
8 static Statement createInstancesBody;
9 static Statement destroyInstancesBody;
10 static External createInstancesExternal;
11 static External destroyInstancesExternal;
13 static void CreateInstancesBody()
15 if(inCompiler && !createInstancesBody)
17 char registerName[1024], moduleName[MAX_FILENAME];
19 Declarator declarator;
21 createInstancesBody = MkCompoundStmt(null, MkList());
22 createInstancesBody.compound.context = Context { parent = globalContext };
24 specifiers = MkList();
25 ListAdd(specifiers, MkSpecifier(VOID));
27 //strcpy(moduleName, outputFile);
28 GetLastDirectory(outputFile, moduleName);
29 StripExtension(moduleName);
30 FixModuleName(moduleName);
31 sprintf(registerName, "__ecereCreateModuleInstances_%s", moduleName);
33 declarator = MkDeclaratorFunction(MkDeclaratorIdentifier(MkIdentifier(registerName)), null);
36 FunctionDefinition function = _MkFunction(specifiers, declarator, null, false);
37 ProcessFunctionBody(function, createInstancesBody);
38 ListAdd(ast, createInstancesExternal = 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, false);
54 ProcessFunctionBody(function, destroyInstancesBody);
55 ListAdd(ast, destroyInstancesExternal = 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(DataMember) * _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(DataMember) * _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(curExternal, (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(curExternal, 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(DataMember) * _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(DataMember) * _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(instExp && (thisMember || method))
621 Expression instExpCopy = CopyExpression(instExp);
622 Expression setExp = null;
624 instExpCopy.tempCount = instExp.tempCount;
627 ident = MkIdentifier(thisMember.name);
630 Expression memberExp;
631 bool freeMemberExp = false;
633 if(thisMember && thisMember.isProperty && ((Property)thisMember).conversion)
635 if(member.identifiers && member.identifiers->count > 1)
637 Identifier id = member.identifiers->first;
638 // TODO: Set the member types for those
639 memberExp = MkExpMember(instExpCopy, id);
640 for(id = id.next; id; id = id.next)
641 memberExp = MkExpMember(memberExp, id);
644 memberExp = MkExpMember(instExpCopy, ident);
646 if(member.initializer && member.initializer.type == expInitializer && member.initializer.exp)
648 member.initializer.exp.usage.usageGet = true;
649 setExp = MkExpOp(memberExp, '=', member.initializer.exp);
652 member.initializer.exp = null;
653 FreeInitializer(member.initializer);
654 member.initializer = null;
658 freeMemberExp = true;
659 // TOCHECK: WHat happens in here?
661 // TODO: list initializer not working...
662 memberExp.loc = inst.loc;
664 if(member.identifiers)
665 member.identifiers->Clear();
669 setExp.loc = inst.loc;
671 FreeType(instExpCopy.expType);
672 instExpCopy.expType = instExp.expType;
673 if(instExp.expType) instExp.expType.refCount++;
677 ProcessExpressionType(setExp);
678 ProcessExpression(setExp);
680 ListAdd(list, setExp);
683 FreeExpression(memberExp);
691 return fullSet || convert;
694 // We may want to have 2 functions here for dependency on struct or class pointer
695 public void DeclareClass(External neededFor, Symbol classSym, const char * className)
697 /*if(classSym.registered.templateClass)
700 char className[1024];
701 strcpy(className, "__ecereClass_");
702 templateSym = FindClass(classSym.registered.templateClass.fullName);
703 FullClassNameCat(className, templateSym.string, true);
705 DeclareClass(templateSym, className);
707 if(classSym && classSym.notYetDeclared)
709 if(!classSym.mustRegister)
711 if(!classSym._import)
713 if(!classSym.module) classSym.module = mainModule;
714 if(!classSym.module) return;
715 classSym._import = ClassImport
717 isRemote = classSym.registered ? classSym.registered.isRemote : 0;
718 name = CopyString(classSym.string);
720 classSym.module.classes.Add(classSym._import);
722 classSym._import.itself = true;
724 classSym.notYetDeclared = false;
726 if(!classSym.pointerExternal && inCompiler)
729 OldList * specifiers, * declarators;
732 specifiers = MkList();
733 declarators = MkList();
735 ListAdd(specifiers, MkSpecifier(EXTERN));
736 ListAdd(specifiers, MkStructOrUnion(structSpecifier, MkIdentifier("__ecereNameSpace__ecere__com__Class"), null));
738 d = MkDeclaratorPointer(MkPointer(null, null),
739 MkDeclaratorIdentifier(MkIdentifier(className)));
741 ListAdd(declarators, MkInitDeclarator(d, null));
743 decl = MkDeclaration(specifiers, declarators);
745 classSym.pointerExternal = MkExternalDeclaration(decl);
746 ast->Add(classSym.pointerExternal);
748 DeclareStruct(classSym.pointerExternal, "ecere::com::Class", false, true);
751 if(inCompiler && classSym && classSym.pointerExternal && neededFor)
752 neededFor.CreateUniqueEdge(classSym.pointerExternal, false);
755 void ProcessExpressionInstPass(Expression exp)
757 ProcessExpression(exp);
760 static void ProcessExpression(Expression exp)
763 char debugExpString[1024] = "";
764 PrintExpression(exp, debugExpString);
772 Instantiation inst = exp.instance;
773 if(inCompiler && inst._class)
775 char className[1024];
776 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
779 if(classSym && classSym.registered && classSym.registered.type == bitClass)
783 OldList list = { 0 };
785 ProcessInstMembers(inst, null, &list, false);
787 ProcessExpression(inst.exp);
789 //Why was this here twice? ProcessInstMembers(inst, null, &list);
792 exp.op.exp1 = inst.exp;
793 exp.op.exp2 = list.first;
795 // Take expression out... (Why was the comment alone?)
800 Type expType = exp.expType;
801 Expression prev = exp.prev, next = exp.next;
803 ProcessInstMembers(inst, null, &list, false);
806 FreeType(exp.destType);
808 *exp = *(Expression)list.first;
811 Expression firstExp = list.first;
815 FreeType(exp.destType);
816 exp.destType = expType;
817 //if(expType) expType.refCount++;
823 else if(classSym && classSym.registered && (classSym.registered.type == unitClass || classSym.registered.type == enumClass))
827 OldList list = { 0 };
830 ProcessInstMembers(inst, null, &list, false);
832 ProcessExpression(inst.exp);
834 //Why was this here twice? ProcessInstMembers(inst, null, &list);
837 exp.op.exp1 = inst.exp;
838 exp.op.exp2 = list.first;
840 // Take expression out... (Why was the comment alone?)
843 list.Remove(list.first);
844 while((e = list.first))
852 Expression prev = exp.prev, next = exp.next;
853 Type expType = exp.expType;
854 OldList list = { 0 };
855 ProcessInstMembers(inst, null, &list, false);
860 Expression e = list.first;
861 FreeType(exp.destType);
865 exp.expType = expType;
868 while((e = list.first))
876 exp.type = constantExp;
877 exp.constant = CopyString("0");
881 else if(classSym && classSym.registered && classSym.registered.type == structClass)
886 exp.type = bracketsExp;
889 ProcessInstMembers(inst, inst.exp, exp.list, false);
891 ProcessExpression(inst.exp);
895 exp.type = dummyExp; // remove expression
899 // Take expression out... -- It seems ProcessInstMembers() makes copies of it and it needs to be freed now
905 Declaration dummyDecl;
906 // Unnamed instantiation
908 // Make a declaration in the closest compound statement
909 // (Do not reuse (since using address for function calls)...)
912 ListAdd(decls, MkInitDeclarator(
913 MkDeclaratorIdentifier(MkIdentifier(className)), null));
914 decl = MkDeclaration(specs, decls);
916 /* Never mind this... somebody might modify the values...
920 sprintf(className, "__simpleStruct%d", curContext.simpleID++);
921 inst.id = MkIdentifier(className);
922 decl = MkDeclarationInst(inst);
923 exp.type = ExpIdentifier;
924 exp.identifier = inst.id;
925 if(!curCompound.compound.declarations)
926 curCompound.compound.declarations = MkList();
927 curCompound.compound.declarations->Insert(null, decl);
928 ProcessDeclaration(decl);
934 //OldList * specs = MkList(), * decls = MkList();
935 //sprintf(className, "__ecereClassData_%s", inst._class.name);
936 //ListAdd(specs, MkStructOrUnion(SpecifierStruct, MkIdentifier(className), null));
939 // TRICKY STUFF, UGLY HACK FOR stateSizeAnchor = SizeAnchor { size.w = 10 };
940 dummyDecl = MkDeclaration(null,null);
941 if(!curCompound.compound.declarations)
942 curCompound.compound.declarations = MkList();
943 curCompound.compound.declarations->Insert(null, dummyDecl);
945 sprintf(className, "__simpleStruct%d", curContext.simpleID++);
948 OldList * list = MkList();
949 if(inst.isConstant && ProcessBracketInst(inst, list))
951 decl = MkDeclaration(MkList(), MkList());
953 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
954 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(className)),
955 MkInitializerList(list)));
957 exp.type = identifierExp;
958 exp.identifier = MkIdentifier(className);
965 decl = MkDeclarationInst(MkInstantiation(CopySpecifier(inst._class), MkExpIdentifier(MkIdentifier(className)), null));
968 // Set properties & data members in expression
969 // to handle jump and control statements
970 // Set unset data members to 0
971 exp.type = bracketsExp;
974 instExp = QMkExpId(className);
975 instExp.loc = exp.loc;
976 instExp.expType = MkClassType(inst._class.name);
978 // Mark the declarated instance as fullset so it doesn't need to be zeroed out
979 decl.inst.fullSet = ProcessInstMembers(inst, instExp, exp.list, false);
981 ListAdd(exp.list, instExp);
985 FreeType(exp.expType);
986 exp.expType = MkClassType(inst._class.name);
988 // TRICKY STUFF, UGLY HACK FOR stateSizeAnchor = SizeAnchor { size.w = 10 };
990 void * prev = dummyDecl.prev, * next = dummyDecl.next;
992 dummyDecl.prev = prev;
993 dummyDecl.next = next;
997 ProcessDeclaration(decl);
1000 if(!curCompound.compound.declarations)
1001 curCompound.compound.declarations = MkList();
1002 curCompound.compound.declarations->Insert(null, decl);
1011 if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
1012 (classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
1015 Class c = classSym.registered.templateClass ? classSym.registered.templateClass : classSym.registered;
1016 Expression e = MkExpClassSize(MkSpecifierName(c.name));
1017 ProcessExpressionType(e);
1018 sprintf(size, "%d", c.structSize);
1019 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne( e /*MkExpConstant(size)*/));
1020 newCall.byReference = true;
1024 strcpy(className, "__ecereClass_");
1025 if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
1027 classSym = FindClass(classSym.registered.templateClass.fullName);
1028 FullClassNameCat(className, classSym.string, true);
1031 FullClassNameCat(className, inst._class.name, true);
1033 DeclareClass(curExternal, classSym, className);
1034 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
1035 newCall.usage = exp.usage;
1037 ProcessExpressionType(newCall);
1038 if(newCall.expType && exp.expType)
1039 newCall.expType.passAsTemplate = exp.expType.passAsTemplate;
1040 newCall.byReference = true;
1045 if(inst.members && inst.members->first)
1047 exp.type = bracketsExp;
1048 exp.list = MkList();
1052 ListAdd(exp.list, MkExpOp(inst.exp, '=', newCall));
1055 FreeExpression(newCall);
1057 ProcessInstMembers(inst, inst.exp, exp.list, false);
1060 FreeExpression(inst.exp);
1066 exp.op.exp1 = inst.exp;
1067 exp.op.exp2 = newCall;
1069 ProcessExpression(inst.exp);
1075 // Unnamed instantiation
1076 if(inst.members && inst.members->first)
1078 char ecereTemp[100];
1079 MembersInit members;
1080 int tempCount = exp.tempCount;
1083 // Check if members use temp count...
1084 for(members = inst.members->first; members; members = members.next)
1086 if(members.type == dataMembersInit && members.dataMembers)
1089 for(member = members.dataMembers->first; member; member = member.next)
1091 if(member.initializer && member.initializer.type == expInitializer)
1093 ProcessMemberInitData(member); // ADDED THIS TO HAVE PROPER tempCount ALREADY...
1094 tempCount = Max(tempCount, member.initializer.exp.tempCount);
1100 tempCount = Max(tempCount, declTempCount);
1103 curExternal.function.tempCount = Max(curExternal.function.tempCount, tempCount);
1104 sprintf(ecereTemp, "__ecereInstance%d", tempCount);
1105 exp.type = extensionCompoundExp;
1106 exp.compound = MkCompoundStmt(null, null);
1107 exp.compound.compound.context = PushContext();
1108 exp.compound.compound.context.simpleID = exp.compound.compound.context.parent.simpleID;
1109 exp.compound.compound.declarations = MkListOne(QMkDeclaration(inst._class.name, MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(ecereTemp)),
1110 MkInitializerAssignment(newCall))));
1111 exp.compound.compound.statements = MkListOne(MkExpressionStmt((expList = MkList())));
1113 instExp = QMkExpId(ecereTemp);
1114 instExp.tempCount = tempCount;
1115 instExp.expType = MkClassType(inst._class.name);
1116 instExp.byReference = true;
1117 ProcessInstMembers(inst, instExp, expList, false);
1118 FreeExpression(instExp);
1122 Expression tmpExp = QMkExpId(ecereTemp);
1123 tmpExp.byReference = true;
1124 ListAdd(expList, tmpExp);
1126 exp.tempCount = tempCount;
1128 declTempCount = Max(declTempCount, tempCount);
1129 PopContext(exp.compound.compound.context);
1133 Expression prev = exp.prev, next = exp.next;
1134 FreeType(newCall.destType);
1135 FreeType(newCall.expType);
1136 newCall.destType = exp.destType;
1137 newCall.expType = exp.expType;
1145 if(exp.type != instanceExp)
1149 ProcessInstantiation(inst);
1158 // if(exp._new.size) exp._new.size.usage.usageGet = true;
1159 ProcessExpression(exp._new.size);
1163 // if(exp._renew.size) exp._renew.size.usage.usageGet = true;
1164 ProcessExpression(exp._renew.size);
1165 // if(exp._renew.exp) exp._renew.exp.usage.usageGet = true;
1166 ProcessExpression(exp._renew.exp);
1170 //bool assign = false;
1174 // Assignment Operators
1177 exp.op.exp2.usage.usageGet = true;
1179 exp.op.exp1.usage.usageSet = true;
1193 exp.op.exp2.usage.usageGet = true;
1196 exp.op.exp1.usage.usageSet = true;
1202 exp.op.exp1.usage.usageSet = true;
1207 if(exp.op.exp1 && exp.op.exp2)
1209 exp.op.exp1.usage.usageGet = true;
1210 exp.op.exp2.usage.usageGet = true;
1219 exp.op.exp1.usage.usageGet = true;
1224 exp.op.exp2.usage.usageGet = true;
1227 // Binary only operators
1243 exp.op.exp1.usage.usageGet = true;
1245 exp.op.exp2.usage.usageGet = true;
1251 if(exp.op.exp1 && exp.op.exp2 && exp.op.exp1.destType && exp.op.exp1.destType.passAsTemplate && exp.op.exp1.expType && !exp.op.exp1.expType.passAsTemplate && !exp.op.exp1.usage.usageSet)
1254 CopyTypeInto(type, exp.op.exp1.destType);
1255 type.passAsTemplate = false;
1256 FreeType(exp.op.exp1.destType);
1257 exp.op.exp1.destType = type;
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 if(exp.op.exp1 && exp.op.exp2 && exp.op.exp2.destType && exp.op.exp2.destType.passAsTemplate && exp.op.exp2.expType && !exp.op.exp2.expType.passAsTemplate && !exp.op.exp1.usage.usageSet)
1269 CopyTypeInto(type, exp.op.exp2.destType);
1270 type.passAsTemplate = false;
1271 FreeType(exp.op.exp2.destType);
1272 exp.op.exp2.destType = type;
1275 // Don't use the temporaries used by the left side...
1277 // TEST: exp.op.exp2.tempCount = Max(exp.op.exp2.tempCount, exp.op.exp1.tempCount);
1278 exp.op.exp2.tempCount = exp.op.exp1.tempCount;
1279 ProcessExpression(exp.op.exp2);
1280 // TEST: exp.tempCount = Max(exp.op.exp2.tempCount, exp.tempCount);
1284 case extensionExpressionExp:
1288 for(e = exp.list->first; e; e = e.next)
1290 e.tempCount = Max(e.tempCount, exp.tempCount);
1293 e.usage |= (exp.usage & (ExpUsage { usageGet = true, usageArg = true }));
1295 ProcessExpression(e);
1296 exp.tempCount = Max(exp.tempCount, e.tempCount);
1304 exp.index.exp.usage.usageGet = true;
1305 ProcessExpression(exp.index.exp);
1306 for(e = exp.index.index->first; e; e = e.next)
1309 e.usage.usageGet = true;
1310 ProcessExpression(e);
1312 // Ignore temps in the index for now...
1313 exp.tempCount = exp.index.exp.tempCount;
1315 if(exp.index.exp.expType)
1317 Type source = exp.index.exp.expType;
1318 if(source.kind == classType && source._class && source._class.registered && source._class.registered != containerClass &&
1319 eClass_IsDerived(source._class.registered, containerClass))
1321 Class _class = source._class.registered;
1322 // __extension__({ Iterator<type> i { container }; i.Index(e, [ exp.usage.usageSet ]; i.value; });
1324 char iteratorType[1024];
1325 OldList * declarations = MkList();
1326 OldList * statements = MkList();
1327 OldList * args = MkList();
1328 OldList * instMembers = MkList();
1330 Context context = PushContext();
1332 sprintf(iteratorType, "Iterator<%s, %s >", _class.templateArgs[2].dataTypeString, _class.templateArgs[1].dataTypeString);
1334 ListAdd(instMembers, MkMemberInit(null, MkInitializerAssignment(exp.index.exp)));
1336 ListAdd(declarations, MkDeclarationInst(MkInstantiationNamed(MkListOne(MkSpecifierName(iteratorType)),
1337 MkExpIdentifier(MkIdentifier("__internalIterator")), MkListOne(MkMembersInitList(instMembers)))));
1339 ListAdd(args, MkExpBrackets(exp.index.index));
1340 ListAdd(args, exp.usage.usageSet ? MkExpIdentifier(MkIdentifier("true")) : MkExpIdentifier(MkIdentifier("false")));
1342 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpCall(MkExpMember(MkExpIdentifier(MkIdentifier("__internalIterator")),
1343 MkIdentifier("Index")), args))));
1345 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(null, '&', MkExpIdentifier(MkIdentifier("__internalIterator"))))));
1347 exp.type = bracketsExp;
1348 exp.list = MkListOne(MkExpPointer(expExt = (MkExpExtensionCompound(MkCompoundStmt(declarations, statements))), MkIdentifier("data")));
1349 expExt.compound.compound.context = context;
1350 PopContext(context);
1351 expExt.usage = exp.usage;
1352 ProcessExpressionType(exp.list->first);
1353 ProcessExpression(exp.list->first);
1362 //Method method = null;
1364 ProcessExpression(exp.call.exp);
1366 if(exp.call.arguments)
1368 for(e = exp.call.arguments->first; e; e = e.next)
1370 e.usage.usageGet = true;
1371 e.usage.usageArg = true;
1373 // TEST: e.tempCount = Max(e.tempCount, exp.tempCount);
1374 ProcessExpression(e);
1375 // TEST: exp.tempCount = Max(exp.tempCount, e.tempCount);
1382 exp.member.exp.usage.usageGet = true;
1383 // Tweak for LinkList::first to be casted to proper type (e.g. Link) when accessing members
1384 if(exp.member.memberType == dataMember &&
1385 exp.member.exp.expType && exp.member.exp.expType.thisClassFrom && exp.member.exp.expType.kind == classType &&
1386 exp.member.exp.expType._class && exp.member.exp.expType._class.registered &&
1387 !eClass_IsDerived(exp.member.exp.expType.thisClassFrom, exp.member.exp.expType._class.registered))
1388 exp.member.exp.expType.passAsTemplate = true;
1389 ProcessExpression(exp.member.exp);
1391 // Must do this here so we can set the MemberType of deep properties inside instantiations
1392 if(!exp.member.memberType)
1394 Type type = exp.member.exp.expType;
1395 if((type && type.kind == classType && exp.member.member))
1397 // Check if it's an instance
1398 Class _class = (exp.member.member._class && exp.member.member.classSym) ? exp.member.member.classSym.registered : (type._class ? type._class.registered : null);
1399 Property prop = null;
1400 Method method = null;
1401 DataMember member = null;
1402 Property revConvert = null;
1404 // Prioritize data members over properties for "this"
1405 if(exp.member.thisPtr)
1407 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1409 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1411 // Prioritize properties over data members otherwise
1414 // Look for publicAccess Members first
1415 prop = eClass_FindProperty(_class, exp.member.member.string, null);
1417 member = eClass_FindDataMember(_class, exp.member.member.string, null, null, null);
1418 if(!prop && !member)
1420 method = eClass_FindMethod(_class, exp.member.member.string, null);
1423 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1425 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1429 if(!prop && !member && !method) // NOTE: Recently added the !method here, causes private methods to unprioritized
1430 method = eClass_FindMethod(_class, exp.member.member.string, privateModule);
1431 if(!prop && !member && !method)
1433 Symbol classSym = FindClass(exp.member.member.string);
1436 Class convertClass = classSym.registered;
1438 revConvert = eClass_FindProperty(convertClass, _class.fullName, privateModule);
1444 exp.member.memberType = propertyMember;
1446 prop.dataType = ProcessTypeString(prop.dataTypeString, false);
1448 FreeType(exp.expType);
1449 exp.expType = prop.dataType;
1450 if(prop.dataType) prop.dataType.refCount++;
1454 exp.member.memberType = methodMember;
1455 if(!method.dataType)
1456 //method.dataType = ((Symbol)method.symbol).type;
1457 ProcessMethodType(method);
1459 FreeType(exp.expType);
1460 exp.expType = method.dataType;
1461 if(method.dataType) method.dataType.refCount++;
1465 exp.member.memberType = dataMember;
1466 DeclareStruct(curExternal, _class.fullName, false, true);
1467 if(!member.dataType)
1468 member.dataType = ProcessTypeString(member.dataTypeString, false);
1470 FreeType(exp.expType);
1471 exp.expType = member.dataType;
1472 if(member.dataType) member.dataType.refCount++;
1476 exp.member.memberType = reverseConversionMember;
1478 FreeType(exp.expType);
1479 exp.expType = MkClassType(revConvert._class.fullName);
1482 printf($"Error: Couldn't find member %s in class %s\n",
1483 exp.member.member.string, _class.name);*/
1492 //exp.cast.exp.usage.usageGet = true;
1493 exp.cast.exp.usage |= exp.usage;
1494 ProcessExpression(exp.cast.exp);
1500 if(exp.usage.usageGet)
1501 exp.cond.cond.usage.usageGet = true;
1503 ProcessExpression(exp.cond.cond);
1504 for(e = exp.cond.exp->first; e; e = e.next)
1506 if(!e.next && exp.usage.usageGet) e.usage.usageGet = true;
1507 ProcessExpression(e);
1509 if(exp.cond.elseExp)
1511 if(exp.usage.usageGet) exp.cond.elseExp.usage.usageGet = true;
1512 ProcessExpression(exp.cond.elseExp);
1516 case extensionCompoundExp:
1518 if(exp.compound.compound.statements &&
1519 ((Statement)exp.compound.compound.statements->last).type == expressionStmt &&
1520 ((Statement)exp.compound.compound.statements->last).expressions &&
1521 ((Statement)exp.compound.compound.statements->last).expressions->last)
1523 ((Expression)((Statement)exp.compound.compound.statements->last).expressions->last).usage = exp.usage;
1525 ProcessStatement(exp.compound);
1530 ProcessExpression(exp.vaArg.exp);
1533 case extensionInitializerExp:
1535 ProcessInitializer(exp.initializer.initializer);
1539 CheckTemplateTypes(exp);
1542 static void ProcessInitializer(Initializer init)
1546 case expInitializer:
1547 init.exp.usage.usageGet = true;
1548 ProcessExpression(init.exp);
1550 case listInitializer:
1553 for(i = init.list->first; i; i = i.next)
1554 ProcessInitializer(i);
1560 static void ProcessSpecifier(Specifier spec)
1575 for(e = spec.list->first; e; e = e.next)
1578 ProcessExpression(e.exp);
1583 case structSpecifier:
1584 case unionSpecifier:
1587 if(spec.definitions)
1590 for(def = spec.definitions->first; def; def = def.next)
1592 if(def.type == declarationClassDef && def.decl && def.decl.type == structDeclaration)
1593 ProcessDeclaration(def.decl);
1599 case SpecifierClass:
1606 static bool ProcessBracketInst_DataMember(DataMember parentMember, Instantiation inst, OldList list, DataMember namedParentMember, bool parentMemberSet)
1608 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1609 DataMember dataMember = null;
1610 bool someMemberSet = false;
1613 // For simple classes, ensure all members are initialized
1614 for(dataMember = parentMember.members.first; dataMember; dataMember = dataMember.next)
1616 MembersInit members;
1617 MemberInit member = null;
1619 if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1621 OldList * subList = MkList(); //(dataMember.type == structMember) ? MkList() : null;
1623 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember.name ? dataMember : namedParentMember, someMemberSet || parentMemberSet || dataMember.prev))
1626 FreeList(subList, FreeInitializer);
1630 if(subList && subList->count)
1632 Initializer init = MkInitializerList(subList);
1634 sprintf(id, "__anon%d", anonID);
1635 init.id = MkIdentifier(id);
1636 ListAdd(list, init);
1637 someMemberSet = true;
1642 someMemberSet = true;
1649 Class curClass = null;
1650 DataMember curMember = null;
1651 DataMember subMemberStack[256];
1652 int subMemberStackPos = 0;
1655 if(inst.members && inst.members->first)
1657 for(members = inst.members->first; members; members = members.next)
1659 if(members.type == dataMembersInit)
1661 for(member = members.dataMembers->first; member; member = member.next)
1663 if(member.identifiers)
1665 Identifier firstID = member.identifiers->first;
1667 DataMember _subMemberStack[256];
1668 int _subMemberStackPos = 0;
1669 DataMember thisMember;
1670 thisMember = firstID ? (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule) : null;
1671 // FILL MEMBER STACK
1672 if(!thisMember && firstID)
1673 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
1674 if(thisMember && thisMember.memberAccess == publicAccess)
1676 curMember = thisMember;
1677 curClass = curMember._class;
1678 memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
1679 subMemberStackPos = _subMemberStackPos;
1682 BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
1685 curMember = link.data;
1688 // Choose the first specified member of the union...
1689 if(parentMember.type == unionMember)
1692 dataMember = curMember;
1696 if(dataMember == thisMember)
1698 // Look for another member of this one and merge them
1699 // into one instantiation...
1700 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
1702 OldList * partList = MkList();
1703 // TODO: We're assuming this is a simple class right now...
1706 MembersInit nextMembers;
1707 MemberInit next = member.next;
1709 if(!dataMember.dataType)
1710 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1711 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
1712 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
1715 OldList * identifiers = MkList();
1717 for(id = ((Identifier)member.identifiers->first).next; id; id = id.next)
1718 identifiers->Add(CopyIdentifier(id));
1720 // *** THE IDENTIFIERS WERE BEING REUSED, CAUSING A CRASH WITH EXPRESSION TEMPLATE CODE IN pass1.ec ***
1721 // members->Add(MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
1722 /*member.identifiers->Remove(firstID);*/
1724 MkMemberInit(/*member.identifiers*/identifiers, MkInitializerAssignment(member.initializer.exp)));
1727 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
1729 if(!nextMembers.dataMembers)
1732 if(members != nextMembers) next = nextMembers.dataMembers->first;
1734 if(nextMembers.type == dataMembersInit)
1736 MemberInit nextMember;
1738 for(nextMember = next; nextMember;
1739 nextMember = next, next = nextMember ? nextMember.next : null)
1741 Identifier nextID = nextMember.identifiers->first;
1742 if(nextMember.identifiers &&
1743 nextMember.identifiers->count > 1 &&
1744 !strcmp(firstID.string, nextID.string))
1746 nextMembers.dataMembers->Remove(nextMember);
1747 nextMember.identifiers->Remove(nextID);
1748 ListAdd(partList, nextMember);
1754 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
1755 MkListOne(MkMembersInitList(partList))));
1763 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1764 if(curMember == dataMember)
1772 curMember = curMember.next;
1774 curMember = parentMember.members.first;
1776 if(curMember == dataMember)
1789 if(member && member.initializer && member.initializer.type == expInitializer)
1791 Initializer init { loc = yylloc };
1792 if(namedParentMember.type == unionMember && dataMember.name)
1793 init.id = MkIdentifier(dataMember.name);
1795 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
1796 member.initializer.exp.expType._class.registered.type == structClass)
1798 OldList * subList = MkList();
1799 ProcessBracketInst(member.initializer.exp.instance, subList);
1800 FreeExpression(member.initializer.exp);
1803 init.type = listInitializer;
1804 init.list = subList;
1808 FreeInitializer(init);
1814 member.initializer.exp.usage.usageGet = true;
1815 ProcessExpression(member.initializer.exp);
1816 init.type = expInitializer;
1817 init.exp = member.initializer.exp;
1820 ListAdd(list, init);
1822 member.initializer.exp = null;
1823 FreeInitializer(member.initializer);
1824 member.initializer = null;
1825 someMemberSet = true;
1827 else if(member && member.initializer && member.initializer.type == listInitializer)
1829 if(namedParentMember.type == unionMember && dataMember.name)
1830 member.initializer.id = MkIdentifier(dataMember.name);
1832 ListAdd(list, member.initializer);
1833 member.initializer = null;
1834 someMemberSet = true;
1836 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/ && parentMember.type != unionMember && namedParentMember.type != unionMember)
1839 Initializer init { loc = yylloc };
1840 if(namedParentMember.type == unionMember && dataMember.name)
1841 init.id = MkIdentifier(dataMember.name);
1843 if(!dataMember.dataType)
1844 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1845 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1846 if(classSym && classSym.registered && classSym.registered.type == structClass)
1848 OldList * subList = MkList();
1849 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1850 Instantiation inst = MkInstantiation(spec, null, null);
1851 ProcessBracketInst(inst, subList);
1856 init.type = listInitializer;
1857 init.list = subList;
1861 FreeInitializer(init);
1867 init.type = expInitializer;
1868 init.exp = MkExpConstant("0");
1870 someMemberSet = true;
1872 ListAdd(list, init);
1876 if(parentMember.type == unionMember)
1880 // TESTING THIS NEW CODE FOR ANCHORS...
1881 if(/*parentMember.type == unionMember && */!someMemberSet && !parentMemberSet)
1884 Initializer init { loc = yylloc };
1886 dataMember = parentMember.members.first;
1887 if(namedParentMember.type == unionMember && dataMember.name)
1888 init.id = MkIdentifier(dataMember.name);
1890 if(!dataMember.dataType && dataMember.dataTypeString)
1891 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1892 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1893 if(classSym && classSym.registered && classSym.registered.type == structClass)
1895 OldList * subList = MkList();
1896 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1897 Instantiation inst = MkInstantiation(spec, null, null);
1898 ProcessBracketInst(inst, subList);
1901 init.type = listInitializer;
1902 init.list = subList;
1904 else if(dataMember.dataType && (dataMember.dataType.kind == arrayType || dataMember.dataType.kind == structType))
1906 Type t = dataMember.dataType.kind == arrayType ? dataMember.dataType.type : dataMember.dataType.members.first;
1907 Initializer i = MkInitializerAssignment(MkExpConstant("0"));
1908 while(t && (t.kind == arrayType || t.kind == structType))
1910 i = MkInitializerList(MkListOne(i));
1911 if(t.kind == arrayType)
1913 else if(t.kind == structType)
1914 t = t.members.first;
1916 init.type = listInitializer;
1917 init.list = MkListOne(i);
1921 init.type = expInitializer;
1922 init.exp = MkExpConstant("0");
1924 ListAdd(list, init);
1929 static bool ProcessBracketInst(Instantiation inst, OldList list)
1931 static int recursionCount = 0;
1932 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1933 Class _class = null;
1936 if(recursionCount > 500) return false;
1939 while(_class != classSym.registered)
1941 DataMember dataMember;
1942 Class lastClass = _class;
1944 for(_class = classSym.registered; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
1946 for(dataMember = _class.membersAndProperties.first; dataMember; dataMember = dataMember.next)
1948 if(!dataMember.isProperty && !dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1950 OldList * subList = MkList(); //(dataMember.type == structMember ? MkList() : null);
1952 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, false))
1955 FreeList(subList, FreeInitializer);
1959 if(dataMember.type == structMember || (subList && subList->count))
1961 Initializer init = MkInitializerList(subList);
1963 sprintf(id, "__anon%d", anonID);
1964 init.id = MkIdentifier(id);
1965 ListAdd(list, init);
1973 MembersInit members;
1974 MemberInit member = null;
1977 if(inst.members && inst.members->first)
1979 DataMember curMember = null;
1980 Class curClass = null;
1981 DataMember subMemberStack[256];
1982 int subMemberStackPos = 0;
1984 for(members = inst.members->first; members; members = members.next)
1986 if(members.type == dataMembersInit)
1988 for(member = members.dataMembers->first; member; member = member.next)
1990 Identifier firstID = member.identifiers ? member.identifiers->first : null;
1993 DataMember _subMemberStack[256];
1994 int _subMemberStackPos = 0;
1995 DataMember thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
1996 // FILL MEMBER STACK
1998 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
2001 curMember = thisMember;
2002 curClass = curMember._class;
2003 memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
2004 subMemberStackPos = _subMemberStackPos;
2007 if(curMember == dataMember)
2009 if(dataMember.isProperty)
2011 if(!((Property)dataMember).Set)
2013 Compiler_Error($"No set defined for property %s\n", dataMember.name);
2020 // Look for another member of this one and merge them
2021 // into one instantiation...
2022 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
2024 OldList * partList = MkList();
2025 // TODO: We're assuming this is a simple _class right now...
2027 MembersInit nextMembers;
2028 MemberInit next = member.next;
2030 if(!dataMember.dataType)
2031 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
2032 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
2033 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
2035 member.identifiers->Remove(firstID);
2037 MkMemberInit(member.identifiers, MkInitializerAssignment(member.initializer.exp)));
2039 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
2041 if(!nextMembers.dataMembers) continue;
2043 if(members != nextMembers) next = nextMembers.dataMembers->first;
2045 if(nextMembers.type == dataMembersInit)
2047 MemberInit nextMember;
2049 for(nextMember = next; nextMember;
2050 nextMember = next, next = nextMember ? nextMember.next : null)
2052 Identifier nextID = nextMember.identifiers->first;
2053 if(nextMember.identifiers &&
2054 nextMember.identifiers->count > 1 &&
2055 !strcmp(firstID.string, nextID.string))
2057 nextMembers.dataMembers->Remove(nextMember);
2058 nextMember.identifiers->Remove(nextID);
2059 ListAdd(partList, nextMember);
2065 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
2066 MkListOne(MkMembersInitList(partList))));
2069 member.identifiers = null;
2077 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2078 if(curMember == dataMember)
2080 if(dataMember.isProperty)
2082 if(!((Property)dataMember).Set)
2084 Compiler_Error($"No set defined for property %s\n", dataMember.name);
2100 if(dataMember.isProperty) continue;
2101 if(member && member.initializer && member.initializer.type == expInitializer)
2103 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
2104 member.initializer.exp.expType._class && member.initializer.exp.expType._class.registered && member.initializer.exp.expType._class.registered.type == structClass)
2106 OldList * subList = MkList();
2107 ProcessBracketInst(member.initializer.exp.instance, subList);
2108 FreeExpression(member.initializer.exp);
2109 member.initializer.exp = null;
2110 ListAdd(list, MkInitializerList(subList));
2114 member.initializer.exp.usage.usageGet = true;
2115 ProcessExpression(member.initializer.exp);
2116 ListAdd(list, MkInitializerAssignment(CopyExpression(member.initializer.exp)));
2120 // member.exp = null;
2121 member.takeOutExp = true;
2123 else if(member && member.initializer && member.initializer.type == listInitializer)
2125 ListAdd(list, member.initializer);
2126 member.initializer = null;
2128 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/)
2132 if(!dataMember.dataType)
2133 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
2134 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
2136 if(classSym && classSym.registered && classSym.registered.type == structClass)
2138 OldList * subList = MkList();
2139 Specifier spec = _MkSpecifierName(dataMember.dataTypeString, classSym, null);
2140 Instantiation inst = MkInstantiation(spec, null, null);
2141 ProcessBracketInst(inst, subList);
2143 ListAdd(list, MkInitializerList(subList));
2145 else if(dataMember.dataType.kind == arrayType)
2147 Type t = dataMember.dataType.type;
2148 Initializer inner = MkInitializerAssignment(null), i = inner;
2149 while(t && t.kind == arrayType)
2151 i = MkInitializerList(MkListOne(i));
2154 if(t && t.kind == classType && t._class && t._class.registered && t._class.registered.type == structClass)
2156 OldList * subList = MkList();
2157 Specifier spec = _MkSpecifierName(t._class.registered.name, classSym, null);
2158 Instantiation inst = MkInstantiation(spec, null, null);
2159 ProcessBracketInst(inst, subList);
2161 inner.type = listInitializer;
2162 inner.list = subList;
2165 inner.exp = MkExpConstant("0");
2166 ListAdd(list, MkInitializerList(MkListOne(i)));
2169 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
2175 if(inst.members && inst.members->first)
2177 MembersInit members;
2178 MemberInit member = null;
2180 for(members = inst.members->first; members; members = members.next)
2182 if(members.type == dataMembersInit)
2184 for(member = members.dataMembers->first; member; member = member.next)
2186 if(member.takeOutExp)
2188 FreeInitializer(member.initializer);
2189 member.initializer = null;
2199 static Declaration curDecl;
2200 static int declTempCount;
2202 static void ProcessDeclaration(Declaration decl)
2207 case initDeclaration:
2209 if(!curDecl) { curDecl = decl; declTempCount = 0; }
2213 for(s = decl.specifiers->first; s; s = s.next)
2215 ProcessSpecifier(s);
2218 if(decl.declarators)
2222 for(d = decl.declarators->first; d; d = d.next)
2225 ProcessInitializer(d.initializer);
2228 if(curDecl == decl) { curDecl = null; declTempCount = 0; }
2231 case instDeclaration:
2233 Instantiation inst = decl.inst;
2237 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
2242 if(!inst.isConstant || (classSym && classSym.registered && (classSym.registered.type == normalClass || classSym.registered.type == noHeadClass)))
2244 // If this instantiation is outside, turn it into a declaration plus an instantiation expression
2245 decl.type = initDeclaration;
2246 decl.specifiers = MkListOne(MkSpecifierName/*MkClassName*/(inst._class.name));
2247 if(decl.declMode == staticAccess)
2249 decl.specifiers->Insert(null, MkSpecifier(STATIC));
2251 decl.declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst.exp.identifier.string)), null));
2253 ProcessDeclaration(decl);
2254 CreateInstancesBody();
2257 Expression exp = MkExpInstance(inst);
2258 stmt = MkExpressionStmt(MkListOne(exp)); // MkExpOp(inst.exp, '=',
2259 ListAdd(createInstancesBody.compound.statements, stmt);
2260 ProcessExpressionType(exp);
2263 if(classSym && classSym.registered && (classSym.registered.type == normalClass))
2265 ListAdd(createInstancesBody.compound.statements,
2266 MkExpressionStmt(MkListOne(MkExpCall(
2267 MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")),
2268 MkListOne(CopyExpression(inst.exp))))));
2270 // We'd like the = 0 as well...
2272 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2273 ListAddFront(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2274 ProcessExpressionType(exp);
2277 else if(classSym && classSym.registered && (classSym.registered.type == noHeadClass))
2279 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2280 ListAddFront(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2281 ProcessExpressionType(exp);
2284 createInstancesExternal.CreateEdge(curExternal, false);
2285 destroyInstancesExternal.CreateEdge(curExternal, false);
2290 // Precompiler won't know if this isn't constant
2291 CreateInstancesBody();
2296 char className[1024];
2299 decl.type = initDeclaration;
2300 decl.specifiers = MkList();
2301 decl.declarators = MkList();
2303 // Replace instantiation here
2304 if(classSym && classSym.registered && classSym.registered.type == bitClass)
2306 OldList list = { 0 };
2308 // Put the instantiation in an InitDeclarator...
2309 ProcessInstMembers(inst, inst.exp, &list, false);
2310 ProcessExpression(inst.exp);
2312 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2313 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2314 MkInitializerAssignment(list.first)));
2315 inst.exp.identifier = null;
2317 else if(classSym && classSym.registered && classSym.registered.type == unitClass)
2319 OldList list = { 0 };
2321 // Put the instantiation in an InitDeclarator...
2322 ProcessInstMembers(inst, inst.exp, &list, false);
2323 ProcessExpression(inst.exp);
2325 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2326 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2327 MkInitializerAssignment(list.first)));
2329 inst.exp.identifier = null;
2331 else if(classSym && classSym.registered && classSym.registered.type == structClass)
2335 DeclareStruct(curExternal, inst._class.name, false, true);
2337 strcpy(className, "__ecereClass_");
2338 FullClassNameCat(className, classSym.string, true);
2339 DeclareClass(classSym, className);
2342 ProcessExpression(inst.exp);
2344 // Put the instantiation in an InitDeclarator...
2348 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2349 ListAdd(decl.declarators,
2350 MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier), null));
2351 inst.exp.identifier = null;
2355 OldList * list = MkList();
2356 if(ProcessBracketInst(inst, list))
2358 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2359 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2360 MkInitializerList(list)));
2361 inst.exp.identifier = null;
2365 // If bracket instantiation failed (property: for conversions only?)
2366 // TODO: (Fix this so it initializes members through brackets,
2367 // and then does properties)
2370 // TESTING THIS MEMORY LEAK FIX:
2371 FreeList(list, FreeInitializer);
2373 exp = MkExpBrackets(MkList());
2374 ProcessInstMembers(inst, inst.exp, exp.list, true);
2375 ListAdd(exp.list, CopyExpression(inst.exp));
2376 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2377 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2378 MkInitializerAssignment(exp)));
2379 inst.exp.identifier = null;
2388 strcpy(className, "__ecereClass_");
2390 if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
2392 classSym = FindClass(classSym.registered.templateClass.fullName);
2393 FullClassNameCat(className, classSym.string, true);
2396 FullClassNameCat(className, inst._class.name, true);
2399 DeclareClass(curExternal, classSym, className);
2401 if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
2402 (classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
2405 Class c = classSym.registered.templateClass ? classSym.registered.templateClass : classSym.registered;
2406 Expression e = MkExpClassSize(MkSpecifierName(c.name));
2407 ProcessExpressionType(e);
2408 sprintf(size, "%d", c.structSize);
2409 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne( e /*MkExpConstant(size)*/));
2413 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
2414 ProcessExpressionType(newCall);
2415 newCall.byReference = true;
2420 Expression exp, newExp;
2421 Identifier id = CopyIdentifier(inst.exp.identifier);
2423 // Put the instantiation in an InitDeclarator...
2424 if(inst.members && inst.members->first)
2426 newExp = MkExpOp(CopyExpression(inst.exp), '=', newCall);
2428 exp = MkExpBrackets(MkList());
2429 ListAdd(exp.list, newExp);
2430 ProcessInstMembers(inst, inst.exp, exp.list, false);
2431 ListAdd(exp.list, inst.exp);
2433 ProcessExpression(inst.exp);
2435 // Take it out since we're using it...
2441 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2442 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(id),
2443 MkInitializerAssignment(exp)));
2444 //inst.exp.identifier = null;
2447 FreeExpression(newCall);
2453 ProcessInstantiation(inst);
2456 case structDeclaration:
2461 for(spec = decl.specifiers->first; spec; spec = spec.next)
2462 ProcessSpecifier(spec);
2469 static void ProcessStatement(Statement stmt)
2475 if(stmt.labeled.stmt)
2476 ProcessStatement(stmt.labeled.stmt);
2479 if(stmt.caseStmt.exp)
2480 ProcessExpression(stmt.caseStmt.exp);
2481 if(stmt.caseStmt.stmt)
2482 ProcessStatement(stmt.caseStmt.stmt);
2486 if(stmt.compound.context)
2490 Statement prevCompound = curCompound;
2491 Context prevContext = curContext;
2493 if(!stmt.compound.isSwitch)
2496 curContext = stmt.compound.context;
2499 if(stmt.compound.declarations)
2501 for(decl = stmt.compound.declarations->first; decl; decl = decl.next)
2502 ProcessDeclaration(decl);
2504 if(stmt.compound.statements)
2506 for(s = stmt.compound.statements->first; s; s = s.next)
2508 ProcessStatement(s);
2512 curCompound = prevCompound;
2513 curContext = prevContext;
2517 case expressionStmt:
2520 if(stmt.expressions)
2522 for(exp = stmt.expressions->first; exp; exp = exp.next)
2524 ProcessExpression(exp);
2533 ((Expression)stmt.ifStmt.exp->last).usage.usageGet = true;
2534 for(exp = stmt.ifStmt.exp->first; exp; exp = exp.next)
2536 ProcessExpression(exp);
2538 if(stmt.ifStmt.stmt)
2539 ProcessStatement(stmt.ifStmt.stmt);
2540 if(stmt.ifStmt.elseStmt)
2541 ProcessStatement(stmt.ifStmt.elseStmt);
2547 ((Expression)stmt.switchStmt.exp->last).usage.usageGet = true;
2548 for(exp = stmt.switchStmt.exp->first; exp; exp = exp.next)
2549 ProcessExpression(exp);
2550 ProcessStatement(stmt.switchStmt.stmt);
2555 if(stmt.whileStmt.exp)
2559 ((Expression)stmt.whileStmt.exp->last).usage.usageGet = true;
2560 for(exp = stmt.whileStmt.exp->first; exp; exp = exp.next)
2562 ProcessExpression(exp);
2565 if(stmt.whileStmt.stmt)
2566 ProcessStatement(stmt.whileStmt.stmt);
2571 if(stmt.doWhile.exp)
2574 ((Expression)stmt.doWhile.exp->last).usage.usageGet = true;
2575 for(exp = stmt.doWhile.exp->first; exp; exp = exp.next)
2577 ProcessExpression(exp);
2580 if(stmt.doWhile.stmt)
2581 ProcessStatement(stmt.doWhile.stmt);
2587 if(stmt.forStmt.init)
2588 ProcessStatement(stmt.forStmt.init);
2590 if(stmt.forStmt.check && stmt.forStmt.check.expressions)
2592 ((Expression)stmt.forStmt.check.expressions->last).usage.usageGet = true;
2595 if(stmt.forStmt.check)
2596 ProcessStatement(stmt.forStmt.check);
2597 if(stmt.forStmt.increment)
2599 for(exp = stmt.forStmt.increment->first; exp; exp = exp.next)
2600 ProcessExpression(exp);
2602 if(stmt.forStmt.stmt)
2603 ProcessStatement(stmt.forStmt.stmt);
2615 if(stmt.expressions && stmt.expressions->last)
2617 ((Expression)stmt.expressions->last).usage.usageGet = true;
2618 for(exp = stmt.expressions->first; exp; exp = exp.next)
2620 ProcessExpression(exp);
2625 case badDeclarationStmt:
2627 ProcessDeclaration(stmt.decl);
2633 if(stmt.asmStmt.inputFields)
2635 for(field = stmt.asmStmt.inputFields->first; field; field = field.next)
2636 if(field.expression)
2637 ProcessExpression(field.expression);
2639 if(stmt.asmStmt.outputFields)
2641 for(field = stmt.asmStmt.outputFields->first; field; field = field.next)
2642 if(field.expression)
2643 ProcessExpression(field.expression);
2645 if(stmt.asmStmt.clobberedFields)
2647 for(field = stmt.asmStmt.clobberedFields->first; field; field = field.next)
2648 if(field.expression)
2649 ProcessExpression(field.expression);
2655 static void ProcessFunction(FunctionDefinition function)
2659 yylloc = function.loc;
2660 ProcessStatement(function.body);
2664 /////////// INSTANTIATIONS / DATA TYPES PASS /////////////////////////////////////////////
2665 public void ProcessInstantiations()
2668 // Is this still needed?
2669 //CreateInstancesBody();
2671 for(external = ast->first; external; external = external.next)
2673 curExternal = external;
2674 if(external.type == declarationExternal)
2676 //currentClass = external.function._class;
2677 if(external.declaration)
2679 bool isInstance = external.declaration.type == instDeclaration;
2680 Symbol sym = isInstance ? FindClass(external.declaration.inst._class.name) : null;
2681 ProcessDeclaration(external.declaration);
2685 // Move edges to the global instances to the create instance body instead
2687 for(e = external.incoming.first; e; e = next)
2689 External from = e.from;
2693 if(from.incoming.count)
2695 bool reroute = true;
2696 if(sym && sym.registered && sym.registered.type == structClass)
2698 else if(from.type == declarationExternal && from.declaration && (!from.declaration.declarators || !from.declaration.declarators->count) && from.declaration.specifiers)
2700 Specifier spec = null;
2701 for(spec = from.declaration.specifiers->first; spec; spec = spec.next)
2703 if(spec.type == structSpecifier || spec.type == unionSpecifier)
2706 if(sym.registered && spec && spec.id && spec.id.string)
2708 char className[1024];
2709 Class c = sym.registered;
2710 strcpy(className, "__ecereClass_");
2711 if(c.type == noHeadClass && c.templateClass)
2712 FullClassNameCat(className, c.templateClass.name, true);
2714 FullClassNameCat(className, c.name, true);
2715 if(!strcmp(c.name, spec.id.string))
2722 e.to = createInstancesExternal;
2723 external.incoming.Remove((IteratorPointer)e);
2724 for(i : createInstancesExternal.incoming)
2729 if(i.breakable && !e.breakable)
2732 createInstancesExternal.nonBreakableIncoming++;
2739 external.nonBreakableIncoming--;
2740 e.from.outgoing.Remove((IteratorPointer)e);
2745 createInstancesExternal.incoming.Add(e);
2748 external.nonBreakableIncoming--;
2749 createInstancesExternal.nonBreakableIncoming++;
2758 else if(external.type == functionExternal)
2760 //currentClass = null;
2761 ProcessFunction(external.function);
2763 else if(external.type == classExternal)
2765 ClassDefinition _class = external._class;
2766 //currentClass = external.symbol.registered;
2767 if(_class.definitions)
2770 //Class regClass = _class.symbol.registered;
2772 // Process all functions
2773 for(def = _class.definitions->first; def; def = def.next)
2775 if(def.type == functionClassDef)
2777 curExternal = def.function.declarator ? def.function.declarator.symbol.pointerExternal : external;
2778 ProcessFunction((FunctionDefinition)def.function);
2780 else if(def.type == declarationClassDef && def.decl.type == instDeclaration)
2782 ProcessInstantiation(def.decl.inst);
2784 else if(def.type == defaultPropertiesClassDef && def.defProperties)
2786 MemberInit defProperty;
2788 // Add this to the context
2791 string = CopyString("this");
2792 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2794 globalContext.symbols.Add((BTNode)thisSymbol);
2796 for(defProperty = def.defProperties->first; defProperty; defProperty = defProperty.next)
2798 //thisClass = regClass;
2799 ProcessMemberInitData(defProperty); ///*, regClass, &id
2803 globalContext.symbols.Remove((BTNode)thisSymbol);
2804 FreeSymbol(thisSymbol);
2806 else if(def.type == propertyClassDef && def.propertyDef)
2808 PropertyDef prop = def.propertyDef;
2810 // Add this to the context
2813 string = CopyString("this");
2814 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2816 globalContext.symbols.Add((BTNode)thisSymbol);
2818 //thisClass = regClass;
2821 curExternal = prop.symbol ? prop.symbol.externalSet : null;
2822 ProcessStatement(prop.setStmt);
2826 curExternal = prop.symbol ? prop.symbol.externalGet : null;
2827 ProcessStatement(prop.getStmt);
2831 curExternal = prop.symbol ? prop.symbol.externalIsSet : null;
2832 ProcessStatement(prop.issetStmt);
2836 globalContext.symbols.Remove((BTNode)thisSymbol);
2837 FreeSymbol(thisSymbol);
2839 else if(def.type == propertyWatchClassDef && def.propertyWatch)
2841 PropertyWatch propertyWatch = def.propertyWatch;
2843 // Add this to the context
2846 string = CopyString("this");
2847 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2849 globalContext.symbols.Add((BTNode)thisSymbol);
2851 //thisClass = regClass;
2852 if(propertyWatch.compound)
2854 /* This was already added in pass15:ProcessClass()
2857 string = CopyString("this");
2858 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2860 propertyWatch.compound.compound.context.symbols.Add((BTNode)thisSymbol);
2862 ProcessStatement(propertyWatch.compound);
2864 // thisClass = null;
2866 //globalContext.symbols.Delete((BTNode)thisSymbol);
2867 globalContext.symbols.Remove((BTNode)thisSymbol);
2868 FreeSymbol(thisSymbol);