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 "vtkConfigure.h"
  29 #include "vtkParse.h"
  30 #include "vtkParseType.h"
  31 #include "vtkParseMain.h"
  32 #include "vtkWrapIDL.h"
  33 #include "vtkWrap.h"
  34
  35 char* Copyright[] = {
  36   "// Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,",
  37   "// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS",
  38   "//",
  39   "// This library is free software; you can redistribute it and/or",
  40   "// modify it under the terms of the GNU Lesser General Public",
  41   "// License as published by the Free Software Foundation; either",
  42   "// version 2.1 of the License.",
  43   "//",
  44   "// This library is distributed in the hope that it will be useful,",
  45   "// but WITHOUT ANY WARRANTY; without even the implied warranty of",
  46   "// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU",
  47   "// Lesser General Public License for more details.",
  48   "//",
  49   "// You should have received a copy of the GNU Lesser General Public",
  50   "// License along with this library; if not, write to the Free Software",
  51   "// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA",
  52   "//",
  53   "// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com",
  54   ""
  55 };
  56
  57 #define bs 12288
  58
  59 HierarchyInfo *hierarchyInfo = NULL;
  60 int numberOfWrappedFunctions = 0;
  61 FunctionInfo *wrappedFunctions[1000];
  62 extern FunctionInfo *currentFunction;
  63 char *EmptyString = "";
  64
  65
  66 static void add_to_sig(char *sig, const char *add, int *i)
  67 {
  68   strcpy(&sig[*i],add);
  69   *i += (int)strlen(add);
  70 }
  71
  72 int IsReturnArg(int I) {
  73   return (I == MAX_ARGS);
  74 }
  75
  76 void AddReturnArg(char *Result, int *CurrPos) {
  77   add_to_sig(Result,"virtual ",CurrPos);
  78 }
  79
  80 int IsIn(ValueInfo* Type) {
  81   return 1;
  82   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 < 1 || (Type % VTK_PARSE_BASE_TYPE)/0x100 > 7);
  83 }
  84
  85 void AddNotReturnArg(ValueInfo* Type, char *Result, int *CurrPos) {
  86 #if defined(IDL_I_HH) || defined(IDL_I_CC)
  87   ;
  88 #else
  89   if(IsIn(Type))
  90     add_to_sig(Result,"in ",CurrPos);
  91   else
  92     add_to_sig(Result,"inout ",CurrPos);
  93 #endif
  94 }
  95
  96 int IsFunction(ValueInfo* Type) {
  97   //return (Type == VTK_PARSE_FUNCTION);
  98   return vtkWrap_IsFunction(Type);
  99 }
 100
 101 int IsConst(ValueInfo* Type) {
 102   //return ((Type % 0x2000) >= 0x1000);
 103   return vtkWrap_IsConst(Type);
 104 }
 105
 106 void AddConst(char *Result, int *CurrPos) {
 107 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 108   add_to_sig(Result,"const ",CurrPos);
 109 #else
 110   add_to_sig(Result,"in ",CurrPos);
 111 #endif
 112 }
 113
 114
 115 int IsClass(ValueInfo* theType) {
 116   //return ((theType->Type % 0x10) == 0x9);
 117   return vtkWrap_IsObject(theType) || vtkWrap_IsVTKObject(theType);
 118 }
 119
 120 int IsString(ValueInfo* Type) {
 121   //return (IsChar(Type) && IsArray(Type));
 122   //return (IsChar(Type) && IsPtr(Type));
 123   return vtkWrap_IsCharPointer(Type) || vtkWrap_IsString(Type) || (strcmp(Type->Class, "vtkStdString") == 0);
 124 }
 125
 126 int IsPtr(ValueInfo* Type) {
 127   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x1);
 128   return vtkWrap_IsPointer(Type) && (!IsString(Type)) && (!IsClass(Type));
 129 }
 130
 131 int IsUnknown(ValueInfo* theType) {
 132   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x8);
 133   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_UNKNOWN;
 134 }
 135
 136 void AddAtomArg(int I, ValueInfo* Type, char *TypeIDL, char *TypeCorba, char *Result, int *CurrPos) {
 137 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 138   add_to_sig(Result,"CORBA::",CurrPos);
 139   add_to_sig(Result,TypeCorba,CurrPos);
 140
 141   if (!IsReturnArg(I) && !IsConst(Type) && !IsIn(Type))
 142     add_to_sig(Result,"&",CurrPos);
 143 #else
 144   add_to_sig(Result,TypeIDL,CurrPos);
 145 #endif
 146   add_to_sig(Result," ",CurrPos);
 147 }
 148
 149 int IsArray(ValueInfo* Type) {
 150   //return ((Type % VTK_PARSE_BASE_TYPE)/0x100 == 0x3);
 151   return vtkWrap_IsArray(Type);
 152 }
 153
 154 void AddArrayArg(int I, ValueInfo* Type, char *TypeIDL, char *Result, int *CurrPos) {
 155 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 156   if(!IsReturnArg(I) && !IsConst(Type))
 157     add_to_sig(Result, "const ",CurrPos);
 158 #endif
 159   add_to_sig(Result, TypeIDL,CurrPos);
 160   add_to_sig(Result, "_array",CurrPos);
 161 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 162   if(IsReturnArg(I)) {
 163     add_to_sig(Result, "*",CurrPos);
 164   } else {
 165     add_to_sig(Result, "&",CurrPos);
 166   }
 167 #else
 168 #endif
 169   add_to_sig(Result, " ",CurrPos);
 170 }
 171
 172 int IsBoolean(ValueInfo* Type) {
 173   //return ((Type % 0x10) == 0xE);
 174   return vtkWrap_IsBool(Type);
 175 }
 176
 177 void AddBooleanAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 178   AddAtomArg(I,Type,"boolean","Boolean",Result,CurrPos);
 179 }
 180
 181 int IsChar(ValueInfo* theType) {
 182   //return ((Type % 0x10) == 0x3 || (Type % 0x10) == 0xD);
 183   int aBase = theType->Type & VTK_PARSE_BASE_TYPE;
 184   return (aBase == VTK_PARSE_CHAR) || (aBase == VTK_PARSE_UNSIGNED_CHAR) || (aBase == VTK_PARSE_SIGNED_CHAR);
 185 }
 186
 187 int IsCharArray(ValueInfo* theType) {
 188   return (IsChar(theType) && IsArray(theType));
 189 }
 190
 191 void AddCharAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 192   AddAtomArg(I,Type,"char","Char",Result,CurrPos);
 193 }
 194
 195 void AddStringArg(int I, char *Result, int *CurrPos) {
 196 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 197   add_to_sig(Result,"char ",CurrPos);
 198 #else
 199   add_to_sig(Result,"string ",CurrPos);
 200 #endif
 201 }
 202
 203 int IsFloat(ValueInfo* theType) {
 204   //return ((Type % 0x10) == 0x1);
 205   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_FLOAT;
 206 }
 207
 208 void AddFloatAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 209   AddAtomArg(I,Type,"float","Float",Result,CurrPos);
 210 }
 211
 212 int IsFloatArray(ValueInfo* theType) {
 213   return (IsFloat(theType) && IsArray(theType));
 214 }
 215
 216 void AddFloatArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 217   AddArrayArg(I,Type,"float",Result,CurrPos);
 218 }
 219
 220 int IsDouble(ValueInfo* theType) {
 221   //return ((Type % 0x10) == 0x7);
 222   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_DOUBLE;
 223 }
 224
 225 void AddDoubleAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 226   AddAtomArg(I,Type,"double","Double",Result,CurrPos);
 227 }
 228
 229 int IsDoubleArray(ValueInfo*  Type) {
 230   return (IsDouble(Type) && IsArray(Type));
 231 }
 232
 233 void AddDoubleArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 234   AddArrayArg(I,Type,"double",Result,CurrPos);
 235 }
 236
 237 int IsvtkIdType(ValueInfo* theType) {
 238   //return((Type % 0x10) == 0xA);
 239   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_ID_TYPE;
 240 }
 241
 242 int IsShort(ValueInfo* theType) {
 243   //return ((Type % 0x10) == 0x4 || (Type % 0x10) == 0x5 || (Type % 0x10) == 0xA);
 244   int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
 245   return (aVal == VTK_PARSE_SHORT) || (aVal == VTK_PARSE_INT) ||
 246     (aVal == VTK_PARSE_ID_TYPE) || (aVal == VTK_PARSE_UNSIGNED_INT) || (aVal == VTK_PARSE_UNSIGNED_SHORT) ||
 247     (aVal == VTK_PARSE_SSIZE_T) || (aVal == VTK_PARSE_SIZE_T);
 248 }
 249
 250 void AddShortAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 251   AddAtomArg(I,Type,"short","Short",Result,CurrPos);
 252 }
 253
 254 int IsShortArray(ValueInfo* Type) {
 255   return (IsShort(Type) && IsArray(Type));
 256 }
 257
 258 void AddShortArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 259   AddArrayArg(I,Type,"short",Result,CurrPos);
 260 }
 261
 262 int IsLong(ValueInfo* theType) {
 263   //return ((Type % 0x10) == 0x6 || (Type % 0x10) == 0xB || (Type % 0x10) == 0xC);
 264   unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
 265   return (aVal == VTK_PARSE_LONG) || (aVal == VTK_PARSE_UNSIGNED_LONG) ||
 266     (aVal == VTK_PARSE___INT64) || (aVal == VTK_PARSE_UNSIGNED___INT64) || (aVal == VTK_PARSE_LONG_LONG) ||
 267     (aVal == VTK_PARSE_UNSIGNED_LONG_LONG);
 268 }
 269
 270 void AddLongAtomArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 271   AddAtomArg(I,Type,"long","Long",Result,CurrPos);
 272 }
 273
 274 int IsLongArray(ValueInfo* Type) {
 275   return (IsLong(Type) && IsArray(Type));
 276 }
 277
 278 void AddLongArrayArg(int I, ValueInfo* Type, char *Result, int *CurrPos) {
 279   AddArrayArg(I,Type,"long",Result,CurrPos);
 280 }
 281
 282 void AddClassArg(int I, ValueInfo* Type, const char *Class, char *Result, int *CurrPos) {
 283 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 284   add_to_sig(Result,"PARAVIS_Base",CurrPos);
 285   if(IsReturnArg(I) || IsConst(Type) || IsIn(Type)) {
 286     add_to_sig(Result,"_ptr",CurrPos);
 287   } else {
 288     add_to_sig(Result,"_ptr&",CurrPos);
 289   }
 290   add_to_sig(Result," ",CurrPos);
 291 #else
 292   add_to_sig(Result,"PARAVIS_Base ",CurrPos);
 293 #endif
 294 }
 295
 296 int _IsVoid(ValueInfo* theType) {
 297   //return ((Type % 0x10) == 0x2);
 298   return (theType->Type & VTK_PARSE_BASE_TYPE) == VTK_PARSE_VOID;
 299 }
 300
 301 int IsVoid(ValueInfo* Type) {
 302   return (_IsVoid(Type) && (!IsPtr(Type)));
 303 }
 304
 305 int IsUnsigned(ValueInfo* theType) {
 306   unsigned int aVal = theType->Type & VTK_PARSE_BASE_TYPE;
 307   switch (aVal) {
 308   case VTK_PARSE_UNSIGNED_CHAR:
 309   case VTK_PARSE_UNSIGNED_INT:
 310   case VTK_PARSE_UNSIGNED_SHORT:
 311   case VTK_PARSE_UNSIGNED_LONG:
 312   case VTK_PARSE_UNSIGNED_ID_TYPE:
 313   case VTK_PARSE_UNSIGNED_LONG_LONG:
 314   case VTK_PARSE_UNSIGNED___INT64:
 315   case VTK_PARSE_UNSIGNED_CHAR_PTR:
 316   case VTK_PARSE_UNSIGNED_INT_PTR:
 317   case VTK_PARSE_UNSIGNED_SHORT_PTR:
 318   case VTK_PARSE_UNSIGNED_LONG_PTR:
 319   case VTK_PARSE_UNSIGNED_ID_TYPE_PTR:
 320   case VTK_PARSE_UNSIGNED_LONG_LONG_PTR:
 321   case VTK_PARSE_UNSIGNED___INT64_PTR:
 322     return 1;
 323   }
 324   return 0;
 325 }
 326
 327 void AddVoid(char *Result, int *CurrPos) {
 328   add_to_sig(Result,"void ",CurrPos);
 329 }
 330
 331 int IsVoidPtr(ValueInfo* Type) {
 332   return (_IsVoid(Type) && (IsPtr(Type) || IsArray(Type)));
 333 }
 334
 335 void AddVoidArg(int I, char *Result, int *CurrPos, ValueInfo* Type) {
 336 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 337   if(!IsReturnArg(I)) {
 338     if(!IsConst(Type))
 339       add_to_sig(Result,"const ",CurrPos);
 340     add_to_sig(Result,"CORBA::Any& ",CurrPos);
 341   } else {
 342     add_to_sig(Result,"CORBA::Any ",CurrPos);
 343   }
 344 #else
 345   add_to_sig(Result,"any ",CurrPos);
 346 #endif
 347 }
 348
 349 void AddTypeArray(ValueInfo* Type, char *Result, int *CurrPos) {
 350   if(IsShort(Type))
 351     add_to_sig(Result,"short",CurrPos);
 352   if(IsLong(Type))
 353     add_to_sig(Result,"long",CurrPos);
 354   if(IsFloat(Type))
 355     add_to_sig(Result,"float",CurrPos);
 356   if(IsDouble(Type))
 357     add_to_sig(Result,"double",CurrPos);
 358   if(IsChar(Type))
 359     add_to_sig(Result,"char",CurrPos);
 360   add_to_sig(Result,"_array",CurrPos);
 361 }
 362
 363 typedef struct _ReadFuncs
 364 {
 365   char* Name;
 366   char* Signature;
 367   int   EndPos;
 368   int   NumPos;
 369 } ReadFuncs;
 370
 371 ReadFuncs readFunctions[1000];
 372 int numberOfReadFunctions = 0;
 373
 374 static int class_has_new = 0;
 375
 376 void output_type(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
 377 {
 378   if (vtkWrap_IsConst(aType))
 379     add_to_sig(result,"const ",currPos);
 380
 381   if(IsFloat(aType)) {
 382     if(IsArray(aType)) {
 383       add_to_sig(result,"float",currPos);
 384     } else {
 385       add_to_sig(result,"CORBA::Float",currPos);
 386     }
 387   }
 388
 389   if(IsDouble(aType)) {
 390     if(IsArray(aType)) {
 391       add_to_sig(result,"double",currPos);
 392     } else {
 393       add_to_sig(result,"CORBA::Double",currPos);
 394     }
 395   }
 396
 397   if(IsShort(aType)) {
 398     if(IsArray(aType)) {
 399       if (IsUnsigned(aType))
 400         add_to_sig(result,"unsigned ",currPos);
 401       if(IsvtkIdType(aType)) {
 402         add_to_sig(result,"vtkIdType",currPos);
 403       } else {
 404         add_to_sig(result,"int",currPos);
 405       }
 406     } else {
 407       add_to_sig(result,"CORBA::Short",currPos);
 408     }
 409   }
 410
 411   if(IsLong(aType)) {
 412     if(IsArray(aType)) {
 413       if (IsUnsigned(aType))
 414         add_to_sig(result,"unsigned ",currPos);
 415       add_to_sig(result,"long",currPos);
 416     } else {
 417       add_to_sig(result,"CORBA::Long",currPos);
 418     }
 419   }
 420
 421   if(IsString(aType)) {
 422     if(IsReturnArg(i))
 423       add_to_sig(result,"const ",currPos);
 424     if(strcmp(aType->Class, "vtkStdString") == 0) {
 425       add_to_sig(result,"vtkStdString",currPos);
 426     } else {
 427       add_to_sig(result,"char",currPos);
 428     }
 429   } else if(IsChar(aType)) {
 430     add_to_sig(result,"CORBA::Char",currPos);
 431   }
 432
 433   if(IsBoolean(aType)) {
 434     add_to_sig(result,"CORBA::Boolean",currPos);
 435   }
 436
 437   if(IsVoidPtr(aType)) {
 438     add_to_sig(result,"void",currPos);
 439   }
 440
 441   if(IsClass(aType)) {
 442     add_to_sig(result,"::",currPos);
 443     add_to_sig(result,Id,currPos);
 444   }
 445
 446   if(IsArray(aType) || IsPtr(aType) || IsClass(aType) || IsString(aType)) {
 447     if(strcmp(aType->Class, "vtkStdString") != 0) {
 448       add_to_sig(result,"*",currPos);
 449     }
 450   }
 451 }
 452
 453 void output_typedef(char* result, int *currPos, int i, ValueInfo* aType, const char *Id)
 454 {
 455   add_to_sig(result,"  typedef ",currPos);
 456   output_type(result,currPos,i,aType,Id);
 457 }
 458
 459 void output_temp(char* result, int *currPos, int i, ValueInfo* aType, const char *Id, int aCount)
 460 {
 461   static char buf[bs];
 462
 463   /* handle VAR FUNCTIONS */
 464   if (IsFunction(aType)) {
 465     return;
 466   }
 467
 468 #if defined(IDL_I_HH)
 469   if(IsReturnArg(i)) {
 470     AddReturnArg(result,currPos);
 471   }
 472 #endif
 473
 474   if (IsReturnArg(i) && IsVoid(aType) && !IsVoidPtr(aType)) {
 475     AddVoid(result,currPos);
 476     return;
 477   }
 478
 479   /* for const * return types prototype with const */
 480   if ( IsConst(aType) || IsString(aType)) {
 481     if(!IsReturnArg(i)) {
 482       AddConst(result,currPos);
 483     }
 484   } else {
 485     if(!IsReturnArg(i)) {
 486       AddNotReturnArg(aType,result,currPos);
 487     }
 488   }
 489
 490   if(IsFloat(aType)) {
 491     if(IsFloatArray(aType)) {
 492       AddFloatArrayArg(i,aType,result,currPos);
 493     } else {
 494       AddFloatAtomArg(i,aType,result,currPos);
 495     }
 496   }
 497
 498   if(IsDouble(aType)) {
 499     if(IsDoubleArray(aType)) {
 500       AddDoubleArrayArg(i,aType,result,currPos);
 501     } else {
 502       AddDoubleAtomArg(i,aType,result,currPos);
 503     }
 504   }
 505
 506   if(IsShort(aType)) {
 507     if(IsShortArray(aType)) {
 508       AddShortArrayArg(i,aType,result,currPos);
 509     } else {
 510       AddShortAtomArg(i,aType,result,currPos);
 511     }
 512   }
 513
 514   if(IsLong(aType)) {
 515     if(IsLongArray(aType)) {
 516       AddLongArrayArg(i,aType,result,currPos);
 517     } else {
 518       AddLongAtomArg(i,aType,result,currPos);
 519     }
 520   }
 521
 522   if(IsChar(aType)) {
 523     if(IsString(aType)) {
 524       AddStringArg(i,result,currPos);
 525     } else {
 526       AddCharAtomArg(i,aType,result,currPos);
 527     }
 528   } else if (IsString(aType)) //!!! VSV
 529     AddStringArg(i,result,currPos);
 530
 531   if(IsBoolean(aType)) {
 532     AddBooleanAtomArg(i,aType,result,currPos);
 533   }
 534
 535   if(IsVoid(aType)) {
 536     AddVoidArg(i,result,currPos,aType);
 537   }
 538
 539   if(IsClass(aType)) {
 540     AddClassArg(i,aType,Id,result,currPos);
 541   }
 542
 543   if(IsUnknown(aType)) {
 544     return;
 545   }
 546
 547   if(!IsClass(aType)) {
 548     if(IsPtr(aType)) {
 549       add_to_sig(result," *",currPos);
 550     }
 551 #if defined(IDL_I_HH) || defined(IDL_I_CC)
 552     if(IsString(aType) && !IsIn(aType) && !IsConst(aType) && !IsReturnArg(i)) {
 553       add_to_sig(result,"*&",currPos);
 554     } else {
 555       if(IsString(aType) || (IsReturnArg(i) && IsVoidPtr(aType))) {
 556         add_to_sig(result," *",currPos);
 557       }
 558     }
 559 #endif
 560   }
 561
 562   if(!IsReturnArg(i)) {
 563     sprintf(buf,"temp%i",i);
 564     add_to_sig(result,buf,currPos);
 565   }
 566
 567   return;
 568 }
 569
 570 void read_class_functions(const char* name, const char* classname, FILE* fp)
 571 {
 572   int len=0;
 573   int curlen=0;
 574   int i, j;
 575   int flen=0;
 576   //int num=0;
 577   int ret_str=0;
 578   FILE *fin;
 579   char buf[bs];
 580   char buf1[bs];
 581   char fname[bs];
 582   static char sig[bs];
 583   static int slen=8;
 584 #if ! defined(IDL_I_CC)
 585   static int clen=15;
 586 #else
 587   static int clen=7;
 588 #endif
 589
 590
 591 #if defined(IDL_I_HH)
 592   sprintf(buf,"PARAVIS_Gen_%s_i.hh",name);
 593 #elif defined(IDL_I_CC)
 594   sprintf(buf,"PARAVIS_Gen_%s_i.cc",name);
 595 #else
 596   sprintf(buf,"PARAVIS_Gen_%s.idl",name);
 597 #endif
 598   if (!(fin = fopen(buf,"r"))) {
 599     fprintf(stderr,"Error opening input file %s\n",buf);
 600     exit(1);
 601   }
 602   while (fgets(sig,bs-1,fin) != 0) {
 603 #if defined(IDL_I_CC)
 604     if(strncmp("#include \"PARAVIS_Gen_vtk",sig,25)==0) {
 605       fprintf(fp, "%s",sig);
 606     }
 607     if(strncmp("#include <vtk",sig,13)==0) {
 608       fprintf(fp, "%s",sig);
 609     }
 610 #endif
 611
 612 #if ! defined(IDL_I_CC)
 613     if(strncmp("        //C++: ",sig,clen)==0) {
 614 #else
 615     if(strncmp("//C++: ",sig,clen)==0) {
 616 #endif
 617 #if defined(IDL_I_CC)
 618       while(fgets(buf,bs-1,fin) != 0) {
 619         len=strlen(sig);
 620         strcpy(sig+len,buf);
 621         if(strlen(buf) == 3 && buf[0]=='/' && buf[1]=='/')
 622           break;
 623       }
 624 #endif
 625       len=strlen(sig);
 626       if(fgets(buf,bs-1,fin)!=NULL && strlen(buf) > 1) {
 627         ret_str=0;
 628 #if defined(IDL_I_HH)
 629         strcpy(sig+len,buf);
 630         readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
 631         sscanf(sig+len,"%s %s %s",buf,buf1,fname);
 632         if(fname[0] == '*') {
 633           ret_str=1;
 634         }
 635 #elif defined(IDL_I_CC)
 636         strcpy(buf1,buf);
 637         sscanf(buf1,"%s %s",buf,fname);
 638
 639         curlen=strlen(sig);
 640         sprintf(sig+curlen,"%s ",buf);
 641         j=strlen(buf)+1;
 642
 643         if(fname[0] == '*') {
 644           curlen=strlen(sig);
 645           sprintf(sig+curlen," *");
 646           j+=1;
 647         }
 648         curlen=strlen(sig);
 649         sprintf(sig+curlen,"%s_i::",classname);
 650
 651         for(i = 0; i < strlen(fname)-1; i++) {
 652           ret_str+=1;
 653           j+=1;
 654           if(fname[i] == ':' && fname[i] == ':') {
 655             ret_str+=1;
 656             j+=1;
 657             break;
 658           }
 659         }
 660         curlen=strlen(sig);
 661         sprintf(sig+curlen,"%s", buf1+j);
 662
 663         curlen=strlen(sig);
 664         readFunctions[numberOfReadFunctions].EndPos=curlen;
 665         while (fgets(sig+curlen,bs-1-curlen,fin) != 0) {
 666           if(sig[curlen] == '}')
 667             break;
 668           curlen=strlen(sig);
 669         }
 670 #else
 671         strcpy(sig+len,buf);
 672         readFunctions[numberOfReadFunctions].EndPos=strlen(sig);
 673         sscanf(sig+len,"%s _%s",buf,fname);
 674 #endif
 675         flen=strlen(fname);
 676         if(flen>0) {
 677           if(flen>2 && fname[flen-2]=='_') {
 678             flen-=2;
 679           }
 680           readFunctions[numberOfReadFunctions].Name = malloc((flen+1-ret_str)*sizeof(char));
 681           strncpy(readFunctions[numberOfReadFunctions].Name,fname+ret_str,flen-ret_str);
 682           readFunctions[numberOfReadFunctions].Name[flen-ret_str]='\0';
 683
 684 #if defined(IDL_I_HH)
 685           len+=slen+strlen(buf)+1+strlen(buf1)+2+flen+ret_str-1; //spaces+virtual+space+return+space+space+*+name
 686 #elif defined(IDL_I_CC)
 687           len+=2+strlen(buf)+2+strlen(classname)+2+strlen(readFunctions[numberOfReadFunctions].Name)-1; //return+space+space+name
 688           if(fname[0] == '*') {
 689             len+=2;
 690           }
 691           if(fname[flen-2]=='_') {
 692             len+=2;
 693           }
 694 #else
 695           len+=slen+strlen(buf)+2+flen; //spaces+return+space+_+name
 696 #endif
 697           readFunctions[numberOfReadFunctions].NumPos=len;
 698           if(fname[flen]=='_') {
 699             readFunctions[numberOfReadFunctions].NumPos=len+2; //+_+num
 700           }
 701
 702           len=strlen(sig);
 703           readFunctions[numberOfReadFunctions].Signature = malloc((len+1)*sizeof(char));
 704           strncpy(readFunctions[numberOfReadFunctions].Signature,sig,len);
 705           readFunctions[numberOfReadFunctions].Signature[len]='\0';
 706
 707           numberOfReadFunctions++;
 708         }
 709       }
 710     }
 711   }
 712   fclose (fin);
 713   return;
 714 }
 715
 716 void get_signature(const char* num, ClassInfo *data)
 717 {
 718   static char result[bs];
 719   int currPos = 0;
 720   int currPos_sig = 0;
 721   //int argtype;
 722   int i, j;
 723   static char buf[bs];
 724   static char buf1[bs];
 725   int ret = 0;
 726   int found = 0;
 727   int currPos_num = 0;
 728   ValueInfo* aRetVal = NULL;
 729   ValueInfo* aArgVal = NULL;
 730   char *cp;
 731
 732   aRetVal = currentFunction->ReturnValue;
 733
 734   add_to_sig(result,"\n",&currPos);
 735   if (currentFunction->Signature) {
 736 #if ! defined(IDL_I_CC)
 737     add_to_sig(result,"        ",&currPos);
 738 #endif
 739     add_to_sig(result,"//C++: ",&currPos);
 740     add_to_sig(result,currentFunction->Signature,&currPos);
 741     add_to_sig(result,"\n",&currPos);
 742   }
 743
 744   if(IsClass(aRetVal) && ret == 0) {
 745     found = 0;
 746     for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
 747       if(strcmp(wrapped_classes[i],currentFunction->ReturnValue->Class) == 0)
 748         found = 1;
 749     }
 750     if(!found)
 751       ret = 1;
 752   }
 753
 754   for (j = 0; j < vtkWrap_CountWrappedParameters(currentFunction); j++) {
 755     aArgVal = currentFunction->Parameters[j];
 756     if(IsFunction(aArgVal))
 757       ret == 1;
 758     if(IsClass(aArgVal) && ret == 0) {
 759       found = 0;
 760       for(i = 0; strcmp(wrapped_classes[i],"") != 0 && found == 0; i++) {
 761         if(strcmp(wrapped_classes[i],aArgVal->Class) == 0)
 762           found = 1;
 763       }
 764       if(!found)
 765         ret = 1;
 766     }
 767   }
 768
 769   if (IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal) && currentFunction->HintSize == 0) {
 770     ret = 1;
 771   }
 772
 773
 774   if(ret) {
 775     add_to_sig(result,"//\n",&currPos);
 776     /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
 777       (size_t)(currPos+1));*/
 778     //strcpy((char*)currentFunction->Signature,result);
 779     cp = (char *)malloc(currPos+1);
 780     strcpy(cp, result);
 781     currentFunction->Signature = cp;
 782     return;
 783   }
 784
 785 #if defined(IDL_I_CC)
 786   add_to_sig(result,"struct CreateEventName(",&currPos);
 787   add_to_sig(result,currentFunction->Name,&currPos);
 788   if( strlen(num)!=0 ) {
 789     add_to_sig(result,num,&currPos);
 790   }
 791   add_to_sig(result,")",&currPos);
 792   add_to_sig(result,": public SALOME_Event\n",&currPos);
 793   add_to_sig(result,"{\n",&currPos);
 794   if(!IsVoid(aRetVal)) {
 795     //output_typedef(result,&currPos,MAX_ARGS,aRetVal, currentFunction->ReturnValue->Class);
 796     add_to_sig(result,"  typedef ",&currPos);
 797     if (vtkWrap_IsConst(aRetVal))
 798       add_to_sig(result, " const ",&currPos);
 799     if (vtkWrap_IsObject(aRetVal))
 800       add_to_sig(result, " ::",&currPos);
 801     add_to_sig(result, aRetVal->Class,&currPos);
 802     if (vtkWrap_IsPointer(aRetVal) || vtkWrap_IsArray(aRetVal))
 803       add_to_sig(result, "*",&currPos);
 804     add_to_sig(result," TResult;\n",&currPos);
 805     add_to_sig(result,"  TResult myResult;\n",&currPos);
 806   }
 807
 808   //output_typedef(result, &currPos, 0, 0x309, data->Name); //!!??
 809   add_to_sig(result,"  typedef ::",&currPos);
 810   add_to_sig(result,data->Name,&currPos);
 811   add_to_sig(result,"* TObj;\n",&currPos);
 812   add_to_sig(result,"  TObj myObj;\n",&currPos);
 813
 814   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 815     aArgVal = currentFunction->Parameters[i];
 816     //output_typedef(result, &currPos, i, currentFunction->ArgTypes[i],
 817     //               currentFunction->ArgClasses[i]);
 818     output_typedef(result, &currPos, i, aArgVal, currentFunction->ArgClasses[i]);
 819     sprintf(buf," TParam%d;\n",i);
 820     add_to_sig(result,buf,&currPos);
 821     sprintf(buf,"  TParam%d myParam%d;\n",i,i);
 822     add_to_sig(result,buf,&currPos);
 823   }
 824
 825   add_to_sig(result,"\n",&currPos);
 826   add_to_sig(result,"  CreateEventName(",&currPos);
 827   add_to_sig(result,currentFunction->Name,&currPos);
 828   if( strlen(num)!=0 ) {
 829     add_to_sig(result,num,&currPos);
 830   }
 831   add_to_sig(result,")",&currPos);
 832   add_to_sig(result,"(TObj theObj",&currPos);
 833   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 834     sprintf(buf,", TParam%d theParam%d",i,i);
 835     add_to_sig(result,buf,&currPos);
 836   }
 837   add_to_sig(result,"):\n",&currPos);
 838   add_to_sig(result,"  myObj(theObj)",&currPos);
 839   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 840     sprintf(buf,", myParam%d(theParam%d)",i,i);
 841     add_to_sig(result,buf,&currPos);
 842   }
 843   add_to_sig(result,"\n",&currPos);
 844   add_to_sig(result,"  { }\n",&currPos);
 845   add_to_sig(result,"\n",&currPos);
 846   add_to_sig(result,"  virtual void Execute()\n",&currPos);
 847   add_to_sig(result,"  {\n",&currPos);
 848   add_to_sig(result,"    ",&currPos);
 849   if(!IsVoid(aRetVal)/* && !IsString(aRetVal)*/) {
 850     add_to_sig(result,"myResult = ",&currPos);
 851   }
 852   //if(IsString(aRetVal)) {
 853   //add_to_sig(result,"const char* ret = ",&currPos);
 854   //}
 855   add_to_sig(result,"myObj->",&currPos);
 856   add_to_sig(result,currentFunction->Name,&currPos);
 857   add_to_sig(result,"(",&currPos);
 858   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 859     aArgVal = currentFunction->Parameters[i];
 860     if(i!=0)
 861       add_to_sig(result,", ",&currPos);
 862     if(IsClass(aArgVal) && IsPtr(aArgVal)) {
 863       add_to_sig(result,"*",&currPos);
 864     }
 865     if (IsString(aArgVal) && IsConst(aArgVal))
 866       sprintf(buf,"checkNullStr(myParam%d)",i);
 867     else
 868       sprintf(buf,"myParam%d",i);
 869     add_to_sig(result,buf,&currPos);
 870   }
 871   add_to_sig(result,");\n",&currPos);
 872   //if(IsString(aRetVal)) {
 873   //add_to_sig(result,"    myResult = (ret==NULL)?NULL:CORBA::string_dup(\"\");\n",&currPos);
 874   //}
 875   add_to_sig(result,"  }\n",&currPos);
 876
 877   add_to_sig(result,"};\n",&currPos);
 878   add_to_sig(result,"//\n",&currPos);
 879 #endif
 880   currPos_sig=currPos;
 881
 882 #if ! defined(IDL_I_CC)
 883   add_to_sig(result,"        ",&currPos);
 884 #endif
 885
 886   output_temp(result,&currPos,MAX_ARGS,aRetVal,
 887               currentFunction->ReturnValue->Class,0);
 888
 889 #if defined(IDL_I_CC)
 890   add_to_sig(result,data->Name,&currPos);
 891   add_to_sig(result,"_i::",&currPos);
 892 #endif
 893 #if ! defined(IDL_I_HH) && ! defined(IDL_I_CC)
 894   add_to_sig(result,"_",&currPos);
 895 #endif
 896   add_to_sig(result,currentFunction->Name,&currPos);
 897
 898   if( strlen(num)!=0 ) {
 899     add_to_sig(result,num,&currPos);
 900   }
 901   currPos_num=currPos;
 902   add_to_sig(result," ",&currPos);
 903
 904   /* print the arg list */
 905   add_to_sig(result,"(",&currPos);
 906
 907   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 908     aArgVal = currentFunction->Parameters[i];
 909     if( i != 0 ) {
 910       add_to_sig(result,", ",&currPos);
 911     }
 912     /*    output_temp(result, &currPos, i, currentFunction->ArgTypes[i],
 913                 (char*)currentFunction->ArgClasses[i],
 914                 currentFunction->ArgCounts[i]);*/
 915     output_temp(result, &currPos, i, aArgVal,  aArgVal->Class, vtkWrap_CountWrappedParameters(currentFunction));
 916   }
 917
 918   add_to_sig(result,")",&currPos);
 919 #if defined(IDL_I_CC)
 920   add_to_sig(result," {\n",&currPos);
 921   add_to_sig(result,"  try {\n",&currPos);
 922   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
 923     aArgVal = currentFunction->Parameters[i];
 924     if(IsClass(aArgVal)) {
 925       sprintf(buf,"    PARAVIS_Base_i* i_temp%d = GET_SERVANT(temp%d);\n",i,i);
 926       add_to_sig(result,buf,&currPos);
 927     }
 928
 929     if(IsArray(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal) && !IsVoid(aArgVal) ) {
 930       sprintf(buf,"    CORBA::ULong j_temp%d;\n",i);
 931       add_to_sig(result,buf,&currPos);
 932       sprintf(buf,"    CORBA::ULong l_temp%d = temp%d.length();\n",i,i);
 933       add_to_sig(result,buf,&currPos);
 934       add_to_sig(result,"    ",&currPos);
 935
 936       if(IsFloat(aArgVal))
 937         add_to_sig(result,"float",&currPos);
 938
 939       if(IsDouble(aArgVal))
 940         add_to_sig(result,"double",&currPos);
 941
 942       if(IsvtkIdType(aArgVal)) {
 943         if (IsUnsigned(aArgVal))
 944           add_to_sig(result,"unsigned ",&currPos);
 945         add_to_sig(result,"vtkIdType",&currPos);
 946       } else {
 947         if(IsShort(aArgVal)) {
 948           if (IsUnsigned(aArgVal))
 949             add_to_sig(result,"unsigned ",&currPos);
 950           add_to_sig(result,"int",&currPos);
 951         }
 952       }
 953
 954       if(IsLong(aArgVal)) {
 955         if (IsUnsigned(aArgVal))
 956           add_to_sig(result,"unsigned ",&currPos);
 957         add_to_sig(result,"long",&currPos);
 958       }
 959       sprintf(buf,"* a_temp%d = new ",i);
 960       add_to_sig(result,buf,&currPos);
 961
 962       if(IsFloat(aArgVal))
 963         add_to_sig(result,"float",&currPos);
 964
 965       if(IsDouble(aArgVal))
 966         add_to_sig(result,"double",&currPos);
 967
 968       if(IsvtkIdType(aArgVal)) {
 969         if (IsUnsigned(aArgVal))
 970           add_to_sig(result,"unsigned ",&currPos);
 971         add_to_sig(result,"vtkIdType",&currPos);
 972       } else {
 973         if(IsShort(aArgVal)) {
 974           if (IsUnsigned(aArgVal))
 975             add_to_sig(result,"unsigned ",&currPos);
 976           add_to_sig(result,"int",&currPos);
 977         }
 978       }
 979
 980       if(IsLong(aArgVal)) {
 981         if (IsUnsigned(aArgVal))
 982           add_to_sig(result,"unsigned ",&currPos);
 983         add_to_sig(result,"long",&currPos);
 984       }
 985
 986       sprintf(buf,"[l_temp%d];\n",i);
 987       add_to_sig(result,buf,&currPos);
 988
 989       sprintf(buf,"    for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
 990       add_to_sig(result,buf,&currPos);
 991
 992       sprintf(buf,"      a_temp%d[j_temp%d]=temp%d[j_temp%d];\n",i,i,i,i);
 993       add_to_sig(result,buf,&currPos);
 994
 995       add_to_sig(result,"    }\n",&currPos);
 996     }
 997
 998     if(IsString(aArgVal)) {
 999       sprintf(buf,"    char *c_temp%d = CORBA::string_dup(temp%d);\n",i,i);
1000       add_to_sig(result,buf,&currPos);
1001     }
1002
1003     if(IsVoid(aArgVal)) {
1004       sprintf(buf,"    long v_temp%d;\n",i);
1005       add_to_sig(result,buf,&currPos);
1006
1007       sprintf(buf,"    temp%d.operator>>=(v_temp%d);\n",i,i);
1008       add_to_sig(result,buf,&currPos);
1009     }
1010   }
1011   add_to_sig(result,"    ",&currPos);
1012
1013   if(IsArray(aRetVal) && !IsClass(aRetVal) && !IsString(aRetVal)) {
1014     add_to_sig(result,"CORBA::ULong i_ret;\n",&currPos);
1015     add_to_sig(result,"    PARAVIS::",&currPos);
1016     AddTypeArray(aRetVal,result,&currPos);
1017     add_to_sig(result,"_var s_ret = new ",&currPos);
1018     AddTypeArray(aRetVal,result,&currPos);
1019     add_to_sig(result,"();\n",&currPos);
1020     sprintf(buf,"    s_ret->length(%d);\n",currentFunction->HintSize);
1021     add_to_sig(result,buf,&currPos);
1022     add_to_sig(result,"    ",&currPos);
1023   }
1024
1025   if(IsArray(aRetVal) && IsUnsigned(aRetVal)) {
1026     add_to_sig(result,"unsigned ",&currPos);
1027   }
1028
1029   if(IsFloat(aRetVal)) {
1030     if(IsArray(aRetVal)) {
1031       add_to_sig(result,"float* a_ret = ",&currPos);
1032     } else {
1033       add_to_sig(result,"CORBA::Float ret = ",&currPos);
1034     }
1035   }
1036
1037   if(IsDouble(aRetVal)) {
1038     if(IsArray(aRetVal)) {
1039       add_to_sig(result,"double* a_ret = ",&currPos);
1040     } else {
1041       add_to_sig(result,"CORBA::Double ret = ",&currPos);
1042     }
1043   }
1044
1045   if(IsShort(aRetVal)) {
1046     if(IsArray(aRetVal)) {
1047       if(IsvtkIdType(aRetVal)) {
1048         add_to_sig(result,"vtkIdType",&currPos);
1049       } else {
1050         add_to_sig(result,"int",&currPos);
1051       }
1052       add_to_sig(result,"* a_ret = ",&currPos);
1053     } else {
1054       add_to_sig(result,"CORBA::Short ret = ",&currPos);
1055     }
1056   }
1057
1058   if(IsLong(aRetVal)) {
1059     if(IsArray(aRetVal)) {
1060       add_to_sig(result,"long* a_ret = ",&currPos);
1061     } else {
1062       add_to_sig(result,"CORBA::Long ret = ",&currPos);
1063     }
1064   }
1065
1066   //if(IsChar(aRetVal)) {
1067     if(IsString(aRetVal)) {
1068       add_to_sig(result,"char * ret = CORBA::string_dup(\"\");\n",&currPos);
1069       add_to_sig(result,"    const char * cret = ",&currPos);
1070     } else if (IsChar(aRetVal)) { //!!! vsv
1071       add_to_sig(result,"CORBA::Char ret = ",&currPos);
1072     }
1073     //}
1074
1075   if(IsBoolean(aRetVal)) {
1076     add_to_sig(result,"CORBA::Boolean ret = ",&currPos);
1077   }
1078
1079   if(IsVoidPtr(aRetVal)) {
1080     add_to_sig(result,"void * v_ret = ",&currPos);
1081   }
1082
1083   if(IsClass(aRetVal)) {
1084     add_to_sig(result,"::",&currPos);
1085     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1086     add_to_sig(result,"* a",&currPos);
1087     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1088     add_to_sig(result," = ",&currPos);
1089   }
1090   if(IsVoid(aRetVal)) {
1091     add_to_sig(result,"if(getVTKObject() != NULL) ProcessVoidEvent",&currPos);
1092   } else {
1093     add_to_sig(result,"(getVTKObject() != NULL) ? ProcessEvent",&currPos);
1094   }
1095   add_to_sig(result,"(\n",&currPos);
1096   add_to_sig(result,"      new CreateEventName(",&currPos);
1097   add_to_sig(result,currentFunction->Name,&currPos);
1098   if( strlen(num)!=0 ) {
1099     add_to_sig(result,num,&currPos);
1100   }
1101   add_to_sig(result,")",&currPos);
1102
1103   add_to_sig(result,"((::",&currPos);
1104   add_to_sig(result,data->Name,&currPos);
1105   add_to_sig(result,"*)",&currPos);
1106   add_to_sig(result,"getVTKObject()\n",&currPos);
1107
1108   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
1109     aArgVal = currentFunction->Parameters[i];
1110     add_to_sig(result,"      , ",&currPos);
1111
1112     //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1113     //add_to_sig(result,"*(",&currPos);
1114     //}
1115
1116     if(IsClass(aArgVal)) {
1117       //sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,currentFunction->ArgClasses[i],i);
1118       sprintf(buf,"(i_temp%d != NULL)?dynamic_cast< ::%s*>(i_temp%d->getVTKObject()):NULL",i,aArgVal->Class,i);
1119     } else {
1120       if(IsArray(aArgVal) && !IsString(aArgVal) && !IsVoid(aArgVal)) {
1121         sprintf(buf,"a_temp%d",i);
1122       } else {
1123         if(IsVoidPtr(aArgVal)) {
1124           sprintf(buf,"(void*)v_temp%d",i);
1125         } else {
1126           if(IsString(aArgVal)) {
1127             sprintf(buf,"c_temp%d",i);
1128           } else {
1129             sprintf(buf,"temp%d",i);
1130           }
1131         }
1132       }
1133     }
1134
1135     add_to_sig(result,buf,&currPos);
1136     //if(IsClass(currentFunction->ArgTypes[i]) && IsPtr(currentFunction->ArgTypes[i])) {
1137     //add_to_sig(result,")",&currPos);
1138     //}
1139     add_to_sig(result,"\n",&currPos);
1140   }
1141
1142   add_to_sig(result,"      )\n",&currPos);
1143   add_to_sig(result,"    )",&currPos);
1144   if(!IsVoid(aRetVal)) {
1145     add_to_sig(result,":",&currPos);
1146     if(IsClass(aRetVal) || IsString(aRetVal) || IsPtr(aRetVal) || IsArray(aRetVal))
1147       add_to_sig(result,"NULL",&currPos);
1148     else
1149       add_to_sig(result,"0",&currPos);
1150   }
1151   add_to_sig(result,";\n",&currPos);
1152   if(IsString(aRetVal)) {
1153     add_to_sig(result,"    if(cret!=NULL) ret=CORBA::string_dup(cret);\n",&currPos);
1154   }
1155
1156   if(IsClass(aRetVal)) {
1157     add_to_sig(result,"    if(a",&currPos);
1158     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1159     add_to_sig(result," == NULL) {\n",&currPos);
1160     add_to_sig(result,"      return PARAVIS::",&currPos);
1161     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1162     add_to_sig(result,"::_nil();\n",&currPos);
1163     add_to_sig(result,"    }\n",&currPos);
1164     add_to_sig(result,"    ",&currPos);
1165     add_to_sig(result,"PARAVIS_Base_i* aPtr = ::CreateInstance(a",&currPos);
1166     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1167     add_to_sig(result,", a",&currPos);
1168     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1169     add_to_sig(result,"->GetClassName());\n",&currPos);
1170     add_to_sig(result,"    aPtr->Init(a",&currPos);
1171     add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1172     add_to_sig(result,");\n",&currPos);
1173   }
1174
1175   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++) {
1176     aArgVal = currentFunction->Parameters[i];
1177     if(IsArray(aArgVal) && !IsVoid(aArgVal) && !IsString(aArgVal) && !IsClass(aArgVal)) {
1178       if (!IsIn(aArgVal)) {
1179         sprintf(buf,"    for(j_temp%d=0;j_temp%d<l_temp%d;j_temp%d++) {\n",i,i,i,i);
1180         add_to_sig(result,buf,&currPos);
1181
1182         sprintf(buf,"      temp%d[j_temp%d]=a_temp%d[j_temp%d];\n",i,i,i,i);
1183         add_to_sig(result,buf,&currPos);
1184
1185         add_to_sig(result,"    }\n",&currPos);
1186       }
1187       sprintf(buf,"    delete [] a_temp%d;\n",i);
1188       add_to_sig(result,buf,&currPos);
1189     }
1190   }
1191
1192   if (IsVoid(aRetVal) && !IsVoidPtr(aRetVal)) {
1193     add_to_sig(result,"    return;\n",&currPos);
1194   } else {
1195     if(IsClass(aRetVal)) {
1196       add_to_sig(result,"    return aPtr->_this();\n",&currPos);
1197     } else {
1198       if(IsVoid(aRetVal)) {
1199         add_to_sig(result,"    CORBA::Any* ret = new CORBA::Any;\n",&currPos);
1200         add_to_sig(result,"    (*ret) <<= v_ret;\n",&currPos);
1201         add_to_sig(result,"    return ret;\n",&currPos);
1202       } else {
1203         if(IsArray(aRetVal) && !IsString(aRetVal)) {
1204           sprintf(buf,"    for(i_ret=0; i_ret<%d; i_ret++) {\n",currentFunction->HintSize);
1205           add_to_sig(result,buf,&currPos);
1206           add_to_sig(result,"      s_ret[i_ret]=a_ret[i_ret];\n",&currPos);
1207           add_to_sig(result,"    }\n",&currPos);
1208           add_to_sig(result,"    return s_ret._retn();\n",&currPos);
1209         } else {
1210           add_to_sig(result,"    return ret;\n",&currPos);
1211         }
1212       }
1213     }
1214   }
1215
1216   add_to_sig(result,"  } catch(...) {\n",&currPos);
1217   add_to_sig(result,"    MESSAGE(\"",&currPos);
1218   //add_to_sig(result,data->ClassName,&currPos);
1219   //add_to_sig(result,"::",&currPos);
1220   add_to_sig(result,currentFunction->Name,&currPos);
1221   add_to_sig(result," - Unknown exception was occured!!!\");\n",&currPos);
1222
1223   if (IsVoid(aRetVal)&& !IsVoidPtr(aRetVal)) {
1224     add_to_sig(result,"    return;\n",&currPos);
1225   } else{
1226     if(IsString(aRetVal)) {
1227       add_to_sig(result,"    return CORBA::string_dup(\"\");\n",&currPos);
1228     } else {
1229       if(IsClass(aRetVal)) {
1230         add_to_sig(result,"    return PARAVIS::",&currPos);
1231         add_to_sig(result,currentFunction->ReturnValue->Class,&currPos);
1232         add_to_sig(result,"::_nil();\n",&currPos);
1233       } else {
1234         if(IsArray(aRetVal) && !IsVoid(aRetVal)) {
1235           add_to_sig(result,"    PARAVIS::",&currPos);
1236           AddTypeArray(aRetVal,result,&currPos);
1237           add_to_sig(result,"_var s_ret = new ",&currPos);
1238           AddTypeArray(aRetVal,result,&currPos);
1239           add_to_sig(result,"();\n",&currPos);
1240           sprintf(buf,"    s_ret->length(%d);\n",currentFunction->HintSize);
1241           add_to_sig(result,buf,&currPos);
1242           add_to_sig(result,"    return s_ret._retn();\n",&currPos);
1243         } else {
1244           add_to_sig(result,"    return 0;\n",&currPos);
1245         }
1246       }
1247     }
1248   }
1249
1250   add_to_sig(result,"  }\n",&currPos);
1251   add_to_sig(result,"}\n",&currPos);
1252 #else
1253   add_to_sig(result,";\n",&currPos);
1254 #endif
1255
1256   if(ret)
1257     {
1258       result[currPos_sig]='\0';
1259       /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1260         (size_t)(currPos_sig+1));*/
1261       cp = (char *)malloc(currPos_sig+1);
1262       strcpy(cp, result);
1263       currentFunction->Signature = cp;
1264       //strcpy((char*)currentFunction->Signature,result);
1265
1266       return;
1267     }
1268
1269   //if(strcmp(currentFunction->Name,"NewInstance") == 0) {
1270   //currentFunction->Signature[0]='\0';
1271   //return;
1272   //}
1273
1274   for(i = 0; i < numberOfReadFunctions; i++) {
1275     if(strcmp(readFunctions[i].Name,currentFunction->Name) == 0) {
1276       j=readFunctions[i].EndPos-readFunctions[i].NumPos;
1277       strncpy(buf,result+currPos_num,j);
1278       strncpy(buf1,readFunctions[i].Signature+readFunctions[i].NumPos,j);
1279       buf[j]=0;
1280       buf1[j]=0;
1281       if(strcmp(buf,buf1) == 0) {
1282         //((char*)currentFunction->Signature)[0]='\0';
1283         currentFunction->Signature = EmptyString;
1284         return;
1285       }
1286     }
1287   }
1288   /*currentFunction->Signature = (const char*)realloc((void*)currentFunction->Signature,
1289     (size_t)(currPos+1));*/
1290   //strcpy((char*)currentFunction->Signature, result);
1291   cp = (char *)malloc(currPos+1);
1292   strcpy(cp, result);
1293   currentFunction->Signature = cp;
1294 }
1295
1296 void outputFunction2(FILE *fp, ClassInfo *data)
1297 {
1298   int i, j, k, is_vtkobject, fnum, backnum;//, is_static, occ, goto_used;
1299   //int all_legacy;
1300   FunctionInfo *theFunc;
1301   FunctionInfo *backFunc;
1302   const char *theName;
1303   unsigned int theType;
1304   const char *backName;
1305   int backType;
1306   char static num[8];
1307   //int isSMObject = 0;
1308   int found = 0;
1309   ValueInfo* aArgVal = 0;
1310   ValueInfo* aBackArgVal = 0;
1311
1312
1313 #if defined(IDL_I_HH)
1314   fprintf(fp,"#include \"SALOMEconfig.h\"\n");
1315   fprintf(fp,"#include CORBA_SERVER_HEADER(PARAVIS_Gen_%s)\n",data->Name);
1316   fprintf(fp,"\n");
1317   fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1318   fprintf(fp,"#include \"PARAVIS_Gen_i.hh\"\n");
1319   fprintf(fp,"#include \"PARAVIS_Gen_Types.hh\"\n");
1320   fprintf(fp,"#include \"vtkSmartPointer.h\"\n");
1321   fprintf(fp,"#include \"SALOME_Event.h\"\n");
1322
1323   for(i=0;i<data->NumberOfSuperClasses;i++)
1324   {
1325     fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->SuperClasses[i]);
1326   }
1327
1328   fprintf(fp,"\nclass %s;\n",data->Name);
1329   fprintf(fp,"\nnamespace PARAVIS\n{\n\n");
1330 #elif defined(IDL_I_CC)
1331   fprintf(fp,"#include \"SALOME_GenericObj_i.hh\"\n");
1332   fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",data->Name);
1333   fprintf(fp,"#include \"PV_Tools.h\"\n");
1334   fprintf(fp,"#include \"SALOME_Event.h\"\n");
1335   fprintf(fp,"#include <%s.h>\n",data->Name);
1336 #else
1337   fprintf(fp,"#include \"PARAVIS_Gen.idl\"\n");
1338   fprintf(fp,"#include \"PARAVIS_Gen_Types.idl\"\n");
1339
1340   for(i=0;i<data->NumberOfSuperClasses;i++)
1341   {
1342     fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",data->SuperClasses[i]);
1343   }
1344
1345   fprintf(fp,"\nmodule PARAVIS\n{\n\n");
1346 #endif
1347
1348   is_vtkobject = ((strcmp(data->Name,"vtkObjectBase") == 0) ||
1349                   (data->NumberOfSuperClasses != 0));
1350
1351   for(i = 0; i < data->NumberOfSuperClasses; i++) {
1352     read_class_functions(data->SuperClasses[i],data->Name,fp);
1353   }
1354
1355   /* create a idl signature for each method */
1356   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1357     {
1358       theFunc = wrappedFunctions[fnum];
1359       currentFunction = theFunc;
1360       //printf("#### %i)Function %s\n", fnum, theFunc->Name);
1361
1362       /* names of idl methods should be unique */
1363       num[0]='\0';
1364       j=-1;
1365       for (i = 0; i < numberOfReadFunctions; i++) {
1366         if(strcmp(currentFunction->Name,readFunctions[i].Name) == 0)
1367           j++;
1368       }
1369       for (i = 0; i < fnum; i++)
1370         {
1371           if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) ==  0 )
1372             j++;
1373         }
1374
1375       if(j<0) {
1376         for (i = fnum+1; i < numberOfWrappedFunctions; i++) {
1377           if( strcmp(currentFunction->Name,wrappedFunctions[i]->Name) ==  0 ) {
1378             j=0;
1379             break;
1380           }
1381         }
1382       } else {
1383         j++;
1384       }
1385
1386       if(j>=0)
1387         {
1388           sprintf(num,"_%d",j);
1389         }
1390       get_signature(num,data);
1391     }
1392   /* create external type declarations for all object
1393      return types */
1394   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++)
1395     {
1396       theFunc = wrappedFunctions[fnum];
1397       currentFunction = theFunc;
1398       theName = NULL;
1399       theType = 0;
1400
1401       for (i = vtkWrap_CountWrappedParameters(theFunc); i >= 0; i--)
1402         {
1403           if (i==0)/* return type */
1404             {
1405               aArgVal = theFunc->ReturnValue;
1406               //theType = theFunc->ReturnType;
1407               //theName = (char*)theFunc->ReturnClass;
1408             }
1409           else /* arg type */
1410             {
1411               aArgVal = theFunc->Parameters[i-1];
1412               //theType = theFunc->ArgTypes[i-1];
1413               //theName = (char*)theFunc->ArgClasses[i-1];
1414             }
1415           theType = aArgVal->Type & VTK_PARSE_BASE_TYPE;
1416           theName = aArgVal->Class;
1417           /* check for object types */
1418           /*if ((theType & VTK_PARSE_BASE_TYPE == 0x309)||
1419             (theType & VTK_PARSE_BASE_TYPE == 0x109))*/
1420           if ((theType == VTK_PARSE_OBJECT) || (theType == VTK_PARSE_OBJECT_REF))
1421             {
1422               /* check that we haven't done this type (no duplicate declarations) */
1423               for (backnum = fnum; backnum >= 0; backnum--)
1424                 {
1425                   backFunc = wrappedFunctions[backnum];
1426                   backName = NULL;
1427                   backType = 0;
1428                   if (backnum == fnum)
1429                     k = i+1;
1430                   else
1431                     k = 0;
1432                   for (j = vtkWrap_CountWrappedParameters(backFunc); j >= k; j--)
1433                     {
1434                       if (j==0) /* return type */
1435                         {
1436                           aBackArgVal = backFunc->ReturnValue;
1437                           //backType = backFunc->ReturnType;
1438                           //backName = (char*)backFunc->ReturnClass;
1439                         }
1440                       else /* arg type */
1441                         {
1442                           aBackArgVal = backFunc->Parameters[j-1];
1443                           //backType = backFunc->ArgTypes[j-1];
1444                           //backName = (char*)backFunc->ArgClasses[j-1];
1445                         }
1446                       backType = aBackArgVal->Type & VTK_PARSE_BASE_TYPE;
1447                       backName = aBackArgVal->Class;
1448                       /*if (((backType % VTK_PARSE_BASE_TYPE == 0x309)||
1449                         (backType % VTK_PARSE_BASE_TYPE == 0x109)))*/
1450                       if ((backType == VTK_PARSE_OBJECT) || (backType == VTK_PARSE_OBJECT_REF))
1451                        {
1452                           if(strcmp(theName,backName) == 0)
1453                             {
1454                               break;
1455                             }
1456                         }
1457                     }
1458                   if (j >= k)
1459                     {
1460                       break;
1461                     }
1462                 }
1463               if (backnum < 0 && strcmp(data->Name,theName) != 0)
1464                 {
1465                   found = 0;
1466                   for(j = 0; strcmp(wrapped_classes[j],"") != 0 && found == 0; j++)
1467                     {
1468                       if(strcmp(wrapped_classes[j],theName) == 0)
1469                         found = 1;
1470                     }
1471                   if(found)
1472                     {
1473 #if defined(IDL_I_HH)
1474                       fprintf(fp,"    class %s_i;\n",theName);
1475 #elif defined(IDL_I_CC)
1476                       fprintf(fp,"#include \"PARAVIS_Gen_%s_i.hh\"\n",theName);
1477                       fprintf(fp,"#include <%s.h>\n",theName);
1478 #else
1479                       //fprintf(fp,"#include \"PARAVIS_Gen_%s.idl\"\n",theName);
1480                       fprintf(fp,"    interface %s;\n",theName);
1481 #endif
1482                     }
1483                 }
1484             }
1485         }
1486     }
1487
1488   //fprintf(fp,"\nmodule PARAVIS\n{\n");
1489 #if defined(IDL_I_HH)
1490   fprintf(fp,"\n    class %s_i : public virtual POA_PARAVIS::%s, public virtual PARAVIS::PARAVIS_Base_i",data->Name,data->Name);
1491   //for(i = 0; i < data->NumberOfSuperClasses; i++) {
1492   //  fprintf(fp,", public virtual %s_i",data->SuperClasses[i]);
1493   //}
1494   //fprintf(fp,", public virtual SALOME::GenericObj_i");
1495   fprintf(fp," {");
1496   fprintf(fp,"\n    public:\n");
1497   fprintf(fp,"\n        %s_i();\n",data->Name);
1498   if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1499     fprintf(fp,"\n        ::vtkObjectBase* GetNew();\n");
1500   }
1501
1502 #elif defined(IDL_I_CC)
1503   fprintf(fp,"extern PARAVIS::PARAVIS_Base_i* CreateInstance(::vtkObjectBase* Inst, const QString&);\n");
1504   fprintf(fp,"\nnamespace PARAVIS\n{\n");
1505   fprintf(fp,"typedef %s_i current_interface;\n",data->Name);
1506   fprintf(fp,"#define CreateEventName(Function) Event%s ##Function\n",data->Name);
1507   fprintf(fp,"%s_i::%s_i() {\n",data->Name,data->Name);
1508   //fprintf(fp,"    Init(::%s::New());\n",data->Name);
1509   fprintf(fp,"}\n");
1510   fprintf(fp,"\n");
1511
1512   if(strcmp(data->Name,"vtkSMSessionProxyManager") != 0) {
1513     fprintf(fp,"::vtkObjectBase* %s_i::GetNew() {\n", data->Name);
1514     if(strcmp(data->Name,"vtkSMProxyManager") == 0) {
1515       fprintf(fp,"  return ::%s::GetProxyManager();\n",data->Name);
1516     } else {
1517       fprintf(fp,"  return ::%s::New();\n",data->Name);
1518     }
1519     fprintf(fp,"}\n");
1520   }
1521 #else
1522   fprintf(fp,"\n    interface %s : PARAVIS_Base",data->Name);
1523   fprintf(fp,"\n    {\n");
1524 #endif
1525
1526   for(i = 0; i < numberOfReadFunctions; i++) {
1527     fprintf(fp, "%s\n", readFunctions[i].Signature);
1528   }
1529
1530   for (fnum = 0; fnum < numberOfWrappedFunctions; fnum++) {
1531     fprintf(fp,"%s\n",wrappedFunctions[fnum]->Signature);
1532   }
1533
1534 #if defined(IDL_I_HH)
1535   fprintf(fp,"    };\n");
1536   fprintf(fp,"}\n");
1537 #elif defined(IDL_I_CC)
1538   fprintf(fp,"};\n");
1539 #else
1540   fprintf(fp,"    };\n");
1541   fprintf(fp,"};\n");
1542 #endif
1543
1544   return;
1545 }
1546
1547 void outputFunction(FILE *fp, ClassInfo *data)
1548 {
1549   int i;
1550   //int args_ok = 1;
1551   ValueInfo* aRetVal = NULL;//currentFunction->ReturnValue;
1552   ValueInfo* aArgVal = NULL;
1553   unsigned int aType;
1554   unsigned int argtype;
1555
1556   fp = fp;
1557   /* some functions will not get wrapped no matter what else,
1558      and some really common functions will appear only in vtkObjectPython */
1559   if (currentFunction->IsOperator ||
1560       currentFunction->ArrayFailure ||
1561       !currentFunction->IsPublic ||
1562       !currentFunction->Name)
1563     {
1564       return;
1565     }
1566   //printf("#### Check %s\n", currentFunction->Name);
1567
1568   /* check to see if we can handle the args */
1569   for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++)
1570     {
1571       aArgVal = currentFunction->Parameters[i];
1572       /*printf("  Argument: %s ", vtkWrap_GetTypeName(aArgVal));
1573       if (vtkWrap_IsArray(aArgVal)) {
1574         printf("!!!! Argument %i is array\n", i);
1575         return;
1576         }*/
1577       if (vtkWrap_IsStream(aArgVal)) {
1578         //printf("!!!! Argument %i is stream\n", i);
1579         return;
1580       }
1581       if (IsPtr(aArgVal)) {
1582         //printf("!!!! Argument %i is pointer value\n", i);
1583         return;
1584       }
1585       if (IsUnknown(aArgVal)) {
1586         //printf("!!!! Argument %i is unknown value\n", i);
1587        return;
1588       }
1589       if (vtkWrap_IsVoidPointer(aArgVal)) {
1590         //printf("!!!! Argument %i is void pointer\n", i);
1591         return;
1592       }
1593       if (vtkWrap_IsVoidFunction(aArgVal)) {
1594         //printf("!!!! Argument %i is void function\n", i);
1595         return;
1596       }
1597       argtype = (aArgVal->Type & VTK_PARSE_INDIRECT);
1598       if (argtype == VTK_PARSE_POINTER_POINTER){
1599         //printf("!!!! Argument %i is pointer to pointer\n", i);
1600         return;
1601       }
1602       if (vtkWrap_IsNonConstRef(aArgVal)) {
1603         //printf("!!!! Argument %i is non const ref\n", i);
1604         return;
1605       }
1606       if (vtkWrap_IsSpecialObject(aArgVal)) {
1607         //printf("!!!! Argument %i is special object\n", i);
1608         return;
1609       }
1610       /*if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 9) args_ok = 0;
1611       if ((currentFunction->ArgTypes[i] % 0x10) == 8) args_ok = 0;
1612       if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1613           (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x109)&&
1614           ((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1615       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1616       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1617       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1618       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1619       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1620       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1621       if (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;*/
1622     }
1623   aRetVal = currentFunction->ReturnValue;
1624   if (aRetVal) {
1625     //printf("#### Return type: %s\n", vtkWrap_GetTypeName(aRetVal));
1626     aType = aRetVal->Type & VTK_PARSE_BASE_TYPE;
1627     if (IsPtr(aRetVal)) {
1628       //printf("!!!! Return Value is pointer\n");
1629       return;
1630     }
1631     /* eliminate unsigned char * and unsigned short * */
1632     argtype = (aRetVal->Type & VTK_PARSE_UNQUALIFIED_TYPE);
1633     if ((argtype == VTK_PARSE_UNSIGNED_CHAR_PTR) || (argtype == VTK_PARSE_UNSIGNED_SHORT)) {
1634       //printf("!!!! Return Value is unsigned char or short\n");
1635       return;
1636     }
1637
1638     if ((aType == VTK_PARSE_UNKNOWN)) {
1639       //printf("!!!! Return Value is unknown\n");
1640       return;
1641     }
1642     argtype = (aRetVal->Type & VTK_PARSE_INDIRECT);
1643     if (argtype == VTK_PARSE_POINTER_POINTER){
1644       //printf("!!!! Return value is pointer to pointer\n", i);
1645       return;
1646     }
1647     if (vtkWrap_IsSpecialObject(aRetVal)) {
1648       //printf("!!!! Return is special object\n", i);
1649       return;
1650     }
1651   }
1652   /*if ((aRetVal % 0x10) == 0x8) args_ok = 0;
1653   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x9) args_ok = 0;
1654   if (((aRetVal % VTK_PARSE_BASE_TYPE)/0x100 != 0x3)&&
1655       (aRetVal % VTK_PARSE_BASE_TYPE != 0x109)&&
1656       ((aRetVal % VTK_PARSE_BASE_TYPE)/0x100)) args_ok = 0;
1657   */
1658
1659   /*if (aRetVal % VTK_PARSE_BASE_TYPE == 0x313) args_ok = 0;
1660   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x314) args_ok = 0;
1661   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31A) args_ok = 0;
1662   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31B) args_ok = 0;
1663   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x31C) args_ok = 0;
1664   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x315) args_ok = 0;
1665   if (aRetVal % VTK_PARSE_BASE_TYPE == 0x316) args_ok = 0;
1666
1667
1668   if (vtkWrap_CountWrappedParameters(currentFunction) &&
1669       (currentFunction->ArgTypes[0] == 0x5000)
1670       &&(vtkWrap_CountWrappedParameters(currentFunction) != 0x1)) args_ok = 0;*/
1671
1672   /* make sure we have all the info we need for array arguments in */
1673   /*for (i = 0; i < vtkWrap_CountWrappedParameters(currentFunction); i++)
1674     {
1675     if (((currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE)/0x100 == 0x3)&&
1676         (currentFunction->ArgCounts[i] <= 0)&&
1677         (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x309)&&
1678         (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x303)&&
1679         (currentFunction->ArgTypes[i] % VTK_PARSE_BASE_TYPE != 0x302)) args_ok = 0;
1680         }*/
1681
1682   /* if we need a return type hint make sure we have one */
1683   //switch (aRetVal % VTK_PARSE_BASE_TYPE)
1684   /*switch (aRetVal->Type % VTK_PARSE_BASE_TYPE)
1685     {
1686     case 0x301: case 0x307: case 0x30A: case 0x30B: case 0x30C: case 0x30D: case 0x30E:
1687     case 0x304: case 0x305: case 0x306:
1688       args_ok = currentFunction->HaveHint;
1689       break;
1690       }*/
1691
1692   /* make sure it isn't a Delete or New function */
1693   if (!strcmp("Delete",currentFunction->Name) ||
1694       !strcmp("New",currentFunction->Name))
1695     {
1696       return;
1697     }
1698
1699   if (vtkWrap_IsDestructor(data, currentFunction) || vtkWrap_IsConstructor(data, currentFunction)) {
1700     //printf("!!!! Return Value is constructor or destructor\n");
1701     return;
1702   }
1703
1704   /* check for New() function */
1705   if (!strcmp("New",currentFunction->Name) && vtkWrap_CountWrappedParameters(currentFunction) == 0)
1706     {
1707       class_has_new = 1;
1708     }
1709
1710   if (currentFunction->IsPublic && //args_ok &&
1711       strcmp(data->Name,currentFunction->Name) &&
1712       strcmp(data->Name, currentFunction->Name + 1))
1713     {
1714       //printf("#### %i Function %s\n", numberOfWrappedFunctions, currentFunction->Name);
1715       wrappedFunctions[numberOfWrappedFunctions] = currentFunction;
1716       numberOfWrappedFunctions++;
1717     }
1718
1719   return;
1720 }
1721
1722 /* print the parsed structures */
1723 int main(int argc, char *argv[])
1724 {
1725   OptionInfo *options;
1726   FileInfo *file_info;
1727   ClassInfo *data;
1728   FILE *fp;
1729   int i;
1730
1731   /* get command-line args and parse the header file */
1732   file_info = vtkParse_Main(argc, argv);
1733
1734   /* get the command-line options */
1735   options = vtkParse_GetCommandLineOptions();
1736
1737   /* get the output file */
1738   fp = fopen(options->OutputFileName, "w");
1739
1740   if (!fp)
1741     {
1742     fprintf(stderr, "Error opening output file %s\n", options->OutputFileName);
1743     exit(1);
1744     }
1745
1746   /* get the main class */
1747   if ((data = file_info->MainClass) == NULL)
1748     {
1749     fclose(fp);
1750     exit(0);
1751     }
1752
1753   /* get the hierarchy info for accurate typing */
1754   if (options->HierarchyFileName)
1755     {
1756     hierarchyInfo = vtkParseHierarchy_ReadFile(options->HierarchyFileName);
1757     }
1758
1759 #if defined(IDL_I_HH)
1760   fprintf(fp, "// idl wrapper interface for %s object implementation\n//\n", data->Name);
1761 #elif defined(IDL_I_CC)
1762   fprintf(fp, "// idl wrapper implementation for %s object\n//\n", data->Name);
1763 #else
1764   fprintf(fp, "// idl wrapper for %s object\n//\n", data->Name);
1765 #endif
1766   for (i = 0;1;i++)
1767     {
1768       if(strlen(Copyright[i]) != 0)
1769         {
1770           fprintf(fp,"%s\n",Copyright[i]);
1771         }
1772       else
1773         {
1774           break;
1775         }
1776     }
1777   fprintf(fp,"\n");
1778 #if defined(IDL_I_HH)
1779   fprintf(fp,"#ifndef PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1780   fprintf(fp,"#define PARAVIS_Gen_%s_i_HeaderFile\n",data->Name);
1781   fprintf(fp,"\n");
1782 #elif defined(IDL_I_CC)
1783 #else
1784   fprintf(fp,"#ifndef __PARAVIS_Gen_%s__\n",data->Name);
1785   fprintf(fp,"#define __PARAVIS_Gen_%s__\n",data->Name);
1786   fprintf(fp,"\n");
1787 #endif
1788
1789   /* insert function handling code here */
1790   for (i = 0; i < data->NumberOfFunctions; i++)
1791     {
1792       currentFunction = data->Functions[i];
1793 #ifdef VTK_LEGACY_REMOVE
1794       if(currentFunction->IsLegacy)
1795         continue;
1796 #endif
1797       outputFunction(fp, data);
1798     }
1799   //printf("#### NbFunctions %i\n", numberOfWrappedFunctions);
1800   //if (data->NumberOfSuperClasses || (!data->IsAbstract))
1801   //if (numberOfWrappedFunctions)
1802   // {
1803       outputFunction2(fp, data);
1804       // }
1805
1806 #if defined(IDL_I_HH)
1807   fprintf(fp,"\n#endif\n");
1808 #elif defined(IDL_I_CC)
1809 #else
1810   fprintf(fp,"\n#endif\n");
1811 #endif
1812
1813   vtkParse_Free(file_info);
1814
1815   return 0;
1816 }