9 static define localeDir = "locale";
12 static Platform targetPlatform;
14 static bool isConsole;
15 static bool isDynamicLibrary;
16 static bool isStaticLibrary;
17 static OldList modules;
18 static File dcomSymbols;
20 static OldList _defines { };
21 static OldList _imports { };
22 static OldList _excludedSymbols { offset = (uint)&((Symbol)0).left };
23 static NameSpace globalData
25 classes.CompareKey = (void *)BinaryTree::CompareString;
26 defines.CompareKey = (void *)BinaryTree::CompareString;
27 functions.CompareKey = (void *)BinaryTree::CompareString;
28 nameSpaces.CompareKey = (void *)BinaryTree::CompareString;
30 static Context theGlobalContext { };
31 static ModuleImport mainModule;
32 static Module privateModule;
34 static char mainModuleName[MAX_LOCATION];
35 static char projectName[MAX_LOCATION];
36 static void LoadImports(char * fileName)
38 File f = FileOpen(fileName, read);
44 if(!f.GetLine(line, sizeof(line))) break;
45 TrimLSpaces(line, line);
49 if(!strcmp(line, "[Imported Modules]"))
51 ModuleImport module = null;
54 if(!f.GetLine(line, sizeof(line))) break;
55 TrimLSpaces(line, line);
56 if(!strcmp(line, ".")) break;
60 ClassImport _class = null;
61 FunctionImport function = null;
63 if(!strcmp(line, "[This]"))
65 if((mainModule = GetMainModule()))
69 mainModule = ModuleImport { };
70 SetMainModule(mainModule);
72 _imports.AddName(module);
75 else if(!strcmp(line, "[Static]"))
77 module.importType = staticImport;
79 else if(!strcmp(line, "[Remote]"))
81 module.importType = remoteImport;
83 else if(!strcmp(line, "[Private]"))
85 if(module.importAccess != publicAccess)
86 module.importAccess = privateAccess;
88 else if(!strcmp(line, "[Public]"))
90 module.importAccess = publicAccess;
92 else if(!strcmp(line, "[Imported Classes]"))
96 if(!f.GetLine(line, sizeof(line))) break;
97 TrimLSpaces(line, line);
98 if(!strcmp(line, ".")) break;
102 if(!strcmp(line, "[Instantiated]"))
104 _class.itself = true;
106 else if(!strcmp(line, "[Remote]"))
110 else if(!strcmp(line, "[Imported Methods]"))
112 MethodImport method = null;
115 if(!f.GetLine(line, sizeof(line))) break;
116 TrimLSpaces(line, line);
117 if(!strcmp(line, ".")) break;
120 if(!(method = _class.methods.FindName(line, false)))
122 method = MethodImport { name = CopyString(line) };
123 _class.methods.AddName(method);
126 else if(!strcmp(line, "[Virtual]"))
127 method.isVirtual = true;
131 else if(!strcmp(line, "[Imported Properties]"))
133 PropertyImport prop = null;
136 if(!f.GetLine(line, sizeof(line))) break;
137 TrimLSpaces(line, line);
138 if(!strcmp(line, ".")) break;
141 if(!(prop = _class.properties.FindName(line, false)))
143 prop = PropertyImport { name = CopyString(line) };
144 _class.properties.AddName(prop);
147 else if(!strcmp(line, "[Set]"))
149 else if(!strcmp(line, "[Get]"))
151 else if(!strcmp(line, "[Virtual]"))
152 prop.isVirtual = true;
158 if(!(_class = module.classes.FindName(line, false)))
160 _class = ClassImport { name = CopyString(line) };
161 module.classes.AddName(_class);
166 else if(!strcmp(line, "[Imported Functions]"))
170 if(!f.GetLine(line, sizeof(line))) break;
171 TrimLSpaces(line, line);
172 if(!strcmp(line, ".")) break;
179 if(!(function = module.functions.FindName(line, false)))
181 function = FunctionImport { name = CopyString(line) };
182 module.functions.AddName(function);
190 if(!(module = _imports.FindName(line, false)))
192 if(!strcmp(line, "ecereCOM"))
194 module = _imports.FindName("ecere", false);
196 else if(!strcmp(line, "ecere"))
198 module = _imports.FindName("ecereCOM", false);
202 module.name = CopyString("ecere");
207 module = ModuleImport { name = CopyString(line) };
208 _imports.AddName(module);
220 // static Class applicationClass;
221 static Class thisAppClass;
223 class ModuleInfo : struct
225 ModuleInfo prev, next;
231 static bool SeardchModuleName(Module searchIn, char * name)
235 if(searchIn.name && !strcmp(searchIn.name, name))
238 for(subModule = searchIn.modules.first; subModule; subModule = subModule.next)
240 if(SearchModuleName(subModule.module, name))
246 static void WriteMain(char * fileName)
248 File f = FileOpen(fileName, write);
252 ModuleInfo defModule;
253 bool nonInst = false, anyMethod = false, anyProp = false, anyFunction = false;
254 ImportedModule importedModule;
256 GetLastDirectory(fileName, mainModuleName);
257 StripExtension(mainModuleName);
260 strcpy(projectName, mainModuleName);
261 StripExtension(projectName);
263 ChangeCh(mainModuleName, '.', '_');
264 ChangeCh(mainModuleName, '-', '_');
265 ChangeCh(mainModuleName, ' ', '_');
267 if(targetPlatform == win32 && !isConsole && !isStaticLibrary && !isDynamicLibrary)
269 //f.Puts("#include <windows.h>\n\n");
271 f.Puts("typedef void * HINSTANCE;\n");
272 f.Puts("#define WINAPI __stdcall\n");
275 for(importedModule = ::_defines.first; importedModule; importedModule = importedModule.next)
277 if(importedModule.type == moduleDefinition)
280 if(importedModule.importType == staticImport)
281 f.Printf("static ", importedModule.name);
282 f.Printf("\"%s\"\n", importedModule.name);
286 f.Puts("default:\n");
287 f.Puts("static Module __currentModule;\n\n");
290 f.Puts("Module __thisModule;\n\n");
292 // TOCHECK: Problem compiling Scrabble.main.ec when binding Client first
297 f.Printf("void __ecereRegisterModule_%s(Module module);\n\n", mainModuleName);
299 for(module = _imports.first; module; module = module.next)
302 FunctionImport function;
303 if(module.importType == staticImport)
305 /*if(targetPlatform == win32)
307 f.Printf("bool __stdcall __ecereDll_Load_%s(Module module);\n", module.name);
308 f.Printf("bool __stdcall __ecereDll_Unload_%s(Module module);\n", module.name);
312 f.Printf("bool __ecereDll_Load_%s(Module module);\n", module.name);
313 f.Printf("bool __ecereDll_Unload_%s(Module module);\n", module.name);
316 for(_class = module.classes.first; _class; _class = _class.next)
320 char className[1024] = "";
321 Class regClass = eSystem_FindClass(privateModule, _class.name);
323 FullClassNameCat(className, _class.name, true);
324 MangleClassName(className);
327 f.Printf("Class __ecereClass_%s;\n", className);
330 //if(!_class.isRemote)
332 //if(strcmp(_class.name, "SerialBuffer"))
334 for(method = _class.methods.first; method; method = method.next)
336 Method meth = eClass_FindMethod(regClass, method.name, privateModule);
337 if(meth && !meth.dataType)
339 Context context = SetupTemplatesContext(regClass);
340 meth.dataType = ProcessTypeString(meth.dataTypeString, false);
341 FinishTemplatesContext(context);
345 f.Printf("int __ecereVMethodID_%s_%s;\n", className, method.name);
346 else if(module.name && module.importType != staticImport && (!meth || !meth.dataType.dllExport))
356 sprintf(name, "__ecereMethod_%s_%s", className, method.name);
357 PrintType(type, name, true);
358 f.Printf("%s;\n", name);
361 //f.Printf("void * __ecereMethod_%s_%s;\n", className, method.name);
363 f.Printf("int (*__ecereMethod_%s_%s)();\n", className, method.name);
370 for(prop = _class.properties.first; prop; prop = prop.next)
374 FullClassNameCat(propName, prop.name, true);
375 // strcpy(propName, prop.name);
376 MangleClassName(propName);
378 if(module.name && module.importType != staticImport)
381 f.Printf("void * __ecereProp_%s_Set_%s;\n", className, propName);
383 f.Printf("void * __ecereProp_%s_Get_%s;\n", className, propName);
385 f.Printf("Property __ecereProp_%s_%s;\n", className, propName);
390 for(function = module.functions.first; function; function = function.next)
392 GlobalFunction func = eSystem_FindFunction(privateModule, function.name);
393 if(func && !func.dataType)
394 func.dataType = ProcessTypeString(func.dataTypeString, false);
396 if(module.name && module.importType != staticImport && (!func || !func.dataType || !func.dataType.dllExport))
398 char functionName[1024];
400 FullClassNameCat(functionName, function.name, false);
401 f.Printf("void * __ecereFunction_%s;\n", functionName);
407 for(defModule = ::modules.first; defModule; defModule = defModule.next)
409 char moduleName[1024];
410 strcpy(moduleName, defModule.name);
411 ChangeCh(moduleName, ' ', '_');
412 ChangeCh(moduleName, '-', '_');
413 ChangeCh(moduleName, '.', '_');
415 f.Printf("void __ecereRegisterModule_%s(Module module);\n", moduleName);
416 f.Printf("void __ecereUnregisterModule_%s(Module module);\n", moduleName);
417 if(defModule.globalInstance)
419 f.Printf("void __ecereCreateModuleInstances_%s();\n", moduleName);
420 f.Printf("void __ecereDestroyModuleInstances_%s();\n", moduleName);
429 // Insert DCOM bindings here
430 dcomSymbols.Seek(0, start);
431 while(!dcomSymbols.Eof())
434 int read = dcomSymbols.Read(buffer, 1, sizeof(buffer));
436 f.Write(buffer, 1, read);
445 /*if(targetPlatform == win32)
446 f.Printf("\nbool __stdcall __ecereDll_Load_%s(Module module)\n{\n", projectName);
448 f.Printf("\nbool __ecereDll_Load_%s(Module module)\n{\n", projectName);
450 else if(isDynamicLibrary)
452 if(targetPlatform == win32)
453 f.Puts("\ndllexport bool __stdcall __ecereDll_Load(Module module)\n{\n");
455 f.Puts("\ndllexport bool __ecereDll_Load(Module module)\n{\n");
457 else if(targetPlatform == win32 && !isConsole)
459 f.Puts("\nint WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, char * cmdLine, int show)\n{\n");
462 f.Puts("\nint main(int _argc, char * _argv[])\n{\n");
464 if(!isDynamicLibrary)
466 f.Puts(" int exitCode;\n");
467 f.Puts(" Module module;\n");
470 //if(nonInst || thisAppClass) // We use it all the time to get "Application" for the exit code now...
471 f.Puts(" Class _class;\n");
474 f.Puts(" Method method;\n");
476 f.Puts(" Property _property;\n");
478 f.Puts(" GlobalFunction function;\n");
484 f.Puts(" if(!__currentModule)\n");
486 f.Puts(" __currentModule = module;\n");
488 f.Puts(" __thisModule = module;\n");
491 else if(targetPlatform == win32 && !isConsole)
492 f.Puts(" __thisModule = __currentModule = module = __ecere_COM_Initialize(1, 0, null);\n\n");
494 f.Puts(" __thisModule = __currentModule = module = __ecere_COM_Initialize(1, _argc, (void *)_argv);\n\n");
496 // First load all modules
499 for(module = _imports.first; module; module = module.next)
503 //if(strcmp(module.name, "ecereCOM") && strcmp(module.name, "ecere") )
505 if(module.importType == staticImport)
506 f.Printf(" eModule_LoadStatic(module, \"%s\", %s, __ecereDll_Load_%s, __ecereDll_Unload_%s);\n", module.name, (module.importAccess == privateAccess) ? "privateAccess" : "publicAccess", module.name,module.name);
508 f.Printf(" eModule_Load(module, \"%s\", %s);\n", module.name, (module.importAccess == privateAccess) ? "privateAccess" : "publicAccess");
515 // Then define the classes
518 for(defModule = ::modules.first; defModule; defModule = defModule.next)
520 char moduleName[1024];
521 strcpy(moduleName, defModule.name);
522 ChangeCh(moduleName, ' ', '_');
523 ChangeCh(moduleName, '-', '_');
524 ChangeCh(moduleName, '.', '_');
526 f.Printf(" __ecereRegisterModule_%s(module);\n", moduleName);
531 // Register Remote Modules
534 f.Printf(" __ecereRegisterModule_%s(module);\n\n", mainModuleName);
540 f.Puts(" if(__currentModule == module)\n");
543 // Then load the imports
544 for(module = _imports.first; module; module = module.next)
547 FunctionImport function;
548 if(module.classes.count)
550 for(_class = module.classes.first; _class; _class = _class.next)
552 Class regClass = eSystem_FindClass(privateModule, _class.name);
554 //if(!_class.isRemote)
559 char className[1024] = "";
560 FullClassNameCat(className, _class.name, true);
561 MangleClassName(className);
564 sprintf(classID, "__ecereClass_%s", className);
566 strcpy(classID, "_class");
568 if(isDynamicLibrary && !isStaticLibrary)
569 f.Printf(" %s = eSystem_FindClass(__currentModule, \"%s\");\n", classID, _class.name);
571 f.Printf(" %s = eSystem_FindClass(module, \"%s\");\n", classID, _class.name);
573 for(method = _class.methods.first; method; method = method.next)
575 Method meth = eClass_FindMethod(regClass, method.name, privateModule);
576 if(!meth || !meth.dataType.dllExport)
578 if(method.isVirtual || (module.name && module.importType != staticImport))
580 f.Printf(" method = eClass_FindMethod(%s, \"%s\", module);\n",
581 classID, method.name);
583 f.Printf(" if(method) __ecereVMethodID_%s_%s = method.vid;\n", className, method.name);
585 f.Printf(" if(method) __ecereMethod_%s_%s = method.function;\n", className, method.name);
590 for(prop = _class.properties.first; prop; prop = prop.next)
594 FullClassNameCat(propName, prop.name, true);
595 // strcpy(propName, prop.name);
596 MangleClassName(propName);
598 f.Printf(" __ecereProp_%s_%s = _property = eClass_FindProperty(%s, \"%s\", module);\n",
599 className, propName, classID, prop.name);
601 if(module.name && module.importType != staticImport)
604 f.Printf(" __ecereProp_%s_Set_%s = _property.Set;\n", className, propName);
606 f.Printf(" __ecereProp_%s_Get_%s = _property.Get;\n", className, propName);
613 if(module.functions.count)
615 for(function = module.functions.first; function; function = function.next)
617 GlobalFunction func = eSystem_FindFunction(privateModule, function.name);
618 if(module.name && module.importType != staticImport && (!func || !func.dataType || !func.dataType.dllExport))
620 char functionName[1024];
622 FullClassNameCat(functionName, function.name, false);
624 if(isDynamicLibrary && !isStaticLibrary)
625 f.Printf(" function = eSystem_FindFunction(__currentModule, \"%s\");\n", function.name);
627 f.Printf(" function = eSystem_FindFunction(module, \"%s\");\n", function.name);
629 f.Printf(" if(function) __ecereFunction_%s = function.function;\n", functionName);
637 for(defModule = ::modules.first; defModule; defModule = defModule.next)
638 if(defModule.globalInstance)
640 if(!strcmp(defModule.name, "i18n"))
641 f.Printf(" __ecereCreateModuleInstances_i18n();\n");
644 f.Printf(" LoadTranslatedStrings(module, \"%s\");\n", projectName);
647 //f.Printf(" module._vTbl[10](module);\n");
651 if(!isDynamicLibrary && thisAppClass)
653 f.Printf(" _class = eSystem_FindClass(__currentModule, \"%s\");\n", thisAppClass.name);
654 f.Printf(" eInstance_Evolve((Instance *)&__currentModule, _class);\n");
655 f.Printf(" __thisModule = __currentModule;\n");
660 f.Puts(" if(__currentModule == module)\n");
664 // Then check if there's any global instances to create
667 for(defModule = ::modules.first; defModule; defModule = defModule.next)
668 if(defModule.globalInstance)
670 char moduleName[1024];
671 if(!strcmp(defModule.name, "i18n")) continue;
672 strcpy(moduleName, defModule.name);
673 ChangeCh(moduleName, ' ', '_');
674 ChangeCh(moduleName, '-', '_');
675 ChangeCh(moduleName, '.', '_');
677 f.Printf(" __ecereCreateModuleInstances_%s();\n", moduleName);
687 if(!isDynamicLibrary && thisAppClass)
689 f.Printf(" __currentModule._vTbl[12](__currentModule);\n");
694 f.Puts(" return true;\n");
698 /*if(targetPlatform == win32)
699 f.Printf("\nbool __stdcall __ecereDll_Unload_%s(Module module)\n{\n", projectName);
701 f.Printf("\nbool __ecereDll_Unload_%s(Module module)\n{\n", projectName);
705 if(targetPlatform == win32)
706 f.Puts("\ndllexport bool __stdcall __ecereDll_Unload(Module module)\n{\n");
708 f.Puts("\ndllexport bool __ecereDll_Unload(Module module)\n{\n");
714 f.Puts(" if(__currentModule == module)\n");
717 // Then check if there's any global instances to destroy
719 bool destroyI18n = false;
722 for(defModule = ::modules.first; defModule; defModule = defModule.next)
723 if(defModule.globalInstance)
725 char moduleName[1024];
726 if(!strcmp(defModule.name, "i18n")) { destroyI18n = true; continue; }
727 strcpy(moduleName, defModule.name);
728 ChangeCh(moduleName, ' ', '_');
729 ChangeCh(moduleName, '-', '_');
730 ChangeCh(moduleName, '.', '_');
731 f.Printf(" __ecereDestroyModuleInstances_%s();\n", moduleName);
737 f.Printf(" UnloadTranslatedStrings(__currentModule);\n");
739 f.Printf(" __ecereDestroyModuleInstances_i18n();\n");
747 //f.Printf(" module._vTbl[11](module);\n");
752 for(defModule = ::modules.first; defModule; defModule = defModule.next)
754 char moduleName[1024];
755 strcpy(moduleName, defModule.name);
756 ChangeCh(moduleName, ' ', '_');
757 ChangeCh(moduleName, '-', '_');
758 ChangeCh(moduleName, '.', '_');
759 f.Printf(" __ecereUnregisterModule_%s(module);\n", moduleName);
763 f.Puts(" if(__currentModule == module)\n");
764 f.Puts(" __currentModule = (void *)0;\n");
767 f.Puts(" if(__thisModule == module)\n");
768 f.Puts(" __thisModule = (void *)0;\n");
772 if(!isDynamicLibrary)
776 " _class = eSystem_FindClass(__currentModule, \"ecere::com::Application\");\n"
777 " exitCode = ((ecere::com::Application)__currentModule).exitCode;\n"
778 " delete __currentModule;\n"
779 " return exitCode;\n");
782 f.Puts(" return true;\n");
788 static Class FindAppClass(NameSpace * nameSpace, bool thisModule)
792 for(link = (BTNamedLink)nameSpace->classes.first; link; link = (BTNamedLink)((BTNode)link).next)
794 Class _class = link.data;
796 applicationClass = eSystem_FindClass(_class.module, "Application");
797 if(_class != applicationClass && eClass_IsDerived(_class, applicationClass) && (!thisModule || _class.module == privateModule))
800 if(strcmp(_class.fullName, "ecere::com::Application") && (!thisModule || _class.module == privateModule))
803 for(base = _class.base; base && base.type != systemClass; base = base.base)
804 if(!strcmp(base.fullName, "ecere::com::Application"))
809 for(ns = (NameSpace *)nameSpace->nameSpaces.first; ns; ns = (NameSpace *)((BTNode)ns).next)
811 Class _class = FindAppClass(ns, thisModule);
812 if(_class) // && _class != applicationClass)
815 return null; //applicationClass;
818 static Class SearchAppClass_Module(Module module)
823 appClass = FindAppClass(module.publicNameSpace, false);
824 if(appClass) return appClass;
825 appClass = FindAppClass(module.privateNameSpace, false);
826 if(appClass) return appClass;
828 for(subModule = module.modules.first; subModule; subModule = subModule.next)
830 appClass = SearchAppClass_Module(subModule.module);
831 if(appClass) return appClass;
836 static void BindDCOMClient()
838 Class dcomClientObjectClass = eSystem_FindClass(privateModule, "ecere::net::DCOMClientObject");
841 if(dcomClientObjectClass && dcomClientObjectClass.derivatives.first)
844 if(!dcomSymbols) dcomSymbols = TempFile { };
848 for(deriv = dcomClientObjectClass.derivatives.first; deriv; deriv = deriv.next)
850 Class _class = deriv.data;
856 DeclareClass(FindClass("ecere::net::DCOMClientObject"), "__ecereClass___ecereNameSpace__ecere__net__DCOMClientObject");
857 f.Printf("class %s : ecere::net::DCOMClientObject\n", _class.fullName);
860 // CLIENT VIRTUAL METHODS BINDINGS
861 if(_class.vTblSize > _class.base.vTblSize)
864 f.Printf(" virtual void CallVirtualMethod(uint __ecereMethodID, SerialBuffer __ecereBuffer)\n");
866 f.Printf(" switch(__ecereMethodID)\n");
869 for(vid = _class.base.vTblSize; vid < _class.vTblSize; vid++)
872 for(method = (Method)_class.methods.first; method; method = (Method)((BTNode)method).next)
874 if(method.type == virtualMethod && method._class == _class && method.vid == vid)
880 method.dataType = ProcessTypeString(method.dataTypeString, false);
881 if(method.dataType && method.dataType.name)
883 f.Printf(" case %d:\n", vid - _class.base.vTblSize);
886 if(method.dataType.returnType.kind != voidType)
889 OldList * specs = MkList();
891 char type[1024] = "";
892 char className[1024];
895 if(method.dataType.returnType.kind == classType)
896 classSym = method.dataType.returnType._class; // VERIFY THIS FindClass(method.dataType.returnType._class.string);
899 PrintType(method.dataType.returnType, type, false, true);
900 classSym = FindClass(type);
903 strcpy(className, "__ecereClass_");
904 FullClassNameCat(className, classSym.string, true);
905 MangleClassName(className);
906 DeclareClass(classSym, className);
908 PrintType(method.dataType.returnType, type, true, true);
910 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier("__ecereResult")));
911 resultType = MkTypeName(specs, decl);
914 OutputTypeName(resultType, f);
918 for(param = method.dataType.params.first; param; param = param.next)
920 if(param.kind == classType && !strcmp(param._class.string, "String"))
922 // Hardcode 1024 chars max string for now
923 f.Printf(" char %s[1024];\n", param.name);
924 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
925 DeclareClass(FindClass("String"), "__ecereClass_String");
929 TypeName paramTypeName;
930 OldList * specs = MkList();
932 char type[1024] = "";
933 char className[1024];
936 if(param.kind == classType)
937 classSym = param._class; // VERIFY THIS FindClass(param._class.string);
940 PrintType(param, type, false, true);
941 classSym = FindClass(type);
945 strcpy(className, "__ecereClass_");
946 FullClassNameCat(className, classSym.string, true);
947 MangleClassName(className);
948 DeclareClass(classSym, className);
950 PrintType(param, type, true, true);
952 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier(param.name /*"__ecereResult"*/)));
953 paramTypeName = MkTypeName(specs, decl);
956 OutputTypeName(paramTypeName, f);
963 for(param = method.dataType.params.first; param; param = param.next)
965 f.Printf(" __ecereBuffer.Unserialize(");
966 if(param.kind == classType && !strcmp(param._class.string, "String"))
968 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
969 f.Printf("(StaticString)");
976 if(method.dataType.returnType.kind != voidType)
977 f.Printf("__ecereResult = ");
979 // f.Printf("this.instance.%s(", method.name);
980 f.Printf("%s(", method.name);
982 for(param = method.dataType.params.first; param; param = param.next)
986 f.Printf("%s", param.name);
991 for(param = method.dataType.params.first; param; param = param.next)
993 if(param.kind == classType && ((param._class && param._class.registered && param._class.registered.type == structClass) || !strcmp(param._class.string, "String")) && !param.constant)
995 if(!strcmp(param._class.string, "String"))
997 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
998 f.Printf(" __ecereBuffer.Serialize((StaticString)%s);\n", param.name);
1001 f.Printf(" __ecereBuffer.Serialize(%s);\n", param.name);
1004 if(method.dataType.returnType.kind != voidType)
1006 f.Printf(" __ecereBuffer.Serialize(__ecereResult);\n");
1009 for(param = method.dataType.params.first; param; param = param.next)
1011 if(param.kind == classType && strcmp(param._class.string, "String") && param._class.registered &&
1012 (param._class.registered.type == normalClass || param._class.registered.type == noHeadClass))
1014 f.Printf(" delete %s;\n", param.name);
1017 if(method.dataType.returnType.kind == classType && strcmp(method.dataType.returnType._class.string, "String") && method.dataType.returnType._class.registered &&
1018 (method.dataType.returnType._class.registered.type == normalClass || method.dataType.returnType._class.registered.type == noHeadClass))
1020 f.Printf(" delete __ecereResult;\n");
1024 f.Printf(" break;\n");
1036 vid = _class.base.vTblSize;
1038 next = (Method)_class.methods.first;
1039 while(next && ((next.type == virtualMethod) != doVirtual || (doVirtual && next.vid != vid)))
1042 next = (Method)((BTNode)next).next;
1043 if(!next && doVirtual)
1045 if(vid == _class.vTblSize)
1050 next = (Method)_class.methods.first;
1053 for(method = next; method; method = next)
1057 if(!method.dataType)
1058 method.dataType = ProcessTypeString(method.dataTypeString, false);
1060 if(method.dataType.name)
1066 strcpy(name, "__ecereVMethodID_");
1067 FullClassNameCat(name, method._class.fullName, true);
1069 strcat(name, method.name);
1070 DeclareMethod(method, name);
1072 f.Printf("virtual ");
1074 f.Printf("%s\n", method.dataTypeString);
1079 if(method.dataType.returnType.kind != voidType)
1081 TypeName resultType;
1082 OldList * specs = MkList();
1084 char type[1024] = "";
1085 char className[1024];
1088 if(method.dataType.returnType.kind == classType)
1089 classSym = method.dataType.returnType._class; // VERIFY THIS FindClass(method.dataType.returnType._class.string);
1092 PrintType(method.dataType.returnType, type, false, true);
1093 classSym = FindClass(type);
1097 strcpy(className, "__ecereClass_");
1098 FullClassNameCat(className, classSym.string, true);
1099 MangleClassName(className);
1100 DeclareClass(classSym, className);
1102 PrintType(method.dataType.returnType, type, true, true);
1104 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier("__ecereResult")));
1105 resultType = MkTypeName(specs, decl);
1108 OutputTypeName(resultType, f);
1109 if(method.dataType.returnType.kind == structType)
1110 f.Printf(" = { 0 }");
1111 else if(method.dataType.returnType.kind == classType && method.dataType.returnType._class.registered && method.dataType.returnType._class.registered.type == structClass)
1117 f.Printf(" incref this;\n");
1118 for(param = method.dataType.params.first; param; param = param.next)
1120 char type[1024] = "";
1121 char className[1024];
1124 if(param.kind == classType)
1125 classSym = param._class; // VERIFY THIS FindClass(param._class.string);
1128 PrintType(param, type, false, true);
1129 classSym = FindClass(type);
1132 strcpy(className, "__ecereClass_");
1133 FullClassNameCat(className, classSym.string, true);
1135 MangleClassName(className);
1136 DeclareClass(classSym, className);
1138 if(param.kind == classType && !strcmp(param._class.string, "String"))
1140 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1141 f.Printf(" __ecereBuffer.Serialize((StaticString)%s);\n", param.name);
1144 f.Printf(" __ecereBuffer.Serialize(%s);\n", param.name);
1148 eSystem_FindClass(privateModule, "ecere::net::DCOMClientObject"), "CallMethod", privateModule),
1149 "__ecereMethod___ecereNameSpace__ecere__net__DCOMClientObject_CallMethod");
1151 f.Printf(" if(DCOMClientObject::CallMethod(%d))\n", id++);
1153 for(param = method.dataType.params.first; param; param = param.next)
1155 if(param.kind == classType && ((param._class && param._class.registered && param._class.registered.type == structClass) || !strcmp(param._class.string, "String")) && !param.constant)
1157 if(!strcmp(param._class.string, "String"))
1159 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1160 f.Printf(" __ecereBuffer.Unserialize((StaticString)%s);\n", param.name);
1163 f.Printf(" __ecereBuffer.Unserialize(%s);\n", param.name);
1166 if(method.dataType.returnType.kind != voidType)
1168 if(method.dataType.returnType.kind == classType && !strcmp(method.dataType.returnType._class.string, "String"))
1170 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1171 f.Printf(" __ecereBuffer.Unserialize((StaticString)__ecereResult);\n");
1174 f.Printf(" __ecereBuffer.Unserialize(__ecereResult);\n");
1177 f.Printf(" __ecereBuffer.Free();\n");
1178 f.Printf(" delete this;\n");
1179 if(method.dataType.returnType.kind != voidType)
1181 f.Printf(" return __ecereResult;\n");
1187 next = (Method)((BTNode)method).next;
1188 while(next && ((next.type == virtualMethod) != doVirtual || (doVirtual && next.vid != vid)))
1191 next = (Method)((BTNode)next).next;
1192 if(!next && doVirtual)
1194 if(vid == _class.vTblSize)
1199 next = (Method)_class.methods.first;
1214 static void BindDCOMServer()
1216 bool mutexDeclared = false;
1218 for(_class = privateModule.classes.first; _class; _class = _class.next)
1220 if(_class.isRemote == 3) //)
1227 if(!dcomSymbols) dcomSymbols = TempFile { };
1230 DeclareClass(FindClass("ecere::net::DCOMServerObject"), "__ecereClass___ecereNameSpace__ecere__net__DCOMServerObject");
1233 for(_class = privateModule.classes.first; _class; _class = _class.next)
1235 if(_class.isRemote == 3) //2 && !strncmp(_class.fullName, "DCOMServer_", strlen("DCOMServer_")))
1241 f.Printf("class DCOM%s : ecere::net::DCOMServerObject\n", _class.fullName);
1242 // f.Printf("class DCOM%s\n", _class.fullName);
1245 f.Printf(" %s instance;\n", _class.fullName);
1246 f.Printf(" unsigned int id;\n");
1247 f.Printf(" SerialBuffer buffer { };\n");
1251 f.Printf(" DCOM%s()\n", _class.fullName);
1253 f.Printf(" instance = eInstance_New(class(%s));\n", _class.fullName);
1257 f.Printf(" virtual void CallMethod(uint __ecereMethodID, SerialBuffer __ecereBuffer)\n");
1259 f.Printf(" %s inst = (%s)instance;\n", _class.fullName, _class.fullName);
1260 f.Printf(" incref inst;\n");
1261 f.Printf(" switch(__ecereMethodID)\n");
1264 for(method = (Method)_class.methods.first; method; method = (Method)((BTNode)method).next)
1267 method.dataType = ProcessTypeString(method.dataTypeString, false);
1268 if(method.dataType && method.dataType.name)
1270 f.Printf(" case %d:\n", id++);
1274 if(method.dataType.returnType.kind != voidType)
1276 TypeName resultType;
1277 OldList * specs = MkList();
1279 char type[1024] = "";
1280 char className[1024];
1283 if(method.dataType.returnType.kind == classType)
1284 classSym = method.dataType.returnType._class; // VERIFY THIS FindClass(method.dataType.returnType._class.string);
1287 PrintType(method.dataType.returnType, type, false, true);
1288 classSym = FindClass(type);
1291 strcpy(className, "__ecereClass_");
1292 FullClassNameCat(className, classSym.string, true);
1293 MangleClassName(className);
1294 DeclareClass(classSym, className);
1296 PrintType(method.dataType.returnType, type, true, true);
1298 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier("__ecereResult")));
1299 resultType = MkTypeName(specs, decl);
1302 OutputTypeName(resultType, f);
1306 for(param = method.dataType.params.first; param; param = param.next)
1308 if(param.kind == classType && !strcmp(param._class.string, "String"))
1310 // Hardcode 1024 chars max string for now
1311 f.Printf(" char %s[1024];\n", param.name);
1312 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1313 DeclareClass(FindClass("String"), "__ecereClass_String");
1317 TypeName paramTypeName;
1318 OldList * specs = MkList();
1320 char type[1024] = "";
1321 char className[1024];
1324 if(param.kind == classType)
1325 classSym = param._class; // VERIFY THIS FindClass(param._class.string);
1328 PrintType(param, type, false, true);
1329 classSym = FindClass(type);
1333 strcpy(className, "__ecereClass_");
1334 FullClassNameCat(className, classSym.string, true);
1335 MangleClassName(className);
1336 DeclareClass(classSym, className);
1338 PrintType(param, type, true, true);
1340 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier(param.name /*"__ecereResult"*/)));
1341 paramTypeName = MkTypeName(specs, decl);
1344 OutputTypeName(paramTypeName, f);
1351 for(param = method.dataType.params.first; param; param = param.next)
1353 f.Printf(" __ecereBuffer.Unserialize(");
1354 if(param.kind == classType && !strcmp(param._class.string, "String"))
1356 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1357 f.Printf("(StaticString)");
1364 if(method.dataType.returnType.kind != voidType)
1365 f.Printf("__ecereResult = ");
1367 // f.Printf("this.instance.%s(", method.name);
1368 f.Printf("((%s)instance).%s(", _class.fullName, method.name);
1370 for(param = method.dataType.params.first; param; param = param.next)
1374 f.Printf("%s", param.name);
1379 for(param = method.dataType.params.first; param; param = param.next)
1381 if(param.kind == classType && ((param._class && param._class.registered && param._class.registered.type == structClass) || !strcmp(param._class.string, "String")) && !param.constant)
1383 if(!strcmp(param._class.string, "String"))
1385 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1386 f.Printf(" __ecereBuffer.Serialize((StaticString)%s);\n", param.name);
1389 f.Printf(" __ecereBuffer.Serialize(%s);\n", param.name);
1392 if(method.dataType.returnType.kind != voidType)
1394 f.Printf(" __ecereBuffer.Serialize(__ecereResult);\n");
1397 for(param = method.dataType.params.first; param; param = param.next)
1399 if(param.kind == classType && strcmp(param._class.string, "String") && param._class.registered &&
1400 (param._class.registered.type == normalClass || param._class.registered.type == noHeadClass))
1402 f.Printf(" delete %s;\n", param.name);
1405 if(method.dataType.returnType.kind == classType && strcmp(method.dataType.returnType._class.string, "String") && method.dataType.returnType._class.registered &&
1406 (method.dataType.returnType._class.registered.type == normalClass || method.dataType.returnType._class.registered.type == noHeadClass))
1408 f.Printf(" delete __ecereResult;\n");
1412 f.Printf(" break;\n");
1417 f.Printf(" delete inst;\n");
1420 // *** VIRTUAL FUNCTIONS BINDINGS ***
1421 for(vid = _class.base.vTblSize; vid < _class.vTblSize; vid++)
1426 for(method = (Method)_class.methods.first; method; method = (Method)((BTNode)method).next)
1427 if(method.type == virtualMethod && method._class == _class && method.vid == vid)
1433 DeclareClass(FindClass("ecere::sys::Mutex"), "__ecereClass___ecereNameSpace__ecere__sys__Mutex");
1436 eSystem_FindClass(privateModule, "ecere::sys::Mutex"), "Wait", privateModule),
1437 "__ecereMethod___ecereNameSpace__ecere__sys__Mutex_Wait");
1440 eSystem_FindClass(privateModule, "ecere::sys::Mutex"), "Release", privateModule),
1441 "__ecereMethod___ecereNameSpace__ecere__sys__Mutex_Release");
1442 mutexDeclared = true;
1446 if(!method.dataType)
1447 method.dataType = ProcessTypeString(method.dataTypeString, false);
1449 if(method.dataType.name)
1451 f.Printf(" virtual %s\n", method.dataTypeString);
1456 f.Printf(" DCOM%s __ecereObject = (void *)_vTbl[-1];\n", _class.fullName);
1457 if(method.dataType.returnType.kind != voidType)
1459 TypeName resultType;
1460 OldList * specs = MkList();
1462 char type[1024] = "";
1463 char className[1024];
1466 if(method.dataType.returnType.kind == classType)
1467 classSym = method.dataType.returnType._class; // VERIFY THIS FindClass(method.dataType.returnType._class.string);
1470 PrintType(method.dataType.returnType, type, false, true);
1471 classSym = FindClass(type);
1475 strcpy(className, "__ecereClass_");
1476 FullClassNameCat(className, classSym.string, true);
1477 MangleClassName(className);
1478 DeclareClass(classSym, className);
1480 PrintType(method.dataType.returnType, type, true, true);
1482 decl = SpecDeclFromString(type, specs, MkDeclaratorIdentifier(MkIdentifier("__ecereResult")));
1483 resultType = MkTypeName(specs, decl);
1486 OutputTypeName(resultType, f);
1487 if(method.dataType.returnType.kind == structType)
1488 f.Printf(" = { 0 }");
1489 else if(method.dataType.returnType.kind == classType && method.dataType.returnType._class.registered && method.dataType.returnType._class.registered.type == structClass)
1496 f.Printf(" incref __ecereObject;\n");
1497 f.Printf(" __ecereMethod___ecereNameSpace__ecere__sys__Mutex_Wait(__ecereObject.mutex);\n");
1499 //f.Printf(" incref this;\n");
1500 for(param = method.dataType.params.first; param; param = param.next)
1502 char type[1024] = "";
1503 char className[1024];
1506 if(param.kind == classType)
1507 classSym = param._class; // VERIFY THIS FindClass(param._class.string);
1510 PrintType(param, type, false, true);
1511 classSym = FindClass(type);
1514 strcpy(className, "__ecereClass_");
1515 FullClassNameCat(className, classSym.string, true);
1516 MangleClassName(className);
1517 DeclareClass(classSym, className);
1519 if(param.kind == classType && !strcmp(param._class.string, "String"))
1521 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1522 f.Printf(" __ecereObject.argsBuffer.Serialize((StaticString)%s);\n", param.name);
1525 f.Printf(" __ecereObject.argsBuffer.Serialize(%s);\n", param.name);
1530 eSystem_FindClass(privateModule, "ecere::net::DCOMServerObject"), "CallVirtualMethod", privateModule),
1531 "__ecereMethod___ecereNameSpace__ecere__net__DCOMServerObject_CallVirtualMethod");
1533 // Check if this method needs to return anything (hasReturnValue)
1535 bool hasReturnValue = method.dataType.returnType.kind != voidType;
1538 for(param = method.dataType.params.first; param; param = param.next)
1540 if(param.kind == classType && ((param._class && param._class.registered && param._class.registered.type == structClass) || !strcmp(param._class.string, "String")) && !param.constant)
1542 hasReturnValue = true;
1547 f.Printf(" if(__ecereObject.CallVirtualMethod(%d, %s))\n", vid - _class.base.vTblSize,
1548 hasReturnValue ? "true" : "false");
1551 for(param = method.dataType.params.first; param; param = param.next)
1553 if(param.kind == classType && ((param._class && param._class.registered && param._class.registered.type == structClass) || !strcmp(param._class.string, "String")) && !param.constant)
1555 if(!strcmp(param._class.string, "String"))
1557 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1558 f.Printf(" __ecereObject.returnBuffer.Unserialize((StaticString)%s);\n", param.name);
1561 f.Printf(" __ecereObject.returnBuffer.Unserialize(%s);\n", param.name);
1564 if(method.dataType.returnType.kind != voidType)
1566 if(method.dataType.returnType.kind == classType && !strcmp(method.dataType.returnType._class.string, "String"))
1568 DeclareClass(FindClass("StaticString"), "__ecereClass_StaticString");
1569 f.Printf(" __ecereObject.returnBuffer.Unserialize((StaticString)__ecereResult);\n");
1572 f.Printf(" __ecereObject.returnBuffer.Unserialize(__ecereResult);\n");
1575 f.Printf(" else\n");
1576 f.Printf(" ((%s)this).%s::%s(", _class.fullName, _class.fullName, method.name);
1577 for(param = method.dataType.params.first; param; param = param.next)
1579 f.Printf("%s", param.name);
1580 if(param.next) f.Printf(", ");
1584 f.Printf(" __ecereObject.returnBuffer.Free();\n");
1585 f.Printf(" __ecereMethod___ecereNameSpace__ecere__sys__Mutex_Release(__ecereObject.mutex);\n");
1586 //f.Printf(" delete this;\n");
1587 f.Printf(" delete __ecereObject;\n");
1588 if(method.dataType.returnType.kind != voidType)
1590 f.Printf(" return __ecereResult;\n");
1595 /*if(vid < _class.vTblSize)
1606 class SymbolgenApp : Application
1611 char ** argv = null;
1616 char * output = null;
1618 targetPlatform = GetRuntimePlatform();
1621 for(c = 0; c<this.argc; c++)
1623 char * arg = this.argv[c];
1624 int argLen = strlen(arg);
1626 argv = renew argv char *[argc + 1];
1627 argv[argc] = new char[argLen+1];
1628 strcpy(argv[argc], arg);
1630 while(argv[argc][argLen-1] == '\\' && c < this.argc-1)
1637 argv[argc] = renew argv[argc] char[argLen + len + 1];
1639 argv[argc][argLen-1] = ' ';
1640 strcpy(argv[argc] + argLen, arg);
1647 for(c = 1; c<argc; c++)
1649 char * arg = argv[c];
1652 if(!strcmp(arg+1, "o"))
1654 if(!output && c + 1 < argc)
1662 else if(!strcmp(arg, "-name"))
1666 strcpy(projectName, argv[c+1]);
1672 else if(!strcmp(arg, "-t"))
1675 targetPlatform = argv[c];
1679 else if(!strcmp(arg, "-console"))
1681 else if(!strcmp(arg, "-dynamiclib"))
1682 isDynamicLibrary = true;
1683 else if(!strcmp(arg, "-staticlib"))
1685 isDynamicLibrary = true; // TOFIX: unmixup
1686 isStaticLibrary = true;
1688 else if(!strcmp(arg, "-symbols"))
1692 SetSymbolsDir(argv[c+1]);
1704 printf($"Syntax:\n ecs [-t <target platform>] <input>[, <input>]* -o <output>\n");
1708 char ext[MAX_EXTENSION];
1709 char symbolModule[MAX_FILENAME];
1710 GetExtension(output, ext);
1711 GetLastDirectory(output, symbolModule);
1713 SetDefines(&::_defines);
1714 SetImports(&_imports);
1715 SetGlobalData(&globalData);
1716 SetExcludedSymbols(&_excludedSymbols);
1717 SetGlobalContext(theGlobalContext);
1718 SetTopContext(theGlobalContext);
1719 SetCurrentContext(theGlobalContext);
1720 SetTargetPlatform(targetPlatform);
1722 privateModule = __ecere_COM_Initialize(true, 1, null);
1723 SetPrivateModule(privateModule);
1724 mainModule = ModuleImport { };
1725 SetMainModule(mainModule);
1726 _imports.Add(mainModule);
1728 //if(!strcmp(ext, "c"))
1730 String symbolsDir = GetSymbolsDir();
1731 // Only generating .pot files when building from release.* directory for now
1732 bool outputPot = symbolsDir && SearchString(symbolsDir, 0, "release.", false, false);
1733 Map<ContextStringPair, List<String> > intlStrings { };
1734 MapIterator<ContextStringPair, List<String>> it { map = intlStrings };
1736 for(c = 1; c<argc; c++)
1738 char * file = argv[c];
1741 if(!strcmp(file, "-c"))
1746 char ext[MAX_EXTENSION];
1747 GetExtension(file,ext);
1748 if(!strcmp(ext, "imp"))
1753 // What is this supposed to do?
1754 for(c = 1; c<argc; c++)
1756 char * file = argv[c];
1759 if(!strcmp(file, "-c"))
1764 for(c = 1; c<argc; c++)
1766 char * file = argv[c];
1769 // Don't even know what it does here?
1770 if(!strcmp(file, "-c"))
1775 char ext[MAX_EXTENSION];
1776 char moduleName[MAX_LOCATION];
1778 GetExtension(file,ext);
1780 GetLastDirectory(file, moduleName);
1781 StripExtension(moduleName);
1782 strcat(moduleName, ".ec");
1784 if(fstrcmp(moduleName, symbolModule) && (!strcmp(ext, "sym") || !strcmp(ext, "ec")))
1786 ImportedModule importedModule;
1787 ModuleInfo module { };
1788 char fileName[MAX_FILENAME];
1789 ::modules.Add(module);
1791 GetLastDirectory(file, fileName);
1793 module.name = CopyString(fileName);
1795 StripExtension(module.name);
1797 for(importedModule = ::_defines.first; importedModule; importedModule = importedModule.next)
1799 if(importedModule.type == moduleDefinition && !strcmpi(importedModule.name, module.name) && !(importedModule.importType == remoteImport))
1804 module.globalInstance = importedModule.globalInstance;
1807 importedModule = ImportedModule
1809 name = CopyString(module.name),
1810 type = moduleDefinition,
1811 importType = normalImport
1813 ::_defines.AddName(importedModule);
1815 module.globalInstance = LoadSymbols(file, normalImport, false);
1816 CheckDataRedefinitions();
1822 ChangeExtension(file, "bowl", fileName);
1823 f = FileOpen(fileName, read);
1826 static char line[65536];
1827 List<String> comments { };
1828 String msgid = null, msgstr = null, msgctxt = null;
1831 if(f.GetLine(line, sizeof(line)))
1834 TrimLSpaces(line, line);
1837 comments.Add(CopyString(line));
1839 else if(strstr(line, "msgid \"") == line)
1842 msgid = CopyString(line + 7);
1843 len = strlen(msgid);
1844 if(len) msgid[len-1] = 0;
1846 else if(strstr(line, "msgctxt \"") == line)
1849 msgctxt = CopyString(line + 9);
1850 len = strlen(msgctxt);
1851 if(len) msgctxt[len-1] = 0;
1853 else if(strstr(line, "msgstr \"") == line)
1856 msgstr = CopyString(line + 8);
1857 len = strlen(msgstr);
1858 if(len) msgstr[len-1] = 0;
1863 ContextStringPair pair { msgid, msgctxt };
1865 if(!it.Index(pair, false))
1867 msgid = null; msgctxt = null;
1868 intlStrings[pair] = comments;
1875 comments.RemoveAll();
1893 ComputeModuleClasses(privateModule);
1895 if(!isDynamicLibrary)
1897 // applicationClass = eSystem_FindClass(privateModule, "Application");
1899 thisAppClass = FindAppClass(&privateModule.application.publicNameSpace, true);
1901 thisAppClass = FindAppClass(&privateModule.application.privateNameSpace, true);
1903 thisAppClass = FindAppClass(&privateModule.application.publicNameSpace, false);
1905 thisAppClass = FindAppClass(&privateModule.application.privateNameSpace, false);
1907 thisAppClass = SearchAppClass_Module(privateModule);
1911 if(outputPot && intlStrings.count)
1914 char potFileName[MAX_LOCATION];
1915 //strcpy(potFileName, output);
1916 //StripExtension(potFileName);
1917 strcpy(potFileName, "locale");
1918 MakeDir(potFileName);
1919 PathCat(potFileName, projectName);
1920 ChangeExtension(potFileName, "pot", potFileName);
1921 potFile = FileOpen(potFileName, write);
1925 potFile.Puts("msgid \"\"\n");
1926 potFile.Puts("msgstr \"\"\n");
1927 potFile.Puts("\"Project-Id-Version: \\n\"\n");
1928 potFile.Puts("\"POT-Creation-Date: \\n\"\n");
1929 potFile.Puts("\"PO-Revision-Date: \\n\"\n");
1930 potFile.Puts("\"Last-Translator: \\n\"\n");
1931 potFile.Puts("\"Language-Team: \\n\"\n");
1932 potFile.Puts("\"MIME-Version: 1.0\\n\"\n");
1933 potFile.Puts("\"Content-Type: text/plain; charset=iso-8859-1\\n\"\n");
1934 potFile.Puts("\"Content-Transfer-Encoding: 8bit\\n\"\n");
1935 potFile.Puts("\"X-Poedit-Basepath: ../\\n\"\n");
1938 for(i : intlStrings)
1940 ContextStringPair pair = &i;
1941 List<String> comments = i;
1950 potFile.Puts("msgctxt \""); potFile.Puts(pair.context); potFile.Puts("\"\n");
1952 potFile.Puts("msgid \""); potFile.Puts(pair.string); potFile.Puts("\"\n");
1953 potFile.Puts("msgstr \""); potFile.Puts(pair.string); potFile.Puts("\"\n");
1963 FreeContext(theGlobalContext);
1964 FreeExcludedSymbols(_excludedSymbols);
1966 ::_defines.Free(FreeModuleDefine);
1967 _imports.Free(FreeModuleImport);
1969 //precompDefines.Free(FreeDefinition);
1971 FreeTypeData(privateModule);
1973 FreeGlobalData(globalData);
1975 delete privateModule;
1978 SetSymbolsDir(null); // Free symbols dir
1981 for(c = 0; c<argc; c++)