idl/vtkWrapIDL.c

   1 // PARAVIS : ParaView wrapper SALOME module
   2 //
   3 // Copyright (C) 2010-2012  CEA/DEN, EDF R&D
   4 //
   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.
   9 //
  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.
  14 //
  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
  18 //
  19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 //
  21 // File   : vtkWrapIDL.c
  22 // Author : Vladimir TURIN
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include "vtkParse.h"
  29 #include "vtkParseType.h"
  30 #include "vtkWrapIDL.h"
  31 #include "vtkWrap.h"
  32
  33 char* Copyright[] = {
  34   "// Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,",
  35   "// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS",
  36   "//",
  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.",
  41   "//",
  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.",
  46   "//",
  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",
  50   "//",
  51   "// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com",
  52   ""
  53 };
  54
  55 #define bs 12288
  56
  57 int numberOfWrappedFunctions = 0;
  58 FunctionInfo *wrappedFunctions[1000];
  59 extern FunctionInfo *currentFunction;
  60
  61
  62 static void add_to_sig(char *sig, const char *add, int *i)
  63 {
  64   strcpy(&sig[*i],add);
  65   *i += (int)strlen(add);
  66 }
  67
  68 int IsReturnArg(int I) {
  69   return (I == MAX_ARGS);
  70 }
  71
  72 void AddReturnArg(char *Result, int *CurrPos) {
  73   add_to_sig(Result,"virtual ",CurrPos);
  74 }
  75
  76 int IsIn(ValueInfo* Type) {
  77   return 1;
  78   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 < 1 || (Type % VTK_PARSE_BASE_TYPE)/0x100 > 7);
  79 }
  80
  81 void AddNotReturnArg(ValueInfo* Type, char *Result, int *CurrPos) {
  82 #if defined(IDL_I_HH) || defined(IDL_I_CC)
  83   ;
  84 #else
  85   if(IsIn(Type))
  86     add_to_sig(Result,"in ",CurrPos);
  87   else
  88     add_to_sig(Result,"inout ",CurrPos);
  89 #endif
  90 }
  91
  92 int IsFunction(ValueInfo* Type) {
  93   //return (Type == VTK_PARSE_FUNCTION);
  94   return vtkWrap_IsFunction(Type);
  95 }
  96
  97 int IsConst(ValueInfo* Type) {
  98   //return ((Type % 0x2000) >= 0x1000);
  99   return vtkWrap_IsConst(Type);
 100 }
 101
 102 void AddConst(char *Result, int *CurrPos) {
 103 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 104   add_to_sig(Result,"const ",CurrPos);
 105 #else
 106   add_to_sig(Result,"in ",CurrPos);
 107 #endif
 108 }
 109
 110
 111 int IsClass(ValueInfo* theType) {
 112   //return ((theType->Type % 0x10) == 0x9);
 113   return vtkWrap_IsObject(theType) || vtkWrap_IsVTKObject(theType);
 114 }
 115
 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);
 120 }
 121
 122 int IsPtr(ValueInfo* Type) {
 123   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x1);
 124   return vtkWrap_IsPointer(Type) && (!IsString(Type)) && (!IsClass(Type));
 125 }
 126
 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;
 130 }
 131
 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);
 136
 137   if (!IsReturnArg(I) && !IsConst(Type) && !IsIn(Type))
 138     add_to_sig(Result,"&",CurrPos);
 139 #else
 140   add_to_sig(Result,TypeIDL,CurrPos);
 141 #endif
 142   add_to_sig(Result," ",CurrPos);
 143 }
 144
 145 int IsArray(ValueInfo* Type) {
 146   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x3);
 147   return vtkWrap_IsArray(Type);
 148 }
 149
 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);
 154 #endif
 155   add_to_sig(Result, TypeIDL,CurrPos);
 156   add_to_sig(Result, "_array",CurrPos);
 157 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 158   if(IsReturnArg(I)) {
 159     add_to_sig(Result, "*",CurrPos);
 160   } else {
 161     add_to_sig(Result, "&",CurrPos);
 162   }
 163 #else
 164 #endif
 165   add_to_sig(Result, " ",CurrPos);
 166 }
 167
 168 int IsBoolean(ValueInfo* Type) {
 169   //return ((Type % 0x10) == 0xE);
 170   return vtkWrap_IsBool(Type);
 171 }
 172
 173 void AddBooleanAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 174   AddAtomArg(I,Type,"boolean","Boolean",Result,CurrPos);
 175 }
 176
 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);
 181 }
 182
 183 int IsCharArray(ValueInfo* theType) {
 184   return (IsChar(theType) && IsArray(theType));
 185 }
 186
 187 void AddCharAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 188   AddAtomArg(I,Type,"char","Char",Result,CurrPos);
 189 }
 190
 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);
 194 #else
 195   add_to_sig(Result,"string ",CurrPos);
 196 #endif
 197 }
 198
 199 int IsFloat(ValueInfo* theType) {
 200   //return ((Type % 0x10) == 0x1);
 201   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FLOAT;
 202 }
 203
 204 void AddFloatAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 205   AddAtomArg(I,Type,"float","Float",Result,CurrPos);
 206 }
 207
 208 int IsFloatArray(ValueInfo* theType) {
 209   return (IsFloat(theType) && IsArray(theType));
 210 }
 211
 212 void AddFloatArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 213   AddArrayArg(I,Type,"float",Result,CurrPos);
 214 }
 215
 216 int IsDouble(ValueInfo* theType) {
 217   //return ((Type % 0x10) == 0x7);
 218   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_DOUBLE;
 219 }
 220
 221 void AddDoubleAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 222   AddAtomArg(I,Type,"double","Double",Result,CurrPos);
 223 }
 224
 225 int IsDoubleArray(ValueInfo*  Type) {
 226   return (IsDouble(Type) && IsArray(Type));
 227 }
 228
 229 void AddDoubleArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 230   AddArrayArg(I,Type,"double",Result,CurrPos);
 231 }
 232
 233 int IsvtkIdType(ValueInfo* theType) {
 234   //return((Type % 0x10) == 0xA);
 235   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_ID_TYPE;
 236 }
 237
 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);
 244 }
 245
 246 void AddShortAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 247   AddAtomArg(I,Type,"short","Short",Result,CurrPos);
 248 }
 249
 250 int IsShortArray(ValueInfo* Type) {
 251   return (IsShort(Type) && IsArray(Type));
 252 }
 253
 254 void AddShortArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 255   AddArrayArg(I,Type,"short",Result,CurrPos);
 256 }
 257
 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);
 264 }
 265
 266 void AddLongAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 267   AddAtomArg(I,Type,"long","Long",Result,CurrPos);
 268 }
 269
 270 int IsLongArray(ValueInfo* Type) {
 271   return (IsLong(Type) && IsArray(Type));
 272 }
 273
 274 void AddLongArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 275   AddArrayArg(I,Type,"long",Result,CurrPos);
 276 }
 277
 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);
 283   } else {
 284     add_to_sig(Result,"_ptr&",CurrPos);
 285   }
 286   add_to_sig(Result," ",CurrPos);
 287 #else
 288   add_to_sig(Result,"PARAVIS_Base ",CurrPos);
 289 #endif
 290 }
 291
 292 int _IsVoid(ValueInfo* theType) {
 293   //return ((Type % 0x10) == 0x2);
 294   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_VOID;
 295 }
 296
 297 int IsVoid(ValueInfo* Type) {
 298   return (_IsVoid(Type) && (!IsPtr(Type)));
 299 }
 300
 301 int IsUnsigned(ValueInfo* theType) {
 302   unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
 303   switch (aVal) {
 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:
 318     return 1;
 319   }
 320   return 0;
 321 }
 322
 323 void AddVoid(char *Result, int *CurrPos) {
 324   add_to_sig(Result,"void ",CurrPos);
 325 }
 326
 327 int IsVoidPtr(ValueInfo* Type) {
 328   return (_IsVoid(Type) && (IsPtr(Type) || IsArray(Type)));
 329 }
 330
 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)) {
 334     if(!IsConst(Type))
 335       add_to_sig(Result,"const ",CurrPos);
 336     add_to_sig(Result,"CORBA::Any& ",CurrPos);
 337   } else {
 338     add_to_sig(Result,"CORBA::Any ",CurrPos);
 339   }
 340 #else
 341   add_to_sig(Result,"any ",CurrPos);
 342 #endif
 343 }
 344
 345 void AddTypeArray(ValueInfo* Type, char *Result, int *CurrPos) {
 346   if(IsShort(Type))
 347     add_to_sig(Result,"short",CurrPos);
 348   if(IsLong(Type))
 349     add_to_sig(Result,"long",CurrPos);
 350   if(IsFloat(Type))
 351     add_to_sig(Result,"float",CurrPos);
 352   if(IsDouble(Type))
 353     add_to_sig(Result,"double",CurrPos);
 354   if(IsChar(Type))
 355     add_to_sig(Result,"char",CurrPos);
 356   add_to_sig(Result,"_array",CurrPos);
 357 }
 358
 359 typedef struct _ReadFuncs
 360 {
 361   char* Name;
 362   char* Signature;
 363   int   EndPos;
 364   int   NumPos;
 365 } ReadFuncs;
 366
 367 ReadFuncs readFunctions[1000];
 368 int numberOfReadFunctions = 0;
 369
 370 static int class_has_new = 0;
 371
 372 void output_type(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
 373 {
 374   if (vtkWrap_IsConst(aType))
 375     add_to_sig(result,"const ",currPos);
 376
 377   if(IsFloat(aType)) {
 378     if(IsArray(aType)) {
 379       add_to_sig(result,"float",currPos);
 380     } else {
 381       add_to_sig(result,"CORBA::Float",currPos);
 382     }
 383   }
 384
 385   if(IsDouble(aType)) {
 386     if(IsArray(aType)) {
 387       add_to_sig(result,"double",currPos);
 388     } else {
 389       add_to_sig(result,"CORBA::Double",currPos);
 390     }
 391   }
 392
 393   if(IsShort(aType)) {
 394     if(IsArray(aType)) {
 395       if (IsUnsigned(aType))
 396         add_to_sig(result,"unsigned ",currPos);
 397       if(IsvtkIdType(aType)) {
 398         add_to_sig(result,"vtkIdType",currPos);
 399       } else {
 400         add_to_sig(result,"int",currPos);
 401       }
 402     } else {
 403       add_to_sig(result,"CORBA::Short",currPos);
 404     }
 405   }
 406
 407   if(IsLong(aType)) {
 408     if(IsArray(aType)) {
 409       if (IsUnsigned(aType))
 410         add_to_sig(result,"unsigned ",currPos);
 411       add_to_sig(result,"long",currPos);
 412     } else {
 413       add_to_sig(result,"CORBA::Long",currPos);
 414     }
 415   }
 416
 417   if(IsChar(aType)) {
 418     if(IsString(aType)) {
 419       if(IsReturnArg(i))
 420         add_to_sig(result,"const ",currPos);
 421       add_to_sig(result,"char",currPos);
 422     } else {
 423       add_to_sig(result,"CORBA::Char",currPos);
 424     }
 425   }
 426
 427   if(IsBoolean(aType)) {
 428     add_to_sig(result,"CORBA::Boolean",currPos);
 429   }
 430
 431   if(IsVoidPtr(aType)) {
 432     add_to_sig(result,"void",currPos);
 433   }
 434
 435   if(IsClass(aType)) {
 436     add_to_sig(result,"::",currPos);
 437     add_to_sig(result,Id,currPos);
 438   }
 439
 440   if(IsArray(aType) || IsPtr(aType) || IsClass(aType) || IsString(aType)) {
 441     add_to_sig(result,"*",currPos);
 442   }
 443 }
 444
 445 void output_typedef(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
 446 {
 447   add_to_sig(result,"  typedef ",currPos);
 448   output_type(result,currPos,i,aType,Id);
 449 }
 450
 451 void output_temp(char* result, int *currPos, int i, ValueInfo* aType, const char *Id, int aCount)
 452 {
 453   static char buf[bs];
 454
 455   /* handle VAR FUNCTIONS */
 456   if (IsFunction(aType)) {
 457     return;
 458   }
 459
 460 #if defined(IDL_I_HH)
 461   if(IsReturnArg(i)) {
 462     AddReturnArg(result,currPos);
 463   }
 464 #endif
 465
 466   if (IsReturnArg(i) && IsVoid(aType) && !IsVoidPtr(aType)) {
 467     AddVoid(result,currPos);
 468     return;
 469   }
 470
 471   /* for const * return types prototype with const */
 472   if ( IsConst(aType) || IsString(aType)) {
 473     if(!IsReturnArg(i)) {
 474       AddConst(result,currPos);
 475     }
 476   } else {
 477     if(!IsReturnArg(i)) {
 478       AddNotReturnArg(aType,result,currPos);
 479     }
 480   }
 481
 482   if(IsFloat(aType)) {
 483     if(IsFloatArray(aType)) {
 484       AddFloatArrayArg(i,aType,result,currPos);
 485     } else {
 486       AddFloatAtomArg(i,aType,result,currPos);
 487     }
 488   }
 489
 490   if(IsDouble(aType)) {
 491     if(IsDoubleArray(aType)) {
 492       AddDoubleArrayArg(i,aType,result,currPos);
 493     } else {
 494       AddDoubleAtomArg(i,aType,result,currPos);
 495     }
 496   }
 497
 498   if(IsShort(aType)) {
 499     if(IsShortArray(aType)) {
 500       AddShortArrayArg(i,aType,result,currPos);
 501     } else {
 502       AddShortAtomArg(i,aType,result,currPos);
 503     }
 504   }
 505
 506   if(IsLong(aType)) {
 507     if(IsLongArray(aType)) {
 508       AddLongArrayArg(i,aType,result,currPos);
 509     } else {
 510       AddLongAtomArg(i,aType,result,currPos);
 511     }
 512   }
 513
 514   if(IsChar(aType)) {
 515     if(IsString(aType)) {
 516       AddStringArg(i,result,currPos);
 517     } else {
 518       AddCharAtomArg(i,aType,result,currPos);
 519     }
 520   } else if (IsString(aType)) //!!! VSV
 521     AddStringArg(i,result,currPos);
 522
 523   if(IsBoolean(aType)) {
 524     AddBooleanAtomArg(i,aType,result,currPos);
 525   }
 526
 527   if(IsVoid(aType)) {
 528     AddVoidArg(i,result,currPos,aType);
 529   }
 530
 531   if(IsClass(aType)) {
 532     AddClassArg(i,aType,Id,result,currPos);
 533   }
 534
 535   if(IsUnknown(aType)) {
 536     return;
 537   }
 538
 539   if(!IsClass(aType)) {
 540     if(IsPtr(aType)) {
 541       add_to_sig(result," *",currPos);
 542     }
 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);
 546     } else {
 547       if(IsString(aType) || (IsReturnArg(i) && IsVoidPtr(aType))) {
 548         add_to_sig(result," *",currPos);
 549       }
 550     }
 551 #endif
 552   }
 553
 554   if(!IsReturnArg(i)) {
 555     sprintf(buf,"temp%i",i);
 556     add_to_sig(result,buf,currPos);
 557   }
 558
 559   return;
 560 }
 561
 562 void read_class_functions(const char* name, const char* classname, FILE* fp)
 563 {
 564   int len=0;
 565   int curlen=0;
 566   int i, j;
 567   int flen=0;
 568   //int num=0;
 569   int ret_str=0;
 570   FILE *fin;
 571   char buf[bs];
 572   char buf1[bs];
 573   char fname[bs];
 574   static char sig[bs];
 575   static int slen=8;
 576 #if ! defined(IDL_I_CC)
 577   static int clen=15;
 578 #else
 579   static int clen=7;
 580 #endif
 581
 582
 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);
 587 #else
 588   sprintf(buf,"PARAVIS_Gen_%s.idl",name);
 589 #endif
 590   if (!(fin = fopen(buf,"r"))) {
 591     fprintf(stderr,"Error opening input file %s\n",buf);
 592     exit(1);
 593   }
 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);
 598     }
 599     if(strncmp("#include <vtk",sig,13)==0) {
 600       fprintf(fp, "%s",sig);
 601     }
 602 #endif
 603
 604 #if ! defined(IDL_I_CC)
 605     if(strncmp("        //C++: ",sig,clen)==0) {
 606 #else
 607     if(strncmp("//C++: ",sig,clen)==0) {
 608 #endif
 609 #if defined(IDL_I_CC)
 610       while(fgets(buf,bs-1,fin) != 0) {
 611         len=strlen(sig);
 612         strcpy(sig+len,buf);
 613         if(strlen(buf) == 3 && buf[0]=='/' && buf[1]=='/')
 614           break;
 615       }
 616 #endif
 617       len=strlen(sig);
 618       if(fgets(buf,bs-1,fin)!=NULL && strlen(buf) > 1) {
 619         ret_str=0;
 620 #if defined(IDL_I_HH)
 621         strcpy(sig+len,buf);
 622         readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
 623         sscanf(sig+len,"%s %s %s",buf,buf1,fname);
 624         if(fname[0] == '*') {
 625           ret_str=1;
 626         }
 627 #elif defined(IDL_I_CC)
 628         strcpy(buf1,buf);
 629         sscanf(buf1,"%s %s",buf,fname);
 630
 631         curlen=strlen(sig);
 632         sprintf(sig+curlen,"%s ",buf);
 633         j=strlen(buf)+1;
 634
 635         if(fname[0] == '*') {
 636           curlen=strlen(sig);
 637           sprintf(sig+curlen," *");
 638           j+=1;
 639         }
 640         curlen=strlen(sig);
 641         sprintf(sig+curlen,"%s_i::",classname);
 642
 643         for(i = 0; i < strlen(fname)-1; i++) {
 644           ret_str+=1;
 645           j+=1;
 646           if(fname[i] == ':' && fname[i] == ':') {
 647             ret_str+=1;
 648             j+=1;
 649             break;
 650           }
 651         }
 652         curlen=strlen(sig);
 653         sprintf(sig+curlen,"%s", buf1+j);
 654
 655         curlen=strlen(sig);
 656         readFunctions[numberOfReadFunctions].EndPos=curlen;
 657         while (fgets(sig+curlen,bs-1-curlen,fin) != 0) {
 658           if(sig[curlen] == '}')
 659             break;
 660           curlen=strlen(sig);
 661         }
 662 #else
 663         strcpy(sig+len,buf);
 664         readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
 665         sscanf(sig+len,"%s _%s",buf,fname);
 666 #endif
 667         flen=strlen(fname);
 668         if(flen>0) {
 669           if(flen>2 && fname[flen-2]=='_') {
 670             flen-=2;
 671           }
 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';
 675
 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] == '*') {
 681             len+=2;
 682           }
 683           if(fname[flen-2]=='_') {
 684             len+=2;
 685           }
 686 #else
 687           len+=slen+strlen(buf)+2+flen; //spaces+return+space+_+name
 688 #endif
 689           readFunctions[numberOfReadFunctions].NumPos=len;
 690           if(fname[flen]=='_') {
 691             readFunctions[numberOfReadFunctions].NumPos=len+2; //+_+num
 692           }
 693
 694           len=strlen(sig);
 695           readFunctions[numberOfReadFunctions].Signature = malloc((len+1)*sizeof(char));
 696           strncpy(readFunctions[numberOfReadFunctions].Signature,sig,len);
 697           readFunctions[numberOfReadFunctions].Signature[len]='\0';
 698
 699           numberOfReadFunctions++;
 700         }
 701       }
 702     }
 703   }
 704   fclose (fin);
 705   return;
 706 }
 707
 708 void get_signature(const char* num, ClassInfo *data)
 709 {
 710   static char result[bs];
 711   int currPos = 0;
 712   int currPos_sig = 0;
 713   //int argtype;
 714   int i, j;
 715   static char buf[bs];
 716   static char buf1[bs];
 717   int ret = 0;
 718   int found = 0;
 719   int currPos_num = 0;
 720   ValueInfo* aRetVal = NULL;
 721   ValueInfo* aArgVal = NULL;
 722   char *cp;
 723
 724   aRetVal = currentFunction->ReturnValue;
 725
 726   add_to_sig(result,"\n",&currPos);
 727   if (currentFunction->Signature) {
 728 #if ! defined(IDL_I_CC)
 729     add_to_sig(result,"        ",&currPos);
 730 #endif
 731     add_to_sig(result,"//C++: ",&currPos);
 732     add_to_sig(result,currentFunction->Signature,&currPos);
 733     add_to_sig(result,"\n",&currPos);
 734   }
 735
 736   if(IsClass(aRetVal) && ret == 0) {
 737     found = 0;
 738     for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
 739       if(strcmp(wrapped_classes[i],currentFunction->ReturnValue->Class) == 0)
 740         found = 1;
 741     }
 742     if(!found)
 743       ret = 1;
 744   }
 745
 746   for (j = 0; j < currentFunction->NumberOfArguments; j++) {
 747     aArgVal = currentFunction->Arguments[j];
 748     if(IsFunction(aArgVal))
 749       ret == 1;
 750     if(IsClass(aArgVal) && ret == 0) {
 751       found = 0;
 752       for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
 753         if(strcmp(wrapped_classes[i],aArgVal->Class) == 0)
 754           found = 1;
 755       }
 756       if(!found)
 757         ret = 1;
 758     }
 759   }
 760
 761   if (IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal) && currentFunction->HintSize == 0) {
 762     ret = 1;
 763   }
 764
 765   if(ret) {
 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);
 771     strcpy(cp, result);
 772     currentFunction->Signature = cp;
 773     return;
 774   }
 775
 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);
 781   }
 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);
 797   }
 798
 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);
 804
 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);
 814   }
 815
 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);
 821   }
 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);
 827   }
 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);
 833   }
 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);
 842   }
 843   //if(IsString(aRetVal)) {
 844   //add_to_sig(result,"const char* ret = ",&currPos);
 845   //}
 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];
 851     if(i!=0)
 852       add_to_sig(result,", ",&currPos);
 853     if(IsClass(aArgVal) && IsPtr(aArgVal)) {
 854       add_to_sig(result,"*",&currPos);
 855     }
 856     if (IsString(aArgVal) && IsConst(aArgVal))
 857       sprintf(buf,"checkNullStr(myParam%d)",i);
 858     else
 859       sprintf(buf,"myParam%d",i);
 860     add_to_sig(result,buf,&currPos);
 861   }
 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);
 865   //}
 866   add_to_sig(result,"  }\n",&currPos);
 867
 868   add_to_sig(result,"};\n",&currPos);
 869   add_to_sig(result,"//\n",&currPos);
 870 #endif
 871   currPos_sig=currPos;
 872
 873 #if ! defined(IDL_I_CC)
 874   add_to_sig(result,"        ",&currPos);
 875 #endif
 876
 877   output_temp(result,&currPos,MAX_ARGS,aRetVal,
 878               currentFunction->ReturnValue->Class,0);
 879
 880 #if defined(IDL_I_CC)
 881   add_to_sig(result,data->Name,&currPos);
 882   add_to_sig(result,"_i::",&currPos);
 883 #endif
 884 #if ! defined(IDL_I_HH) && ! defined(IDL_I_CC)
 885   add_to_sig(result,"_",&currPos);
 886 #endif
 887   add_to_sig(result,currentFunction->Name,&currPos);
 888
 889   if( strlen(num)!=0 ) {
 890     add_to_sig(result,num,&currPos);
 891   }
 892   currPos_num=currPos;
 893   add_to_sig(result," ",&currPos);
 894
 895   /* print the arg list */
 896   add_to_sig(result,"(",&currPos);
 897
 898   for (i = 0; i < currentFunction->NumberOfArguments; i++) {
 899     aArgVal = currentFunction->Arguments[i];
 900     if( i != 0 ) {
 901       add_to_sig(result,", ",&currPos);
 902     }
 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);
 907   }
 908
 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);
 918     }
 919
 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);
 926
 927       if(IsFloat(aArgVal))
 928         add_to_sig(result,"float",&currPos);
 929
 930       if(IsDouble(aArgVal))
 931         add_to_sig(result,"double",&currPos);
 932
 933       if(IsvtkIdType(aArgVal)) {
 934         if (IsUnsigned(aArgVal))
 935           add_to_sig(result,"unsigned ",&currPos);
 936         add_to_sig(result,"vtkIdType",&currPos);
 937       } else {
 938         if(IsShort(aArgVal)) {
 939           if (IsUnsigned(aArgVal))
 940             add_to_sig(result,"unsigned ",&currPos);
 941           add_to_sig(result,"int",&currPos);
 942         }
 943       }
 944
 945       if(IsLong(aArgVal)) {
 946         if (IsUnsigned(aArgVal))
 947           add_to_sig(result,"unsigned ",&currPos);
 948         add_to_sig(result,"long",&currPos);
 949       }
 950       sprintf(buf,"* a_temp%d = new ",i);
 951       add_to_sig(result,buf,&currPos);
 952
 953       if(IsFloat(aArgVal))
 954         add_to_sig(result,"float",&currPos);
 955
 956       if(IsDouble(aArgVal))
 957         add_to_sig(result,"double",&currPos);
 958
 959       if(IsvtkIdType(aArgVal)) {
 960         if (IsUnsigned(aArgVal))
 961           add_to_sig(result,"unsigned ",&currPos);
 962         add_to_sig(result,"vtkIdType",&currPos);
 963       } else {
 964         if(IsShort(aArgVal)) {
 965           if (IsUnsigned(aArgVal))
 966             add_to_sig(result,"unsigned ",&currPos);
 967           add_to_sig(result,"int",&currPos);
 968         }
 969       }
 970
 971       if(IsLong(aArgVal)) {
 972         if (IsUnsigned(aArgVal))
 973           add_to_sig(result,"unsigned ",&currPos);
 974         add_to_sig(result,"long",&currPos);
 975       }
 976
 977       sprintf(buf,"[l_temp%d];\n",i);
 978       add_to_sig(result,buf,&currPos);
 979
 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);
 982
 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);
 985
 986       add_to_sig(result,"    }\n",&currPos);
 987     }
 988
 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);
 992     }
 993
 994     if(IsVoid(aArgVal)) {
 995       sprintf(buf,"    long v_temp%d;\n",i);
 996       add_to_sig(result,buf,&currPos);
 997
 998       sprintf(buf,"    temp%d.operator>>=(v_temp%d);\n",i,i);
 999       add_to_sig(result,buf,&currPos);
1000     }
1001   }
1002   add_to_sig(result,"    ",&currPos);
1003
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);
1014   }
1015
1016   if(IsFloat(aRetVal)) {
1017     if(IsArray(aRetVal)) {
1018       add_to_sig(result,"float* a_ret = ",&currPos);
1019     } else {
1020       add_to_sig(result,"CORBA::Float ret = ",&currPos);
1021     }
1022   }
1023
1024   if(IsDouble(aRetVal)) {
1025     if(IsArray(aRetVal)) {
1026       add_to_sig(result,"double* a_ret = ",&currPos);
1027     } else {
1028       add_to_sig(result,"CORBA::Double ret = ",&currPos);
1029     }
1030   }
1031
1032   if(IsShort(aRetVal)) {
1033     if(IsArray(aRetVal)) {
1034       if(IsvtkIdType(aRetVal)) {
1035         add_to_sig(result,"vtkIdType",&currPos);
1036       } else {
1037         add_to_sig(result,"int",&currPos);
1038       }
1039       add_to_sig(result,"* a_ret = ",&currPos);
1040     } else {
1041       add_to_sig(result,"CORBA::Short ret = ",&currPos);
1042     }
1043   }
1044
1045   if(IsLong(aRetVal)) {
1046     if(IsArray(aRetVal)) {
1047       add_to_sig(result,"long* a_ret = ",&currPos);
1048     } else {
1049       add_to_sig(result,"CORBA::Long ret = ",&currPos);
1050     }
1051   }
1052
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);
1059     }
1060     //}
1061
1062   if(IsBoolean(aRetVal)) {
1063     add_to_sig(result,"CORBA::Boolean ret = ",&currPos);
1064   }
1065
1066   if(IsVoidPtr(aRetVal)) {
1067     add_to_sig(result,"void * v_ret = ",&currPos);
1068   }
1069
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);
1076   }
1077   if(IsVoid(aRetVal)) {
1078     add_to_sig(result,"if(getVTKObject() != NULL) ProcessVoidEvent",&currPos);
1079   } else {
1080     add_to_sig(result,"(getVTKObject() != NULL) ? ProcessEvent",&currPos);
1081   }
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);
1087   }
1088   add_to_sig(result,")",&currPos);
1089
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);
1094
1095   for (i = 0; i < currentFunction->NumberOfArguments; i++) {
1096     aArgVal = currentFunction->Arguments[i];
1097     add_to_sig(result,"      , ",&currPos);
1098
1099     //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1100     //add_to_sig(result,"*(",&currPos);
1101     //}
1102
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);
1106     } else {
1107       if(IsArray(aArgVal) && !IsString(aArgVal) && !IsVoid(aArgVal)) {
1108         sprintf(buf,"a_temp%d",i);
1109       } else {
1110         if(IsVoidPtr(aArgVal)) {
1111           sprintf(buf,"(void*)v_temp%d",i);
1112         } else {
1113           if(IsString(aArgVal)) {
1114             sprintf(buf,"c_temp%d",i);
1115           } else {
1116             sprintf(buf,"temp%d",i);
1117           }
1118         }
1119       }
1120     }
1121
1122     add_to_sig(result,buf,&currPos);
1123     //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1124     //add_to_sig(result,")",&currPos);
1125     //}
1126     add_to_sig(result,"\n",&currPos);
1127   }
1128
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);
1135     else
1136       add_to_sig(result,"0",&currPos);
1137   }
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);
1141   }
1142
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);
1160   }
1161
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);
1168
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);
1171
1172         add_to_sig(result,"    }\n",&currPos);
1173       }
1174       sprintf(buf,"    delete [] a_temp%d;\n",i);
1175       add_to_sig(result,buf,&currPos);
1176     }
1177   }
1178
1179   if (IsVoid(aRetVal) && !IsVoidPtr(aRetVal)) {
1180     add_to_sig(result,"    return;\n",&currPos);
1181   } else {
1182     if(IsClass(aRetVal)) {
1183       add_to_sig(result,"    return aPtr->_this();\n",&currPos);
1184     } else {
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);
1189       } else {
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);
1196         } else {
1197           add_to_sig(result,"    return ret;\n",&currPos);
1198         }
1199       }
1200     }
1201   }
1202
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);
1209
1210   if (IsVoid(aRetVal)&& !IsVoidPtr(aRetVal)) {
1211     add_to_sig(result,"    return;\n",&currPos);
1212   } else{
1213     if(IsString(aRetVal)) {
1214       add_to_sig(result,"    return CORBA::string_dup(\"\");\n",&currPos);
1215     } else {
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);
1220       } else {
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);
1230         } else {
1231           add_to_sig(result,"    return 0;\n",&currPos);
1232         }
1233       }
1234     }
1235   }
1236
1237   add_to_sig(result,"  }\n",&currPos);
1238   add_to_sig(result,"}\n",&currPos);
1239 #else
1240   add_to_sig(result,";\n",&currPos);
1241 #endif
1242
1243   if(ret)
1244     {
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);
1249       strcpy(cp, result);
1250       currentFunction->Signature = cp;
1251       //strcpy((char*)currentFunction->Signature,result);
1252
1253       return;
1254     }
1255
1256   //if(strcmp(currentFunction->Name,"NewInstance") == 0) {
1257   //currentFunction->Signature[0]='\0';
1258   //return;
1259   //}
1260
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);
1266       buf[j]=0;
1267       buf1[j]=0;
1268       if(strcmp(buf,buf1) == 0) {
1269         ((char*)currentFunction->Signature)[0]='\0';
1270         return;
1271       }
1272     }
1273   }
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);
1278   strcpy(cp, result);
1279   currentFunction->Signature = cp;
1280 }
1281
1282 void outputFunction2(FILE *fp, ClassInfo *data)
1283 {
1284   int i, j, k, is_vtkobject, fnum, backnum;//, is_static, occ, goto_used;
1285   //int all_legacy;
1286   FunctionInfo *theFunc;
1287   FunctionInfo *backFunc;
1288   const char *theName;
1289   unsigned int theType;
1290   const char *backName;
1291   int backType;
1292   char static num[8];
1293   //int isSMObject = 0;
1294   int found = 0;
1295   ValueInfo* aArgVal = 0;
1296   ValueInfo* aBackArgVal = 0;
1297
1298
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);
1302   fprintf(fp,"\n");
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");
1308
1309   for(i=0;i<data->NumberOfSuperClasses;i++)
1310   {
1311     fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->SuperClasses[i]);
1312   }
1313
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);
1322 #else
1323   fprintf(fp,"#include \"PARAVIS_Gen.idl\"\n");
1324   fprintf(fp,"#include \"PARAVIS_Gen_Types.idl\"\n");
1325
1326   for(i=0;i<data->NumberOfSuperClasses;i++)
1327   {
1328     fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",data->SuperClasses[i]);
1329   }
1330
1331   fprintf(fp,"\nmodule PARAVIS\n{\n\n");
1332 #endif
1333
1334   is_vtkobject = ((strcmp(data->Name,"vtkObjectBase") == 0) ||
1335                   (data->NumberOfSuperClasses != 0));
1336
1337   for(i = 0; i < data->NumberOfSuperClasses; i++) {
1338     read_class_functions(data->SuperClasses[i],data->Name,fp);
1339   }
1340
1341   /* create a idl signature for each method */
1342   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1343     {
1344       theFunc = wrappedFunctions[fnum];
1345       currentFunction = theFunc;
1346       //printf("#### %i)Function %s\n", fnum, theFunc->Name);
1347
1348       /* names of idl methods should be unique */
1349       num[0]='\0';
1350       j=-1;
1351       for (i = 0; i < numberOfReadFunctions; i++) {
1352         if(strcmp(currentFunction->Name,readFunctions[i].Name) == 0)
1353           j++;
1354       }
1355       for (i = 0; i < fnum; i++)
1356         {
1357           if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) ==  0 )
1358             j++;
1359         }
1360
1361       if(j<0) {
1362         for (i = fnum+1; i < numberOfWrappedFunctions; i++) {
1363           if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) ==  0 ) {
1364             j=0;
1365             break;
1366           }
1367         }
1368       } else {
1369         j++;
1370       }
1371
1372       if(j>=0)
1373         {
1374           sprintf(num,"_%d",j);
1375         }
1376
1377       get_signature(num,data);
1378     }
1379   /* create external type declarations for all object
1380      return types */
1381   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1382     {
1383       theFunc = wrappedFunctions[fnum];
1384       currentFunction = theFunc;
1385       theName = NULL;
1386       theType = 0;
1387
1388       for (i = theFunc->NumberOfArguments; i >= 0; i--)
1389         {
1390           if (i==0)/* return type */
1391             {
1392               aArgVal = theFunc->ReturnValue;
1393               //theType = theFunc->ReturnType;
1394               //theName = (char*)theFunc->ReturnClass;
1395             }
1396           else /* arg type */
1397             {
1398               aArgVal = theFunc->Arguments[i-1];
1399               //theType = theFunc->ArgTypes[i-1];
1400               //theName = (char*)theFunc->ArgClasses[i-1];
1401             }
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))
1408             {
1409               /* check that we haven't done this type (no duplicate declarations) */
1410               for (backnum = fnum; backnum >= 0; backnum--)
1411                 {
1412                   backFunc = wrappedFunctions[backnum];
1413                   backName = NULL;
1414                   backType = 0;
1415                   if (backnum == fnum)
1416                     k = i+1;
1417                   else
1418                     k = 0;
1419                   for (j = backFunc->NumberOfArguments; j >= k; j--)
1420                     {
1421                       if (j==0) /* return type */
1422                         {
1423                           aBackArgVal = backFunc->ReturnValue;
1424                           //backType = backFunc->ReturnType;
1425                           //backName = (char*)backFunc->ReturnClass;
1426                         }
1427                       else /* arg type */
1428                         {
1429                           aBackArgVal = backFunc->Arguments[j-1];
1430                           //backType = backFunc->ArgTypes[j-1];
1431                           //backName = (char*)backFunc->ArgClasses[j-1];
1432                         }
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))
1438                        {
1439                           if(strcmp(theName,backName) == 0)
1440                             {
1441                               break;
1442                             }
1443                         }
1444                     }
1445                   if (j >= k)
1446                     {
1447                       break;
1448                     }
1449                 }
1450               if (backnum < 0 && strcmp(data->Name,theName) != 0)
1451                 {
1452                   found = 0;
1453                   for(j = 0; strcmp(wrapped_classes[j],"") != 0 && found == 0; j++)
1454                     {
1455                       if(strcmp(wrapped_classes[j],theName) == 0)
1456                         found = 1;
1457                     }
1458                   if(found)
1459                     {
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);
1465 #else
1466                       //fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",theName);
1467                       fprintf(fp,"    interface %s;\n",theName);
1468 #endif
1469                     }
1470                 }
1471             }
1472         }
1473     }
1474
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]);
1480   //}
1481   //fprintf(fp,", public virtual SALOME::GenericObj_i");
1482   fprintf(fp," {");
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");
1487   }
1488
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);
1496   fprintf(fp,"}\n");
1497   fprintf(fp,"\n");
1498
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);
1503     } else {
1504       fprintf(fp,"  return ::%s::New();\n",data->Name);
1505     }
1506     fprintf(fp,"}\n");
1507   }
1508 #else
1509   fprintf(fp,"\n    interface %s : PARAVIS_Base",data->Name);
1510   fprintf(fp,"\n    {\n");
1511 #endif
1512
1513   for(i = 0; i < numberOfReadFunctions; i++) {
1514     fprintf(fp, "%s\n", readFunctions[i].Signature);
1515   }
1516
1517   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++) {
1518     fprintf(fp,"%s\n",wrappedFunctions[fnum]->Signature);
1519   }
1520
1521 #if defined(IDL_I_HH)
1522   fprintf(fp,"    };\n");
1523   fprintf(fp,"}\n");
1524 #elif defined(IDL_I_CC)
1525   fprintf(fp,"};\n");
1526 #else
1527   fprintf(fp,"    };\n");
1528   fprintf(fp,"};\n");
1529 #endif
1530
1531   return;
1532 }
1533
1534 void outputFunction(FILE *fp, ClassInfo *data)
1535 {
1536   int i;
1537   //int args_ok = 1;
1538   ValueInfo* aRetVal = NULL;//currentFunction->ReturnValue;
1539   ValueInfo* aArgVal = NULL;
1540   unsigned int aType;
1541   unsigned int argtype;
1542
1543   fp = fp;
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)
1550     {
1551       return;
1552     }
1553   //printf("#### Check %s\n", currentFunction->Name);
1554
1555   /* check to see if we can handle the args */
1556   for (i = 0; i < currentFunction->NumberOfArguments; i++)
1557     {
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);
1562         return;
1563         }*/
1564       if (vtkWrap_IsStream(aArgVal)) {
1565         //printf("!!!! Argument %i is stream\n", i);
1566         return;
1567       }
1568       if (IsPtr(aArgVal)) {
1569         //printf("!!!! Argument %i is pointer value\n", i);
1570         return;
1571       }
1572       if (IsUnknown(aArgVal)) {
1573         //printf("!!!! Argument %i is unknown value\n", i);
1574        return;
1575       }
1576       if (vtkWrap_IsVoidPointer(aArgVal)) {
1577         //printf("!!!! Argument %i is void pointer\n", i);
1578         return;
1579       }
1580       if (vtkWrap_IsVoidFunction(aArgVal)) {
1581         //printf("!!!! Argument %i is void function\n", i);
1582         return;
1583       }
1584       argtype = (aArgVal->Type & VTK_PARSE_INDIRECT);
1585       if (argtype == VTK_PARSE_POINTER_POINTER){
1586         //printf("!!!! Argument %i is pointer to pointer\n", i);
1587         return;
1588       }
1589       if (vtkWrap_IsNonConstRef(aArgVal)) {
1590         //printf("!!!! Argument %i is non const ref\n", i);
1591         return;
1592       }
1593       if (vtkWrap_IsSpecialObject(aArgVal)) {
1594         //printf("!!!! Argument %i is special object\n", i);
1595         return;
1596       }
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;*/
1609     }
1610   aRetVal = currentFunction->ReturnValue;
1611   if (aRetVal) {
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");
1616       return;
1617     }
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");
1622       return;
1623     }
1624
1625     if ((aType == VTK_PARSE_UNKNOWN)) {
1626       //printf("!!!! Return Value is unknown\n");
1627       return;
1628     }
1629     argtype = (aRetVal->Type & VTK_PARSE_INDIRECT);
1630     if (argtype == VTK_PARSE_POINTER_POINTER){
1631       //printf("!!!! Return value is pointer to pointer\n", i);
1632       return;
1633     }
1634     if (vtkWrap_IsSpecialObject(aRetVal)) {
1635       //printf("!!!! Return is special object\n", i);
1636       return;
1637     }
1638   }
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;
1644   */
1645
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;
1653
1654
1655   if (currentFunction->NumberOfArguments &&
1656       (currentFunction->ArgTypes[0] == 0x5000)
1657       &&(currentFunction->NumberOfArguments != 0x1)) args_ok = 0;*/
1658
1659   /* make sure we have all the info we need for array arguments in */
1660   /*for (i = 0; i < currentFunction->NumberOfArguments; i++)
1661     {
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;
1667         }*/
1668
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)
1672     {
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;
1676       break;
1677       }*/
1678
1679   /* make sure it isn't a Delete or New function */
1680   if (!strcmp("Delete",currentFunction->Name) ||
1681       !strcmp("New",currentFunction->Name))
1682     {
1683       return;
1684     }
1685
1686   if (vtkWrap_IsDestructor(data, currentFunction) || vtkWrap_IsConstructor(data, currentFunction)) {
1687     //printf("!!!! Return Value is constructor or destructor\n");
1688     return;
1689   }
1690
1691   /* check for New() function */
1692   if (!strcmp("New",currentFunction->Name) && currentFunction->NumberOfArguments == 0)
1693     {
1694       class_has_new = 1;
1695     }
1696
1697   if (currentFunction->IsPublic && //args_ok &&
1698       strcmp(data->Name,currentFunction->Name) &&
1699       strcmp(data->Name, currentFunction->Name + 1))
1700     {
1701       //printf("#### %i Function %s\n", numberOfWrappedFunctions, currentFunction->Name);
1702       wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
1703       numberOfWrappedFunctions++;
1704     }
1705
1706   return;
1707 }
1708
1709 /* print the parsed structures */
1710 void vtkParseOutput(FILE *fp, FileInfo *file_info)
1711 {
1712   int i;
1713   ClassInfo *data;
1714
1715   /* get the main class */
1716   data = file_info->MainClass;
1717
1718   // Do not wrap this class
1719   //  if (strcmp(data->Name, "vtkVariant") == 0)
1720   //  return;
1721
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);
1726 #else
1727   fprintf(fp, "// idl wrapper for %s object\n//\n", data->Name);
1728 #endif
1729   for (i = 0;1;i++)
1730     {
1731       if(strlen(Copyright[i]) != 0)
1732         {
1733           fprintf(fp,"%s\n",Copyright[i]);
1734         }
1735       else
1736         {
1737           break;
1738         }
1739     }
1740   fprintf(fp,"\n");
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);
1744   fprintf(fp,"\n");
1745 #elif defined(IDL_I_CC)
1746 #else
1747   fprintf(fp,"#ifndef __PARAVIS_Gen_%s__\n",data->Name);
1748   fprintf(fp,"#define __PARAVIS_Gen_%s__\n",data->Name);
1749   fprintf(fp,"\n");
1750 #endif
1751
1752   /* insert function handling code here */
1753   for (i = 0; i < data->NumberOfFunctions; i++)
1754     {
1755       currentFunction = data->Functions[i];
1756       outputFunction(fp, data);
1757     }
1758   //printf("#### NbFunctions %i\n", numberOfWrappedFunctions);
1759   //if (data->NumberOfSuperClasses || (!data->IsAbstract))
1760   //if (numberOfWrappedFunctions)
1761   // {
1762       outputFunction2(fp, data);
1763       // }
1764
1765 #if defined(IDL_I_HH)
1766   fprintf(fp,"\n#endif\n");
1767 #elif defined(IDL_I_CC)
1768 #else
1769   fprintf(fp,"\n#endif\n");
1770 #endif
1771   return;
1772 }