1 // PARAVIS : ParaView wrapper SALOME module
3 // Copyright (C) 2010-2012 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
29 #include "vtkParseType.h"
30 #include "vtkWrapIDL.h"
34 "// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,",
35 "// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS",
37 "// This library is free software; you can redistribute it and/or",
38 "// modify it under the terms of the GNU Lesser General Public",
39 "// License as published by the Free Software Foundation; either",
40 "// version 2.1 of the License.",
42 "// This library is distributed in the hope that it will be useful,",
43 "// but WITHOUT ANY WARRANTY; without even the implied warranty of",
44 "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU",
45 "// Lesser General Public License for more details.",
47 "// You should have received a copy of the GNU Lesser General Public",
48 "// License along with this library; if not, write to the Free Software",
49 "// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA",
51 "// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com",
57 int numberOfWrappedFunctions = 0;
58 FunctionInfo *wrappedFunctions[1000];
59 extern FunctionInfo *currentFunction;
62 static void add_to_sig(char *sig, const char *add, int *i)
65 *i += (int)strlen(add);
68 int IsReturnArg(int I) {
69 return (I == MAX_ARGS);
72 void AddReturnArg(char *Result, int *CurrPos) {
73 add_to_sig(Result,"virtual ",CurrPos);
76 int IsIn(ValueInfo* Type) {
78 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 < 1 || (Type % VTK_PARSE_BASE_TYPE)/0x100 > 7);
81 void AddNotReturnArg(ValueInfo* Type, char *Result, int *CurrPos) {
82 #if defined(IDL_I_HH) || defined(IDL_I_CC)
86 add_to_sig(Result,"in ",CurrPos);
88 add_to_sig(Result,"inout ",CurrPos);
92 int IsFunction(ValueInfo* Type) {
93 //return (Type == VTK_PARSE_FUNCTION);
94 return vtkWrap_IsFunction(Type);
97 int IsConst(ValueInfo* Type) {
98 //return ((Type % 0x2000) >= 0x1000);
99 return vtkWrap_IsConst(Type);
102 void AddConst(char *Result, int *CurrPos) {
103 #if defined(IDL_I_HH) || defined(IDL_I_CC)
104 add_to_sig(Result,"const ",CurrPos);
106 add_to_sig(Result,"in ",CurrPos);
111 int IsClass(ValueInfo* theType) {
112 //return ((theType->Type % 0x10) == 0x9);
113 return vtkWrap_IsObject(theType) || vtkWrap_IsVTKObject(theType);
116 int IsString(ValueInfo* Type) {
117 //return (IsChar(Type) && IsArray(Type));
118 //return (IsChar(Type) && IsPtr(Type));
119 return vtkWrap_IsCharPointer(Type) || vtkWrap_IsString(Type) || (strcmp(Type->Class, "vtkStdString") == 0);
122 int IsPtr(ValueInfo* Type) {
123 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x1);
124 return vtkWrap_IsPointer(Type) && (!IsString(Type)) && (!IsClass(Type));
127 int IsUnknown(ValueInfo* theType) {
128 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x8);
129 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_UNKNOWN;
132 void AddAtomArg(int I, ValueInfo* Type, char *TypeIDL, char *TypeCorba, char *Result, int *CurrPos) {
133 #if defined(IDL_I_HH) || defined(IDL_I_CC)
134 add_to_sig(Result,"CORBA::",CurrPos);
135 add_to_sig(Result,TypeCorba,CurrPos);
137 if (!IsReturnArg(I) && !IsConst(Type) && !IsIn(Type))
138 add_to_sig(Result,"&",CurrPos);
140 add_to_sig(Result,TypeIDL,CurrPos);
142 add_to_sig(Result," ",CurrPos);
145 int IsArray(ValueInfo* Type) {
146 //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x3);
147 return vtkWrap_IsArray(Type);
150 void AddArrayArg(int I, ValueInfo* Type, char *TypeIDL, char *Result, int *CurrPos) {
151 #if defined(IDL_I_HH) || defined(IDL_I_CC)
152 if(!IsReturnArg(I) && !IsConst(Type))
153 add_to_sig(Result, "const ",CurrPos);
155 add_to_sig(Result, TypeIDL,CurrPos);
156 add_to_sig(Result, "_array",CurrPos);
157 #if defined(IDL_I_HH) || defined(IDL_I_CC)
159 add_to_sig(Result, "*",CurrPos);
161 add_to_sig(Result, "&",CurrPos);
165 add_to_sig(Result, " ",CurrPos);
168 int IsBoolean(ValueInfo* Type) {
169 //return ((Type % 0x10) == 0xE);
170 return vtkWrap_IsBool(Type);
173 void AddBooleanAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
174 AddAtomArg(I,Type,"boolean","Boolean",Result,CurrPos);
177 int IsChar(ValueInfo* theType) {
178 //return ((Type % 0x10) == 0x3 || (Type % 0x10) == 0xD);
179 int aBase = theType->Type & VTK_PARSE_BASE_TYPE;
180 return (aBase == VTK_PARSE_CHAR) || (aBase == VTK_PARSE_UNSIGNED_CHAR) || (aBase == VTK_PARSE_SIGNED_CHAR);
183 int IsCharArray(ValueInfo* theType) {
184 return (IsChar(theType) && IsArray(theType));
187 void AddCharAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
188 AddAtomArg(I,Type,"char","Char",Result,CurrPos);
191 void AddStringArg(int I, char *Result, int *CurrPos) {
192 #if defined(IDL_I_HH) || defined(IDL_I_CC)
193 add_to_sig(Result,"char ",CurrPos);
195 add_to_sig(Result,"string ",CurrPos);
199 int IsFloat(ValueInfo* theType) {
200 //return ((Type % 0x10) == 0x1);
201 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FLOAT;
204 void AddFloatAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
205 AddAtomArg(I,Type,"float","Float",Result,CurrPos);
208 int IsFloatArray(ValueInfo* theType) {
209 return (IsFloat(theType) && IsArray(theType));
212 void AddFloatArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
213 AddArrayArg(I,Type,"float",Result,CurrPos);
216 int IsDouble(ValueInfo* theType) {
217 //return ((Type % 0x10) == 0x7);
218 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_DOUBLE;
221 void AddDoubleAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
222 AddAtomArg(I,Type,"double","Double",Result,CurrPos);
225 int IsDoubleArray(ValueInfo* Type) {
226 return (IsDouble(Type) && IsArray(Type));
229 void AddDoubleArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
230 AddArrayArg(I,Type,"double",Result,CurrPos);
233 int IsvtkIdType(ValueInfo* theType) {
234 //return((Type % 0x10) == 0xA);
235 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_ID_TYPE;
238 int IsShort(ValueInfo* theType) {
239 //return ((Type % 0x10) == 0x4 || (Type % 0x10) == 0x5 || (Type % 0x10) == 0xA);
240 int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
241 return (aVal == VTK_PARSE_SHORT) || (aVal == VTK_PARSE_INT) ||
242 (aVal == VTK_PARSE_ID_TYPE) || (aVal == VTK_PARSE_UNSIGNED_INT) || (aVal == VTK_PARSE_UNSIGNED_SHORT) ||
243 (aVal == VTK_PARSE_SSIZE_T) || (aVal == VTK_PARSE_SIZE_T);
246 void AddShortAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
247 AddAtomArg(I,Type,"short","Short",Result,CurrPos);
250 int IsShortArray(ValueInfo* Type) {
251 return (IsShort(Type) && IsArray(Type));
254 void AddShortArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
255 AddArrayArg(I,Type,"short",Result,CurrPos);
258 int IsLong(ValueInfo* theType) {
259 //return ((Type % 0x10) == 0x6 || (Type % 0x10) == 0xB || (Type % 0x10) == 0xC);
260 unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
261 return (aVal == VTK_PARSE_LONG) || (aVal == VTK_PARSE_UNSIGNED_LONG) ||
262 (aVal == VTK_PARSE___INT64) || (aVal == VTK_PARSE_UNSIGNED___INT64) || (aVal == VTK_PARSE_LONG_LONG) ||
263 (aVal == VTK_PARSE_UNSIGNED_LONG_LONG);
266 void AddLongAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
267 AddAtomArg(I,Type,"long","Long",Result,CurrPos);
270 int IsLongArray(ValueInfo* Type) {
271 return (IsLong(Type) && IsArray(Type));
274 void AddLongArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
275 AddArrayArg(I,Type,"long",Result,CurrPos);
278 void AddClassArg(int I, ValueInfo* Type, const char *Class, char *Result, int *CurrPos) {
279 #if defined(IDL_I_HH) || defined(IDL_I_CC)
280 add_to_sig(Result,"PARAVIS_Base",CurrPos);
281 if(IsReturnArg(I) || IsConst(Type) || IsIn(Type)) {
282 add_to_sig(Result,"_ptr",CurrPos);
284 add_to_sig(Result,"_ptr&",CurrPos);
286 add_to_sig(Result," ",CurrPos);
288 add_to_sig(Result,"PARAVIS_Base ",CurrPos);
292 int _IsVoid(ValueInfo* theType) {
293 //return ((Type % 0x10) == 0x2);
294 return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_VOID;
297 int IsVoid(ValueInfo* Type) {
298 return (_IsVoid(Type) && (!IsPtr(Type)));
301 int IsUnsigned(ValueInfo* theType) {
302 unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
304 case VTK_PARSE_UNSIGNED_CHAR:
305 case VTK_PARSE_UNSIGNED_INT:
306 case VTK_PARSE_UNSIGNED_SHORT:
307 case VTK_PARSE_UNSIGNED_LONG:
308 case VTK_PARSE_UNSIGNED_ID_TYPE:
309 case VTK_PARSE_UNSIGNED_LONG_LONG:
310 case VTK_PARSE_UNSIGNED___INT64:
311 case VTK_PARSE_UNSIGNED_CHAR_PTR:
312 case VTK_PARSE_UNSIGNED_INT_PTR:
313 case VTK_PARSE_UNSIGNED_SHORT_PTR:
314 case VTK_PARSE_UNSIGNED_LONG_PTR:
315 case VTK_PARSE_UNSIGNED_ID_TYPE_PTR:
316 case VTK_PARSE_UNSIGNED_LONG_LONG_PTR:
317 case VTK_PARSE_UNSIGNED___INT64_PTR:
323 void AddVoid(char *Result, int *CurrPos) {
324 add_to_sig(Result,"void ",CurrPos);
327 int IsVoidPtr(ValueInfo* Type) {
328 return (_IsVoid(Type) && (IsPtr(Type) || IsArray(Type)));
331 void AddVoidArg(int I, char *Result, int *CurrPos, ValueInfo* Type) {
332 #if defined(IDL_I_HH) || defined(IDL_I_CC)
333 if(!IsReturnArg(I)) {
335 add_to_sig(Result,"const ",CurrPos);
336 add_to_sig(Result,"CORBA::Any& ",CurrPos);
338 add_to_sig(Result,"CORBA::Any ",CurrPos);
341 add_to_sig(Result,"any ",CurrPos);
345 void AddTypeArray(ValueInfo* Type, char *Result, int *CurrPos) {
347 add_to_sig(Result,"short",CurrPos);
349 add_to_sig(Result,"long",CurrPos);
351 add_to_sig(Result,"float",CurrPos);
353 add_to_sig(Result,"double",CurrPos);
355 add_to_sig(Result,"char",CurrPos);
356 add_to_sig(Result,"_array",CurrPos);
359 typedef struct _ReadFuncs
367 ReadFuncs readFunctions[1000];
368 int numberOfReadFunctions = 0;
370 static int class_has_new = 0;
372 void output_type(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
374 if (vtkWrap_IsConst(aType))
375 add_to_sig(result,"const ",currPos);
379 add_to_sig(result,"float",currPos);
381 add_to_sig(result,"CORBA::Float",currPos);
385 if(IsDouble(aType)) {
387 add_to_sig(result,"double",currPos);
389 add_to_sig(result,"CORBA::Double",currPos);
395 if (IsUnsigned(aType))
396 add_to_sig(result,"unsigned ",currPos);
397 if(IsvtkIdType(aType)) {
398 add_to_sig(result,"vtkIdType",currPos);
400 add_to_sig(result,"int",currPos);
403 add_to_sig(result,"CORBA::Short",currPos);
409 if (IsUnsigned(aType))
410 add_to_sig(result,"unsigned ",currPos);
411 add_to_sig(result,"long",currPos);
413 add_to_sig(result,"CORBA::Long",currPos);
418 if(IsString(aType)) {
420 add_to_sig(result,"const ",currPos);
421 add_to_sig(result,"char",currPos);
423 add_to_sig(result,"CORBA::Char",currPos);
427 if(IsBoolean(aType)) {
428 add_to_sig(result,"CORBA::Boolean",currPos);
431 if(IsVoidPtr(aType)) {
432 add_to_sig(result,"void",currPos);
436 add_to_sig(result,"::",currPos);
437 add_to_sig(result,Id,currPos);
440 if(IsArray(aType) || IsPtr(aType) || IsClass(aType) || IsString(aType)) {
441 add_to_sig(result,"*",currPos);
445 void output_typedef(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
447 add_to_sig(result," typedef ",currPos);
448 output_type(result,currPos,i,aType,Id);
451 void output_temp(char* result, int *currPos, int i, ValueInfo* aType, const char *Id, int aCount)
455 /* handle VAR FUNCTIONS */
456 if (IsFunction(aType)) {
460 #if defined(IDL_I_HH)
462 AddReturnArg(result,currPos);
466 if (IsReturnArg(i) && IsVoid(aType) && !IsVoidPtr(aType)) {
467 AddVoid(result,currPos);
471 /* for const * return types prototype with const */
472 if ( IsConst(aType) || IsString(aType)) {
473 if(!IsReturnArg(i)) {
474 AddConst(result,currPos);
477 if(!IsReturnArg(i)) {
478 AddNotReturnArg(aType,result,currPos);
483 if(IsFloatArray(aType)) {
484 AddFloatArrayArg(i,aType,result,currPos);
486 AddFloatAtomArg(i,aType,result,currPos);
490 if(IsDouble(aType)) {
491 if(IsDoubleArray(aType)) {
492 AddDoubleArrayArg(i,aType,result,currPos);
494 AddDoubleAtomArg(i,aType,result,currPos);
499 if(IsShortArray(aType)) {
500 AddShortArrayArg(i,aType,result,currPos);
502 AddShortAtomArg(i,aType,result,currPos);
507 if(IsLongArray(aType)) {
508 AddLongArrayArg(i,aType,result,currPos);
510 AddLongAtomArg(i,aType,result,currPos);
515 if(IsString(aType)) {
516 AddStringArg(i,result,currPos);
518 AddCharAtomArg(i,aType,result,currPos);
520 } else if (IsString(aType)) //!!! VSV
521 AddStringArg(i,result,currPos);
523 if(IsBoolean(aType)) {
524 AddBooleanAtomArg(i,aType,result,currPos);
528 AddVoidArg(i,result,currPos,aType);
532 AddClassArg(i,aType,Id,result,currPos);
535 if(IsUnknown(aType)) {
539 if(!IsClass(aType)) {
541 add_to_sig(result," *",currPos);
543 #if defined(IDL_I_HH) || defined(IDL_I_CC)
544 if(IsString(aType) && !IsIn(aType) && !IsConst(aType) && !IsReturnArg(i)) {
545 add_to_sig(result,"*&",currPos);
547 if(IsString(aType) || (IsReturnArg(i) && IsVoidPtr(aType))) {
548 add_to_sig(result," *",currPos);
554 if(!IsReturnArg(i)) {
555 sprintf(buf,"temp%i",i);
556 add_to_sig(result,buf,currPos);
562 void read_class_functions(const char* name, const char* classname, FILE* fp)
576 #if ! defined(IDL_I_CC)
583 #if defined(IDL_I_HH)
584 sprintf(buf,"PARAVIS_Gen_%s_i.hh",name);
585 #elif defined(IDL_I_CC)
586 sprintf(buf,"PARAVIS_Gen_%s_i.cc",name);
588 sprintf(buf,"PARAVIS_Gen_%s.idl",name);
590 if (!(fin = fopen(buf,"r"))) {
591 fprintf(stderr,"Error opening input file %s\n",buf);
594 while (fgets(sig,bs-1,fin) != 0) {
595 #if defined(IDL_I_CC)
596 if(strncmp("#include \"PARAVIS_Gen_vtk",sig,25)==0) {
597 fprintf(fp, "%s",sig);
599 if(strncmp("#include <vtk",sig,13)==0) {
600 fprintf(fp, "%s",sig);
604 #if ! defined(IDL_I_CC)
605 if(strncmp(" //C++: ",sig,clen)==0) {
607 if(strncmp("//C++: ",sig,clen)==0) {
609 #if defined(IDL_I_CC)
610 while(fgets(buf,bs-1,fin) != 0) {
613 if(strlen(buf) == 3 && buf[0]=='/' && buf[1]=='/')
618 if(fgets(buf,bs-1,fin)!=NULL && strlen(buf) > 1) {
620 #if defined(IDL_I_HH)
622 readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
623 sscanf(sig+len,"%s %s %s",buf,buf1,fname);
624 if(fname[0] == '*') {
627 #elif defined(IDL_I_CC)
629 sscanf(buf1,"%s %s",buf,fname);
632 sprintf(sig+curlen,"%s ",buf);
635 if(fname[0] == '*') {
637 sprintf(sig+curlen," *");
641 sprintf(sig+curlen,"%s_i::",classname);
643 for(i = 0; i < strlen(fname)-1; i++) {
646 if(fname[i] == ':' && fname[i] == ':') {
653 sprintf(sig+curlen,"%s", buf1+j);
656 readFunctions[numberOfReadFunctions].EndPos=curlen;
657 while (fgets(sig+curlen,bs-1-curlen,fin) != 0) {
658 if(sig[curlen] == '}')
664 readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
665 sscanf(sig+len,"%s _%s",buf,fname);
669 if(flen>2 && fname[flen-2]=='_') {
672 readFunctions[numberOfReadFunctions].Name = malloc((flen+1-ret_str)*sizeof(char));
673 strncpy(readFunctions[numberOfReadFunctions].Name,fname+ret_str,flen-ret_str);
674 readFunctions[numberOfReadFunctions].Name[flen-ret_str]='\0';
676 #if defined(IDL_I_HH)
677 len+=slen+strlen(buf)+1+strlen(buf1)+2+flen+ret_str-1; //spaces+virtual+space+return+space+space+*+name
678 #elif defined(IDL_I_CC)
679 len+=2+strlen(buf)+2+strlen(classname)+2+strlen(readFunctions[numberOfReadFunctions].Name)-1; //return+space+space+name
680 if(fname[0] == '*') {
683 if(fname[flen-2]=='_') {
687 len+=slen+strlen(buf)+2+flen; //spaces+return+space+_+name
689 readFunctions[numberOfReadFunctions].NumPos=len;
690 if(fname[flen]=='_') {
691 readFunctions[numberOfReadFunctions].NumPos=len+2; //+_+num
695 readFunctions[numberOfReadFunctions].Signature = malloc((len+1)*sizeof(char));
696 strncpy(readFunctions[numberOfReadFunctions].Signature,sig,len);
697 readFunctions[numberOfReadFunctions].Signature[len]='\0';
699 numberOfReadFunctions++;
708 void get_signature(const char* num, ClassInfo *data)
710 static char result[bs];
716 static char buf1[bs];
720 ValueInfo* aRetVal = NULL;
721 ValueInfo* aArgVal = NULL;
724 aRetVal = currentFunction->ReturnValue;
726 add_to_sig(result,"\n",&currPos);
727 if (currentFunction->Signature) {
728 #if ! defined(IDL_I_CC)
729 add_to_sig(result," ",&currPos);
731 add_to_sig(result,"//C++: ",&currPos);
732 add_to_sig(result,currentFunction->Signature,&currPos);
733 add_to_sig(result,"\n",&currPos);
736 if(IsClass(aRetVal) && ret == 0) {
738 for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
739 if(strcmp(wrapped_classes[i],currentFunction->ReturnValue->Class) == 0)
746 for (j = 0; j < currentFunction->NumberOfArguments; j++) {
747 aArgVal = currentFunction->Arguments[j];
748 if(IsFunction(aArgVal))
750 if(IsClass(aArgVal) && ret == 0) {
752 for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
753 if(strcmp(wrapped_classes[i],aArgVal->Class) == 0)
761 if (IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal) && currentFunction->HintSize == 0) {
766 add_to_sig(result,"//\n",&currPos);
767 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
768 (size_t)(currPos+1));*/
769 //strcpy((char*)currentFunction->Signature,result);
770 cp = (char *)malloc(currPos+1);
772 currentFunction->Signature = cp;
776 #if defined(IDL_I_CC)
777 add_to_sig(result,"struct CreateEventName(",&currPos);
778 add_to_sig(result,currentFunction->Name,&currPos);
779 if( strlen(num)!=0 ) {
780 add_to_sig(result,num,&currPos);
782 add_to_sig(result,")",&currPos);
783 add_to_sig(result,": public SALOME_Event\n",&currPos);
784 add_to_sig(result,"{\n",&currPos);
785 if(!IsVoid(aRetVal)) {
786 //output_typedef(result,&currPos,MAX_ARGS,aRetVal, currentFunction->ReturnValue->Class);
787 add_to_sig(result," typedef ",&currPos);
788 if (vtkWrap_IsConst(aRetVal))
789 add_to_sig(result, " const ",&currPos);
790 if (vtkWrap_IsObject(aRetVal))
791 add_to_sig(result, " ::",&currPos);
792 add_to_sig(result, aRetVal->Class,&currPos);
793 if (vtkWrap_IsPointer(aRetVal) || vtkWrap_IsArray(aRetVal))
794 add_to_sig(result, "*",&currPos);
795 add_to_sig(result," TResult;\n",&currPos);
796 add_to_sig(result," TResult myResult;\n",&currPos);
799 //output_typedef(result, &currPos, 0, 0x309, data->Name); //!!??
800 add_to_sig(result," typedef ::",&currPos);
801 add_to_sig(result,data->Name,&currPos);
802 add_to_sig(result,"* TObj;\n",&currPos);
803 add_to_sig(result," TObj myObj;\n",&currPos);
805 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
806 aArgVal = currentFunction->Arguments[i];
807 //output_typedef(result, &currPos, i, currentFunction->ArgTypes[i],
808 // currentFunction->ArgClasses[i]);
809 output_typedef(result, &currPos, i, aArgVal, currentFunction->ArgClasses[i]);
810 sprintf(buf," TParam%d;\n",i);
811 add_to_sig(result,buf,&currPos);
812 sprintf(buf," TParam%d myParam%d;\n",i,i);
813 add_to_sig(result,buf,&currPos);
816 add_to_sig(result,"\n",&currPos);
817 add_to_sig(result," CreateEventName(",&currPos);
818 add_to_sig(result,currentFunction->Name,&currPos);
819 if( strlen(num)!=0 ) {
820 add_to_sig(result,num,&currPos);
822 add_to_sig(result,")",&currPos);
823 add_to_sig(result,"(TObj theObj",&currPos);
824 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
825 sprintf(buf,", TParam%d theParam%d",i,i);
826 add_to_sig(result,buf,&currPos);
828 add_to_sig(result,"):\n",&currPos);
829 add_to_sig(result," myObj(theObj)",&currPos);
830 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
831 sprintf(buf,", myParam%d(theParam%d)",i,i);
832 add_to_sig(result,buf,&currPos);
834 add_to_sig(result,"\n",&currPos);
835 add_to_sig(result," { }\n",&currPos);
836 add_to_sig(result,"\n",&currPos);
837 add_to_sig(result," virtual void Execute()\n",&currPos);
838 add_to_sig(result," {\n",&currPos);
839 add_to_sig(result," ",&currPos);
840 if(!IsVoid(aRetVal)/* && !IsString(aRetVal)*/) {
841 add_to_sig(result,"myResult = ",&currPos);
843 //if(IsString(aRetVal)) {
844 //add_to_sig(result,"const char* ret = ",&currPos);
846 add_to_sig(result,"myObj->",&currPos);
847 add_to_sig(result,currentFunction->Name,&currPos);
848 add_to_sig(result,"(",&currPos);
849 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
850 aArgVal = currentFunction->Arguments[i];
852 add_to_sig(result,", ",&currPos);
853 if(IsClass(aArgVal) && IsPtr(aArgVal)) {
854 add_to_sig(result,"*",&currPos);
856 if (IsString(aArgVal) && IsConst(aArgVal))
857 sprintf(buf,"checkNullStr(myParam%d)",i);
859 sprintf(buf,"myParam%d",i);
860 add_to_sig(result,buf,&currPos);
862 add_to_sig(result,");\n",&currPos);
863 //if(IsString(aRetVal)) {
864 //add_to_sig(result," myResult = (ret==NULL)?NULL:CORBA::string_dup(\"\");\n",&currPos);
866 add_to_sig(result," }\n",&currPos);
868 add_to_sig(result,"};\n",&currPos);
869 add_to_sig(result,"//\n",&currPos);
873 #if ! defined(IDL_I_CC)
874 add_to_sig(result," ",&currPos);
877 output_temp(result,&currPos,MAX_ARGS,aRetVal,
878 currentFunction->ReturnValue->Class,0);
880 #if defined(IDL_I_CC)
881 add_to_sig(result,data->Name,&currPos);
882 add_to_sig(result,"_i::",&currPos);
884 #if ! defined(IDL_I_HH) && ! defined(IDL_I_CC)
885 add_to_sig(result,"_",&currPos);
887 add_to_sig(result,currentFunction->Name,&currPos);
889 if( strlen(num)!=0 ) {
890 add_to_sig(result,num,&currPos);
893 add_to_sig(result," ",&currPos);
895 /* print the arg list */
896 add_to_sig(result,"(",&currPos);
898 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
899 aArgVal = currentFunction->Arguments[i];
901 add_to_sig(result,", ",&currPos);
903 /* output_temp(result, &currPos, i, currentFunction->ArgTypes[i],
904 (char*)currentFunction->ArgClasses[i],
905 currentFunction->ArgCounts[i]);*/
906 output_temp(result, &currPos, i, aArgVal, aArgVal->Class, currentFunction->NumberOfArguments);
909 add_to_sig(result,")",&currPos);
910 #if defined(IDL_I_CC)
911 add_to_sig(result," {\n",&currPos);
912 add_to_sig(result," try {\n",&currPos);
913 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
914 aArgVal = currentFunction->Arguments[i];
915 if(IsClass(aArgVal)) {
916 sprintf(buf," PARAVIS_Base_i* i_temp%d = GET_SERVANT(temp%d);\n",i,i);
917 add_to_sig(result,buf,&currPos);
920 if(IsArray(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal) && !IsVoid(aArgVal) ) {
921 sprintf(buf," CORBA::ULong j_temp%d;\n",i);
922 add_to_sig(result,buf,&currPos);
923 sprintf(buf," CORBA::ULong l_temp%d = temp%d.length();\n",i,i);
924 add_to_sig(result,buf,&currPos);
925 add_to_sig(result," ",&currPos);
928 add_to_sig(result,"float",&currPos);
930 if(IsDouble(aArgVal))
931 add_to_sig(result,"double",&currPos);
933 if(IsvtkIdType(aArgVal)) {
934 if (IsUnsigned(aArgVal))
935 add_to_sig(result,"unsigned ",&currPos);
936 add_to_sig(result,"vtkIdType",&currPos);
938 if(IsShort(aArgVal)) {
939 if (IsUnsigned(aArgVal))
940 add_to_sig(result,"unsigned ",&currPos);
941 add_to_sig(result,"int",&currPos);
945 if(IsLong(aArgVal)) {
946 if (IsUnsigned(aArgVal))
947 add_to_sig(result,"unsigned ",&currPos);
948 add_to_sig(result,"long",&currPos);
950 sprintf(buf,"* a_temp%d = new ",i);
951 add_to_sig(result,buf,&currPos);
954 add_to_sig(result,"float",&currPos);
956 if(IsDouble(aArgVal))
957 add_to_sig(result,"double",&currPos);
959 if(IsvtkIdType(aArgVal)) {
960 if (IsUnsigned(aArgVal))
961 add_to_sig(result,"unsigned ",&currPos);
962 add_to_sig(result,"vtkIdType",&currPos);
964 if(IsShort(aArgVal)) {
965 if (IsUnsigned(aArgVal))
966 add_to_sig(result,"unsigned ",&currPos);
967 add_to_sig(result,"int",&currPos);
971 if(IsLong(aArgVal)) {
972 if (IsUnsigned(aArgVal))
973 add_to_sig(result,"unsigned ",&currPos);
974 add_to_sig(result,"long",&currPos);
977 sprintf(buf,"[l_temp%d];\n",i);
978 add_to_sig(result,buf,&currPos);
980 sprintf(buf," for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
981 add_to_sig(result,buf,&currPos);
983 sprintf(buf," a_temp%d[j_temp%d]=temp%d[j_temp%d];\n",i,i,i,i);
984 add_to_sig(result,buf,&currPos);
986 add_to_sig(result," }\n",&currPos);
989 if(IsString(aArgVal)) {
990 sprintf(buf," char *c_temp%d = CORBA::string_dup(temp%d);\n",i,i);
991 add_to_sig(result,buf,&currPos);
994 if(IsVoid(aArgVal)) {
995 sprintf(buf," long v_temp%d;\n",i);
996 add_to_sig(result,buf,&currPos);
998 sprintf(buf," temp%d.operator>>=(v_temp%d);\n",i,i);
999 add_to_sig(result,buf,&currPos);
1002 add_to_sig(result," ",&currPos);
1004 if(IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal)) {
1005 add_to_sig(result,"CORBA::ULong i_ret;\n",&currPos);
1006 add_to_sig(result," PARAVIS::",&currPos);
1007 AddTypeArray(aRetVal,result,&currPos);
1008 add_to_sig(result,"_var s_ret = new ",&currPos);
1009 AddTypeArray(aRetVal,result,&currPos);
1010 add_to_sig(result,"();\n",&currPos);
1011 sprintf(buf," s_ret->length(%d);\n",currentFunction->HintSize);
1012 add_to_sig(result,buf,&currPos);
1013 add_to_sig(result," ",&currPos);
1016 if(IsFloat(aRetVal)) {
1017 if(IsArray(aRetVal)) {
1018 add_to_sig(result,"float* a_ret = ",&currPos);
1020 add_to_sig(result,"CORBA::Float ret = ",&currPos);
1024 if(IsDouble(aRetVal)) {
1025 if(IsArray(aRetVal)) {
1026 add_to_sig(result,"double* a_ret = ",&currPos);
1028 add_to_sig(result,"CORBA::Double ret = ",&currPos);
1032 if(IsShort(aRetVal)) {
1033 if(IsArray(aRetVal)) {
1034 if(IsvtkIdType(aRetVal)) {
1035 add_to_sig(result,"vtkIdType",&currPos);
1037 add_to_sig(result,"int",&currPos);
1039 add_to_sig(result,"* a_ret = ",&currPos);
1041 add_to_sig(result,"CORBA::Short ret = ",&currPos);
1045 if(IsLong(aRetVal)) {
1046 if(IsArray(aRetVal)) {
1047 add_to_sig(result,"long* a_ret = ",&currPos);
1049 add_to_sig(result,"CORBA::Long ret = ",&currPos);
1053 //if(IsChar(aRetVal)) {
1054 if(IsString(aRetVal)) {
1055 add_to_sig(result,"char * ret = CORBA::string_dup(\"\");\n",&currPos);
1056 add_to_sig(result," const char * cret = ",&currPos);
1057 } else if (IsChar(aRetVal)) { //!!! vsv
1058 add_to_sig(result,"CORBA::Char ret = ",&currPos);
1062 if(IsBoolean(aRetVal)) {
1063 add_to_sig(result,"CORBA::Boolean ret = ",&currPos);
1066 if(IsVoidPtr(aRetVal)) {
1067 add_to_sig(result,"void * v_ret = ",&currPos);
1070 if(IsClass(aRetVal)) {
1071 add_to_sig(result,"::",&currPos);
1072 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1073 add_to_sig(result,"* a",&currPos);
1074 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1075 add_to_sig(result," = ",&currPos);
1077 if(IsVoid(aRetVal)) {
1078 add_to_sig(result,"if(getVTKObject() != NULL) ProcessVoidEvent",&currPos);
1080 add_to_sig(result,"(getVTKObject() != NULL) ? ProcessEvent",&currPos);
1082 add_to_sig(result,"(\n",&currPos);
1083 add_to_sig(result," new CreateEventName(",&currPos);
1084 add_to_sig(result,currentFunction->Name,&currPos);
1085 if( strlen(num)!=0 ) {
1086 add_to_sig(result,num,&currPos);
1088 add_to_sig(result,")",&currPos);
1090 add_to_sig(result,"((::",&currPos);
1091 add_to_sig(result,data->Name,&currPos);
1092 add_to_sig(result,"*)",&currPos);
1093 add_to_sig(result,"getVTKObject()\n",&currPos);
1095 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
1096 aArgVal = currentFunction->Arguments[i];
1097 add_to_sig(result," , ",&currPos);
1099 //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1100 //add_to_sig(result,"*(",&currPos);
1103 if(IsClass(aArgVal)) {
1104 //sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,currentFunction->ArgClasses[i],i);
1105 sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,aArgVal->Class,i);
1107 if(IsArray(aArgVal) && !IsString(aArgVal) && !IsVoid(aArgVal)) {
1108 sprintf(buf,"a_temp%d",i);
1110 if(IsVoidPtr(aArgVal)) {
1111 sprintf(buf,"(void*)v_temp%d",i);
1113 if(IsString(aArgVal)) {
1114 sprintf(buf,"c_temp%d",i);
1116 sprintf(buf,"temp%d",i);
1122 add_to_sig(result,buf,&currPos);
1123 //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1124 //add_to_sig(result,")",&currPos);
1126 add_to_sig(result,"\n",&currPos);
1129 add_to_sig(result," )\n",&currPos);
1130 add_to_sig(result," )",&currPos);
1131 if(!IsVoid(aRetVal)) {
1132 add_to_sig(result,":",&currPos);
1133 if(IsClass(aRetVal) || IsString(aRetVal) || IsPtr(aRetVal) || IsArray(aRetVal))
1134 add_to_sig(result,"NULL",&currPos);
1136 add_to_sig(result,"0",&currPos);
1138 add_to_sig(result,";\n",&currPos);
1139 if(IsString(aRetVal)) {
1140 add_to_sig(result," if(cret!=NULL) ret=CORBA::string_dup(cret);\n",&currPos);
1143 if(IsClass(aRetVal)) {
1144 add_to_sig(result," if(a",&currPos);
1145 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1146 add_to_sig(result," == NULL) {\n",&currPos);
1147 add_to_sig(result," return PARAVIS::",&currPos);
1148 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1149 add_to_sig(result,"::_nil();\n",&currPos);
1150 add_to_sig(result," }\n",&currPos);
1151 add_to_sig(result," ",&currPos);
1152 add_to_sig(result,"PARAVIS_Base_i* aPtr = ::CreateInstance(a",&currPos);
1153 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1154 add_to_sig(result,", a",&currPos);
1155 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1156 add_to_sig(result,"->GetClassName());\n",&currPos);
1157 add_to_sig(result," aPtr->Init(a",&currPos);
1158 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1159 add_to_sig(result,");\n",&currPos);
1162 for (i = 0; i < currentFunction->NumberOfArguments; i++) {
1163 aArgVal = currentFunction->Arguments[i];
1164 if(IsArray(aArgVal) && !IsVoid(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal)) {
1165 if (!IsIn(aArgVal)) {
1166 sprintf(buf," for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
1167 add_to_sig(result,buf,&currPos);
1169 sprintf(buf," temp%d[j_temp%d]=a_temp%d[j_temp%d];\n",i,i,i,i);
1170 add_to_sig(result,buf,&currPos);
1172 add_to_sig(result," }\n",&currPos);
1174 sprintf(buf," delete [] a_temp%d;\n",i);
1175 add_to_sig(result,buf,&currPos);
1179 if (IsVoid(aRetVal) && !IsVoidPtr(aRetVal)) {
1180 add_to_sig(result," return;\n",&currPos);
1182 if(IsClass(aRetVal)) {
1183 add_to_sig(result," return aPtr->_this();\n",&currPos);
1185 if(IsVoid(aRetVal)) {
1186 add_to_sig(result," CORBA::Any* ret = new CORBA::Any;\n",&currPos);
1187 add_to_sig(result," (*ret) <<= v_ret;\n",&currPos);
1188 add_to_sig(result," return ret;\n",&currPos);
1190 if(IsArray(aRetVal) && !IsString(aRetVal)) {
1191 sprintf(buf," for(i_ret=0; i_ret<%d; i_ret++) {\n",currentFunction->HintSize);
1192 add_to_sig(result,buf,&currPos);
1193 add_to_sig(result," s_ret[i_ret]=a_ret[i_ret];\n",&currPos);
1194 add_to_sig(result," }\n",&currPos);
1195 add_to_sig(result," return s_ret._retn();\n",&currPos);
1197 add_to_sig(result," return ret;\n",&currPos);
1203 add_to_sig(result," } catch(...) {\n",&currPos);
1204 add_to_sig(result," MESSAGE(\"",&currPos);
1205 //add_to_sig(result,data->ClassName,&currPos);
1206 //add_to_sig(result,"::",&currPos);
1207 add_to_sig(result,currentFunction->Name,&currPos);
1208 add_to_sig(result," - Unknown exception was occured!!!\");\n",&currPos);
1210 if (IsVoid(aRetVal)&& !IsVoidPtr(aRetVal)) {
1211 add_to_sig(result," return;\n",&currPos);
1213 if(IsString(aRetVal)) {
1214 add_to_sig(result," return CORBA::string_dup(\"\");\n",&currPos);
1216 if(IsClass(aRetVal)) {
1217 add_to_sig(result," return PARAVIS::",&currPos);
1218 add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1219 add_to_sig(result,"::_nil();\n",&currPos);
1221 if(IsArray(aRetVal) && !IsVoid(aRetVal)) {
1222 add_to_sig(result," PARAVIS::",&currPos);
1223 AddTypeArray(aRetVal,result,&currPos);
1224 add_to_sig(result,"_var s_ret = new ",&currPos);
1225 AddTypeArray(aRetVal,result,&currPos);
1226 add_to_sig(result,"();\n",&currPos);
1227 sprintf(buf," s_ret->length(%d);\n",currentFunction->HintSize);
1228 add_to_sig(result,buf,&currPos);
1229 add_to_sig(result," return s_ret._retn();\n",&currPos);
1231 add_to_sig(result," return 0;\n",&currPos);
1237 add_to_sig(result," }\n",&currPos);
1238 add_to_sig(result,"}\n",&currPos);
1240 add_to_sig(result,";\n",&currPos);
1245 result[currPos_sig]='\0';
1246 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1247 (size_t)(currPos_sig+1));*/
1248 cp = (char *)malloc(currPos_sig+1);
1250 currentFunction->Signature = cp;
1251 //strcpy((char*)currentFunction->Signature,result);
1256 //if(strcmp(currentFunction->Name,"NewInstance") == 0) {
1257 //currentFunction->Signature[0]='\0';
1261 for(i = 0; i < numberOfReadFunctions; i++) {
1262 if(strcmp(readFunctions[i].Name,currentFunction->Name) == 0) {
1263 j=readFunctions[i].EndPos-readFunctions[i].NumPos;
1264 strncpy(buf,result+currPos_num,j);
1265 strncpy(buf1,readFunctions[i].Signature+readFunctions[i].NumPos,j);
1268 if(strcmp(buf,buf1) == 0) {
1269 ((char*)currentFunction->Signature)[0]='\0';
1274 /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1275 (size_t)(currPos+1));*/
1276 //strcpy((char*)currentFunction->Signature, result);
1277 cp = (char *)malloc(currPos+1);
1279 currentFunction->Signature = cp;
1282 void outputFunction2(FILE *fp, ClassInfo *data)
1284 int i, j, k, is_vtkobject, fnum, backnum;//, is_static, occ, goto_used;
1286 FunctionInfo *theFunc;
1287 FunctionInfo *backFunc;
1288 const char *theName;
1289 unsigned int theType;
1290 const char *backName;
1293 //int isSMObject = 0;
1295 ValueInfo* aArgVal = 0;
1296 ValueInfo* aBackArgVal = 0;
1299 #if defined(IDL_I_HH)
1300 fprintf(fp,"#include \"SALOMEconfig.h\"\n");
1301 fprintf(fp,"#include CORBA_SERVER_HEADER(PARAVIS_Gen_%s)\n",data->Name);
1303 fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1304 fprintf(fp,"#include \"PARAVIS_Gen_i.hh\"\n");
1305 fprintf(fp,"#include \"PARAVIS_Gen_Types.hh\"\n");
1306 fprintf(fp,"#include \"vtkSmartPointer.h\"\n");
1307 fprintf(fp,"#include \"SALOME_Event.h\"\n");
1309 for(i=0;i<data->NumberOfSuperClasses;i++)
1311 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->SuperClasses[i]);
1314 fprintf(fp,"\nclass %s;\n",data->Name);
1315 fprintf(fp,"\nnamespace PARAVIS\n{\n\n");
1316 #elif defined(IDL_I_CC)
1317 fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1318 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->Name);
1319 fprintf(fp,"#include \"PV_Tools.h\"\n");
1320 fprintf(fp,"#include \"SALOME_Event.h\"\n");
1321 fprintf(fp,"#include <%s.h>\n",data->Name);
1323 fprintf(fp,"#include \"PARAVIS_Gen.idl\"\n");
1324 fprintf(fp,"#include \"PARAVIS_Gen_Types.idl\"\n");
1326 for(i=0;i<data->NumberOfSuperClasses;i++)
1328 fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",data->SuperClasses[i]);
1331 fprintf(fp,"\nmodule PARAVIS\n{\n\n");
1334 is_vtkobject = ((strcmp(data->Name,"vtkObjectBase") == 0) ||
1335 (data->NumberOfSuperClasses != 0));
1337 for(i = 0; i < data->NumberOfSuperClasses; i++) {
1338 read_class_functions(data->SuperClasses[i],data->Name,fp);
1341 /* create a idl signature for each method */
1342 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1344 theFunc = wrappedFunctions[fnum];
1345 currentFunction = theFunc;
1346 //printf("#### %i)Function %s\n", fnum, theFunc->Name);
1348 /* names of idl methods should be unique */
1351 for (i = 0; i < numberOfReadFunctions; i++) {
1352 if(strcmp(currentFunction->Name,readFunctions[i].Name) == 0)
1355 for (i = 0; i < fnum; i++)
1357 if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) == 0 )
1362 for (i = fnum+1; i < numberOfWrappedFunctions; i++) {
1363 if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) == 0 ) {
1374 sprintf(num,"_%d",j);
1377 get_signature(num,data);
1379 /* create external type declarations for all object
1381 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1383 theFunc = wrappedFunctions[fnum];
1384 currentFunction = theFunc;
1388 for (i = theFunc->NumberOfArguments; i >= 0; i--)
1390 if (i==0)/* return type */
1392 aArgVal = theFunc->ReturnValue;
1393 //theType = theFunc->ReturnType;
1394 //theName = (char*)theFunc->ReturnClass;
1398 aArgVal = theFunc->Arguments[i-1];
1399 //theType = theFunc->ArgTypes[i-1];
1400 //theName = (char*)theFunc->ArgClasses[i-1];
1402 theType = aArgVal->Type & VTK_PARSE_BASE_TYPE;
1403 theName = aArgVal->Class;
1404 /* check for object types */
1405 /*if ((theType & VTK_PARSE_BASE_TYPE == 0x309)||
1406 (theType & VTK_PARSE_BASE_TYPE == 0x109))*/
1407 if ((theType == VTK_PARSE_OBJECT) || (theType == VTK_PARSE_OBJECT_REF))
1409 /* check that we haven't done this type (no duplicate declarations) */
1410 for (backnum = fnum; backnum >= 0; backnum--)
1412 backFunc = wrappedFunctions[backnum];
1415 if (backnum == fnum)
1419 for (j = backFunc->NumberOfArguments; j >= k; j--)
1421 if (j==0) /* return type */
1423 aBackArgVal = backFunc->ReturnValue;
1424 //backType = backFunc->ReturnType;
1425 //backName = (char*)backFunc->ReturnClass;
1429 aBackArgVal = backFunc->Arguments[j-1];
1430 //backType = backFunc->ArgTypes[j-1];
1431 //backName = (char*)backFunc->ArgClasses[j-1];
1433 backType = aBackArgVal->Type & VTK_PARSE_BASE_TYPE;
1434 backName = aBackArgVal->Class;
1435 /*if (((backType % VTK_PARSE_BASE_TYPE == 0x309)||
1436 (backType % VTK_PARSE_BASE_TYPE == 0x109)))*/
1437 if ((backType == VTK_PARSE_OBJECT) || (backType == VTK_PARSE_OBJECT_REF))
1439 if(strcmp(theName,backName) == 0)
1450 if (backnum < 0 && strcmp(data->Name,theName) != 0)
1453 for(j = 0; strcmp(wrapped_classes[j],"") != 0 && found == 0; j++)
1455 if(strcmp(wrapped_classes[j],theName) == 0)
1460 #if defined(IDL_I_HH)
1461 fprintf(fp," class %s_i;\n",theName);
1462 #elif defined(IDL_I_CC)
1463 fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",theName);
1464 fprintf(fp,"#include <%s.h>\n",theName);
1466 //fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",theName);
1467 fprintf(fp," interface %s;\n",theName);
1475 //fprintf(fp,"\nmodule PARAVIS\n{\n");
1476 #if defined(IDL_I_HH)
1477 fprintf(fp,"\n class %s_i : public virtual POA_PARAVIS::%s, public virtual PARAVIS::PARAVIS_Base_i",data->Name,data->Name);
1478 //for(i = 0; i < data->NumberOfSuperClasses; i++) {
1479 // fprintf(fp,", public virtual %s_i",data->SuperClasses[i]);
1481 //fprintf(fp,", public virtual SALOME::GenericObj_i");
1483 fprintf(fp,"\n public:\n");
1484 fprintf(fp,"\n %s_i();\n",data->Name);
1485 if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1486 fprintf(fp,"\n ::vtkObjectBase* GetNew();\n");
1489 #elif defined(IDL_I_CC)
1490 fprintf(fp,"extern PARAVIS::PARAVIS_Base_i* CreateInstance(::vtkObjectBase* Inst, const QString&);\n");
1491 fprintf(fp,"\nnamespace PARAVIS\n{\n");
1492 fprintf(fp,"typedef %s_i current_interface;\n",data->Name);
1493 fprintf(fp,"#define CreateEventName(Function) Event%s ##Function\n",data->Name);
1494 fprintf(fp,"%s_i::%s_i() {\n",data->Name,data->Name);
1495 //fprintf(fp," Init(::%s::New());\n",data->Name);
1499 if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1500 fprintf(fp,"::vtkObjectBase* %s_i::GetNew() {\n", data->Name);
1501 if(strcmp(data->Name,"vtkSMProxyManager") == 0) {
1502 fprintf(fp," return ::%s::GetProxyManager();\n",data->Name);
1504 fprintf(fp," return ::%s::New();\n",data->Name);
1509 fprintf(fp,"\n interface %s : PARAVIS_Base",data->Name);
1510 fprintf(fp,"\n {\n");
1513 for(i = 0; i < numberOfReadFunctions; i++) {
1514 fprintf(fp, "%s\n", readFunctions[i].Signature);
1517 for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++) {
1518 fprintf(fp,"%s\n",wrappedFunctions[fnum]->Signature);
1521 #if defined(IDL_I_HH)
1522 fprintf(fp," };\n");
1524 #elif defined(IDL_I_CC)
1527 fprintf(fp," };\n");
1534 void outputFunction(FILE *fp, ClassInfo *data)
1538 ValueInfo* aRetVal = NULL;//currentFunction->ReturnValue;
1539 ValueInfo* aArgVal = NULL;
1541 unsigned int argtype;
1544 /* some functions will not get wrapped no matter what else,
1545 and some really common functions will appear only in vtkObjectPython */
1546 if (currentFunction->IsOperator ||
1547 currentFunction->ArrayFailure ||
1548 !currentFunction->IsPublic ||
1549 !currentFunction->Name)
1553 //printf("#### Check %s\n", currentFunction->Name);
1555 /* check to see if we can handle the args */
1556 for (i = 0; i < currentFunction->NumberOfArguments; i++)
1558 aArgVal = currentFunction->Arguments[i];
1559 /*printf(" Argument: %s ", vtkWrap_GetTypeName(aArgVal));
1560 if (vtkWrap_IsArray(aArgVal)) {
1561 printf("!!!! Argument %i is array\n", i);
1564 if (vtkWrap_IsStream(aArgVal)) {
1565 //printf("!!!! Argument %i is stream\n", i);
1568 if (IsPtr(aArgVal)) {
1569 //printf("!!!! Argument %i is pointer value\n", i);
1572 if (IsUnknown(aArgVal)) {
1573 //printf("!!!! Argument %i is unknown value\n", i);
1576 if (vtkWrap_IsVoidPointer(aArgVal)) {
1577 //printf("!!!! Argument %i is void pointer\n", i);
1580 if (vtkWrap_IsVoidFunction(aArgVal)) {
1581 //printf("!!!! Argument %i is void function\n", i);
1584 argtype = (aArgVal->Type & VTK_PARSE_INDIRECT);
1585 if (argtype == VTK_PARSE_POINTER_POINTER){
1586 //printf("!!!! Argument %i is pointer to pointer\n", i);
1589 if (vtkWrap_IsNonConstRef(aArgVal)) {
1590 //printf("!!!! Argument %i is non const ref\n", i);
1593 if (vtkWrap_IsSpecialObject(aArgVal)) {
1594 //printf("!!!! Argument %i is special object\n", i);
1597 /*if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 9) args_ok = 0;
1598 if ((currentFunction->ArgTypes[i] % 0x10) == 8) args_ok = 0;
1599 if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1600 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x109)&&
1601 ((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1602 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1603 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1604 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1605 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1606 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1607 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1608 if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;*/
1610 aRetVal = currentFunction->ReturnValue;
1612 //printf("#### Return type: %s\n", vtkWrap_GetTypeName(aRetVal));
1613 aType = aRetVal->Type & VTK_PARSE_BASE_TYPE;
1614 if (IsPtr(aRetVal)) {
1615 //printf("!!!! Return Value is pointer\n");
1618 /* eliminate unsigned char * and unsigned short * */
1619 argtype = (aRetVal->Type & VTK_PARSE_UNQUALIFIED_TYPE);
1620 if ((argtype == VTK_PARSE_UNSIGNED_CHAR_PTR) || (argtype == VTK_PARSE_UNSIGNED_SHORT)) {
1621 //printf("!!!! Return Value is unsigned char or short\n");
1625 if ((aType == VTK_PARSE_UNKNOWN)) {
1626 //printf("!!!! Return Value is unknown\n");
1629 argtype = (aRetVal->Type & VTK_PARSE_INDIRECT);
1630 if (argtype == VTK_PARSE_POINTER_POINTER){
1631 //printf("!!!! Return value is pointer to pointer\n", i);
1634 if (vtkWrap_IsSpecialObject(aRetVal)) {
1635 //printf("!!!! Return is special object\n", i);
1639 /*if ((aRetVal % 0x10) == 0x8) args_ok = 0;
1640 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x9) args_ok = 0;
1641 if (((aRetVal % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1642 (aRetVal % VTK_PARSE_BASE_TYPE != 0x109)&&
1643 ((aRetVal % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1646 /*if (aRetVal % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1647 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1648 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1649 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1650 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1651 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1652 if (aRetVal % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;
1655 if (currentFunction->NumberOfArguments &&
1656 (currentFunction->ArgTypes[0] == 0x5000)
1657 &&(currentFunction->NumberOfArguments != 0x1)) args_ok = 0;*/
1659 /* make sure we have all the info we need for array arguments in */
1660 /*for (i = 0; i < currentFunction->NumberOfArguments; i++)
1662 if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 == 0x3)&&
1663 (currentFunction->ArgCounts[i] <= 0)&&
1664 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x309)&&
1665 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x303)&&
1666 (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x302)) args_ok = 0;
1669 /* if we need a return type hint make sure we have one */
1670 //switch (aRetVal % VTK_PARSE_BASE_TYPE)
1671 /*switch (aRetVal->Type % VTK_PARSE_BASE_TYPE)
1673 case 0x301: case 0x307: case 0x30A: case 0x30B: case 0x30C: case 0x30D: case 0x30E:
1674 case 0x304: case 0x305: case 0x306:
1675 args_ok = currentFunction->HaveHint;
1679 /* make sure it isn't a Delete or New function */
1680 if (!strcmp("Delete",currentFunction->Name) ||
1681 !strcmp("New",currentFunction->Name))
1686 if (vtkWrap_IsDestructor(data, currentFunction) || vtkWrap_IsConstructor(data, currentFunction)) {
1687 //printf("!!!! Return Value is constructor or destructor\n");
1691 /* check for New() function */
1692 if (!strcmp("New",currentFunction->Name) && currentFunction->NumberOfArguments == 0)
1697 if (currentFunction->IsPublic && //args_ok &&
1698 strcmp(data->Name,currentFunction->Name) &&
1699 strcmp(data->Name, currentFunction->Name + 1))
1701 //printf("#### %i Function %s\n", numberOfWrappedFunctions, currentFunction->Name);
1702 wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
1703 numberOfWrappedFunctions++;
1709 /* print the parsed structures */
1710 void vtkParseOutput(FILE *fp, FileInfo *file_info)
1715 /* get the main class */
1716 data = file_info->MainClass;
1718 // Do not wrap this class
1719 // if (strcmp(data->Name, "vtkVariant") == 0)
1722 #if defined(IDL_I_HH)
1723 fprintf(fp, "// idl wrapper interface for %s object implementation\n//\n", data->Name);
1724 #elif defined(IDL_I_CC)
1725 fprintf(fp, "// idl wrapper implementation for %s object\n//\n", data->Name);
1727 fprintf(fp, "// idl wrapper for %s object\n//\n", data->Name);
1731 if(strlen(Copyright[i]) != 0)
1733 fprintf(fp,"%s\n",Copyright[i]);
1741 #if defined(IDL_I_HH)
1742 fprintf(fp,"#ifndef PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1743 fprintf(fp,"#define PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1745 #elif defined(IDL_I_CC)
1747 fprintf(fp,"#ifndef __PARAVIS_Gen_%s__\n",data->Name);
1748 fprintf(fp,"#define __PARAVIS_Gen_%s__\n",data->Name);
1752 /* insert function handling code here */
1753 for (i = 0; i < data->NumberOfFunctions; i++)
1755 currentFunction = data->Functions[i];
1756 outputFunction(fp, data);
1758 //printf("#### NbFunctions %i\n", numberOfWrappedFunctions);
1759 //if (data->NumberOfSuperClasses || (!data->IsAbstract))
1760 //if (numberOfWrappedFunctions)
1762 outputFunction2(fp, data);
1765 #if defined(IDL_I_HH)
1766 fprintf(fp,"\n#endif\n");
1767 #elif defined(IDL_I_CC)
1769 fprintf(fp,"\n#endif\n");