idl/vtkWrapIDL.c

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