1 // PARAVIS : ParaView wrapper SALOME module
3 // Copyright (C) 2010-2013 CEA/DEN, EDF R&D
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License.
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 // File : vtkWrapIDL.c
22 // Author : Vladimir TURIN
28 #include "vtkConfigure.h"
30 #include "vtkParseType.h"
31 #include "vtkParseMain.h"
32 #include "vtkWrapIDL.h"
36 "// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,",
37 "// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS",
39 "// This library is free software; you can redistribute it and/or",
40 "// modify it under the terms of the GNU Lesser General Public",
41 "// License as published by the Free Software Foundation; either",
42 "// version 2.1 of the License.",
44 "// This library is distributed in the hope that it will be useful,",
45 "// but WITHOUT ANY WARRANTY; without even the implied warranty of",
46 "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU",
47 "// Lesser General Public License for more details.",
49 "// You should have received a copy of the GNU Lesser General Public",
50 "// License along with this library; if not, write to the Free Software",
51 "// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA",
53 "// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com",
59 HierarchyInfo *hierarchyInfo = NULL;
60 int numberOfWrappedFunctions = 0;
61 FunctionInfo *wrappedFunctions[1000];
62 extern FunctionInfo *currentFunction;
63 char *EmptyString = "";
66 static void add_to_sig(char *sig, const char *add, int *i)
69 *i += (int)strlen(add);
72 int IsReturnArg(int I) {
73 return (I == MAX_ARGS);
76 void AddReturnArg(char *Result, int *CurrPos) {
77 add_to_sig(Result,"virtual ",CurrPos);
80 int IsIn(ValueInfo* Type) {
82 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 < 1 || (Type % VTK_PARSE_BASE_TYPE)/0x100 > 7);
85 void AddNotReturnArg(ValueInfo* Type, char *Result, int *CurrPos) {
86 #if defined(IDL_I_HH) || defined(IDL_I_CC)
90 add_to_sig(Result,"in ",CurrPos);
92 add_to_sig(Result,"inout ",CurrPos);
96 int IsFunction(ValueInfo* Type) {
97 //return (Type == VTK_PARSE_FUNCTION);
98 return vtkWrap_IsFunction(Type);
101 int IsConst(ValueInfo* Type) {
102 //return ((Type % 0x2000) >= 0x1000);
103 return vtkWrap_IsConst(Type);
106 void AddConst(char *Result, int *CurrPos) {
107 #if defined(IDL_I_HH) || defined(IDL_I_CC)
108 add_to_sig(Result,"const ",CurrPos);
110 add_to_sig(Result,"in ",CurrPos);
115 int IsClass(ValueInfo* theType) {
116 //return ((theType->Type % 0x10) == 0x9);
117 return vtkWrap_IsObject(theType) || vtkWrap_IsVTKObject(theType);
120 int IsString(ValueInfo* Type) {
121 //return (IsChar(Type) && IsArray(Type));
122 //return (IsChar(Type) && IsPtr(Type));
123 return vtkWrap_IsCharPointer(Type) || vtkWrap_IsString(Type) || (strcmp(Type->Class, "vtkStdString") == 0);
126 int IsPtr(ValueInfo* Type) {
127 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x1);
128 return vtkWrap_IsPointer(Type) && (!IsString(Type)) && (!IsClass(Type));
131 int IsUnknown(ValueInfo* theType) {
132 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x8);
133 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_UNKNOWN;
136 void AddAtomArg(int I, ValueInfo* Type, char *TypeIDL, char *TypeCorba, char *Result, int *CurrPos) {
137 #if defined(IDL_I_HH) || defined(IDL_I_CC)
138 add_to_sig(Result,"CORBA::",CurrPos);
139 add_to_sig(Result,TypeCorba,CurrPos);
141 if (!IsReturnArg(I) && !IsConst(Type) && !IsIn(Type))
142 add_to_sig(Result,"&",CurrPos);
144 add_to_sig(Result,TypeIDL,CurrPos);
146 add_to_sig(Result," ",CurrPos);
149 int IsArray(ValueInfo* Type) {
150 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x3);
151 return vtkWrap_IsArray(Type);
154 void AddArrayArg(int I, ValueInfo* Type, char *TypeIDL, char *Result, int *CurrPos) {
155 #if defined(IDL_I_HH) || defined(IDL_I_CC)
156 if(!IsReturnArg(I) && !IsConst(Type))
157 add_to_sig(Result, "const ",CurrPos);
159 add_to_sig(Result, TypeIDL,CurrPos);
160 add_to_sig(Result, "_array",CurrPos);
161 #if defined(IDL_I_HH) || defined(IDL_I_CC)
163 add_to_sig(Result, "*",CurrPos);
165 add_to_sig(Result, "&",CurrPos);
169 add_to_sig(Result, " ",CurrPos);
172 int IsBoolean(ValueInfo* Type) {
173 //return ((Type % 0x10) == 0xE);
174 return vtkWrap_IsBool(Type);
177 void AddBooleanAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
178 AddAtomArg(I,Type,"boolean","Boolean",Result,CurrPos);
181 int IsChar(ValueInfo* theType) {
182 //return ((Type % 0x10) == 0x3 || (Type % 0x10) == 0xD);
183 int aBase = theType->Type & VTK_PARSE_BASE_TYPE;
184 return (aBase == VTK_PARSE_CHAR) || (aBase == VTK_PARSE_UNSIGNED_CHAR) || (aBase == VTK_PARSE_SIGNED_CHAR);
187 int IsCharArray(ValueInfo* theType) {
188 return (IsChar(theType) && IsArray(theType));
191 void AddCharAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
192 AddAtomArg(I,Type,"char","Char",Result,CurrPos);
195 void AddCharArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
196 AddArrayArg(I,Type,"char",Result,CurrPos);
199 void AddStringArg(int I, char *Result, int *CurrPos) {
200 #if defined(IDL_I_HH) || defined(IDL_I_CC)
201 add_to_sig(Result,"char ",CurrPos);
203 add_to_sig(Result,"string ",CurrPos);
207 int IsFloat(ValueInfo* theType) {
208 //return ((Type % 0x10) == 0x1);
209 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FLOAT;
212 void AddFloatAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
213 AddAtomArg(I,Type,"float","Float",Result,CurrPos);
216 int IsFloatArray(ValueInfo* theType) {
217 return (IsFloat(theType) && IsArray(theType));
220 void AddFloatArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
221 AddArrayArg(I,Type,"float",Result,CurrPos);
224 int IsDouble(ValueInfo* theType) {
225 //return ((Type % 0x10) == 0x7);
226 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_DOUBLE;
229 void AddDoubleAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
230 AddAtomArg(I,Type,"double","Double",Result,CurrPos);
233 int IsDoubleArray(ValueInfo* Type) {
234 return (IsDouble(Type) && IsArray(Type));
237 void AddDoubleArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
238 AddArrayArg(I,Type,"double",Result,CurrPos);
241 int IsvtkIdType(ValueInfo* theType) {
242 //return((Type % 0x10) == 0xA);
243 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_ID_TYPE;
246 int IsShort(ValueInfo* theType) {
247 //return ((Type % 0x10) == 0x4 || (Type % 0x10) == 0x5 || (Type % 0x10) == 0xA);
248 int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
249 return (aVal == VTK_PARSE_SHORT) || (aVal == VTK_PARSE_UNSIGNED_SHORT);
252 int IsInt(ValueInfo* theType) {
253 //return ((Type % 0x10) == 0x4 || (Type % 0x10) == 0x5 || (Type % 0x10) == 0xA);
254 int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
255 return (aVal == VTK_PARSE_INT) ||
256 (aVal == VTK_PARSE_ID_TYPE) || (aVal == VTK_PARSE_UNSIGNED_INT) ||
257 (aVal == VTK_PARSE_SSIZE_T) || (aVal == VTK_PARSE_SIZE_T);
260 int IsShortInt(ValueInfo* theType) {
261 //return ((Type % 0x10) == 0x4 || (Type % 0x10) == 0x5 || (Type % 0x10) == 0xA);
262 return (IsShort(theType) || IsInt(theType));
265 void AddShortAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
266 AddAtomArg(I,Type,"short","Short",Result,CurrPos);
269 int IsShortArray(ValueInfo* Type) {
270 return (IsShort(Type) && IsArray(Type));
273 int IsIntArray(ValueInfo* Type) {
274 return (IsInt(Type) && IsArray(Type));
277 void AddShortArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
278 AddArrayArg(I,Type,"short",Result,CurrPos);
281 int IsLong(ValueInfo* theType) {
282 //return ((Type % 0x10) == 0x6 || (Type % 0x10) == 0xB || (Type % 0x10) == 0xC);
283 unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
284 return (aVal == VTK_PARSE_LONG) || (aVal == VTK_PARSE_UNSIGNED_LONG) ||
285 (aVal == VTK_PARSE___INT64) || (aVal == VTK_PARSE_UNSIGNED___INT64) || (aVal == VTK_PARSE_LONG_LONG) ||
286 (aVal == VTK_PARSE_UNSIGNED_LONG_LONG);
289 void AddLongAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
290 AddAtomArg(I,Type,"long","Long",Result,CurrPos);
293 int IsLongArray(ValueInfo* Type) {
294 return (IsLong(Type) && IsArray(Type));
297 void AddLongArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
298 AddArrayArg(I,Type,"long",Result,CurrPos);
301 void AddClassArg(int I, ValueInfo* Type, const char *Class, char *Result, int *CurrPos) {
302 #if defined(IDL_I_HH) || defined(IDL_I_CC)
303 add_to_sig(Result,"PARAVIS_Base",CurrPos);
304 if(IsReturnArg(I) || IsConst(Type) || IsIn(Type)) {
305 add_to_sig(Result,"_ptr",CurrPos);
307 add_to_sig(Result,"_ptr&",CurrPos);
309 add_to_sig(Result," ",CurrPos);
311 add_to_sig(Result,"PARAVIS_Base ",CurrPos);
315 int _IsVoid(ValueInfo* theType) {
316 //return ((Type % 0x10) == 0x2);
317 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_VOID;
320 int IsVoid(ValueInfo* Type) {
321 return (_IsVoid(Type) && (!IsPtr(Type)));
324 int IsUnsigned(ValueInfo* theType) {
325 unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
327 case VTK_PARSE_UNSIGNED_CHAR:
328 case VTK_PARSE_UNSIGNED_INT:
329 case VTK_PARSE_UNSIGNED_SHORT:
330 case VTK_PARSE_UNSIGNED_LONG:
331 case VTK_PARSE_UNSIGNED_ID_TYPE:
332 case VTK_PARSE_UNSIGNED_LONG_LONG:
333 case VTK_PARSE_UNSIGNED___INT64:
334 case VTK_PARSE_UNSIGNED_CHAR_PTR:
335 case VTK_PARSE_UNSIGNED_INT_PTR:
336 case VTK_PARSE_UNSIGNED_SHORT_PTR:
337 case VTK_PARSE_UNSIGNED_LONG_PTR:
338 case VTK_PARSE_UNSIGNED_ID_TYPE_PTR:
339 case VTK_PARSE_UNSIGNED_LONG_LONG_PTR:
340 case VTK_PARSE_UNSIGNED___INT64_PTR:
346 void AddVoid(char *Result, int *CurrPos) {
347 add_to_sig(Result,"void ",CurrPos);
350 int IsVoidPtr(ValueInfo* Type) {
351 return (_IsVoid(Type) && (IsPtr(Type) || IsArray(Type)));
354 void AddVoidArg(int I, char *Result, int *CurrPos, ValueInfo* Type) {
355 #if defined(IDL_I_HH) || defined(IDL_I_CC)
356 if(!IsReturnArg(I)) {
358 add_to_sig(Result,"const ",CurrPos);
359 add_to_sig(Result,"CORBA::Any& ",CurrPos);
361 add_to_sig(Result,"CORBA::Any ",CurrPos);
364 add_to_sig(Result,"any ",CurrPos);
368 void AddTypeArray(ValueInfo* Type, char *Result, int *CurrPos) {
370 add_to_sig(Result,"short",CurrPos);
372 add_to_sig(Result,"long",CurrPos);
374 add_to_sig(Result,"float",CurrPos);
376 add_to_sig(Result,"double",CurrPos);
378 add_to_sig(Result,"char",CurrPos);
379 add_to_sig(Result,"_array",CurrPos);
382 typedef struct _ReadFuncs
390 ReadFuncs readFunctions[1000];
391 int numberOfReadFunctions = 0;
393 static int class_has_new = 0;
395 void output_type(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
397 if (vtkWrap_IsConst(aType))
398 add_to_sig(result,"const ",currPos);
402 add_to_sig(result,"float",currPos);
404 add_to_sig(result,"CORBA::Float",currPos);
408 if(IsDouble(aType)) {
410 add_to_sig(result,"double",currPos);
412 add_to_sig(result,"CORBA::Double",currPos);
416 if(IsShortInt(aType)) {
418 if (IsUnsigned(aType))
419 add_to_sig(result,"unsigned ",currPos);
420 if(IsvtkIdType(aType)) {
421 add_to_sig(result,"vtkIdType",currPos);
423 add_to_sig(result,"int",currPos);
426 add_to_sig(result,"CORBA::Short",currPos);
432 if (IsUnsigned(aType))
433 add_to_sig(result,"unsigned ",currPos);
434 add_to_sig(result,"long",currPos);
436 add_to_sig(result,"CORBA::Long",currPos);
440 if(IsString(aType)) {
442 add_to_sig(result,"const ",currPos);
443 if(strcmp(aType->Class, "vtkStdString") == 0) {
444 add_to_sig(result,"vtkStdString",currPos);
446 add_to_sig(result,"char",currPos);
448 } else if(IsChar(aType)) {
450 if (IsUnsigned(aType))
451 add_to_sig(result,"unsigned ",currPos);
452 add_to_sig(result,"char",currPos);
454 add_to_sig(result,"CORBA::Char",currPos);
458 if(IsBoolean(aType)) {
459 add_to_sig(result,"CORBA::Boolean",currPos);
462 if(IsVoidPtr(aType)) {
463 add_to_sig(result,"void",currPos);
467 add_to_sig(result,"::",currPos);
468 add_to_sig(result,Id,currPos);
471 if(IsArray(aType) || IsPtr(aType) || IsClass(aType) || IsString(aType)) {
472 if(strcmp(aType->Class, "vtkStdString") != 0) {
473 add_to_sig(result,"*",currPos);
478 void output_typedef(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
480 add_to_sig(result," typedef ",currPos);
481 output_type(result,currPos,i,aType,Id);
484 void output_temp(char* result, int *currPos, int i, ValueInfo* aType, const char *Id, int aCount)
488 /* handle VAR FUNCTIONS */
489 if (IsFunction(aType)) {
493 #if defined(IDL_I_HH)
495 AddReturnArg(result,currPos);
499 if (IsReturnArg(i) && IsVoid(aType) && !IsVoidPtr(aType)) {
500 AddVoid(result,currPos);
504 /* for const * return types prototype with const */
505 if ( IsConst(aType) || IsString(aType)) {
506 if(!IsReturnArg(i)) {
507 AddConst(result,currPos);
510 if(!IsReturnArg(i)) {
511 AddNotReturnArg(aType,result,currPos);
516 if(IsFloatArray(aType)) {
517 AddFloatArrayArg(i,aType,result,currPos);
519 AddFloatAtomArg(i,aType,result,currPos);
523 if(IsDouble(aType)) {
524 if(IsDoubleArray(aType)) {
525 AddDoubleArrayArg(i,aType,result,currPos);
527 AddDoubleAtomArg(i,aType,result,currPos);
531 if(IsShortInt(aType)) {
533 AddShortArrayArg(i,aType,result,currPos);
535 AddShortAtomArg(i,aType,result,currPos);
540 if(IsLongArray(aType)) {
541 AddLongArrayArg(i,aType,result,currPos);
543 AddLongAtomArg(i,aType,result,currPos);
548 if(IsString(aType)) {
549 AddStringArg(i,result,currPos);
551 if(IsCharArray(aType)) {
552 AddCharArrayArg(i,aType,result,currPos);
554 AddCharAtomArg(i,aType,result,currPos);
557 } else if (IsString(aType)) //!!! VSV
558 AddStringArg(i,result,currPos);
560 if(IsBoolean(aType)) {
561 AddBooleanAtomArg(i,aType,result,currPos);
565 AddVoidArg(i,result,currPos,aType);
569 AddClassArg(i,aType,Id,result,currPos);
572 if(IsUnknown(aType)) {
576 if(!IsClass(aType)) {
578 add_to_sig(result," *",currPos);
580 #if defined(IDL_I_HH) || defined(IDL_I_CC)
581 if(IsString(aType) && !IsIn(aType) && !IsConst(aType) && !IsReturnArg(i)) {
582 add_to_sig(result,"*&",currPos);
584 if(IsString(aType) || (IsReturnArg(i) && IsVoidPtr(aType))) {
585 add_to_sig(result," *",currPos);
591 if(!IsReturnArg(i)) {
592 sprintf(buf,"temp%i",i);
593 add_to_sig(result,buf,currPos);
599 void read_class_functions(const char* name, const char* classname, FILE* fp)
613 #if ! defined(IDL_I_CC)
620 #if defined(IDL_I_HH)
621 sprintf(buf,"PARAVIS_Gen_%s_i.hh",name);
622 #elif defined(IDL_I_CC)
623 sprintf(buf,"PARAVIS_Gen_%s_i.cc",name);
625 sprintf(buf,"PARAVIS_Gen_%s.idl",name);
627 if (!(fin = fopen(buf,"r"))) {
628 fprintf(stderr,"Error opening input file %s\n",buf);
631 while (fgets(sig,bs-1,fin) != 0) {
632 #if defined(IDL_I_CC)
633 if(strncmp("#include \"PARAVIS_Gen_vtk",sig,25)==0) {
634 fprintf(fp, "%s",sig);
636 if(strncmp("#include <vtk",sig,13)==0) {
637 fprintf(fp, "%s",sig);
641 #if ! defined(IDL_I_CC)
642 if(strncmp(" //C++: ",sig,clen)==0) {
644 if(strncmp("//C++: ",sig,clen)==0) {
646 #if defined(IDL_I_CC)
647 while(fgets(buf,bs-1,fin) != 0) {
650 if(strlen(buf) == 3 && buf[0]=='/' && buf[1]=='/')
655 if(fgets(buf,bs-1,fin)!=NULL && strlen(buf) > 1) {
657 #if defined(IDL_I_HH)
659 readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
660 sscanf(sig+len,"%s %s %s",buf,buf1,fname);
661 if(fname[0] == '*') {
664 #elif defined(IDL_I_CC)
666 sscanf(buf1,"%s %s",buf,fname);
669 sprintf(sig+curlen,"%s ",buf);
672 if(fname[0] == '*') {
674 sprintf(sig+curlen," *");
678 sprintf(sig+curlen,"%s_i::",classname);
680 for(i = 0; i < strlen(fname)-1; i++) {
683 if(fname[i] == ':' && fname[i] == ':') {
690 sprintf(sig+curlen,"%s", buf1+j);
693 readFunctions[numberOfReadFunctions].EndPos=curlen;
694 while (fgets(sig+curlen,bs-1-curlen,fin) != 0) {
695 if(sig[curlen] == '}')
701 readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
702 sscanf(sig+len,"%s _%s",buf,fname);
706 if(flen>2 && fname[flen-2]=='_') {
709 readFunctions[numberOfReadFunctions].Name = malloc((flen+1-ret_str)*sizeof(char));
710 strncpy(readFunctions[numberOfReadFunctions].Name,fname+ret_str,flen-ret_str);
711 readFunctions[numberOfReadFunctions].Name[flen-ret_str]='\0';
713 #if defined(IDL_I_HH)
714 len+=slen+strlen(buf)+1+strlen(buf1)+2+flen+ret_str-1; //spaces+virtual+space+return+space+space+*+name
715 #elif defined(IDL_I_CC)
716 len+=2+strlen(buf)+2+strlen(classname)+2+strlen(readFunctions[numberOfReadFunctions].Name)-1; //return+space+space+name
717 if(fname[0] == '*') {
720 if(fname[flen-2]=='_') {
724 len+=slen+strlen(buf)+2+flen; //spaces+return+space+_+name
726 readFunctions[numberOfReadFunctions].NumPos=len;
727 if(fname[flen]=='_') {
728 readFunctions[numberOfReadFunctions].NumPos=len+2; //+_+num
732 readFunctions[numberOfReadFunctions].Signature = malloc((len+1)*sizeof(char));
733 strncpy(readFunctions[numberOfReadFunctions].Signature,sig,len);
734 readFunctions[numberOfReadFunctions].Signature[len]='\0';
736 numberOfReadFunctions++;
745 void get_signature(const char* num, ClassInfo *data)
747 static char result[bs];
753 static char buf1[bs];
757 ValueInfo* aRetVal = NULL;
758 ValueInfo* aArgVal = NULL;
761 aRetVal = currentFunction->ReturnValue;
763 add_to_sig(result,"\n",&currPos);
764 if (currentFunction->Signature) {
765 #if ! defined(IDL_I_CC)
766 add_to_sig(result," ",&currPos);
768 add_to_sig(result,"//C++: ",&currPos);
769 add_to_sig(result,currentFunction->Signature,&currPos);
770 add_to_sig(result,"\n",&currPos);
773 if(IsClass(aRetVal) && ret == 0) {
775 for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
776 if(strcmp(wrapped_classes[i],currentFunction->ReturnValue->Class) == 0)
783 for (j = 0; j < vtkWrap_CountWrappedParameters(currentFunction); j++) {
784 aArgVal = currentFunction->Parameters[j];
785 if(IsFunction(aArgVal))
787 if(IsClass(aArgVal) && ret == 0) {
789 for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
790 if(strcmp(wrapped_classes[i],aArgVal->Class) == 0)
798 if (IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal) && currentFunction->HintSize == 0) {
804 add_to_sig(result,"//\n",&currPos);
805 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
806 (size_t)(currPos+1));*/
807 //strcpy((char*)currentFunction->Signature,result);
808 cp = (char *)malloc(currPos+1);
810 currentFunction->Signature = cp;
814 #if defined(IDL_I_CC)
815 add_to_sig(result,"struct CreateEventName(",&currPos);
816 add_to_sig(result,currentFunction->Name,&currPos);
817 if( strlen(num)!=0 ) {
818 add_to_sig(result,num,&currPos);
820 add_to_sig(result,")",&currPos);
821 add_to_sig(result,": public SALOME_Event\n",&currPos);
822 add_to_sig(result,"{\n",&currPos);
823 if(!IsVoid(aRetVal)) {
824 //output_typedef(result,&currPos,MAX_ARGS,aRetVal, currentFunction->ReturnValue->Class);
825 add_to_sig(result," typedef ",&currPos);
826 if (vtkWrap_IsConst(aRetVal))
827 add_to_sig(result, " const ",&currPos);
828 if (vtkWrap_IsObject(aRetVal))
829 add_to_sig(result, " ::",&currPos);
830 add_to_sig(result, aRetVal->Class,&currPos);
831 if (vtkWrap_IsPointer(aRetVal) || vtkWrap_IsArray(aRetVal))
832 add_to_sig(result, "*",&currPos);
833 add_to_sig(result," TResult;\n",&currPos);
834 add_to_sig(result," TResult myResult;\n",&currPos);
837 //output_typedef(result, &currPos, 0, 0x309, data->Name); //!!??
838 add_to_sig(result," typedef ::",&currPos);
839 add_to_sig(result,data->Name,&currPos);
840 add_to_sig(result,"* TObj;\n",&currPos);
841 add_to_sig(result," TObj myObj;\n",&currPos);
843 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
844 aArgVal = currentFunction->Parameters[i];
845 //output_typedef(result, &currPos, i, currentFunction->ArgTypes[i],
846 // currentFunction->ArgClasses[i]);
847 output_typedef(result, &currPos, i, aArgVal, currentFunction->ArgClasses[i]);
848 sprintf(buf," TParam%d;\n",i);
849 add_to_sig(result,buf,&currPos);
850 sprintf(buf," TParam%d myParam%d;\n",i,i);
851 add_to_sig(result,buf,&currPos);
854 add_to_sig(result,"\n",&currPos);
855 add_to_sig(result," CreateEventName(",&currPos);
856 add_to_sig(result,currentFunction->Name,&currPos);
857 if( strlen(num)!=0 ) {
858 add_to_sig(result,num,&currPos);
860 add_to_sig(result,")",&currPos);
861 add_to_sig(result,"(TObj theObj",&currPos);
862 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
863 sprintf(buf,", TParam%d theParam%d",i,i);
864 add_to_sig(result,buf,&currPos);
866 add_to_sig(result,"):\n",&currPos);
867 add_to_sig(result," myObj(theObj)",&currPos);
868 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
869 sprintf(buf,", myParam%d(theParam%d)",i,i);
870 add_to_sig(result,buf,&currPos);
872 add_to_sig(result,"\n",&currPos);
873 add_to_sig(result," { }\n",&currPos);
874 add_to_sig(result,"\n",&currPos);
875 add_to_sig(result," virtual void Execute()\n",&currPos);
876 add_to_sig(result," {\n",&currPos);
877 add_to_sig(result," ",&currPos);
878 if(!IsVoid(aRetVal)/* && !IsString(aRetVal)*/) {
879 add_to_sig(result,"myResult = ",&currPos);
881 //if(IsString(aRetVal)) {
882 //add_to_sig(result,"const char* ret = ",&currPos);
884 add_to_sig(result,"myObj->",&currPos);
885 add_to_sig(result,currentFunction->Name,&currPos);
886 add_to_sig(result,"(",&currPos);
887 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
888 aArgVal = currentFunction->Parameters[i];
890 add_to_sig(result,", ",&currPos);
891 if(IsClass(aArgVal) && IsPtr(aArgVal)) {
892 add_to_sig(result,"*",&currPos);
894 if (IsString(aArgVal) && IsConst(aArgVal) && strcmp(aArgVal->Class, "vtkStdString") != 0)
895 sprintf(buf,"checkNullStr(myParam%d)",i);
897 sprintf(buf,"myParam%d",i);
898 add_to_sig(result,buf,&currPos);
900 add_to_sig(result,");\n",&currPos);
901 //if(IsString(aRetVal)) {
902 //add_to_sig(result," myResult = (ret==NULL)?NULL:CORBA::string_dup(\"\");\n",&currPos);
904 add_to_sig(result," }\n",&currPos);
906 add_to_sig(result,"};\n",&currPos);
907 add_to_sig(result,"//\n",&currPos);
911 #if ! defined(IDL_I_CC)
912 add_to_sig(result," ",&currPos);
915 output_temp(result,&currPos,MAX_ARGS,aRetVal,
916 currentFunction->ReturnValue->Class,0);
918 #if defined(IDL_I_CC)
919 add_to_sig(result,data->Name,&currPos);
920 add_to_sig(result,"_i::",&currPos);
922 #if ! defined(IDL_I_HH) && ! defined(IDL_I_CC)
923 add_to_sig(result,"_",&currPos);
925 add_to_sig(result,currentFunction->Name,&currPos);
927 if( strlen(num)!=0 ) {
928 add_to_sig(result,num,&currPos);
931 add_to_sig(result," ",&currPos);
933 /* print the arg list */
934 add_to_sig(result,"(",&currPos);
936 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
937 aArgVal = currentFunction->Parameters[i];
939 add_to_sig(result,", ",&currPos);
941 /* output_temp(result, &currPos, i, currentFunction->ArgTypes[i],
942 (char*)currentFunction->ArgClasses[i],
943 currentFunction->ArgCounts[i]);*/
944 output_temp(result, &currPos, i, aArgVal, aArgVal->Class, vtkWrap_CountWrappedParameters(currentFunction));
947 add_to_sig(result,")",&currPos);
948 #if defined(IDL_I_CC)
949 add_to_sig(result," {\n",&currPos);
950 add_to_sig(result," try {\n",&currPos);
951 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
952 aArgVal = currentFunction->Parameters[i];
953 if(IsClass(aArgVal)) {
954 sprintf(buf," PARAVIS_Base_i* i_temp%d = GET_SERVANT(temp%d);\n",i,i);
955 add_to_sig(result,buf,&currPos);
958 if(IsArray(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal) && !IsVoid(aArgVal) ) {
959 sprintf(buf," CORBA::ULong j_temp%d;\n",i);
960 add_to_sig(result,buf,&currPos);
961 sprintf(buf," CORBA::ULong l_temp%d = temp%d.length();\n",i,i);
962 add_to_sig(result,buf,&currPos);
963 add_to_sig(result," ",&currPos);
966 add_to_sig(result,"float",&currPos);
968 if(IsDouble(aArgVal))
969 add_to_sig(result,"double",&currPos);
971 if(IsChar(aArgVal)) {
972 if (IsUnsigned(aArgVal))
973 add_to_sig(result,"unsigned ",&currPos);
974 add_to_sig(result,"char",&currPos);
977 if(IsvtkIdType(aArgVal)) {
978 if (IsUnsigned(aArgVal))
979 add_to_sig(result,"unsigned ",&currPos);
980 add_to_sig(result,"vtkIdType",&currPos);
982 if(IsShortInt(aArgVal)) {
983 if (IsUnsigned(aArgVal))
984 add_to_sig(result,"unsigned ",&currPos);
985 add_to_sig(result,"int",&currPos);
989 if(IsLong(aArgVal)) {
990 if (IsUnsigned(aArgVal))
991 add_to_sig(result,"unsigned ",&currPos);
992 add_to_sig(result,"long",&currPos);
994 sprintf(buf,"* a_temp%d = new ",i);
995 add_to_sig(result,buf,&currPos);
998 add_to_sig(result,"float",&currPos);
1000 if(IsDouble(aArgVal))
1001 add_to_sig(result,"double",&currPos);
1003 if(IsChar(aArgVal)) {
1004 if (IsUnsigned(aArgVal))
1005 add_to_sig(result,"unsigned ",&currPos);
1006 add_to_sig(result,"char",&currPos);
1009 if(IsvtkIdType(aArgVal)) {
1010 if (IsUnsigned(aArgVal))
1011 add_to_sig(result,"unsigned ",&currPos);
1012 add_to_sig(result,"vtkIdType",&currPos);
1014 if(IsShortInt(aArgVal)) {
1015 if (IsUnsigned(aArgVal))
1016 add_to_sig(result,"unsigned ",&currPos);
1017 add_to_sig(result,"int",&currPos);
1021 if(IsLong(aArgVal)) {
1022 if (IsUnsigned(aArgVal))
1023 add_to_sig(result,"unsigned ",&currPos);
1024 add_to_sig(result,"long",&currPos);
1027 sprintf(buf,"[l_temp%d];\n",i);
1028 add_to_sig(result,buf,&currPos);
1030 sprintf(buf," for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
1031 add_to_sig(result,buf,&currPos);
1033 sprintf(buf," a_temp%d[j_temp%d]=temp%d[j_temp%d];\n",i,i,i,i);
1034 add_to_sig(result,buf,&currPos);
1036 add_to_sig(result," }\n",&currPos);
1039 if(IsString(aArgVal)) {
1040 sprintf(buf," char *c_temp%d = CORBA::string_dup(temp%d);\n",i,i);
1041 add_to_sig(result,buf,&currPos);
1044 if(IsVoid(aArgVal)) {
1045 sprintf(buf," long v_temp%d;\n",i);
1046 add_to_sig(result,buf,&currPos);
1048 sprintf(buf," temp%d.operator>>=(v_temp%d);\n",i,i);
1049 add_to_sig(result,buf,&currPos);
1052 add_to_sig(result," ",&currPos);
1054 if(IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal)) {
1055 add_to_sig(result,"CORBA::ULong i_ret;\n",&currPos);
1056 add_to_sig(result," PARAVIS::",&currPos);
1057 AddTypeArray(aRetVal,result,&currPos);
1058 add_to_sig(result,"_var s_ret = new ",&currPos);
1059 AddTypeArray(aRetVal,result,&currPos);
1060 add_to_sig(result,"();\n",&currPos);
1061 sprintf(buf," s_ret->length(%d);\n",currentFunction->HintSize);
1062 add_to_sig(result,buf,&currPos);
1063 add_to_sig(result," ",&currPos);
1066 if(IsArray(aRetVal) && IsUnsigned(aRetVal)) {
1067 add_to_sig(result,"unsigned ",&currPos);
1070 if(IsFloat(aRetVal)) {
1071 if(IsArray(aRetVal)) {
1072 add_to_sig(result,"float* a_ret = ",&currPos);
1074 add_to_sig(result,"CORBA::Float ret = ",&currPos);
1078 if(IsDouble(aRetVal)) {
1079 if(IsArray(aRetVal)) {
1080 add_to_sig(result,"double* a_ret = ",&currPos);
1082 add_to_sig(result,"CORBA::Double ret = ",&currPos);
1086 if(IsShortInt(aRetVal)) {
1087 if(IsArray(aRetVal)) {
1088 if(IsvtkIdType(aRetVal)) {
1089 add_to_sig(result,"vtkIdType",&currPos);
1091 if(IsShort(aRetVal)) {
1092 add_to_sig(result,"short",&currPos);
1094 add_to_sig(result,"int",&currPos);
1097 add_to_sig(result,"* a_ret = ",&currPos);
1099 add_to_sig(result,"CORBA::Short ret = ",&currPos);
1103 if(IsLong(aRetVal)) {
1104 if(IsArray(aRetVal)) {
1105 add_to_sig(result,"long* a_ret = ",&currPos);
1107 add_to_sig(result,"CORBA::Long ret = ",&currPos);
1111 //if(IsChar(aRetVal)) {
1112 if(IsString(aRetVal)) {
1113 add_to_sig(result,"char * ret = CORBA::string_dup(\"\");\n",&currPos);
1114 add_to_sig(result," const char * cret = ",&currPos);
1115 } else if (IsChar(aRetVal)) { //!!! vsv
1116 add_to_sig(result,"CORBA::Char ret = ",&currPos);
1120 if(IsBoolean(aRetVal)) {
1121 add_to_sig(result,"CORBA::Boolean ret = ",&currPos);
1124 if(IsVoidPtr(aRetVal)) {
1125 add_to_sig(result,"void * v_ret = ",&currPos);
1128 if(IsClass(aRetVal)) {
1129 add_to_sig(result,"::",&currPos);
1130 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1131 add_to_sig(result,"* a",&currPos);
1132 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1133 add_to_sig(result," = ",&currPos);
1135 if(IsVoid(aRetVal)) {
1136 add_to_sig(result,"if(getVTKObject() != NULL) ProcessVoidEvent",&currPos);
1138 add_to_sig(result,"(getVTKObject() != NULL) ? ProcessEvent",&currPos);
1140 add_to_sig(result,"(\n",&currPos);
1141 add_to_sig(result," new CreateEventName(",&currPos);
1142 add_to_sig(result,currentFunction->Name,&currPos);
1143 if( strlen(num)!=0 ) {
1144 add_to_sig(result,num,&currPos);
1146 add_to_sig(result,")",&currPos);
1148 add_to_sig(result,"((::",&currPos);
1149 add_to_sig(result,data->Name,&currPos);
1150 add_to_sig(result,"*)",&currPos);
1151 add_to_sig(result,"getVTKObject()\n",&currPos);
1153 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
1154 aArgVal = currentFunction->Parameters[i];
1155 add_to_sig(result," , ",&currPos);
1157 //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1158 //add_to_sig(result,"*(",&currPos);
1161 if(IsClass(aArgVal)) {
1162 //sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,currentFunction->ArgClasses[i],i);
1163 sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,aArgVal->Class,i);
1165 if(IsArray(aArgVal) && !IsString(aArgVal) && !IsVoid(aArgVal)) {
1166 sprintf(buf,"a_temp%d",i);
1168 if(IsVoidPtr(aArgVal)) {
1169 sprintf(buf,"(void*)v_temp%d",i);
1171 if(IsString(aArgVal)) {
1172 sprintf(buf,"c_temp%d",i);
1174 sprintf(buf,"temp%d",i);
1180 add_to_sig(result,buf,&currPos);
1181 //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1182 //add_to_sig(result,")",&currPos);
1184 add_to_sig(result,"\n",&currPos);
1187 add_to_sig(result," )\n",&currPos);
1188 add_to_sig(result," )",&currPos);
1189 if(!IsVoid(aRetVal)) {
1190 add_to_sig(result,":",&currPos);
1191 if(IsClass(aRetVal) || IsString(aRetVal) || IsPtr(aRetVal) || IsArray(aRetVal))
1192 add_to_sig(result,"NULL",&currPos);
1194 add_to_sig(result,"0",&currPos);
1196 add_to_sig(result,";\n",&currPos);
1197 if(IsString(aRetVal)) {
1198 add_to_sig(result," if(cret!=NULL) ret=CORBA::string_dup(cret);\n",&currPos);
1201 if(IsClass(aRetVal)) {
1202 add_to_sig(result," if(a",&currPos);
1203 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1204 add_to_sig(result," == NULL) {\n",&currPos);
1205 add_to_sig(result," return PARAVIS::",&currPos);
1206 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1207 add_to_sig(result,"::_nil();\n",&currPos);
1208 add_to_sig(result," }\n",&currPos);
1209 add_to_sig(result," ",&currPos);
1210 add_to_sig(result,"PARAVIS_Base_i* aPtr = ::CreateInstance(a",&currPos);
1211 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1212 add_to_sig(result,", a",&currPos);
1213 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1214 add_to_sig(result,"->GetClassName());\n",&currPos);
1215 add_to_sig(result," aPtr->Init(a",&currPos);
1216 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1217 add_to_sig(result,");\n",&currPos);
1220 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
1221 aArgVal = currentFunction->Parameters[i];
1222 if(IsArray(aArgVal) && !IsVoid(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal)) {
1223 if (!IsIn(aArgVal)) {
1224 sprintf(buf," for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
1225 add_to_sig(result,buf,&currPos);
1227 sprintf(buf," temp%d[j_temp%d]=a_temp%d[j_temp%d];\n",i,i,i,i);
1228 add_to_sig(result,buf,&currPos);
1230 add_to_sig(result," }\n",&currPos);
1232 sprintf(buf," delete [] a_temp%d;\n",i);
1233 add_to_sig(result,buf,&currPos);
1237 if (IsVoid(aRetVal) && !IsVoidPtr(aRetVal)) {
1238 add_to_sig(result," return;\n",&currPos);
1240 if(IsClass(aRetVal)) {
1241 add_to_sig(result," return aPtr->_this();\n",&currPos);
1243 if(IsVoid(aRetVal)) {
1244 add_to_sig(result," CORBA::Any* ret = new CORBA::Any;\n",&currPos);
1245 add_to_sig(result," (*ret) <<= v_ret;\n",&currPos);
1246 add_to_sig(result," return ret;\n",&currPos);
1248 if(IsArray(aRetVal) && !IsString(aRetVal)) {
1249 sprintf(buf," for(i_ret=0; i_ret<%d; i_ret++) {\n",currentFunction->HintSize);
1250 add_to_sig(result,buf,&currPos);
1251 add_to_sig(result," s_ret[i_ret]=a_ret[i_ret];\n",&currPos);
1252 add_to_sig(result," }\n",&currPos);
1253 add_to_sig(result," return s_ret._retn();\n",&currPos);
1255 add_to_sig(result," return ret;\n",&currPos);
1261 add_to_sig(result," } catch(...) {\n",&currPos);
1262 add_to_sig(result," MESSAGE(\"",&currPos);
1263 //add_to_sig(result,data->ClassName,&currPos);
1264 //add_to_sig(result,"::",&currPos);
1265 add_to_sig(result,currentFunction->Name,&currPos);
1266 add_to_sig(result," - Unknown exception was occured!!!\");\n",&currPos);
1268 if (IsVoid(aRetVal)&& !IsVoidPtr(aRetVal)) {
1269 add_to_sig(result," return;\n",&currPos);
1271 if(IsString(aRetVal)) {
1272 add_to_sig(result," return CORBA::string_dup(\"\");\n",&currPos);
1274 if(IsClass(aRetVal)) {
1275 add_to_sig(result," return PARAVIS::",&currPos);
1276 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1277 add_to_sig(result,"::_nil();\n",&currPos);
1279 if(IsArray(aRetVal) && !IsVoid(aRetVal)) {
1280 add_to_sig(result," PARAVIS::",&currPos);
1281 AddTypeArray(aRetVal,result,&currPos);
1282 add_to_sig(result,"_var s_ret = new ",&currPos);
1283 AddTypeArray(aRetVal,result,&currPos);
1284 add_to_sig(result,"();\n",&currPos);
1285 sprintf(buf," s_ret->length(%d);\n",currentFunction->HintSize);
1286 add_to_sig(result,buf,&currPos);
1287 add_to_sig(result," return s_ret._retn();\n",&currPos);
1289 add_to_sig(result," return 0;\n",&currPos);
1295 add_to_sig(result," }\n",&currPos);
1296 add_to_sig(result,"}\n",&currPos);
1298 add_to_sig(result,";\n",&currPos);
1303 result[currPos_sig]='\0';
1304 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1305 (size_t)(currPos_sig+1));*/
1306 cp = (char *)malloc(currPos_sig+1);
1308 currentFunction->Signature = cp;
1309 //strcpy((char*)currentFunction->Signature,result);
1314 //if(strcmp(currentFunction->Name,"NewInstance") == 0) {
1315 //currentFunction->Signature[0]='\0';
1319 for(i = 0; i < numberOfReadFunctions; i++) {
1320 if(strcmp(readFunctions[i].Name,currentFunction->Name) == 0) {
1321 j=readFunctions[i].EndPos-readFunctions[i].NumPos;
1322 strncpy(buf,result+currPos_num,j);
1323 strncpy(buf1,readFunctions[i].Signature+readFunctions[i].NumPos,j);
1326 if(strcmp(buf,buf1) == 0) {
1327 //((char*)currentFunction->Signature)[0]='\0';
1328 currentFunction->Signature = EmptyString;
1333 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1334 (size_t)(currPos+1));*/
1335 //strcpy((char*)currentFunction->Signature, result);
1336 cp = (char *)malloc(currPos+1);
1338 currentFunction->Signature = cp;
1341 void outputFunction2(FILE *fp, ClassInfo *data)
1343 int i, j, k, is_vtkobject, fnum, backnum;//, is_static, occ, goto_used;
1345 FunctionInfo *theFunc;
1346 FunctionInfo *backFunc;
1347 const char *theName;
1348 unsigned int theType;
1349 const char *backName;
1352 //int isSMObject = 0;
1354 ValueInfo* aArgVal = 0;
1355 ValueInfo* aBackArgVal = 0;
1358 #if defined(IDL_I_HH)
1359 fprintf(fp,"#include \"SALOMEconfig.h\"\n");
1360 fprintf(fp,"#include CORBA_SERVER_HEADER(PARAVIS_Gen_%s)\n",data->Name);
1362 fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1363 fprintf(fp,"#include \"PARAVIS_Gen_i.hh\"\n");
1364 fprintf(fp,"#include \"PARAVIS_Gen_Types.hh\"\n");
1365 fprintf(fp,"#include \"vtkSmartPointer.h\"\n");
1366 fprintf(fp,"#include \"SALOME_Event.h\"\n");
1368 for(i=0;i<data->NumberOfSuperClasses;i++)
1370 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->SuperClasses[i]);
1373 fprintf(fp,"\nclass %s;\n",data->Name);
1374 fprintf(fp,"\nnamespace PARAVIS\n{\n\n");
1375 #elif defined(IDL_I_CC)
1376 fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1377 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->Name);
1378 fprintf(fp,"#include \"PV_Tools.h\"\n");
1379 fprintf(fp,"#include \"SALOME_Event.h\"\n");
1380 fprintf(fp,"#include <%s.h>\n",data->Name);
1382 fprintf(fp,"#include \"PARAVIS_Gen.idl\"\n");
1383 fprintf(fp,"#include \"PARAVIS_Gen_Types.idl\"\n");
1385 for(i=0;i<data->NumberOfSuperClasses;i++)
1387 fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",data->SuperClasses[i]);
1390 fprintf(fp,"\nmodule PARAVIS\n{\n\n");
1393 is_vtkobject = ((strcmp(data->Name,"vtkObjectBase") == 0) ||
1394 (data->NumberOfSuperClasses != 0));
1396 for(i = 0; i < data->NumberOfSuperClasses; i++) {
1397 read_class_functions(data->SuperClasses[i],data->Name,fp);
1400 /* create a idl signature for each method */
1401 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1403 theFunc = wrappedFunctions[fnum];
1404 currentFunction = theFunc;
1405 //printf("#### %i)Function %s\n", fnum, theFunc->Name);
1407 /* names of idl methods should be unique */
1410 for (i = 0; i < numberOfReadFunctions; i++) {
1411 if(strcmp(currentFunction->Name,readFunctions[i].Name) == 0)
1414 for (i = 0; i < fnum; i++)
1416 if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) == 0 )
1421 for (i = fnum+1; i < numberOfWrappedFunctions; i++) {
1422 if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) == 0 ) {
1433 sprintf(num,"_%d",j);
1435 get_signature(num,data);
1437 /* create external type declarations for all object
1439 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1441 theFunc = wrappedFunctions[fnum];
1442 currentFunction = theFunc;
1446 for (i = vtkWrap_CountWrappedParameters(theFunc); i >= 0; i--)
1448 if (i==0)/* return type */
1450 aArgVal = theFunc->ReturnValue;
1451 //theType = theFunc->ReturnType;
1452 //theName = (char*)theFunc->ReturnClass;
1456 aArgVal = theFunc->Parameters[i-1];
1457 //theType = theFunc->ArgTypes[i-1];
1458 //theName = (char*)theFunc->ArgClasses[i-1];
1460 theType = aArgVal->Type & VTK_PARSE_BASE_TYPE;
1461 theName = aArgVal->Class;
1462 /* check for object types */
1463 /*if ((theType & VTK_PARSE_BASE_TYPE == 0x309)||
1464 (theType & VTK_PARSE_BASE_TYPE == 0x109))*/
1465 if ((theType == VTK_PARSE_OBJECT) || (theType == VTK_PARSE_OBJECT_REF))
1467 /* check that we haven't done this type (no duplicate declarations) */
1468 for (backnum = fnum; backnum >= 0; backnum--)
1470 backFunc = wrappedFunctions[backnum];
1473 if (backnum == fnum)
1477 for (j = vtkWrap_CountWrappedParameters(backFunc); j >= k; j--)
1479 if (j==0) /* return type */
1481 aBackArgVal = backFunc->ReturnValue;
1482 //backType = backFunc->ReturnType;
1483 //backName = (char*)backFunc->ReturnClass;
1487 aBackArgVal = backFunc->Parameters[j-1];
1488 //backType = backFunc->ArgTypes[j-1];
1489 //backName = (char*)backFunc->ArgClasses[j-1];
1491 backType = aBackArgVal->Type & VTK_PARSE_BASE_TYPE;
1492 backName = aBackArgVal->Class;
1493 /*if (((backType % VTK_PARSE_BASE_TYPE == 0x309)||
1494 (backType % VTK_PARSE_BASE_TYPE == 0x109)))*/
1495 if ((backType == VTK_PARSE_OBJECT) || (backType == VTK_PARSE_OBJECT_REF))
1497 if(strcmp(theName,backName) == 0)
1508 if (backnum < 0 && strcmp(data->Name,theName) != 0)
1511 for(j = 0; strcmp(wrapped_classes[j],"") != 0 && found == 0; j++)
1513 if(strcmp(wrapped_classes[j],theName) == 0)
1518 #if defined(IDL_I_HH)
1519 fprintf(fp," class %s_i;\n",theName);
1520 #elif defined(IDL_I_CC)
1521 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",theName);
1522 fprintf(fp,"#include <%s.h>\n",theName);
1524 //fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",theName);
1525 fprintf(fp," interface %s;\n",theName);
1533 //fprintf(fp,"\nmodule PARAVIS\n{\n");
1534 #if defined(IDL_I_HH)
1535 fprintf(fp,"\n class %s_i : public virtual POA_PARAVIS::%s, public virtual PARAVIS::PARAVIS_Base_i",data->Name,data->Name);
1536 //for(i = 0; i < data->NumberOfSuperClasses; i++) {
1537 // fprintf(fp,", public virtual %s_i",data->SuperClasses[i]);
1539 //fprintf(fp,", public virtual SALOME::GenericObj_i");
1541 fprintf(fp,"\n public:\n");
1542 fprintf(fp,"\n %s_i();\n",data->Name);
1543 if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1544 fprintf(fp,"\n ::vtkObjectBase* GetNew();\n");
1547 #elif defined(IDL_I_CC)
1548 fprintf(fp,"extern PARAVIS::PARAVIS_Base_i* CreateInstance(::vtkObjectBase* Inst, const QString&);\n");
1549 fprintf(fp,"\nnamespace PARAVIS\n{\n");
1550 fprintf(fp,"typedef %s_i current_interface;\n",data->Name);
1551 fprintf(fp,"#define CreateEventName(Function) Event%s ##Function\n",data->Name);
1552 fprintf(fp,"%s_i::%s_i() {\n",data->Name,data->Name);
1553 //fprintf(fp," Init(::%s::New());\n",data->Name);
1557 if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1558 fprintf(fp,"::vtkObjectBase* %s_i::GetNew() {\n", data->Name);
1559 if(strcmp(data->Name,"vtkSMProxyManager") == 0) {
1560 fprintf(fp," return ::%s::GetProxyManager();\n",data->Name);
1562 fprintf(fp," return ::%s::New();\n",data->Name);
1567 fprintf(fp,"\n interface %s : PARAVIS_Base",data->Name);
1568 fprintf(fp,"\n {\n");
1571 for(i = 0; i < numberOfReadFunctions; i++) {
1572 fprintf(fp, "%s\n", readFunctions[i].Signature);
1575 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++) {
1576 fprintf(fp,"%s\n",wrappedFunctions[fnum]->Signature);
1579 #if defined(IDL_I_HH)
1580 fprintf(fp," };\n");
1582 #elif defined(IDL_I_CC)
1585 fprintf(fp," };\n");
1592 void outputFunction(FILE *fp, ClassInfo *data)
1596 ValueInfo* aRetVal = NULL;//currentFunction->ReturnValue;
1597 ValueInfo* aArgVal = NULL;
1599 unsigned int argtype;
1602 /* some functions will not get wrapped no matter what else,
1603 and some really common functions will appear only in vtkObjectPython */
1604 if (currentFunction->IsOperator ||
1605 currentFunction->ArrayFailure ||
1606 !currentFunction->IsPublic ||
1607 !currentFunction->Name)
1611 //printf("#### Check %s\n", currentFunction->Name);
1613 /* check to see if we can handle the args */
1614 for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++)
1616 aArgVal = currentFunction->Parameters[i];
1617 /*printf(" Argument: %s ", vtkWrap_GetTypeName(aArgVal));
1618 if (vtkWrap_IsArray(aArgVal)) {
1619 printf("!!!! Argument %i is array\n", i);
1622 if (vtkWrap_IsStream(aArgVal)) {
1623 //printf("!!!! Argument %i is stream\n", i);
1626 if (IsPtr(aArgVal)) {
1627 //printf("!!!! Argument %i is pointer value\n", i);
1630 if (IsUnknown(aArgVal)) {
1631 //printf("!!!! Argument %i is unknown value\n", i);
1634 if (vtkWrap_IsVoidPointer(aArgVal)) {
1635 //printf("!!!! Argument %i is void pointer\n", i);
1638 if (vtkWrap_IsVoidFunction(aArgVal)) {
1639 //printf("!!!! Argument %i is void function\n", i);
1642 argtype = (aArgVal->Type & VTK_PARSE_INDIRECT);
1643 if (argtype == VTK_PARSE_POINTER_POINTER){
1644 //printf("!!!! Argument %i is pointer to pointer\n", i);
1647 if (vtkWrap_IsNonConstRef(aArgVal)) {
1648 //printf("!!!! Argument %i is non const ref\n", i);
1651 if (vtkWrap_IsSpecialObject(aArgVal)) {
1652 //printf("!!!! Argument %i is special object\n", i);
1655 /*if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 9) args_ok = 0;
1656 if ((currentFunction->ArgTypes[i] % 0x10) == 8) args_ok = 0;
1657 if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1658 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x109)&&
1659 ((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1660 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1661 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1662 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1663 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1664 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1665 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1666 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;*/
1668 aRetVal = currentFunction->ReturnValue;
1670 //printf("#### Return type: %s\n", vtkWrap_GetTypeName(aRetVal));
1671 aType = aRetVal->Type & VTK_PARSE_BASE_TYPE;
1672 if (IsPtr(aRetVal)) {
1673 //printf("!!!! Return Value is pointer\n");
1676 /* eliminate unsigned char * and unsigned short * */
1677 argtype = (aRetVal->Type & VTK_PARSE_UNQUALIFIED_TYPE);
1678 if ((argtype == VTK_PARSE_UNSIGNED_CHAR_PTR) || (argtype == VTK_PARSE_UNSIGNED_SHORT)) {
1679 //printf("!!!! Return Value is unsigned char or short\n");
1683 if ((aType == VTK_PARSE_UNKNOWN)) {
1684 //printf("!!!! Return Value is unknown\n");
1687 argtype = (aRetVal->Type & VTK_PARSE_INDIRECT);
1688 if (argtype == VTK_PARSE_POINTER_POINTER){
1689 //printf("!!!! Return value is pointer to pointer\n", i);
1692 if (vtkWrap_IsSpecialObject(aRetVal)) {
1693 //printf("!!!! Return is special object\n", i);
1697 /*if ((aRetVal % 0x10) == 0x8) args_ok = 0;
1698 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x9) args_ok = 0;
1699 if (((aRetVal % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1700 (aRetVal % VTK_PARSE_BASE_TYPE != 0x109)&&
1701 ((aRetVal % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1704 /*if (aRetVal % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1705 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1706 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1707 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1708 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1709 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1710 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;
1713 if (vtkWrap_CountWrappedParameters(currentFunction) &&
1714 (currentFunction->ArgTypes[0] == 0x5000)
1715 &&(vtkWrap_CountWrappedParameters(currentFunction) != 0x1)) args_ok = 0;*/
1717 /* make sure we have all the info we need for array arguments in */
1718 /*for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++)
1720 if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 == 0x3)&&
1721 (currentFunction->ArgCounts[i] <= 0)&&
1722 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x309)&&
1723 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x303)&&
1724 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x302)) args_ok = 0;
1727 /* if we need a return type hint make sure we have one */
1728 //switch (aRetVal % VTK_PARSE_BASE_TYPE)
1729 /*switch (aRetVal->Type % VTK_PARSE_BASE_TYPE)
1731 case 0x301: case 0x307: case 0x30A: case 0x30B: case 0x30C: case 0x30D: case 0x30E:
1732 case 0x304: case 0x305: case 0x306:
1733 args_ok = currentFunction->HaveHint;
1737 /* make sure it isn't a Delete or New function */
1738 if (!strcmp("Delete",currentFunction->Name) ||
1739 !strcmp("New",currentFunction->Name))
1744 if (vtkWrap_IsDestructor(data, currentFunction) || vtkWrap_IsConstructor(data, currentFunction)) {
1745 //printf("!!!! Return Value is constructor or destructor\n");
1749 /* check for New() function */
1750 if (!strcmp("New",currentFunction->Name) && vtkWrap_CountWrappedParameters(currentFunction) == 0)
1755 if (currentFunction->IsPublic && //args_ok &&
1756 strcmp(data->Name,currentFunction->Name) &&
1757 strcmp(data->Name, currentFunction->Name + 1))
1759 //printf("#### %i Function %s\n", numberOfWrappedFunctions, currentFunction->Name);
1760 wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
1761 numberOfWrappedFunctions++;
1767 /* print the parsed structures */
1768 int main(int argc, char *argv[])
1770 OptionInfo *options;
1771 FileInfo *file_info;
1776 /* get command-line args and parse the header file */
1777 file_info = vtkParse_Main(argc, argv);
1779 /* get the command-line options */
1780 options = vtkParse_GetCommandLineOptions();
1782 /* get the output file */
1783 fp = fopen(options->OutputFileName, "w");
1787 fprintf(stderr, "Error opening output file %s\n", options->OutputFileName);
1791 /* get the main class */
1792 if ((data = file_info->MainClass) == NULL)
1798 /* get the hierarchy info for accurate typing */
1799 if (options->HierarchyFileName)
1801 hierarchyInfo = vtkParseHierarchy_ReadFile(options->HierarchyFileName);
1804 #if defined(IDL_I_HH)
1805 fprintf(fp, "// idl wrapper interface for %s object implementation\n//\n", data->Name);
1806 #elif defined(IDL_I_CC)
1807 fprintf(fp, "// idl wrapper implementation for %s object\n//\n", data->Name);
1809 fprintf(fp, "// idl wrapper for %s object\n//\n", data->Name);
1813 if(strlen(Copyright[i]) != 0)
1815 fprintf(fp,"%s\n",Copyright[i]);
1823 #if defined(IDL_I_HH)
1824 fprintf(fp,"#ifndef PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1825 fprintf(fp,"#define PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1827 #elif defined(IDL_I_CC)
1829 fprintf(fp,"#ifndef __PARAVIS_Gen_%s__\n",data->Name);
1830 fprintf(fp,"#define __PARAVIS_Gen_%s__\n",data->Name);
1834 /* insert function handling code here */
1835 for (i = 0; i < data->NumberOfFunctions; i++)
1837 currentFunction = data->Functions[i];
1838 #ifdef VTK_LEGACY_REMOVE
1839 if(currentFunction->IsLegacy)
1842 outputFunction(fp, data);
1844 //printf("#### NbFunctions %i\n", numberOfWrappedFunctions);
1845 //if (data->NumberOfSuperClasses || (!data->IsAbstract))
1846 //if (numberOfWrappedFunctions)
1848 outputFunction2(fp, data);
1851 #if defined(IDL_I_HH)
1852 fprintf(fp,"\n#endif\n");
1853 #elif defined(IDL_I_CC)
1855 fprintf(fp,"\n#endif\n");
1858 vtkParse_Free(file_info);