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 ProcessExpression(exp.member.exp);
1385 // Must do this here so we can set the MemberType of deep properties inside instantiations
1386 if(!exp.member.memberType)
1388 Type type = exp.member.exp.expType;
1389 if((type && type.kind == classType && exp.member.member))
1391 // Check if it's an instance
1392 Class _class = (exp.member.member._class && exp.member.member.classSym) ? exp.member.member.classSym.registered : (type._class ? type._class.registered : null);
1393 Property prop = null;
1394 Method method = null;
1395 DataMember member = null;
1396 Property revConvert = null;
1398 // Prioritize data members over properties for "this"
1399 if(exp.member.thisPtr)
1401 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1403 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1405 // Prioritize properties over data members otherwise
1408 // Look for publicAccess Members first
1409 prop = eClass_FindProperty(_class, exp.member.member.string, null);
1411 member = eClass_FindDataMember(_class, exp.member.member.string, null, null, null);
1412 if(!prop && !member)
1414 method = eClass_FindMethod(_class, exp.member.member.string, null);
1417 prop = eClass_FindProperty(_class, exp.member.member.string, privateModule);
1419 member = eClass_FindDataMember(_class, exp.member.member.string, privateModule, null, null);
1423 if(!prop && !member && !method) // NOTE: Recently added the !method here, causes private methods to unprioritized
1424 method = eClass_FindMethod(_class, exp.member.member.string, privateModule);
1425 if(!prop && !member && !method)
1427 Symbol classSym = FindClass(exp.member.member.string);
1430 Class convertClass = classSym.registered;
1432 revConvert = eClass_FindProperty(convertClass, _class.fullName, privateModule);
1438 exp.member.memberType = propertyMember;
1440 prop.dataType = ProcessTypeString(prop.dataTypeString, false);
1442 FreeType(exp.expType);
1443 exp.expType = prop.dataType;
1444 if(prop.dataType) prop.dataType.refCount++;
1448 exp.member.memberType = methodMember;
1449 if(!method.dataType)
1450 //method.dataType = ((Symbol)method.symbol).type;
1451 ProcessMethodType(method);
1453 FreeType(exp.expType);
1454 exp.expType = method.dataType;
1455 if(method.dataType) method.dataType.refCount++;
1459 exp.member.memberType = dataMember;
1460 DeclareStruct(curExternal, _class.fullName, false, true);
1461 if(!member.dataType)
1462 member.dataType = ProcessTypeString(member.dataTypeString, false);
1464 FreeType(exp.expType);
1465 exp.expType = member.dataType;
1466 if(member.dataType) member.dataType.refCount++;
1470 exp.member.memberType = reverseConversionMember;
1472 FreeType(exp.expType);
1473 exp.expType = MkClassType(revConvert._class.fullName);
1476 printf($"Error: Couldn't find member %s in class %s\n",
1477 exp.member.member.string, _class.name);*/
1486 //exp.cast.exp.usage.usageGet = true;
1487 exp.cast.exp.usage |= exp.usage;
1488 ProcessExpression(exp.cast.exp);
1494 if(exp.usage.usageGet)
1495 exp.cond.cond.usage.usageGet = true;
1497 ProcessExpression(exp.cond.cond);
1498 for(e = exp.cond.exp->first; e; e = e.next)
1500 if(!e.next && exp.usage.usageGet) e.usage.usageGet = true;
1501 ProcessExpression(e);
1503 if(exp.cond.elseExp)
1505 if(exp.usage.usageGet) exp.cond.elseExp.usage.usageGet = true;
1506 ProcessExpression(exp.cond.elseExp);
1510 case extensionCompoundExp:
1512 if(exp.compound.compound.statements &&
1513 ((Statement)exp.compound.compound.statements->last).type == expressionStmt &&
1514 ((Statement)exp.compound.compound.statements->last).expressions &&
1515 ((Statement)exp.compound.compound.statements->last).expressions->last)
1517 ((Expression)((Statement)exp.compound.compound.statements->last).expressions->last).usage = exp.usage;
1519 ProcessStatement(exp.compound);
1524 ProcessExpression(exp.vaArg.exp);
1527 case extensionInitializerExp:
1529 ProcessInitializer(exp.initializer.initializer);
1533 CheckTemplateTypes(exp);
1536 static void ProcessInitializer(Initializer init)
1540 case expInitializer:
1541 init.exp.usage.usageGet = true;
1542 ProcessExpression(init.exp);
1544 case listInitializer:
1547 for(i = init.list->first; i; i = i.next)
1548 ProcessInitializer(i);
1554 static void ProcessSpecifier(Specifier spec)
1569 for(e = spec.list->first; e; e = e.next)
1572 ProcessExpression(e.exp);
1577 case structSpecifier:
1578 case unionSpecifier:
1581 if(spec.definitions)
1584 for(def = spec.definitions->first; def; def = def.next)
1586 if(def.type == declarationClassDef && def.decl && def.decl.type == structDeclaration)
1587 ProcessDeclaration(def.decl);
1593 case SpecifierClass:
1600 static bool ProcessBracketInst_DataMember(DataMember parentMember, Instantiation inst, OldList list, DataMember namedParentMember, bool parentMemberSet)
1602 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1603 DataMember dataMember = null;
1604 bool someMemberSet = false;
1607 // For simple classes, ensure all members are initialized
1608 for(dataMember = parentMember.members.first; dataMember; dataMember = dataMember.next)
1610 MembersInit members;
1611 MemberInit member = null;
1613 if(!dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1615 OldList * subList = MkList(); //(dataMember.type == structMember) ? MkList() : null;
1617 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember.name ? dataMember : namedParentMember, someMemberSet || parentMemberSet || dataMember.prev))
1620 FreeList(subList, FreeInitializer);
1624 if(subList && subList->count)
1626 Initializer init = MkInitializerList(subList);
1628 sprintf(id, "__anon%d", anonID);
1629 init.id = MkIdentifier(id);
1630 ListAdd(list, init);
1631 someMemberSet = true;
1636 someMemberSet = true;
1643 Class curClass = null;
1644 DataMember curMember = null;
1645 DataMember subMemberStack[256];
1646 int subMemberStackPos = 0;
1649 if(inst.members && inst.members->first)
1651 for(members = inst.members->first; members; members = members.next)
1653 if(members.type == dataMembersInit)
1655 for(member = members.dataMembers->first; member; member = member.next)
1657 if(member.identifiers)
1659 Identifier firstID = member.identifiers->first;
1661 DataMember _subMemberStack[256];
1662 int _subMemberStackPos = 0;
1663 DataMember thisMember;
1664 thisMember = firstID ? (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule) : null;
1665 // FILL MEMBER STACK
1666 if(!thisMember && firstID)
1667 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
1668 if(thisMember && thisMember.memberAccess == publicAccess)
1670 curMember = thisMember;
1671 curClass = curMember._class;
1672 memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
1673 subMemberStackPos = _subMemberStackPos;
1676 BTNamedLink link = parentMember.membersAlpha.Find((uintptr)firstID.string);
1679 curMember = link.data;
1682 // Choose the first specified member of the union...
1683 if(parentMember.type == unionMember)
1686 dataMember = curMember;
1690 if(dataMember == thisMember)
1692 // Look for another member of this one and merge them
1693 // into one instantiation...
1694 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
1696 OldList * partList = MkList();
1697 // TODO: We're assuming this is a simple class right now...
1700 MembersInit nextMembers;
1701 MemberInit next = member.next;
1703 if(!dataMember.dataType)
1704 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1705 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
1706 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
1709 OldList * identifiers = MkList();
1711 for(id = ((Identifier)member.identifiers->first).next; id; id = id.next)
1712 identifiers->Add(CopyIdentifier(id));
1714 // *** THE IDENTIFIERS WERE BEING REUSED, CAUSING A CRASH WITH EXPRESSION TEMPLATE CODE IN pass1.ec ***
1715 // members->Add(MkMemberInit(ids, MkInitializerAssignment(MkExpConstant(ui64String))));
1716 /*member.identifiers->Remove(firstID);*/
1718 MkMemberInit(/*member.identifiers*/identifiers, MkInitializerAssignment(member.initializer.exp)));
1721 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
1723 if(!nextMembers.dataMembers)
1726 if(members != nextMembers) next = nextMembers.dataMembers->first;
1728 if(nextMembers.type == dataMembersInit)
1730 MemberInit nextMember;
1732 for(nextMember = next; nextMember;
1733 nextMember = next, next = nextMember ? nextMember.next : null)
1735 Identifier nextID = nextMember.identifiers->first;
1736 if(nextMember.identifiers &&
1737 nextMember.identifiers->count > 1 &&
1738 !strcmp(firstID.string, nextID.string))
1740 nextMembers.dataMembers->Remove(nextMember);
1741 nextMember.identifiers->Remove(nextID);
1742 ListAdd(partList, nextMember);
1748 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
1749 MkListOne(MkMembersInitList(partList))));
1757 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
1758 if(curMember == dataMember)
1766 curMember = curMember.next;
1768 curMember = parentMember.members.first;
1770 if(curMember == dataMember)
1783 if(member && member.initializer && member.initializer.type == expInitializer)
1785 Initializer init { loc = yylloc };
1786 if(namedParentMember.type == unionMember && dataMember.name)
1787 init.id = MkIdentifier(dataMember.name);
1789 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
1790 member.initializer.exp.expType._class.registered.type == structClass)
1792 OldList * subList = MkList();
1793 ProcessBracketInst(member.initializer.exp.instance, subList);
1794 FreeExpression(member.initializer.exp);
1797 init.type = listInitializer;
1798 init.list = subList;
1802 FreeInitializer(init);
1808 member.initializer.exp.usage.usageGet = true;
1809 ProcessExpression(member.initializer.exp);
1810 init.type = expInitializer;
1811 init.exp = member.initializer.exp;
1814 ListAdd(list, init);
1816 member.initializer.exp = null;
1817 FreeInitializer(member.initializer);
1818 member.initializer = null;
1819 someMemberSet = true;
1821 else if(member && member.initializer && member.initializer.type == listInitializer)
1823 if(namedParentMember.type == unionMember && dataMember.name)
1824 member.initializer.id = MkIdentifier(dataMember.name);
1826 ListAdd(list, member.initializer);
1827 member.initializer = null;
1828 someMemberSet = true;
1830 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/ && parentMember.type != unionMember && namedParentMember.type != unionMember)
1833 Initializer init { loc = yylloc };
1834 if(namedParentMember.type == unionMember && dataMember.name)
1835 init.id = MkIdentifier(dataMember.name);
1837 if(!dataMember.dataType)
1838 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1839 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1840 if(classSym && classSym.registered && classSym.registered.type == structClass)
1842 OldList * subList = MkList();
1843 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1844 Instantiation inst = MkInstantiation(spec, null, null);
1845 ProcessBracketInst(inst, subList);
1850 init.type = listInitializer;
1851 init.list = subList;
1855 FreeInitializer(init);
1861 init.type = expInitializer;
1862 init.exp = MkExpConstant("0");
1864 someMemberSet = true;
1866 ListAdd(list, init);
1870 if(parentMember.type == unionMember)
1874 // TESTING THIS NEW CODE FOR ANCHORS...
1875 if(/*parentMember.type == unionMember && */!someMemberSet && !parentMemberSet)
1878 Initializer init { loc = yylloc };
1880 dataMember = parentMember.members.first;
1881 if(namedParentMember.type == unionMember && dataMember.name)
1882 init.id = MkIdentifier(dataMember.name);
1884 if(!dataMember.dataType && dataMember.dataTypeString)
1885 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
1886 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
1887 if(classSym && classSym.registered && classSym.registered.type == structClass)
1889 OldList * subList = MkList();
1890 Specifier spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, classSym, null);
1891 Instantiation inst = MkInstantiation(spec, null, null);
1892 ProcessBracketInst(inst, subList);
1895 init.type = listInitializer;
1896 init.list = subList;
1898 else if(dataMember.dataType && (dataMember.dataType.kind == arrayType || dataMember.dataType.kind == structType))
1900 Type t = dataMember.dataType.kind == arrayType ? dataMember.dataType.type : dataMember.dataType.members.first;
1901 Initializer i = MkInitializerAssignment(MkExpConstant("0"));
1902 while(t && (t.kind == arrayType || t.kind == structType))
1904 i = MkInitializerList(MkListOne(i));
1905 if(t.kind == arrayType)
1907 else if(t.kind == structType)
1908 t = t.members.first;
1910 init.type = listInitializer;
1911 init.list = MkListOne(i);
1915 init.type = expInitializer;
1916 init.exp = MkExpConstant("0");
1918 ListAdd(list, init);
1923 static bool ProcessBracketInst(Instantiation inst, OldList list)
1925 static int recursionCount = 0;
1926 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
1927 Class _class = null;
1930 if(recursionCount > 500) return false;
1933 while(_class != classSym.registered)
1935 DataMember dataMember;
1936 Class lastClass = _class;
1938 for(_class = classSym.registered; _class.base != lastClass && _class.base.type != systemClass; _class = _class.base);
1940 for(dataMember = _class.membersAndProperties.first; dataMember; dataMember = dataMember.next)
1942 if(!dataMember.isProperty && !dataMember.name && (dataMember.type == unionMember || dataMember.type == structMember))
1944 OldList * subList = MkList(); //(dataMember.type == structMember ? MkList() : null);
1946 if(!ProcessBracketInst_DataMember(dataMember, inst, subList ? subList : list, dataMember, false))
1949 FreeList(subList, FreeInitializer);
1953 if(dataMember.type == structMember || (subList && subList->count))
1955 Initializer init = MkInitializerList(subList);
1957 sprintf(id, "__anon%d", anonID);
1958 init.id = MkIdentifier(id);
1959 ListAdd(list, init);
1967 MembersInit members;
1968 MemberInit member = null;
1971 if(inst.members && inst.members->first)
1973 DataMember curMember = null;
1974 Class curClass = null;
1975 DataMember subMemberStack[256];
1976 int subMemberStackPos = 0;
1978 for(members = inst.members->first; members; members = members.next)
1980 if(members.type == dataMembersInit)
1982 for(member = members.dataMembers->first; member; member = member.next)
1984 Identifier firstID = member.identifiers ? member.identifiers->first : null;
1987 DataMember _subMemberStack[256];
1988 int _subMemberStackPos = 0;
1989 DataMember thisMember = (DataMember)eClass_FindProperty(classSym.registered, firstID.string, privateModule);
1990 // FILL MEMBER STACK
1992 thisMember = (DataMember)eClass_FindDataMember(classSym.registered, firstID.string, privateModule, _subMemberStack, &_subMemberStackPos);
1995 curMember = thisMember;
1996 curClass = curMember._class;
1997 memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
1998 subMemberStackPos = _subMemberStackPos;
2001 if(curMember == dataMember)
2003 if(dataMember.isProperty)
2005 if(!((Property)dataMember).Set)
2007 Compiler_Error($"No set defined for property %s\n", dataMember.name);
2014 // Look for another member of this one and merge them
2015 // into one instantiation...
2016 if(member.identifiers->count > 1 && member.initializer && member.initializer.type == expInitializer)
2018 OldList * partList = MkList();
2019 // TODO: We're assuming this is a simple _class right now...
2021 MembersInit nextMembers;
2022 MemberInit next = member.next;
2024 if(!dataMember.dataType)
2025 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
2026 symbol = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null;
2027 spec = _MkSpecifierName/*MkClassName*/(dataMember.dataTypeString, symbol, null);
2029 member.identifiers->Remove(firstID);
2031 MkMemberInit(member.identifiers, MkInitializerAssignment(member.initializer.exp)));
2033 for(nextMembers = members; nextMembers; nextMembers = nextMembers.next)
2035 if(!nextMembers.dataMembers) continue;
2037 if(members != nextMembers) next = nextMembers.dataMembers->first;
2039 if(nextMembers.type == dataMembersInit)
2041 MemberInit nextMember;
2043 for(nextMember = next; nextMember;
2044 nextMember = next, next = nextMember ? nextMember.next : null)
2046 Identifier nextID = nextMember.identifiers->first;
2047 if(nextMember.identifiers &&
2048 nextMember.identifiers->count > 1 &&
2049 !strcmp(firstID.string, nextID.string))
2051 nextMembers.dataMembers->Remove(nextMember);
2052 nextMember.identifiers->Remove(nextID);
2053 ListAdd(partList, nextMember);
2059 member.initializer.exp = MkExpInstance(MkInstantiation(spec, null,
2060 MkListOne(MkMembersInitList(partList))));
2063 member.identifiers = null;
2071 eClass_FindNextMember(classSym.registered, &curClass, &curMember, subMemberStack, &subMemberStackPos);
2072 if(curMember == dataMember)
2074 if(dataMember.isProperty)
2076 if(!((Property)dataMember).Set)
2078 Compiler_Error($"No set defined for property %s\n", dataMember.name);
2094 if(dataMember.isProperty) continue;
2095 if(member && member.initializer && member.initializer.type == expInitializer)
2097 if(member.initializer.exp.type == instanceExp && member.initializer.exp.expType &&
2098 member.initializer.exp.expType._class && member.initializer.exp.expType._class.registered && member.initializer.exp.expType._class.registered.type == structClass)
2100 OldList * subList = MkList();
2101 ProcessBracketInst(member.initializer.exp.instance, subList);
2102 FreeExpression(member.initializer.exp);
2103 member.initializer.exp = null;
2104 ListAdd(list, MkInitializerList(subList));
2108 member.initializer.exp.usage.usageGet = true;
2109 ProcessExpression(member.initializer.exp);
2110 ListAdd(list, MkInitializerAssignment(CopyExpression(member.initializer.exp)));
2114 // member.exp = null;
2115 member.takeOutExp = true;
2117 else if(member && member.initializer && member.initializer.type == listInitializer)
2119 ListAdd(list, member.initializer);
2120 member.initializer = null;
2122 else if(dataMember && dataMember.dataTypeString/* && !inst.fullSet*/)
2126 if(!dataMember.dataType)
2127 dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
2128 classSym = (dataMember.dataType && dataMember.dataType.kind == classType) ? dataMember.dataType._class : null; // FindClass(dataMember.dataTypeString);
2130 if(classSym && classSym.registered && classSym.registered.type == structClass)
2132 OldList * subList = MkList();
2133 Specifier spec = _MkSpecifierName(dataMember.dataTypeString, classSym, null);
2134 Instantiation inst = MkInstantiation(spec, null, null);
2135 ProcessBracketInst(inst, subList);
2137 ListAdd(list, MkInitializerList(subList));
2139 else if(dataMember.dataType.kind == arrayType)
2141 Type t = dataMember.dataType.type;
2142 Initializer inner = MkInitializerAssignment(null), i = inner;
2143 while(t && t.kind == arrayType)
2145 i = MkInitializerList(MkListOne(i));
2148 if(t && t.kind == classType && t._class && t._class.registered && t._class.registered.type == structClass)
2150 OldList * subList = MkList();
2151 Specifier spec = _MkSpecifierName(t._class.registered.name, classSym, null);
2152 Instantiation inst = MkInstantiation(spec, null, null);
2153 ProcessBracketInst(inst, subList);
2155 inner.type = listInitializer;
2156 inner.list = subList;
2159 inner.exp = MkExpConstant("0");
2160 ListAdd(list, MkInitializerList(MkListOne(i)));
2163 ListAdd(list, MkInitializerAssignment(MkExpConstant("0")));
2169 if(inst.members && inst.members->first)
2171 MembersInit members;
2172 MemberInit member = null;
2174 for(members = inst.members->first; members; members = members.next)
2176 if(members.type == dataMembersInit)
2178 for(member = members.dataMembers->first; member; member = member.next)
2180 if(member.takeOutExp)
2182 FreeInitializer(member.initializer);
2183 member.initializer = null;
2193 static Declaration curDecl;
2194 static int declTempCount;
2196 static void ProcessDeclaration(Declaration decl)
2201 case initDeclaration:
2203 if(!curDecl) { curDecl = decl; declTempCount = 0; }
2207 for(s = decl.specifiers->first; s; s = s.next)
2209 ProcessSpecifier(s);
2212 if(decl.declarators)
2216 for(d = decl.declarators->first; d; d = d.next)
2219 ProcessInitializer(d.initializer);
2222 if(curDecl == decl) { curDecl = null; declTempCount = 0; }
2225 case instDeclaration:
2227 Instantiation inst = decl.inst;
2231 Symbol classSym = inst._class.symbol; // FindClass(inst._class.name);
2236 if(!inst.isConstant || (classSym && classSym.registered && (classSym.registered.type == normalClass || classSym.registered.type == noHeadClass)))
2238 // If this instantiation is outside, turn it into a declaration plus an instantiation expression
2239 decl.type = initDeclaration;
2240 decl.specifiers = MkListOne(MkSpecifierName/*MkClassName*/(inst._class.name));
2241 if(decl.declMode == staticAccess)
2243 decl.specifiers->Insert(null, MkSpecifier(STATIC));
2245 decl.declarators = MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier(inst.exp.identifier.string)), null));
2247 ProcessDeclaration(decl);
2248 CreateInstancesBody();
2251 Expression exp = MkExpInstance(inst);
2252 stmt = MkExpressionStmt(MkListOne(exp)); // MkExpOp(inst.exp, '=',
2253 ListAdd(createInstancesBody.compound.statements, stmt);
2254 ProcessExpressionType(exp);
2257 if(classSym && classSym.registered && (classSym.registered.type == normalClass))
2259 ListAdd(createInstancesBody.compound.statements,
2260 MkExpressionStmt(MkListOne(MkExpCall(
2261 MkExpIdentifier(MkIdentifier("ecere::com::eInstance_IncRef")),
2262 MkListOne(CopyExpression(inst.exp))))));
2264 // We'd like the = 0 as well...
2266 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2267 ListAddFront(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2268 ProcessExpressionType(exp);
2271 else if(classSym && classSym.registered && (classSym.registered.type == noHeadClass))
2273 Expression exp = MkExpOp(null, DELETE, CopyExpression(inst.exp));
2274 ListAddFront(destroyInstancesBody.compound.statements, MkExpressionStmt(MkListOne(exp)));
2275 ProcessExpressionType(exp);
2278 createInstancesExternal.CreateEdge(curExternal, false);
2279 destroyInstancesExternal.CreateEdge(curExternal, false);
2284 // Precompiler won't know if this isn't constant
2285 CreateInstancesBody();
2290 char className[1024];
2293 decl.type = initDeclaration;
2294 decl.specifiers = MkList();
2295 decl.declarators = MkList();
2297 // Replace instantiation here
2298 if(classSym && classSym.registered && classSym.registered.type == bitClass)
2300 OldList list = { 0 };
2302 // Put the instantiation in an InitDeclarator...
2303 ProcessInstMembers(inst, inst.exp, &list, false);
2304 ProcessExpression(inst.exp);
2306 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2307 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2308 MkInitializerAssignment(list.first)));
2309 inst.exp.identifier = null;
2311 else if(classSym && classSym.registered && classSym.registered.type == unitClass)
2313 OldList list = { 0 };
2315 // Put the instantiation in an InitDeclarator...
2316 ProcessInstMembers(inst, inst.exp, &list, false);
2317 ProcessExpression(inst.exp);
2319 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2320 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2321 MkInitializerAssignment(list.first)));
2323 inst.exp.identifier = null;
2325 else if(classSym && classSym.registered && classSym.registered.type == structClass)
2329 DeclareStruct(curExternal, inst._class.name, false, true);
2331 strcpy(className, "__ecereClass_");
2332 FullClassNameCat(className, classSym.string, true);
2333 DeclareClass(classSym, className);
2336 ProcessExpression(inst.exp);
2338 // Put the instantiation in an InitDeclarator...
2342 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2343 ListAdd(decl.declarators,
2344 MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier), null));
2345 inst.exp.identifier = null;
2349 OldList * list = MkList();
2350 if(ProcessBracketInst(inst, list))
2352 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2353 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2354 MkInitializerList(list)));
2355 inst.exp.identifier = null;
2359 // If bracket instantiation failed (property: for conversions only?)
2360 // TODO: (Fix this so it initializes members through brackets,
2361 // and then does properties)
2364 // TESTING THIS MEMORY LEAK FIX:
2365 FreeList(list, FreeInitializer);
2367 exp = MkExpBrackets(MkList());
2368 ProcessInstMembers(inst, inst.exp, exp.list, true);
2369 ListAdd(exp.list, CopyExpression(inst.exp));
2370 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2371 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(inst.exp.identifier),
2372 MkInitializerAssignment(exp)));
2373 inst.exp.identifier = null;
2382 strcpy(className, "__ecereClass_");
2384 if(classSym && classSym.registered && classSym.registered.type == noHeadClass && classSym.registered.templateClass)
2386 classSym = FindClass(classSym.registered.templateClass.fullName);
2387 FullClassNameCat(className, classSym.string, true);
2390 FullClassNameCat(className, inst._class.name, true);
2393 DeclareClass(curExternal, classSym, className);
2395 if(classSym && classSym.registered && classSym.registered.type == noHeadClass &&
2396 (classSym.registered.templateClass ? classSym.registered.templateClass.fixed : classSym.registered.fixed))
2399 Class c = classSym.registered.templateClass ? classSym.registered.templateClass : classSym.registered;
2400 Expression e = MkExpClassSize(MkSpecifierName(c.name));
2401 ProcessExpressionType(e);
2402 sprintf(size, "%d", c.structSize);
2403 newCall = MkExpCall(QMkExpId("ecere::com::eSystem_New0"), MkListOne( e /*MkExpConstant(size)*/));
2407 newCall = MkExpCall(QMkExpId("ecere::com::eInstance_New"), MkListOne(QMkExpId(className)));
2408 ProcessExpressionType(newCall);
2409 newCall.byReference = true;
2414 Expression exp, newExp;
2415 Identifier id = CopyIdentifier(inst.exp.identifier);
2417 // Put the instantiation in an InitDeclarator...
2418 if(inst.members && inst.members->first)
2420 newExp = MkExpOp(CopyExpression(inst.exp), '=', newCall);
2422 exp = MkExpBrackets(MkList());
2423 ListAdd(exp.list, newExp);
2424 ProcessInstMembers(inst, inst.exp, exp.list, false);
2425 ListAdd(exp.list, inst.exp);
2427 ProcessExpression(inst.exp);
2429 // Take it out since we're using it...
2435 ListAdd(decl.specifiers, MkSpecifierName/*MkClassName*/(inst._class.name));
2436 ListAdd(decl.declarators, MkInitDeclarator(MkDeclaratorIdentifier(id),
2437 MkInitializerAssignment(exp)));
2438 //inst.exp.identifier = null;
2441 FreeExpression(newCall);
2447 ProcessInstantiation(inst);
2450 case structDeclaration:
2455 for(spec = decl.specifiers->first; spec; spec = spec.next)
2456 ProcessSpecifier(spec);
2463 static void ProcessStatement(Statement stmt)
2469 if(stmt.labeled.stmt)
2470 ProcessStatement(stmt.labeled.stmt);
2473 if(stmt.caseStmt.exp)
2474 ProcessExpression(stmt.caseStmt.exp);
2475 if(stmt.caseStmt.stmt)
2476 ProcessStatement(stmt.caseStmt.stmt);
2480 if(stmt.compound.context)
2484 Statement prevCompound = curCompound;
2485 Context prevContext = curContext;
2487 if(!stmt.compound.isSwitch)
2490 curContext = stmt.compound.context;
2493 if(stmt.compound.declarations)
2495 for(decl = stmt.compound.declarations->first; decl; decl = decl.next)
2496 ProcessDeclaration(decl);
2498 if(stmt.compound.statements)
2500 for(s = stmt.compound.statements->first; s; s = s.next)
2502 ProcessStatement(s);
2506 curCompound = prevCompound;
2507 curContext = prevContext;
2511 case expressionStmt:
2514 if(stmt.expressions)
2516 for(exp = stmt.expressions->first; exp; exp = exp.next)
2518 ProcessExpression(exp);
2527 ((Expression)stmt.ifStmt.exp->last).usage.usageGet = true;
2528 for(exp = stmt.ifStmt.exp->first; exp; exp = exp.next)
2530 ProcessExpression(exp);
2532 if(stmt.ifStmt.stmt)
2533 ProcessStatement(stmt.ifStmt.stmt);
2534 if(stmt.ifStmt.elseStmt)
2535 ProcessStatement(stmt.ifStmt.elseStmt);
2541 ((Expression)stmt.switchStmt.exp->last).usage.usageGet = true;
2542 for(exp = stmt.switchStmt.exp->first; exp; exp = exp.next)
2543 ProcessExpression(exp);
2544 ProcessStatement(stmt.switchStmt.stmt);
2549 if(stmt.whileStmt.exp)
2553 ((Expression)stmt.whileStmt.exp->last).usage.usageGet = true;
2554 for(exp = stmt.whileStmt.exp->first; exp; exp = exp.next)
2556 ProcessExpression(exp);
2559 if(stmt.whileStmt.stmt)
2560 ProcessStatement(stmt.whileStmt.stmt);
2565 if(stmt.doWhile.exp)
2568 ((Expression)stmt.doWhile.exp->last).usage.usageGet = true;
2569 for(exp = stmt.doWhile.exp->first; exp; exp = exp.next)
2571 ProcessExpression(exp);
2574 if(stmt.doWhile.stmt)
2575 ProcessStatement(stmt.doWhile.stmt);
2581 if(stmt.forStmt.init)
2582 ProcessStatement(stmt.forStmt.init);
2584 if(stmt.forStmt.check && stmt.forStmt.check.expressions)
2586 ((Expression)stmt.forStmt.check.expressions->last).usage.usageGet = true;
2589 if(stmt.forStmt.check)
2590 ProcessStatement(stmt.forStmt.check);
2591 if(stmt.forStmt.increment)
2593 for(exp = stmt.forStmt.increment->first; exp; exp = exp.next)
2594 ProcessExpression(exp);
2596 if(stmt.forStmt.stmt)
2597 ProcessStatement(stmt.forStmt.stmt);
2609 if(stmt.expressions && stmt.expressions->last)
2611 ((Expression)stmt.expressions->last).usage.usageGet = true;
2612 for(exp = stmt.expressions->first; exp; exp = exp.next)
2614 ProcessExpression(exp);
2619 case badDeclarationStmt:
2621 ProcessDeclaration(stmt.decl);
2627 if(stmt.asmStmt.inputFields)
2629 for(field = stmt.asmStmt.inputFields->first; field; field = field.next)
2630 if(field.expression)
2631 ProcessExpression(field.expression);
2633 if(stmt.asmStmt.outputFields)
2635 for(field = stmt.asmStmt.outputFields->first; field; field = field.next)
2636 if(field.expression)
2637 ProcessExpression(field.expression);
2639 if(stmt.asmStmt.clobberedFields)
2641 for(field = stmt.asmStmt.clobberedFields->first; field; field = field.next)
2642 if(field.expression)
2643 ProcessExpression(field.expression);
2649 static void ProcessFunction(FunctionDefinition function)
2653 yylloc = function.loc;
2654 ProcessStatement(function.body);
2658 /////////// INSTANTIATIONS / DATA TYPES PASS /////////////////////////////////////////////
2659 public void ProcessInstantiations()
2662 // Is this still needed?
2663 //CreateInstancesBody();
2665 for(external = ast->first; external; external = external.next)
2667 curExternal = external;
2668 if(external.type == declarationExternal)
2670 //currentClass = external.function._class;
2671 if(external.declaration)
2673 bool isInstance = external.declaration.type == instDeclaration;
2674 Symbol sym = isInstance ? FindClass(external.declaration.inst._class.name) : null;
2675 ProcessDeclaration(external.declaration);
2679 // Move edges to the global instances to the create instance body instead
2681 for(e = external.incoming.first; e; e = next)
2683 External from = e.from;
2687 if(from.incoming.count)
2689 bool reroute = true;
2690 if(sym && sym.registered && sym.registered.type == structClass)
2692 else if(from.type == declarationExternal && from.declaration && (!from.declaration.declarators || !from.declaration.declarators->count) && from.declaration.specifiers)
2694 Specifier spec = null;
2695 for(spec = from.declaration.specifiers->first; spec; spec = spec.next)
2697 if(spec.type == structSpecifier || spec.type == unionSpecifier)
2700 if(sym.registered && spec && spec.id && spec.id.string)
2702 char className[1024];
2703 Class c = sym.registered;
2704 strcpy(className, "__ecereClass_");
2705 if(c.type == noHeadClass && c.templateClass)
2706 FullClassNameCat(className, c.templateClass.name, true);
2708 FullClassNameCat(className, c.name, true);
2709 if(!strcmp(c.name, spec.id.string))
2716 e.to = createInstancesExternal;
2717 external.incoming.Remove((IteratorPointer)e);
2718 for(i : createInstancesExternal.incoming)
2723 if(i.breakable && !e.breakable)
2726 createInstancesExternal.nonBreakableIncoming++;
2733 external.nonBreakableIncoming--;
2734 e.from.outgoing.Remove((IteratorPointer)e);
2739 createInstancesExternal.incoming.Add(e);
2742 external.nonBreakableIncoming--;
2743 createInstancesExternal.nonBreakableIncoming++;
2752 else if(external.type == functionExternal)
2754 //currentClass = null;
2755 ProcessFunction(external.function);
2757 else if(external.type == classExternal)
2759 ClassDefinition _class = external._class;
2760 //currentClass = external.symbol.registered;
2761 if(_class.definitions)
2764 //Class regClass = _class.symbol.registered;
2766 // Process all functions
2767 for(def = _class.definitions->first; def; def = def.next)
2769 if(def.type == functionClassDef)
2771 curExternal = def.function.declarator ? def.function.declarator.symbol.pointerExternal : external;
2772 ProcessFunction((FunctionDefinition)def.function);
2774 else if(def.type == declarationClassDef && def.decl.type == instDeclaration)
2776 ProcessInstantiation(def.decl.inst);
2778 else if(def.type == defaultPropertiesClassDef && def.defProperties)
2780 MemberInit defProperty;
2782 // Add this to the context
2785 string = CopyString("this");
2786 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2788 globalContext.symbols.Add((BTNode)thisSymbol);
2790 for(defProperty = def.defProperties->first; defProperty; defProperty = defProperty.next)
2792 //thisClass = regClass;
2793 ProcessMemberInitData(defProperty); ///*, regClass, &id
2797 globalContext.symbols.Remove((BTNode)thisSymbol);
2798 FreeSymbol(thisSymbol);
2800 else if(def.type == propertyClassDef && def.propertyDef)
2802 PropertyDef prop = def.propertyDef;
2804 // Add this to the context
2807 string = CopyString("this");
2808 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2810 globalContext.symbols.Add((BTNode)thisSymbol);
2812 //thisClass = regClass;
2815 curExternal = prop.symbol ? prop.symbol.externalSet : null;
2816 ProcessStatement(prop.setStmt);
2820 curExternal = prop.symbol ? prop.symbol.externalGet : null;
2821 ProcessStatement(prop.getStmt);
2825 curExternal = prop.symbol ? prop.symbol.externalIsSet : null;
2826 ProcessStatement(prop.issetStmt);
2830 globalContext.symbols.Remove((BTNode)thisSymbol);
2831 FreeSymbol(thisSymbol);
2833 else if(def.type == propertyWatchClassDef && def.propertyWatch)
2835 PropertyWatch propertyWatch = def.propertyWatch;
2837 // Add this to the context
2840 string = CopyString("this");
2841 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2843 globalContext.symbols.Add((BTNode)thisSymbol);
2845 //thisClass = regClass;
2846 if(propertyWatch.compound)
2848 /* This was already added in pass15:ProcessClass()
2851 string = CopyString("this");
2852 type = MkClassTypeSymbol(_class.symbol); //regClass.fullName);
2854 propertyWatch.compound.compound.context.symbols.Add((BTNode)thisSymbol);
2856 ProcessStatement(propertyWatch.compound);
2858 // thisClass = null;
2860 //globalContext.symbols.Delete((BTNode)thisSymbol);
2861 globalContext.symbols.Remove((BTNode)thisSymbol);
2862 FreeSymbol(thisSymbol);