libyaz4j/typemaps.txt

   1 Swigging the Zoom Headers
   2 ---[ typemaps ]--------------------------------------------------------------
   3 ::: scope 0
   4
   5 Hash {
   6     'jdouble' : Hash {
   7         'tmap:jstype' : Hash {
   8             'typemap' : typemap(jstype) jdouble,
   9             'code' : double,
  10             'type' : jdouble,
  11         }
  12 ,
  13         'tmap:directorin' : Hash {
  14             'kwargs' : Hash {
  15                 'name' : descriptor,
  16                 'value' : D,
  17             }
  18 ,
  19             'typemap' : typemap(directorin) jdouble,
  20             'code' : $input = $1;,
  21             'type' : jdouble,
  22         }
  23 ,
  24         'tmap:javadirectorin' : Hash {
  25             'typemap' : typemap(javadirectorin) jdouble,
  26             'code' : $jniinput,
  27             'type' : jdouble,
  28         }
  29 ,
  30         'tmap:in' : Hash {
  31             'kwargs' : Hash {
  32                 'name' : numinputs,
  33                 'value' : 1,
  34             }
  35 ,
  36             'typemap' : typemap(in) jdouble,
  37             'code' :  $1 = $input; ,
  38             'type' : jdouble,
  39         }
  40 ,
  41         'tmap:directorout' : Hash {
  42             'typemap' : typemap(directorout) jdouble,
  43             'code' :  $result = $input; ,
  44             'type' : jdouble,
  45         }
  46 ,
  47         'tmap:javadirectorout' : Hash {
  48             'typemap' : typemap(javadirectorout) jdouble,
  49             'code' : $javacall,
  50             'type' : jdouble,
  51         }
  52 ,
  53         'tmap:jni' : Hash {
  54             'typemap' : typemap(jni) jdouble,
  55             'code' : jdouble,
  56             'type' : jdouble,
  57         }
  58 ,
  59         'tmap:jtype' : Hash {
  60             'typemap' : typemap(jtype) jdouble,
  61             'code' : double,
  62             'type' : jdouble,
  63         }
  64 ,
  65         'tmap:out' : Hash {
  66             'typemap' : typemap(out) jdouble,
  67             'code' :  $result = $1; ,
  68             'type' : jdouble,
  69         }
  70 ,
  71         'tmap:typecheck' : Hash {
  72             'kwargs' : Hash {
  73                 'name' : precedence,
  74                 'value' : 90,
  75             }
  76 ,
  77             'typemap' : typemap(typecheck) jdouble,
  78             'code' : ,
  79             'type' : jdouble,
  80         }
  81 ,
  82         'tmap:javain' : Hash {
  83             'typemap' : typemap(javain) jdouble,
  84             'code' : $javainput,
  85             'type' : jdouble,
  86         }
  87 ,
  88         'tmap:javaout' : Hash {
  89             'typemap' : typemap(javaout) jdouble,
  90             'code' : {
  91     return $jnicall;
  92   },
  93             'type' : jdouble,
  94         }
  95 ,
  96     }
  97 ,
  98     'r.q(const).double' : Hash {
  99         'tmap:jstype' : Hash {
 100             'typemap' : typemap(jstype) double const &,
 101             'code' : double,
 102             'type' : r.q(const).double,
 103         }
 104 ,
 105         'tmap:directorin' : Hash {
 106             'kwargs' : Hash {
 107                 'name' : descriptor,
 108                 'value' : D,
 109             }
 110 ,
 111             'typemap' : typemap(directorin) double const &,
 112             'code' : $input = (jdouble)$1_name;,
 113             'type' : r.q(const).double,
 114         }
 115 ,
 116         'tmap:javadirectorin' : Hash {
 117             'locals' : Hash {
 118                 'name' : temp,
 119                 'type' : $*1_ltype,
 120             }
 121 ,
 122             'typemap' : typemap(javadirectorin) double const &,
 123             'code' : $jniinput,
 124             'type' : r.q(const).double,
 125         }
 126 ,
 127         'tmap:in' : Hash {
 128             'locals' : Hash {
 129                 'name' : temp,
 130                 'type' : $*1_ltype,
 131             }
 132 ,
 133             'kwargs' : Hash {
 134                 'name' : numinputs,
 135                 'value' : 1,
 136             }
 137 ,
 138             'typemap' : typemap(in) double const &,
 139             'code' :  temp = ($*1_ltype)$input;
 140    $1 = &temp; ,
 141             'type' : r.q(const).double,
 142         }
 143 ,
 144         'tmap:directorout' : Hash {
 145             'kwargs' : Hash {
 146                 'name' : warning,
 147                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
 148             }
 149 ,
 150             'typemap' : typemap(directorout) double const &,
 151             'code' :  static $*1_ltype temp;
 152    temp = ($*1_ltype)$input;
 153    $result = &temp; ,
 154             'type' : r.q(const).double,
 155         }
 156 ,
 157         'tmap:javadirectorout' : Hash {
 158             'locals' : Hash {
 159                 'name' : temp,
 160                 'type' : $*1_ltype,
 161             }
 162 ,
 163             'typemap' : typemap(javadirectorout) double const &,
 164             'code' : $javacall,
 165             'type' : r.q(const).double,
 166         }
 167 ,
 168         'tmap:jni' : Hash {
 169             'typemap' : typemap(jni) double const &,
 170             'code' : jdouble,
 171             'type' : r.q(const).double,
 172         }
 173 ,
 174         'tmap:jtype' : Hash {
 175             'typemap' : typemap(jtype) double const &,
 176             'code' : double,
 177             'type' : r.q(const).double,
 178         }
 179 ,
 180         'tmap:out' : Hash {
 181             'typemap' : typemap(out) double const &,
 182             'code' :  $result = (jdouble)*$1; ,
 183             'type' : r.q(const).double,
 184         }
 185 ,
 186         'tmap:typecheck' : Hash {
 187             'kwargs' : Hash {
 188                 'name' : precedence,
 189                 'value' : 90,
 190             }
 191 ,
 192             'typemap' : typemap(typecheck) double const &,
 193             'code' : ,
 194             'type' : r.q(const).double,
 195         }
 196 ,
 197         'tmap:javain' : Hash {
 198             'typemap' : typemap(javain) double const &,
 199             'code' : $javainput,
 200             'type' : r.q(const).double,
 201         }
 202 ,
 203         'tmap:javaout' : Hash {
 204             'typemap' : typemap(javaout) double const &,
 205             'code' : {
 206     return $jnicall;
 207   },
 208             'type' : r.q(const).double,
 209         }
 210 ,
 211     }
 212 ,
 213     'double' : Hash {
 214         'tmap:jstype' : Hash {
 215             'typemap' : typemap(jstype) double,
 216             'code' : double,
 217             'type' : double,
 218         }
 219 ,
 220         'tmap:directorin' : Hash {
 221             'kwargs' : Hash {
 222                 'name' : descriptor,
 223                 'value' : D,
 224             }
 225 ,
 226             'typemap' : typemap(directorin) double,
 227             'code' : $input = (jdouble) $1;,
 228             'type' : double,
 229         }
 230 ,
 231         'tmap:javadirectorin' : Hash {
 232             'typemap' : typemap(javadirectorin) double,
 233             'code' : $jniinput,
 234             'type' : double,
 235         }
 236 ,
 237         'tmap:in' : Hash {
 238             'kwargs' : Hash {
 239                 'name' : numinputs,
 240                 'value' : 1,
 241             }
 242 ,
 243             'typemap' : typemap(in) double,
 244             'code' :  $1 = ($1_ltype)$input; ,
 245             'type' : double,
 246         }
 247 ,
 248         'tmap:directorout' : Hash {
 249             'typemap' : typemap(directorout) double,
 250             'code' :  $result = ($1_ltype)$input; ,
 251             'type' : double,
 252         }
 253 ,
 254         'tmap:javadirectorout' : Hash {
 255             'typemap' : typemap(javadirectorout) double,
 256             'code' : $javacall,
 257             'type' : double,
 258         }
 259 ,
 260         'tmap:jni' : Hash {
 261             'typemap' : typemap(jni) double,
 262             'code' : jdouble,
 263             'type' : double,
 264         }
 265 ,
 266         'tmap:jtype' : Hash {
 267             'typemap' : typemap(jtype) double,
 268             'code' : double,
 269             'type' : double,
 270         }
 271 ,
 272         'tmap:out' : Hash {
 273             'typemap' : typemap(out) double,
 274             'code' :  $result = (jdouble)$1; ,
 275             'type' : double,
 276         }
 277 ,
 278         'tmap:typecheck' : Hash {
 279             'kwargs' : Hash {
 280                 'name' : precedence,
 281                 'value' : 90,
 282             }
 283 ,
 284             'typemap' : typemap(typecheck) double,
 285             'code' : ,
 286             'type' : double,
 287         }
 288 ,
 289         'tmap:javain' : Hash {
 290             'typemap' : typemap(javain) double,
 291             'code' : $javainput,
 292             'type' : double,
 293         }
 294 ,
 295         'tmap:javaout' : Hash {
 296             'typemap' : typemap(javaout) double,
 297             'code' : {
 298     return $jnicall;
 299   },
 300             'type' : double,
 301         }
 302 ,
 303     }
 304 ,
 305     'p.double' : Hash {
 306         'INOUT' : Hash {
 307             'tmap:freearg' : Hash {
 308                 'pname' : INOUT,
 309                 'typemap' : typemap(freearg) double *INOUT,
 310                 'code' : ,
 311                 'type' : p.double,
 312             }
 313 ,
 314             'tmap:jstype' : Hash {
 315                 'pname' : INOUT,
 316                 'typemap' : typemap(jstype) double *INOUT,
 317                 'code' : double[],
 318                 'type' : p.double,
 319             }
 320 ,
 321             'tmap:javadirectorin' : Hash {
 322                 'pname' : INOUT,
 323                 'typemap' : typemap(javadirectorin) double *INOUT,
 324                 'code' : $jniinput,
 325                 'type' : p.double,
 326             }
 327 ,
 328             'tmap:directorin' : Hash {
 329                 'kwargs' : Hash {
 330                     'name' : descriptor,
 331                     'value' : [Ljava/lang/Double;,
 332                     'nextSibling' : Hash {
 333                         'name' : warning,
 334                         'value' : Need to provide double *INOUT directorin typemap, double array length is unknown,
 335                     }
 336 ,
 337                 }
 338 ,
 339                 'pname' : INOUT,
 340                 'typemap' : typemap(directorin) double *INOUT,
 341                 'code' : {
 342 },
 343                 'type' : p.double,
 344             }
 345 ,
 346             'tmap:argout' : Hash {
 347                 'pname' : INOUT,
 348                 'typemap' : typemap(argout) double *INOUT,
 349                 'code' : { jenv->ReleaseDoubleArrayElements($input, (jdouble *)$1, 0); },
 350                 'type' : p.double,
 351             }
 352 ,
 353             'tmap:javadirectorout' : Hash {
 354                 'pname' : INOUT,
 355                 'typemap' : typemap(javadirectorout) double *INOUT,
 356                 'code' : $javacall,
 357                 'type' : p.double,
 358             }
 359 ,
 360             'tmap:in' : Hash {
 361                 'kwargs' : Hash {
 362                     'name' : numinputs,
 363                     'value' : 1,
 364                 }
 365 ,
 366                 'pname' : INOUT,
 367                 'typemap' : typemap(in) double *INOUT,
 368                 'code' : {
 369   if (!$input) {
 370     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
 371     return $null;
 372   }
 373   if (jenv->GetArrayLength($input) == 0) {
 374     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
 375     return $null;
 376   }
 377   $1 = ($1_ltype) jenv->GetDoubleArrayElements($input, 0);
 378 },
 379                 'type' : p.double,
 380             }
 381 ,
 382             'tmap:directorout' : Hash {
 383                 'kwargs' : Hash {
 384                     'name' : warning,
 385                     'value' : Need to provide double *INOUT directorout typemap,
 386                 }
 387 ,
 388                 'pname' : INOUT,
 389                 'typemap' : typemap(directorout) double *INOUT,
 390                 'code' : {
 391 },
 392                 'type' : p.double,
 393             }
 394 ,
 395             'tmap:typecheck' : Hash {
 396                 'kwargs' : Hash {
 397                     'name' : precedence,
 398                     'value' : 1090,
 399                 }
 400 ,
 401                 'pname' : INOUT,
 402                 'typemap' : typemap(typecheck) double *INOUT,
 403                 'code' : ,
 404                 'type' : p.double,
 405             }
 406 ,
 407             'tmap:jni' : Hash {
 408                 'pname' : INOUT,
 409                 'typemap' : typemap(jni) double *INOUT,
 410                 'code' : jdoubleArray,
 411                 'type' : p.double,
 412             }
 413 ,
 414             'tmap:jtype' : Hash {
 415                 'pname' : INOUT,
 416                 'typemap' : typemap(jtype) double *INOUT,
 417                 'code' : double[],
 418                 'type' : p.double,
 419             }
 420 ,
 421             'tmap:javain' : Hash {
 422                 'pname' : INOUT,
 423                 'typemap' : typemap(javain) double *INOUT,
 424                 'code' : $javainput,
 425                 'type' : p.double,
 426             }
 427 ,
 428         }
 429 ,
 430         'INPUT' : Hash {
 431             'tmap:freearg' : Hash {
 432                 'pname' : INPUT,
 433                 'typemap' : typemap(freearg) double *INPUT,
 434                 'code' : ,
 435                 'type' : p.double,
 436             }
 437 ,
 438             'tmap:jstype' : Hash {
 439                 'pname' : INPUT,
 440                 'typemap' : typemap(jstype) double *INPUT,
 441                 'code' : double,
 442                 'type' : p.double,
 443             }
 444 ,
 445             'tmap:javadirectorin' : Hash {
 446                 'pname' : INPUT,
 447                 'typemap' : typemap(javadirectorin) double *INPUT,
 448                 'code' : $jniinput,
 449                 'type' : p.double,
 450             }
 451 ,
 452             'tmap:directorin' : Hash {
 453                 'kwargs' : Hash {
 454                     'name' : descriptor,
 455                     'value' : D,
 456                 }
 457 ,
 458                 'pname' : INPUT,
 459                 'typemap' : typemap(directorin) double *INPUT,
 460                 'code' :  *(($&1_ltype) $input) = (jdouble *) $1; ,
 461                 'type' : p.double,
 462             }
 463 ,
 464             'tmap:javadirectorout' : Hash {
 465                 'pname' : INPUT,
 466                 'typemap' : typemap(javadirectorout) double *INPUT,
 467                 'code' : $javacall,
 468                 'type' : p.double,
 469             }
 470 ,
 471             'tmap:in' : Hash {
 472                 'kwargs' : Hash {
 473                     'name' : numinputs,
 474                     'value' : 1,
 475                 }
 476 ,
 477                 'pname' : INPUT,
 478                 'typemap' : typemap(in) double *INPUT,
 479                 'code' :  $1 = ($1_ltype)&$input; ,
 480                 'type' : p.double,
 481             }
 482 ,
 483             'tmap:directorout' : Hash {
 484                 'pname' : INPUT,
 485                 'typemap' : typemap(directorout) double *INPUT,
 486                 'code' :  $result = ($1_ltype)&$input; ,
 487                 'type' : p.double,
 488             }
 489 ,
 490             'tmap:jni' : Hash {
 491                 'pname' : INPUT,
 492                 'typemap' : typemap(jni) double *INPUT,
 493                 'code' : jdouble,
 494                 'type' : p.double,
 495             }
 496 ,
 497             'tmap:jtype' : Hash {
 498                 'pname' : INPUT,
 499                 'typemap' : typemap(jtype) double *INPUT,
 500                 'code' : double,
 501                 'type' : p.double,
 502             }
 503 ,
 504             'tmap:javain' : Hash {
 505                 'pname' : INPUT,
 506                 'typemap' : typemap(javain) double *INPUT,
 507                 'code' : $javainput,
 508                 'type' : p.double,
 509             }
 510 ,
 511             'tmap:typecheck' : Hash {
 512                 'kwargs' : Hash {
 513                     'name' : precedence,
 514                     'value' : 90,
 515                 }
 516 ,
 517                 'pname' : INPUT,
 518                 'typemap' : typemap(typecheck) double *INPUT,
 519                 'code' : ,
 520                 'type' : p.double,
 521             }
 522 ,
 523         }
 524 ,
 525         'OUTPUT' : Hash {
 526             'tmap:freearg' : Hash {
 527                 'pname' : OUTPUT,
 528                 'typemap' : typemap(freearg) double *OUTPUT,
 529                 'code' : ,
 530                 'type' : p.double,
 531             }
 532 ,
 533             'tmap:jstype' : Hash {
 534                 'pname' : OUTPUT,
 535                 'typemap' : typemap(jstype) double *OUTPUT,
 536                 'code' : double[],
 537                 'type' : p.double,
 538             }
 539 ,
 540             'tmap:javadirectorin' : Hash {
 541                 'pname' : OUTPUT,
 542                 'typemap' : typemap(javadirectorin) double *OUTPUT,
 543                 'code' : $jniinput,
 544                 'type' : p.double,
 545             }
 546 ,
 547             'tmap:directorin' : Hash {
 548                 'kwargs' : Hash {
 549                     'name' : descriptor,
 550                     'value' : [Ljava/lang/Double;,
 551                     'nextSibling' : Hash {
 552                         'name' : warning,
 553                         'value' : Need to provide double *OUTPUT directorin typemap, double array length is unknown,
 554                     }
 555 ,
 556                 }
 557 ,
 558                 'pname' : OUTPUT,
 559                 'typemap' : typemap(directorin) double *OUTPUT,
 560                 'code' : {
 561 },
 562                 'type' : p.double,
 563             }
 564 ,
 565             'tmap:argout' : Hash {
 566                 'pname' : OUTPUT,
 567                 'typemap' : typemap(argout) double *OUTPUT,
 568                 'code' : {
 569   jdouble jvalue = (jdouble)temp$argnum;
 570   jenv->SetDoubleArrayRegion($input, 0, 1, &jvalue);
 571 },
 572                 'type' : p.double,
 573             }
 574 ,
 575             'tmap:javadirectorout' : Hash {
 576                 'pname' : OUTPUT,
 577                 'typemap' : typemap(javadirectorout) double *OUTPUT,
 578                 'code' : $javacall,
 579                 'type' : p.double,
 580             }
 581 ,
 582             'tmap:in' : Hash {
 583                 'locals' : Hash {
 584                     'name' : temp,
 585                     'type' : $*1_ltype,
 586                 }
 587 ,
 588                 'kwargs' : Hash {
 589                     'name' : numinputs,
 590                     'value' : 1,
 591                 }
 592 ,
 593                 'pname' : OUTPUT,
 594                 'typemap' : typemap(in) double *OUTPUT,
 595                 'code' : {
 596   if (!$input) {
 597     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
 598     return $null;
 599   }
 600   if (jenv->GetArrayLength($input) == 0) {
 601     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
 602     return $null;
 603   }
 604   $1 = &temp;
 605 },
 606                 'type' : p.double,
 607             }
 608 ,
 609             'tmap:directorout' : Hash {
 610                 'kwargs' : Hash {
 611                     'name' : warning,
 612                     'value' : Need to provide double *OUTPUT directorout typemap,
 613                 }
 614 ,
 615                 'pname' : OUTPUT,
 616                 'typemap' : typemap(directorout) double *OUTPUT,
 617                 'code' : {
 618 },
 619                 'type' : p.double,
 620             }
 621 ,
 622             'tmap:jni' : Hash {
 623                 'pname' : OUTPUT,
 624                 'typemap' : typemap(jni) double *OUTPUT,
 625                 'code' : jdoubleArray,
 626                 'type' : p.double,
 627             }
 628 ,
 629             'tmap:jtype' : Hash {
 630                 'pname' : OUTPUT,
 631                 'typemap' : typemap(jtype) double *OUTPUT,
 632                 'code' : double[],
 633                 'type' : p.double,
 634             }
 635 ,
 636             'tmap:javain' : Hash {
 637                 'pname' : OUTPUT,
 638                 'typemap' : typemap(javain) double *OUTPUT,
 639                 'code' : $javainput,
 640                 'type' : p.double,
 641             }
 642 ,
 643         }
 644 ,
 645     }
 646 ,
 647     'r.double' : Hash {
 648         'INOUT' : Hash {
 649             'tmap:freearg' : Hash {
 650                 'pname' : INOUT,
 651                 'typemap' : typemap(freearg) double &INOUT,
 652                 'code' : ,
 653                 'type' : r.double,
 654             }
 655 ,
 656             'tmap:jstype' : Hash {
 657                 'pname' : INOUT,
 658                 'typemap' : typemap(jstype) double &INOUT,
 659                 'code' : double[],
 660                 'type' : r.double,
 661             }
 662 ,
 663             'tmap:javadirectorin' : Hash {
 664                 'pname' : INOUT,
 665                 'typemap' : typemap(javadirectorin) double &INOUT,
 666                 'code' : $jniinput,
 667                 'type' : r.double,
 668             }
 669 ,
 670             'tmap:directorin' : Hash {
 671                 'kwargs' : Hash {
 672                     'name' : descriptor,
 673                     'value' : [Ljava/lang/Double;,
 674                     'nextSibling' : Hash {
 675                         'name' : warning,
 676                         'value' : Need to provide double *INOUT directorin typemap, double array length is unknown,
 677                     }
 678 ,
 679                 }
 680 ,
 681                 'pname' : INOUT,
 682                 'typemap' : typemap(directorin) double &INOUT,
 683                 'code' : {
 684 },
 685                 'type' : r.double,
 686             }
 687 ,
 688             'tmap:argout' : Hash {
 689                 'pname' : INOUT,
 690                 'typemap' : typemap(argout) double &INOUT,
 691                 'code' : { jenv->ReleaseDoubleArrayElements($input, (jdouble *)$1, 0); },
 692                 'type' : r.double,
 693             }
 694 ,
 695             'tmap:javadirectorout' : Hash {
 696                 'pname' : INOUT,
 697                 'typemap' : typemap(javadirectorout) double &INOUT,
 698                 'code' : $javacall,
 699                 'type' : r.double,
 700             }
 701 ,
 702             'tmap:in' : Hash {
 703                 'kwargs' : Hash {
 704                     'name' : numinputs,
 705                     'value' : 1,
 706                 }
 707 ,
 708                 'pname' : INOUT,
 709                 'typemap' : typemap(in) double &INOUT,
 710                 'code' : {
 711   if (!$input) {
 712     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
 713     return $null;
 714   }
 715   if (jenv->GetArrayLength($input) == 0) {
 716     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
 717     return $null;
 718   }
 719   $1 = ($1_ltype) jenv->GetDoubleArrayElements($input, 0);
 720 },
 721                 'type' : r.double,
 722             }
 723 ,
 724             'tmap:directorout' : Hash {
 725                 'kwargs' : Hash {
 726                     'name' : warning,
 727                     'value' : Need to provide double *INOUT directorout typemap,
 728                 }
 729 ,
 730                 'pname' : INOUT,
 731                 'typemap' : typemap(directorout) double &INOUT,
 732                 'code' : {
 733 },
 734                 'type' : r.double,
 735             }
 736 ,
 737             'tmap:typecheck' : Hash {
 738                 'kwargs' : Hash {
 739                     'name' : precedence,
 740                     'value' : 1090,
 741                 }
 742 ,
 743                 'pname' : INOUT,
 744                 'typemap' : typemap(typecheck) double &INOUT,
 745                 'code' : ,
 746                 'type' : r.double,
 747             }
 748 ,
 749             'tmap:jni' : Hash {
 750                 'pname' : INOUT,
 751                 'typemap' : typemap(jni) double &INOUT,
 752                 'code' : jdoubleArray,
 753                 'type' : r.double,
 754             }
 755 ,
 756             'tmap:jtype' : Hash {
 757                 'pname' : INOUT,
 758                 'typemap' : typemap(jtype) double &INOUT,
 759                 'code' : double[],
 760                 'type' : r.double,
 761             }
 762 ,
 763             'tmap:javain' : Hash {
 764                 'pname' : INOUT,
 765                 'typemap' : typemap(javain) double &INOUT,
 766                 'code' : $javainput,
 767                 'type' : r.double,
 768             }
 769 ,
 770         }
 771 ,
 772         'INPUT' : Hash {
 773             'tmap:freearg' : Hash {
 774                 'pname' : INPUT,
 775                 'typemap' : typemap(freearg) double &INPUT,
 776                 'code' : ,
 777                 'type' : r.double,
 778             }
 779 ,
 780             'tmap:jstype' : Hash {
 781                 'pname' : INPUT,
 782                 'typemap' : typemap(jstype) double &INPUT,
 783                 'code' : double,
 784                 'type' : r.double,
 785             }
 786 ,
 787             'tmap:javadirectorin' : Hash {
 788                 'pname' : INPUT,
 789                 'typemap' : typemap(javadirectorin) double &INPUT,
 790                 'code' : $jniinput,
 791                 'type' : r.double,
 792             }
 793 ,
 794             'tmap:directorin' : Hash {
 795                 'kwargs' : Hash {
 796                     'name' : descriptor,
 797                     'value' : D,
 798                 }
 799 ,
 800                 'pname' : INPUT,
 801                 'typemap' : typemap(directorin) double &INPUT,
 802                 'code' :  *(($&1_ltype) $input) = (jdouble *) &$1; ,
 803                 'type' : r.double,
 804             }
 805 ,
 806             'tmap:javadirectorout' : Hash {
 807                 'pname' : INPUT,
 808                 'typemap' : typemap(javadirectorout) double &INPUT,
 809                 'code' : $javacall,
 810                 'type' : r.double,
 811             }
 812 ,
 813             'tmap:in' : Hash {
 814                 'kwargs' : Hash {
 815                     'name' : numinputs,
 816                     'value' : 1,
 817                 }
 818 ,
 819                 'pname' : INPUT,
 820                 'typemap' : typemap(in) double &INPUT,
 821                 'code' :  $1 = ($1_ltype)&$input; ,
 822                 'type' : r.double,
 823             }
 824 ,
 825             'tmap:directorout' : Hash {
 826                 'pname' : INPUT,
 827                 'typemap' : typemap(directorout) double &INPUT,
 828                 'code' :  $result = ($1_ltype)&$input; ,
 829                 'type' : r.double,
 830             }
 831 ,
 832             'tmap:jni' : Hash {
 833                 'pname' : INPUT,
 834                 'typemap' : typemap(jni) double &INPUT,
 835                 'code' : jdouble,
 836                 'type' : r.double,
 837             }
 838 ,
 839             'tmap:jtype' : Hash {
 840                 'pname' : INPUT,
 841                 'typemap' : typemap(jtype) double &INPUT,
 842                 'code' : double,
 843                 'type' : r.double,
 844             }
 845 ,
 846             'tmap:javain' : Hash {
 847                 'pname' : INPUT,
 848                 'typemap' : typemap(javain) double &INPUT,
 849                 'code' : $javainput,
 850                 'type' : r.double,
 851             }
 852 ,
 853             'tmap:typecheck' : Hash {
 854                 'kwargs' : Hash {
 855                     'name' : precedence,
 856                     'value' : 90,
 857                 }
 858 ,
 859                 'pname' : INPUT,
 860                 'typemap' : typemap(typecheck) double &INPUT,
 861                 'code' : ,
 862                 'type' : r.double,
 863             }
 864 ,
 865         }
 866 ,
 867         'OUTPUT' : Hash {
 868             'tmap:freearg' : Hash {
 869                 'pname' : OUTPUT,
 870                 'typemap' : typemap(freearg) double &OUTPUT,
 871                 'code' : ,
 872                 'type' : r.double,
 873             }
 874 ,
 875             'tmap:jstype' : Hash {
 876                 'pname' : OUTPUT,
 877                 'typemap' : typemap(jstype) double &OUTPUT,
 878                 'code' : double[],
 879                 'type' : r.double,
 880             }
 881 ,
 882             'tmap:javadirectorin' : Hash {
 883                 'pname' : OUTPUT,
 884                 'typemap' : typemap(javadirectorin) double &OUTPUT,
 885                 'code' : $jniinput,
 886                 'type' : r.double,
 887             }
 888 ,
 889             'tmap:directorin' : Hash {
 890                 'kwargs' : Hash {
 891                     'name' : descriptor,
 892                     'value' : [Ljava/lang/Double;,
 893                 }
 894 ,
 895                 'pname' : OUTPUT,
 896                 'typemap' : typemap(directorin) double &OUTPUT,
 897                 'code' :  *(($&1_ltype) $input = &$1; ,
 898                 'type' : r.double,
 899             }
 900 ,
 901             'tmap:argout' : Hash {
 902                 'pname' : OUTPUT,
 903                 'typemap' : typemap(argout) double &OUTPUT,
 904                 'code' : {
 905   jdouble jvalue = (jdouble)temp$argnum;
 906   jenv->SetDoubleArrayRegion($input, 0, 1, &jvalue);
 907 },
 908                 'type' : r.double,
 909             }
 910 ,
 911             'tmap:javadirectorout' : Hash {
 912                 'pname' : OUTPUT,
 913                 'typemap' : typemap(javadirectorout) double &OUTPUT,
 914                 'code' : $javacall,
 915                 'type' : r.double,
 916             }
 917 ,
 918             'tmap:in' : Hash {
 919                 'locals' : Hash {
 920                     'name' : temp,
 921                     'type' : $*1_ltype,
 922                 }
 923 ,
 924                 'kwargs' : Hash {
 925                     'name' : numinputs,
 926                     'value' : 1,
 927                 }
 928 ,
 929                 'pname' : OUTPUT,
 930                 'typemap' : typemap(in) double &OUTPUT,
 931                 'code' : {
 932   if (!$input) {
 933     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
 934     return $null;
 935   }
 936   if (jenv->GetArrayLength($input) == 0) {
 937     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
 938     return $null;
 939   }
 940   $1 = &temp;
 941 },
 942                 'type' : r.double,
 943             }
 944 ,
 945             'tmap:directorout' : Hash {
 946                 'kwargs' : Hash {
 947                     'name' : warning,
 948                     'value' : Need to provide double *OUTPUT directorout typemap,
 949                 }
 950 ,
 951                 'pname' : OUTPUT,
 952                 'typemap' : typemap(directorout) double &OUTPUT,
 953                 'code' : {
 954 },
 955                 'type' : r.double,
 956             }
 957 ,
 958             'tmap:jni' : Hash {
 959                 'pname' : OUTPUT,
 960                 'typemap' : typemap(jni) double &OUTPUT,
 961                 'code' : jdoubleArray,
 962                 'type' : r.double,
 963             }
 964 ,
 965             'tmap:jtype' : Hash {
 966                 'pname' : OUTPUT,
 967                 'typemap' : typemap(jtype) double &OUTPUT,
 968                 'code' : double[],
 969                 'type' : r.double,
 970             }
 971 ,
 972             'tmap:javain' : Hash {
 973                 'pname' : OUTPUT,
 974                 'typemap' : typemap(javain) double &OUTPUT,
 975                 'code' : $javainput,
 976                 'type' : r.double,
 977             }
 978 ,
 979         }
 980 ,
 981     }
 982 ,
 983     'a(ANY).double' : Hash {
 984         'tmap:freearg' : Hash {
 985             'typemap' : typemap(freearg) double [ANY],
 986             'code' :  delete [] $1; ,
 987             'type' : a(ANY).double,
 988         }
 989 ,
 990         'tmap:jstype' : Hash {
 991             'typemap' : typemap(jstype) double [ANY],
 992             'code' : double[],
 993             'type' : a(ANY).double,
 994         }
 995 ,
 996         'tmap:argout' : Hash {
 997             'typemap' : typemap(argout) double [ANY],
 998             'code' :  SWIG_JavaArrayArgoutDouble(jenv, jarr$argnum, $1, $input); ,
 999             'type' : a(ANY).double,
1000         }
1001 ,
1002         'tmap:in' : Hash {
1003             'locals' : Hash {
1004                 'name' : jarr,
1005                 'type' : p.jdouble,
1006             }
1007 ,
1008             'kwargs' : Hash {
1009                 'name' : numinputs,
1010                 'value' : 1,
1011             }
1012 ,
1013             'typemap' : typemap(in) double [ANY],
1014             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
1015     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
1016     return $null;
1017   }
1018   if (!SWIG_JavaArrayInDouble(jenv, &jarr, &$1, $input)) return $null; ,
1019             'type' : a(ANY).double,
1020         }
1021 ,
1022         'tmap:jni' : Hash {
1023             'typemap' : typemap(jni) double [ANY],
1024             'code' : jdoubleArray,
1025             'type' : a(ANY).double,
1026         }
1027 ,
1028         'tmap:jtype' : Hash {
1029             'typemap' : typemap(jtype) double [ANY],
1030             'code' : double[],
1031             'type' : a(ANY).double,
1032         }
1033 ,
1034         'tmap:out' : Hash {
1035             'typemap' : typemap(out) double [ANY],
1036             'code' : $result = SWIG_JavaArrayOutDouble(jenv, $1, $1_dim0); ,
1037             'type' : a(ANY).double,
1038         }
1039 ,
1040         'tmap:javain' : Hash {
1041             'typemap' : typemap(javain) double [ANY],
1042             'code' : $javainput,
1043             'type' : a(ANY).double,
1044         }
1045 ,
1046         'tmap:typecheck' : Hash {
1047             'kwargs' : Hash {
1048                 'name' : precedence,
1049                 'value' : 1090,
1050             }
1051 ,
1052             'typemap' : typemap(typecheck) double [ANY],
1053             'code' : ,
1054             'type' : a(ANY).double,
1055         }
1056 ,
1057         'tmap:javaout' : Hash {
1058             'typemap' : typemap(javaout) double [ANY],
1059             'code' : {
1060     return $jnicall;
1061   },
1062             'type' : a(ANY).double,
1063         }
1064 ,
1065     }
1066 ,
1067     'a().double' : Hash {
1068         'tmap:freearg' : Hash {
1069             'typemap' : typemap(freearg) double [],
1070             'code' :  delete [] $1; ,
1071             'type' : a().double,
1072         }
1073 ,
1074         'tmap:jstype' : Hash {
1075             'typemap' : typemap(jstype) double [],
1076             'code' : double[],
1077             'type' : a().double,
1078         }
1079 ,
1080         'tmap:argout' : Hash {
1081             'typemap' : typemap(argout) double [],
1082             'code' :  SWIG_JavaArrayArgoutDouble(jenv, jarr$argnum, $1, $input); ,
1083             'type' : a().double,
1084         }
1085 ,
1086         'tmap:in' : Hash {
1087             'locals' : Hash {
1088                 'name' : jarr,
1089                 'type' : p.jdouble,
1090             }
1091 ,
1092             'kwargs' : Hash {
1093                 'name' : numinputs,
1094                 'value' : 1,
1095             }
1096 ,
1097             'typemap' : typemap(in) double [],
1098             'code' :   if (!SWIG_JavaArrayInDouble(jenv, &jarr, &$1, $input)) return $null; ,
1099             'type' : a().double,
1100         }
1101 ,
1102         'tmap:jni' : Hash {
1103             'typemap' : typemap(jni) double [],
1104             'code' : jdoubleArray,
1105             'type' : a().double,
1106         }
1107 ,
1108         'tmap:jtype' : Hash {
1109             'typemap' : typemap(jtype) double [],
1110             'code' : double[],
1111             'type' : a().double,
1112         }
1113 ,
1114         'tmap:out' : Hash {
1115             'typemap' : typemap(out) double [],
1116             'code' : $result = SWIG_JavaArrayOutDouble(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
1117             'type' : a().double,
1118         }
1119 ,
1120         'tmap:javain' : Hash {
1121             'typemap' : typemap(javain) double [],
1122             'code' : $javainput,
1123             'type' : a().double,
1124         }
1125 ,
1126         'tmap:typecheck' : Hash {
1127             'kwargs' : Hash {
1128                 'name' : precedence,
1129                 'value' : 1090,
1130             }
1131 ,
1132             'typemap' : typemap(typecheck) double [],
1133             'code' : ,
1134             'type' : a().double,
1135         }
1136 ,
1137         'tmap:javaout' : Hash {
1138             'typemap' : typemap(javaout) double [],
1139             'code' : {
1140     return $jnicall;
1141   },
1142             'type' : a().double,
1143         }
1144 ,
1145     }
1146 ,
1147     'bool' : Hash {
1148         'tmap:jstype' : Hash {
1149             'typemap' : typemap(jstype) bool,
1150             'code' : boolean,
1151             'type' : bool,
1152         }
1153 ,
1154         'tmap:javadirectorin' : Hash {
1155             'typemap' : typemap(javadirectorin) bool,
1156             'code' : $jniinput,
1157             'type' : bool,
1158         }
1159 ,
1160         'tmap:directorin' : Hash {
1161             'kwargs' : Hash {
1162                 'name' : descriptor,
1163                 'value' : Z,
1164             }
1165 ,
1166             'typemap' : typemap(directorin) bool,
1167             'code' : $input = (jboolean) $1;,
1168             'type' : bool,
1169         }
1170 ,
1171         'tmap:in' : Hash {
1172             'kwargs' : Hash {
1173                 'name' : numinputs,
1174                 'value' : 1,
1175             }
1176 ,
1177             'typemap' : typemap(in) bool,
1178             'code' :  $1 = $input ? true : false; ,
1179             'type' : bool,
1180         }
1181 ,
1182         'tmap:directorout' : Hash {
1183             'typemap' : typemap(directorout) bool,
1184             'code' :  $result = $input ? true : false; ,
1185             'type' : bool,
1186         }
1187 ,
1188         'tmap:javadirectorout' : Hash {
1189             'typemap' : typemap(javadirectorout) bool,
1190             'code' : $javacall,
1191             'type' : bool,
1192         }
1193 ,
1194         'tmap:jni' : Hash {
1195             'typemap' : typemap(jni) bool,
1196             'code' : jboolean,
1197             'type' : bool,
1198         }
1199 ,
1200         'tmap:jtype' : Hash {
1201             'typemap' : typemap(jtype) bool,
1202             'code' : boolean,
1203             'type' : bool,
1204         }
1205 ,
1206         'tmap:out' : Hash {
1207             'typemap' : typemap(out) bool,
1208             'code' :  $result = (jboolean)$1; ,
1209             'type' : bool,
1210         }
1211 ,
1212         'tmap:typecheck' : Hash {
1213             'kwargs' : Hash {
1214                 'name' : precedence,
1215                 'value' : 15,
1216             }
1217 ,
1218             'typemap' : typemap(typecheck) bool,
1219             'code' : ,
1220             'type' : bool,
1221         }
1222 ,
1223         'tmap:javain' : Hash {
1224             'typemap' : typemap(javain) bool,
1225             'code' : $javainput,
1226             'type' : bool,
1227         }
1228 ,
1229         'tmap:javaout' : Hash {
1230             'typemap' : typemap(javaout) bool,
1231             'code' : {
1232     return $jnicall;
1233   },
1234             'type' : bool,
1235         }
1236 ,
1237     }
1238 ,
1239     'jfloat' : Hash {
1240         'tmap:jstype' : Hash {
1241             'typemap' : typemap(jstype) jfloat,
1242             'code' : float,
1243             'type' : jfloat,
1244         }
1245 ,
1246         'tmap:directorin' : Hash {
1247             'kwargs' : Hash {
1248                 'name' : descriptor,
1249                 'value' : F,
1250             }
1251 ,
1252             'typemap' : typemap(directorin) jfloat,
1253             'code' : $input = $1;,
1254             'type' : jfloat,
1255         }
1256 ,
1257         'tmap:javadirectorin' : Hash {
1258             'typemap' : typemap(javadirectorin) jfloat,
1259             'code' : $jniinput,
1260             'type' : jfloat,
1261         }
1262 ,
1263         'tmap:in' : Hash {
1264             'kwargs' : Hash {
1265                 'name' : numinputs,
1266                 'value' : 1,
1267             }
1268 ,
1269             'typemap' : typemap(in) jfloat,
1270             'code' :  $1 = $input; ,
1271             'type' : jfloat,
1272         }
1273 ,
1274         'tmap:directorout' : Hash {
1275             'typemap' : typemap(directorout) jfloat,
1276             'code' :  $result = $input; ,
1277             'type' : jfloat,
1278         }
1279 ,
1280         'tmap:javadirectorout' : Hash {
1281             'typemap' : typemap(javadirectorout) jfloat,
1282             'code' : $javacall,
1283             'type' : jfloat,
1284         }
1285 ,
1286         'tmap:jni' : Hash {
1287             'typemap' : typemap(jni) jfloat,
1288             'code' : jfloat,
1289             'type' : jfloat,
1290         }
1291 ,
1292         'tmap:jtype' : Hash {
1293             'typemap' : typemap(jtype) jfloat,
1294             'code' : float,
1295             'type' : jfloat,
1296         }
1297 ,
1298         'tmap:out' : Hash {
1299             'typemap' : typemap(out) jfloat,
1300             'code' :  $result = $1; ,
1301             'type' : jfloat,
1302         }
1303 ,
1304         'tmap:typecheck' : Hash {
1305             'kwargs' : Hash {
1306                 'name' : precedence,
1307                 'value' : 80,
1308             }
1309 ,
1310             'typemap' : typemap(typecheck) jfloat,
1311             'code' : ,
1312             'type' : jfloat,
1313         }
1314 ,
1315         'tmap:javain' : Hash {
1316             'typemap' : typemap(javain) jfloat,
1317             'code' : $javainput,
1318             'type' : jfloat,
1319         }
1320 ,
1321         'tmap:javaout' : Hash {
1322             'typemap' : typemap(javaout) jfloat,
1323             'code' : {
1324     return $jnicall;
1325   },
1326             'type' : jfloat,
1327         }
1328 ,
1329     }
1330 ,
1331     'int' : Hash {
1332         'tmap:jstype' : Hash {
1333             'typemap' : typemap(jstype) int,
1334             'code' : int,
1335             'type' : int,
1336         }
1337 ,
1338         'tmap:directorin' : Hash {
1339             'kwargs' : Hash {
1340                 'name' : descriptor,
1341                 'value' : I,
1342             }
1343 ,
1344             'typemap' : typemap(directorin) int,
1345             'code' : $input = (jint) $1;,
1346             'type' : int,
1347         }
1348 ,
1349         'tmap:javadirectorin' : Hash {
1350             'typemap' : typemap(javadirectorin) int,
1351             'code' : $jniinput,
1352             'type' : int,
1353         }
1354 ,
1355         'tmap:in' : Hash {
1356             'kwargs' : Hash {
1357                 'name' : numinputs,
1358                 'value' : 1,
1359             }
1360 ,
1361             'typemap' : typemap(in) int,
1362             'code' :  $1 = ($1_ltype)$input; ,
1363             'type' : int,
1364         }
1365 ,
1366         'tmap:directorout' : Hash {
1367             'typemap' : typemap(directorout) int,
1368             'code' :  $result = ($1_ltype)$input; ,
1369             'type' : int,
1370         }
1371 ,
1372         'tmap:javadirectorout' : Hash {
1373             'typemap' : typemap(javadirectorout) int,
1374             'code' : $javacall,
1375             'type' : int,
1376         }
1377 ,
1378         'tmap:jni' : Hash {
1379             'typemap' : typemap(jni) int,
1380             'code' : jint,
1381             'type' : int,
1382         }
1383 ,
1384         'tmap:jtype' : Hash {
1385             'typemap' : typemap(jtype) int,
1386             'code' : int,
1387             'type' : int,
1388         }
1389 ,
1390         'tmap:out' : Hash {
1391             'typemap' : typemap(out) int,
1392             'code' :  $result = (jint)$1; ,
1393             'type' : int,
1394         }
1395 ,
1396         'tmap:typecheck' : Hash {
1397             'kwargs' : Hash {
1398                 'name' : precedence,
1399                 'value' : 45,
1400             }
1401 ,
1402             'typemap' : typemap(typecheck) int,
1403             'code' : ,
1404             'type' : int,
1405         }
1406 ,
1407         'tmap:throws' : Hash {
1408             'typemap' : typemap(throws) int,
1409             'code' :  char error_msg[256];
1410    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
1411    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
1412    return $null; ,
1413             'type' : int,
1414         }
1415 ,
1416         'tmap:javain' : Hash {
1417             'typemap' : typemap(javain) int,
1418             'code' : $javainput,
1419             'type' : int,
1420         }
1421 ,
1422         'tmap:javaout' : Hash {
1423             'typemap' : typemap(javaout) int,
1424             'code' : {
1425     return $jnicall;
1426   },
1427             'type' : int,
1428         }
1429 ,
1430     }
1431 ,
1432     'a(ANY).bool' : Hash {
1433         'tmap:freearg' : Hash {
1434             'typemap' : typemap(freearg) bool [ANY],
1435             'code' :  delete [] $1; ,
1436             'type' : a(ANY).bool,
1437         }
1438 ,
1439         'tmap:jstype' : Hash {
1440             'typemap' : typemap(jstype) bool [ANY],
1441             'code' : boolean[],
1442             'type' : a(ANY).bool,
1443         }
1444 ,
1445         'tmap:argout' : Hash {
1446             'typemap' : typemap(argout) bool [ANY],
1447             'code' :  SWIG_JavaArrayArgoutBool(jenv, jarr$argnum, $1, $input); ,
1448             'type' : a(ANY).bool,
1449         }
1450 ,
1451         'tmap:in' : Hash {
1452             'locals' : Hash {
1453                 'name' : jarr,
1454                 'type' : p.jboolean,
1455             }
1456 ,
1457             'kwargs' : Hash {
1458                 'name' : numinputs,
1459                 'value' : 1,
1460             }
1461 ,
1462             'typemap' : typemap(in) bool [ANY],
1463             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
1464     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
1465     return $null;
1466   }
1467   if (!SWIG_JavaArrayInBool(jenv, &jarr, &$1, $input)) return $null; ,
1468             'type' : a(ANY).bool,
1469         }
1470 ,
1471         'tmap:jni' : Hash {
1472             'typemap' : typemap(jni) bool [ANY],
1473             'code' : jbooleanArray,
1474             'type' : a(ANY).bool,
1475         }
1476 ,
1477         'tmap:jtype' : Hash {
1478             'typemap' : typemap(jtype) bool [ANY],
1479             'code' : boolean[],
1480             'type' : a(ANY).bool,
1481         }
1482 ,
1483         'tmap:out' : Hash {
1484             'typemap' : typemap(out) bool [ANY],
1485             'code' : $result = SWIG_JavaArrayOutBool(jenv, $1, $1_dim0); ,
1486             'type' : a(ANY).bool,
1487         }
1488 ,
1489         'tmap:javain' : Hash {
1490             'typemap' : typemap(javain) bool [ANY],
1491             'code' : $javainput,
1492             'type' : a(ANY).bool,
1493         }
1494 ,
1495         'tmap:typecheck' : Hash {
1496             'kwargs' : Hash {
1497                 'name' : precedence,
1498                 'value' : 1015,
1499             }
1500 ,
1501             'typemap' : typemap(typecheck) bool [ANY],
1502             'code' : ,
1503             'type' : a(ANY).bool,
1504         }
1505 ,
1506         'tmap:javaout' : Hash {
1507             'typemap' : typemap(javaout) bool [ANY],
1508             'code' : {
1509     return $jnicall;
1510   },
1511             'type' : a(ANY).bool,
1512         }
1513 ,
1514     }
1515 ,
1516     'r.q(const).long' : Hash {
1517         'tmap:jstype' : Hash {
1518             'typemap' : typemap(jstype) long const &,
1519             'code' : int,
1520             'type' : r.q(const).long,
1521         }
1522 ,
1523         'tmap:directorin' : Hash {
1524             'kwargs' : Hash {
1525                 'name' : descriptor,
1526                 'value' : I,
1527             }
1528 ,
1529             'typemap' : typemap(directorin) long const &,
1530             'code' : $input = (jint)$1_name;,
1531             'type' : r.q(const).long,
1532         }
1533 ,
1534         'tmap:javadirectorin' : Hash {
1535             'locals' : Hash {
1536                 'name' : temp,
1537                 'type' : $*1_ltype,
1538             }
1539 ,
1540             'typemap' : typemap(javadirectorin) long const &,
1541             'code' : $jniinput,
1542             'type' : r.q(const).long,
1543         }
1544 ,
1545         'tmap:in' : Hash {
1546             'locals' : Hash {
1547                 'name' : temp,
1548                 'type' : $*1_ltype,
1549             }
1550 ,
1551             'kwargs' : Hash {
1552                 'name' : numinputs,
1553                 'value' : 1,
1554             }
1555 ,
1556             'typemap' : typemap(in) long const &,
1557             'code' :  temp = ($*1_ltype)$input;
1558    $1 = &temp; ,
1559             'type' : r.q(const).long,
1560         }
1561 ,
1562         'tmap:directorout' : Hash {
1563             'kwargs' : Hash {
1564                 'name' : warning,
1565                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
1566             }
1567 ,
1568             'typemap' : typemap(directorout) long const &,
1569             'code' :  static $*1_ltype temp;
1570    temp = ($*1_ltype)$input;
1571    $result = &temp; ,
1572             'type' : r.q(const).long,
1573         }
1574 ,
1575         'tmap:javadirectorout' : Hash {
1576             'locals' : Hash {
1577                 'name' : temp,
1578                 'type' : $*1_ltype,
1579             }
1580 ,
1581             'typemap' : typemap(javadirectorout) long const &,
1582             'code' : $javacall,
1583             'type' : r.q(const).long,
1584         }
1585 ,
1586         'tmap:jni' : Hash {
1587             'typemap' : typemap(jni) long const &,
1588             'code' : jint,
1589             'type' : r.q(const).long,
1590         }
1591 ,
1592         'tmap:jtype' : Hash {
1593             'typemap' : typemap(jtype) long const &,
1594             'code' : int,
1595             'type' : r.q(const).long,
1596         }
1597 ,
1598         'tmap:out' : Hash {
1599             'typemap' : typemap(out) long const &,
1600             'code' :  $result = (jint)*$1; ,
1601             'type' : r.q(const).long,
1602         }
1603 ,
1604         'tmap:typecheck' : Hash {
1605             'kwargs' : Hash {
1606                 'name' : precedence,
1607                 'value' : 45,
1608             }
1609 ,
1610             'typemap' : typemap(typecheck) long const &,
1611             'code' : ,
1612             'type' : r.q(const).long,
1613         }
1614 ,
1615         'tmap:javain' : Hash {
1616             'typemap' : typemap(javain) long const &,
1617             'code' : $javainput,
1618             'type' : r.q(const).long,
1619         }
1620 ,
1621         'tmap:javaout' : Hash {
1622             'typemap' : typemap(javaout) long const &,
1623             'code' : {
1624     return $jnicall;
1625   },
1626             'type' : r.q(const).long,
1627         }
1628 ,
1629     }
1630 ,
1631     'a().long' : Hash {
1632         'tmap:freearg' : Hash {
1633             'typemap' : typemap(freearg) long [],
1634             'code' :  delete [] $1; ,
1635             'type' : a().long,
1636         }
1637 ,
1638         'tmap:jstype' : Hash {
1639             'typemap' : typemap(jstype) long [],
1640             'code' : int[],
1641             'type' : a().long,
1642         }
1643 ,
1644         'tmap:argout' : Hash {
1645             'typemap' : typemap(argout) long [],
1646             'code' :  SWIG_JavaArrayArgoutLong(jenv, jarr$argnum, $1, $input); ,
1647             'type' : a().long,
1648         }
1649 ,
1650         'tmap:in' : Hash {
1651             'locals' : Hash {
1652                 'name' : jarr,
1653                 'type' : p.jint,
1654             }
1655 ,
1656             'kwargs' : Hash {
1657                 'name' : numinputs,
1658                 'value' : 1,
1659             }
1660 ,
1661             'typemap' : typemap(in) long [],
1662             'code' :   if (!SWIG_JavaArrayInLong(jenv, &jarr, &$1, $input)) return $null; ,
1663             'type' : a().long,
1664         }
1665 ,
1666         'tmap:jni' : Hash {
1667             'typemap' : typemap(jni) long [],
1668             'code' : jintArray,
1669             'type' : a().long,
1670         }
1671 ,
1672         'tmap:jtype' : Hash {
1673             'typemap' : typemap(jtype) long [],
1674             'code' : int[],
1675             'type' : a().long,
1676         }
1677 ,
1678         'tmap:out' : Hash {
1679             'typemap' : typemap(out) long [],
1680             'code' : $result = SWIG_JavaArrayOutLong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
1681             'type' : a().long,
1682         }
1683 ,
1684         'tmap:javain' : Hash {
1685             'typemap' : typemap(javain) long [],
1686             'code' : $javainput,
1687             'type' : a().long,
1688         }
1689 ,
1690         'tmap:typecheck' : Hash {
1691             'kwargs' : Hash {
1692                 'name' : precedence,
1693                 'value' : 1045,
1694             }
1695 ,
1696             'typemap' : typemap(typecheck) long [],
1697             'code' : ,
1698             'type' : a().long,
1699         }
1700 ,
1701         'tmap:javaout' : Hash {
1702             'typemap' : typemap(javaout) long [],
1703             'code' : {
1704     return $jnicall;
1705   },
1706             'type' : a().long,
1707         }
1708 ,
1709     }
1710 ,
1711     'r.int' : Hash {
1712         'INOUT' : Hash {
1713             'tmap:freearg' : Hash {
1714                 'pname' : INOUT,
1715                 'typemap' : typemap(freearg) int &INOUT,
1716                 'code' : ,
1717                 'type' : r.int,
1718             }
1719 ,
1720             'tmap:jstype' : Hash {
1721                 'pname' : INOUT,
1722                 'typemap' : typemap(jstype) int &INOUT,
1723                 'code' : int[],
1724                 'type' : r.int,
1725             }
1726 ,
1727             'tmap:javadirectorin' : Hash {
1728                 'pname' : INOUT,
1729                 'typemap' : typemap(javadirectorin) int &INOUT,
1730                 'code' : $jniinput,
1731                 'type' : r.int,
1732             }
1733 ,
1734             'tmap:directorin' : Hash {
1735                 'kwargs' : Hash {
1736                     'name' : descriptor,
1737                     'value' : [Ljava/lang/Integer;,
1738                     'nextSibling' : Hash {
1739                         'name' : warning,
1740                         'value' : Need to provide int *INOUT directorin typemap, int array length is unknown,
1741                     }
1742 ,
1743                 }
1744 ,
1745                 'pname' : INOUT,
1746                 'typemap' : typemap(directorin) int &INOUT,
1747                 'code' : {
1748 },
1749                 'type' : r.int,
1750             }
1751 ,
1752             'tmap:argout' : Hash {
1753                 'pname' : INOUT,
1754                 'typemap' : typemap(argout) int &INOUT,
1755                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
1756                 'type' : r.int,
1757             }
1758 ,
1759             'tmap:javadirectorout' : Hash {
1760                 'pname' : INOUT,
1761                 'typemap' : typemap(javadirectorout) int &INOUT,
1762                 'code' : $javacall,
1763                 'type' : r.int,
1764             }
1765 ,
1766             'tmap:in' : Hash {
1767                 'kwargs' : Hash {
1768                     'name' : numinputs,
1769                     'value' : 1,
1770                 }
1771 ,
1772                 'pname' : INOUT,
1773                 'typemap' : typemap(in) int &INOUT,
1774                 'code' : {
1775   if (!$input) {
1776     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1777     return $null;
1778   }
1779   if (jenv->GetArrayLength($input) == 0) {
1780     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
1781     return $null;
1782   }
1783   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
1784 },
1785                 'type' : r.int,
1786             }
1787 ,
1788             'tmap:directorout' : Hash {
1789                 'kwargs' : Hash {
1790                     'name' : warning,
1791                     'value' : Need to provide int *INOUT directorout typemap,
1792                 }
1793 ,
1794                 'pname' : INOUT,
1795                 'typemap' : typemap(directorout) int &INOUT,
1796                 'code' : {
1797 },
1798                 'type' : r.int,
1799             }
1800 ,
1801             'tmap:typecheck' : Hash {
1802                 'kwargs' : Hash {
1803                     'name' : precedence,
1804                     'value' : 1045,
1805                 }
1806 ,
1807                 'pname' : INOUT,
1808                 'typemap' : typemap(typecheck) int &INOUT,
1809                 'code' : ,
1810                 'type' : r.int,
1811             }
1812 ,
1813             'tmap:jni' : Hash {
1814                 'pname' : INOUT,
1815                 'typemap' : typemap(jni) int &INOUT,
1816                 'code' : jintArray,
1817                 'type' : r.int,
1818             }
1819 ,
1820             'tmap:jtype' : Hash {
1821                 'pname' : INOUT,
1822                 'typemap' : typemap(jtype) int &INOUT,
1823                 'code' : int[],
1824                 'type' : r.int,
1825             }
1826 ,
1827             'tmap:javain' : Hash {
1828                 'pname' : INOUT,
1829                 'typemap' : typemap(javain) int &INOUT,
1830                 'code' : $javainput,
1831                 'type' : r.int,
1832             }
1833 ,
1834         }
1835 ,
1836         'INPUT' : Hash {
1837             'tmap:freearg' : Hash {
1838                 'pname' : INPUT,
1839                 'typemap' : typemap(freearg) int &INPUT,
1840                 'code' : ,
1841                 'type' : r.int,
1842             }
1843 ,
1844             'tmap:jstype' : Hash {
1845                 'pname' : INPUT,
1846                 'typemap' : typemap(jstype) int &INPUT,
1847                 'code' : int,
1848                 'type' : r.int,
1849             }
1850 ,
1851             'tmap:javadirectorin' : Hash {
1852                 'pname' : INPUT,
1853                 'typemap' : typemap(javadirectorin) int &INPUT,
1854                 'code' : $jniinput,
1855                 'type' : r.int,
1856             }
1857 ,
1858             'tmap:directorin' : Hash {
1859                 'kwargs' : Hash {
1860                     'name' : descriptor,
1861                     'value' : I,
1862                 }
1863 ,
1864                 'pname' : INPUT,
1865                 'typemap' : typemap(directorin) int &INPUT,
1866                 'code' :  *(($&1_ltype) $input) = (jint *) &$1; ,
1867                 'type' : r.int,
1868             }
1869 ,
1870             'tmap:javadirectorout' : Hash {
1871                 'pname' : INPUT,
1872                 'typemap' : typemap(javadirectorout) int &INPUT,
1873                 'code' : $javacall,
1874                 'type' : r.int,
1875             }
1876 ,
1877             'tmap:in' : Hash {
1878                 'kwargs' : Hash {
1879                     'name' : numinputs,
1880                     'value' : 1,
1881                 }
1882 ,
1883                 'pname' : INPUT,
1884                 'typemap' : typemap(in) int &INPUT,
1885                 'code' :  $1 = ($1_ltype)&$input; ,
1886                 'type' : r.int,
1887             }
1888 ,
1889             'tmap:directorout' : Hash {
1890                 'pname' : INPUT,
1891                 'typemap' : typemap(directorout) int &INPUT,
1892                 'code' :  $result = ($1_ltype)&$input; ,
1893                 'type' : r.int,
1894             }
1895 ,
1896             'tmap:jni' : Hash {
1897                 'pname' : INPUT,
1898                 'typemap' : typemap(jni) int &INPUT,
1899                 'code' : jint,
1900                 'type' : r.int,
1901             }
1902 ,
1903             'tmap:jtype' : Hash {
1904                 'pname' : INPUT,
1905                 'typemap' : typemap(jtype) int &INPUT,
1906                 'code' : int,
1907                 'type' : r.int,
1908             }
1909 ,
1910             'tmap:javain' : Hash {
1911                 'pname' : INPUT,
1912                 'typemap' : typemap(javain) int &INPUT,
1913                 'code' : $javainput,
1914                 'type' : r.int,
1915             }
1916 ,
1917             'tmap:typecheck' : Hash {
1918                 'kwargs' : Hash {
1919                     'name' : precedence,
1920                     'value' : 45,
1921                 }
1922 ,
1923                 'pname' : INPUT,
1924                 'typemap' : typemap(typecheck) int &INPUT,
1925                 'code' : ,
1926                 'type' : r.int,
1927             }
1928 ,
1929         }
1930 ,
1931         'OUTPUT' : Hash {
1932             'tmap:freearg' : Hash {
1933                 'pname' : OUTPUT,
1934                 'typemap' : typemap(freearg) int &OUTPUT,
1935                 'code' : ,
1936                 'type' : r.int,
1937             }
1938 ,
1939             'tmap:jstype' : Hash {
1940                 'pname' : OUTPUT,
1941                 'typemap' : typemap(jstype) int &OUTPUT,
1942                 'code' : int[],
1943                 'type' : r.int,
1944             }
1945 ,
1946             'tmap:javadirectorin' : Hash {
1947                 'pname' : OUTPUT,
1948                 'typemap' : typemap(javadirectorin) int &OUTPUT,
1949                 'code' : $jniinput,
1950                 'type' : r.int,
1951             }
1952 ,
1953             'tmap:directorin' : Hash {
1954                 'kwargs' : Hash {
1955                     'name' : descriptor,
1956                     'value' : [Ljava/lang/Integer;,
1957                 }
1958 ,
1959                 'pname' : OUTPUT,
1960                 'typemap' : typemap(directorin) int &OUTPUT,
1961                 'code' :  *(($&1_ltype) $input = &$1; ,
1962                 'type' : r.int,
1963             }
1964 ,
1965             'tmap:argout' : Hash {
1966                 'pname' : OUTPUT,
1967                 'typemap' : typemap(argout) int &OUTPUT,
1968                 'code' : {
1969   jint jvalue = (jint)temp$argnum;
1970   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
1971 },
1972                 'type' : r.int,
1973             }
1974 ,
1975             'tmap:javadirectorout' : Hash {
1976                 'pname' : OUTPUT,
1977                 'typemap' : typemap(javadirectorout) int &OUTPUT,
1978                 'code' : $javacall,
1979                 'type' : r.int,
1980             }
1981 ,
1982             'tmap:in' : Hash {
1983                 'locals' : Hash {
1984                     'name' : temp,
1985                     'type' : $*1_ltype,
1986                 }
1987 ,
1988                 'kwargs' : Hash {
1989                     'name' : numinputs,
1990                     'value' : 1,
1991                 }
1992 ,
1993                 'pname' : OUTPUT,
1994                 'typemap' : typemap(in) int &OUTPUT,
1995                 'code' : {
1996   if (!$input) {
1997     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
1998     return $null;
1999   }
2000   if (jenv->GetArrayLength($input) == 0) {
2001     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
2002     return $null;
2003   }
2004   $1 = &temp;
2005 },
2006                 'type' : r.int,
2007             }
2008 ,
2009             'tmap:directorout' : Hash {
2010                 'kwargs' : Hash {
2011                     'name' : warning,
2012                     'value' : Need to provide int *OUTPUT directorout typemap,
2013                 }
2014 ,
2015                 'pname' : OUTPUT,
2016                 'typemap' : typemap(directorout) int &OUTPUT,
2017                 'code' : {
2018 },
2019                 'type' : r.int,
2020             }
2021 ,
2022             'tmap:jni' : Hash {
2023                 'pname' : OUTPUT,
2024                 'typemap' : typemap(jni) int &OUTPUT,
2025                 'code' : jintArray,
2026                 'type' : r.int,
2027             }
2028 ,
2029             'tmap:jtype' : Hash {
2030                 'pname' : OUTPUT,
2031                 'typemap' : typemap(jtype) int &OUTPUT,
2032                 'code' : int[],
2033                 'type' : r.int,
2034             }
2035 ,
2036             'tmap:javain' : Hash {
2037                 'pname' : OUTPUT,
2038                 'typemap' : typemap(javain) int &OUTPUT,
2039                 'code' : $javainput,
2040                 'type' : r.int,
2041             }
2042 ,
2043         }
2044 ,
2045     }
2046 ,
2047     'short' : Hash {
2048         'tmap:jstype' : Hash {
2049             'typemap' : typemap(jstype) short,
2050             'code' : short,
2051             'type' : short,
2052         }
2053 ,
2054         'tmap:directorin' : Hash {
2055             'kwargs' : Hash {
2056                 'name' : descriptor,
2057                 'value' : S,
2058             }
2059 ,
2060             'typemap' : typemap(directorin) short,
2061             'code' : $input = (jshort) $1;,
2062             'type' : short,
2063         }
2064 ,
2065         'tmap:javadirectorin' : Hash {
2066             'typemap' : typemap(javadirectorin) short,
2067             'code' : $jniinput,
2068             'type' : short,
2069         }
2070 ,
2071         'tmap:in' : Hash {
2072             'kwargs' : Hash {
2073                 'name' : numinputs,
2074                 'value' : 1,
2075             }
2076 ,
2077             'typemap' : typemap(in) short,
2078             'code' :  $1 = ($1_ltype)$input; ,
2079             'type' : short,
2080         }
2081 ,
2082         'tmap:directorout' : Hash {
2083             'typemap' : typemap(directorout) short,
2084             'code' :  $result = ($1_ltype)$input; ,
2085             'type' : short,
2086         }
2087 ,
2088         'tmap:javadirectorout' : Hash {
2089             'typemap' : typemap(javadirectorout) short,
2090             'code' : $javacall,
2091             'type' : short,
2092         }
2093 ,
2094         'tmap:jni' : Hash {
2095             'typemap' : typemap(jni) short,
2096             'code' : jshort,
2097             'type' : short,
2098         }
2099 ,
2100         'tmap:jtype' : Hash {
2101             'typemap' : typemap(jtype) short,
2102             'code' : short,
2103             'type' : short,
2104         }
2105 ,
2106         'tmap:out' : Hash {
2107             'typemap' : typemap(out) short,
2108             'code' :  $result = (jshort)$1; ,
2109             'type' : short,
2110         }
2111 ,
2112         'tmap:typecheck' : Hash {
2113             'kwargs' : Hash {
2114                 'name' : precedence,
2115                 'value' : 35,
2116             }
2117 ,
2118             'typemap' : typemap(typecheck) short,
2119             'code' : ,
2120             'type' : short,
2121         }
2122 ,
2123         'tmap:throws' : Hash {
2124             'typemap' : typemap(throws) short,
2125             'code' :  char error_msg[256];
2126    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
2127    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
2128    return $null; ,
2129             'type' : short,
2130         }
2131 ,
2132         'tmap:javain' : Hash {
2133             'typemap' : typemap(javain) short,
2134             'code' : $javainput,
2135             'type' : short,
2136         }
2137 ,
2138         'tmap:javaout' : Hash {
2139             'typemap' : typemap(javaout) short,
2140             'code' : {
2141     return $jnicall;
2142   },
2143             'type' : short,
2144         }
2145 ,
2146     }
2147 ,
2148     'r.q(const).char' : Hash {
2149         'tmap:jstype' : Hash {
2150             'typemap' : typemap(jstype) char const &,
2151             'code' : char,
2152             'type' : r.q(const).char,
2153         }
2154 ,
2155         'tmap:directorin' : Hash {
2156             'kwargs' : Hash {
2157                 'name' : descriptor,
2158                 'value' : C,
2159             }
2160 ,
2161             'typemap' : typemap(directorin) char const &,
2162             'code' : $input = (jchar)$1_name;,
2163             'type' : r.q(const).char,
2164         }
2165 ,
2166         'tmap:javadirectorin' : Hash {
2167             'locals' : Hash {
2168                 'name' : temp,
2169                 'type' : $*1_ltype,
2170             }
2171 ,
2172             'typemap' : typemap(javadirectorin) char const &,
2173             'code' : $jniinput,
2174             'type' : r.q(const).char,
2175         }
2176 ,
2177         'tmap:in' : Hash {
2178             'locals' : Hash {
2179                 'name' : temp,
2180                 'type' : $*1_ltype,
2181             }
2182 ,
2183             'kwargs' : Hash {
2184                 'name' : numinputs,
2185                 'value' : 1,
2186             }
2187 ,
2188             'typemap' : typemap(in) char const &,
2189             'code' :  temp = ($*1_ltype)$input;
2190    $1 = &temp; ,
2191             'type' : r.q(const).char,
2192         }
2193 ,
2194         'tmap:directorout' : Hash {
2195             'kwargs' : Hash {
2196                 'name' : warning,
2197                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
2198             }
2199 ,
2200             'typemap' : typemap(directorout) char const &,
2201             'code' :  static $*1_ltype temp;
2202    temp = ($*1_ltype)$input;
2203    $result = &temp; ,
2204             'type' : r.q(const).char,
2205         }
2206 ,
2207         'tmap:javadirectorout' : Hash {
2208             'locals' : Hash {
2209                 'name' : temp,
2210                 'type' : $*1_ltype,
2211             }
2212 ,
2213             'typemap' : typemap(javadirectorout) char const &,
2214             'code' : $javacall,
2215             'type' : r.q(const).char,
2216         }
2217 ,
2218         'tmap:jni' : Hash {
2219             'typemap' : typemap(jni) char const &,
2220             'code' : jchar,
2221             'type' : r.q(const).char,
2222         }
2223 ,
2224         'tmap:jtype' : Hash {
2225             'typemap' : typemap(jtype) char const &,
2226             'code' : char,
2227             'type' : r.q(const).char,
2228         }
2229 ,
2230         'tmap:out' : Hash {
2231             'typemap' : typemap(out) char const &,
2232             'code' :  $result = (jchar)*$1; ,
2233             'type' : r.q(const).char,
2234         }
2235 ,
2236         'tmap:typecheck' : Hash {
2237             'kwargs' : Hash {
2238                 'name' : precedence,
2239                 'value' : 130,
2240             }
2241 ,
2242             'typemap' : typemap(typecheck) char const &,
2243             'code' : ,
2244             'type' : r.q(const).char,
2245         }
2246 ,
2247         'tmap:javain' : Hash {
2248             'typemap' : typemap(javain) char const &,
2249             'code' : $javainput,
2250             'type' : r.q(const).char,
2251         }
2252 ,
2253         'tmap:javaout' : Hash {
2254             'typemap' : typemap(javaout) char const &,
2255             'code' : {
2256     return $jnicall;
2257   },
2258             'type' : r.q(const).char,
2259         }
2260 ,
2261     }
2262 ,
2263     'a().char' : Hash {
2264         'tmap:typecheck' : Hash {
2265             'kwargs' : Hash {
2266                 'name' : precedence,
2267                 'value' : 140,
2268             }
2269 ,
2270             'typemap' : typemap(typecheck) char [],
2271             'code' : ,
2272             'type' : a().char,
2273         }
2274 ,
2275         'tmap:memberin' : Hash {
2276             'typemap' : typemap(memberin) char [],
2277             'code' : {
2278   if ($input) strcpy((char *)$1, (const char *)$input);
2279   else $1[0] = 0;
2280 },
2281             'type' : a().char,
2282         }
2283 ,
2284         'tmap:jtype' : Hash {
2285             'typemap' : typemap(jtype) char [],
2286             'code' : String,
2287             'type' : a().char,
2288         }
2289 ,
2290         'tmap:javadirectorin' : Hash {
2291             'typemap' : typemap(javadirectorin) char [],
2292             'code' : $jniinput,
2293             'type' : a().char,
2294         }
2295 ,
2296         'tmap:directorin' : Hash {
2297             'kwargs' : Hash {
2298                 'name' : descriptor,
2299                 'value' : Ljava/lang/String;,
2300                 'nextSibling' : Hash {
2301                     'name' : noblock,
2302                     'value' : 1,
2303                 }
2304 ,
2305             }
2306 ,
2307             'typemap' : typemap(directorin) char [],
2308             'code' : $input = 0;
2309   if ($1) {
2310     $input = jenv->NewStringUTF((const char *)$1);
2311     if (!$input) return $null;
2312   },
2313             'type' : a().char,
2314         }
2315 ,
2316         'tmap:javadirectorout' : Hash {
2317             'typemap' : typemap(javadirectorout) char [],
2318             'code' : $javacall,
2319             'type' : a().char,
2320         }
2321 ,
2322         'tmap:directorout' : Hash {
2323             'kwargs' : Hash {
2324                 'name' : noblock,
2325                 'value' : 1,
2326             }
2327 ,
2328             'typemap' : typemap(directorout) char [],
2329             'code' : $1 = 0;
2330   if ($input) {
2331     $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
2332     if (!$result) return $null;
2333   },
2334             'type' : a().char,
2335         }
2336 ,
2337         'tmap:out' : Hash {
2338             'kwargs' : Hash {
2339                 'name' : noblock,
2340                 'value' : 1,
2341             }
2342 ,
2343             'typemap' : typemap(out) char [],
2344             'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);,
2345             'type' : a().char,
2346         }
2347 ,
2348         'tmap:jni' : Hash {
2349             'typemap' : typemap(jni) char [],
2350             'code' : jstring,
2351             'type' : a().char,
2352         }
2353 ,
2354         'tmap:javaout' : Hash {
2355             'typemap' : typemap(javaout) char [],
2356             'code' : {
2357     return $jnicall;
2358   },
2359             'type' : a().char,
2360         }
2361 ,
2362         'tmap:globalin' : Hash {
2363             'typemap' : typemap(globalin) char [],
2364             'code' : {
2365   if ($input) strcpy((char *)$1, (const char *)$input);
2366   else $1[0] = 0;
2367 },
2368             'type' : a().char,
2369         }
2370 ,
2371         'tmap:in' : Hash {
2372             'kwargs' : Hash {
2373                 'name' : numinputs,
2374                 'value' : 1,
2375                 'nextSibling' : Hash {
2376                     'name' : noblock,
2377                     'value' : 1,
2378                 }
2379 ,
2380             }
2381 ,
2382             'typemap' : typemap(in) char [],
2383             'code' : $1 = 0;
2384   if ($input) {
2385     $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
2386     if (!$1) return $null;
2387   },
2388             'type' : a().char,
2389         }
2390 ,
2391         'tmap:javain' : Hash {
2392             'typemap' : typemap(javain) char [],
2393             'code' : $javainput,
2394             'type' : a().char,
2395         }
2396 ,
2397         'tmap:jstype' : Hash {
2398             'typemap' : typemap(jstype) char [],
2399             'code' : String,
2400             'type' : a().char,
2401         }
2402 ,
2403         'tmap:argout' : Hash {
2404             'typemap' : typemap(argout) char [],
2405             'code' : ,
2406             'type' : a().char,
2407         }
2408 ,
2409         'tmap:freearg' : Hash {
2410             'kwargs' : Hash {
2411                 'name' : noblock,
2412                 'value' : 1,
2413             }
2414 ,
2415             'typemap' : typemap(freearg) char [],
2416             'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);,
2417             'type' : a().char,
2418         }
2419 ,
2420     }
2421 ,
2422     'p.q(const).char' : Hash {
2423         'tmap:memberin' : Hash {
2424             'kwargs' : Hash {
2425                 'name' : warning,
2426                 'value' : 451:Setting a const char * variable may leak memory.,
2427             }
2428 ,
2429             'typemap' : typemap(memberin) char const *,
2430             'code' : {
2431   if ($input) {
2432      $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
2433      strcpy((char *)$1, (const char *)$input);
2434   } else {
2435      $1 = 0;
2436   }
2437 },
2438             'type' : p.q(const).char,
2439         }
2440 ,
2441         'tmap:globalin' : Hash {
2442             'kwargs' : Hash {
2443                 'name' : warning,
2444                 'value' : 451:Setting a const char * variable may leak memory.,
2445             }
2446 ,
2447             'typemap' : typemap(globalin) char const *,
2448             'code' : {
2449   if ($input) {
2450      $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
2451      strcpy((char *)$1, (const char *)$input);
2452   } else {
2453      $1 = 0;
2454   }
2455 },
2456             'type' : p.q(const).char,
2457         }
2458 ,
2459     }
2460 ,
2461     'void' : Hash {
2462         'tmap:jstype' : Hash {
2463             'typemap' : typemap(jstype) void,
2464             'code' : void,
2465             'type' : void,
2466         }
2467 ,
2468         'tmap:javadirectorin' : Hash {
2469             'typemap' : typemap(javadirectorin) void,
2470             'code' : $jniinput,
2471             'type' : void,
2472         }
2473 ,
2474         'tmap:directorin' : Hash {
2475             'kwargs' : Hash {
2476                 'name' : descriptor,
2477                 'value' : V,
2478             }
2479 ,
2480             'typemap' : typemap(directorin) void,
2481             'code' : ,
2482             'type' : void,
2483         }
2484 ,
2485         'tmap:javadirectorout' : Hash {
2486             'typemap' : typemap(javadirectorout) void,
2487             'code' : $javacall,
2488             'type' : void,
2489         }
2490 ,
2491         'tmap:jni' : Hash {
2492             'typemap' : typemap(jni) void,
2493             'code' : void,
2494             'type' : void,
2495         }
2496 ,
2497         'tmap:jtype' : Hash {
2498             'typemap' : typemap(jtype) void,
2499             'code' : void,
2500             'type' : void,
2501         }
2502 ,
2503         'tmap:out' : Hash {
2504             'typemap' : typemap(out) void,
2505             'code' : ,
2506             'type' : void,
2507         }
2508 ,
2509         'tmap:javaout' : Hash {
2510             'typemap' : typemap(javaout) void,
2511             'code' : {
2512     $jnicall;
2513   },
2514             'type' : void,
2515         }
2516 ,
2517     }
2518 ,
2519     'r.q(const).short' : Hash {
2520         'tmap:jstype' : Hash {
2521             'typemap' : typemap(jstype) short const &,
2522             'code' : short,
2523             'type' : r.q(const).short,
2524         }
2525 ,
2526         'tmap:directorin' : Hash {
2527             'kwargs' : Hash {
2528                 'name' : descriptor,
2529                 'value' : S,
2530             }
2531 ,
2532             'typemap' : typemap(directorin) short const &,
2533             'code' : $input = (jshort)$1_name;,
2534             'type' : r.q(const).short,
2535         }
2536 ,
2537         'tmap:javadirectorin' : Hash {
2538             'locals' : Hash {
2539                 'name' : temp,
2540                 'type' : $*1_ltype,
2541             }
2542 ,
2543             'typemap' : typemap(javadirectorin) short const &,
2544             'code' : $jniinput,
2545             'type' : r.q(const).short,
2546         }
2547 ,
2548         'tmap:in' : Hash {
2549             'locals' : Hash {
2550                 'name' : temp,
2551                 'type' : $*1_ltype,
2552             }
2553 ,
2554             'kwargs' : Hash {
2555                 'name' : numinputs,
2556                 'value' : 1,
2557             }
2558 ,
2559             'typemap' : typemap(in) short const &,
2560             'code' :  temp = ($*1_ltype)$input;
2561    $1 = &temp; ,
2562             'type' : r.q(const).short,
2563         }
2564 ,
2565         'tmap:directorout' : Hash {
2566             'kwargs' : Hash {
2567                 'name' : warning,
2568                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
2569             }
2570 ,
2571             'typemap' : typemap(directorout) short const &,
2572             'code' :  static $*1_ltype temp;
2573    temp = ($*1_ltype)$input;
2574    $result = &temp; ,
2575             'type' : r.q(const).short,
2576         }
2577 ,
2578         'tmap:javadirectorout' : Hash {
2579             'locals' : Hash {
2580                 'name' : temp,
2581                 'type' : $*1_ltype,
2582             }
2583 ,
2584             'typemap' : typemap(javadirectorout) short const &,
2585             'code' : $javacall,
2586             'type' : r.q(const).short,
2587         }
2588 ,
2589         'tmap:jni' : Hash {
2590             'typemap' : typemap(jni) short const &,
2591             'code' : jshort,
2592             'type' : r.q(const).short,
2593         }
2594 ,
2595         'tmap:jtype' : Hash {
2596             'typemap' : typemap(jtype) short const &,
2597             'code' : short,
2598             'type' : r.q(const).short,
2599         }
2600 ,
2601         'tmap:out' : Hash {
2602             'typemap' : typemap(out) short const &,
2603             'code' :  $result = (jshort)*$1; ,
2604             'type' : r.q(const).short,
2605         }
2606 ,
2607         'tmap:typecheck' : Hash {
2608             'kwargs' : Hash {
2609                 'name' : precedence,
2610                 'value' : 35,
2611             }
2612 ,
2613             'typemap' : typemap(typecheck) short const &,
2614             'code' : ,
2615             'type' : r.q(const).short,
2616         }
2617 ,
2618         'tmap:javain' : Hash {
2619             'typemap' : typemap(javain) short const &,
2620             'code' : $javainput,
2621             'type' : r.q(const).short,
2622         }
2623 ,
2624         'tmap:javaout' : Hash {
2625             'typemap' : typemap(javaout) short const &,
2626             'code' : {
2627     return $jnicall;
2628   },
2629             'type' : r.q(const).short,
2630         }
2631 ,
2632     }
2633 ,
2634     'a(ANY).short' : Hash {
2635         'tmap:freearg' : Hash {
2636             'typemap' : typemap(freearg) short [ANY],
2637             'code' :  delete [] $1; ,
2638             'type' : a(ANY).short,
2639         }
2640 ,
2641         'tmap:jstype' : Hash {
2642             'typemap' : typemap(jstype) short [ANY],
2643             'code' : short[],
2644             'type' : a(ANY).short,
2645         }
2646 ,
2647         'tmap:argout' : Hash {
2648             'typemap' : typemap(argout) short [ANY],
2649             'code' :  SWIG_JavaArrayArgoutShort(jenv, jarr$argnum, $1, $input); ,
2650             'type' : a(ANY).short,
2651         }
2652 ,
2653         'tmap:in' : Hash {
2654             'locals' : Hash {
2655                 'name' : jarr,
2656                 'type' : p.jshort,
2657             }
2658 ,
2659             'kwargs' : Hash {
2660                 'name' : numinputs,
2661                 'value' : 1,
2662             }
2663 ,
2664             'typemap' : typemap(in) short [ANY],
2665             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
2666     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
2667     return $null;
2668   }
2669   if (!SWIG_JavaArrayInShort(jenv, &jarr, &$1, $input)) return $null; ,
2670             'type' : a(ANY).short,
2671         }
2672 ,
2673         'tmap:jni' : Hash {
2674             'typemap' : typemap(jni) short [ANY],
2675             'code' : jshortArray,
2676             'type' : a(ANY).short,
2677         }
2678 ,
2679         'tmap:jtype' : Hash {
2680             'typemap' : typemap(jtype) short [ANY],
2681             'code' : short[],
2682             'type' : a(ANY).short,
2683         }
2684 ,
2685         'tmap:out' : Hash {
2686             'typemap' : typemap(out) short [ANY],
2687             'code' : $result = SWIG_JavaArrayOutShort(jenv, $1, $1_dim0); ,
2688             'type' : a(ANY).short,
2689         }
2690 ,
2691         'tmap:javain' : Hash {
2692             'typemap' : typemap(javain) short [ANY],
2693             'code' : $javainput,
2694             'type' : a(ANY).short,
2695         }
2696 ,
2697         'tmap:typecheck' : Hash {
2698             'kwargs' : Hash {
2699                 'name' : precedence,
2700                 'value' : 1035,
2701             }
2702 ,
2703             'typemap' : typemap(typecheck) short [ANY],
2704             'code' : ,
2705             'type' : a(ANY).short,
2706         }
2707 ,
2708         'tmap:javaout' : Hash {
2709             'typemap' : typemap(javaout) short [ANY],
2710             'code' : {
2711     return $jnicall;
2712   },
2713             'type' : a(ANY).short,
2714         }
2715 ,
2716     }
2717 ,
2718     'a().short' : Hash {
2719         'tmap:freearg' : Hash {
2720             'typemap' : typemap(freearg) short [],
2721             'code' :  delete [] $1; ,
2722             'type' : a().short,
2723         }
2724 ,
2725         'tmap:jstype' : Hash {
2726             'typemap' : typemap(jstype) short [],
2727             'code' : short[],
2728             'type' : a().short,
2729         }
2730 ,
2731         'tmap:argout' : Hash {
2732             'typemap' : typemap(argout) short [],
2733             'code' :  SWIG_JavaArrayArgoutShort(jenv, jarr$argnum, $1, $input); ,
2734             'type' : a().short,
2735         }
2736 ,
2737         'tmap:in' : Hash {
2738             'locals' : Hash {
2739                 'name' : jarr,
2740                 'type' : p.jshort,
2741             }
2742 ,
2743             'kwargs' : Hash {
2744                 'name' : numinputs,
2745                 'value' : 1,
2746             }
2747 ,
2748             'typemap' : typemap(in) short [],
2749             'code' :   if (!SWIG_JavaArrayInShort(jenv, &jarr, &$1, $input)) return $null; ,
2750             'type' : a().short,
2751         }
2752 ,
2753         'tmap:jni' : Hash {
2754             'typemap' : typemap(jni) short [],
2755             'code' : jshortArray,
2756             'type' : a().short,
2757         }
2758 ,
2759         'tmap:jtype' : Hash {
2760             'typemap' : typemap(jtype) short [],
2761             'code' : short[],
2762             'type' : a().short,
2763         }
2764 ,
2765         'tmap:out' : Hash {
2766             'typemap' : typemap(out) short [],
2767             'code' : $result = SWIG_JavaArrayOutShort(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
2768             'type' : a().short,
2769         }
2770 ,
2771         'tmap:javain' : Hash {
2772             'typemap' : typemap(javain) short [],
2773             'code' : $javainput,
2774             'type' : a().short,
2775         }
2776 ,
2777         'tmap:typecheck' : Hash {
2778             'kwargs' : Hash {
2779                 'name' : precedence,
2780                 'value' : 1035,
2781             }
2782 ,
2783             'typemap' : typemap(typecheck) short [],
2784             'code' : ,
2785             'type' : a().short,
2786         }
2787 ,
2788         'tmap:javaout' : Hash {
2789             'typemap' : typemap(javaout) short [],
2790             'code' : {
2791     return $jnicall;
2792   },
2793             'type' : a().short,
2794         }
2795 ,
2796     }
2797 ,
2798     'long long' : Hash {
2799         'tmap:jstype' : Hash {
2800             'typemap' : typemap(jstype) long long,
2801             'code' : long,
2802             'type' : long long,
2803         }
2804 ,
2805         'tmap:directorin' : Hash {
2806             'kwargs' : Hash {
2807                 'name' : descriptor,
2808                 'value' : J,
2809             }
2810 ,
2811             'typemap' : typemap(directorin) long long,
2812             'code' : $input = (jlong) $1;,
2813             'type' : long long,
2814         }
2815 ,
2816         'tmap:javadirectorin' : Hash {
2817             'typemap' : typemap(javadirectorin) long long,
2818             'code' : $jniinput,
2819             'type' : long long,
2820         }
2821 ,
2822         'tmap:in' : Hash {
2823             'kwargs' : Hash {
2824                 'name' : numinputs,
2825                 'value' : 1,
2826             }
2827 ,
2828             'typemap' : typemap(in) long long,
2829             'code' :  $1 = ($1_ltype)$input; ,
2830             'type' : long long,
2831         }
2832 ,
2833         'tmap:directorout' : Hash {
2834             'typemap' : typemap(directorout) long long,
2835             'code' :  $result = ($1_ltype)$input; ,
2836             'type' : long long,
2837         }
2838 ,
2839         'tmap:javadirectorout' : Hash {
2840             'typemap' : typemap(javadirectorout) long long,
2841             'code' : $javacall,
2842             'type' : long long,
2843         }
2844 ,
2845         'tmap:jni' : Hash {
2846             'typemap' : typemap(jni) long long,
2847             'code' : jlong,
2848             'type' : long long,
2849         }
2850 ,
2851         'tmap:jtype' : Hash {
2852             'typemap' : typemap(jtype) long long,
2853             'code' : long,
2854             'type' : long long,
2855         }
2856 ,
2857         'tmap:out' : Hash {
2858             'typemap' : typemap(out) long long,
2859             'code' :  $result = (jlong)$1; ,
2860             'type' : long long,
2861         }
2862 ,
2863         'tmap:typecheck' : Hash {
2864             'kwargs' : Hash {
2865                 'name' : precedence,
2866                 'value' : 55,
2867             }
2868 ,
2869             'typemap' : typemap(typecheck) long long,
2870             'code' : ,
2871             'type' : long long,
2872         }
2873 ,
2874         'tmap:javain' : Hash {
2875             'typemap' : typemap(javain) long long,
2876             'code' : $javainput,
2877             'type' : long long,
2878         }
2879 ,
2880         'tmap:javaout' : Hash {
2881             'typemap' : typemap(javaout) long long,
2882             'code' : {
2883     return $jnicall;
2884   },
2885             'type' : long long,
2886         }
2887 ,
2888     }
2889 ,
2890     'r.q(const).long long' : Hash {
2891         'tmap:jstype' : Hash {
2892             'typemap' : typemap(jstype) long long const &,
2893             'code' : long,
2894             'type' : r.q(const).long long,
2895         }
2896 ,
2897         'tmap:directorin' : Hash {
2898             'kwargs' : Hash {
2899                 'name' : descriptor,
2900                 'value' : J,
2901             }
2902 ,
2903             'typemap' : typemap(directorin) long long const &,
2904             'code' : $input = (jlong)$1_name;,
2905             'type' : r.q(const).long long,
2906         }
2907 ,
2908         'tmap:javadirectorin' : Hash {
2909             'locals' : Hash {
2910                 'name' : temp,
2911                 'type' : $*1_ltype,
2912             }
2913 ,
2914             'typemap' : typemap(javadirectorin) long long const &,
2915             'code' : $jniinput,
2916             'type' : r.q(const).long long,
2917         }
2918 ,
2919         'tmap:in' : Hash {
2920             'locals' : Hash {
2921                 'name' : temp,
2922                 'type' : $*1_ltype,
2923             }
2924 ,
2925             'kwargs' : Hash {
2926                 'name' : numinputs,
2927                 'value' : 1,
2928             }
2929 ,
2930             'typemap' : typemap(in) long long const &,
2931             'code' :  temp = ($*1_ltype)$input;
2932    $1 = &temp; ,
2933             'type' : r.q(const).long long,
2934         }
2935 ,
2936         'tmap:directorout' : Hash {
2937             'kwargs' : Hash {
2938                 'name' : warning,
2939                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
2940             }
2941 ,
2942             'typemap' : typemap(directorout) long long const &,
2943             'code' :  static $*1_ltype temp;
2944    temp = ($*1_ltype)$input;
2945    $result = &temp; ,
2946             'type' : r.q(const).long long,
2947         }
2948 ,
2949         'tmap:javadirectorout' : Hash {
2950             'locals' : Hash {
2951                 'name' : temp,
2952                 'type' : $*1_ltype,
2953             }
2954 ,
2955             'typemap' : typemap(javadirectorout) long long const &,
2956             'code' : $javacall,
2957             'type' : r.q(const).long long,
2958         }
2959 ,
2960         'tmap:jni' : Hash {
2961             'typemap' : typemap(jni) long long const &,
2962             'code' : jlong,
2963             'type' : r.q(const).long long,
2964         }
2965 ,
2966         'tmap:jtype' : Hash {
2967             'typemap' : typemap(jtype) long long const &,
2968             'code' : long,
2969             'type' : r.q(const).long long,
2970         }
2971 ,
2972         'tmap:out' : Hash {
2973             'typemap' : typemap(out) long long const &,
2974             'code' :  $result = (jlong)*$1; ,
2975             'type' : r.q(const).long long,
2976         }
2977 ,
2978         'tmap:typecheck' : Hash {
2979             'kwargs' : Hash {
2980                 'name' : precedence,
2981                 'value' : 55,
2982             }
2983 ,
2984             'typemap' : typemap(typecheck) long long const &,
2985             'code' : ,
2986             'type' : r.q(const).long long,
2987         }
2988 ,
2989         'tmap:javain' : Hash {
2990             'typemap' : typemap(javain) long long const &,
2991             'code' : $javainput,
2992             'type' : r.q(const).long long,
2993         }
2994 ,
2995         'tmap:javaout' : Hash {
2996             'typemap' : typemap(javaout) long long const &,
2997             'code' : {
2998     return $jnicall;
2999   },
3000             'type' : r.q(const).long long,
3001         }
3002 ,
3003     }
3004 ,
3005     'unsigned long long' : Hash {
3006         'tmap:jstype' : Hash {
3007             'typemap' : typemap(jstype) unsigned long long,
3008             'code' : java.math.BigInteger,
3009             'type' : unsigned long long,
3010         }
3011 ,
3012         'tmap:directorin' : Hash {
3013             'kwargs' : Hash {
3014                 'name' : descriptor,
3015                 'value' : Ljava/math/BigInteger;,
3016             }
3017 ,
3018             'typemap' : typemap(directorin) unsigned long long,
3019             'code' : {
3020   jbyteArray ba = jenv->NewByteArray(9);
3021   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
3022   jclass clazz = jenv->FindClass("java/math/BigInteger");
3023   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
3024   jobject bigint;
3025   int swig_i;
3026
3027   bae[0] = 0;
3028   for(swig_i=1; swig_i<9; swig_i++ ) {
3029     bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
3030   }
3031
3032   jenv->ReleaseByteArrayElements(ba, bae, 0);
3033   bigint = jenv->NewObject(clazz, mid, ba);
3034   $input = bigint;
3035 },
3036             'type' : unsigned long long,
3037         }
3038 ,
3039         'tmap:javadirectorin' : Hash {
3040             'typemap' : typemap(javadirectorin) unsigned long long,
3041             'code' : $jniinput,
3042             'type' : unsigned long long,
3043         }
3044 ,
3045         'tmap:in' : Hash {
3046             'kwargs' : Hash {
3047                 'name' : numinputs,
3048                 'value' : 1,
3049             }
3050 ,
3051             'typemap' : typemap(in) unsigned long long,
3052             'code' : {
3053   jclass clazz;
3054   jmethodID mid;
3055   jbyteArray ba;
3056   jbyte* bae;
3057   jsize sz;
3058   int i;
3059
3060   if (!$input) {
3061     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
3062     return $null;
3063   }
3064   clazz = jenv->GetObjectClass($input);
3065   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
3066   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
3067   bae = jenv->GetByteArrayElements(ba, 0);
3068   sz = jenv->GetArrayLength(ba);
3069   $1 = 0;
3070   for(i=0; i<sz; i++) {
3071     $1 = ($1 << 8) | ($1_type)(unsigned char)bae[i];
3072   }
3073   jenv->ReleaseByteArrayElements(ba, bae, 0);
3074 },
3075             'type' : unsigned long long,
3076         }
3077 ,
3078         'tmap:directorout' : Hash {
3079             'typemap' : typemap(directorout) unsigned long long,
3080             'code' : {
3081   jclass clazz;
3082   jmethodID mid;
3083   jbyteArray ba;
3084   jbyte* bae;
3085   jsize sz;
3086   int i;
3087
3088   if (!$input) {
3089     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
3090     return $null;
3091   }
3092   clazz = jenv->GetObjectClass($input);
3093   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
3094   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
3095   bae = jenv->GetByteArrayElements(ba, 0);
3096   sz = jenv->GetArrayLength(ba);
3097   $result = 0;
3098   for(i=0; i<sz; i++) {
3099     $result = ($result << 8) | ($1_type)(unsigned char)bae[i];
3100   }
3101   jenv->ReleaseByteArrayElements(ba, bae, 0);
3102 },
3103             'type' : unsigned long long,
3104         }
3105 ,
3106         'tmap:javadirectorout' : Hash {
3107             'typemap' : typemap(javadirectorout) unsigned long long,
3108             'code' : $javacall,
3109             'type' : unsigned long long,
3110         }
3111 ,
3112         'tmap:jni' : Hash {
3113             'typemap' : typemap(jni) unsigned long long,
3114             'code' : jobject,
3115             'type' : unsigned long long,
3116         }
3117 ,
3118         'tmap:jtype' : Hash {
3119             'typemap' : typemap(jtype) unsigned long long,
3120             'code' : java.math.BigInteger,
3121             'type' : unsigned long long,
3122         }
3123 ,
3124         'tmap:out' : Hash {
3125             'typemap' : typemap(out) unsigned long long,
3126             'code' : {
3127   jbyteArray ba = jenv->NewByteArray(9);
3128   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
3129   jclass clazz = jenv->FindClass("java/math/BigInteger");
3130   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
3131   jobject bigint;
3132   int i;
3133
3134   bae[0] = 0;
3135   for(i=1; i<9; i++ ) {
3136     bae[i] = (jbyte)($1>>8*(8-i));
3137   }
3138
3139   jenv->ReleaseByteArrayElements(ba, bae, 0);
3140   bigint = jenv->NewObject(clazz, mid, ba);
3141   $result = bigint;
3142 },
3143             'type' : unsigned long long,
3144         }
3145 ,
3146         'tmap:typecheck' : Hash {
3147             'kwargs' : Hash {
3148                 'name' : precedence,
3149                 'value' : 65,
3150             }
3151 ,
3152             'typemap' : typemap(typecheck) unsigned long long,
3153             'code' : ,
3154             'type' : unsigned long long,
3155         }
3156 ,
3157         'tmap:javain' : Hash {
3158             'typemap' : typemap(javain) unsigned long long,
3159             'code' : $javainput,
3160             'type' : unsigned long long,
3161         }
3162 ,
3163         'tmap:javaout' : Hash {
3164             'typemap' : typemap(javaout) unsigned long long,
3165             'code' : {
3166     return $jnicall;
3167   },
3168             'type' : unsigned long long,
3169         }
3170 ,
3171     }
3172 ,
3173     'r.q(const).unsigned long long' : Hash {
3174         'tmap:jstype' : Hash {
3175             'typemap' : typemap(jstype) unsigned long long const &,
3176             'code' : java.math.BigInteger,
3177             'type' : r.q(const).unsigned long long,
3178         }
3179 ,
3180         'tmap:directorin' : Hash {
3181             'kwargs' : Hash {
3182                 'name' : descriptor,
3183                 'value' : Ljava/math/BigInteger;,
3184             }
3185 ,
3186             'typemap' : typemap(directorin) unsigned long long const &,
3187             'code' : {
3188   jbyteArray ba = jenv->NewByteArray(9);
3189   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
3190   jclass clazz = jenv->FindClass("java/math/BigInteger");
3191   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
3192   jobject bigint;
3193   int swig_i;
3194
3195   bae[0] = 0;
3196   for(swig_i=1; swig_i<9; swig_i++ ) {
3197     bae[swig_i] = (jbyte)($1>>8*(8-swig_i));
3198   }
3199
3200   jenv->ReleaseByteArrayElements(ba, bae, 0);
3201   bigint = jenv->NewObject(clazz, mid, ba);
3202   $input = bigint;
3203 },
3204             'type' : r.q(const).unsigned long long,
3205         }
3206 ,
3207         'tmap:javadirectorin' : Hash {
3208             'typemap' : typemap(javadirectorin) unsigned long long const &,
3209             'code' : $jniinput,
3210             'type' : r.q(const).unsigned long long,
3211         }
3212 ,
3213         'tmap:in' : Hash {
3214             'locals' : Hash {
3215                 'name' : temp,
3216                 'type' : $*1_ltype,
3217             }
3218 ,
3219             'kwargs' : Hash {
3220                 'name' : numinputs,
3221                 'value' : 1,
3222             }
3223 ,
3224             'typemap' : typemap(in) unsigned long long const &,
3225             'code' : {
3226   jclass clazz;
3227   jmethodID mid;
3228   jbyteArray ba;
3229   jbyte* bae;
3230   jsize sz;
3231   int i;
3232
3233   if (!$input) {
3234     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
3235     return $null;
3236   }
3237   clazz = jenv->GetObjectClass($input);
3238   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
3239   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
3240   bae = jenv->GetByteArrayElements(ba, 0);
3241   sz = jenv->GetArrayLength(ba);
3242   $1 = &temp;
3243   temp = 0;
3244   for(i=0; i<sz; i++) {
3245     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
3246   }
3247   jenv->ReleaseByteArrayElements(ba, bae, 0);
3248 },
3249             'type' : r.q(const).unsigned long long,
3250         }
3251 ,
3252         'tmap:directorout' : Hash {
3253             'kwargs' : Hash {
3254                 'name' : warning,
3255                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
3256             }
3257 ,
3258             'typemap' : typemap(directorout) unsigned long long const &,
3259             'code' : {
3260   static $*1_ltype temp;
3261   jclass clazz;
3262   jmethodID mid;
3263   jbyteArray ba;
3264   jbyte* bae;
3265   jsize sz;
3266   int i;
3267
3268   if (!$input) {
3269     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
3270     return $null;
3271   }
3272   clazz = jenv->GetObjectClass($input);
3273   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
3274   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
3275   bae = jenv->GetByteArrayElements(ba, 0);
3276   sz = jenv->GetArrayLength(ba);
3277   $result = &temp;
3278   temp = 0;
3279   for(i=0; i<sz; i++) {
3280     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
3281   }
3282   jenv->ReleaseByteArrayElements(ba, bae, 0);
3283 },
3284             'type' : r.q(const).unsigned long long,
3285         }
3286 ,
3287         'tmap:javadirectorout' : Hash {
3288             'typemap' : typemap(javadirectorout) unsigned long long const &,
3289             'code' : $javacall,
3290             'type' : r.q(const).unsigned long long,
3291         }
3292 ,
3293         'tmap:jni' : Hash {
3294             'typemap' : typemap(jni) unsigned long long const &,
3295             'code' : jobject,
3296             'type' : r.q(const).unsigned long long,
3297         }
3298 ,
3299         'tmap:jtype' : Hash {
3300             'typemap' : typemap(jtype) unsigned long long const &,
3301             'code' : java.math.BigInteger,
3302             'type' : r.q(const).unsigned long long,
3303         }
3304 ,
3305         'tmap:out' : Hash {
3306             'typemap' : typemap(out) unsigned long long const &,
3307             'code' : {
3308   jbyteArray ba = jenv->NewByteArray(9);
3309   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
3310   jclass clazz = jenv->FindClass("java/math/BigInteger");
3311   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
3312   jobject bigint;
3313   int i;
3314
3315   bae[0] = 0;
3316   for(i=1; i<9; i++ ) {
3317     bae[i] = (jbyte)(*$1>>8*(8-i));
3318   }
3319
3320   jenv->ReleaseByteArrayElements(ba, bae, 0);
3321   bigint = jenv->NewObject(clazz, mid, ba);
3322   $result = bigint;
3323 },
3324             'type' : r.q(const).unsigned long long,
3325         }
3326 ,
3327         'tmap:typecheck' : Hash {
3328             'kwargs' : Hash {
3329                 'name' : precedence,
3330                 'value' : 65,
3331             }
3332 ,
3333             'typemap' : typemap(typecheck) unsigned long long const &,
3334             'code' : ,
3335             'type' : r.q(const).unsigned long long,
3336         }
3337 ,
3338         'tmap:javain' : Hash {
3339             'typemap' : typemap(javain) unsigned long long const &,
3340             'code' : $javainput,
3341             'type' : r.q(const).unsigned long long,
3342         }
3343 ,
3344         'tmap:javaout' : Hash {
3345             'typemap' : typemap(javaout) unsigned long long const &,
3346             'code' : {
3347     return $jnicall;
3348   },
3349             'type' : r.q(const).unsigned long long,
3350         }
3351 ,
3352     }
3353 ,
3354     'jint' : Hash {
3355         'tmap:jstype' : Hash {
3356             'typemap' : typemap(jstype) jint,
3357             'code' : int,
3358             'type' : jint,
3359         }
3360 ,
3361         'tmap:directorin' : Hash {
3362             'kwargs' : Hash {
3363                 'name' : descriptor,
3364                 'value' : I,
3365             }
3366 ,
3367             'typemap' : typemap(directorin) jint,
3368             'code' : $input = $1;,
3369             'type' : jint,
3370         }
3371 ,
3372         'tmap:javadirectorin' : Hash {
3373             'typemap' : typemap(javadirectorin) jint,
3374             'code' : $jniinput,
3375             'type' : jint,
3376         }
3377 ,
3378         'tmap:in' : Hash {
3379             'kwargs' : Hash {
3380                 'name' : numinputs,
3381                 'value' : 1,
3382             }
3383 ,
3384             'typemap' : typemap(in) jint,
3385             'code' :  $1 = $input; ,
3386             'type' : jint,
3387         }
3388 ,
3389         'tmap:directorout' : Hash {
3390             'typemap' : typemap(directorout) jint,
3391             'code' :  $result = $input; ,
3392             'type' : jint,
3393         }
3394 ,
3395         'tmap:javadirectorout' : Hash {
3396             'typemap' : typemap(javadirectorout) jint,
3397             'code' : $javacall,
3398             'type' : jint,
3399         }
3400 ,
3401         'tmap:jni' : Hash {
3402             'typemap' : typemap(jni) jint,
3403             'code' : jint,
3404             'type' : jint,
3405         }
3406 ,
3407         'tmap:jtype' : Hash {
3408             'typemap' : typemap(jtype) jint,
3409             'code' : int,
3410             'type' : jint,
3411         }
3412 ,
3413         'tmap:out' : Hash {
3414             'typemap' : typemap(out) jint,
3415             'code' :  $result = $1; ,
3416             'type' : jint,
3417         }
3418 ,
3419         'tmap:typecheck' : Hash {
3420             'kwargs' : Hash {
3421                 'name' : precedence,
3422                 'value' : 45,
3423             }
3424 ,
3425             'typemap' : typemap(typecheck) jint,
3426             'code' : ,
3427             'type' : jint,
3428         }
3429 ,
3430         'tmap:javain' : Hash {
3431             'typemap' : typemap(javain) jint,
3432             'code' : $javainput,
3433             'type' : jint,
3434         }
3435 ,
3436         'tmap:javaout' : Hash {
3437             'typemap' : typemap(javaout) jint,
3438             'code' : {
3439     return $jnicall;
3440   },
3441             'type' : jint,
3442         }
3443 ,
3444     }
3445 ,
3446     'p.long long' : Hash {
3447         'INOUT' : Hash {
3448             'tmap:freearg' : Hash {
3449                 'pname' : INOUT,
3450                 'typemap' : typemap(freearg) long long *INOUT,
3451                 'code' : ,
3452                 'type' : p.long long,
3453             }
3454 ,
3455             'tmap:jstype' : Hash {
3456                 'pname' : INOUT,
3457                 'typemap' : typemap(jstype) long long *INOUT,
3458                 'code' : long[],
3459                 'type' : p.long long,
3460             }
3461 ,
3462             'tmap:javadirectorin' : Hash {
3463                 'pname' : INOUT,
3464                 'typemap' : typemap(javadirectorin) long long *INOUT,
3465                 'code' : $jniinput,
3466                 'type' : p.long long,
3467             }
3468 ,
3469             'tmap:directorin' : Hash {
3470                 'kwargs' : Hash {
3471                     'name' : descriptor,
3472                     'value' : [Ljava/lang/Long;,
3473                     'nextSibling' : Hash {
3474                         'name' : warning,
3475                         'value' : Need to provide long long *INOUT directorin typemap, long long array length is unknown,
3476                     }
3477 ,
3478                 }
3479 ,
3480                 'pname' : INOUT,
3481                 'typemap' : typemap(directorin) long long *INOUT,
3482                 'code' : {
3483 },
3484                 'type' : p.long long,
3485             }
3486 ,
3487             'tmap:argout' : Hash {
3488                 'pname' : INOUT,
3489                 'typemap' : typemap(argout) long long *INOUT,
3490                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
3491                 'type' : p.long long,
3492             }
3493 ,
3494             'tmap:javadirectorout' : Hash {
3495                 'pname' : INOUT,
3496                 'typemap' : typemap(javadirectorout) long long *INOUT,
3497                 'code' : $javacall,
3498                 'type' : p.long long,
3499             }
3500 ,
3501             'tmap:in' : Hash {
3502                 'kwargs' : Hash {
3503                     'name' : numinputs,
3504                     'value' : 1,
3505                 }
3506 ,
3507                 'pname' : INOUT,
3508                 'typemap' : typemap(in) long long *INOUT,
3509                 'code' : {
3510   if (!$input) {
3511     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3512     return $null;
3513   }
3514   if (jenv->GetArrayLength($input) == 0) {
3515     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3516     return $null;
3517   }
3518   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
3519 },
3520                 'type' : p.long long,
3521             }
3522 ,
3523             'tmap:directorout' : Hash {
3524                 'kwargs' : Hash {
3525                     'name' : warning,
3526                     'value' : Need to provide long long *INOUT directorout typemap,
3527                 }
3528 ,
3529                 'pname' : INOUT,
3530                 'typemap' : typemap(directorout) long long *INOUT,
3531                 'code' : {
3532 },
3533                 'type' : p.long long,
3534             }
3535 ,
3536             'tmap:typecheck' : Hash {
3537                 'kwargs' : Hash {
3538                     'name' : precedence,
3539                     'value' : 1055,
3540                 }
3541 ,
3542                 'pname' : INOUT,
3543                 'typemap' : typemap(typecheck) long long *INOUT,
3544                 'code' : ,
3545                 'type' : p.long long,
3546             }
3547 ,
3548             'tmap:jni' : Hash {
3549                 'pname' : INOUT,
3550                 'typemap' : typemap(jni) long long *INOUT,
3551                 'code' : jlongArray,
3552                 'type' : p.long long,
3553             }
3554 ,
3555             'tmap:jtype' : Hash {
3556                 'pname' : INOUT,
3557                 'typemap' : typemap(jtype) long long *INOUT,
3558                 'code' : long[],
3559                 'type' : p.long long,
3560             }
3561 ,
3562             'tmap:javain' : Hash {
3563                 'pname' : INOUT,
3564                 'typemap' : typemap(javain) long long *INOUT,
3565                 'code' : $javainput,
3566                 'type' : p.long long,
3567             }
3568 ,
3569         }
3570 ,
3571         'INPUT' : Hash {
3572             'tmap:freearg' : Hash {
3573                 'pname' : INPUT,
3574                 'typemap' : typemap(freearg) long long *INPUT,
3575                 'code' : ,
3576                 'type' : p.long long,
3577             }
3578 ,
3579             'tmap:jstype' : Hash {
3580                 'pname' : INPUT,
3581                 'typemap' : typemap(jstype) long long *INPUT,
3582                 'code' : long,
3583                 'type' : p.long long,
3584             }
3585 ,
3586             'tmap:javadirectorin' : Hash {
3587                 'pname' : INPUT,
3588                 'typemap' : typemap(javadirectorin) long long *INPUT,
3589                 'code' : $jniinput,
3590                 'type' : p.long long,
3591             }
3592 ,
3593             'tmap:directorin' : Hash {
3594                 'kwargs' : Hash {
3595                     'name' : descriptor,
3596                     'value' : J,
3597                 }
3598 ,
3599                 'pname' : INPUT,
3600                 'typemap' : typemap(directorin) long long *INPUT,
3601                 'code' :  *(($&1_ltype) $input) = (jlong *) $1; ,
3602                 'type' : p.long long,
3603             }
3604 ,
3605             'tmap:javadirectorout' : Hash {
3606                 'pname' : INPUT,
3607                 'typemap' : typemap(javadirectorout) long long *INPUT,
3608                 'code' : $javacall,
3609                 'type' : p.long long,
3610             }
3611 ,
3612             'tmap:in' : Hash {
3613                 'kwargs' : Hash {
3614                     'name' : numinputs,
3615                     'value' : 1,
3616                 }
3617 ,
3618                 'pname' : INPUT,
3619                 'typemap' : typemap(in) long long *INPUT,
3620                 'code' :  $1 = ($1_ltype)&$input; ,
3621                 'type' : p.long long,
3622             }
3623 ,
3624             'tmap:directorout' : Hash {
3625                 'pname' : INPUT,
3626                 'typemap' : typemap(directorout) long long *INPUT,
3627                 'code' :  $result = ($1_ltype)&$input; ,
3628                 'type' : p.long long,
3629             }
3630 ,
3631             'tmap:jni' : Hash {
3632                 'pname' : INPUT,
3633                 'typemap' : typemap(jni) long long *INPUT,
3634                 'code' : jlong,
3635                 'type' : p.long long,
3636             }
3637 ,
3638             'tmap:jtype' : Hash {
3639                 'pname' : INPUT,
3640                 'typemap' : typemap(jtype) long long *INPUT,
3641                 'code' : long,
3642                 'type' : p.long long,
3643             }
3644 ,
3645             'tmap:javain' : Hash {
3646                 'pname' : INPUT,
3647                 'typemap' : typemap(javain) long long *INPUT,
3648                 'code' : $javainput,
3649                 'type' : p.long long,
3650             }
3651 ,
3652             'tmap:typecheck' : Hash {
3653                 'kwargs' : Hash {
3654                     'name' : precedence,
3655                     'value' : 55,
3656                 }
3657 ,
3658                 'pname' : INPUT,
3659                 'typemap' : typemap(typecheck) long long *INPUT,
3660                 'code' : ,
3661                 'type' : p.long long,
3662             }
3663 ,
3664         }
3665 ,
3666         'OUTPUT' : Hash {
3667             'tmap:freearg' : Hash {
3668                 'pname' : OUTPUT,
3669                 'typemap' : typemap(freearg) long long *OUTPUT,
3670                 'code' : ,
3671                 'type' : p.long long,
3672             }
3673 ,
3674             'tmap:jstype' : Hash {
3675                 'pname' : OUTPUT,
3676                 'typemap' : typemap(jstype) long long *OUTPUT,
3677                 'code' : long[],
3678                 'type' : p.long long,
3679             }
3680 ,
3681             'tmap:javadirectorin' : Hash {
3682                 'pname' : OUTPUT,
3683                 'typemap' : typemap(javadirectorin) long long *OUTPUT,
3684                 'code' : $jniinput,
3685                 'type' : p.long long,
3686             }
3687 ,
3688             'tmap:directorin' : Hash {
3689                 'kwargs' : Hash {
3690                     'name' : descriptor,
3691                     'value' : [Ljava/lang/Long;,
3692                     'nextSibling' : Hash {
3693                         'name' : warning,
3694                         'value' : Need to provide long long *OUTPUT directorin typemap, long long array length is unknown,
3695                     }
3696 ,
3697                 }
3698 ,
3699                 'pname' : OUTPUT,
3700                 'typemap' : typemap(directorin) long long *OUTPUT,
3701                 'code' : {
3702 },
3703                 'type' : p.long long,
3704             }
3705 ,
3706             'tmap:argout' : Hash {
3707                 'pname' : OUTPUT,
3708                 'typemap' : typemap(argout) long long *OUTPUT,
3709                 'code' : {
3710   jlong jvalue = (jlong)temp$argnum;
3711   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
3712 },
3713                 'type' : p.long long,
3714             }
3715 ,
3716             'tmap:javadirectorout' : Hash {
3717                 'pname' : OUTPUT,
3718                 'typemap' : typemap(javadirectorout) long long *OUTPUT,
3719                 'code' : $javacall,
3720                 'type' : p.long long,
3721             }
3722 ,
3723             'tmap:in' : Hash {
3724                 'locals' : Hash {
3725                     'name' : temp,
3726                     'type' : $*1_ltype,
3727                 }
3728 ,
3729                 'kwargs' : Hash {
3730                     'name' : numinputs,
3731                     'value' : 1,
3732                 }
3733 ,
3734                 'pname' : OUTPUT,
3735                 'typemap' : typemap(in) long long *OUTPUT,
3736                 'code' : {
3737   if (!$input) {
3738     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3739     return $null;
3740   }
3741   if (jenv->GetArrayLength($input) == 0) {
3742     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3743     return $null;
3744   }
3745   $1 = &temp;
3746 },
3747                 'type' : p.long long,
3748             }
3749 ,
3750             'tmap:directorout' : Hash {
3751                 'kwargs' : Hash {
3752                     'name' : warning,
3753                     'value' : Need to provide long long *OUTPUT directorout typemap,
3754                 }
3755 ,
3756                 'pname' : OUTPUT,
3757                 'typemap' : typemap(directorout) long long *OUTPUT,
3758                 'code' : {
3759 },
3760                 'type' : p.long long,
3761             }
3762 ,
3763             'tmap:jni' : Hash {
3764                 'pname' : OUTPUT,
3765                 'typemap' : typemap(jni) long long *OUTPUT,
3766                 'code' : jlongArray,
3767                 'type' : p.long long,
3768             }
3769 ,
3770             'tmap:jtype' : Hash {
3771                 'pname' : OUTPUT,
3772                 'typemap' : typemap(jtype) long long *OUTPUT,
3773                 'code' : long[],
3774                 'type' : p.long long,
3775             }
3776 ,
3777             'tmap:javain' : Hash {
3778                 'pname' : OUTPUT,
3779                 'typemap' : typemap(javain) long long *OUTPUT,
3780                 'code' : $javainput,
3781                 'type' : p.long long,
3782             }
3783 ,
3784         }
3785 ,
3786     }
3787 ,
3788     'r.long long' : Hash {
3789         'INOUT' : Hash {
3790             'tmap:freearg' : Hash {
3791                 'pname' : INOUT,
3792                 'typemap' : typemap(freearg) long long &INOUT,
3793                 'code' : ,
3794                 'type' : r.long long,
3795             }
3796 ,
3797             'tmap:jstype' : Hash {
3798                 'pname' : INOUT,
3799                 'typemap' : typemap(jstype) long long &INOUT,
3800                 'code' : long[],
3801                 'type' : r.long long,
3802             }
3803 ,
3804             'tmap:javadirectorin' : Hash {
3805                 'pname' : INOUT,
3806                 'typemap' : typemap(javadirectorin) long long &INOUT,
3807                 'code' : $jniinput,
3808                 'type' : r.long long,
3809             }
3810 ,
3811             'tmap:directorin' : Hash {
3812                 'kwargs' : Hash {
3813                     'name' : descriptor,
3814                     'value' : [Ljava/lang/Long;,
3815                     'nextSibling' : Hash {
3816                         'name' : warning,
3817                         'value' : Need to provide long long *INOUT directorin typemap, long long array length is unknown,
3818                     }
3819 ,
3820                 }
3821 ,
3822                 'pname' : INOUT,
3823                 'typemap' : typemap(directorin) long long &INOUT,
3824                 'code' : {
3825 },
3826                 'type' : r.long long,
3827             }
3828 ,
3829             'tmap:argout' : Hash {
3830                 'pname' : INOUT,
3831                 'typemap' : typemap(argout) long long &INOUT,
3832                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
3833                 'type' : r.long long,
3834             }
3835 ,
3836             'tmap:javadirectorout' : Hash {
3837                 'pname' : INOUT,
3838                 'typemap' : typemap(javadirectorout) long long &INOUT,
3839                 'code' : $javacall,
3840                 'type' : r.long long,
3841             }
3842 ,
3843             'tmap:in' : Hash {
3844                 'kwargs' : Hash {
3845                     'name' : numinputs,
3846                     'value' : 1,
3847                 }
3848 ,
3849                 'pname' : INOUT,
3850                 'typemap' : typemap(in) long long &INOUT,
3851                 'code' : {
3852   if (!$input) {
3853     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
3854     return $null;
3855   }
3856   if (jenv->GetArrayLength($input) == 0) {
3857     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
3858     return $null;
3859   }
3860   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
3861 },
3862                 'type' : r.long long,
3863             }
3864 ,
3865             'tmap:directorout' : Hash {
3866                 'kwargs' : Hash {
3867                     'name' : warning,
3868                     'value' : Need to provide long long *INOUT directorout typemap,
3869                 }
3870 ,
3871                 'pname' : INOUT,
3872                 'typemap' : typemap(directorout) long long &INOUT,
3873                 'code' : {
3874 },
3875                 'type' : r.long long,
3876             }
3877 ,
3878             'tmap:typecheck' : Hash {
3879                 'kwargs' : Hash {
3880                     'name' : precedence,
3881                     'value' : 1055,
3882                 }
3883 ,
3884                 'pname' : INOUT,
3885                 'typemap' : typemap(typecheck) long long &INOUT,
3886                 'code' : ,
3887                 'type' : r.long long,
3888             }
3889 ,
3890             'tmap:jni' : Hash {
3891                 'pname' : INOUT,
3892                 'typemap' : typemap(jni) long long &INOUT,
3893                 'code' : jlongArray,
3894                 'type' : r.long long,
3895             }
3896 ,
3897             'tmap:jtype' : Hash {
3898                 'pname' : INOUT,
3899                 'typemap' : typemap(jtype) long long &INOUT,
3900                 'code' : long[],
3901                 'type' : r.long long,
3902             }
3903 ,
3904             'tmap:javain' : Hash {
3905                 'pname' : INOUT,
3906                 'typemap' : typemap(javain) long long &INOUT,
3907                 'code' : $javainput,
3908                 'type' : r.long long,
3909             }
3910 ,
3911         }
3912 ,
3913         'INPUT' : Hash {
3914             'tmap:freearg' : Hash {
3915                 'pname' : INPUT,
3916                 'typemap' : typemap(freearg) long long &INPUT,
3917                 'code' : ,
3918                 'type' : r.long long,
3919             }
3920 ,
3921             'tmap:jstype' : Hash {
3922                 'pname' : INPUT,
3923                 'typemap' : typemap(jstype) long long &INPUT,
3924                 'code' : long,
3925                 'type' : r.long long,
3926             }
3927 ,
3928             'tmap:javadirectorin' : Hash {
3929                 'pname' : INPUT,
3930                 'typemap' : typemap(javadirectorin) long long &INPUT,
3931                 'code' : $jniinput,
3932                 'type' : r.long long,
3933             }
3934 ,
3935             'tmap:directorin' : Hash {
3936                 'kwargs' : Hash {
3937                     'name' : descriptor,
3938                     'value' : J,
3939                 }
3940 ,
3941                 'pname' : INPUT,
3942                 'typemap' : typemap(directorin) long long &INPUT,
3943                 'code' :  *(($&1_ltype) $input) = (jlong *) &$1; ,
3944                 'type' : r.long long,
3945             }
3946 ,
3947             'tmap:javadirectorout' : Hash {
3948                 'pname' : INPUT,
3949                 'typemap' : typemap(javadirectorout) long long &INPUT,
3950                 'code' : $javacall,
3951                 'type' : r.long long,
3952             }
3953 ,
3954             'tmap:in' : Hash {
3955                 'kwargs' : Hash {
3956                     'name' : numinputs,
3957                     'value' : 1,
3958                 }
3959 ,
3960                 'pname' : INPUT,
3961                 'typemap' : typemap(in) long long &INPUT,
3962                 'code' :  $1 = ($1_ltype)&$input; ,
3963                 'type' : r.long long,
3964             }
3965 ,
3966             'tmap:directorout' : Hash {
3967                 'pname' : INPUT,
3968                 'typemap' : typemap(directorout) long long &INPUT,
3969                 'code' :  $result = ($1_ltype)&$input; ,
3970                 'type' : r.long long,
3971             }
3972 ,
3973             'tmap:jni' : Hash {
3974                 'pname' : INPUT,
3975                 'typemap' : typemap(jni) long long &INPUT,
3976                 'code' : jlong,
3977                 'type' : r.long long,
3978             }
3979 ,
3980             'tmap:jtype' : Hash {
3981                 'pname' : INPUT,
3982                 'typemap' : typemap(jtype) long long &INPUT,
3983                 'code' : long,
3984                 'type' : r.long long,
3985             }
3986 ,
3987             'tmap:javain' : Hash {
3988                 'pname' : INPUT,
3989                 'typemap' : typemap(javain) long long &INPUT,
3990                 'code' : $javainput,
3991                 'type' : r.long long,
3992             }
3993 ,
3994             'tmap:typecheck' : Hash {
3995                 'kwargs' : Hash {
3996                     'name' : precedence,
3997                     'value' : 55,
3998                 }
3999 ,
4000                 'pname' : INPUT,
4001                 'typemap' : typemap(typecheck) long long &INPUT,
4002                 'code' : ,
4003                 'type' : r.long long,
4004             }
4005 ,
4006         }
4007 ,
4008         'OUTPUT' : Hash {
4009             'tmap:freearg' : Hash {
4010                 'pname' : OUTPUT,
4011                 'typemap' : typemap(freearg) long long &OUTPUT,
4012                 'code' : ,
4013                 'type' : r.long long,
4014             }
4015 ,
4016             'tmap:jstype' : Hash {
4017                 'pname' : OUTPUT,
4018                 'typemap' : typemap(jstype) long long &OUTPUT,
4019                 'code' : long[],
4020                 'type' : r.long long,
4021             }
4022 ,
4023             'tmap:javadirectorin' : Hash {
4024                 'pname' : OUTPUT,
4025                 'typemap' : typemap(javadirectorin) long long &OUTPUT,
4026                 'code' : $jniinput,
4027                 'type' : r.long long,
4028             }
4029 ,
4030             'tmap:directorin' : Hash {
4031                 'kwargs' : Hash {
4032                     'name' : descriptor,
4033                     'value' : [Ljava/lang/Long;,
4034                 }
4035 ,
4036                 'pname' : OUTPUT,
4037                 'typemap' : typemap(directorin) long long &OUTPUT,
4038                 'code' :  *(($&1_ltype) $input = &$1; ,
4039                 'type' : r.long long,
4040             }
4041 ,
4042             'tmap:argout' : Hash {
4043                 'pname' : OUTPUT,
4044                 'typemap' : typemap(argout) long long &OUTPUT,
4045                 'code' : {
4046   jlong jvalue = (jlong)temp$argnum;
4047   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
4048 },
4049                 'type' : r.long long,
4050             }
4051 ,
4052             'tmap:javadirectorout' : Hash {
4053                 'pname' : OUTPUT,
4054                 'typemap' : typemap(javadirectorout) long long &OUTPUT,
4055                 'code' : $javacall,
4056                 'type' : r.long long,
4057             }
4058 ,
4059             'tmap:in' : Hash {
4060                 'locals' : Hash {
4061                     'name' : temp,
4062                     'type' : $*1_ltype,
4063                 }
4064 ,
4065                 'kwargs' : Hash {
4066                     'name' : numinputs,
4067                     'value' : 1,
4068                 }
4069 ,
4070                 'pname' : OUTPUT,
4071                 'typemap' : typemap(in) long long &OUTPUT,
4072                 'code' : {
4073   if (!$input) {
4074     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4075     return $null;
4076   }
4077   if (jenv->GetArrayLength($input) == 0) {
4078     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4079     return $null;
4080   }
4081   $1 = &temp;
4082 },
4083                 'type' : r.long long,
4084             }
4085 ,
4086             'tmap:directorout' : Hash {
4087                 'kwargs' : Hash {
4088                     'name' : warning,
4089                     'value' : Need to provide long long *OUTPUT directorout typemap,
4090                 }
4091 ,
4092                 'pname' : OUTPUT,
4093                 'typemap' : typemap(directorout) long long &OUTPUT,
4094                 'code' : {
4095 },
4096                 'type' : r.long long,
4097             }
4098 ,
4099             'tmap:jni' : Hash {
4100                 'pname' : OUTPUT,
4101                 'typemap' : typemap(jni) long long &OUTPUT,
4102                 'code' : jlongArray,
4103                 'type' : r.long long,
4104             }
4105 ,
4106             'tmap:jtype' : Hash {
4107                 'pname' : OUTPUT,
4108                 'typemap' : typemap(jtype) long long &OUTPUT,
4109                 'code' : long[],
4110                 'type' : r.long long,
4111             }
4112 ,
4113             'tmap:javain' : Hash {
4114                 'pname' : OUTPUT,
4115                 'typemap' : typemap(javain) long long &OUTPUT,
4116                 'code' : $javainput,
4117                 'type' : r.long long,
4118             }
4119 ,
4120         }
4121 ,
4122     }
4123 ,
4124     'p.unsigned long long' : Hash {
4125         'INOUT' : Hash {
4126             'tmap:freearg' : Hash {
4127                 'pname' : INOUT,
4128                 'typemap' : typemap(freearg) unsigned long long *INOUT,
4129                 'code' : ,
4130                 'type' : p.unsigned long long,
4131             }
4132 ,
4133             'tmap:jstype' : Hash {
4134                 'pname' : INOUT,
4135                 'typemap' : typemap(jstype) unsigned long long *INOUT,
4136                 'code' : java.math.BigInteger[],
4137                 'type' : p.unsigned long long,
4138             }
4139 ,
4140             'tmap:javadirectorin' : Hash {
4141                 'pname' : INOUT,
4142                 'typemap' : typemap(javadirectorin) unsigned long long *INOUT,
4143                 'code' : $jniinput,
4144                 'type' : p.unsigned long long,
4145             }
4146 ,
4147             'tmap:directorin' : Hash {
4148                 'kwargs' : Hash {
4149                     'name' : descriptor,
4150                     'value' : [Ljava.math.BigInteger;,
4151                     'nextSibling' : Hash {
4152                         'name' : warning,
4153                         'value' : Need to provide unsigned long long *INOUT directorin typemap, unsigned long long array length is unknown,
4154                     }
4155 ,
4156                 }
4157 ,
4158                 'pname' : INOUT,
4159                 'typemap' : typemap(directorin) unsigned long long *INOUT,
4160                 'code' : {
4161 },
4162                 'type' : p.unsigned long long,
4163             }
4164 ,
4165             'tmap:argout' : Hash {
4166                 'pname' : INOUT,
4167                 'typemap' : typemap(argout) unsigned long long *INOUT,
4168                 'code' : {
4169   jbyteArray ba = jenv->NewByteArray(9);
4170   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
4171   jclass clazz = jenv->FindClass("java/math/BigInteger");
4172   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
4173   jobject bigint;
4174   int i;
4175
4176   bae[0] = 0;
4177   for(i=1; i<9; i++ ) {
4178     bae[i] = (jbyte)(temp$argnum>>8*(8-i));
4179   }
4180
4181   jenv->ReleaseByteArrayElements(ba, bae, 0);
4182   bigint = jenv->NewObject(clazz, mid, ba);
4183   jenv->SetObjectArrayElement($input, 0, bigint);
4184 },
4185                 'type' : p.unsigned long long,
4186             }
4187 ,
4188             'tmap:javadirectorout' : Hash {
4189                 'pname' : INOUT,
4190                 'typemap' : typemap(javadirectorout) unsigned long long *INOUT,
4191                 'code' : $javacall,
4192                 'type' : p.unsigned long long,
4193             }
4194 ,
4195             'tmap:in' : Hash {
4196                 'kwargs' : Hash {
4197                     'name' : numinputs,
4198                     'value' : 1,
4199                 }
4200 ,
4201                 'locals' : Hash {
4202                     'name' : temp,
4203                     'type' : $*1_ltype,
4204                 }
4205 ,
4206                 'pname' : INOUT,
4207                 'typemap' : typemap(in) unsigned long long *INOUT,
4208                 'code' : {
4209   jobject bigint;
4210   jclass clazz;
4211   jmethodID mid;
4212   jbyteArray ba;
4213   jbyte* bae;
4214   jsize sz;
4215   int i;
4216
4217   if (!$input) {
4218     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4219     return $null;
4220   }
4221   if (jenv->GetArrayLength($input) == 0) {
4222     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4223     return $null;
4224   }
4225   bigint = jenv->GetObjectArrayElement($input, 0);
4226   if (!bigint) {
4227     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
4228     return $null;
4229   }
4230   clazz = jenv->GetObjectClass(bigint);
4231   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
4232   ba = (jbyteArray)jenv->CallObjectMethod(bigint, mid);
4233   bae = jenv->GetByteArrayElements(ba, 0);
4234   sz = jenv->GetArrayLength(ba);
4235   temp = 0;
4236   for(i=0; i<sz; i++) {
4237     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
4238   }
4239   jenv->ReleaseByteArrayElements(ba, bae, 0);
4240   $1 = &temp;
4241 },
4242                 'type' : p.unsigned long long,
4243             }
4244 ,
4245             'tmap:directorout' : Hash {
4246                 'kwargs' : Hash {
4247                     'name' : warning,
4248                     'value' : Need to provide unsigned long long *INOUT directorout typemap,
4249                 }
4250 ,
4251                 'pname' : INOUT,
4252                 'typemap' : typemap(directorout) unsigned long long *INOUT,
4253                 'code' : {
4254 },
4255                 'type' : p.unsigned long long,
4256             }
4257 ,
4258             'tmap:typecheck' : Hash {
4259                 'kwargs' : Hash {
4260                     'name' : precedence,
4261                     'value' : 1065,
4262                 }
4263 ,
4264                 'pname' : INOUT,
4265                 'typemap' : typemap(typecheck) unsigned long long *INOUT,
4266                 'code' : ,
4267                 'type' : p.unsigned long long,
4268             }
4269 ,
4270             'tmap:jni' : Hash {
4271                 'pname' : INOUT,
4272                 'typemap' : typemap(jni) unsigned long long *INOUT,
4273                 'code' : jobjectArray,
4274                 'type' : p.unsigned long long,
4275             }
4276 ,
4277             'tmap:jtype' : Hash {
4278                 'pname' : INOUT,
4279                 'typemap' : typemap(jtype) unsigned long long *INOUT,
4280                 'code' : java.math.BigInteger[],
4281                 'type' : p.unsigned long long,
4282             }
4283 ,
4284             'tmap:javain' : Hash {
4285                 'pname' : INOUT,
4286                 'typemap' : typemap(javain) unsigned long long *INOUT,
4287                 'code' : $javainput,
4288                 'type' : p.unsigned long long,
4289             }
4290 ,
4291         }
4292 ,
4293         'INPUT' : Hash {
4294             'tmap:freearg' : Hash {
4295                 'pname' : INPUT,
4296                 'typemap' : typemap(freearg) unsigned long long *INPUT,
4297                 'code' : ,
4298                 'type' : p.unsigned long long,
4299             }
4300 ,
4301             'tmap:jstype' : Hash {
4302                 'pname' : INPUT,
4303                 'typemap' : typemap(jstype) unsigned long long *INPUT,
4304                 'code' : java.math.BigInteger,
4305                 'type' : p.unsigned long long,
4306             }
4307 ,
4308             'tmap:javadirectorin' : Hash {
4309                 'pname' : INPUT,
4310                 'typemap' : typemap(javadirectorin) unsigned long long *INPUT,
4311                 'code' : $jniinput,
4312                 'type' : p.unsigned long long,
4313             }
4314 ,
4315             'tmap:directorin' : Hash {
4316                 'kwargs' : Hash {
4317                     'name' : descriptor,
4318                     'value' : Ljava/math/BigInteger;,
4319                 }
4320 ,
4321                 'pname' : INPUT,
4322                 'typemap' : typemap(directorin) unsigned long long *INPUT,
4323                 'code' :  *(($&1_ltype) $input) = (jobject *) $1; ,
4324                 'type' : p.unsigned long long,
4325             }
4326 ,
4327             'tmap:javadirectorout' : Hash {
4328                 'pname' : INPUT,
4329                 'typemap' : typemap(javadirectorout) unsigned long long *INPUT,
4330                 'code' : $javacall,
4331                 'type' : p.unsigned long long,
4332             }
4333 ,
4334             'tmap:in' : Hash {
4335                 'kwargs' : Hash {
4336                     'name' : numinputs,
4337                     'value' : 1,
4338                 }
4339 ,
4340                 'locals' : Hash {
4341                     'name' : temp,
4342                     'type' : $*1_ltype,
4343                 }
4344 ,
4345                 'pname' : INPUT,
4346                 'typemap' : typemap(in) unsigned long long *INPUT,
4347                 'code' : {
4348   jclass clazz;
4349   jmethodID mid;
4350   jbyteArray ba;
4351   jbyte* bae;
4352   jsize sz;
4353   int i;
4354
4355   if (!$input) {
4356     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
4357     return $null;
4358   }
4359   clazz = jenv->GetObjectClass($input);
4360   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
4361   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
4362   bae = jenv->GetByteArrayElements(ba, 0);
4363   sz = jenv->GetArrayLength(ba);
4364   temp = 0;
4365   for(i=0; i<sz; i++) {
4366     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
4367   }
4368   jenv->ReleaseByteArrayElements(ba, bae, 0);
4369   $1 = &temp;
4370 },
4371                 'type' : p.unsigned long long,
4372             }
4373 ,
4374             'tmap:directorout' : Hash {
4375                 'pname' : INPUT,
4376                 'typemap' : typemap(directorout) unsigned long long *INPUT,
4377                 'code' :  $result = ($1_ltype)&$input; ,
4378                 'type' : p.unsigned long long,
4379             }
4380 ,
4381             'tmap:jni' : Hash {
4382                 'pname' : INPUT,
4383                 'typemap' : typemap(jni) unsigned long long *INPUT,
4384                 'code' : jobject,
4385                 'type' : p.unsigned long long,
4386             }
4387 ,
4388             'tmap:jtype' : Hash {
4389                 'pname' : INPUT,
4390                 'typemap' : typemap(jtype) unsigned long long *INPUT,
4391                 'code' : java.math.BigInteger,
4392                 'type' : p.unsigned long long,
4393             }
4394 ,
4395             'tmap:javain' : Hash {
4396                 'pname' : INPUT,
4397                 'typemap' : typemap(javain) unsigned long long *INPUT,
4398                 'code' : $javainput,
4399                 'type' : p.unsigned long long,
4400             }
4401 ,
4402             'tmap:typecheck' : Hash {
4403                 'kwargs' : Hash {
4404                     'name' : precedence,
4405                     'value' : 65,
4406                 }
4407 ,
4408                 'pname' : INPUT,
4409                 'typemap' : typemap(typecheck) unsigned long long *INPUT,
4410                 'code' : ,
4411                 'type' : p.unsigned long long,
4412             }
4413 ,
4414         }
4415 ,
4416         'OUTPUT' : Hash {
4417             'tmap:freearg' : Hash {
4418                 'pname' : OUTPUT,
4419                 'typemap' : typemap(freearg) unsigned long long *OUTPUT,
4420                 'code' : ,
4421                 'type' : p.unsigned long long,
4422             }
4423 ,
4424             'tmap:jstype' : Hash {
4425                 'pname' : OUTPUT,
4426                 'typemap' : typemap(jstype) unsigned long long *OUTPUT,
4427                 'code' : java.math.BigInteger[],
4428                 'type' : p.unsigned long long,
4429             }
4430 ,
4431             'tmap:javadirectorin' : Hash {
4432                 'pname' : OUTPUT,
4433                 'typemap' : typemap(javadirectorin) unsigned long long *OUTPUT,
4434                 'code' : $jniinput,
4435                 'type' : p.unsigned long long,
4436             }
4437 ,
4438             'tmap:directorin' : Hash {
4439                 'kwargs' : Hash {
4440                     'name' : descriptor,
4441                     'value' : [Ljava/lang/BigInteger;,
4442                     'nextSibling' : Hash {
4443                         'name' : warning,
4444                         'value' : Need to provide unsigned long long *OUTPUT directorin typemap, unsigned long long array length is unknown,
4445                     }
4446 ,
4447                 }
4448 ,
4449                 'pname' : OUTPUT,
4450                 'typemap' : typemap(directorin) unsigned long long *OUTPUT,
4451                 'code' : {
4452 },
4453                 'type' : p.unsigned long long,
4454             }
4455 ,
4456             'tmap:argout' : Hash {
4457                 'pname' : OUTPUT,
4458                 'typemap' : typemap(argout) unsigned long long *OUTPUT,
4459                 'code' : {
4460   jbyteArray ba = jenv->NewByteArray(9);
4461   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
4462   jclass clazz = jenv->FindClass("java/math/BigInteger");
4463   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
4464   jobject bigint;
4465   int i;
4466
4467   bae[0] = 0;
4468   for(i=1; i<9; i++ ) {
4469     bae[i] = (jbyte)(temp$argnum>>8*(8-i));
4470   }
4471
4472   jenv->ReleaseByteArrayElements(ba, bae, 0);
4473   bigint = jenv->NewObject(clazz, mid, ba);
4474   jenv->SetObjectArrayElement($input, 0, bigint);
4475 },
4476                 'type' : p.unsigned long long,
4477             }
4478 ,
4479             'tmap:javadirectorout' : Hash {
4480                 'pname' : OUTPUT,
4481                 'typemap' : typemap(javadirectorout) unsigned long long *OUTPUT,
4482                 'code' : $javacall,
4483                 'type' : p.unsigned long long,
4484             }
4485 ,
4486             'tmap:in' : Hash {
4487                 'locals' : Hash {
4488                     'name' : temp,
4489                     'type' : $*1_ltype,
4490                 }
4491 ,
4492                 'kwargs' : Hash {
4493                     'name' : numinputs,
4494                     'value' : 1,
4495                 }
4496 ,
4497                 'pname' : OUTPUT,
4498                 'typemap' : typemap(in) unsigned long long *OUTPUT,
4499                 'code' : {
4500   if (!$input) {
4501     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4502     return $null;
4503   }
4504   if (jenv->GetArrayLength($input) == 0) {
4505     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4506     return $null;
4507   }
4508   $1 = &temp;
4509 },
4510                 'type' : p.unsigned long long,
4511             }
4512 ,
4513             'tmap:directorout' : Hash {
4514                 'kwargs' : Hash {
4515                     'name' : warning,
4516                     'value' : Need to provide unsigned long long *OUTPUT directorout typemap,
4517                 }
4518 ,
4519                 'pname' : OUTPUT,
4520                 'typemap' : typemap(directorout) unsigned long long *OUTPUT,
4521                 'code' : {
4522 },
4523                 'type' : p.unsigned long long,
4524             }
4525 ,
4526             'tmap:jni' : Hash {
4527                 'pname' : OUTPUT,
4528                 'typemap' : typemap(jni) unsigned long long *OUTPUT,
4529                 'code' : jobjectArray,
4530                 'type' : p.unsigned long long,
4531             }
4532 ,
4533             'tmap:jtype' : Hash {
4534                 'pname' : OUTPUT,
4535                 'typemap' : typemap(jtype) unsigned long long *OUTPUT,
4536                 'code' : java.math.BigInteger[],
4537                 'type' : p.unsigned long long,
4538             }
4539 ,
4540             'tmap:javain' : Hash {
4541                 'pname' : OUTPUT,
4542                 'typemap' : typemap(javain) unsigned long long *OUTPUT,
4543                 'code' : $javainput,
4544                 'type' : p.unsigned long long,
4545             }
4546 ,
4547         }
4548 ,
4549     }
4550 ,
4551     'r.unsigned long long' : Hash {
4552         'INOUT' : Hash {
4553             'tmap:freearg' : Hash {
4554                 'pname' : INOUT,
4555                 'typemap' : typemap(freearg) unsigned long long &INOUT,
4556                 'code' : ,
4557                 'type' : r.unsigned long long,
4558             }
4559 ,
4560             'tmap:jstype' : Hash {
4561                 'pname' : INOUT,
4562                 'typemap' : typemap(jstype) unsigned long long &INOUT,
4563                 'code' : java.math.BigInteger[],
4564                 'type' : r.unsigned long long,
4565             }
4566 ,
4567             'tmap:javadirectorin' : Hash {
4568                 'pname' : INOUT,
4569                 'typemap' : typemap(javadirectorin) unsigned long long &INOUT,
4570                 'code' : $jniinput,
4571                 'type' : r.unsigned long long,
4572             }
4573 ,
4574             'tmap:directorin' : Hash {
4575                 'kwargs' : Hash {
4576                     'name' : descriptor,
4577                     'value' : [Ljava.math.BigInteger;,
4578                     'nextSibling' : Hash {
4579                         'name' : warning,
4580                         'value' : Need to provide unsigned long long *INOUT directorin typemap, unsigned long long array length is unknown,
4581                     }
4582 ,
4583                 }
4584 ,
4585                 'pname' : INOUT,
4586                 'typemap' : typemap(directorin) unsigned long long &INOUT,
4587                 'code' : {
4588 },
4589                 'type' : r.unsigned long long,
4590             }
4591 ,
4592             'tmap:argout' : Hash {
4593                 'pname' : INOUT,
4594                 'typemap' : typemap(argout) unsigned long long &INOUT,
4595                 'code' : {
4596   jbyteArray ba = jenv->NewByteArray(9);
4597   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
4598   jclass clazz = jenv->FindClass("java/math/BigInteger");
4599   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
4600   jobject bigint;
4601   int i;
4602
4603   bae[0] = 0;
4604   for(i=1; i<9; i++ ) {
4605     bae[i] = (jbyte)(temp$argnum>>8*(8-i));
4606   }
4607
4608   jenv->ReleaseByteArrayElements(ba, bae, 0);
4609   bigint = jenv->NewObject(clazz, mid, ba);
4610   jenv->SetObjectArrayElement($input, 0, bigint);
4611 },
4612                 'type' : r.unsigned long long,
4613             }
4614 ,
4615             'tmap:javadirectorout' : Hash {
4616                 'pname' : INOUT,
4617                 'typemap' : typemap(javadirectorout) unsigned long long &INOUT,
4618                 'code' : $javacall,
4619                 'type' : r.unsigned long long,
4620             }
4621 ,
4622             'tmap:in' : Hash {
4623                 'kwargs' : Hash {
4624                     'name' : numinputs,
4625                     'value' : 1,
4626                 }
4627 ,
4628                 'locals' : Hash {
4629                     'name' : temp,
4630                     'type' : $*1_ltype,
4631                 }
4632 ,
4633                 'pname' : INOUT,
4634                 'typemap' : typemap(in) unsigned long long &INOUT,
4635                 'code' : {
4636   jobject bigint;
4637   jclass clazz;
4638   jmethodID mid;
4639   jbyteArray ba;
4640   jbyte* bae;
4641   jsize sz;
4642   int i;
4643
4644   if (!$input) {
4645     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4646     return $null;
4647   }
4648   if (jenv->GetArrayLength($input) == 0) {
4649     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4650     return $null;
4651   }
4652   bigint = jenv->GetObjectArrayElement($input, 0);
4653   if (!bigint) {
4654     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array element null");
4655     return $null;
4656   }
4657   clazz = jenv->GetObjectClass(bigint);
4658   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
4659   ba = (jbyteArray)jenv->CallObjectMethod(bigint, mid);
4660   bae = jenv->GetByteArrayElements(ba, 0);
4661   sz = jenv->GetArrayLength(ba);
4662   temp = 0;
4663   for(i=0; i<sz; i++) {
4664     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
4665   }
4666   jenv->ReleaseByteArrayElements(ba, bae, 0);
4667   $1 = &temp;
4668 },
4669                 'type' : r.unsigned long long,
4670             }
4671 ,
4672             'tmap:directorout' : Hash {
4673                 'kwargs' : Hash {
4674                     'name' : warning,
4675                     'value' : Need to provide unsigned long long *INOUT directorout typemap,
4676                 }
4677 ,
4678                 'pname' : INOUT,
4679                 'typemap' : typemap(directorout) unsigned long long &INOUT,
4680                 'code' : {
4681 },
4682                 'type' : r.unsigned long long,
4683             }
4684 ,
4685             'tmap:typecheck' : Hash {
4686                 'kwargs' : Hash {
4687                     'name' : precedence,
4688                     'value' : 1065,
4689                 }
4690 ,
4691                 'pname' : INOUT,
4692                 'typemap' : typemap(typecheck) unsigned long long &INOUT,
4693                 'code' : ,
4694                 'type' : r.unsigned long long,
4695             }
4696 ,
4697             'tmap:jni' : Hash {
4698                 'pname' : INOUT,
4699                 'typemap' : typemap(jni) unsigned long long &INOUT,
4700                 'code' : jobjectArray,
4701                 'type' : r.unsigned long long,
4702             }
4703 ,
4704             'tmap:jtype' : Hash {
4705                 'pname' : INOUT,
4706                 'typemap' : typemap(jtype) unsigned long long &INOUT,
4707                 'code' : java.math.BigInteger[],
4708                 'type' : r.unsigned long long,
4709             }
4710 ,
4711             'tmap:javain' : Hash {
4712                 'pname' : INOUT,
4713                 'typemap' : typemap(javain) unsigned long long &INOUT,
4714                 'code' : $javainput,
4715                 'type' : r.unsigned long long,
4716             }
4717 ,
4718         }
4719 ,
4720         'INPUT' : Hash {
4721             'tmap:freearg' : Hash {
4722                 'pname' : INPUT,
4723                 'typemap' : typemap(freearg) unsigned long long &INPUT,
4724                 'code' : ,
4725                 'type' : r.unsigned long long,
4726             }
4727 ,
4728             'tmap:jstype' : Hash {
4729                 'pname' : INPUT,
4730                 'typemap' : typemap(jstype) unsigned long long &INPUT,
4731                 'code' : java.math.BigInteger,
4732                 'type' : r.unsigned long long,
4733             }
4734 ,
4735             'tmap:javadirectorin' : Hash {
4736                 'pname' : INPUT,
4737                 'typemap' : typemap(javadirectorin) unsigned long long &INPUT,
4738                 'code' : $jniinput,
4739                 'type' : r.unsigned long long,
4740             }
4741 ,
4742             'tmap:directorin' : Hash {
4743                 'kwargs' : Hash {
4744                     'name' : descriptor,
4745                     'value' : Ljava/math/BigInteger;,
4746                 }
4747 ,
4748                 'pname' : INPUT,
4749                 'typemap' : typemap(directorin) unsigned long long &INPUT,
4750                 'code' :  *(($&1_ltype) $input) = (jobject *) &$1; ,
4751                 'type' : r.unsigned long long,
4752             }
4753 ,
4754             'tmap:javadirectorout' : Hash {
4755                 'pname' : INPUT,
4756                 'typemap' : typemap(javadirectorout) unsigned long long &INPUT,
4757                 'code' : $javacall,
4758                 'type' : r.unsigned long long,
4759             }
4760 ,
4761             'tmap:in' : Hash {
4762                 'kwargs' : Hash {
4763                     'name' : numinputs,
4764                     'value' : 1,
4765                 }
4766 ,
4767                 'locals' : Hash {
4768                     'name' : temp,
4769                     'type' : $*1_ltype,
4770                 }
4771 ,
4772                 'pname' : INPUT,
4773                 'typemap' : typemap(in) unsigned long long &INPUT,
4774                 'code' : {
4775   jclass clazz;
4776   jmethodID mid;
4777   jbyteArray ba;
4778   jbyte* bae;
4779   jsize sz;
4780   int i;
4781
4782   if (!$input) {
4783     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "BigInteger null");
4784     return $null;
4785   }
4786   clazz = jenv->GetObjectClass($input);
4787   mid = jenv->GetMethodID(clazz, "toByteArray", "()[B");
4788   ba = (jbyteArray)jenv->CallObjectMethod($input, mid);
4789   bae = jenv->GetByteArrayElements(ba, 0);
4790   sz = jenv->GetArrayLength(ba);
4791   temp = 0;
4792   for(i=0; i<sz; i++) {
4793     temp = (temp << 8) | ($*1_ltype)(unsigned char)bae[i];
4794   }
4795   jenv->ReleaseByteArrayElements(ba, bae, 0);
4796   $1 = &temp;
4797 },
4798                 'type' : r.unsigned long long,
4799             }
4800 ,
4801             'tmap:directorout' : Hash {
4802                 'pname' : INPUT,
4803                 'typemap' : typemap(directorout) unsigned long long &INPUT,
4804                 'code' :  $result = ($1_ltype)&$input; ,
4805                 'type' : r.unsigned long long,
4806             }
4807 ,
4808             'tmap:jni' : Hash {
4809                 'pname' : INPUT,
4810                 'typemap' : typemap(jni) unsigned long long &INPUT,
4811                 'code' : jobject,
4812                 'type' : r.unsigned long long,
4813             }
4814 ,
4815             'tmap:jtype' : Hash {
4816                 'pname' : INPUT,
4817                 'typemap' : typemap(jtype) unsigned long long &INPUT,
4818                 'code' : java.math.BigInteger,
4819                 'type' : r.unsigned long long,
4820             }
4821 ,
4822             'tmap:javain' : Hash {
4823                 'pname' : INPUT,
4824                 'typemap' : typemap(javain) unsigned long long &INPUT,
4825                 'code' : $javainput,
4826                 'type' : r.unsigned long long,
4827             }
4828 ,
4829             'tmap:typecheck' : Hash {
4830                 'kwargs' : Hash {
4831                     'name' : precedence,
4832                     'value' : 65,
4833                 }
4834 ,
4835                 'pname' : INPUT,
4836                 'typemap' : typemap(typecheck) unsigned long long &INPUT,
4837                 'code' : ,
4838                 'type' : r.unsigned long long,
4839             }
4840 ,
4841         }
4842 ,
4843         'OUTPUT' : Hash {
4844             'tmap:freearg' : Hash {
4845                 'pname' : OUTPUT,
4846                 'typemap' : typemap(freearg) unsigned long long &OUTPUT,
4847                 'code' : ,
4848                 'type' : r.unsigned long long,
4849             }
4850 ,
4851             'tmap:jstype' : Hash {
4852                 'pname' : OUTPUT,
4853                 'typemap' : typemap(jstype) unsigned long long &OUTPUT,
4854                 'code' : java.math.BigInteger[],
4855                 'type' : r.unsigned long long,
4856             }
4857 ,
4858             'tmap:javadirectorin' : Hash {
4859                 'pname' : OUTPUT,
4860                 'typemap' : typemap(javadirectorin) unsigned long long &OUTPUT,
4861                 'code' : $jniinput,
4862                 'type' : r.unsigned long long,
4863             }
4864 ,
4865             'tmap:directorin' : Hash {
4866                 'kwargs' : Hash {
4867                     'name' : descriptor,
4868                     'value' : [Ljava/lang/BigInteger;,
4869                 }
4870 ,
4871                 'pname' : OUTPUT,
4872                 'typemap' : typemap(directorin) unsigned long long &OUTPUT,
4873                 'code' :  *(($&1_ltype) $input = &$1; ,
4874                 'type' : r.unsigned long long,
4875             }
4876 ,
4877             'tmap:argout' : Hash {
4878                 'pname' : OUTPUT,
4879                 'typemap' : typemap(argout) unsigned long long &OUTPUT,
4880                 'code' : {
4881   jbyteArray ba = jenv->NewByteArray(9);
4882   jbyte* bae = jenv->GetByteArrayElements(ba, 0);
4883   jclass clazz = jenv->FindClass("java/math/BigInteger");
4884   jmethodID mid = jenv->GetMethodID(clazz, "<init>", "([B)V");
4885   jobject bigint;
4886   int i;
4887
4888   bae[0] = 0;
4889   for(i=1; i<9; i++ ) {
4890     bae[i] = (jbyte)(temp$argnum>>8*(8-i));
4891   }
4892
4893   jenv->ReleaseByteArrayElements(ba, bae, 0);
4894   bigint = jenv->NewObject(clazz, mid, ba);
4895   jenv->SetObjectArrayElement($input, 0, bigint);
4896 },
4897                 'type' : r.unsigned long long,
4898             }
4899 ,
4900             'tmap:javadirectorout' : Hash {
4901                 'pname' : OUTPUT,
4902                 'typemap' : typemap(javadirectorout) unsigned long long &OUTPUT,
4903                 'code' : $javacall,
4904                 'type' : r.unsigned long long,
4905             }
4906 ,
4907             'tmap:in' : Hash {
4908                 'locals' : Hash {
4909                     'name' : temp,
4910                     'type' : $*1_ltype,
4911                 }
4912 ,
4913                 'kwargs' : Hash {
4914                     'name' : numinputs,
4915                     'value' : 1,
4916                 }
4917 ,
4918                 'pname' : OUTPUT,
4919                 'typemap' : typemap(in) unsigned long long &OUTPUT,
4920                 'code' : {
4921   if (!$input) {
4922     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
4923     return $null;
4924   }
4925   if (jenv->GetArrayLength($input) == 0) {
4926     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
4927     return $null;
4928   }
4929   $1 = &temp;
4930 },
4931                 'type' : r.unsigned long long,
4932             }
4933 ,
4934             'tmap:directorout' : Hash {
4935                 'kwargs' : Hash {
4936                     'name' : warning,
4937                     'value' : Need to provide unsigned long long *OUTPUT directorout typemap,
4938                 }
4939 ,
4940                 'pname' : OUTPUT,
4941                 'typemap' : typemap(directorout) unsigned long long &OUTPUT,
4942                 'code' : {
4943 },
4944                 'type' : r.unsigned long long,
4945             }
4946 ,
4947             'tmap:jni' : Hash {
4948                 'pname' : OUTPUT,
4949                 'typemap' : typemap(jni) unsigned long long &OUTPUT,
4950                 'code' : jobjectArray,
4951                 'type' : r.unsigned long long,
4952             }
4953 ,
4954             'tmap:jtype' : Hash {
4955                 'pname' : OUTPUT,
4956                 'typemap' : typemap(jtype) unsigned long long &OUTPUT,
4957                 'code' : java.math.BigInteger[],
4958                 'type' : r.unsigned long long,
4959             }
4960 ,
4961             'tmap:javain' : Hash {
4962                 'pname' : OUTPUT,
4963                 'typemap' : typemap(javain) unsigned long long &OUTPUT,
4964                 'code' : $javainput,
4965                 'type' : r.unsigned long long,
4966             }
4967 ,
4968         }
4969 ,
4970     }
4971 ,
4972     'a(ANY).long long' : Hash {
4973         'tmap:freearg' : Hash {
4974             'typemap' : typemap(freearg) long long [ANY],
4975             'code' :  delete [] $1; ,
4976             'type' : a(ANY).long long,
4977         }
4978 ,
4979         'tmap:jstype' : Hash {
4980             'typemap' : typemap(jstype) long long [ANY],
4981             'code' : long[],
4982             'type' : a(ANY).long long,
4983         }
4984 ,
4985         'tmap:argout' : Hash {
4986             'typemap' : typemap(argout) long long [ANY],
4987             'code' :  SWIG_JavaArrayArgoutLonglong(jenv, jarr$argnum, $1, $input); ,
4988             'type' : a(ANY).long long,
4989         }
4990 ,
4991         'tmap:in' : Hash {
4992             'locals' : Hash {
4993                 'name' : jarr,
4994                 'type' : p.jlong,
4995             }
4996 ,
4997             'kwargs' : Hash {
4998                 'name' : numinputs,
4999                 'value' : 1,
5000             }
5001 ,
5002             'typemap' : typemap(in) long long [ANY],
5003             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
5004     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
5005     return $null;
5006   }
5007   if (!SWIG_JavaArrayInLonglong(jenv, &jarr, &$1, $input)) return $null; ,
5008             'type' : a(ANY).long long,
5009         }
5010 ,
5011         'tmap:jni' : Hash {
5012             'typemap' : typemap(jni) long long [ANY],
5013             'code' : jlongArray,
5014             'type' : a(ANY).long long,
5015         }
5016 ,
5017         'tmap:jtype' : Hash {
5018             'typemap' : typemap(jtype) long long [ANY],
5019             'code' : long[],
5020             'type' : a(ANY).long long,
5021         }
5022 ,
5023         'tmap:out' : Hash {
5024             'typemap' : typemap(out) long long [ANY],
5025             'code' : $result = SWIG_JavaArrayOutLonglong(jenv, $1, $1_dim0); ,
5026             'type' : a(ANY).long long,
5027         }
5028 ,
5029         'tmap:javain' : Hash {
5030             'typemap' : typemap(javain) long long [ANY],
5031             'code' : $javainput,
5032             'type' : a(ANY).long long,
5033         }
5034 ,
5035         'tmap:typecheck' : Hash {
5036             'kwargs' : Hash {
5037                 'name' : precedence,
5038                 'value' : 1055,
5039             }
5040 ,
5041             'typemap' : typemap(typecheck) long long [ANY],
5042             'code' : ,
5043             'type' : a(ANY).long long,
5044         }
5045 ,
5046         'tmap:javaout' : Hash {
5047             'typemap' : typemap(javaout) long long [ANY],
5048             'code' : {
5049     return $jnicall;
5050   },
5051             'type' : a(ANY).long long,
5052         }
5053 ,
5054     }
5055 ,
5056     'a().long long' : Hash {
5057         'tmap:freearg' : Hash {
5058             'typemap' : typemap(freearg) long long [],
5059             'code' :  delete [] $1; ,
5060             'type' : a().long long,
5061         }
5062 ,
5063         'tmap:jstype' : Hash {
5064             'typemap' : typemap(jstype) long long [],
5065             'code' : long[],
5066             'type' : a().long long,
5067         }
5068 ,
5069         'tmap:argout' : Hash {
5070             'typemap' : typemap(argout) long long [],
5071             'code' :  SWIG_JavaArrayArgoutLonglong(jenv, jarr$argnum, $1, $input); ,
5072             'type' : a().long long,
5073         }
5074 ,
5075         'tmap:in' : Hash {
5076             'locals' : Hash {
5077                 'name' : jarr,
5078                 'type' : p.jlong,
5079             }
5080 ,
5081             'kwargs' : Hash {
5082                 'name' : numinputs,
5083                 'value' : 1,
5084             }
5085 ,
5086             'typemap' : typemap(in) long long [],
5087             'code' :   if (!SWIG_JavaArrayInLonglong(jenv, &jarr, &$1, $input)) return $null; ,
5088             'type' : a().long long,
5089         }
5090 ,
5091         'tmap:jni' : Hash {
5092             'typemap' : typemap(jni) long long [],
5093             'code' : jlongArray,
5094             'type' : a().long long,
5095         }
5096 ,
5097         'tmap:jtype' : Hash {
5098             'typemap' : typemap(jtype) long long [],
5099             'code' : long[],
5100             'type' : a().long long,
5101         }
5102 ,
5103         'tmap:out' : Hash {
5104             'typemap' : typemap(out) long long [],
5105             'code' : $result = SWIG_JavaArrayOutLonglong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
5106             'type' : a().long long,
5107         }
5108 ,
5109         'tmap:javain' : Hash {
5110             'typemap' : typemap(javain) long long [],
5111             'code' : $javainput,
5112             'type' : a().long long,
5113         }
5114 ,
5115         'tmap:typecheck' : Hash {
5116             'kwargs' : Hash {
5117                 'name' : precedence,
5118                 'value' : 1055,
5119             }
5120 ,
5121             'typemap' : typemap(typecheck) long long [],
5122             'code' : ,
5123             'type' : a().long long,
5124         }
5125 ,
5126         'tmap:javaout' : Hash {
5127             'typemap' : typemap(javaout) long long [],
5128             'code' : {
5129     return $jnicall;
5130   },
5131             'type' : a().long long,
5132         }
5133 ,
5134     }
5135 ,
5136     'a(ANY).unsigned long long' : Hash {
5137         'tmap:typecheck' : Hash {
5138             'kwargs' : Hash {
5139                 'name' : precedence,
5140                 'value' : 1065,
5141             }
5142 ,
5143             'typemap' : typemap(typecheck) unsigned long long [ANY],
5144             'code' : ,
5145             'type' : a(ANY).unsigned long long,
5146         }
5147 ,
5148     }
5149 ,
5150     'a().unsigned long long' : Hash {
5151         'tmap:typecheck' : Hash {
5152             'kwargs' : Hash {
5153                 'name' : precedence,
5154                 'value' : 1065,
5155             }
5156 ,
5157             'typemap' : typemap(typecheck) unsigned long long [],
5158             'code' : ,
5159             'type' : a().unsigned long long,
5160         }
5161 ,
5162     }
5163 ,
5164     'p.bool' : Hash {
5165         'INOUT' : Hash {
5166             'tmap:freearg' : Hash {
5167                 'pname' : INOUT,
5168                 'typemap' : typemap(freearg) bool *INOUT,
5169                 'code' : ,
5170                 'type' : p.bool,
5171             }
5172 ,
5173             'tmap:jstype' : Hash {
5174                 'pname' : INOUT,
5175                 'typemap' : typemap(jstype) bool *INOUT,
5176                 'code' : boolean[],
5177                 'type' : p.bool,
5178             }
5179 ,
5180             'tmap:javadirectorin' : Hash {
5181                 'pname' : INOUT,
5182                 'typemap' : typemap(javadirectorin) bool *INOUT,
5183                 'code' : $jniinput,
5184                 'type' : p.bool,
5185             }
5186 ,
5187             'tmap:directorin' : Hash {
5188                 'kwargs' : Hash {
5189                     'name' : descriptor,
5190                     'value' : [Ljava/lang/Boolean;,
5191                     'nextSibling' : Hash {
5192                         'name' : warning,
5193                         'value' : Need to provide bool *INOUT directorin typemap, bool array length is unknown,
5194                     }
5195 ,
5196                 }
5197 ,
5198                 'pname' : INOUT,
5199                 'typemap' : typemap(directorin) bool *INOUT,
5200                 'code' : {
5201 },
5202                 'type' : p.bool,
5203             }
5204 ,
5205             'tmap:argout' : Hash {
5206                 'pname' : INOUT,
5207                 'typemap' : typemap(argout) bool *INOUT,
5208                 'code' : { jenv->ReleaseBooleanArrayElements($input, (jboolean *)$1, 0); },
5209                 'type' : p.bool,
5210             }
5211 ,
5212             'tmap:javadirectorout' : Hash {
5213                 'pname' : INOUT,
5214                 'typemap' : typemap(javadirectorout) bool *INOUT,
5215                 'code' : $javacall,
5216                 'type' : p.bool,
5217             }
5218 ,
5219             'tmap:in' : Hash {
5220                 'kwargs' : Hash {
5221                     'name' : numinputs,
5222                     'value' : 1,
5223                 }
5224 ,
5225                 'pname' : INOUT,
5226                 'typemap' : typemap(in) bool *INOUT,
5227                 'code' : {
5228   if (!$input) {
5229     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5230     return $null;
5231   }
5232   if (jenv->GetArrayLength($input) == 0) {
5233     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5234     return $null;
5235   }
5236   $1 = ($1_ltype) jenv->GetBooleanArrayElements($input, 0);
5237 },
5238                 'type' : p.bool,
5239             }
5240 ,
5241             'tmap:directorout' : Hash {
5242                 'kwargs' : Hash {
5243                     'name' : warning,
5244                     'value' : Need to provide bool *INOUT directorout typemap,
5245                 }
5246 ,
5247                 'pname' : INOUT,
5248                 'typemap' : typemap(directorout) bool *INOUT,
5249                 'code' : {
5250 },
5251                 'type' : p.bool,
5252             }
5253 ,
5254             'tmap:typecheck' : Hash {
5255                 'kwargs' : Hash {
5256                     'name' : precedence,
5257                     'value' : 1015,
5258                 }
5259 ,
5260                 'pname' : INOUT,
5261                 'typemap' : typemap(typecheck) bool *INOUT,
5262                 'code' : ,
5263                 'type' : p.bool,
5264             }
5265 ,
5266             'tmap:jni' : Hash {
5267                 'pname' : INOUT,
5268                 'typemap' : typemap(jni) bool *INOUT,
5269                 'code' : jbooleanArray,
5270                 'type' : p.bool,
5271             }
5272 ,
5273             'tmap:jtype' : Hash {
5274                 'pname' : INOUT,
5275                 'typemap' : typemap(jtype) bool *INOUT,
5276                 'code' : boolean[],
5277                 'type' : p.bool,
5278             }
5279 ,
5280             'tmap:javain' : Hash {
5281                 'pname' : INOUT,
5282                 'typemap' : typemap(javain) bool *INOUT,
5283                 'code' : $javainput,
5284                 'type' : p.bool,
5285             }
5286 ,
5287         }
5288 ,
5289         'INPUT' : Hash {
5290             'tmap:freearg' : Hash {
5291                 'pname' : INPUT,
5292                 'typemap' : typemap(freearg) bool *INPUT,
5293                 'code' : ,
5294                 'type' : p.bool,
5295             }
5296 ,
5297             'tmap:jstype' : Hash {
5298                 'pname' : INPUT,
5299                 'typemap' : typemap(jstype) bool *INPUT,
5300                 'code' : boolean,
5301                 'type' : p.bool,
5302             }
5303 ,
5304             'tmap:javadirectorin' : Hash {
5305                 'pname' : INPUT,
5306                 'typemap' : typemap(javadirectorin) bool *INPUT,
5307                 'code' : $jniinput,
5308                 'type' : p.bool,
5309             }
5310 ,
5311             'tmap:directorin' : Hash {
5312                 'kwargs' : Hash {
5313                     'name' : descriptor,
5314                     'value' : Z,
5315                 }
5316 ,
5317                 'pname' : INPUT,
5318                 'typemap' : typemap(directorin) bool *INPUT,
5319                 'code' :  *(($&1_ltype) $input) = (jboolean *) $1; ,
5320                 'type' : p.bool,
5321             }
5322 ,
5323             'tmap:javadirectorout' : Hash {
5324                 'pname' : INPUT,
5325                 'typemap' : typemap(javadirectorout) bool *INPUT,
5326                 'code' : $javacall,
5327                 'type' : p.bool,
5328             }
5329 ,
5330             'tmap:in' : Hash {
5331                 'kwargs' : Hash {
5332                     'name' : numinputs,
5333                     'value' : 1,
5334                 }
5335 ,
5336                 'pname' : INPUT,
5337                 'typemap' : typemap(in) bool *INPUT,
5338                 'code' :  $1 = ($1_ltype)&$input; ,
5339                 'type' : p.bool,
5340             }
5341 ,
5342             'tmap:directorout' : Hash {
5343                 'pname' : INPUT,
5344                 'typemap' : typemap(directorout) bool *INPUT,
5345                 'code' :  $result = ($1_ltype)&$input; ,
5346                 'type' : p.bool,
5347             }
5348 ,
5349             'tmap:jni' : Hash {
5350                 'pname' : INPUT,
5351                 'typemap' : typemap(jni) bool *INPUT,
5352                 'code' : jboolean,
5353                 'type' : p.bool,
5354             }
5355 ,
5356             'tmap:jtype' : Hash {
5357                 'pname' : INPUT,
5358                 'typemap' : typemap(jtype) bool *INPUT,
5359                 'code' : boolean,
5360                 'type' : p.bool,
5361             }
5362 ,
5363             'tmap:javain' : Hash {
5364                 'pname' : INPUT,
5365                 'typemap' : typemap(javain) bool *INPUT,
5366                 'code' : $javainput,
5367                 'type' : p.bool,
5368             }
5369 ,
5370             'tmap:typecheck' : Hash {
5371                 'kwargs' : Hash {
5372                     'name' : precedence,
5373                     'value' : 15,
5374                 }
5375 ,
5376                 'pname' : INPUT,
5377                 'typemap' : typemap(typecheck) bool *INPUT,
5378                 'code' : ,
5379                 'type' : p.bool,
5380             }
5381 ,
5382         }
5383 ,
5384         'OUTPUT' : Hash {
5385             'tmap:freearg' : Hash {
5386                 'pname' : OUTPUT,
5387                 'typemap' : typemap(freearg) bool *OUTPUT,
5388                 'code' : ,
5389                 'type' : p.bool,
5390             }
5391 ,
5392             'tmap:jstype' : Hash {
5393                 'pname' : OUTPUT,
5394                 'typemap' : typemap(jstype) bool *OUTPUT,
5395                 'code' : boolean[],
5396                 'type' : p.bool,
5397             }
5398 ,
5399             'tmap:javadirectorin' : Hash {
5400                 'pname' : OUTPUT,
5401                 'typemap' : typemap(javadirectorin) bool *OUTPUT,
5402                 'code' : $jniinput,
5403                 'type' : p.bool,
5404             }
5405 ,
5406             'tmap:directorin' : Hash {
5407                 'kwargs' : Hash {
5408                     'name' : descriptor,
5409                     'value' : [Ljava/lang/Boolean;,
5410                     'nextSibling' : Hash {
5411                         'name' : warning,
5412                         'value' : Need to provide bool *OUTPUT directorin typemap, bool array length is unknown,
5413                     }
5414 ,
5415                 }
5416 ,
5417                 'pname' : OUTPUT,
5418                 'typemap' : typemap(directorin) bool *OUTPUT,
5419                 'code' : {
5420 },
5421                 'type' : p.bool,
5422             }
5423 ,
5424             'tmap:argout' : Hash {
5425                 'pname' : OUTPUT,
5426                 'typemap' : typemap(argout) bool *OUTPUT,
5427                 'code' : {
5428   jboolean jvalue = (jboolean)temp$argnum;
5429   jenv->SetBooleanArrayRegion($input, 0, 1, &jvalue);
5430 },
5431                 'type' : p.bool,
5432             }
5433 ,
5434             'tmap:javadirectorout' : Hash {
5435                 'pname' : OUTPUT,
5436                 'typemap' : typemap(javadirectorout) bool *OUTPUT,
5437                 'code' : $javacall,
5438                 'type' : p.bool,
5439             }
5440 ,
5441             'tmap:in' : Hash {
5442                 'locals' : Hash {
5443                     'name' : temp,
5444                     'type' : $*1_ltype,
5445                 }
5446 ,
5447                 'kwargs' : Hash {
5448                     'name' : numinputs,
5449                     'value' : 1,
5450                 }
5451 ,
5452                 'pname' : OUTPUT,
5453                 'typemap' : typemap(in) bool *OUTPUT,
5454                 'code' : {
5455   if (!$input) {
5456     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
5457     return $null;
5458   }
5459   if (jenv->GetArrayLength($input) == 0) {
5460     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
5461     return $null;
5462   }
5463   $1 = &temp;
5464 },
5465                 'type' : p.bool,
5466             }
5467 ,
5468             'tmap:directorout' : Hash {
5469                 'kwargs' : Hash {
5470                     'name' : warning,
5471                     'value' : Need to provide bool *OUTPUT directorout typemap,
5472                 }
5473 ,
5474                 'pname' : OUTPUT,
5475                 'typemap' : typemap(directorout) bool *OUTPUT,
5476                 'code' : {
5477 },
5478                 'type' : p.bool,
5479             }
5480 ,
5481             'tmap:jni' : Hash {
5482                 'pname' : OUTPUT,
5483                 'typemap' : typemap(jni) bool *OUTPUT,
5484                 'code' : jbooleanArray,
5485                 'type' : p.bool,
5486             }
5487 ,
5488             'tmap:jtype' : Hash {
5489                 'pname' : OUTPUT,
5490                 'typemap' : typemap(jtype) bool *OUTPUT,
5491                 'code' : boolean[],
5492                 'type' : p.bool,
5493             }
5494 ,
5495             'tmap:javain' : Hash {
5496                 'pname' : OUTPUT,
5497                 'typemap' : typemap(javain) bool *OUTPUT,
5498                 'code' : $javainput,
5499                 'type' : p.bool,
5500             }
5501 ,
5502         }
5503 ,
5504     }
5505 ,
5506     'jdoubleArray' : Hash {
5507         'tmap:jstype' : Hash {
5508             'typemap' : typemap(jstype) jdoubleArray,
5509             'code' : double[],
5510             'type' : jdoubleArray,
5511         }
5512 ,
5513         'tmap:directorin' : Hash {
5514             'kwargs' : Hash {
5515                 'name' : descriptor,
5516                 'value' : [D,
5517             }
5518 ,
5519             'typemap' : typemap(directorin) jdoubleArray,
5520             'code' : $input = $1;,
5521             'type' : jdoubleArray,
5522         }
5523 ,
5524         'tmap:javadirectorin' : Hash {
5525             'typemap' : typemap(javadirectorin) jdoubleArray,
5526             'code' : $jniinput,
5527             'type' : jdoubleArray,
5528         }
5529 ,
5530         'tmap:in' : Hash {
5531             'kwargs' : Hash {
5532                 'name' : numinputs,
5533                 'value' : 1,
5534             }
5535 ,
5536             'typemap' : typemap(in) jdoubleArray,
5537             'code' :  $1 = $input; ,
5538             'type' : jdoubleArray,
5539         }
5540 ,
5541         'tmap:directorout' : Hash {
5542             'typemap' : typemap(directorout) jdoubleArray,
5543             'code' :  $result = $input; ,
5544             'type' : jdoubleArray,
5545         }
5546 ,
5547         'tmap:javadirectorout' : Hash {
5548             'typemap' : typemap(javadirectorout) jdoubleArray,
5549             'code' : $javacall,
5550             'type' : jdoubleArray,
5551         }
5552 ,
5553         'tmap:jni' : Hash {
5554             'typemap' : typemap(jni) jdoubleArray,
5555             'code' : jdoubleArray,
5556             'type' : jdoubleArray,
5557         }
5558 ,
5559         'tmap:jtype' : Hash {
5560             'typemap' : typemap(jtype) jdoubleArray,
5561             'code' : double[],
5562             'type' : jdoubleArray,
5563         }
5564 ,
5565         'tmap:out' : Hash {
5566             'typemap' : typemap(out) jdoubleArray,
5567             'code' :  $result = $1; ,
5568             'type' : jdoubleArray,
5569         }
5570 ,
5571         'tmap:typecheck' : Hash {
5572             'kwargs' : Hash {
5573                 'name' : precedence,
5574                 'value' : 1090,
5575             }
5576 ,
5577             'typemap' : typemap(typecheck) jdoubleArray,
5578             'code' : ,
5579             'type' : jdoubleArray,
5580         }
5581 ,
5582         'tmap:javain' : Hash {
5583             'typemap' : typemap(javain) jdoubleArray,
5584             'code' : $javainput,
5585             'type' : jdoubleArray,
5586         }
5587 ,
5588         'tmap:javaout' : Hash {
5589             'typemap' : typemap(javaout) jdoubleArray,
5590             'code' : {
5591     return $jnicall;
5592   },
5593             'type' : jdoubleArray,
5594         }
5595 ,
5596     }
5597 ,
5598     'jbyteArray' : Hash {
5599         'tmap:jstype' : Hash {
5600             'typemap' : typemap(jstype) jbyteArray,
5601             'code' : byte[],
5602             'type' : jbyteArray,
5603         }
5604 ,
5605         'tmap:directorin' : Hash {
5606             'kwargs' : Hash {
5607                 'name' : descriptor,
5608                 'value' : [B,
5609             }
5610 ,
5611             'typemap' : typemap(directorin) jbyteArray,
5612             'code' : $input = $1;,
5613             'type' : jbyteArray,
5614         }
5615 ,
5616         'tmap:javadirectorin' : Hash {
5617             'typemap' : typemap(javadirectorin) jbyteArray,
5618             'code' : $jniinput,
5619             'type' : jbyteArray,
5620         }
5621 ,
5622         'tmap:in' : Hash {
5623             'kwargs' : Hash {
5624                 'name' : numinputs,
5625                 'value' : 1,
5626             }
5627 ,
5628             'typemap' : typemap(in) jbyteArray,
5629             'code' :  $1 = $input; ,
5630             'type' : jbyteArray,
5631         }
5632 ,
5633         'tmap:directorout' : Hash {
5634             'typemap' : typemap(directorout) jbyteArray,
5635             'code' :  $result = $input; ,
5636             'type' : jbyteArray,
5637         }
5638 ,
5639         'tmap:javadirectorout' : Hash {
5640             'typemap' : typemap(javadirectorout) jbyteArray,
5641             'code' : $javacall,
5642             'type' : jbyteArray,
5643         }
5644 ,
5645         'tmap:jni' : Hash {
5646             'typemap' : typemap(jni) jbyteArray,
5647             'code' : jbyteArray,
5648             'type' : jbyteArray,
5649         }
5650 ,
5651         'tmap:jtype' : Hash {
5652             'typemap' : typemap(jtype) jbyteArray,
5653             'code' : byte[],
5654             'type' : jbyteArray,
5655         }
5656 ,
5657         'tmap:out' : Hash {
5658             'typemap' : typemap(out) jbyteArray,
5659             'code' :  $result = $1; ,
5660             'type' : jbyteArray,
5661         }
5662 ,
5663         'tmap:typecheck' : Hash {
5664             'kwargs' : Hash {
5665                 'name' : precedence,
5666                 'value' : 1025,
5667             }
5668 ,
5669             'typemap' : typemap(typecheck) jbyteArray,
5670             'code' : ,
5671             'type' : jbyteArray,
5672         }
5673 ,
5674         'tmap:javain' : Hash {
5675             'typemap' : typemap(javain) jbyteArray,
5676             'code' : $javainput,
5677             'type' : jbyteArray,
5678         }
5679 ,
5680         'tmap:javaout' : Hash {
5681             'typemap' : typemap(javaout) jbyteArray,
5682             'code' : {
5683     return $jnicall;
5684   },
5685             'type' : jbyteArray,
5686         }
5687 ,
5688     }
5689 ,
5690     'struct CharStarByteArray' : Hash {
5691         'tmap:jstype' : Hash {
5692             'typemap' : typemap(jstype) struct CharStarByteArray,
5693             'code' : byte[],
5694             'type' : struct CharStarByteArray,
5695         }
5696 ,
5697         'tmap:jni' : Hash {
5698             'typemap' : typemap(jni) struct CharStarByteArray,
5699             'code' : jbyteArray,
5700             'type' : struct CharStarByteArray,
5701         }
5702 ,
5703         'tmap:jtype' : Hash {
5704             'typemap' : typemap(jtype) struct CharStarByteArray,
5705             'code' : byte[],
5706             'type' : struct CharStarByteArray,
5707         }
5708 ,
5709         'tmap:out' : Hash {
5710             'typemap' : typemap(out) struct CharStarByteArray,
5711             'code' : {
5712                 $result = SWIG_JavaArrayOutSChar(jenv, $1.data, $1.length);
5713                 free((void*)$1.data);
5714         },
5715             'type' : struct CharStarByteArray,
5716         }
5717 ,
5718         'tmap:javaout' : Hash {
5719             'typemap' : typemap(javaout) struct CharStarByteArray,
5720             'code' : { return $jnicall; },
5721             'type' : struct CharStarByteArray,
5722         }
5723 ,
5724     }
5725 ,
5726     'jshort' : Hash {
5727         'tmap:jstype' : Hash {
5728             'typemap' : typemap(jstype) jshort,
5729             'code' : short,
5730             'type' : jshort,
5731         }
5732 ,
5733         'tmap:directorin' : Hash {
5734             'kwargs' : Hash {
5735                 'name' : descriptor,
5736                 'value' : S,
5737             }
5738 ,
5739             'typemap' : typemap(directorin) jshort,
5740             'code' : $input = $1;,
5741             'type' : jshort,
5742         }
5743 ,
5744         'tmap:javadirectorin' : Hash {
5745             'typemap' : typemap(javadirectorin) jshort,
5746             'code' : $jniinput,
5747             'type' : jshort,
5748         }
5749 ,
5750         'tmap:in' : Hash {
5751             'kwargs' : Hash {
5752                 'name' : numinputs,
5753                 'value' : 1,
5754             }
5755 ,
5756             'typemap' : typemap(in) jshort,
5757             'code' :  $1 = $input; ,
5758             'type' : jshort,
5759         }
5760 ,
5761         'tmap:directorout' : Hash {
5762             'typemap' : typemap(directorout) jshort,
5763             'code' :  $result = $input; ,
5764             'type' : jshort,
5765         }
5766 ,
5767         'tmap:javadirectorout' : Hash {
5768             'typemap' : typemap(javadirectorout) jshort,
5769             'code' : $javacall,
5770             'type' : jshort,
5771         }
5772 ,
5773         'tmap:jni' : Hash {
5774             'typemap' : typemap(jni) jshort,
5775             'code' : jshort,
5776             'type' : jshort,
5777         }
5778 ,
5779         'tmap:jtype' : Hash {
5780             'typemap' : typemap(jtype) jshort,
5781             'code' : short,
5782             'type' : jshort,
5783         }
5784 ,
5785         'tmap:out' : Hash {
5786             'typemap' : typemap(out) jshort,
5787             'code' :  $result = $1; ,
5788             'type' : jshort,
5789         }
5790 ,
5791         'tmap:typecheck' : Hash {
5792             'kwargs' : Hash {
5793                 'name' : precedence,
5794                 'value' : 35,
5795             }
5796 ,
5797             'typemap' : typemap(typecheck) jshort,
5798             'code' : ,
5799             'type' : jshort,
5800         }
5801 ,
5802         'tmap:javain' : Hash {
5803             'typemap' : typemap(javain) jshort,
5804             'code' : $javainput,
5805             'type' : jshort,
5806         }
5807 ,
5808         'tmap:javaout' : Hash {
5809             'typemap' : typemap(javaout) jshort,
5810             'code' : {
5811     return $jnicall;
5812   },
5813             'type' : jshort,
5814         }
5815 ,
5816     }
5817 ,
5818     'jobjectArray' : Hash {
5819         'tmap:jstype' : Hash {
5820             'typemap' : typemap(jstype) jobjectArray,
5821             'code' : Object[],
5822             'type' : jobjectArray,
5823         }
5824 ,
5825         'tmap:directorin' : Hash {
5826             'kwargs' : Hash {
5827                 'name' : descriptor,
5828                 'value' : [Ljava/lang/Object;,
5829                 'nextSibling' : Hash {
5830                     'name' : nouse,
5831                     'value' : 1,
5832                 }
5833 ,
5834             }
5835 ,
5836             'typemap' : typemap(directorin) jobjectArray,
5837             'code' : $input = $1;,
5838             'type' : jobjectArray,
5839         }
5840 ,
5841         'tmap:javadirectorin' : Hash {
5842             'typemap' : typemap(javadirectorin) jobjectArray,
5843             'code' : $jniinput,
5844             'type' : jobjectArray,
5845         }
5846 ,
5847         'tmap:in' : Hash {
5848             'kwargs' : Hash {
5849                 'name' : numinputs,
5850                 'value' : 1,
5851             }
5852 ,
5853             'typemap' : typemap(in) jobjectArray,
5854             'code' :  $1 = $input; ,
5855             'type' : jobjectArray,
5856         }
5857 ,
5858         'tmap:directorout' : Hash {
5859             'typemap' : typemap(directorout) jobjectArray,
5860             'code' :  $result = $input; ,
5861             'type' : jobjectArray,
5862         }
5863 ,
5864         'tmap:javadirectorout' : Hash {
5865             'typemap' : typemap(javadirectorout) jobjectArray,
5866             'code' : $javacall,
5867             'type' : jobjectArray,
5868         }
5869 ,
5870         'tmap:jni' : Hash {
5871             'typemap' : typemap(jni) jobjectArray,
5872             'code' : jobjectArray,
5873             'type' : jobjectArray,
5874         }
5875 ,
5876         'tmap:jtype' : Hash {
5877             'typemap' : typemap(jtype) jobjectArray,
5878             'code' : Object[],
5879             'type' : jobjectArray,
5880         }
5881 ,
5882         'tmap:out' : Hash {
5883             'typemap' : typemap(out) jobjectArray,
5884             'code' :  $result = $1; ,
5885             'type' : jobjectArray,
5886         }
5887 ,
5888         'tmap:typecheck' : Hash {
5889             'kwargs' : Hash {
5890                 'name' : precedence,
5891                 'value' : 1150,
5892             }
5893 ,
5894             'typemap' : typemap(typecheck) jobjectArray,
5895             'code' : ,
5896             'type' : jobjectArray,
5897         }
5898 ,
5899         'tmap:javain' : Hash {
5900             'typemap' : typemap(javain) jobjectArray,
5901             'code' : $javainput,
5902             'type' : jobjectArray,
5903         }
5904 ,
5905         'tmap:javaout' : Hash {
5906             'typemap' : typemap(javaout) jobjectArray,
5907             'code' : {
5908     return $jnicall;
5909   },
5910             'type' : jobjectArray,
5911         }
5912 ,
5913     }
5914 ,
5915     'jfloatArray' : Hash {
5916         'tmap:jstype' : Hash {
5917             'typemap' : typemap(jstype) jfloatArray,
5918             'code' : float[],
5919             'type' : jfloatArray,
5920         }
5921 ,
5922         'tmap:directorin' : Hash {
5923             'kwargs' : Hash {
5924                 'name' : descriptor,
5925                 'value' : [F,
5926             }
5927 ,
5928             'typemap' : typemap(directorin) jfloatArray,
5929             'code' : $input = $1;,
5930             'type' : jfloatArray,
5931         }
5932 ,
5933         'tmap:javadirectorin' : Hash {
5934             'typemap' : typemap(javadirectorin) jfloatArray,
5935             'code' : $jniinput,
5936             'type' : jfloatArray,
5937         }
5938 ,
5939         'tmap:in' : Hash {
5940             'kwargs' : Hash {
5941                 'name' : numinputs,
5942                 'value' : 1,
5943             }
5944 ,
5945             'typemap' : typemap(in) jfloatArray,
5946             'code' :  $1 = $input; ,
5947             'type' : jfloatArray,
5948         }
5949 ,
5950         'tmap:directorout' : Hash {
5951             'typemap' : typemap(directorout) jfloatArray,
5952             'code' :  $result = $input; ,
5953             'type' : jfloatArray,
5954         }
5955 ,
5956         'tmap:javadirectorout' : Hash {
5957             'typemap' : typemap(javadirectorout) jfloatArray,
5958             'code' : $javacall,
5959             'type' : jfloatArray,
5960         }
5961 ,
5962         'tmap:jni' : Hash {
5963             'typemap' : typemap(jni) jfloatArray,
5964             'code' : jfloatArray,
5965             'type' : jfloatArray,
5966         }
5967 ,
5968         'tmap:jtype' : Hash {
5969             'typemap' : typemap(jtype) jfloatArray,
5970             'code' : float[],
5971             'type' : jfloatArray,
5972         }
5973 ,
5974         'tmap:out' : Hash {
5975             'typemap' : typemap(out) jfloatArray,
5976             'code' :  $result = $1; ,
5977             'type' : jfloatArray,
5978         }
5979 ,
5980         'tmap:typecheck' : Hash {
5981             'kwargs' : Hash {
5982                 'name' : precedence,
5983                 'value' : 1080,
5984             }
5985 ,
5986             'typemap' : typemap(typecheck) jfloatArray,
5987             'code' : ,
5988             'type' : jfloatArray,
5989         }
5990 ,
5991         'tmap:javain' : Hash {
5992             'typemap' : typemap(javain) jfloatArray,
5993             'code' : $javainput,
5994             'type' : jfloatArray,
5995         }
5996 ,
5997         'tmap:javaout' : Hash {
5998             'typemap' : typemap(javaout) jfloatArray,
5999             'code' : {
6000     return $jnicall;
6001   },
6002             'type' : jfloatArray,
6003         }
6004 ,
6005     }
6006 ,
6007     'enum SWIGTYPE' : Hash {
6008         'tmap:typecheck' : Hash {
6009             'kwargs' : Hash {
6010                 'name' : precedence,
6011                 'value' : 0,
6012             }
6013 ,
6014             'typemap' : typemap(typecheck) enum SWIGTYPE,
6015             'code' : ,
6016             'type' : enum SWIGTYPE,
6017         }
6018 ,
6019         'tmap:javabase' : Hash {
6020             'typemap' : typemap(javabase) enum SWIGTYPE,
6021             'code' : ,
6022             'type' : enum SWIGTYPE,
6023         }
6024 ,
6025         'tmap:throws' : Hash {
6026             'typemap' : typemap(throws) enum SWIGTYPE,
6027             'code' :  (void)$1;
6028    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); ,
6029             'type' : enum SWIGTYPE,
6030         }
6031 ,
6032         'tmap:jtype' : Hash {
6033             'typemap' : typemap(jtype) enum SWIGTYPE,
6034             'code' : int,
6035             'type' : enum SWIGTYPE,
6036         }
6037 ,
6038         'tmap:javadirectorin' : Hash {
6039             'typemap' : typemap(javadirectorin) enum SWIGTYPE,
6040             'code' : $javaclassname.swigToEnum($jniinput),
6041             'type' : enum SWIGTYPE,
6042         }
6043 ,
6044         'tmap:directorin' : Hash {
6045             'kwargs' : Hash {
6046                 'name' : descriptor,
6047                 'value' : L$packagepath/$javaclassname;,
6048             }
6049 ,
6050             'typemap' : typemap(directorin) enum SWIGTYPE,
6051             'code' : $input = (jint) $1;,
6052             'type' : enum SWIGTYPE,
6053         }
6054 ,
6055         'tmap:javabody' : Hash {
6056             'typemap' : typemap(javabody) enum SWIGTYPE,
6057             'code' :
6058   public final int swigValue() {
6059     return swigValue;
6060   }
6061
6062   public String toString() {
6063     return swigName;
6064   }
6065
6066   public static $javaclassname swigToEnum(int swigValue) {
6067     if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
6068       return swigValues[swigValue];
6069     for (int i = 0; i < swigValues.length; i++)
6070       if (swigValues[i].swigValue == swigValue)
6071         return swigValues[i];
6072     throw new IllegalArgumentException("No enum " + $javaclassname.class + " with value " + swigValue);
6073   }
6074
6075   private $javaclassname(String swigName) {
6076     this.swigName = swigName;
6077     this.swigValue = swigNext++;
6078   }
6079
6080   private $javaclassname(String swigName, int swigValue) {
6081     this.swigName = swigName;
6082     this.swigValue = swigValue;
6083     swigNext = swigValue+1;
6084   }
6085
6086   private $javaclassname(String swigName, $javaclassname swigEnum) {
6087     this.swigName = swigName;
6088     this.swigValue = swigEnum.swigValue;
6089     swigNext = this.swigValue+1;
6090   }
6091
6092   private static $javaclassname[] swigValues = { $enumvalues };
6093   private static int swigNext = 0;
6094   private final int swigValue;
6095   private final String swigName;
6096 ,
6097             'type' : enum SWIGTYPE,
6098         }
6099 ,
6100         'tmap:javadirectorout' : Hash {
6101             'typemap' : typemap(javadirectorout) enum SWIGTYPE,
6102             'code' : ($javacall).swigValue(),
6103             'type' : enum SWIGTYPE,
6104         }
6105 ,
6106         'tmap:directorout' : Hash {
6107             'typemap' : typemap(directorout) enum SWIGTYPE,
6108             'code' :  $result = ($1_ltype)$input; ,
6109             'type' : enum SWIGTYPE,
6110         }
6111 ,
6112         'tmap:out' : Hash {
6113             'typemap' : typemap(out) enum SWIGTYPE,
6114             'code' :  $result = (jint)$1; ,
6115             'type' : enum SWIGTYPE,
6116         }
6117 ,
6118         'tmap:jni' : Hash {
6119             'typemap' : typemap(jni) enum SWIGTYPE,
6120             'code' : jint,
6121             'type' : enum SWIGTYPE,
6122         }
6123 ,
6124         'tmap:javaout' : Hash {
6125             'typemap' : typemap(javaout) enum SWIGTYPE,
6126             'code' : {
6127     return $javaclassname.swigToEnum($jnicall);
6128   },
6129             'type' : enum SWIGTYPE,
6130         }
6131 ,
6132         'tmap:javaclassmodifiers' : Hash {
6133             'typemap' : typemap(javaclassmodifiers) enum SWIGTYPE,
6134             'code' : public final $static class,
6135             'type' : enum SWIGTYPE,
6136         }
6137 ,
6138         'tmap:javacode' : Hash {
6139             'typemap' : typemap(javacode) enum SWIGTYPE,
6140             'code' : ,
6141             'type' : enum SWIGTYPE,
6142         }
6143 ,
6144         'tmap:javain' : Hash {
6145             'typemap' : typemap(javain) enum SWIGTYPE,
6146             'code' : $javainput.swigValue(),
6147             'type' : enum SWIGTYPE,
6148         }
6149 ,
6150         'tmap:in' : Hash {
6151             'kwargs' : Hash {
6152                 'name' : numinputs,
6153                 'value' : 1,
6154             }
6155 ,
6156             'typemap' : typemap(in) enum SWIGTYPE,
6157             'code' :  $1 = ($1_ltype)$input; ,
6158             'type' : enum SWIGTYPE,
6159         }
6160 ,
6161         'tmap:javaimports' : Hash {
6162             'typemap' : typemap(javaimports) enum SWIGTYPE,
6163             'code' : ,
6164             'type' : enum SWIGTYPE,
6165         }
6166 ,
6167         'tmap:javainterfaces' : Hash {
6168             'typemap' : typemap(javainterfaces) enum SWIGTYPE,
6169             'code' : ,
6170             'type' : enum SWIGTYPE,
6171         }
6172 ,
6173         'tmap:jstype' : Hash {
6174             'typemap' : typemap(jstype) enum SWIGTYPE,
6175             'code' : $javaclassname,
6176             'type' : enum SWIGTYPE,
6177         }
6178 ,
6179     }
6180 ,
6181     'r.q(const).enum SWIGTYPE' : Hash {
6182         'tmap:jstype' : Hash {
6183             'typemap' : typemap(jstype) enum SWIGTYPE const &,
6184             'code' : $*javaclassname,
6185             'type' : r.q(const).enum SWIGTYPE,
6186         }
6187 ,
6188         'tmap:directorin' : Hash {
6189             'kwargs' : Hash {
6190                 'name' : descriptor,
6191                 'value' : L$packagepath/$*javaclassname;,
6192             }
6193 ,
6194             'typemap' : typemap(directorin) enum SWIGTYPE const &,
6195             'code' : $input = (jint)$1_name;,
6196             'type' : r.q(const).enum SWIGTYPE,
6197         }
6198 ,
6199         'tmap:javadirectorin' : Hash {
6200             'typemap' : typemap(javadirectorin) enum SWIGTYPE const &,
6201             'code' : $*javaclassname.swigToEnum($jniinput),
6202             'type' : r.q(const).enum SWIGTYPE,
6203         }
6204 ,
6205         'tmap:in' : Hash {
6206             'locals' : Hash {
6207                 'name' : temp,
6208                 'type' : $*1_ltype,
6209             }
6210 ,
6211             'kwargs' : Hash {
6212                 'name' : numinputs,
6213                 'value' : 1,
6214             }
6215 ,
6216             'typemap' : typemap(in) enum SWIGTYPE const &,
6217             'code' :  temp = ($*1_ltype)$input;
6218    $1 = &temp; ,
6219             'type' : r.q(const).enum SWIGTYPE,
6220         }
6221 ,
6222         'tmap:directorout' : Hash {
6223             'kwargs' : Hash {
6224                 'name' : warning,
6225                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
6226             }
6227 ,
6228             'typemap' : typemap(directorout) enum SWIGTYPE const &,
6229             'code' :  static $*1_ltype temp = ($*1_ltype)$input;
6230    $result = &temp; ,
6231             'type' : r.q(const).enum SWIGTYPE,
6232         }
6233 ,
6234         'tmap:javadirectorout' : Hash {
6235             'typemap' : typemap(javadirectorout) enum SWIGTYPE const &,
6236             'code' : ($javacall).swigValue(),
6237             'type' : r.q(const).enum SWIGTYPE,
6238         }
6239 ,
6240         'tmap:jni' : Hash {
6241             'typemap' : typemap(jni) enum SWIGTYPE const &,
6242             'code' : jint,
6243             'type' : r.q(const).enum SWIGTYPE,
6244         }
6245 ,
6246         'tmap:jtype' : Hash {
6247             'typemap' : typemap(jtype) enum SWIGTYPE const &,
6248             'code' : int,
6249             'type' : r.q(const).enum SWIGTYPE,
6250         }
6251 ,
6252         'tmap:out' : Hash {
6253             'typemap' : typemap(out) enum SWIGTYPE const &,
6254             'code' :  $result = (jint)*$1; ,
6255             'type' : r.q(const).enum SWIGTYPE,
6256         }
6257 ,
6258         'tmap:typecheck' : Hash {
6259             'kwargs' : Hash {
6260                 'name' : precedence,
6261                 'value' : 0,
6262             }
6263 ,
6264             'typemap' : typemap(typecheck) enum SWIGTYPE const &,
6265             'code' : ,
6266             'type' : r.q(const).enum SWIGTYPE,
6267         }
6268 ,
6269         'tmap:throws' : Hash {
6270             'typemap' : typemap(throws) enum SWIGTYPE const &,
6271             'code' :  (void)$1;
6272    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); ,
6273             'type' : r.q(const).enum SWIGTYPE,
6274         }
6275 ,
6276         'tmap:javain' : Hash {
6277             'typemap' : typemap(javain) enum SWIGTYPE const &,
6278             'code' : $javainput.swigValue(),
6279             'type' : r.q(const).enum SWIGTYPE,
6280         }
6281 ,
6282         'tmap:javaout' : Hash {
6283             'typemap' : typemap(javaout) enum SWIGTYPE const &,
6284             'code' : {
6285     return $*javaclassname.swigToEnum($jnicall);
6286   },
6287             'type' : r.q(const).enum SWIGTYPE,
6288         }
6289 ,
6290     }
6291 ,
6292     'r.a(ANY).SWIGTYPE' : Hash {
6293         'tmap:jstype' : Hash {
6294             'typemap' : typemap(jstype) SWIGTYPE (&)[ANY],
6295             'code' : $javaclassname,
6296             'type' : r.a(ANY).SWIGTYPE,
6297         }
6298 ,
6299         'tmap:directorin' : Hash {
6300             'kwargs' : Hash {
6301                 'name' : descriptor,
6302                 'value' : L$packagepath/$javaclassname;,
6303             }
6304 ,
6305             'typemap' : typemap(directorin) SWIGTYPE (&)[ANY],
6306             'code' :  *($&1_ltype)&$input = ($1_ltype) &$1; ,
6307             'type' : r.a(ANY).SWIGTYPE,
6308         }
6309 ,
6310         'tmap:javadirectorin' : Hash {
6311             'typemap' : typemap(javadirectorin) SWIGTYPE (&)[ANY],
6312             'code' : new $javaclassname($jniinput, false),
6313             'type' : r.a(ANY).SWIGTYPE,
6314         }
6315 ,
6316         'tmap:in' : Hash {
6317             'kwargs' : Hash {
6318                 'name' : numinputs,
6319                 'value' : 1,
6320             }
6321 ,
6322             'typemap' : typemap(in) SWIGTYPE (&)[ANY],
6323             'code' :  $1 = *($&1_ltype)&$input;
6324   if(!$1) {
6325     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
6326     return $null;
6327   } ,
6328             'type' : r.a(ANY).SWIGTYPE,
6329         }
6330 ,
6331         'tmap:directorout' : Hash {
6332             'kwargs' : Hash {
6333                 'name' : warning,
6334                 'value' : 473:Returning a pointer or reference in a director method is not recommended.,
6335             }
6336 ,
6337             'typemap' : typemap(directorout) SWIGTYPE (&)[ANY],
6338             'code' :  if (!$input) {
6339      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
6340      return $null;
6341    }
6342    $result = *($&1_ltype)&$input; ,
6343             'type' : r.a(ANY).SWIGTYPE,
6344         }
6345 ,
6346         'tmap:javadirectorout' : Hash {
6347             'typemap' : typemap(javadirectorout) SWIGTYPE (&)[ANY],
6348             'code' : $javaclassname.getCPtr($javacall),
6349             'type' : r.a(ANY).SWIGTYPE,
6350         }
6351 ,
6352         'tmap:jni' : Hash {
6353             'typemap' : typemap(jni) SWIGTYPE (&)[ANY],
6354             'code' : jlong,
6355             'type' : r.a(ANY).SWIGTYPE,
6356         }
6357 ,
6358         'tmap:jtype' : Hash {
6359             'typemap' : typemap(jtype) SWIGTYPE (&)[ANY],
6360             'code' : long,
6361             'type' : r.a(ANY).SWIGTYPE,
6362         }
6363 ,
6364         'tmap:out' : Hash {
6365             'typemap' : typemap(out) SWIGTYPE (&)[ANY],
6366             'code' :  *($&1_ltype)&$result = $1; ,
6367             'type' : r.a(ANY).SWIGTYPE,
6368         }
6369 ,
6370         'tmap:typecheck' : Hash {
6371             'kwargs' : Hash {
6372                 'name' : precedence,
6373                 'value' : 0,
6374             }
6375 ,
6376             'typemap' : typemap(typecheck) SWIGTYPE (&)[ANY],
6377             'code' : ,
6378             'type' : r.a(ANY).SWIGTYPE,
6379         }
6380 ,
6381         'tmap:throws' : Hash {
6382             'typemap' : typemap(throws) SWIGTYPE (&)[ANY],
6383             'code' :  (void)$1;
6384    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
6385    return $null; ,
6386             'type' : r.a(ANY).SWIGTYPE,
6387         }
6388 ,
6389         'tmap:javain' : Hash {
6390             'typemap' : typemap(javain) SWIGTYPE (&)[ANY],
6391             'code' : $javaclassname.getCPtr($javainput),
6392             'type' : r.a(ANY).SWIGTYPE,
6393         }
6394 ,
6395         'tmap:javaout' : Hash {
6396             'typemap' : typemap(javaout) SWIGTYPE (&)[ANY],
6397             'code' : {
6398     return new $javaclassname($jnicall, $owner);
6399   },
6400             'type' : r.a(ANY).SWIGTYPE,
6401         }
6402 ,
6403     }
6404 ,
6405     'r.p.SWIGTYPE' : Hash {
6406         'tmap:jstype' : Hash {
6407             'typemap' : typemap(jstype) SWIGTYPE *&,
6408             'code' : $*javaclassname,
6409             'type' : r.p.SWIGTYPE,
6410         }
6411 ,
6412         'tmap:in' : Hash {
6413             'locals' : Hash {
6414                 'name' : temp,
6415                 'value' : 0,
6416                 'type' : $*1_ltype,
6417             }
6418 ,
6419             'kwargs' : Hash {
6420                 'name' : numinputs,
6421                 'value' : 1,
6422             }
6423 ,
6424             'typemap' : typemap(in) SWIGTYPE *&,
6425             'code' :  temp = *($1_ltype)&$input;
6426    $1 = &temp; ,
6427             'type' : r.p.SWIGTYPE,
6428         }
6429 ,
6430         'tmap:jni' : Hash {
6431             'typemap' : typemap(jni) SWIGTYPE *&,
6432             'code' : jlong,
6433             'type' : r.p.SWIGTYPE,
6434         }
6435 ,
6436         'tmap:jtype' : Hash {
6437             'typemap' : typemap(jtype) SWIGTYPE *&,
6438             'code' : long,
6439             'type' : r.p.SWIGTYPE,
6440         }
6441 ,
6442         'tmap:javain' : Hash {
6443             'typemap' : typemap(javain) SWIGTYPE *&,
6444             'code' : $*javaclassname.getCPtr($javainput),
6445             'type' : r.p.SWIGTYPE,
6446         }
6447 ,
6448         'tmap:out' : Hash {
6449             'typemap' : typemap(out) SWIGTYPE *&,
6450             'code' :  *($1_ltype)&$result = *$1; ,
6451             'type' : r.p.SWIGTYPE,
6452         }
6453 ,
6454         'tmap:javaout' : Hash {
6455             'typemap' : typemap(javaout) SWIGTYPE *&,
6456             'code' : {
6457     long cPtr = $jnicall;
6458     return (cPtr == 0) ? null : new $*javaclassname(cPtr, $owner);
6459   },
6460             'type' : r.p.SWIGTYPE,
6461         }
6462 ,
6463     }
6464 ,
6465     'm(CLASS).SWIGTYPE' : Hash {
6466         'tmap:typecheck' : Hash {
6467             'kwargs' : Hash {
6468                 'name' : precedence,
6469                 'value' : 0,
6470             }
6471 ,
6472             'typemap' : typemap(typecheck) SWIGTYPE CLASS::*,
6473             'code' : ,
6474             'type' : m(CLASS).SWIGTYPE,
6475         }
6476 ,
6477         'tmap:javabase' : Hash {
6478             'typemap' : typemap(javabase) SWIGTYPE CLASS::*,
6479             'code' : ,
6480             'type' : m(CLASS).SWIGTYPE,
6481         }
6482 ,
6483         'tmap:jtype' : Hash {
6484             'typemap' : typemap(jtype) SWIGTYPE CLASS::*,
6485             'code' : long,
6486             'type' : m(CLASS).SWIGTYPE,
6487         }
6488 ,
6489         'tmap:javadirectorin' : Hash {
6490             'typemap' : typemap(javadirectorin) SWIGTYPE CLASS::*,
6491             'code' : new $javaclassname($jniinput, false),
6492             'type' : m(CLASS).SWIGTYPE,
6493         }
6494 ,
6495         'tmap:directorin' : Hash {
6496             'kwargs' : Hash {
6497                 'name' : descriptor,
6498                 'value' : L$packagepath/$javaclassname;,
6499             }
6500 ,
6501             'typemap' : typemap(directorin) SWIGTYPE CLASS::*,
6502             'code' :  *(($&1_ltype)&$input) = ($1_ltype) $1; ,
6503             'type' : m(CLASS).SWIGTYPE,
6504         }
6505 ,
6506         'tmap:javabody' : Hash {
6507             'typemap' : typemap(javabody) SWIGTYPE CLASS::*,
6508             'code' :
6509   private long swigCPtr;
6510
6511   protected $javaclassname(long cPtr, boolean futureUse) {
6512     swigCPtr = cPtr;
6513   }
6514
6515   protected $javaclassname() {
6516     swigCPtr = 0;
6517   }
6518
6519   protected static long getCPtr($javaclassname obj) {
6520     return (obj == null) ? 0 : obj.swigCPtr;
6521   }
6522 ,
6523             'type' : m(CLASS).SWIGTYPE,
6524         }
6525 ,
6526         'tmap:javadirectorout' : Hash {
6527             'typemap' : typemap(javadirectorout) SWIGTYPE CLASS::*,
6528             'code' : $javaclassname.getCPtr($javacall),
6529             'type' : m(CLASS).SWIGTYPE,
6530         }
6531 ,
6532         'tmap:directorout' : Hash {
6533             'kwargs' : Hash {
6534                 'name' : warning,
6535                 'value' : 473:Returning a pointer or reference in a director method is not recommended.,
6536             }
6537 ,
6538             'typemap' : typemap(directorout) SWIGTYPE CLASS::*,
6539             'code' :  $result = *($&1_ltype)&$input; ,
6540             'type' : m(CLASS).SWIGTYPE,
6541         }
6542 ,
6543         'tmap:out' : Hash {
6544             'typemap' : typemap(out) SWIGTYPE CLASS::*,
6545             'code' :  *($&1_ltype)&$result = $1; ,
6546             'type' : m(CLASS).SWIGTYPE,
6547         }
6548 ,
6549         'tmap:jni' : Hash {
6550             'typemap' : typemap(jni) SWIGTYPE CLASS::*,
6551             'code' : jlong,
6552             'type' : m(CLASS).SWIGTYPE,
6553         }
6554 ,
6555         'tmap:javaout' : Hash {
6556             'typemap' : typemap(javaout) SWIGTYPE CLASS::*,
6557             'code' : {
6558     long cPtr = $jnicall;
6559     return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
6560   },
6561             'type' : m(CLASS).SWIGTYPE,
6562         }
6563 ,
6564         'tmap:javaclassmodifiers' : Hash {
6565             'typemap' : typemap(javaclassmodifiers) SWIGTYPE CLASS::*,
6566             'code' : public class,
6567             'type' : m(CLASS).SWIGTYPE,
6568         }
6569 ,
6570         'tmap:javacode' : Hash {
6571             'typemap' : typemap(javacode) SWIGTYPE CLASS::*,
6572             'code' : ,
6573             'type' : m(CLASS).SWIGTYPE,
6574         }
6575 ,
6576         'tmap:javain' : Hash {
6577             'typemap' : typemap(javain) SWIGTYPE CLASS::*,
6578             'code' : $javaclassname.getCPtr($javainput),
6579             'type' : m(CLASS).SWIGTYPE,
6580         }
6581 ,
6582         'tmap:in' : Hash {
6583             'kwargs' : Hash {
6584                 'name' : numinputs,
6585                 'value' : 1,
6586             }
6587 ,
6588             'typemap' : typemap(in) SWIGTYPE CLASS::*,
6589             'code' :  $1 = *($&1_ltype)&$input; ,
6590             'type' : m(CLASS).SWIGTYPE,
6591         }
6592 ,
6593         'tmap:javaimports' : Hash {
6594             'typemap' : typemap(javaimports) SWIGTYPE CLASS::*,
6595             'code' : ,
6596             'type' : m(CLASS).SWIGTYPE,
6597         }
6598 ,
6599         'tmap:javainterfaces' : Hash {
6600             'typemap' : typemap(javainterfaces) SWIGTYPE CLASS::*,
6601             'code' : ,
6602             'type' : m(CLASS).SWIGTYPE,
6603         }
6604 ,
6605         'tmap:jstype' : Hash {
6606             'typemap' : typemap(jstype) SWIGTYPE CLASS::*,
6607             'code' : $javaclassname,
6608             'type' : m(CLASS).SWIGTYPE,
6609         }
6610 ,
6611     }
6612 ,
6613     'r.SWIGTYPE' : Hash {
6614         'tmap:typecheck' : Hash {
6615             'kwargs' : Hash {
6616                 'name' : precedence,
6617                 'value' : 0,
6618             }
6619 ,
6620             'typemap' : typemap(typecheck) SWIGTYPE &,
6621             'code' : ,
6622             'type' : r.SWIGTYPE,
6623         }
6624 ,
6625         'tmap:javabase' : Hash {
6626             'typemap' : typemap(javabase) SWIGTYPE &,
6627             'code' : ,
6628             'type' : r.SWIGTYPE,
6629         }
6630 ,
6631         'tmap:throws' : Hash {
6632             'typemap' : typemap(throws) SWIGTYPE &,
6633             'code' :  (void)$1;
6634    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
6635    return $null; ,
6636             'type' : r.SWIGTYPE,
6637         }
6638 ,
6639         'tmap:jtype' : Hash {
6640             'typemap' : typemap(jtype) SWIGTYPE &,
6641             'code' : long,
6642             'type' : r.SWIGTYPE,
6643         }
6644 ,
6645         'tmap:javadirectorin' : Hash {
6646             'typemap' : typemap(javadirectorin) SWIGTYPE &,
6647             'code' : new $javaclassname($jniinput, false),
6648             'type' : r.SWIGTYPE,
6649         }
6650 ,
6651         'tmap:directorin' : Hash {
6652             'kwargs' : Hash {
6653                 'name' : descriptor,
6654                 'value' : L$packagepath/$javaclassname;,
6655             }
6656 ,
6657             'typemap' : typemap(directorin) SWIGTYPE &,
6658             'code' :  *($&1_ltype)&$input = ($1_ltype) &$1; ,
6659             'type' : r.SWIGTYPE,
6660         }
6661 ,
6662         'tmap:javabody' : Hash {
6663             'typemap' : typemap(javabody) SWIGTYPE &,
6664             'code' :
6665   private long swigCPtr;
6666
6667   protected $javaclassname(long cPtr, boolean futureUse) {
6668     swigCPtr = cPtr;
6669   }
6670
6671   protected $javaclassname() {
6672     swigCPtr = 0;
6673   }
6674
6675   protected static long getCPtr($javaclassname obj) {
6676     return (obj == null) ? 0 : obj.swigCPtr;
6677   }
6678 ,
6679             'type' : r.SWIGTYPE,
6680         }
6681 ,
6682         'tmap:javadirectorout' : Hash {
6683             'typemap' : typemap(javadirectorout) SWIGTYPE &,
6684             'code' : $javaclassname.getCPtr($javacall),
6685             'type' : r.SWIGTYPE,
6686         }
6687 ,
6688         'tmap:directorout' : Hash {
6689             'kwargs' : Hash {
6690                 'name' : warning,
6691                 'value' : 473:Returning a pointer or reference in a director method is not recommended.,
6692             }
6693 ,
6694             'typemap' : typemap(directorout) SWIGTYPE &,
6695             'code' :  if (!$input) {
6696      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
6697      return $null;
6698    }
6699    $result = *($&1_ltype)&$input; ,
6700             'type' : r.SWIGTYPE,
6701         }
6702 ,
6703         'tmap:out' : Hash {
6704             'typemap' : typemap(out) SWIGTYPE &,
6705             'code' :  *($&1_ltype)&$result = $1; ,
6706             'type' : r.SWIGTYPE,
6707         }
6708 ,
6709         'tmap:jni' : Hash {
6710             'typemap' : typemap(jni) SWIGTYPE &,
6711             'code' : jlong,
6712             'type' : r.SWIGTYPE,
6713         }
6714 ,
6715         'tmap:javaout' : Hash {
6716             'typemap' : typemap(javaout) SWIGTYPE &,
6717             'code' : {
6718     return new $javaclassname($jnicall, $owner);
6719   },
6720             'type' : r.SWIGTYPE,
6721         }
6722 ,
6723         'tmap:javaclassmodifiers' : Hash {
6724             'typemap' : typemap(javaclassmodifiers) SWIGTYPE &,
6725             'code' : public class,
6726             'type' : r.SWIGTYPE,
6727         }
6728 ,
6729         'tmap:javacode' : Hash {
6730             'typemap' : typemap(javacode) SWIGTYPE &,
6731             'code' : ,
6732             'type' : r.SWIGTYPE,
6733         }
6734 ,
6735         'tmap:javain' : Hash {
6736             'typemap' : typemap(javain) SWIGTYPE &,
6737             'code' : $javaclassname.getCPtr($javainput),
6738             'type' : r.SWIGTYPE,
6739         }
6740 ,
6741         'tmap:in' : Hash {
6742             'kwargs' : Hash {
6743                 'name' : numinputs,
6744                 'value' : 1,
6745             }
6746 ,
6747             'typemap' : typemap(in) SWIGTYPE &,
6748             'code' :  $1 = *($&1_ltype)&$input;
6749   if(!$1) {
6750     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null");
6751     return $null;
6752   } ,
6753             'type' : r.SWIGTYPE,
6754         }
6755 ,
6756         'tmap:javaimports' : Hash {
6757             'typemap' : typemap(javaimports) SWIGTYPE &,
6758             'code' : ,
6759             'type' : r.SWIGTYPE,
6760         }
6761 ,
6762         'tmap:javainterfaces' : Hash {
6763             'typemap' : typemap(javainterfaces) SWIGTYPE &,
6764             'code' : ,
6765             'type' : r.SWIGTYPE,
6766         }
6767 ,
6768         'tmap:jstype' : Hash {
6769             'typemap' : typemap(jstype) SWIGTYPE &,
6770             'code' : $javaclassname,
6771             'type' : r.SWIGTYPE,
6772         }
6773 ,
6774     }
6775 ,
6776     'a().SWIGTYPE' : Hash {
6777         'tmap:typecheck' : Hash {
6778             'kwargs' : Hash {
6779                 'name' : precedence,
6780                 'value' : 0,
6781             }
6782 ,
6783             'typemap' : typemap(typecheck) SWIGTYPE [],
6784             'code' : ,
6785             'type' : a().SWIGTYPE,
6786         }
6787 ,
6788         'tmap:javabase' : Hash {
6789             'typemap' : typemap(javabase) SWIGTYPE [],
6790             'code' : ,
6791             'type' : a().SWIGTYPE,
6792         }
6793 ,
6794         'tmap:throws' : Hash {
6795             'typemap' : typemap(throws) SWIGTYPE [],
6796             'code' :  (void)$1;
6797    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
6798    return $null; ,
6799             'type' : a().SWIGTYPE,
6800         }
6801 ,
6802         'tmap:jtype' : Hash {
6803             'typemap' : typemap(jtype) SWIGTYPE [],
6804             'code' : long,
6805             'type' : a().SWIGTYPE,
6806         }
6807 ,
6808         'tmap:javabody' : Hash {
6809             'typemap' : typemap(javabody) SWIGTYPE [],
6810             'code' :
6811   private long swigCPtr;
6812
6813   protected $javaclassname(long cPtr, boolean futureUse) {
6814     swigCPtr = cPtr;
6815   }
6816
6817   protected $javaclassname() {
6818     swigCPtr = 0;
6819   }
6820
6821   protected static long getCPtr($javaclassname obj) {
6822     return (obj == null) ? 0 : obj.swigCPtr;
6823   }
6824 ,
6825             'type' : a().SWIGTYPE,
6826         }
6827 ,
6828         'tmap:out' : Hash {
6829             'typemap' : typemap(out) SWIGTYPE [],
6830             'code' :  *($&1_ltype)&$result = $1; ,
6831             'type' : a().SWIGTYPE,
6832         }
6833 ,
6834         'tmap:jni' : Hash {
6835             'typemap' : typemap(jni) SWIGTYPE [],
6836             'code' : jlong,
6837             'type' : a().SWIGTYPE,
6838         }
6839 ,
6840         'tmap:javaout' : Hash {
6841             'typemap' : typemap(javaout) SWIGTYPE [],
6842             'code' : {
6843     long cPtr = $jnicall;
6844     return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
6845   },
6846             'type' : a().SWIGTYPE,
6847         }
6848 ,
6849         'tmap:javaclassmodifiers' : Hash {
6850             'typemap' : typemap(javaclassmodifiers) SWIGTYPE [],
6851             'code' : public class,
6852             'type' : a().SWIGTYPE,
6853         }
6854 ,
6855         'tmap:javacode' : Hash {
6856             'typemap' : typemap(javacode) SWIGTYPE [],
6857             'code' : ,
6858             'type' : a().SWIGTYPE,
6859         }
6860 ,
6861         'tmap:javaimports' : Hash {
6862             'typemap' : typemap(javaimports) SWIGTYPE [],
6863             'code' : ,
6864             'type' : a().SWIGTYPE,
6865         }
6866 ,
6867         'tmap:javain' : Hash {
6868             'typemap' : typemap(javain) SWIGTYPE [],
6869             'code' : $javaclassname.getCPtr($javainput),
6870             'type' : a().SWIGTYPE,
6871         }
6872 ,
6873         'tmap:in' : Hash {
6874             'kwargs' : Hash {
6875                 'name' : numinputs,
6876                 'value' : 1,
6877             }
6878 ,
6879             'typemap' : typemap(in) SWIGTYPE [],
6880             'code' :  $1 = *($&1_ltype)&$input; ,
6881             'type' : a().SWIGTYPE,
6882         }
6883 ,
6884         'tmap:javainterfaces' : Hash {
6885             'typemap' : typemap(javainterfaces) SWIGTYPE [],
6886             'code' : ,
6887             'type' : a().SWIGTYPE,
6888         }
6889 ,
6890         'tmap:jstype' : Hash {
6891             'typemap' : typemap(jstype) SWIGTYPE [],
6892             'code' : $javaclassname,
6893             'type' : a().SWIGTYPE,
6894         }
6895 ,
6896         'tmap:freearg' : Hash {
6897             'typemap' : typemap(freearg) SWIGTYPE [],
6898             'code' : ,
6899             'type' : a().SWIGTYPE,
6900         }
6901 ,
6902     }
6903 ,
6904     'SWIGTYPE' : Hash {
6905         'tmap:typecheck' : Hash {
6906             'kwargs' : Hash {
6907                 'name' : precedence,
6908                 'value' : 0,
6909             }
6910 ,
6911             'typemap' : typemap(typecheck) SWIGTYPE,
6912             'code' : ,
6913             'type' : SWIGTYPE,
6914         }
6915 ,
6916         'tmap:javabase' : Hash {
6917             'typemap' : typemap(javabase) SWIGTYPE,
6918             'code' : ,
6919             'type' : SWIGTYPE,
6920         }
6921 ,
6922         'tmap:javabody_derived' : Hash {
6923             'typemap' : typemap(javabody_derived) SWIGTYPE,
6924             'code' :
6925   private long swigCPtr;
6926
6927   protected $javaclassname(long cPtr, boolean cMemoryOwn) {
6928     super($imclassname.SWIG$javaclassnameUpcast(cPtr), cMemoryOwn);
6929     swigCPtr = cPtr;
6930   }
6931
6932   protected static long getCPtr($javaclassname obj) {
6933     return (obj == null) ? 0 : obj.swigCPtr;
6934   }
6935 ,
6936             'type' : SWIGTYPE,
6937         }
6938 ,
6939         'tmap:javadestruct_derived' : Hash {
6940             'kwargs' : Hash {
6941                 'name' : methodname,
6942                 'value' : delete,
6943                 'nextSibling' : Hash {
6944                     'name' : methodmodifiers,
6945                     'value' : public synchronized,
6946                 }
6947 ,
6948             }
6949 ,
6950             'typemap' : typemap(javadestruct_derived) SWIGTYPE,
6951             'code' : {
6952     if(swigCPtr != 0 && swigCMemOwn) {
6953       swigCMemOwn = false;
6954       $jnicall;
6955     }
6956     swigCPtr = 0;
6957     super.delete();
6958   },
6959             'type' : SWIGTYPE,
6960         }
6961 ,
6962         'tmap:directorowner_take' : Hash {
6963             'kwargs' : Hash {
6964                 'name' : methodname,
6965                 'value' : swigTakeOwnership,
6966             }
6967 ,
6968             'typemap' : typemap(directorowner_take) SWIGTYPE,
6969             'code' :
6970   public void $methodname() {
6971     swigCMemOwn = true;
6972     $jnicall;
6973   }
6974 ,
6975             'type' : SWIGTYPE,
6976         }
6977 ,
6978         'tmap:throws' : Hash {
6979             'typemap' : typemap(throws) SWIGTYPE,
6980             'code' :  (void)$1;
6981    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
6982    return $null; ,
6983             'type' : SWIGTYPE,
6984         }
6985 ,
6986         'tmap:jtype' : Hash {
6987             'typemap' : typemap(jtype) SWIGTYPE,
6988             'code' : long,
6989             'type' : SWIGTYPE,
6990         }
6991 ,
6992         'tmap:javadirectorin' : Hash {
6993             'typemap' : typemap(javadirectorin) SWIGTYPE,
6994             'code' : new $&javaclassname($jniinput, false),
6995             'type' : SWIGTYPE,
6996         }
6997 ,
6998         'tmap:directorin' : Hash {
6999             'kwargs' : Hash {
7000                 'name' : descriptor,
7001                 'value' : L$packagepath/$&javaclassname;,
7002             }
7003 ,
7004             'typemap' : typemap(directorin) SWIGTYPE,
7005             'code' :  $input = 0;
7006    *(($&1_ltype*)&$input) = &$1; ,
7007             'type' : SWIGTYPE,
7008         }
7009 ,
7010         'tmap:javabody' : Hash {
7011             'typemap' : typemap(javabody) SWIGTYPE,
7012             'code' :
7013   private long swigCPtr;
7014   protected boolean swigCMemOwn;
7015
7016   protected $javaclassname(long cPtr, boolean cMemoryOwn) {
7017     swigCMemOwn = cMemoryOwn;
7018     swigCPtr = cPtr;
7019   }
7020
7021   protected static long getCPtr($javaclassname obj) {
7022     return (obj == null) ? 0 : obj.swigCPtr;
7023   }
7024 ,
7025             'type' : SWIGTYPE,
7026         }
7027 ,
7028         'tmap:javaconstruct' : Hash {
7029             'kwargs' : Hash {
7030                 'name' : directorconnect,
7031                 'value' :
7032     $imclassname.$javaclassname_director_connect(this, swigCPtr, swigCMemOwn, true);,
7033             }
7034 ,
7035             'typemap' : typemap(javaconstruct) SWIGTYPE,
7036             'code' : {
7037     this($imcall, true);$directorconnect
7038   },
7039             'type' : SWIGTYPE,
7040         }
7041 ,
7042         'tmap:javadirectorout' : Hash {
7043             'typemap' : typemap(javadirectorout) SWIGTYPE,
7044             'code' : $&javaclassname.getCPtr($javacall),
7045             'type' : SWIGTYPE,
7046         }
7047 ,
7048         'tmap:directorout' : Hash {
7049             'locals' : Hash {
7050                 'name' : argp,
7051                 'type' : $&1_type,
7052             }
7053 ,
7054             'typemap' : typemap(directorout) SWIGTYPE,
7055             'code' :  argp = *($&1_ltype*)&$input;
7056    if (!argp) {
7057      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Unexpected null return for type $1_type");
7058      return $null;
7059    }
7060    $result = *argp; ,
7061             'type' : SWIGTYPE,
7062         }
7063 ,
7064         'tmap:out' : Hash {
7065             'typemap' : typemap(out) SWIGTYPE,
7066             'code' :  *($&1_ltype*)&$result = new $1_ltype(($1_ltype &)$1); ,
7067             'type' : SWIGTYPE,
7068         }
7069 ,
7070         'tmap:jni' : Hash {
7071             'typemap' : typemap(jni) SWIGTYPE,
7072             'code' : jlong,
7073             'type' : SWIGTYPE,
7074         }
7075 ,
7076         'tmap:javafinalize' : Hash {
7077             'typemap' : typemap(javafinalize) SWIGTYPE,
7078             'code' :
7079   protected void finalize() {
7080     delete();
7081   }
7082 ,
7083             'type' : SWIGTYPE,
7084         }
7085 ,
7086         'tmap:javaout' : Hash {
7087             'typemap' : typemap(javaout) SWIGTYPE,
7088             'code' : {
7089     return new $&javaclassname($jnicall, true);
7090   },
7091             'type' : SWIGTYPE,
7092         }
7093 ,
7094         'tmap:javadestruct' : Hash {
7095             'kwargs' : Hash {
7096                 'name' : methodname,
7097                 'value' : delete,
7098                 'nextSibling' : Hash {
7099                     'name' : methodmodifiers,
7100                     'value' : public synchronized,
7101                 }
7102 ,
7103             }
7104 ,
7105             'typemap' : typemap(javadestruct) SWIGTYPE,
7106             'code' : {
7107     if(swigCPtr != 0 && swigCMemOwn) {
7108       swigCMemOwn = false;
7109       $jnicall;
7110     }
7111     swigCPtr = 0;
7112   },
7113             'type' : SWIGTYPE,
7114         }
7115 ,
7116         'tmap:directordisconnect' : Hash {
7117             'kwargs' : Hash {
7118                 'name' : methodname,
7119                 'value' : swigDirectorDisconnect,
7120             }
7121 ,
7122             'typemap' : typemap(directordisconnect) SWIGTYPE,
7123             'code' :
7124   protected void $methodname() {
7125     swigCMemOwn = false;
7126     $jnicall;
7127   }
7128 ,
7129             'type' : SWIGTYPE,
7130         }
7131 ,
7132         'tmap:javaclassmodifiers' : Hash {
7133             'typemap' : typemap(javaclassmodifiers) SWIGTYPE,
7134             'code' : public class,
7135             'type' : SWIGTYPE,
7136         }
7137 ,
7138         'tmap:javacode' : Hash {
7139             'typemap' : typemap(javacode) SWIGTYPE,
7140             'code' : ,
7141             'type' : SWIGTYPE,
7142         }
7143 ,
7144         'tmap:javain' : Hash {
7145             'typemap' : typemap(javain) SWIGTYPE,
7146             'code' : $&javaclassname.getCPtr($javainput),
7147             'type' : SWIGTYPE,
7148         }
7149 ,
7150         'tmap:in' : Hash {
7151             'locals' : Hash {
7152                 'name' : argp,
7153                 'type' : $&1_type,
7154             }
7155 ,
7156             'kwargs' : Hash {
7157                 'name' : numinputs,
7158                 'value' : 1,
7159             }
7160 ,
7161             'typemap' : typemap(in) SWIGTYPE,
7162             'code' :  argp = *($&1_ltype*)&$input;
7163    if (!argp) {
7164      SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type");
7165      return $null;
7166    }
7167    $1 = *argp; ,
7168             'type' : SWIGTYPE,
7169         }
7170 ,
7171         'tmap:javaimports' : Hash {
7172             'typemap' : typemap(javaimports) SWIGTYPE,
7173             'code' : ,
7174             'type' : SWIGTYPE,
7175         }
7176 ,
7177         'tmap:javainterfaces' : Hash {
7178             'typemap' : typemap(javainterfaces) SWIGTYPE,
7179             'code' : ,
7180             'type' : SWIGTYPE,
7181         }
7182 ,
7183         'tmap:directorowner_release' : Hash {
7184             'kwargs' : Hash {
7185                 'name' : methodname,
7186                 'value' : swigReleaseOwnership,
7187             }
7188 ,
7189             'typemap' : typemap(directorowner_release) SWIGTYPE,
7190             'code' :
7191   public void $methodname() {
7192     swigCMemOwn = false;
7193     $jnicall;
7194   }
7195 ,
7196             'type' : SWIGTYPE,
7197         }
7198 ,
7199         'tmap:jstype' : Hash {
7200             'typemap' : typemap(jstype) SWIGTYPE,
7201             'code' : $&javaclassname,
7202             'type' : SWIGTYPE,
7203         }
7204 ,
7205         'VARARGS_SENTINEL' : Hash {
7206             'tmap:in' : Hash {
7207                 'kwargs' : Hash {
7208                     'name' : numinputs,
7209                     'value' : 0,
7210                 }
7211 ,
7212                 'pname' : VARARGS_SENTINEL,
7213                 'typemap' : typemap(in) SWIGTYPE VARARGS_SENTINEL,
7214                 'code' : ,
7215                 'type' : SWIGTYPE,
7216             }
7217 ,
7218         }
7219 ,
7220     }
7221 ,
7222     'p.SWIGTYPE' : Hash {
7223         'tmap:typecheck' : Hash {
7224             'kwargs' : Hash {
7225                 'name' : precedence,
7226                 'value' : 0,
7227             }
7228 ,
7229             'typemap' : typemap(typecheck) SWIGTYPE *,
7230             'code' : ,
7231             'type' : p.SWIGTYPE,
7232         }
7233 ,
7234         'tmap:javabase' : Hash {
7235             'typemap' : typemap(javabase) SWIGTYPE *,
7236             'code' : ,
7237             'type' : p.SWIGTYPE,
7238         }
7239 ,
7240         'tmap:throws' : Hash {
7241             'typemap' : typemap(throws) SWIGTYPE *,
7242             'code' :  (void)$1;
7243    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
7244    return $null; ,
7245             'type' : p.SWIGTYPE,
7246         }
7247 ,
7248         'tmap:jtype' : Hash {
7249             'typemap' : typemap(jtype) SWIGTYPE *,
7250             'code' : long,
7251             'type' : p.SWIGTYPE,
7252         }
7253 ,
7254         'tmap:javadirectorin' : Hash {
7255             'typemap' : typemap(javadirectorin) SWIGTYPE *,
7256             'code' : new $javaclassname($jniinput, false),
7257             'type' : p.SWIGTYPE,
7258         }
7259 ,
7260         'tmap:directorin' : Hash {
7261             'kwargs' : Hash {
7262                 'name' : descriptor,
7263                 'value' : L$packagepath/$javaclassname;,
7264             }
7265 ,
7266             'typemap' : typemap(directorin) SWIGTYPE *,
7267             'code' :  *(($&1_ltype)&$input) = ($1_ltype) $1; ,
7268             'type' : p.SWIGTYPE,
7269         }
7270 ,
7271         'tmap:javabody' : Hash {
7272             'typemap' : typemap(javabody) SWIGTYPE *,
7273             'code' :
7274   private long swigCPtr;
7275
7276   protected $javaclassname(long cPtr, boolean futureUse) {
7277     swigCPtr = cPtr;
7278   }
7279
7280   protected $javaclassname() {
7281     swigCPtr = 0;
7282   }
7283
7284   protected static long getCPtr($javaclassname obj) {
7285     return (obj == null) ? 0 : obj.swigCPtr;
7286   }
7287 ,
7288             'type' : p.SWIGTYPE,
7289         }
7290 ,
7291         'tmap:javadirectorout' : Hash {
7292             'typemap' : typemap(javadirectorout) SWIGTYPE *,
7293             'code' : $javaclassname.getCPtr($javacall),
7294             'type' : p.SWIGTYPE,
7295         }
7296 ,
7297         'tmap:directorout' : Hash {
7298             'kwargs' : Hash {
7299                 'name' : warning,
7300                 'value' : 473:Returning a pointer or reference in a director method is not recommended.,
7301             }
7302 ,
7303             'typemap' : typemap(directorout) SWIGTYPE *,
7304             'code' :  $result = *($&1_ltype)&$input; ,
7305             'type' : p.SWIGTYPE,
7306         }
7307 ,
7308         'tmap:out' : Hash {
7309             'typemap' : typemap(out) SWIGTYPE *,
7310             'code' :  *($&1_ltype)&$result = $1; ,
7311             'type' : p.SWIGTYPE,
7312         }
7313 ,
7314         'tmap:jni' : Hash {
7315             'typemap' : typemap(jni) SWIGTYPE *,
7316             'code' : jlong,
7317             'type' : p.SWIGTYPE,
7318         }
7319 ,
7320         'tmap:javaout' : Hash {
7321             'typemap' : typemap(javaout) SWIGTYPE *,
7322             'code' : {
7323     long cPtr = $jnicall;
7324     return (cPtr == 0) ? null : new $javaclassname(cPtr, $owner);
7325   },
7326             'type' : p.SWIGTYPE,
7327         }
7328 ,
7329         'tmap:javaclassmodifiers' : Hash {
7330             'typemap' : typemap(javaclassmodifiers) SWIGTYPE *,
7331             'code' : public class,
7332             'type' : p.SWIGTYPE,
7333         }
7334 ,
7335         'tmap:javacode' : Hash {
7336             'typemap' : typemap(javacode) SWIGTYPE *,
7337             'code' : ,
7338             'type' : p.SWIGTYPE,
7339         }
7340 ,
7341         'tmap:javain' : Hash {
7342             'typemap' : typemap(javain) SWIGTYPE *,
7343             'code' : $javaclassname.getCPtr($javainput),
7344             'type' : p.SWIGTYPE,
7345         }
7346 ,
7347         'tmap:in' : Hash {
7348             'kwargs' : Hash {
7349                 'name' : numinputs,
7350                 'value' : 1,
7351             }
7352 ,
7353             'typemap' : typemap(in) SWIGTYPE *,
7354             'code' :  $1 = *($&1_ltype)&$input; ,
7355             'type' : p.SWIGTYPE,
7356         }
7357 ,
7358         'tmap:javaimports' : Hash {
7359             'typemap' : typemap(javaimports) SWIGTYPE *,
7360             'code' : ,
7361             'type' : p.SWIGTYPE,
7362         }
7363 ,
7364         'tmap:javainterfaces' : Hash {
7365             'typemap' : typemap(javainterfaces) SWIGTYPE *,
7366             'code' : ,
7367             'type' : p.SWIGTYPE,
7368         }
7369 ,
7370         'tmap:jstype' : Hash {
7371             'typemap' : typemap(jstype) SWIGTYPE *,
7372             'code' : $javaclassname,
7373             'type' : p.SWIGTYPE,
7374         }
7375 ,
7376         'VARARGS_SENTINEL' : Hash {
7377             'tmap:in' : Hash {
7378                 'kwargs' : Hash {
7379                     'name' : numinputs,
7380                     'value' : 0,
7381                 }
7382 ,
7383                 'pname' : VARARGS_SENTINEL,
7384                 'typemap' : typemap(in) SWIGTYPE *VARARGS_SENTINEL,
7385                 'code' : ,
7386                 'type' : p.SWIGTYPE,
7387             }
7388 ,
7389         }
7390 ,
7391     }
7392 ,
7393     'a(ANY).a(ANY).SWIGTYPE' : Hash {
7394         'tmap:memberin' : Hash {
7395             'typemap' : typemap(memberin) SWIGTYPE [ANY][ANY],
7396             'code' : {
7397   $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
7398   $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
7399   size_t ii = 0;
7400   for (; ii < $dim0; ++ii) {
7401     $basetype *ip = inp[ii];
7402     $basetype *dp = dest[ii];
7403     size_t jj = 0;
7404     for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
7405   }
7406 },
7407             'type' : a(ANY).a(ANY).SWIGTYPE,
7408         }
7409 ,
7410         'tmap:globalin' : Hash {
7411             'typemap' : typemap(globalin) SWIGTYPE [ANY][ANY],
7412             'code' : {
7413   $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
7414   $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
7415   size_t ii = 0;
7416   for (; ii < $dim0; ++ii) {
7417     $basetype *ip = inp[ii];
7418     $basetype *dp = dest[ii];
7419     size_t jj = 0;
7420     for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
7421   }
7422 },
7423             'type' : a(ANY).a(ANY).SWIGTYPE,
7424         }
7425 ,
7426     }
7427 ,
7428     'a(ANY).SWIGTYPE' : Hash {
7429         'tmap:freearg' : Hash {
7430             'typemap' : typemap(freearg) SWIGTYPE [ANY],
7431             'code' : ,
7432             'type' : a(ANY).SWIGTYPE,
7433         }
7434 ,
7435         'tmap:memberin' : Hash {
7436             'typemap' : typemap(memberin) SWIGTYPE [ANY],
7437             'code' : {
7438   size_t ii;
7439   $1_basetype *b = ($1_basetype *) $1;
7440   for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
7441 },
7442             'type' : a(ANY).SWIGTYPE,
7443         }
7444 ,
7445         'tmap:throws' : Hash {
7446             'typemap' : typemap(throws) SWIGTYPE [ANY],
7447             'code' :  (void)$1;
7448    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown");
7449    return $null; ,
7450             'type' : a(ANY).SWIGTYPE,
7451         }
7452 ,
7453         'tmap:globalin' : Hash {
7454             'typemap' : typemap(globalin) SWIGTYPE [ANY],
7455             'code' : {
7456   size_t ii;
7457   $1_basetype *b = ($1_basetype *) $1;
7458   for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
7459 },
7460             'type' : a(ANY).SWIGTYPE,
7461         }
7462 ,
7463     }
7464 ,
7465     'SWIGBIGINTEGERARRAY' : Hash {
7466         'tmap:typecheck' : Hash {
7467             'kwargs' : Hash {
7468                 'name' : precedence,
7469                 'value' : 1065,
7470             }
7471 ,
7472             'typemap' : typemap(typecheck) SWIGBIGINTEGERARRAY,
7473             'code' : ,
7474             'type' : SWIGBIGINTEGERARRAY,
7475         }
7476 ,
7477     }
7478 ,
7479     'jbooleanArray' : Hash {
7480         'tmap:jstype' : Hash {
7481             'typemap' : typemap(jstype) jbooleanArray,
7482             'code' : boolean[],
7483             'type' : jbooleanArray,
7484         }
7485 ,
7486         'tmap:directorin' : Hash {
7487             'kwargs' : Hash {
7488                 'name' : descriptor,
7489                 'value' : [Z,
7490             }
7491 ,
7492             'typemap' : typemap(directorin) jbooleanArray,
7493             'code' : $input = $1;,
7494             'type' : jbooleanArray,
7495         }
7496 ,
7497         'tmap:javadirectorin' : Hash {
7498             'typemap' : typemap(javadirectorin) jbooleanArray,
7499             'code' : $jniinput,
7500             'type' : jbooleanArray,
7501         }
7502 ,
7503         'tmap:in' : Hash {
7504             'kwargs' : Hash {
7505                 'name' : numinputs,
7506                 'value' : 1,
7507             }
7508 ,
7509             'typemap' : typemap(in) jbooleanArray,
7510             'code' :  $1 = $input; ,
7511             'type' : jbooleanArray,
7512         }
7513 ,
7514         'tmap:directorout' : Hash {
7515             'typemap' : typemap(directorout) jbooleanArray,
7516             'code' :  $result = $input; ,
7517             'type' : jbooleanArray,
7518         }
7519 ,
7520         'tmap:javadirectorout' : Hash {
7521             'typemap' : typemap(javadirectorout) jbooleanArray,
7522             'code' : $javacall,
7523             'type' : jbooleanArray,
7524         }
7525 ,
7526         'tmap:jni' : Hash {
7527             'typemap' : typemap(jni) jbooleanArray,
7528             'code' : jbooleanArray,
7529             'type' : jbooleanArray,
7530         }
7531 ,
7532         'tmap:jtype' : Hash {
7533             'typemap' : typemap(jtype) jbooleanArray,
7534             'code' : boolean[],
7535             'type' : jbooleanArray,
7536         }
7537 ,
7538         'tmap:out' : Hash {
7539             'typemap' : typemap(out) jbooleanArray,
7540             'code' :  $result = $1; ,
7541             'type' : jbooleanArray,
7542         }
7543 ,
7544         'tmap:typecheck' : Hash {
7545             'kwargs' : Hash {
7546                 'name' : precedence,
7547                 'value' : 1015,
7548             }
7549 ,
7550             'typemap' : typemap(typecheck) jbooleanArray,
7551             'code' : ,
7552             'type' : jbooleanArray,
7553         }
7554 ,
7555         'tmap:javain' : Hash {
7556             'typemap' : typemap(javain) jbooleanArray,
7557             'code' : $javainput,
7558             'type' : jbooleanArray,
7559         }
7560 ,
7561         'tmap:javaout' : Hash {
7562             'typemap' : typemap(javaout) jbooleanArray,
7563             'code' : {
7564     return $jnicall;
7565   },
7566             'type' : jbooleanArray,
7567         }
7568 ,
7569     }
7570 ,
7571     'long' : Hash {
7572         'tmap:jstype' : Hash {
7573             'typemap' : typemap(jstype) long,
7574             'code' : int,
7575             'type' : long,
7576         }
7577 ,
7578         'tmap:directorin' : Hash {
7579             'kwargs' : Hash {
7580                 'name' : descriptor,
7581                 'value' : I,
7582             }
7583 ,
7584             'typemap' : typemap(directorin) long,
7585             'code' : $input = (jint) $1;,
7586             'type' : long,
7587         }
7588 ,
7589         'tmap:javadirectorin' : Hash {
7590             'typemap' : typemap(javadirectorin) long,
7591             'code' : $jniinput,
7592             'type' : long,
7593         }
7594 ,
7595         'tmap:in' : Hash {
7596             'kwargs' : Hash {
7597                 'name' : numinputs,
7598                 'value' : 1,
7599             }
7600 ,
7601             'typemap' : typemap(in) long,
7602             'code' :  $1 = ($1_ltype)$input; ,
7603             'type' : long,
7604         }
7605 ,
7606         'tmap:directorout' : Hash {
7607             'typemap' : typemap(directorout) long,
7608             'code' :  $result = ($1_ltype)$input; ,
7609             'type' : long,
7610         }
7611 ,
7612         'tmap:javadirectorout' : Hash {
7613             'typemap' : typemap(javadirectorout) long,
7614             'code' : $javacall,
7615             'type' : long,
7616         }
7617 ,
7618         'tmap:jni' : Hash {
7619             'typemap' : typemap(jni) long,
7620             'code' : jint,
7621             'type' : long,
7622         }
7623 ,
7624         'tmap:jtype' : Hash {
7625             'typemap' : typemap(jtype) long,
7626             'code' : int,
7627             'type' : long,
7628         }
7629 ,
7630         'tmap:out' : Hash {
7631             'typemap' : typemap(out) long,
7632             'code' :  $result = (jint)$1; ,
7633             'type' : long,
7634         }
7635 ,
7636         'tmap:typecheck' : Hash {
7637             'kwargs' : Hash {
7638                 'name' : precedence,
7639                 'value' : 45,
7640             }
7641 ,
7642             'typemap' : typemap(typecheck) long,
7643             'code' : ,
7644             'type' : long,
7645         }
7646 ,
7647         'tmap:throws' : Hash {
7648             'typemap' : typemap(throws) long,
7649             'code' :  char error_msg[256];
7650    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
7651    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
7652    return $null; ,
7653             'type' : long,
7654         }
7655 ,
7656         'tmap:javain' : Hash {
7657             'typemap' : typemap(javain) long,
7658             'code' : $javainput,
7659             'type' : long,
7660         }
7661 ,
7662         'tmap:javaout' : Hash {
7663             'typemap' : typemap(javaout) long,
7664             'code' : {
7665     return $jnicall;
7666   },
7667             'type' : long,
7668         }
7669 ,
7670     }
7671 ,
7672     'jobject' : Hash {
7673         'tmap:jstype' : Hash {
7674             'typemap' : typemap(jstype) jobject,
7675             'code' : Object,
7676             'type' : jobject,
7677         }
7678 ,
7679         'tmap:directorin' : Hash {
7680             'kwargs' : Hash {
7681                 'name' : descriptor,
7682                 'value' : Ljava/lang/Object;,
7683                 'nextSibling' : Hash {
7684                     'name' : nouse,
7685                     'value' : 1,
7686                 }
7687 ,
7688             }
7689 ,
7690             'typemap' : typemap(directorin) jobject,
7691             'code' : $input = $1;,
7692             'type' : jobject,
7693         }
7694 ,
7695         'tmap:javadirectorin' : Hash {
7696             'typemap' : typemap(javadirectorin) jobject,
7697             'code' : $jniinput,
7698             'type' : jobject,
7699         }
7700 ,
7701         'tmap:in' : Hash {
7702             'kwargs' : Hash {
7703                 'name' : numinputs,
7704                 'value' : 1,
7705             }
7706 ,
7707             'typemap' : typemap(in) jobject,
7708             'code' :  $1 = $input; ,
7709             'type' : jobject,
7710         }
7711 ,
7712         'tmap:directorout' : Hash {
7713             'typemap' : typemap(directorout) jobject,
7714             'code' :  $result = $input; ,
7715             'type' : jobject,
7716         }
7717 ,
7718         'tmap:javadirectorout' : Hash {
7719             'typemap' : typemap(javadirectorout) jobject,
7720             'code' : $javacall,
7721             'type' : jobject,
7722         }
7723 ,
7724         'tmap:jni' : Hash {
7725             'typemap' : typemap(jni) jobject,
7726             'code' : jobject,
7727             'type' : jobject,
7728         }
7729 ,
7730         'tmap:jtype' : Hash {
7731             'typemap' : typemap(jtype) jobject,
7732             'code' : Object,
7733             'type' : jobject,
7734         }
7735 ,
7736         'tmap:out' : Hash {
7737             'typemap' : typemap(out) jobject,
7738             'code' :  $result = $1; ,
7739             'type' : jobject,
7740         }
7741 ,
7742         'tmap:javain' : Hash {
7743             'typemap' : typemap(javain) jobject,
7744             'code' : $javainput,
7745             'type' : jobject,
7746         }
7747 ,
7748         'tmap:javaout' : Hash {
7749             'typemap' : typemap(javaout) jobject,
7750             'code' : {
7751     return $jnicall;
7752   },
7753             'type' : jobject,
7754         }
7755 ,
7756     }
7757 ,
7758     'unsigned int' : Hash {
7759         'tmap:jstype' : Hash {
7760             'typemap' : typemap(jstype) unsigned int,
7761             'code' : long,
7762             'type' : unsigned int,
7763         }
7764 ,
7765         'tmap:directorin' : Hash {
7766             'kwargs' : Hash {
7767                 'name' : descriptor,
7768                 'value' : J,
7769             }
7770 ,
7771             'typemap' : typemap(directorin) unsigned int,
7772             'code' : $input = (jlong) $1;,
7773             'type' : unsigned int,
7774         }
7775 ,
7776         'tmap:javadirectorin' : Hash {
7777             'typemap' : typemap(javadirectorin) unsigned int,
7778             'code' : $jniinput,
7779             'type' : unsigned int,
7780         }
7781 ,
7782         'tmap:in' : Hash {
7783             'kwargs' : Hash {
7784                 'name' : numinputs,
7785                 'value' : 1,
7786             }
7787 ,
7788             'typemap' : typemap(in) unsigned int,
7789             'code' :  $1 = ($1_ltype)$input; ,
7790             'type' : unsigned int,
7791         }
7792 ,
7793         'tmap:directorout' : Hash {
7794             'typemap' : typemap(directorout) unsigned int,
7795             'code' :  $result = ($1_ltype)$input; ,
7796             'type' : unsigned int,
7797         }
7798 ,
7799         'tmap:javadirectorout' : Hash {
7800             'typemap' : typemap(javadirectorout) unsigned int,
7801             'code' : $javacall,
7802             'type' : unsigned int,
7803         }
7804 ,
7805         'tmap:jni' : Hash {
7806             'typemap' : typemap(jni) unsigned int,
7807             'code' : jlong,
7808             'type' : unsigned int,
7809         }
7810 ,
7811         'tmap:jtype' : Hash {
7812             'typemap' : typemap(jtype) unsigned int,
7813             'code' : long,
7814             'type' : unsigned int,
7815         }
7816 ,
7817         'tmap:out' : Hash {
7818             'typemap' : typemap(out) unsigned int,
7819             'code' :  $result = (jlong)$1; ,
7820             'type' : unsigned int,
7821         }
7822 ,
7823         'tmap:typecheck' : Hash {
7824             'kwargs' : Hash {
7825                 'name' : precedence,
7826                 'value' : 55,
7827             }
7828 ,
7829             'typemap' : typemap(typecheck) unsigned int,
7830             'code' : ,
7831             'type' : unsigned int,
7832         }
7833 ,
7834         'tmap:throws' : Hash {
7835             'typemap' : typemap(throws) unsigned int,
7836             'code' :  char error_msg[256];
7837    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
7838    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
7839    return $null; ,
7840             'type' : unsigned int,
7841         }
7842 ,
7843         'tmap:javain' : Hash {
7844             'typemap' : typemap(javain) unsigned int,
7845             'code' : $javainput,
7846             'type' : unsigned int,
7847         }
7848 ,
7849         'tmap:javaout' : Hash {
7850             'typemap' : typemap(javaout) unsigned int,
7851             'code' : {
7852     return $jnicall;
7853   },
7854             'type' : unsigned int,
7855         }
7856 ,
7857     }
7858 ,
7859     'r.q(const).unsigned int' : Hash {
7860         'tmap:jstype' : Hash {
7861             'typemap' : typemap(jstype) unsigned int const &,
7862             'code' : long,
7863             'type' : r.q(const).unsigned int,
7864         }
7865 ,
7866         'tmap:directorin' : Hash {
7867             'kwargs' : Hash {
7868                 'name' : descriptor,
7869                 'value' : J,
7870             }
7871 ,
7872             'typemap' : typemap(directorin) unsigned int const &,
7873             'code' : $input = (jlong)$1_name;,
7874             'type' : r.q(const).unsigned int,
7875         }
7876 ,
7877         'tmap:javadirectorin' : Hash {
7878             'locals' : Hash {
7879                 'name' : temp,
7880                 'type' : $*1_ltype,
7881             }
7882 ,
7883             'typemap' : typemap(javadirectorin) unsigned int const &,
7884             'code' : $jniinput,
7885             'type' : r.q(const).unsigned int,
7886         }
7887 ,
7888         'tmap:in' : Hash {
7889             'locals' : Hash {
7890                 'name' : temp,
7891                 'type' : $*1_ltype,
7892             }
7893 ,
7894             'kwargs' : Hash {
7895                 'name' : numinputs,
7896                 'value' : 1,
7897             }
7898 ,
7899             'typemap' : typemap(in) unsigned int const &,
7900             'code' :  temp = ($*1_ltype)$input;
7901    $1 = &temp; ,
7902             'type' : r.q(const).unsigned int,
7903         }
7904 ,
7905         'tmap:directorout' : Hash {
7906             'kwargs' : Hash {
7907                 'name' : warning,
7908                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
7909             }
7910 ,
7911             'typemap' : typemap(directorout) unsigned int const &,
7912             'code' :  static $*1_ltype temp;
7913    temp = ($*1_ltype)$input;
7914    $result = &temp; ,
7915             'type' : r.q(const).unsigned int,
7916         }
7917 ,
7918         'tmap:javadirectorout' : Hash {
7919             'locals' : Hash {
7920                 'name' : temp,
7921                 'type' : $*1_ltype,
7922             }
7923 ,
7924             'typemap' : typemap(javadirectorout) unsigned int const &,
7925             'code' : $javacall,
7926             'type' : r.q(const).unsigned int,
7927         }
7928 ,
7929         'tmap:jni' : Hash {
7930             'typemap' : typemap(jni) unsigned int const &,
7931             'code' : jlong,
7932             'type' : r.q(const).unsigned int,
7933         }
7934 ,
7935         'tmap:jtype' : Hash {
7936             'typemap' : typemap(jtype) unsigned int const &,
7937             'code' : long,
7938             'type' : r.q(const).unsigned int,
7939         }
7940 ,
7941         'tmap:out' : Hash {
7942             'typemap' : typemap(out) unsigned int const &,
7943             'code' :  $result = (jlong)*$1; ,
7944             'type' : r.q(const).unsigned int,
7945         }
7946 ,
7947         'tmap:typecheck' : Hash {
7948             'kwargs' : Hash {
7949                 'name' : precedence,
7950                 'value' : 55,
7951             }
7952 ,
7953             'typemap' : typemap(typecheck) unsigned int const &,
7954             'code' : ,
7955             'type' : r.q(const).unsigned int,
7956         }
7957 ,
7958         'tmap:javain' : Hash {
7959             'typemap' : typemap(javain) unsigned int const &,
7960             'code' : $javainput,
7961             'type' : r.q(const).unsigned int,
7962         }
7963 ,
7964         'tmap:javaout' : Hash {
7965             'typemap' : typemap(javaout) unsigned int const &,
7966             'code' : {
7967     return $jnicall;
7968   },
7969             'type' : r.q(const).unsigned int,
7970         }
7971 ,
7972     }
7973 ,
7974     'p.unsigned int' : Hash {
7975         'INOUT' : Hash {
7976             'tmap:freearg' : Hash {
7977                 'pname' : INOUT,
7978                 'typemap' : typemap(freearg) unsigned int *INOUT,
7979                 'code' : ,
7980                 'type' : p.unsigned int,
7981             }
7982 ,
7983             'tmap:jstype' : Hash {
7984                 'pname' : INOUT,
7985                 'typemap' : typemap(jstype) unsigned int *INOUT,
7986                 'code' : long[],
7987                 'type' : p.unsigned int,
7988             }
7989 ,
7990             'tmap:javadirectorin' : Hash {
7991                 'pname' : INOUT,
7992                 'typemap' : typemap(javadirectorin) unsigned int *INOUT,
7993                 'code' : $jniinput,
7994                 'type' : p.unsigned int,
7995             }
7996 ,
7997             'tmap:directorin' : Hash {
7998                 'kwargs' : Hash {
7999                     'name' : descriptor,
8000                     'value' : [Ljava/lang/Long;,
8001                     'nextSibling' : Hash {
8002                         'name' : warning,
8003                         'value' : Need to provide unsigned int *INOUT directorin typemap, unsigned int array length is unknown,
8004                     }
8005 ,
8006                 }
8007 ,
8008                 'pname' : INOUT,
8009                 'typemap' : typemap(directorin) unsigned int *INOUT,
8010                 'code' : {
8011 },
8012                 'type' : p.unsigned int,
8013             }
8014 ,
8015             'tmap:argout' : Hash {
8016                 'pname' : INOUT,
8017                 'typemap' : typemap(argout) unsigned int *INOUT,
8018                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
8019                 'type' : p.unsigned int,
8020             }
8021 ,
8022             'tmap:javadirectorout' : Hash {
8023                 'pname' : INOUT,
8024                 'typemap' : typemap(javadirectorout) unsigned int *INOUT,
8025                 'code' : $javacall,
8026                 'type' : p.unsigned int,
8027             }
8028 ,
8029             'tmap:in' : Hash {
8030                 'kwargs' : Hash {
8031                     'name' : numinputs,
8032                     'value' : 1,
8033                 }
8034 ,
8035                 'pname' : INOUT,
8036                 'typemap' : typemap(in) unsigned int *INOUT,
8037                 'code' : {
8038   if (!$input) {
8039     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8040     return $null;
8041   }
8042   if (jenv->GetArrayLength($input) == 0) {
8043     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8044     return $null;
8045   }
8046   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
8047 },
8048                 'type' : p.unsigned int,
8049             }
8050 ,
8051             'tmap:directorout' : Hash {
8052                 'kwargs' : Hash {
8053                     'name' : warning,
8054                     'value' : Need to provide unsigned int *INOUT directorout typemap,
8055                 }
8056 ,
8057                 'pname' : INOUT,
8058                 'typemap' : typemap(directorout) unsigned int *INOUT,
8059                 'code' : {
8060 },
8061                 'type' : p.unsigned int,
8062             }
8063 ,
8064             'tmap:typecheck' : Hash {
8065                 'kwargs' : Hash {
8066                     'name' : precedence,
8067                     'value' : 1055,
8068                 }
8069 ,
8070                 'pname' : INOUT,
8071                 'typemap' : typemap(typecheck) unsigned int *INOUT,
8072                 'code' : ,
8073                 'type' : p.unsigned int,
8074             }
8075 ,
8076             'tmap:jni' : Hash {
8077                 'pname' : INOUT,
8078                 'typemap' : typemap(jni) unsigned int *INOUT,
8079                 'code' : jlongArray,
8080                 'type' : p.unsigned int,
8081             }
8082 ,
8083             'tmap:jtype' : Hash {
8084                 'pname' : INOUT,
8085                 'typemap' : typemap(jtype) unsigned int *INOUT,
8086                 'code' : long[],
8087                 'type' : p.unsigned int,
8088             }
8089 ,
8090             'tmap:javain' : Hash {
8091                 'pname' : INOUT,
8092                 'typemap' : typemap(javain) unsigned int *INOUT,
8093                 'code' : $javainput,
8094                 'type' : p.unsigned int,
8095             }
8096 ,
8097         }
8098 ,
8099         'INPUT' : Hash {
8100             'tmap:freearg' : Hash {
8101                 'pname' : INPUT,
8102                 'typemap' : typemap(freearg) unsigned int *INPUT,
8103                 'code' : ,
8104                 'type' : p.unsigned int,
8105             }
8106 ,
8107             'tmap:jstype' : Hash {
8108                 'pname' : INPUT,
8109                 'typemap' : typemap(jstype) unsigned int *INPUT,
8110                 'code' : long,
8111                 'type' : p.unsigned int,
8112             }
8113 ,
8114             'tmap:javadirectorin' : Hash {
8115                 'pname' : INPUT,
8116                 'typemap' : typemap(javadirectorin) unsigned int *INPUT,
8117                 'code' : $jniinput,
8118                 'type' : p.unsigned int,
8119             }
8120 ,
8121             'tmap:directorin' : Hash {
8122                 'kwargs' : Hash {
8123                     'name' : descriptor,
8124                     'value' : J,
8125                 }
8126 ,
8127                 'pname' : INPUT,
8128                 'typemap' : typemap(directorin) unsigned int *INPUT,
8129                 'code' :  *(($&1_ltype) $input) = (jlong *) $1; ,
8130                 'type' : p.unsigned int,
8131             }
8132 ,
8133             'tmap:javadirectorout' : Hash {
8134                 'pname' : INPUT,
8135                 'typemap' : typemap(javadirectorout) unsigned int *INPUT,
8136                 'code' : $javacall,
8137                 'type' : p.unsigned int,
8138             }
8139 ,
8140             'tmap:in' : Hash {
8141                 'kwargs' : Hash {
8142                     'name' : numinputs,
8143                     'value' : 1,
8144                 }
8145 ,
8146                 'pname' : INPUT,
8147                 'typemap' : typemap(in) unsigned int *INPUT,
8148                 'code' :  $1 = ($1_ltype)&$input; ,
8149                 'type' : p.unsigned int,
8150             }
8151 ,
8152             'tmap:directorout' : Hash {
8153                 'pname' : INPUT,
8154                 'typemap' : typemap(directorout) unsigned int *INPUT,
8155                 'code' :  $result = ($1_ltype)&$input; ,
8156                 'type' : p.unsigned int,
8157             }
8158 ,
8159             'tmap:jni' : Hash {
8160                 'pname' : INPUT,
8161                 'typemap' : typemap(jni) unsigned int *INPUT,
8162                 'code' : jlong,
8163                 'type' : p.unsigned int,
8164             }
8165 ,
8166             'tmap:jtype' : Hash {
8167                 'pname' : INPUT,
8168                 'typemap' : typemap(jtype) unsigned int *INPUT,
8169                 'code' : long,
8170                 'type' : p.unsigned int,
8171             }
8172 ,
8173             'tmap:javain' : Hash {
8174                 'pname' : INPUT,
8175                 'typemap' : typemap(javain) unsigned int *INPUT,
8176                 'code' : $javainput,
8177                 'type' : p.unsigned int,
8178             }
8179 ,
8180             'tmap:typecheck' : Hash {
8181                 'kwargs' : Hash {
8182                     'name' : precedence,
8183                     'value' : 55,
8184                 }
8185 ,
8186                 'pname' : INPUT,
8187                 'typemap' : typemap(typecheck) unsigned int *INPUT,
8188                 'code' : ,
8189                 'type' : p.unsigned int,
8190             }
8191 ,
8192         }
8193 ,
8194         'OUTPUT' : Hash {
8195             'tmap:freearg' : Hash {
8196                 'pname' : OUTPUT,
8197                 'typemap' : typemap(freearg) unsigned int *OUTPUT,
8198                 'code' : ,
8199                 'type' : p.unsigned int,
8200             }
8201 ,
8202             'tmap:jstype' : Hash {
8203                 'pname' : OUTPUT,
8204                 'typemap' : typemap(jstype) unsigned int *OUTPUT,
8205                 'code' : long[],
8206                 'type' : p.unsigned int,
8207             }
8208 ,
8209             'tmap:javadirectorin' : Hash {
8210                 'pname' : OUTPUT,
8211                 'typemap' : typemap(javadirectorin) unsigned int *OUTPUT,
8212                 'code' : $jniinput,
8213                 'type' : p.unsigned int,
8214             }
8215 ,
8216             'tmap:directorin' : Hash {
8217                 'kwargs' : Hash {
8218                     'name' : descriptor,
8219                     'value' : [Ljava/lang/Long;,
8220                     'nextSibling' : Hash {
8221                         'name' : warning,
8222                         'value' : Need to provide unsigned int *OUTPUT directorin typemap, unsigned int array length is unknown,
8223                     }
8224 ,
8225                 }
8226 ,
8227                 'pname' : OUTPUT,
8228                 'typemap' : typemap(directorin) unsigned int *OUTPUT,
8229                 'code' : {
8230 },
8231                 'type' : p.unsigned int,
8232             }
8233 ,
8234             'tmap:argout' : Hash {
8235                 'pname' : OUTPUT,
8236                 'typemap' : typemap(argout) unsigned int *OUTPUT,
8237                 'code' : {
8238   jlong jvalue = (jlong)temp$argnum;
8239   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
8240 },
8241                 'type' : p.unsigned int,
8242             }
8243 ,
8244             'tmap:javadirectorout' : Hash {
8245                 'pname' : OUTPUT,
8246                 'typemap' : typemap(javadirectorout) unsigned int *OUTPUT,
8247                 'code' : $javacall,
8248                 'type' : p.unsigned int,
8249             }
8250 ,
8251             'tmap:in' : Hash {
8252                 'locals' : Hash {
8253                     'name' : temp,
8254                     'type' : $*1_ltype,
8255                 }
8256 ,
8257                 'kwargs' : Hash {
8258                     'name' : numinputs,
8259                     'value' : 1,
8260                 }
8261 ,
8262                 'pname' : OUTPUT,
8263                 'typemap' : typemap(in) unsigned int *OUTPUT,
8264                 'code' : {
8265   if (!$input) {
8266     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8267     return $null;
8268   }
8269   if (jenv->GetArrayLength($input) == 0) {
8270     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8271     return $null;
8272   }
8273   $1 = &temp;
8274 },
8275                 'type' : p.unsigned int,
8276             }
8277 ,
8278             'tmap:directorout' : Hash {
8279                 'kwargs' : Hash {
8280                     'name' : warning,
8281                     'value' : Need to provide unsigned int *OUTPUT directorout typemap,
8282                 }
8283 ,
8284                 'pname' : OUTPUT,
8285                 'typemap' : typemap(directorout) unsigned int *OUTPUT,
8286                 'code' : {
8287 },
8288                 'type' : p.unsigned int,
8289             }
8290 ,
8291             'tmap:jni' : Hash {
8292                 'pname' : OUTPUT,
8293                 'typemap' : typemap(jni) unsigned int *OUTPUT,
8294                 'code' : jlongArray,
8295                 'type' : p.unsigned int,
8296             }
8297 ,
8298             'tmap:jtype' : Hash {
8299                 'pname' : OUTPUT,
8300                 'typemap' : typemap(jtype) unsigned int *OUTPUT,
8301                 'code' : long[],
8302                 'type' : p.unsigned int,
8303             }
8304 ,
8305             'tmap:javain' : Hash {
8306                 'pname' : OUTPUT,
8307                 'typemap' : typemap(javain) unsigned int *OUTPUT,
8308                 'code' : $javainput,
8309                 'type' : p.unsigned int,
8310             }
8311 ,
8312         }
8313 ,
8314     }
8315 ,
8316     'r.unsigned int' : Hash {
8317         'INOUT' : Hash {
8318             'tmap:freearg' : Hash {
8319                 'pname' : INOUT,
8320                 'typemap' : typemap(freearg) unsigned int &INOUT,
8321                 'code' : ,
8322                 'type' : r.unsigned int,
8323             }
8324 ,
8325             'tmap:jstype' : Hash {
8326                 'pname' : INOUT,
8327                 'typemap' : typemap(jstype) unsigned int &INOUT,
8328                 'code' : long[],
8329                 'type' : r.unsigned int,
8330             }
8331 ,
8332             'tmap:javadirectorin' : Hash {
8333                 'pname' : INOUT,
8334                 'typemap' : typemap(javadirectorin) unsigned int &INOUT,
8335                 'code' : $jniinput,
8336                 'type' : r.unsigned int,
8337             }
8338 ,
8339             'tmap:directorin' : Hash {
8340                 'kwargs' : Hash {
8341                     'name' : descriptor,
8342                     'value' : [Ljava/lang/Long;,
8343                     'nextSibling' : Hash {
8344                         'name' : warning,
8345                         'value' : Need to provide unsigned int *INOUT directorin typemap, unsigned int array length is unknown,
8346                     }
8347 ,
8348                 }
8349 ,
8350                 'pname' : INOUT,
8351                 'typemap' : typemap(directorin) unsigned int &INOUT,
8352                 'code' : {
8353 },
8354                 'type' : r.unsigned int,
8355             }
8356 ,
8357             'tmap:argout' : Hash {
8358                 'pname' : INOUT,
8359                 'typemap' : typemap(argout) unsigned int &INOUT,
8360                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
8361                 'type' : r.unsigned int,
8362             }
8363 ,
8364             'tmap:javadirectorout' : Hash {
8365                 'pname' : INOUT,
8366                 'typemap' : typemap(javadirectorout) unsigned int &INOUT,
8367                 'code' : $javacall,
8368                 'type' : r.unsigned int,
8369             }
8370 ,
8371             'tmap:in' : Hash {
8372                 'kwargs' : Hash {
8373                     'name' : numinputs,
8374                     'value' : 1,
8375                 }
8376 ,
8377                 'pname' : INOUT,
8378                 'typemap' : typemap(in) unsigned int &INOUT,
8379                 'code' : {
8380   if (!$input) {
8381     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8382     return $null;
8383   }
8384   if (jenv->GetArrayLength($input) == 0) {
8385     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8386     return $null;
8387   }
8388   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
8389 },
8390                 'type' : r.unsigned int,
8391             }
8392 ,
8393             'tmap:directorout' : Hash {
8394                 'kwargs' : Hash {
8395                     'name' : warning,
8396                     'value' : Need to provide unsigned int *INOUT directorout typemap,
8397                 }
8398 ,
8399                 'pname' : INOUT,
8400                 'typemap' : typemap(directorout) unsigned int &INOUT,
8401                 'code' : {
8402 },
8403                 'type' : r.unsigned int,
8404             }
8405 ,
8406             'tmap:typecheck' : Hash {
8407                 'kwargs' : Hash {
8408                     'name' : precedence,
8409                     'value' : 1055,
8410                 }
8411 ,
8412                 'pname' : INOUT,
8413                 'typemap' : typemap(typecheck) unsigned int &INOUT,
8414                 'code' : ,
8415                 'type' : r.unsigned int,
8416             }
8417 ,
8418             'tmap:jni' : Hash {
8419                 'pname' : INOUT,
8420                 'typemap' : typemap(jni) unsigned int &INOUT,
8421                 'code' : jlongArray,
8422                 'type' : r.unsigned int,
8423             }
8424 ,
8425             'tmap:jtype' : Hash {
8426                 'pname' : INOUT,
8427                 'typemap' : typemap(jtype) unsigned int &INOUT,
8428                 'code' : long[],
8429                 'type' : r.unsigned int,
8430             }
8431 ,
8432             'tmap:javain' : Hash {
8433                 'pname' : INOUT,
8434                 'typemap' : typemap(javain) unsigned int &INOUT,
8435                 'code' : $javainput,
8436                 'type' : r.unsigned int,
8437             }
8438 ,
8439         }
8440 ,
8441         'INPUT' : Hash {
8442             'tmap:freearg' : Hash {
8443                 'pname' : INPUT,
8444                 'typemap' : typemap(freearg) unsigned int &INPUT,
8445                 'code' : ,
8446                 'type' : r.unsigned int,
8447             }
8448 ,
8449             'tmap:jstype' : Hash {
8450                 'pname' : INPUT,
8451                 'typemap' : typemap(jstype) unsigned int &INPUT,
8452                 'code' : long,
8453                 'type' : r.unsigned int,
8454             }
8455 ,
8456             'tmap:javadirectorin' : Hash {
8457                 'pname' : INPUT,
8458                 'typemap' : typemap(javadirectorin) unsigned int &INPUT,
8459                 'code' : $jniinput,
8460                 'type' : r.unsigned int,
8461             }
8462 ,
8463             'tmap:directorin' : Hash {
8464                 'kwargs' : Hash {
8465                     'name' : descriptor,
8466                     'value' : J,
8467                 }
8468 ,
8469                 'pname' : INPUT,
8470                 'typemap' : typemap(directorin) unsigned int &INPUT,
8471                 'code' :  *(($&1_ltype) $input) = (jlong *) &$1; ,
8472                 'type' : r.unsigned int,
8473             }
8474 ,
8475             'tmap:javadirectorout' : Hash {
8476                 'pname' : INPUT,
8477                 'typemap' : typemap(javadirectorout) unsigned int &INPUT,
8478                 'code' : $javacall,
8479                 'type' : r.unsigned int,
8480             }
8481 ,
8482             'tmap:in' : Hash {
8483                 'kwargs' : Hash {
8484                     'name' : numinputs,
8485                     'value' : 1,
8486                 }
8487 ,
8488                 'pname' : INPUT,
8489                 'typemap' : typemap(in) unsigned int &INPUT,
8490                 'code' :  $1 = ($1_ltype)&$input; ,
8491                 'type' : r.unsigned int,
8492             }
8493 ,
8494             'tmap:directorout' : Hash {
8495                 'pname' : INPUT,
8496                 'typemap' : typemap(directorout) unsigned int &INPUT,
8497                 'code' :  $result = ($1_ltype)&$input; ,
8498                 'type' : r.unsigned int,
8499             }
8500 ,
8501             'tmap:jni' : Hash {
8502                 'pname' : INPUT,
8503                 'typemap' : typemap(jni) unsigned int &INPUT,
8504                 'code' : jlong,
8505                 'type' : r.unsigned int,
8506             }
8507 ,
8508             'tmap:jtype' : Hash {
8509                 'pname' : INPUT,
8510                 'typemap' : typemap(jtype) unsigned int &INPUT,
8511                 'code' : long,
8512                 'type' : r.unsigned int,
8513             }
8514 ,
8515             'tmap:javain' : Hash {
8516                 'pname' : INPUT,
8517                 'typemap' : typemap(javain) unsigned int &INPUT,
8518                 'code' : $javainput,
8519                 'type' : r.unsigned int,
8520             }
8521 ,
8522             'tmap:typecheck' : Hash {
8523                 'kwargs' : Hash {
8524                     'name' : precedence,
8525                     'value' : 55,
8526                 }
8527 ,
8528                 'pname' : INPUT,
8529                 'typemap' : typemap(typecheck) unsigned int &INPUT,
8530                 'code' : ,
8531                 'type' : r.unsigned int,
8532             }
8533 ,
8534         }
8535 ,
8536         'OUTPUT' : Hash {
8537             'tmap:freearg' : Hash {
8538                 'pname' : OUTPUT,
8539                 'typemap' : typemap(freearg) unsigned int &OUTPUT,
8540                 'code' : ,
8541                 'type' : r.unsigned int,
8542             }
8543 ,
8544             'tmap:jstype' : Hash {
8545                 'pname' : OUTPUT,
8546                 'typemap' : typemap(jstype) unsigned int &OUTPUT,
8547                 'code' : long[],
8548                 'type' : r.unsigned int,
8549             }
8550 ,
8551             'tmap:javadirectorin' : Hash {
8552                 'pname' : OUTPUT,
8553                 'typemap' : typemap(javadirectorin) unsigned int &OUTPUT,
8554                 'code' : $jniinput,
8555                 'type' : r.unsigned int,
8556             }
8557 ,
8558             'tmap:directorin' : Hash {
8559                 'kwargs' : Hash {
8560                     'name' : descriptor,
8561                     'value' : [Ljava/lang/Long;,
8562                 }
8563 ,
8564                 'pname' : OUTPUT,
8565                 'typemap' : typemap(directorin) unsigned int &OUTPUT,
8566                 'code' :  *(($&1_ltype) $input = &$1; ,
8567                 'type' : r.unsigned int,
8568             }
8569 ,
8570             'tmap:argout' : Hash {
8571                 'pname' : OUTPUT,
8572                 'typemap' : typemap(argout) unsigned int &OUTPUT,
8573                 'code' : {
8574   jlong jvalue = (jlong)temp$argnum;
8575   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
8576 },
8577                 'type' : r.unsigned int,
8578             }
8579 ,
8580             'tmap:javadirectorout' : Hash {
8581                 'pname' : OUTPUT,
8582                 'typemap' : typemap(javadirectorout) unsigned int &OUTPUT,
8583                 'code' : $javacall,
8584                 'type' : r.unsigned int,
8585             }
8586 ,
8587             'tmap:in' : Hash {
8588                 'locals' : Hash {
8589                     'name' : temp,
8590                     'type' : $*1_ltype,
8591                 }
8592 ,
8593                 'kwargs' : Hash {
8594                     'name' : numinputs,
8595                     'value' : 1,
8596                 }
8597 ,
8598                 'pname' : OUTPUT,
8599                 'typemap' : typemap(in) unsigned int &OUTPUT,
8600                 'code' : {
8601   if (!$input) {
8602     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
8603     return $null;
8604   }
8605   if (jenv->GetArrayLength($input) == 0) {
8606     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
8607     return $null;
8608   }
8609   $1 = &temp;
8610 },
8611                 'type' : r.unsigned int,
8612             }
8613 ,
8614             'tmap:directorout' : Hash {
8615                 'kwargs' : Hash {
8616                     'name' : warning,
8617                     'value' : Need to provide unsigned int *OUTPUT directorout typemap,
8618                 }
8619 ,
8620                 'pname' : OUTPUT,
8621                 'typemap' : typemap(directorout) unsigned int &OUTPUT,
8622                 'code' : {
8623 },
8624                 'type' : r.unsigned int,
8625             }
8626 ,
8627             'tmap:jni' : Hash {
8628                 'pname' : OUTPUT,
8629                 'typemap' : typemap(jni) unsigned int &OUTPUT,
8630                 'code' : jlongArray,
8631                 'type' : r.unsigned int,
8632             }
8633 ,
8634             'tmap:jtype' : Hash {
8635                 'pname' : OUTPUT,
8636                 'typemap' : typemap(jtype) unsigned int &OUTPUT,
8637                 'code' : long[],
8638                 'type' : r.unsigned int,
8639             }
8640 ,
8641             'tmap:javain' : Hash {
8642                 'pname' : OUTPUT,
8643                 'typemap' : typemap(javain) unsigned int &OUTPUT,
8644                 'code' : $javainput,
8645                 'type' : r.unsigned int,
8646             }
8647 ,
8648         }
8649 ,
8650     }
8651 ,
8652     'a(ANY).unsigned int' : Hash {
8653         'tmap:freearg' : Hash {
8654             'typemap' : typemap(freearg) unsigned int [ANY],
8655             'code' :  delete [] $1; ,
8656             'type' : a(ANY).unsigned int,
8657         }
8658 ,
8659         'tmap:jstype' : Hash {
8660             'typemap' : typemap(jstype) unsigned int [ANY],
8661             'code' : long[],
8662             'type' : a(ANY).unsigned int,
8663         }
8664 ,
8665         'tmap:argout' : Hash {
8666             'typemap' : typemap(argout) unsigned int [ANY],
8667             'code' :  SWIG_JavaArrayArgoutUint(jenv, jarr$argnum, $1, $input); ,
8668             'type' : a(ANY).unsigned int,
8669         }
8670 ,
8671         'tmap:in' : Hash {
8672             'locals' : Hash {
8673                 'name' : jarr,
8674                 'type' : p.jlong,
8675             }
8676 ,
8677             'kwargs' : Hash {
8678                 'name' : numinputs,
8679                 'value' : 1,
8680             }
8681 ,
8682             'typemap' : typemap(in) unsigned int [ANY],
8683             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
8684     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
8685     return $null;
8686   }
8687   if (!SWIG_JavaArrayInUint(jenv, &jarr, &$1, $input)) return $null; ,
8688             'type' : a(ANY).unsigned int,
8689         }
8690 ,
8691         'tmap:jni' : Hash {
8692             'typemap' : typemap(jni) unsigned int [ANY],
8693             'code' : jlongArray,
8694             'type' : a(ANY).unsigned int,
8695         }
8696 ,
8697         'tmap:jtype' : Hash {
8698             'typemap' : typemap(jtype) unsigned int [ANY],
8699             'code' : long[],
8700             'type' : a(ANY).unsigned int,
8701         }
8702 ,
8703         'tmap:out' : Hash {
8704             'typemap' : typemap(out) unsigned int [ANY],
8705             'code' : $result = SWIG_JavaArrayOutUint(jenv, $1, $1_dim0); ,
8706             'type' : a(ANY).unsigned int,
8707         }
8708 ,
8709         'tmap:javain' : Hash {
8710             'typemap' : typemap(javain) unsigned int [ANY],
8711             'code' : $javainput,
8712             'type' : a(ANY).unsigned int,
8713         }
8714 ,
8715         'tmap:typecheck' : Hash {
8716             'kwargs' : Hash {
8717                 'name' : precedence,
8718                 'value' : 1055,
8719             }
8720 ,
8721             'typemap' : typemap(typecheck) unsigned int [ANY],
8722             'code' : ,
8723             'type' : a(ANY).unsigned int,
8724         }
8725 ,
8726         'tmap:javaout' : Hash {
8727             'typemap' : typemap(javaout) unsigned int [ANY],
8728             'code' : {
8729     return $jnicall;
8730   },
8731             'type' : a(ANY).unsigned int,
8732         }
8733 ,
8734     }
8735 ,
8736     'a().unsigned int' : Hash {
8737         'tmap:freearg' : Hash {
8738             'typemap' : typemap(freearg) unsigned int [],
8739             'code' :  delete [] $1; ,
8740             'type' : a().unsigned int,
8741         }
8742 ,
8743         'tmap:jstype' : Hash {
8744             'typemap' : typemap(jstype) unsigned int [],
8745             'code' : long[],
8746             'type' : a().unsigned int,
8747         }
8748 ,
8749         'tmap:argout' : Hash {
8750             'typemap' : typemap(argout) unsigned int [],
8751             'code' :  SWIG_JavaArrayArgoutUint(jenv, jarr$argnum, $1, $input); ,
8752             'type' : a().unsigned int,
8753         }
8754 ,
8755         'tmap:in' : Hash {
8756             'locals' : Hash {
8757                 'name' : jarr,
8758                 'type' : p.jlong,
8759             }
8760 ,
8761             'kwargs' : Hash {
8762                 'name' : numinputs,
8763                 'value' : 1,
8764             }
8765 ,
8766             'typemap' : typemap(in) unsigned int [],
8767             'code' :   if (!SWIG_JavaArrayInUint(jenv, &jarr, &$1, $input)) return $null; ,
8768             'type' : a().unsigned int,
8769         }
8770 ,
8771         'tmap:jni' : Hash {
8772             'typemap' : typemap(jni) unsigned int [],
8773             'code' : jlongArray,
8774             'type' : a().unsigned int,
8775         }
8776 ,
8777         'tmap:jtype' : Hash {
8778             'typemap' : typemap(jtype) unsigned int [],
8779             'code' : long[],
8780             'type' : a().unsigned int,
8781         }
8782 ,
8783         'tmap:out' : Hash {
8784             'typemap' : typemap(out) unsigned int [],
8785             'code' : $result = SWIG_JavaArrayOutUint(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
8786             'type' : a().unsigned int,
8787         }
8788 ,
8789         'tmap:javain' : Hash {
8790             'typemap' : typemap(javain) unsigned int [],
8791             'code' : $javainput,
8792             'type' : a().unsigned int,
8793         }
8794 ,
8795         'tmap:typecheck' : Hash {
8796             'kwargs' : Hash {
8797                 'name' : precedence,
8798                 'value' : 1055,
8799             }
8800 ,
8801             'typemap' : typemap(typecheck) unsigned int [],
8802             'code' : ,
8803             'type' : a().unsigned int,
8804         }
8805 ,
8806         'tmap:javaout' : Hash {
8807             'typemap' : typemap(javaout) unsigned int [],
8808             'code' : {
8809     return $jnicall;
8810   },
8811             'type' : a().unsigned int,
8812         }
8813 ,
8814     }
8815 ,
8816     'a(ANY).long' : Hash {
8817         'tmap:freearg' : Hash {
8818             'typemap' : typemap(freearg) long [ANY],
8819             'code' :  delete [] $1; ,
8820             'type' : a(ANY).long,
8821         }
8822 ,
8823         'tmap:jstype' : Hash {
8824             'typemap' : typemap(jstype) long [ANY],
8825             'code' : int[],
8826             'type' : a(ANY).long,
8827         }
8828 ,
8829         'tmap:argout' : Hash {
8830             'typemap' : typemap(argout) long [ANY],
8831             'code' :  SWIG_JavaArrayArgoutLong(jenv, jarr$argnum, $1, $input); ,
8832             'type' : a(ANY).long,
8833         }
8834 ,
8835         'tmap:in' : Hash {
8836             'locals' : Hash {
8837                 'name' : jarr,
8838                 'type' : p.jint,
8839             }
8840 ,
8841             'kwargs' : Hash {
8842                 'name' : numinputs,
8843                 'value' : 1,
8844             }
8845 ,
8846             'typemap' : typemap(in) long [ANY],
8847             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
8848     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
8849     return $null;
8850   }
8851   if (!SWIG_JavaArrayInLong(jenv, &jarr, &$1, $input)) return $null; ,
8852             'type' : a(ANY).long,
8853         }
8854 ,
8855         'tmap:jni' : Hash {
8856             'typemap' : typemap(jni) long [ANY],
8857             'code' : jintArray,
8858             'type' : a(ANY).long,
8859         }
8860 ,
8861         'tmap:jtype' : Hash {
8862             'typemap' : typemap(jtype) long [ANY],
8863             'code' : int[],
8864             'type' : a(ANY).long,
8865         }
8866 ,
8867         'tmap:out' : Hash {
8868             'typemap' : typemap(out) long [ANY],
8869             'code' : $result = SWIG_JavaArrayOutLong(jenv, $1, $1_dim0); ,
8870             'type' : a(ANY).long,
8871         }
8872 ,
8873         'tmap:javain' : Hash {
8874             'typemap' : typemap(javain) long [ANY],
8875             'code' : $javainput,
8876             'type' : a(ANY).long,
8877         }
8878 ,
8879         'tmap:typecheck' : Hash {
8880             'kwargs' : Hash {
8881                 'name' : precedence,
8882                 'value' : 1045,
8883             }
8884 ,
8885             'typemap' : typemap(typecheck) long [ANY],
8886             'code' : ,
8887             'type' : a(ANY).long,
8888         }
8889 ,
8890         'tmap:javaout' : Hash {
8891             'typemap' : typemap(javaout) long [ANY],
8892             'code' : {
8893     return $jnicall;
8894   },
8895             'type' : a(ANY).long,
8896         }
8897 ,
8898     }
8899 ,
8900     'char' : Hash {
8901         'tmap:jstype' : Hash {
8902             'typemap' : typemap(jstype) char,
8903             'code' : char,
8904             'type' : char,
8905         }
8906 ,
8907         'tmap:directorin' : Hash {
8908             'kwargs' : Hash {
8909                 'name' : descriptor,
8910                 'value' : C,
8911             }
8912 ,
8913             'typemap' : typemap(directorin) char,
8914             'code' : $input = (jint) $1;,
8915             'type' : char,
8916         }
8917 ,
8918         'tmap:javadirectorin' : Hash {
8919             'typemap' : typemap(javadirectorin) char,
8920             'code' : $jniinput,
8921             'type' : char,
8922         }
8923 ,
8924         'tmap:in' : Hash {
8925             'kwargs' : Hash {
8926                 'name' : numinputs,
8927                 'value' : 1,
8928             }
8929 ,
8930             'typemap' : typemap(in) char,
8931             'code' :  $1 = ($1_ltype)$input; ,
8932             'type' : char,
8933         }
8934 ,
8935         'tmap:directorout' : Hash {
8936             'typemap' : typemap(directorout) char,
8937             'code' :  $result = ($1_ltype)$input; ,
8938             'type' : char,
8939         }
8940 ,
8941         'tmap:javadirectorout' : Hash {
8942             'typemap' : typemap(javadirectorout) char,
8943             'code' : $javacall,
8944             'type' : char,
8945         }
8946 ,
8947         'tmap:jni' : Hash {
8948             'typemap' : typemap(jni) char,
8949             'code' : jchar,
8950             'type' : char,
8951         }
8952 ,
8953         'tmap:jtype' : Hash {
8954             'typemap' : typemap(jtype) char,
8955             'code' : char,
8956             'type' : char,
8957         }
8958 ,
8959         'tmap:out' : Hash {
8960             'typemap' : typemap(out) char,
8961             'code' :  $result = (jchar)$1; ,
8962             'type' : char,
8963         }
8964 ,
8965         'tmap:typecheck' : Hash {
8966             'kwargs' : Hash {
8967                 'name' : precedence,
8968                 'value' : 130,
8969             }
8970 ,
8971             'typemap' : typemap(typecheck) char,
8972             'code' : ,
8973             'type' : char,
8974         }
8975 ,
8976         'tmap:javain' : Hash {
8977             'typemap' : typemap(javain) char,
8978             'code' : $javainput,
8979             'type' : char,
8980         }
8981 ,
8982         'tmap:javaout' : Hash {
8983             'typemap' : typemap(javaout) char,
8984             'code' : {
8985     return $jnicall;
8986   },
8987             'type' : char,
8988         }
8989 ,
8990     }
8991 ,
8992     'jstring' : Hash {
8993         'tmap:jstype' : Hash {
8994             'typemap' : typemap(jstype) jstring,
8995             'code' : String,
8996             'type' : jstring,
8997         }
8998 ,
8999         'tmap:directorin' : Hash {
9000             'kwargs' : Hash {
9001                 'name' : descriptor,
9002                 'value' : Ljava/lang/String;,
9003             }
9004 ,
9005             'typemap' : typemap(directorin) jstring,
9006             'code' : $input = $1;,
9007             'type' : jstring,
9008         }
9009 ,
9010         'tmap:javadirectorin' : Hash {
9011             'typemap' : typemap(javadirectorin) jstring,
9012             'code' : $jniinput,
9013             'type' : jstring,
9014         }
9015 ,
9016         'tmap:in' : Hash {
9017             'kwargs' : Hash {
9018                 'name' : numinputs,
9019                 'value' : 1,
9020             }
9021 ,
9022             'typemap' : typemap(in) jstring,
9023             'code' :  $1 = $input; ,
9024             'type' : jstring,
9025         }
9026 ,
9027         'tmap:directorout' : Hash {
9028             'typemap' : typemap(directorout) jstring,
9029             'code' :  $result = $input; ,
9030             'type' : jstring,
9031         }
9032 ,
9033         'tmap:javadirectorout' : Hash {
9034             'typemap' : typemap(javadirectorout) jstring,
9035             'code' : $javacall,
9036             'type' : jstring,
9037         }
9038 ,
9039         'tmap:jni' : Hash {
9040             'typemap' : typemap(jni) jstring,
9041             'code' : jstring,
9042             'type' : jstring,
9043         }
9044 ,
9045         'tmap:jtype' : Hash {
9046             'typemap' : typemap(jtype) jstring,
9047             'code' : String,
9048             'type' : jstring,
9049         }
9050 ,
9051         'tmap:out' : Hash {
9052             'typemap' : typemap(out) jstring,
9053             'code' :  $result = $1; ,
9054             'type' : jstring,
9055         }
9056 ,
9057         'tmap:typecheck' : Hash {
9058             'kwargs' : Hash {
9059                 'name' : precedence,
9060                 'value' : 140,
9061             }
9062 ,
9063             'typemap' : typemap(typecheck) jstring,
9064             'code' : ,
9065             'type' : jstring,
9066         }
9067 ,
9068         'tmap:javain' : Hash {
9069             'typemap' : typemap(javain) jstring,
9070             'code' : $javainput,
9071             'type' : jstring,
9072         }
9073 ,
9074         'tmap:javaout' : Hash {
9075             'typemap' : typemap(javaout) jstring,
9076             'code' : {
9077     return $jnicall;
9078   },
9079             'type' : jstring,
9080         }
9081 ,
9082     }
9083 ,
9084     'jlong' : Hash {
9085         'tmap:jstype' : Hash {
9086             'typemap' : typemap(jstype) jlong,
9087             'code' : long,
9088             'type' : jlong,
9089         }
9090 ,
9091         'tmap:directorin' : Hash {
9092             'kwargs' : Hash {
9093                 'name' : descriptor,
9094                 'value' : J,
9095             }
9096 ,
9097             'typemap' : typemap(directorin) jlong,
9098             'code' : $input = $1;,
9099             'type' : jlong,
9100         }
9101 ,
9102         'tmap:javadirectorin' : Hash {
9103             'typemap' : typemap(javadirectorin) jlong,
9104             'code' : $jniinput,
9105             'type' : jlong,
9106         }
9107 ,
9108         'tmap:in' : Hash {
9109             'kwargs' : Hash {
9110                 'name' : numinputs,
9111                 'value' : 1,
9112             }
9113 ,
9114             'typemap' : typemap(in) jlong,
9115             'code' :  $1 = $input; ,
9116             'type' : jlong,
9117         }
9118 ,
9119         'tmap:directorout' : Hash {
9120             'typemap' : typemap(directorout) jlong,
9121             'code' :  $result = $input; ,
9122             'type' : jlong,
9123         }
9124 ,
9125         'tmap:javadirectorout' : Hash {
9126             'typemap' : typemap(javadirectorout) jlong,
9127             'code' : $javacall,
9128             'type' : jlong,
9129         }
9130 ,
9131         'tmap:jni' : Hash {
9132             'typemap' : typemap(jni) jlong,
9133             'code' : jlong,
9134             'type' : jlong,
9135         }
9136 ,
9137         'tmap:jtype' : Hash {
9138             'typemap' : typemap(jtype) jlong,
9139             'code' : long,
9140             'type' : jlong,
9141         }
9142 ,
9143         'tmap:out' : Hash {
9144             'typemap' : typemap(out) jlong,
9145             'code' :  $result = $1; ,
9146             'type' : jlong,
9147         }
9148 ,
9149         'tmap:typecheck' : Hash {
9150             'kwargs' : Hash {
9151                 'name' : precedence,
9152                 'value' : 55,
9153             }
9154 ,
9155             'typemap' : typemap(typecheck) jlong,
9156             'code' : ,
9157             'type' : jlong,
9158         }
9159 ,
9160         'tmap:javain' : Hash {
9161             'typemap' : typemap(javain) jlong,
9162             'code' : $javainput,
9163             'type' : jlong,
9164         }
9165 ,
9166         'tmap:javaout' : Hash {
9167             'typemap' : typemap(javaout) jlong,
9168             'code' : {
9169     return $jnicall;
9170   },
9171             'type' : jlong,
9172         }
9173 ,
9174     }
9175 ,
9176     'a(ANY).char' : Hash {
9177         'tmap:typecheck' : Hash {
9178             'kwargs' : Hash {
9179                 'name' : precedence,
9180                 'value' : 140,
9181             }
9182 ,
9183             'typemap' : typemap(typecheck) char [ANY],
9184             'code' : ,
9185             'type' : a(ANY).char,
9186         }
9187 ,
9188         'tmap:memberin' : Hash {
9189             'typemap' : typemap(memberin) char [ANY],
9190             'code' : {
9191   if ($input) strncpy((char *)$1, (const char *)$input, $1_dim0);
9192   else $1[0] = 0;
9193 },
9194             'type' : a(ANY).char,
9195         }
9196 ,
9197         'tmap:jtype' : Hash {
9198             'typemap' : typemap(jtype) char [ANY],
9199             'code' : String,
9200             'type' : a(ANY).char,
9201         }
9202 ,
9203         'tmap:javadirectorin' : Hash {
9204             'typemap' : typemap(javadirectorin) char [ANY],
9205             'code' : $jniinput,
9206             'type' : a(ANY).char,
9207         }
9208 ,
9209         'tmap:directorin' : Hash {
9210             'kwargs' : Hash {
9211                 'name' : descriptor,
9212                 'value' : Ljava/lang/String;,
9213                 'nextSibling' : Hash {
9214                     'name' : noblock,
9215                     'value' : 1,
9216                 }
9217 ,
9218             }
9219 ,
9220             'typemap' : typemap(directorin) char [ANY],
9221             'code' : $input = 0;
9222   if ($1) {
9223     $input = jenv->NewStringUTF((const char *)$1);
9224     if (!$input) return $null;
9225   },
9226             'type' : a(ANY).char,
9227         }
9228 ,
9229         'tmap:javadirectorout' : Hash {
9230             'typemap' : typemap(javadirectorout) char [ANY],
9231             'code' : $javacall,
9232             'type' : a(ANY).char,
9233         }
9234 ,
9235         'tmap:directorout' : Hash {
9236             'kwargs' : Hash {
9237                 'name' : noblock,
9238                 'value' : 1,
9239             }
9240 ,
9241             'typemap' : typemap(directorout) char [ANY],
9242             'code' : $1 = 0;
9243   if ($input) {
9244     $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
9245     if (!$result) return $null;
9246   },
9247             'type' : a(ANY).char,
9248         }
9249 ,
9250         'tmap:out' : Hash {
9251             'kwargs' : Hash {
9252                 'name' : noblock,
9253                 'value' : 1,
9254             }
9255 ,
9256             'typemap' : typemap(out) char [ANY],
9257             'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);,
9258             'type' : a(ANY).char,
9259         }
9260 ,
9261         'tmap:jni' : Hash {
9262             'typemap' : typemap(jni) char [ANY],
9263             'code' : jstring,
9264             'type' : a(ANY).char,
9265         }
9266 ,
9267         'tmap:javaout' : Hash {
9268             'typemap' : typemap(javaout) char [ANY],
9269             'code' : {
9270     return $jnicall;
9271   },
9272             'type' : a(ANY).char,
9273         }
9274 ,
9275         'tmap:globalin' : Hash {
9276             'typemap' : typemap(globalin) char [ANY],
9277             'code' : {
9278   if ($input) strncpy((char *)$1, (const char *)$input, $1_dim0);
9279   else $1[0] = 0;
9280 },
9281             'type' : a(ANY).char,
9282         }
9283 ,
9284         'tmap:in' : Hash {
9285             'kwargs' : Hash {
9286                 'name' : numinputs,
9287                 'value' : 1,
9288                 'nextSibling' : Hash {
9289                     'name' : noblock,
9290                     'value' : 1,
9291                 }
9292 ,
9293             }
9294 ,
9295             'typemap' : typemap(in) char [ANY],
9296             'code' : $1 = 0;
9297   if ($input) {
9298     $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
9299     if (!$1) return $null;
9300   },
9301             'type' : a(ANY).char,
9302         }
9303 ,
9304         'tmap:javain' : Hash {
9305             'typemap' : typemap(javain) char [ANY],
9306             'code' : $javainput,
9307             'type' : a(ANY).char,
9308         }
9309 ,
9310         'tmap:jstype' : Hash {
9311             'typemap' : typemap(jstype) char [ANY],
9312             'code' : String,
9313             'type' : a(ANY).char,
9314         }
9315 ,
9316         'tmap:argout' : Hash {
9317             'typemap' : typemap(argout) char [ANY],
9318             'code' : ,
9319             'type' : a(ANY).char,
9320         }
9321 ,
9322         'tmap:freearg' : Hash {
9323             'kwargs' : Hash {
9324                 'name' : noblock,
9325                 'value' : 1,
9326             }
9327 ,
9328             'typemap' : typemap(freearg) char [ANY],
9329             'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);,
9330             'type' : a(ANY).char,
9331         }
9332 ,
9333     }
9334 ,
9335     'r.bool' : Hash {
9336         'INOUT' : Hash {
9337             'tmap:freearg' : Hash {
9338                 'pname' : INOUT,
9339                 'typemap' : typemap(freearg) bool &INOUT,
9340                 'code' : ,
9341                 'type' : r.bool,
9342             }
9343 ,
9344             'tmap:jstype' : Hash {
9345                 'pname' : INOUT,
9346                 'typemap' : typemap(jstype) bool &INOUT,
9347                 'code' : boolean[],
9348                 'type' : r.bool,
9349             }
9350 ,
9351             'tmap:javadirectorin' : Hash {
9352                 'pname' : INOUT,
9353                 'typemap' : typemap(javadirectorin) bool &INOUT,
9354                 'code' : $jniinput,
9355                 'type' : r.bool,
9356             }
9357 ,
9358             'tmap:directorin' : Hash {
9359                 'kwargs' : Hash {
9360                     'name' : descriptor,
9361                     'value' : [Ljava/lang/Boolean;,
9362                     'nextSibling' : Hash {
9363                         'name' : warning,
9364                         'value' : Need to provide bool *INOUT directorin typemap, bool array length is unknown,
9365                     }
9366 ,
9367                 }
9368 ,
9369                 'pname' : INOUT,
9370                 'typemap' : typemap(directorin) bool &INOUT,
9371                 'code' : {
9372 },
9373                 'type' : r.bool,
9374             }
9375 ,
9376             'tmap:argout' : Hash {
9377                 'pname' : INOUT,
9378                 'typemap' : typemap(argout) bool &INOUT,
9379                 'code' : { jenv->ReleaseBooleanArrayElements($input, (jboolean *)$1, 0); },
9380                 'type' : r.bool,
9381             }
9382 ,
9383             'tmap:javadirectorout' : Hash {
9384                 'pname' : INOUT,
9385                 'typemap' : typemap(javadirectorout) bool &INOUT,
9386                 'code' : $javacall,
9387                 'type' : r.bool,
9388             }
9389 ,
9390             'tmap:in' : Hash {
9391                 'kwargs' : Hash {
9392                     'name' : numinputs,
9393                     'value' : 1,
9394                 }
9395 ,
9396                 'pname' : INOUT,
9397                 'typemap' : typemap(in) bool &INOUT,
9398                 'code' : {
9399   if (!$input) {
9400     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
9401     return $null;
9402   }
9403   if (jenv->GetArrayLength($input) == 0) {
9404     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
9405     return $null;
9406   }
9407   $1 = ($1_ltype) jenv->GetBooleanArrayElements($input, 0);
9408 },
9409                 'type' : r.bool,
9410             }
9411 ,
9412             'tmap:directorout' : Hash {
9413                 'kwargs' : Hash {
9414                     'name' : warning,
9415                     'value' : Need to provide bool *INOUT directorout typemap,
9416                 }
9417 ,
9418                 'pname' : INOUT,
9419                 'typemap' : typemap(directorout) bool &INOUT,
9420                 'code' : {
9421 },
9422                 'type' : r.bool,
9423             }
9424 ,
9425             'tmap:typecheck' : Hash {
9426                 'kwargs' : Hash {
9427                     'name' : precedence,
9428                     'value' : 1015,
9429                 }
9430 ,
9431                 'pname' : INOUT,
9432                 'typemap' : typemap(typecheck) bool &INOUT,
9433                 'code' : ,
9434                 'type' : r.bool,
9435             }
9436 ,
9437             'tmap:jni' : Hash {
9438                 'pname' : INOUT,
9439                 'typemap' : typemap(jni) bool &INOUT,
9440                 'code' : jbooleanArray,
9441                 'type' : r.bool,
9442             }
9443 ,
9444             'tmap:jtype' : Hash {
9445                 'pname' : INOUT,
9446                 'typemap' : typemap(jtype) bool &INOUT,
9447                 'code' : boolean[],
9448                 'type' : r.bool,
9449             }
9450 ,
9451             'tmap:javain' : Hash {
9452                 'pname' : INOUT,
9453                 'typemap' : typemap(javain) bool &INOUT,
9454                 'code' : $javainput,
9455                 'type' : r.bool,
9456             }
9457 ,
9458         }
9459 ,
9460         'INPUT' : Hash {
9461             'tmap:freearg' : Hash {
9462                 'pname' : INPUT,
9463                 'typemap' : typemap(freearg) bool &INPUT,
9464                 'code' : ,
9465                 'type' : r.bool,
9466             }
9467 ,
9468             'tmap:jstype' : Hash {
9469                 'pname' : INPUT,
9470                 'typemap' : typemap(jstype) bool &INPUT,
9471                 'code' : boolean,
9472                 'type' : r.bool,
9473             }
9474 ,
9475             'tmap:javadirectorin' : Hash {
9476                 'pname' : INPUT,
9477                 'typemap' : typemap(javadirectorin) bool &INPUT,
9478                 'code' : $jniinput,
9479                 'type' : r.bool,
9480             }
9481 ,
9482             'tmap:directorin' : Hash {
9483                 'kwargs' : Hash {
9484                     'name' : descriptor,
9485                     'value' : Z,
9486                 }
9487 ,
9488                 'pname' : INPUT,
9489                 'typemap' : typemap(directorin) bool &INPUT,
9490                 'code' :  *(($&1_ltype) $input) = (jboolean *) &$1; ,
9491                 'type' : r.bool,
9492             }
9493 ,
9494             'tmap:javadirectorout' : Hash {
9495                 'pname' : INPUT,
9496                 'typemap' : typemap(javadirectorout) bool &INPUT,
9497                 'code' : $javacall,
9498                 'type' : r.bool,
9499             }
9500 ,
9501             'tmap:in' : Hash {
9502                 'kwargs' : Hash {
9503                     'name' : numinputs,
9504                     'value' : 1,
9505                 }
9506 ,
9507                 'pname' : INPUT,
9508                 'typemap' : typemap(in) bool &INPUT,
9509                 'code' :  $1 = ($1_ltype)&$input; ,
9510                 'type' : r.bool,
9511             }
9512 ,
9513             'tmap:directorout' : Hash {
9514                 'pname' : INPUT,
9515                 'typemap' : typemap(directorout) bool &INPUT,
9516                 'code' :  $result = ($1_ltype)&$input; ,
9517                 'type' : r.bool,
9518             }
9519 ,
9520             'tmap:jni' : Hash {
9521                 'pname' : INPUT,
9522                 'typemap' : typemap(jni) bool &INPUT,
9523                 'code' : jboolean,
9524                 'type' : r.bool,
9525             }
9526 ,
9527             'tmap:jtype' : Hash {
9528                 'pname' : INPUT,
9529                 'typemap' : typemap(jtype) bool &INPUT,
9530                 'code' : boolean,
9531                 'type' : r.bool,
9532             }
9533 ,
9534             'tmap:javain' : Hash {
9535                 'pname' : INPUT,
9536                 'typemap' : typemap(javain) bool &INPUT,
9537                 'code' : $javainput,
9538                 'type' : r.bool,
9539             }
9540 ,
9541             'tmap:typecheck' : Hash {
9542                 'kwargs' : Hash {
9543                     'name' : precedence,
9544                     'value' : 15,
9545                 }
9546 ,
9547                 'pname' : INPUT,
9548                 'typemap' : typemap(typecheck) bool &INPUT,
9549                 'code' : ,
9550                 'type' : r.bool,
9551             }
9552 ,
9553         }
9554 ,
9555         'OUTPUT' : Hash {
9556             'tmap:freearg' : Hash {
9557                 'pname' : OUTPUT,
9558                 'typemap' : typemap(freearg) bool &OUTPUT,
9559                 'code' : ,
9560                 'type' : r.bool,
9561             }
9562 ,
9563             'tmap:jstype' : Hash {
9564                 'pname' : OUTPUT,
9565                 'typemap' : typemap(jstype) bool &OUTPUT,
9566                 'code' : boolean[],
9567                 'type' : r.bool,
9568             }
9569 ,
9570             'tmap:javadirectorin' : Hash {
9571                 'pname' : OUTPUT,
9572                 'typemap' : typemap(javadirectorin) bool &OUTPUT,
9573                 'code' : $jniinput,
9574                 'type' : r.bool,
9575             }
9576 ,
9577             'tmap:directorin' : Hash {
9578                 'kwargs' : Hash {
9579                     'name' : descriptor,
9580                     'value' : [Ljava/lang/Boolean;,
9581                 }
9582 ,
9583                 'pname' : OUTPUT,
9584                 'typemap' : typemap(directorin) bool &OUTPUT,
9585                 'code' :  *(($&1_ltype) $input = &$1; ,
9586                 'type' : r.bool,
9587             }
9588 ,
9589             'tmap:argout' : Hash {
9590                 'pname' : OUTPUT,
9591                 'typemap' : typemap(argout) bool &OUTPUT,
9592                 'code' : {
9593   jboolean jvalue = (jboolean)temp$argnum;
9594   jenv->SetBooleanArrayRegion($input, 0, 1, &jvalue);
9595 },
9596                 'type' : r.bool,
9597             }
9598 ,
9599             'tmap:javadirectorout' : Hash {
9600                 'pname' : OUTPUT,
9601                 'typemap' : typemap(javadirectorout) bool &OUTPUT,
9602                 'code' : $javacall,
9603                 'type' : r.bool,
9604             }
9605 ,
9606             'tmap:in' : Hash {
9607                 'locals' : Hash {
9608                     'name' : temp,
9609                     'type' : $*1_ltype,
9610                 }
9611 ,
9612                 'kwargs' : Hash {
9613                     'name' : numinputs,
9614                     'value' : 1,
9615                 }
9616 ,
9617                 'pname' : OUTPUT,
9618                 'typemap' : typemap(in) bool &OUTPUT,
9619                 'code' : {
9620   if (!$input) {
9621     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
9622     return $null;
9623   }
9624   if (jenv->GetArrayLength($input) == 0) {
9625     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
9626     return $null;
9627   }
9628   $1 = &temp;
9629 },
9630                 'type' : r.bool,
9631             }
9632 ,
9633             'tmap:directorout' : Hash {
9634                 'kwargs' : Hash {
9635                     'name' : warning,
9636                     'value' : Need to provide bool *OUTPUT directorout typemap,
9637                 }
9638 ,
9639                 'pname' : OUTPUT,
9640                 'typemap' : typemap(directorout) bool &OUTPUT,
9641                 'code' : {
9642 },
9643                 'type' : r.bool,
9644             }
9645 ,
9646             'tmap:jni' : Hash {
9647                 'pname' : OUTPUT,
9648                 'typemap' : typemap(jni) bool &OUTPUT,
9649                 'code' : jbooleanArray,
9650                 'type' : r.bool,
9651             }
9652 ,
9653             'tmap:jtype' : Hash {
9654                 'pname' : OUTPUT,
9655                 'typemap' : typemap(jtype) bool &OUTPUT,
9656                 'code' : boolean[],
9657                 'type' : r.bool,
9658             }
9659 ,
9660             'tmap:javain' : Hash {
9661                 'pname' : OUTPUT,
9662                 'typemap' : typemap(javain) bool &OUTPUT,
9663                 'code' : $javainput,
9664                 'type' : r.bool,
9665             }
9666 ,
9667         }
9668 ,
9669     }
9670 ,
9671     'jlongArray' : Hash {
9672         'tmap:jstype' : Hash {
9673             'typemap' : typemap(jstype) jlongArray,
9674             'code' : long[],
9675             'type' : jlongArray,
9676         }
9677 ,
9678         'tmap:directorin' : Hash {
9679             'kwargs' : Hash {
9680                 'name' : descriptor,
9681                 'value' : [J,
9682             }
9683 ,
9684             'typemap' : typemap(directorin) jlongArray,
9685             'code' : $input = $1;,
9686             'type' : jlongArray,
9687         }
9688 ,
9689         'tmap:javadirectorin' : Hash {
9690             'typemap' : typemap(javadirectorin) jlongArray,
9691             'code' : $jniinput,
9692             'type' : jlongArray,
9693         }
9694 ,
9695         'tmap:in' : Hash {
9696             'kwargs' : Hash {
9697                 'name' : numinputs,
9698                 'value' : 1,
9699             }
9700 ,
9701             'typemap' : typemap(in) jlongArray,
9702             'code' :  $1 = $input; ,
9703             'type' : jlongArray,
9704         }
9705 ,
9706         'tmap:directorout' : Hash {
9707             'typemap' : typemap(directorout) jlongArray,
9708             'code' :  $result = $input; ,
9709             'type' : jlongArray,
9710         }
9711 ,
9712         'tmap:javadirectorout' : Hash {
9713             'typemap' : typemap(javadirectorout) jlongArray,
9714             'code' : $javacall,
9715             'type' : jlongArray,
9716         }
9717 ,
9718         'tmap:jni' : Hash {
9719             'typemap' : typemap(jni) jlongArray,
9720             'code' : jlongArray,
9721             'type' : jlongArray,
9722         }
9723 ,
9724         'tmap:jtype' : Hash {
9725             'typemap' : typemap(jtype) jlongArray,
9726             'code' : long[],
9727             'type' : jlongArray,
9728         }
9729 ,
9730         'tmap:out' : Hash {
9731             'typemap' : typemap(out) jlongArray,
9732             'code' :  $result = $1; ,
9733             'type' : jlongArray,
9734         }
9735 ,
9736         'tmap:typecheck' : Hash {
9737             'kwargs' : Hash {
9738                 'name' : precedence,
9739                 'value' : 1055,
9740             }
9741 ,
9742             'typemap' : typemap(typecheck) jlongArray,
9743             'code' : ,
9744             'type' : jlongArray,
9745         }
9746 ,
9747         'tmap:javain' : Hash {
9748             'typemap' : typemap(javain) jlongArray,
9749             'code' : $javainput,
9750             'type' : jlongArray,
9751         }
9752 ,
9753         'tmap:javaout' : Hash {
9754             'typemap' : typemap(javaout) jlongArray,
9755             'code' : {
9756     return $jnicall;
9757   },
9758             'type' : jlongArray,
9759         }
9760 ,
9761     }
9762 ,
9763     'jchar' : Hash {
9764         'tmap:jstype' : Hash {
9765             'typemap' : typemap(jstype) jchar,
9766             'code' : char,
9767             'type' : jchar,
9768         }
9769 ,
9770         'tmap:directorin' : Hash {
9771             'kwargs' : Hash {
9772                 'name' : descriptor,
9773                 'value' : C,
9774             }
9775 ,
9776             'typemap' : typemap(directorin) jchar,
9777             'code' : $input = $1;,
9778             'type' : jchar,
9779         }
9780 ,
9781         'tmap:javadirectorin' : Hash {
9782             'typemap' : typemap(javadirectorin) jchar,
9783             'code' : $jniinput,
9784             'type' : jchar,
9785         }
9786 ,
9787         'tmap:in' : Hash {
9788             'kwargs' : Hash {
9789                 'name' : numinputs,
9790                 'value' : 1,
9791             }
9792 ,
9793             'typemap' : typemap(in) jchar,
9794             'code' :  $1 = $input; ,
9795             'type' : jchar,
9796         }
9797 ,
9798         'tmap:directorout' : Hash {
9799             'typemap' : typemap(directorout) jchar,
9800             'code' :  $result = $input; ,
9801             'type' : jchar,
9802         }
9803 ,
9804         'tmap:javadirectorout' : Hash {
9805             'typemap' : typemap(javadirectorout) jchar,
9806             'code' : $javacall,
9807             'type' : jchar,
9808         }
9809 ,
9810         'tmap:jni' : Hash {
9811             'typemap' : typemap(jni) jchar,
9812             'code' : jchar,
9813             'type' : jchar,
9814         }
9815 ,
9816         'tmap:jtype' : Hash {
9817             'typemap' : typemap(jtype) jchar,
9818             'code' : char,
9819             'type' : jchar,
9820         }
9821 ,
9822         'tmap:out' : Hash {
9823             'typemap' : typemap(out) jchar,
9824             'code' :  $result = $1; ,
9825             'type' : jchar,
9826         }
9827 ,
9828         'tmap:typecheck' : Hash {
9829             'kwargs' : Hash {
9830                 'name' : precedence,
9831                 'value' : 130,
9832             }
9833 ,
9834             'typemap' : typemap(typecheck) jchar,
9835             'code' : ,
9836             'type' : jchar,
9837         }
9838 ,
9839         'tmap:javain' : Hash {
9840             'typemap' : typemap(javain) jchar,
9841             'code' : $javainput,
9842             'type' : jchar,
9843         }
9844 ,
9845         'tmap:javaout' : Hash {
9846             'typemap' : typemap(javaout) jchar,
9847             'code' : {
9848     return $jnicall;
9849   },
9850             'type' : jchar,
9851         }
9852 ,
9853     }
9854 ,
9855     'jboolean' : Hash {
9856         'tmap:jstype' : Hash {
9857             'typemap' : typemap(jstype) jboolean,
9858             'code' : boolean,
9859             'type' : jboolean,
9860         }
9861 ,
9862         'tmap:directorin' : Hash {
9863             'kwargs' : Hash {
9864                 'name' : descriptor,
9865                 'value' : Z,
9866             }
9867 ,
9868             'typemap' : typemap(directorin) jboolean,
9869             'code' : $input = $1;,
9870             'type' : jboolean,
9871         }
9872 ,
9873         'tmap:javadirectorin' : Hash {
9874             'typemap' : typemap(javadirectorin) jboolean,
9875             'code' : $jniinput,
9876             'type' : jboolean,
9877         }
9878 ,
9879         'tmap:in' : Hash {
9880             'kwargs' : Hash {
9881                 'name' : numinputs,
9882                 'value' : 1,
9883             }
9884 ,
9885             'typemap' : typemap(in) jboolean,
9886             'code' :  $1 = $input; ,
9887             'type' : jboolean,
9888         }
9889 ,
9890         'tmap:directorout' : Hash {
9891             'typemap' : typemap(directorout) jboolean,
9892             'code' :  $result = $input; ,
9893             'type' : jboolean,
9894         }
9895 ,
9896         'tmap:javadirectorout' : Hash {
9897             'typemap' : typemap(javadirectorout) jboolean,
9898             'code' : $javacall,
9899             'type' : jboolean,
9900         }
9901 ,
9902         'tmap:jni' : Hash {
9903             'typemap' : typemap(jni) jboolean,
9904             'code' : jboolean,
9905             'type' : jboolean,
9906         }
9907 ,
9908         'tmap:jtype' : Hash {
9909             'typemap' : typemap(jtype) jboolean,
9910             'code' : boolean,
9911             'type' : jboolean,
9912         }
9913 ,
9914         'tmap:out' : Hash {
9915             'typemap' : typemap(out) jboolean,
9916             'code' :  $result = $1; ,
9917             'type' : jboolean,
9918         }
9919 ,
9920         'tmap:typecheck' : Hash {
9921             'kwargs' : Hash {
9922                 'name' : precedence,
9923                 'value' : 15,
9924             }
9925 ,
9926             'typemap' : typemap(typecheck) jboolean,
9927             'code' : ,
9928             'type' : jboolean,
9929         }
9930 ,
9931         'tmap:javain' : Hash {
9932             'typemap' : typemap(javain) jboolean,
9933             'code' : $javainput,
9934             'type' : jboolean,
9935         }
9936 ,
9937         'tmap:javaout' : Hash {
9938             'typemap' : typemap(javaout) jboolean,
9939             'code' : {
9940     return $jnicall;
9941   },
9942             'type' : jboolean,
9943         }
9944 ,
9945     }
9946 ,
9947     'p.float' : Hash {
9948         'INOUT' : Hash {
9949             'tmap:freearg' : Hash {
9950                 'pname' : INOUT,
9951                 'typemap' : typemap(freearg) float *INOUT,
9952                 'code' : ,
9953                 'type' : p.float,
9954             }
9955 ,
9956             'tmap:jstype' : Hash {
9957                 'pname' : INOUT,
9958                 'typemap' : typemap(jstype) float *INOUT,
9959                 'code' : float[],
9960                 'type' : p.float,
9961             }
9962 ,
9963             'tmap:javadirectorin' : Hash {
9964                 'pname' : INOUT,
9965                 'typemap' : typemap(javadirectorin) float *INOUT,
9966                 'code' : $jniinput,
9967                 'type' : p.float,
9968             }
9969 ,
9970             'tmap:directorin' : Hash {
9971                 'kwargs' : Hash {
9972                     'name' : descriptor,
9973                     'value' : [Ljava/lang/Float;,
9974                     'nextSibling' : Hash {
9975                         'name' : warning,
9976                         'value' : Need to provide float *INOUT directorin typemap, float array length is unknown,
9977                     }
9978 ,
9979                 }
9980 ,
9981                 'pname' : INOUT,
9982                 'typemap' : typemap(directorin) float *INOUT,
9983                 'code' : {
9984 },
9985                 'type' : p.float,
9986             }
9987 ,
9988             'tmap:argout' : Hash {
9989                 'pname' : INOUT,
9990                 'typemap' : typemap(argout) float *INOUT,
9991                 'code' : { jenv->ReleaseFloatArrayElements($input, (jfloat *)$1, 0); },
9992                 'type' : p.float,
9993             }
9994 ,
9995             'tmap:javadirectorout' : Hash {
9996                 'pname' : INOUT,
9997                 'typemap' : typemap(javadirectorout) float *INOUT,
9998                 'code' : $javacall,
9999                 'type' : p.float,
10000             }
10001 ,
10002             'tmap:in' : Hash {
10003                 'kwargs' : Hash {
10004                     'name' : numinputs,
10005                     'value' : 1,
10006                 }
10007 ,
10008                 'pname' : INOUT,
10009                 'typemap' : typemap(in) float *INOUT,
10010                 'code' : {
10011   if (!$input) {
10012     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10013     return $null;
10014   }
10015   if (jenv->GetArrayLength($input) == 0) {
10016     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10017     return $null;
10018   }
10019   $1 = ($1_ltype) jenv->GetFloatArrayElements($input, 0);
10020 },
10021                 'type' : p.float,
10022             }
10023 ,
10024             'tmap:directorout' : Hash {
10025                 'kwargs' : Hash {
10026                     'name' : warning,
10027                     'value' : Need to provide float *INOUT directorout typemap,
10028                 }
10029 ,
10030                 'pname' : INOUT,
10031                 'typemap' : typemap(directorout) float *INOUT,
10032                 'code' : {
10033 },
10034                 'type' : p.float,
10035             }
10036 ,
10037             'tmap:typecheck' : Hash {
10038                 'kwargs' : Hash {
10039                     'name' : precedence,
10040                     'value' : 1080,
10041                 }
10042 ,
10043                 'pname' : INOUT,
10044                 'typemap' : typemap(typecheck) float *INOUT,
10045                 'code' : ,
10046                 'type' : p.float,
10047             }
10048 ,
10049             'tmap:jni' : Hash {
10050                 'pname' : INOUT,
10051                 'typemap' : typemap(jni) float *INOUT,
10052                 'code' : jfloatArray,
10053                 'type' : p.float,
10054             }
10055 ,
10056             'tmap:jtype' : Hash {
10057                 'pname' : INOUT,
10058                 'typemap' : typemap(jtype) float *INOUT,
10059                 'code' : float[],
10060                 'type' : p.float,
10061             }
10062 ,
10063             'tmap:javain' : Hash {
10064                 'pname' : INOUT,
10065                 'typemap' : typemap(javain) float *INOUT,
10066                 'code' : $javainput,
10067                 'type' : p.float,
10068             }
10069 ,
10070         }
10071 ,
10072         'INPUT' : Hash {
10073             'tmap:freearg' : Hash {
10074                 'pname' : INPUT,
10075                 'typemap' : typemap(freearg) float *INPUT,
10076                 'code' : ,
10077                 'type' : p.float,
10078             }
10079 ,
10080             'tmap:jstype' : Hash {
10081                 'pname' : INPUT,
10082                 'typemap' : typemap(jstype) float *INPUT,
10083                 'code' : float,
10084                 'type' : p.float,
10085             }
10086 ,
10087             'tmap:javadirectorin' : Hash {
10088                 'pname' : INPUT,
10089                 'typemap' : typemap(javadirectorin) float *INPUT,
10090                 'code' : $jniinput,
10091                 'type' : p.float,
10092             }
10093 ,
10094             'tmap:directorin' : Hash {
10095                 'kwargs' : Hash {
10096                     'name' : descriptor,
10097                     'value' : F,
10098                 }
10099 ,
10100                 'pname' : INPUT,
10101                 'typemap' : typemap(directorin) float *INPUT,
10102                 'code' :  *(($&1_ltype) $input) = (jfloat *) $1; ,
10103                 'type' : p.float,
10104             }
10105 ,
10106             'tmap:javadirectorout' : Hash {
10107                 'pname' : INPUT,
10108                 'typemap' : typemap(javadirectorout) float *INPUT,
10109                 'code' : $javacall,
10110                 'type' : p.float,
10111             }
10112 ,
10113             'tmap:in' : Hash {
10114                 'kwargs' : Hash {
10115                     'name' : numinputs,
10116                     'value' : 1,
10117                 }
10118 ,
10119                 'pname' : INPUT,
10120                 'typemap' : typemap(in) float *INPUT,
10121                 'code' :  $1 = ($1_ltype)&$input; ,
10122                 'type' : p.float,
10123             }
10124 ,
10125             'tmap:directorout' : Hash {
10126                 'pname' : INPUT,
10127                 'typemap' : typemap(directorout) float *INPUT,
10128                 'code' :  $result = ($1_ltype)&$input; ,
10129                 'type' : p.float,
10130             }
10131 ,
10132             'tmap:jni' : Hash {
10133                 'pname' : INPUT,
10134                 'typemap' : typemap(jni) float *INPUT,
10135                 'code' : jfloat,
10136                 'type' : p.float,
10137             }
10138 ,
10139             'tmap:jtype' : Hash {
10140                 'pname' : INPUT,
10141                 'typemap' : typemap(jtype) float *INPUT,
10142                 'code' : float,
10143                 'type' : p.float,
10144             }
10145 ,
10146             'tmap:javain' : Hash {
10147                 'pname' : INPUT,
10148                 'typemap' : typemap(javain) float *INPUT,
10149                 'code' : $javainput,
10150                 'type' : p.float,
10151             }
10152 ,
10153             'tmap:typecheck' : Hash {
10154                 'kwargs' : Hash {
10155                     'name' : precedence,
10156                     'value' : 80,
10157                 }
10158 ,
10159                 'pname' : INPUT,
10160                 'typemap' : typemap(typecheck) float *INPUT,
10161                 'code' : ,
10162                 'type' : p.float,
10163             }
10164 ,
10165         }
10166 ,
10167         'OUTPUT' : Hash {
10168             'tmap:freearg' : Hash {
10169                 'pname' : OUTPUT,
10170                 'typemap' : typemap(freearg) float *OUTPUT,
10171                 'code' : ,
10172                 'type' : p.float,
10173             }
10174 ,
10175             'tmap:jstype' : Hash {
10176                 'pname' : OUTPUT,
10177                 'typemap' : typemap(jstype) float *OUTPUT,
10178                 'code' : float[],
10179                 'type' : p.float,
10180             }
10181 ,
10182             'tmap:javadirectorin' : Hash {
10183                 'pname' : OUTPUT,
10184                 'typemap' : typemap(javadirectorin) float *OUTPUT,
10185                 'code' : $jniinput,
10186                 'type' : p.float,
10187             }
10188 ,
10189             'tmap:directorin' : Hash {
10190                 'kwargs' : Hash {
10191                     'name' : descriptor,
10192                     'value' : [Ljava/lang/Float;,
10193                     'nextSibling' : Hash {
10194                         'name' : warning,
10195                         'value' : Need to provide float *OUTPUT directorin typemap, float array length is unknown,
10196                     }
10197 ,
10198                 }
10199 ,
10200                 'pname' : OUTPUT,
10201                 'typemap' : typemap(directorin) float *OUTPUT,
10202                 'code' : {
10203 },
10204                 'type' : p.float,
10205             }
10206 ,
10207             'tmap:argout' : Hash {
10208                 'pname' : OUTPUT,
10209                 'typemap' : typemap(argout) float *OUTPUT,
10210                 'code' : {
10211   jfloat jvalue = (jfloat)temp$argnum;
10212   jenv->SetFloatArrayRegion($input, 0, 1, &jvalue);
10213 },
10214                 'type' : p.float,
10215             }
10216 ,
10217             'tmap:javadirectorout' : Hash {
10218                 'pname' : OUTPUT,
10219                 'typemap' : typemap(javadirectorout) float *OUTPUT,
10220                 'code' : $javacall,
10221                 'type' : p.float,
10222             }
10223 ,
10224             'tmap:in' : Hash {
10225                 'locals' : Hash {
10226                     'name' : temp,
10227                     'type' : $*1_ltype,
10228                 }
10229 ,
10230                 'kwargs' : Hash {
10231                     'name' : numinputs,
10232                     'value' : 1,
10233                 }
10234 ,
10235                 'pname' : OUTPUT,
10236                 'typemap' : typemap(in) float *OUTPUT,
10237                 'code' : {
10238   if (!$input) {
10239     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10240     return $null;
10241   }
10242   if (jenv->GetArrayLength($input) == 0) {
10243     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10244     return $null;
10245   }
10246   $1 = &temp;
10247 },
10248                 'type' : p.float,
10249             }
10250 ,
10251             'tmap:directorout' : Hash {
10252                 'kwargs' : Hash {
10253                     'name' : warning,
10254                     'value' : Need to provide float *OUTPUT directorout typemap,
10255                 }
10256 ,
10257                 'pname' : OUTPUT,
10258                 'typemap' : typemap(directorout) float *OUTPUT,
10259                 'code' : {
10260 },
10261                 'type' : p.float,
10262             }
10263 ,
10264             'tmap:jni' : Hash {
10265                 'pname' : OUTPUT,
10266                 'typemap' : typemap(jni) float *OUTPUT,
10267                 'code' : jfloatArray,
10268                 'type' : p.float,
10269             }
10270 ,
10271             'tmap:jtype' : Hash {
10272                 'pname' : OUTPUT,
10273                 'typemap' : typemap(jtype) float *OUTPUT,
10274                 'code' : float[],
10275                 'type' : p.float,
10276             }
10277 ,
10278             'tmap:javain' : Hash {
10279                 'pname' : OUTPUT,
10280                 'typemap' : typemap(javain) float *OUTPUT,
10281                 'code' : $javainput,
10282                 'type' : p.float,
10283             }
10284 ,
10285         }
10286 ,
10287     }
10288 ,
10289     'r.float' : Hash {
10290         'INOUT' : Hash {
10291             'tmap:freearg' : Hash {
10292                 'pname' : INOUT,
10293                 'typemap' : typemap(freearg) float &INOUT,
10294                 'code' : ,
10295                 'type' : r.float,
10296             }
10297 ,
10298             'tmap:jstype' : Hash {
10299                 'pname' : INOUT,
10300                 'typemap' : typemap(jstype) float &INOUT,
10301                 'code' : float[],
10302                 'type' : r.float,
10303             }
10304 ,
10305             'tmap:javadirectorin' : Hash {
10306                 'pname' : INOUT,
10307                 'typemap' : typemap(javadirectorin) float &INOUT,
10308                 'code' : $jniinput,
10309                 'type' : r.float,
10310             }
10311 ,
10312             'tmap:directorin' : Hash {
10313                 'kwargs' : Hash {
10314                     'name' : descriptor,
10315                     'value' : [Ljava/lang/Float;,
10316                     'nextSibling' : Hash {
10317                         'name' : warning,
10318                         'value' : Need to provide float *INOUT directorin typemap, float array length is unknown,
10319                     }
10320 ,
10321                 }
10322 ,
10323                 'pname' : INOUT,
10324                 'typemap' : typemap(directorin) float &INOUT,
10325                 'code' : {
10326 },
10327                 'type' : r.float,
10328             }
10329 ,
10330             'tmap:argout' : Hash {
10331                 'pname' : INOUT,
10332                 'typemap' : typemap(argout) float &INOUT,
10333                 'code' : { jenv->ReleaseFloatArrayElements($input, (jfloat *)$1, 0); },
10334                 'type' : r.float,
10335             }
10336 ,
10337             'tmap:javadirectorout' : Hash {
10338                 'pname' : INOUT,
10339                 'typemap' : typemap(javadirectorout) float &INOUT,
10340                 'code' : $javacall,
10341                 'type' : r.float,
10342             }
10343 ,
10344             'tmap:in' : Hash {
10345                 'kwargs' : Hash {
10346                     'name' : numinputs,
10347                     'value' : 1,
10348                 }
10349 ,
10350                 'pname' : INOUT,
10351                 'typemap' : typemap(in) float &INOUT,
10352                 'code' : {
10353   if (!$input) {
10354     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10355     return $null;
10356   }
10357   if (jenv->GetArrayLength($input) == 0) {
10358     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10359     return $null;
10360   }
10361   $1 = ($1_ltype) jenv->GetFloatArrayElements($input, 0);
10362 },
10363                 'type' : r.float,
10364             }
10365 ,
10366             'tmap:directorout' : Hash {
10367                 'kwargs' : Hash {
10368                     'name' : warning,
10369                     'value' : Need to provide float *INOUT directorout typemap,
10370                 }
10371 ,
10372                 'pname' : INOUT,
10373                 'typemap' : typemap(directorout) float &INOUT,
10374                 'code' : {
10375 },
10376                 'type' : r.float,
10377             }
10378 ,
10379             'tmap:typecheck' : Hash {
10380                 'kwargs' : Hash {
10381                     'name' : precedence,
10382                     'value' : 1080,
10383                 }
10384 ,
10385                 'pname' : INOUT,
10386                 'typemap' : typemap(typecheck) float &INOUT,
10387                 'code' : ,
10388                 'type' : r.float,
10389             }
10390 ,
10391             'tmap:jni' : Hash {
10392                 'pname' : INOUT,
10393                 'typemap' : typemap(jni) float &INOUT,
10394                 'code' : jfloatArray,
10395                 'type' : r.float,
10396             }
10397 ,
10398             'tmap:jtype' : Hash {
10399                 'pname' : INOUT,
10400                 'typemap' : typemap(jtype) float &INOUT,
10401                 'code' : float[],
10402                 'type' : r.float,
10403             }
10404 ,
10405             'tmap:javain' : Hash {
10406                 'pname' : INOUT,
10407                 'typemap' : typemap(javain) float &INOUT,
10408                 'code' : $javainput,
10409                 'type' : r.float,
10410             }
10411 ,
10412         }
10413 ,
10414         'INPUT' : Hash {
10415             'tmap:freearg' : Hash {
10416                 'pname' : INPUT,
10417                 'typemap' : typemap(freearg) float &INPUT,
10418                 'code' : ,
10419                 'type' : r.float,
10420             }
10421 ,
10422             'tmap:jstype' : Hash {
10423                 'pname' : INPUT,
10424                 'typemap' : typemap(jstype) float &INPUT,
10425                 'code' : float,
10426                 'type' : r.float,
10427             }
10428 ,
10429             'tmap:javadirectorin' : Hash {
10430                 'pname' : INPUT,
10431                 'typemap' : typemap(javadirectorin) float &INPUT,
10432                 'code' : $jniinput,
10433                 'type' : r.float,
10434             }
10435 ,
10436             'tmap:directorin' : Hash {
10437                 'kwargs' : Hash {
10438                     'name' : descriptor,
10439                     'value' : F,
10440                 }
10441 ,
10442                 'pname' : INPUT,
10443                 'typemap' : typemap(directorin) float &INPUT,
10444                 'code' :  *(($&1_ltype) $input) = (jfloat *) &$1; ,
10445                 'type' : r.float,
10446             }
10447 ,
10448             'tmap:javadirectorout' : Hash {
10449                 'pname' : INPUT,
10450                 'typemap' : typemap(javadirectorout) float &INPUT,
10451                 'code' : $javacall,
10452                 'type' : r.float,
10453             }
10454 ,
10455             'tmap:in' : Hash {
10456                 'kwargs' : Hash {
10457                     'name' : numinputs,
10458                     'value' : 1,
10459                 }
10460 ,
10461                 'pname' : INPUT,
10462                 'typemap' : typemap(in) float &INPUT,
10463                 'code' :  $1 = ($1_ltype)&$input; ,
10464                 'type' : r.float,
10465             }
10466 ,
10467             'tmap:directorout' : Hash {
10468                 'pname' : INPUT,
10469                 'typemap' : typemap(directorout) float &INPUT,
10470                 'code' :  $result = ($1_ltype)&$input; ,
10471                 'type' : r.float,
10472             }
10473 ,
10474             'tmap:jni' : Hash {
10475                 'pname' : INPUT,
10476                 'typemap' : typemap(jni) float &INPUT,
10477                 'code' : jfloat,
10478                 'type' : r.float,
10479             }
10480 ,
10481             'tmap:jtype' : Hash {
10482                 'pname' : INPUT,
10483                 'typemap' : typemap(jtype) float &INPUT,
10484                 'code' : float,
10485                 'type' : r.float,
10486             }
10487 ,
10488             'tmap:javain' : Hash {
10489                 'pname' : INPUT,
10490                 'typemap' : typemap(javain) float &INPUT,
10491                 'code' : $javainput,
10492                 'type' : r.float,
10493             }
10494 ,
10495             'tmap:typecheck' : Hash {
10496                 'kwargs' : Hash {
10497                     'name' : precedence,
10498                     'value' : 80,
10499                 }
10500 ,
10501                 'pname' : INPUT,
10502                 'typemap' : typemap(typecheck) float &INPUT,
10503                 'code' : ,
10504                 'type' : r.float,
10505             }
10506 ,
10507         }
10508 ,
10509         'OUTPUT' : Hash {
10510             'tmap:freearg' : Hash {
10511                 'pname' : OUTPUT,
10512                 'typemap' : typemap(freearg) float &OUTPUT,
10513                 'code' : ,
10514                 'type' : r.float,
10515             }
10516 ,
10517             'tmap:jstype' : Hash {
10518                 'pname' : OUTPUT,
10519                 'typemap' : typemap(jstype) float &OUTPUT,
10520                 'code' : float[],
10521                 'type' : r.float,
10522             }
10523 ,
10524             'tmap:javadirectorin' : Hash {
10525                 'pname' : OUTPUT,
10526                 'typemap' : typemap(javadirectorin) float &OUTPUT,
10527                 'code' : $jniinput,
10528                 'type' : r.float,
10529             }
10530 ,
10531             'tmap:directorin' : Hash {
10532                 'kwargs' : Hash {
10533                     'name' : descriptor,
10534                     'value' : [Ljava/lang/Float;,
10535                 }
10536 ,
10537                 'pname' : OUTPUT,
10538                 'typemap' : typemap(directorin) float &OUTPUT,
10539                 'code' :  *(($&1_ltype) $input = &$1; ,
10540                 'type' : r.float,
10541             }
10542 ,
10543             'tmap:argout' : Hash {
10544                 'pname' : OUTPUT,
10545                 'typemap' : typemap(argout) float &OUTPUT,
10546                 'code' : {
10547   jfloat jvalue = (jfloat)temp$argnum;
10548   jenv->SetFloatArrayRegion($input, 0, 1, &jvalue);
10549 },
10550                 'type' : r.float,
10551             }
10552 ,
10553             'tmap:javadirectorout' : Hash {
10554                 'pname' : OUTPUT,
10555                 'typemap' : typemap(javadirectorout) float &OUTPUT,
10556                 'code' : $javacall,
10557                 'type' : r.float,
10558             }
10559 ,
10560             'tmap:in' : Hash {
10561                 'locals' : Hash {
10562                     'name' : temp,
10563                     'type' : $*1_ltype,
10564                 }
10565 ,
10566                 'kwargs' : Hash {
10567                     'name' : numinputs,
10568                     'value' : 1,
10569                 }
10570 ,
10571                 'pname' : OUTPUT,
10572                 'typemap' : typemap(in) float &OUTPUT,
10573                 'code' : {
10574   if (!$input) {
10575     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
10576     return $null;
10577   }
10578   if (jenv->GetArrayLength($input) == 0) {
10579     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
10580     return $null;
10581   }
10582   $1 = &temp;
10583 },
10584                 'type' : r.float,
10585             }
10586 ,
10587             'tmap:directorout' : Hash {
10588                 'kwargs' : Hash {
10589                     'name' : warning,
10590                     'value' : Need to provide float *OUTPUT directorout typemap,
10591                 }
10592 ,
10593                 'pname' : OUTPUT,
10594                 'typemap' : typemap(directorout) float &OUTPUT,
10595                 'code' : {
10596 },
10597                 'type' : r.float,
10598             }
10599 ,
10600             'tmap:jni' : Hash {
10601                 'pname' : OUTPUT,
10602                 'typemap' : typemap(jni) float &OUTPUT,
10603                 'code' : jfloatArray,
10604                 'type' : r.float,
10605             }
10606 ,
10607             'tmap:jtype' : Hash {
10608                 'pname' : OUTPUT,
10609                 'typemap' : typemap(jtype) float &OUTPUT,
10610                 'code' : float[],
10611                 'type' : r.float,
10612             }
10613 ,
10614             'tmap:javain' : Hash {
10615                 'pname' : OUTPUT,
10616                 'typemap' : typemap(javain) float &OUTPUT,
10617                 'code' : $javainput,
10618                 'type' : r.float,
10619             }
10620 ,
10621         }
10622 ,
10623     }
10624 ,
10625     'a(ANY).ARRAYSOFENUMS' : Hash {
10626         'tmap:freearg' : Hash {
10627             'typemap' : typemap(freearg) ARRAYSOFENUMS [ANY],
10628             'code' :  delete [] $1; ,
10629             'type' : a(ANY).ARRAYSOFENUMS,
10630         }
10631 ,
10632         'tmap:jstype' : Hash {
10633             'typemap' : typemap(jstype) ARRAYSOFENUMS [ANY],
10634             'code' : int[],
10635             'type' : a(ANY).ARRAYSOFENUMS,
10636         }
10637 ,
10638         'tmap:argout' : Hash {
10639             'typemap' : typemap(argout) ARRAYSOFENUMS [ANY],
10640             'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, (int *)$1, $input); ,
10641             'type' : a(ANY).ARRAYSOFENUMS,
10642         }
10643 ,
10644         'tmap:in' : Hash {
10645             'locals' : Hash {
10646                 'name' : jarr,
10647                 'type' : p.jint,
10648             }
10649 ,
10650             'kwargs' : Hash {
10651                 'name' : numinputs,
10652                 'value' : 1,
10653             }
10654 ,
10655             'typemap' : typemap(in) ARRAYSOFENUMS [ANY],
10656             'code' : {
10657   if ($input && jenv->GetArrayLength($input) != $1_size) {
10658     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
10659     return $null;
10660   }
10661   if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null;
10662 },
10663             'type' : a(ANY).ARRAYSOFENUMS,
10664         }
10665 ,
10666         'tmap:jni' : Hash {
10667             'typemap' : typemap(jni) ARRAYSOFENUMS [ANY],
10668             'code' : jintArray,
10669             'type' : a(ANY).ARRAYSOFENUMS,
10670         }
10671 ,
10672         'tmap:jtype' : Hash {
10673             'typemap' : typemap(jtype) ARRAYSOFENUMS [ANY],
10674             'code' : int[],
10675             'type' : a(ANY).ARRAYSOFENUMS,
10676         }
10677 ,
10678         'tmap:javain' : Hash {
10679             'typemap' : typemap(javain) ARRAYSOFENUMS [ANY],
10680             'code' : $javainput,
10681             'type' : a(ANY).ARRAYSOFENUMS,
10682         }
10683 ,
10684         'tmap:out' : Hash {
10685             'typemap' : typemap(out) ARRAYSOFENUMS [ANY],
10686             'code' : $result = SWIG_JavaArrayOutInt(jenv, (int *)$1, $1_dim0); ,
10687             'type' : a(ANY).ARRAYSOFENUMS,
10688         }
10689 ,
10690         'tmap:javaout' : Hash {
10691             'typemap' : typemap(javaout) ARRAYSOFENUMS [ANY],
10692             'code' : {
10693     return $jnicall;
10694   },
10695             'type' : a(ANY).ARRAYSOFENUMS,
10696         }
10697 ,
10698     }
10699 ,
10700     'a().ARRAYSOFENUMS' : Hash {
10701         'tmap:in' : Hash {
10702             'locals' : Hash {
10703                 'name' : jarr,
10704                 'type' : p.jint,
10705             }
10706 ,
10707             'kwargs' : Hash {
10708                 'name' : numinputs,
10709                 'value' : 1,
10710             }
10711 ,
10712             'typemap' : typemap(in) ARRAYSOFENUMS [],
10713             'code' :   if (!SWIG_JavaArrayInInt(jenv, &jarr, (int **)&$1, $input)) return $null; ,
10714             'type' : a().ARRAYSOFENUMS,
10715         }
10716 ,
10717     }
10718 ,
10719     'unsigned long' : Hash {
10720         'tmap:jstype' : Hash {
10721             'typemap' : typemap(jstype) unsigned long,
10722             'code' : long,
10723             'type' : unsigned long,
10724         }
10725 ,
10726         'tmap:directorin' : Hash {
10727             'kwargs' : Hash {
10728                 'name' : descriptor,
10729                 'value' : J,
10730             }
10731 ,
10732             'typemap' : typemap(directorin) unsigned long,
10733             'code' : $input = (jlong) $1;,
10734             'type' : unsigned long,
10735         }
10736 ,
10737         'tmap:javadirectorin' : Hash {
10738             'typemap' : typemap(javadirectorin) unsigned long,
10739             'code' : $jniinput,
10740             'type' : unsigned long,
10741         }
10742 ,
10743         'tmap:in' : Hash {
10744             'kwargs' : Hash {
10745                 'name' : numinputs,
10746                 'value' : 1,
10747             }
10748 ,
10749             'typemap' : typemap(in) unsigned long,
10750             'code' :  $1 = ($1_ltype)$input; ,
10751             'type' : unsigned long,
10752         }
10753 ,
10754         'tmap:directorout' : Hash {
10755             'typemap' : typemap(directorout) unsigned long,
10756             'code' :  $result = ($1_ltype)$input; ,
10757             'type' : unsigned long,
10758         }
10759 ,
10760         'tmap:javadirectorout' : Hash {
10761             'typemap' : typemap(javadirectorout) unsigned long,
10762             'code' : $javacall,
10763             'type' : unsigned long,
10764         }
10765 ,
10766         'tmap:jni' : Hash {
10767             'typemap' : typemap(jni) unsigned long,
10768             'code' : jlong,
10769             'type' : unsigned long,
10770         }
10771 ,
10772         'tmap:jtype' : Hash {
10773             'typemap' : typemap(jtype) unsigned long,
10774             'code' : long,
10775             'type' : unsigned long,
10776         }
10777 ,
10778         'tmap:out' : Hash {
10779             'typemap' : typemap(out) unsigned long,
10780             'code' :  $result = (jlong)$1; ,
10781             'type' : unsigned long,
10782         }
10783 ,
10784         'tmap:typecheck' : Hash {
10785             'kwargs' : Hash {
10786                 'name' : precedence,
10787                 'value' : 55,
10788             }
10789 ,
10790             'typemap' : typemap(typecheck) unsigned long,
10791             'code' : ,
10792             'type' : unsigned long,
10793         }
10794 ,
10795         'tmap:throws' : Hash {
10796             'typemap' : typemap(throws) unsigned long,
10797             'code' :  char error_msg[256];
10798    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
10799    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
10800    return $null; ,
10801             'type' : unsigned long,
10802         }
10803 ,
10804         'tmap:javain' : Hash {
10805             'typemap' : typemap(javain) unsigned long,
10806             'code' : $javainput,
10807             'type' : unsigned long,
10808         }
10809 ,
10810         'tmap:javaout' : Hash {
10811             'typemap' : typemap(javaout) unsigned long,
10812             'code' : {
10813     return $jnicall;
10814   },
10815             'type' : unsigned long,
10816         }
10817 ,
10818     }
10819 ,
10820     'r.q(const).unsigned long' : Hash {
10821         'tmap:jstype' : Hash {
10822             'typemap' : typemap(jstype) unsigned long const &,
10823             'code' : long,
10824             'type' : r.q(const).unsigned long,
10825         }
10826 ,
10827         'tmap:directorin' : Hash {
10828             'kwargs' : Hash {
10829                 'name' : descriptor,
10830                 'value' : J,
10831             }
10832 ,
10833             'typemap' : typemap(directorin) unsigned long const &,
10834             'code' : $input = (jlong)$1_name;,
10835             'type' : r.q(const).unsigned long,
10836         }
10837 ,
10838         'tmap:javadirectorin' : Hash {
10839             'locals' : Hash {
10840                 'name' : temp,
10841                 'type' : $*1_ltype,
10842             }
10843 ,
10844             'typemap' : typemap(javadirectorin) unsigned long const &,
10845             'code' : $jniinput,
10846             'type' : r.q(const).unsigned long,
10847         }
10848 ,
10849         'tmap:in' : Hash {
10850             'locals' : Hash {
10851                 'name' : temp,
10852                 'type' : $*1_ltype,
10853             }
10854 ,
10855             'kwargs' : Hash {
10856                 'name' : numinputs,
10857                 'value' : 1,
10858             }
10859 ,
10860             'typemap' : typemap(in) unsigned long const &,
10861             'code' :  temp = ($*1_ltype)$input;
10862    $1 = &temp; ,
10863             'type' : r.q(const).unsigned long,
10864         }
10865 ,
10866         'tmap:directorout' : Hash {
10867             'kwargs' : Hash {
10868                 'name' : warning,
10869                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
10870             }
10871 ,
10872             'typemap' : typemap(directorout) unsigned long const &,
10873             'code' :  static $*1_ltype temp;
10874    temp = ($*1_ltype)$input;
10875    $result = &temp; ,
10876             'type' : r.q(const).unsigned long,
10877         }
10878 ,
10879         'tmap:javadirectorout' : Hash {
10880             'locals' : Hash {
10881                 'name' : temp,
10882                 'type' : $*1_ltype,
10883             }
10884 ,
10885             'typemap' : typemap(javadirectorout) unsigned long const &,
10886             'code' : $javacall,
10887             'type' : r.q(const).unsigned long,
10888         }
10889 ,
10890         'tmap:jni' : Hash {
10891             'typemap' : typemap(jni) unsigned long const &,
10892             'code' : jlong,
10893             'type' : r.q(const).unsigned long,
10894         }
10895 ,
10896         'tmap:jtype' : Hash {
10897             'typemap' : typemap(jtype) unsigned long const &,
10898             'code' : long,
10899             'type' : r.q(const).unsigned long,
10900         }
10901 ,
10902         'tmap:out' : Hash {
10903             'typemap' : typemap(out) unsigned long const &,
10904             'code' :  $result = (jlong)*$1; ,
10905             'type' : r.q(const).unsigned long,
10906         }
10907 ,
10908         'tmap:typecheck' : Hash {
10909             'kwargs' : Hash {
10910                 'name' : precedence,
10911                 'value' : 55,
10912             }
10913 ,
10914             'typemap' : typemap(typecheck) unsigned long const &,
10915             'code' : ,
10916             'type' : r.q(const).unsigned long,
10917         }
10918 ,
10919         'tmap:javain' : Hash {
10920             'typemap' : typemap(javain) unsigned long const &,
10921             'code' : $javainput,
10922             'type' : r.q(const).unsigned long,
10923         }
10924 ,
10925         'tmap:javaout' : Hash {
10926             'typemap' : typemap(javaout) unsigned long const &,
10927             'code' : {
10928     return $jnicall;
10929   },
10930             'type' : r.q(const).unsigned long,
10931         }
10932 ,
10933     }
10934 ,
10935     'p.long' : Hash {
10936         'INOUT' : Hash {
10937             'tmap:freearg' : Hash {
10938                 'pname' : INOUT,
10939                 'typemap' : typemap(freearg) long *INOUT,
10940                 'code' : ,
10941                 'type' : p.long,
10942             }
10943 ,
10944             'tmap:jstype' : Hash {
10945                 'pname' : INOUT,
10946                 'typemap' : typemap(jstype) long *INOUT,
10947                 'code' : int[],
10948                 'type' : p.long,
10949             }
10950 ,
10951             'tmap:javadirectorin' : Hash {
10952                 'pname' : INOUT,
10953                 'typemap' : typemap(javadirectorin) long *INOUT,
10954                 'code' : $jniinput,
10955                 'type' : p.long,
10956             }
10957 ,
10958             'tmap:directorin' : Hash {
10959                 'kwargs' : Hash {
10960                     'name' : descriptor,
10961                     'value' : [Ljava/lang/Integer;,
10962                     'nextSibling' : Hash {
10963                         'name' : warning,
10964                         'value' : Need to provide long *INOUT directorin typemap, long array length is unknown,
10965                     }
10966 ,
10967                 }
10968 ,
10969                 'pname' : INOUT,
10970                 'typemap' : typemap(directorin) long *INOUT,
10971                 'code' : {
10972 },
10973                 'type' : p.long,
10974             }
10975 ,
10976             'tmap:argout' : Hash {
10977                 'pname' : INOUT,
10978                 'typemap' : typemap(argout) long *INOUT,
10979                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
10980                 'type' : p.long,
10981             }
10982 ,
10983             'tmap:javadirectorout' : Hash {
10984                 'pname' : INOUT,
10985                 'typemap' : typemap(javadirectorout) long *INOUT,
10986                 'code' : $javacall,
10987                 'type' : p.long,
10988             }
10989 ,
10990             'tmap:in' : Hash {
10991                 'kwargs' : Hash {
10992                     'name' : numinputs,
10993                     'value' : 1,
10994                 }
10995 ,
10996                 'pname' : INOUT,
10997                 'typemap' : typemap(in) long *INOUT,
10998                 'code' : {
10999   if (!$input) {
11000     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11001     return $null;
11002   }
11003   if (jenv->GetArrayLength($input) == 0) {
11004     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11005     return $null;
11006   }
11007   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
11008 },
11009                 'type' : p.long,
11010             }
11011 ,
11012             'tmap:directorout' : Hash {
11013                 'kwargs' : Hash {
11014                     'name' : warning,
11015                     'value' : Need to provide long *INOUT directorout typemap,
11016                 }
11017 ,
11018                 'pname' : INOUT,
11019                 'typemap' : typemap(directorout) long *INOUT,
11020                 'code' : {
11021 },
11022                 'type' : p.long,
11023             }
11024 ,
11025             'tmap:typecheck' : Hash {
11026                 'kwargs' : Hash {
11027                     'name' : precedence,
11028                     'value' : 1045,
11029                 }
11030 ,
11031                 'pname' : INOUT,
11032                 'typemap' : typemap(typecheck) long *INOUT,
11033                 'code' : ,
11034                 'type' : p.long,
11035             }
11036 ,
11037             'tmap:jni' : Hash {
11038                 'pname' : INOUT,
11039                 'typemap' : typemap(jni) long *INOUT,
11040                 'code' : jintArray,
11041                 'type' : p.long,
11042             }
11043 ,
11044             'tmap:jtype' : Hash {
11045                 'pname' : INOUT,
11046                 'typemap' : typemap(jtype) long *INOUT,
11047                 'code' : int[],
11048                 'type' : p.long,
11049             }
11050 ,
11051             'tmap:javain' : Hash {
11052                 'pname' : INOUT,
11053                 'typemap' : typemap(javain) long *INOUT,
11054                 'code' : $javainput,
11055                 'type' : p.long,
11056             }
11057 ,
11058         }
11059 ,
11060         'INPUT' : Hash {
11061             'tmap:freearg' : Hash {
11062                 'pname' : INPUT,
11063                 'typemap' : typemap(freearg) long *INPUT,
11064                 'code' : ,
11065                 'type' : p.long,
11066             }
11067 ,
11068             'tmap:jstype' : Hash {
11069                 'pname' : INPUT,
11070                 'typemap' : typemap(jstype) long *INPUT,
11071                 'code' : int,
11072                 'type' : p.long,
11073             }
11074 ,
11075             'tmap:javadirectorin' : Hash {
11076                 'pname' : INPUT,
11077                 'typemap' : typemap(javadirectorin) long *INPUT,
11078                 'code' : $jniinput,
11079                 'type' : p.long,
11080             }
11081 ,
11082             'tmap:directorin' : Hash {
11083                 'kwargs' : Hash {
11084                     'name' : descriptor,
11085                     'value' : I,
11086                 }
11087 ,
11088                 'pname' : INPUT,
11089                 'typemap' : typemap(directorin) long *INPUT,
11090                 'code' :  *(($&1_ltype) $input) = (jint *) $1; ,
11091                 'type' : p.long,
11092             }
11093 ,
11094             'tmap:javadirectorout' : Hash {
11095                 'pname' : INPUT,
11096                 'typemap' : typemap(javadirectorout) long *INPUT,
11097                 'code' : $javacall,
11098                 'type' : p.long,
11099             }
11100 ,
11101             'tmap:in' : Hash {
11102                 'kwargs' : Hash {
11103                     'name' : numinputs,
11104                     'value' : 1,
11105                 }
11106 ,
11107                 'pname' : INPUT,
11108                 'typemap' : typemap(in) long *INPUT,
11109                 'code' :  $1 = ($1_ltype)&$input; ,
11110                 'type' : p.long,
11111             }
11112 ,
11113             'tmap:directorout' : Hash {
11114                 'pname' : INPUT,
11115                 'typemap' : typemap(directorout) long *INPUT,
11116                 'code' :  $result = ($1_ltype)&$input; ,
11117                 'type' : p.long,
11118             }
11119 ,
11120             'tmap:jni' : Hash {
11121                 'pname' : INPUT,
11122                 'typemap' : typemap(jni) long *INPUT,
11123                 'code' : jint,
11124                 'type' : p.long,
11125             }
11126 ,
11127             'tmap:jtype' : Hash {
11128                 'pname' : INPUT,
11129                 'typemap' : typemap(jtype) long *INPUT,
11130                 'code' : int,
11131                 'type' : p.long,
11132             }
11133 ,
11134             'tmap:javain' : Hash {
11135                 'pname' : INPUT,
11136                 'typemap' : typemap(javain) long *INPUT,
11137                 'code' : $javainput,
11138                 'type' : p.long,
11139             }
11140 ,
11141             'tmap:typecheck' : Hash {
11142                 'kwargs' : Hash {
11143                     'name' : precedence,
11144                     'value' : 45,
11145                 }
11146 ,
11147                 'pname' : INPUT,
11148                 'typemap' : typemap(typecheck) long *INPUT,
11149                 'code' : ,
11150                 'type' : p.long,
11151             }
11152 ,
11153         }
11154 ,
11155         'OUTPUT' : Hash {
11156             'tmap:freearg' : Hash {
11157                 'pname' : OUTPUT,
11158                 'typemap' : typemap(freearg) long *OUTPUT,
11159                 'code' : ,
11160                 'type' : p.long,
11161             }
11162 ,
11163             'tmap:jstype' : Hash {
11164                 'pname' : OUTPUT,
11165                 'typemap' : typemap(jstype) long *OUTPUT,
11166                 'code' : int[],
11167                 'type' : p.long,
11168             }
11169 ,
11170             'tmap:javadirectorin' : Hash {
11171                 'pname' : OUTPUT,
11172                 'typemap' : typemap(javadirectorin) long *OUTPUT,
11173                 'code' : $jniinput,
11174                 'type' : p.long,
11175             }
11176 ,
11177             'tmap:directorin' : Hash {
11178                 'kwargs' : Hash {
11179                     'name' : descriptor,
11180                     'value' : [Ljava/lang/Integer;,
11181                     'nextSibling' : Hash {
11182                         'name' : warning,
11183                         'value' : Need to provide long *OUTPUT directorin typemap, long array length is unknown,
11184                     }
11185 ,
11186                 }
11187 ,
11188                 'pname' : OUTPUT,
11189                 'typemap' : typemap(directorin) long *OUTPUT,
11190                 'code' : {
11191 },
11192                 'type' : p.long,
11193             }
11194 ,
11195             'tmap:argout' : Hash {
11196                 'pname' : OUTPUT,
11197                 'typemap' : typemap(argout) long *OUTPUT,
11198                 'code' : {
11199   jint jvalue = (jint)temp$argnum;
11200   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
11201 },
11202                 'type' : p.long,
11203             }
11204 ,
11205             'tmap:javadirectorout' : Hash {
11206                 'pname' : OUTPUT,
11207                 'typemap' : typemap(javadirectorout) long *OUTPUT,
11208                 'code' : $javacall,
11209                 'type' : p.long,
11210             }
11211 ,
11212             'tmap:in' : Hash {
11213                 'locals' : Hash {
11214                     'name' : temp,
11215                     'type' : $*1_ltype,
11216                 }
11217 ,
11218                 'kwargs' : Hash {
11219                     'name' : numinputs,
11220                     'value' : 1,
11221                 }
11222 ,
11223                 'pname' : OUTPUT,
11224                 'typemap' : typemap(in) long *OUTPUT,
11225                 'code' : {
11226   if (!$input) {
11227     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11228     return $null;
11229   }
11230   if (jenv->GetArrayLength($input) == 0) {
11231     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11232     return $null;
11233   }
11234   $1 = &temp;
11235 },
11236                 'type' : p.long,
11237             }
11238 ,
11239             'tmap:directorout' : Hash {
11240                 'kwargs' : Hash {
11241                     'name' : warning,
11242                     'value' : Need to provide long *OUTPUT directorout typemap,
11243                 }
11244 ,
11245                 'pname' : OUTPUT,
11246                 'typemap' : typemap(directorout) long *OUTPUT,
11247                 'code' : {
11248 },
11249                 'type' : p.long,
11250             }
11251 ,
11252             'tmap:jni' : Hash {
11253                 'pname' : OUTPUT,
11254                 'typemap' : typemap(jni) long *OUTPUT,
11255                 'code' : jintArray,
11256                 'type' : p.long,
11257             }
11258 ,
11259             'tmap:jtype' : Hash {
11260                 'pname' : OUTPUT,
11261                 'typemap' : typemap(jtype) long *OUTPUT,
11262                 'code' : int[],
11263                 'type' : p.long,
11264             }
11265 ,
11266             'tmap:javain' : Hash {
11267                 'pname' : OUTPUT,
11268                 'typemap' : typemap(javain) long *OUTPUT,
11269                 'code' : $javainput,
11270                 'type' : p.long,
11271             }
11272 ,
11273         }
11274 ,
11275     }
11276 ,
11277     'p.unsigned long' : Hash {
11278         'INOUT' : Hash {
11279             'tmap:freearg' : Hash {
11280                 'pname' : INOUT,
11281                 'typemap' : typemap(freearg) unsigned long *INOUT,
11282                 'code' : ,
11283                 'type' : p.unsigned long,
11284             }
11285 ,
11286             'tmap:jstype' : Hash {
11287                 'pname' : INOUT,
11288                 'typemap' : typemap(jstype) unsigned long *INOUT,
11289                 'code' : long[],
11290                 'type' : p.unsigned long,
11291             }
11292 ,
11293             'tmap:javadirectorin' : Hash {
11294                 'pname' : INOUT,
11295                 'typemap' : typemap(javadirectorin) unsigned long *INOUT,
11296                 'code' : $jniinput,
11297                 'type' : p.unsigned long,
11298             }
11299 ,
11300             'tmap:directorin' : Hash {
11301                 'kwargs' : Hash {
11302                     'name' : descriptor,
11303                     'value' : [Ljava/lang/Long;,
11304                     'nextSibling' : Hash {
11305                         'name' : warning,
11306                         'value' : Need to provide unsigned long *INOUT directorin typemap, unsigned long array length is unknown,
11307                     }
11308 ,
11309                 }
11310 ,
11311                 'pname' : INOUT,
11312                 'typemap' : typemap(directorin) unsigned long *INOUT,
11313                 'code' : {
11314 },
11315                 'type' : p.unsigned long,
11316             }
11317 ,
11318             'tmap:argout' : Hash {
11319                 'pname' : INOUT,
11320                 'typemap' : typemap(argout) unsigned long *INOUT,
11321                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
11322                 'type' : p.unsigned long,
11323             }
11324 ,
11325             'tmap:javadirectorout' : Hash {
11326                 'pname' : INOUT,
11327                 'typemap' : typemap(javadirectorout) unsigned long *INOUT,
11328                 'code' : $javacall,
11329                 'type' : p.unsigned long,
11330             }
11331 ,
11332             'tmap:in' : Hash {
11333                 'kwargs' : Hash {
11334                     'name' : numinputs,
11335                     'value' : 1,
11336                 }
11337 ,
11338                 'pname' : INOUT,
11339                 'typemap' : typemap(in) unsigned long *INOUT,
11340                 'code' : {
11341   if (!$input) {
11342     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11343     return $null;
11344   }
11345   if (jenv->GetArrayLength($input) == 0) {
11346     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11347     return $null;
11348   }
11349   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
11350 },
11351                 'type' : p.unsigned long,
11352             }
11353 ,
11354             'tmap:directorout' : Hash {
11355                 'kwargs' : Hash {
11356                     'name' : warning,
11357                     'value' : Need to provide unsigned long *INOUT directorout typemap,
11358                 }
11359 ,
11360                 'pname' : INOUT,
11361                 'typemap' : typemap(directorout) unsigned long *INOUT,
11362                 'code' : {
11363 },
11364                 'type' : p.unsigned long,
11365             }
11366 ,
11367             'tmap:typecheck' : Hash {
11368                 'kwargs' : Hash {
11369                     'name' : precedence,
11370                     'value' : 1055,
11371                 }
11372 ,
11373                 'pname' : INOUT,
11374                 'typemap' : typemap(typecheck) unsigned long *INOUT,
11375                 'code' : ,
11376                 'type' : p.unsigned long,
11377             }
11378 ,
11379             'tmap:jni' : Hash {
11380                 'pname' : INOUT,
11381                 'typemap' : typemap(jni) unsigned long *INOUT,
11382                 'code' : jlongArray,
11383                 'type' : p.unsigned long,
11384             }
11385 ,
11386             'tmap:jtype' : Hash {
11387                 'pname' : INOUT,
11388                 'typemap' : typemap(jtype) unsigned long *INOUT,
11389                 'code' : long[],
11390                 'type' : p.unsigned long,
11391             }
11392 ,
11393             'tmap:javain' : Hash {
11394                 'pname' : INOUT,
11395                 'typemap' : typemap(javain) unsigned long *INOUT,
11396                 'code' : $javainput,
11397                 'type' : p.unsigned long,
11398             }
11399 ,
11400         }
11401 ,
11402         'INPUT' : Hash {
11403             'tmap:freearg' : Hash {
11404                 'pname' : INPUT,
11405                 'typemap' : typemap(freearg) unsigned long *INPUT,
11406                 'code' : ,
11407                 'type' : p.unsigned long,
11408             }
11409 ,
11410             'tmap:jstype' : Hash {
11411                 'pname' : INPUT,
11412                 'typemap' : typemap(jstype) unsigned long *INPUT,
11413                 'code' : long,
11414                 'type' : p.unsigned long,
11415             }
11416 ,
11417             'tmap:javadirectorin' : Hash {
11418                 'pname' : INPUT,
11419                 'typemap' : typemap(javadirectorin) unsigned long *INPUT,
11420                 'code' : $jniinput,
11421                 'type' : p.unsigned long,
11422             }
11423 ,
11424             'tmap:directorin' : Hash {
11425                 'kwargs' : Hash {
11426                     'name' : descriptor,
11427                     'value' : J,
11428                 }
11429 ,
11430                 'pname' : INPUT,
11431                 'typemap' : typemap(directorin) unsigned long *INPUT,
11432                 'code' :  *(($&1_ltype) $input) = (jlong *) $1; ,
11433                 'type' : p.unsigned long,
11434             }
11435 ,
11436             'tmap:javadirectorout' : Hash {
11437                 'pname' : INPUT,
11438                 'typemap' : typemap(javadirectorout) unsigned long *INPUT,
11439                 'code' : $javacall,
11440                 'type' : p.unsigned long,
11441             }
11442 ,
11443             'tmap:in' : Hash {
11444                 'kwargs' : Hash {
11445                     'name' : numinputs,
11446                     'value' : 1,
11447                 }
11448 ,
11449                 'pname' : INPUT,
11450                 'typemap' : typemap(in) unsigned long *INPUT,
11451                 'code' :  $1 = ($1_ltype)&$input; ,
11452                 'type' : p.unsigned long,
11453             }
11454 ,
11455             'tmap:directorout' : Hash {
11456                 'pname' : INPUT,
11457                 'typemap' : typemap(directorout) unsigned long *INPUT,
11458                 'code' :  $result = ($1_ltype)&$input; ,
11459                 'type' : p.unsigned long,
11460             }
11461 ,
11462             'tmap:jni' : Hash {
11463                 'pname' : INPUT,
11464                 'typemap' : typemap(jni) unsigned long *INPUT,
11465                 'code' : jlong,
11466                 'type' : p.unsigned long,
11467             }
11468 ,
11469             'tmap:jtype' : Hash {
11470                 'pname' : INPUT,
11471                 'typemap' : typemap(jtype) unsigned long *INPUT,
11472                 'code' : long,
11473                 'type' : p.unsigned long,
11474             }
11475 ,
11476             'tmap:javain' : Hash {
11477                 'pname' : INPUT,
11478                 'typemap' : typemap(javain) unsigned long *INPUT,
11479                 'code' : $javainput,
11480                 'type' : p.unsigned long,
11481             }
11482 ,
11483             'tmap:typecheck' : Hash {
11484                 'kwargs' : Hash {
11485                     'name' : precedence,
11486                     'value' : 55,
11487                 }
11488 ,
11489                 'pname' : INPUT,
11490                 'typemap' : typemap(typecheck) unsigned long *INPUT,
11491                 'code' : ,
11492                 'type' : p.unsigned long,
11493             }
11494 ,
11495         }
11496 ,
11497         'OUTPUT' : Hash {
11498             'tmap:freearg' : Hash {
11499                 'pname' : OUTPUT,
11500                 'typemap' : typemap(freearg) unsigned long *OUTPUT,
11501                 'code' : ,
11502                 'type' : p.unsigned long,
11503             }
11504 ,
11505             'tmap:jstype' : Hash {
11506                 'pname' : OUTPUT,
11507                 'typemap' : typemap(jstype) unsigned long *OUTPUT,
11508                 'code' : long[],
11509                 'type' : p.unsigned long,
11510             }
11511 ,
11512             'tmap:javadirectorin' : Hash {
11513                 'pname' : OUTPUT,
11514                 'typemap' : typemap(javadirectorin) unsigned long *OUTPUT,
11515                 'code' : $jniinput,
11516                 'type' : p.unsigned long,
11517             }
11518 ,
11519             'tmap:directorin' : Hash {
11520                 'kwargs' : Hash {
11521                     'name' : descriptor,
11522                     'value' : [Ljava/lang/Long;,
11523                     'nextSibling' : Hash {
11524                         'name' : warning,
11525                         'value' : Need to provide unsigned long *OUTPUT directorin typemap, unsigned long array length is unknown,
11526                     }
11527 ,
11528                 }
11529 ,
11530                 'pname' : OUTPUT,
11531                 'typemap' : typemap(directorin) unsigned long *OUTPUT,
11532                 'code' : {
11533 },
11534                 'type' : p.unsigned long,
11535             }
11536 ,
11537             'tmap:argout' : Hash {
11538                 'pname' : OUTPUT,
11539                 'typemap' : typemap(argout) unsigned long *OUTPUT,
11540                 'code' : {
11541   jlong jvalue = (jlong)temp$argnum;
11542   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
11543 },
11544                 'type' : p.unsigned long,
11545             }
11546 ,
11547             'tmap:javadirectorout' : Hash {
11548                 'pname' : OUTPUT,
11549                 'typemap' : typemap(javadirectorout) unsigned long *OUTPUT,
11550                 'code' : $javacall,
11551                 'type' : p.unsigned long,
11552             }
11553 ,
11554             'tmap:in' : Hash {
11555                 'locals' : Hash {
11556                     'name' : temp,
11557                     'type' : $*1_ltype,
11558                 }
11559 ,
11560                 'kwargs' : Hash {
11561                     'name' : numinputs,
11562                     'value' : 1,
11563                 }
11564 ,
11565                 'pname' : OUTPUT,
11566                 'typemap' : typemap(in) unsigned long *OUTPUT,
11567                 'code' : {
11568   if (!$input) {
11569     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11570     return $null;
11571   }
11572   if (jenv->GetArrayLength($input) == 0) {
11573     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11574     return $null;
11575   }
11576   $1 = &temp;
11577 },
11578                 'type' : p.unsigned long,
11579             }
11580 ,
11581             'tmap:directorout' : Hash {
11582                 'kwargs' : Hash {
11583                     'name' : warning,
11584                     'value' : Need to provide unsigned long *OUTPUT directorout typemap,
11585                 }
11586 ,
11587                 'pname' : OUTPUT,
11588                 'typemap' : typemap(directorout) unsigned long *OUTPUT,
11589                 'code' : {
11590 },
11591                 'type' : p.unsigned long,
11592             }
11593 ,
11594             'tmap:jni' : Hash {
11595                 'pname' : OUTPUT,
11596                 'typemap' : typemap(jni) unsigned long *OUTPUT,
11597                 'code' : jlongArray,
11598                 'type' : p.unsigned long,
11599             }
11600 ,
11601             'tmap:jtype' : Hash {
11602                 'pname' : OUTPUT,
11603                 'typemap' : typemap(jtype) unsigned long *OUTPUT,
11604                 'code' : long[],
11605                 'type' : p.unsigned long,
11606             }
11607 ,
11608             'tmap:javain' : Hash {
11609                 'pname' : OUTPUT,
11610                 'typemap' : typemap(javain) unsigned long *OUTPUT,
11611                 'code' : $javainput,
11612                 'type' : p.unsigned long,
11613             }
11614 ,
11615         }
11616 ,
11617     }
11618 ,
11619     'r.unsigned long' : Hash {
11620         'INOUT' : Hash {
11621             'tmap:freearg' : Hash {
11622                 'pname' : INOUT,
11623                 'typemap' : typemap(freearg) unsigned long &INOUT,
11624                 'code' : ,
11625                 'type' : r.unsigned long,
11626             }
11627 ,
11628             'tmap:jstype' : Hash {
11629                 'pname' : INOUT,
11630                 'typemap' : typemap(jstype) unsigned long &INOUT,
11631                 'code' : long[],
11632                 'type' : r.unsigned long,
11633             }
11634 ,
11635             'tmap:javadirectorin' : Hash {
11636                 'pname' : INOUT,
11637                 'typemap' : typemap(javadirectorin) unsigned long &INOUT,
11638                 'code' : $jniinput,
11639                 'type' : r.unsigned long,
11640             }
11641 ,
11642             'tmap:directorin' : Hash {
11643                 'kwargs' : Hash {
11644                     'name' : descriptor,
11645                     'value' : [Ljava/lang/Long;,
11646                     'nextSibling' : Hash {
11647                         'name' : warning,
11648                         'value' : Need to provide unsigned long *INOUT directorin typemap, unsigned long array length is unknown,
11649                     }
11650 ,
11651                 }
11652 ,
11653                 'pname' : INOUT,
11654                 'typemap' : typemap(directorin) unsigned long &INOUT,
11655                 'code' : {
11656 },
11657                 'type' : r.unsigned long,
11658             }
11659 ,
11660             'tmap:argout' : Hash {
11661                 'pname' : INOUT,
11662                 'typemap' : typemap(argout) unsigned long &INOUT,
11663                 'code' : { jenv->ReleaseLongArrayElements($input, (jlong *)$1, 0); },
11664                 'type' : r.unsigned long,
11665             }
11666 ,
11667             'tmap:javadirectorout' : Hash {
11668                 'pname' : INOUT,
11669                 'typemap' : typemap(javadirectorout) unsigned long &INOUT,
11670                 'code' : $javacall,
11671                 'type' : r.unsigned long,
11672             }
11673 ,
11674             'tmap:in' : Hash {
11675                 'kwargs' : Hash {
11676                     'name' : numinputs,
11677                     'value' : 1,
11678                 }
11679 ,
11680                 'pname' : INOUT,
11681                 'typemap' : typemap(in) unsigned long &INOUT,
11682                 'code' : {
11683   if (!$input) {
11684     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11685     return $null;
11686   }
11687   if (jenv->GetArrayLength($input) == 0) {
11688     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11689     return $null;
11690   }
11691   $1 = ($1_ltype) jenv->GetLongArrayElements($input, 0);
11692 },
11693                 'type' : r.unsigned long,
11694             }
11695 ,
11696             'tmap:directorout' : Hash {
11697                 'kwargs' : Hash {
11698                     'name' : warning,
11699                     'value' : Need to provide unsigned long *INOUT directorout typemap,
11700                 }
11701 ,
11702                 'pname' : INOUT,
11703                 'typemap' : typemap(directorout) unsigned long &INOUT,
11704                 'code' : {
11705 },
11706                 'type' : r.unsigned long,
11707             }
11708 ,
11709             'tmap:typecheck' : Hash {
11710                 'kwargs' : Hash {
11711                     'name' : precedence,
11712                     'value' : 1055,
11713                 }
11714 ,
11715                 'pname' : INOUT,
11716                 'typemap' : typemap(typecheck) unsigned long &INOUT,
11717                 'code' : ,
11718                 'type' : r.unsigned long,
11719             }
11720 ,
11721             'tmap:jni' : Hash {
11722                 'pname' : INOUT,
11723                 'typemap' : typemap(jni) unsigned long &INOUT,
11724                 'code' : jlongArray,
11725                 'type' : r.unsigned long,
11726             }
11727 ,
11728             'tmap:jtype' : Hash {
11729                 'pname' : INOUT,
11730                 'typemap' : typemap(jtype) unsigned long &INOUT,
11731                 'code' : long[],
11732                 'type' : r.unsigned long,
11733             }
11734 ,
11735             'tmap:javain' : Hash {
11736                 'pname' : INOUT,
11737                 'typemap' : typemap(javain) unsigned long &INOUT,
11738                 'code' : $javainput,
11739                 'type' : r.unsigned long,
11740             }
11741 ,
11742         }
11743 ,
11744         'INPUT' : Hash {
11745             'tmap:freearg' : Hash {
11746                 'pname' : INPUT,
11747                 'typemap' : typemap(freearg) unsigned long &INPUT,
11748                 'code' : ,
11749                 'type' : r.unsigned long,
11750             }
11751 ,
11752             'tmap:jstype' : Hash {
11753                 'pname' : INPUT,
11754                 'typemap' : typemap(jstype) unsigned long &INPUT,
11755                 'code' : long,
11756                 'type' : r.unsigned long,
11757             }
11758 ,
11759             'tmap:javadirectorin' : Hash {
11760                 'pname' : INPUT,
11761                 'typemap' : typemap(javadirectorin) unsigned long &INPUT,
11762                 'code' : $jniinput,
11763                 'type' : r.unsigned long,
11764             }
11765 ,
11766             'tmap:directorin' : Hash {
11767                 'kwargs' : Hash {
11768                     'name' : descriptor,
11769                     'value' : J,
11770                 }
11771 ,
11772                 'pname' : INPUT,
11773                 'typemap' : typemap(directorin) unsigned long &INPUT,
11774                 'code' :  *(($&1_ltype) $input) = (jlong *) &$1; ,
11775                 'type' : r.unsigned long,
11776             }
11777 ,
11778             'tmap:javadirectorout' : Hash {
11779                 'pname' : INPUT,
11780                 'typemap' : typemap(javadirectorout) unsigned long &INPUT,
11781                 'code' : $javacall,
11782                 'type' : r.unsigned long,
11783             }
11784 ,
11785             'tmap:in' : Hash {
11786                 'kwargs' : Hash {
11787                     'name' : numinputs,
11788                     'value' : 1,
11789                 }
11790 ,
11791                 'pname' : INPUT,
11792                 'typemap' : typemap(in) unsigned long &INPUT,
11793                 'code' :  $1 = ($1_ltype)&$input; ,
11794                 'type' : r.unsigned long,
11795             }
11796 ,
11797             'tmap:directorout' : Hash {
11798                 'pname' : INPUT,
11799                 'typemap' : typemap(directorout) unsigned long &INPUT,
11800                 'code' :  $result = ($1_ltype)&$input; ,
11801                 'type' : r.unsigned long,
11802             }
11803 ,
11804             'tmap:jni' : Hash {
11805                 'pname' : INPUT,
11806                 'typemap' : typemap(jni) unsigned long &INPUT,
11807                 'code' : jlong,
11808                 'type' : r.unsigned long,
11809             }
11810 ,
11811             'tmap:jtype' : Hash {
11812                 'pname' : INPUT,
11813                 'typemap' : typemap(jtype) unsigned long &INPUT,
11814                 'code' : long,
11815                 'type' : r.unsigned long,
11816             }
11817 ,
11818             'tmap:javain' : Hash {
11819                 'pname' : INPUT,
11820                 'typemap' : typemap(javain) unsigned long &INPUT,
11821                 'code' : $javainput,
11822                 'type' : r.unsigned long,
11823             }
11824 ,
11825             'tmap:typecheck' : Hash {
11826                 'kwargs' : Hash {
11827                     'name' : precedence,
11828                     'value' : 55,
11829                 }
11830 ,
11831                 'pname' : INPUT,
11832                 'typemap' : typemap(typecheck) unsigned long &INPUT,
11833                 'code' : ,
11834                 'type' : r.unsigned long,
11835             }
11836 ,
11837         }
11838 ,
11839         'OUTPUT' : Hash {
11840             'tmap:freearg' : Hash {
11841                 'pname' : OUTPUT,
11842                 'typemap' : typemap(freearg) unsigned long &OUTPUT,
11843                 'code' : ,
11844                 'type' : r.unsigned long,
11845             }
11846 ,
11847             'tmap:jstype' : Hash {
11848                 'pname' : OUTPUT,
11849                 'typemap' : typemap(jstype) unsigned long &OUTPUT,
11850                 'code' : long[],
11851                 'type' : r.unsigned long,
11852             }
11853 ,
11854             'tmap:javadirectorin' : Hash {
11855                 'pname' : OUTPUT,
11856                 'typemap' : typemap(javadirectorin) unsigned long &OUTPUT,
11857                 'code' : $jniinput,
11858                 'type' : r.unsigned long,
11859             }
11860 ,
11861             'tmap:directorin' : Hash {
11862                 'kwargs' : Hash {
11863                     'name' : descriptor,
11864                     'value' : [Ljava/lang/Long;,
11865                 }
11866 ,
11867                 'pname' : OUTPUT,
11868                 'typemap' : typemap(directorin) unsigned long &OUTPUT,
11869                 'code' :  *(($&1_ltype) $input = &$1; ,
11870                 'type' : r.unsigned long,
11871             }
11872 ,
11873             'tmap:argout' : Hash {
11874                 'pname' : OUTPUT,
11875                 'typemap' : typemap(argout) unsigned long &OUTPUT,
11876                 'code' : {
11877   jlong jvalue = (jlong)temp$argnum;
11878   jenv->SetLongArrayRegion($input, 0, 1, &jvalue);
11879 },
11880                 'type' : r.unsigned long,
11881             }
11882 ,
11883             'tmap:javadirectorout' : Hash {
11884                 'pname' : OUTPUT,
11885                 'typemap' : typemap(javadirectorout) unsigned long &OUTPUT,
11886                 'code' : $javacall,
11887                 'type' : r.unsigned long,
11888             }
11889 ,
11890             'tmap:in' : Hash {
11891                 'locals' : Hash {
11892                     'name' : temp,
11893                     'type' : $*1_ltype,
11894                 }
11895 ,
11896                 'kwargs' : Hash {
11897                     'name' : numinputs,
11898                     'value' : 1,
11899                 }
11900 ,
11901                 'pname' : OUTPUT,
11902                 'typemap' : typemap(in) unsigned long &OUTPUT,
11903                 'code' : {
11904   if (!$input) {
11905     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
11906     return $null;
11907   }
11908   if (jenv->GetArrayLength($input) == 0) {
11909     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
11910     return $null;
11911   }
11912   $1 = &temp;
11913 },
11914                 'type' : r.unsigned long,
11915             }
11916 ,
11917             'tmap:directorout' : Hash {
11918                 'kwargs' : Hash {
11919                     'name' : warning,
11920                     'value' : Need to provide unsigned long *OUTPUT directorout typemap,
11921                 }
11922 ,
11923                 'pname' : OUTPUT,
11924                 'typemap' : typemap(directorout) unsigned long &OUTPUT,
11925                 'code' : {
11926 },
11927                 'type' : r.unsigned long,
11928             }
11929 ,
11930             'tmap:jni' : Hash {
11931                 'pname' : OUTPUT,
11932                 'typemap' : typemap(jni) unsigned long &OUTPUT,
11933                 'code' : jlongArray,
11934                 'type' : r.unsigned long,
11935             }
11936 ,
11937             'tmap:jtype' : Hash {
11938                 'pname' : OUTPUT,
11939                 'typemap' : typemap(jtype) unsigned long &OUTPUT,
11940                 'code' : long[],
11941                 'type' : r.unsigned long,
11942             }
11943 ,
11944             'tmap:javain' : Hash {
11945                 'pname' : OUTPUT,
11946                 'typemap' : typemap(javain) unsigned long &OUTPUT,
11947                 'code' : $javainput,
11948                 'type' : r.unsigned long,
11949             }
11950 ,
11951         }
11952 ,
11953     }
11954 ,
11955     'a(ANY).unsigned long' : Hash {
11956         'tmap:freearg' : Hash {
11957             'typemap' : typemap(freearg) unsigned long [ANY],
11958             'code' :  delete [] $1; ,
11959             'type' : a(ANY).unsigned long,
11960         }
11961 ,
11962         'tmap:jstype' : Hash {
11963             'typemap' : typemap(jstype) unsigned long [ANY],
11964             'code' : long[],
11965             'type' : a(ANY).unsigned long,
11966         }
11967 ,
11968         'tmap:argout' : Hash {
11969             'typemap' : typemap(argout) unsigned long [ANY],
11970             'code' :  SWIG_JavaArrayArgoutUlong(jenv, jarr$argnum, $1, $input); ,
11971             'type' : a(ANY).unsigned long,
11972         }
11973 ,
11974         'tmap:in' : Hash {
11975             'locals' : Hash {
11976                 'name' : jarr,
11977                 'type' : p.jlong,
11978             }
11979 ,
11980             'kwargs' : Hash {
11981                 'name' : numinputs,
11982                 'value' : 1,
11983             }
11984 ,
11985             'typemap' : typemap(in) unsigned long [ANY],
11986             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
11987     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
11988     return $null;
11989   }
11990   if (!SWIG_JavaArrayInUlong(jenv, &jarr, &$1, $input)) return $null; ,
11991             'type' : a(ANY).unsigned long,
11992         }
11993 ,
11994         'tmap:jni' : Hash {
11995             'typemap' : typemap(jni) unsigned long [ANY],
11996             'code' : jlongArray,
11997             'type' : a(ANY).unsigned long,
11998         }
11999 ,
12000         'tmap:jtype' : Hash {
12001             'typemap' : typemap(jtype) unsigned long [ANY],
12002             'code' : long[],
12003             'type' : a(ANY).unsigned long,
12004         }
12005 ,
12006         'tmap:out' : Hash {
12007             'typemap' : typemap(out) unsigned long [ANY],
12008             'code' : $result = SWIG_JavaArrayOutUlong(jenv, $1, $1_dim0); ,
12009             'type' : a(ANY).unsigned long,
12010         }
12011 ,
12012         'tmap:javain' : Hash {
12013             'typemap' : typemap(javain) unsigned long [ANY],
12014             'code' : $javainput,
12015             'type' : a(ANY).unsigned long,
12016         }
12017 ,
12018         'tmap:typecheck' : Hash {
12019             'kwargs' : Hash {
12020                 'name' : precedence,
12021                 'value' : 1055,
12022             }
12023 ,
12024             'typemap' : typemap(typecheck) unsigned long [ANY],
12025             'code' : ,
12026             'type' : a(ANY).unsigned long,
12027         }
12028 ,
12029         'tmap:javaout' : Hash {
12030             'typemap' : typemap(javaout) unsigned long [ANY],
12031             'code' : {
12032     return $jnicall;
12033   },
12034             'type' : a(ANY).unsigned long,
12035         }
12036 ,
12037     }
12038 ,
12039     'a().unsigned long' : Hash {
12040         'tmap:freearg' : Hash {
12041             'typemap' : typemap(freearg) unsigned long [],
12042             'code' :  delete [] $1; ,
12043             'type' : a().unsigned long,
12044         }
12045 ,
12046         'tmap:jstype' : Hash {
12047             'typemap' : typemap(jstype) unsigned long [],
12048             'code' : long[],
12049             'type' : a().unsigned long,
12050         }
12051 ,
12052         'tmap:argout' : Hash {
12053             'typemap' : typemap(argout) unsigned long [],
12054             'code' :  SWIG_JavaArrayArgoutUlong(jenv, jarr$argnum, $1, $input); ,
12055             'type' : a().unsigned long,
12056         }
12057 ,
12058         'tmap:in' : Hash {
12059             'locals' : Hash {
12060                 'name' : jarr,
12061                 'type' : p.jlong,
12062             }
12063 ,
12064             'kwargs' : Hash {
12065                 'name' : numinputs,
12066                 'value' : 1,
12067             }
12068 ,
12069             'typemap' : typemap(in) unsigned long [],
12070             'code' :   if (!SWIG_JavaArrayInUlong(jenv, &jarr, &$1, $input)) return $null; ,
12071             'type' : a().unsigned long,
12072         }
12073 ,
12074         'tmap:jni' : Hash {
12075             'typemap' : typemap(jni) unsigned long [],
12076             'code' : jlongArray,
12077             'type' : a().unsigned long,
12078         }
12079 ,
12080         'tmap:jtype' : Hash {
12081             'typemap' : typemap(jtype) unsigned long [],
12082             'code' : long[],
12083             'type' : a().unsigned long,
12084         }
12085 ,
12086         'tmap:out' : Hash {
12087             'typemap' : typemap(out) unsigned long [],
12088             'code' : $result = SWIG_JavaArrayOutUlong(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
12089             'type' : a().unsigned long,
12090         }
12091 ,
12092         'tmap:javain' : Hash {
12093             'typemap' : typemap(javain) unsigned long [],
12094             'code' : $javainput,
12095             'type' : a().unsigned long,
12096         }
12097 ,
12098         'tmap:typecheck' : Hash {
12099             'kwargs' : Hash {
12100                 'name' : precedence,
12101                 'value' : 1055,
12102             }
12103 ,
12104             'typemap' : typemap(typecheck) unsigned long [],
12105             'code' : ,
12106             'type' : a().unsigned long,
12107         }
12108 ,
12109         'tmap:javaout' : Hash {
12110             'typemap' : typemap(javaout) unsigned long [],
12111             'code' : {
12112     return $jnicall;
12113   },
12114             'type' : a().unsigned long,
12115         }
12116 ,
12117     }
12118 ,
12119     'jbyte' : Hash {
12120         'tmap:jstype' : Hash {
12121             'typemap' : typemap(jstype) jbyte,
12122             'code' : byte,
12123             'type' : jbyte,
12124         }
12125 ,
12126         'tmap:directorin' : Hash {
12127             'kwargs' : Hash {
12128                 'name' : descriptor,
12129                 'value' : B,
12130             }
12131 ,
12132             'typemap' : typemap(directorin) jbyte,
12133             'code' : $input = $1;,
12134             'type' : jbyte,
12135         }
12136 ,
12137         'tmap:javadirectorin' : Hash {
12138             'typemap' : typemap(javadirectorin) jbyte,
12139             'code' : $jniinput,
12140             'type' : jbyte,
12141         }
12142 ,
12143         'tmap:in' : Hash {
12144             'kwargs' : Hash {
12145                 'name' : numinputs,
12146                 'value' : 1,
12147             }
12148 ,
12149             'typemap' : typemap(in) jbyte,
12150             'code' :  $1 = $input; ,
12151             'type' : jbyte,
12152         }
12153 ,
12154         'tmap:directorout' : Hash {
12155             'typemap' : typemap(directorout) jbyte,
12156             'code' :  $result = $input; ,
12157             'type' : jbyte,
12158         }
12159 ,
12160         'tmap:javadirectorout' : Hash {
12161             'typemap' : typemap(javadirectorout) jbyte,
12162             'code' : $javacall,
12163             'type' : jbyte,
12164         }
12165 ,
12166         'tmap:jni' : Hash {
12167             'typemap' : typemap(jni) jbyte,
12168             'code' : jbyte,
12169             'type' : jbyte,
12170         }
12171 ,
12172         'tmap:jtype' : Hash {
12173             'typemap' : typemap(jtype) jbyte,
12174             'code' : byte,
12175             'type' : jbyte,
12176         }
12177 ,
12178         'tmap:out' : Hash {
12179             'typemap' : typemap(out) jbyte,
12180             'code' :  $result = $1; ,
12181             'type' : jbyte,
12182         }
12183 ,
12184         'tmap:typecheck' : Hash {
12185             'kwargs' : Hash {
12186                 'name' : precedence,
12187                 'value' : 25,
12188             }
12189 ,
12190             'typemap' : typemap(typecheck) jbyte,
12191             'code' : ,
12192             'type' : jbyte,
12193         }
12194 ,
12195         'tmap:javain' : Hash {
12196             'typemap' : typemap(javain) jbyte,
12197             'code' : $javainput,
12198             'type' : jbyte,
12199         }
12200 ,
12201         'tmap:javaout' : Hash {
12202             'typemap' : typemap(javaout) jbyte,
12203             'code' : {
12204     return $jnicall;
12205   },
12206             'type' : jbyte,
12207         }
12208 ,
12209     }
12210 ,
12211     'p.char' : Hash {
12212         'tmap:typecheck' : Hash {
12213             'kwargs' : Hash {
12214                 'name' : precedence,
12215                 'value' : 140,
12216             }
12217 ,
12218             'typemap' : typemap(typecheck) char *,
12219             'code' : ,
12220             'type' : p.char,
12221         }
12222 ,
12223         'tmap:memberin' : Hash {
12224             'typemap' : typemap(memberin) char *,
12225             'code' : {
12226   if ($1) delete [] $1;
12227   if ($input) {
12228      $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
12229      strcpy((char *)$1, (const char *)$input);
12230   } else {
12231      $1 = 0;
12232   }
12233 },
12234             'type' : p.char,
12235         }
12236 ,
12237         'tmap:newfree' : Hash {
12238             'typemap' : typemap(newfree) char *,
12239             'code' : delete [] $1;,
12240             'type' : p.char,
12241         }
12242 ,
12243         'tmap:jtype' : Hash {
12244             'typemap' : typemap(jtype) char *,
12245             'code' : String,
12246             'type' : p.char,
12247         }
12248 ,
12249         'tmap:javadirectorin' : Hash {
12250             'typemap' : typemap(javadirectorin) char *,
12251             'code' : $jniinput,
12252             'type' : p.char,
12253         }
12254 ,
12255         'tmap:directorin' : Hash {
12256             'kwargs' : Hash {
12257                 'name' : descriptor,
12258                 'value' : Ljava/lang/String;,
12259                 'nextSibling' : Hash {
12260                     'name' : noblock,
12261                     'value' : 1,
12262                 }
12263 ,
12264             }
12265 ,
12266             'typemap' : typemap(directorin) char *,
12267             'code' : $input = 0;
12268   if ($1) {
12269     $input = jenv->NewStringUTF((const char *)$1);
12270     if (!$input) return $null;
12271   },
12272             'type' : p.char,
12273         }
12274 ,
12275         'tmap:throws' : Hash {
12276             'typemap' : typemap(throws) char *,
12277             'code' :  SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1);
12278    return $null; ,
12279             'type' : p.char,
12280         }
12281 ,
12282         'tmap:javadirectorout' : Hash {
12283             'typemap' : typemap(javadirectorout) char *,
12284             'code' : $javacall,
12285             'type' : p.char,
12286         }
12287 ,
12288         'tmap:directorout' : Hash {
12289             'kwargs' : Hash {
12290                 'name' : noblock,
12291                 'value' : 1,
12292                 'nextSibling' : Hash {
12293                     'name' : warning,
12294                     'value' : 473:Returning a pointer or reference in a director method is not recommended.,
12295                 }
12296 ,
12297             }
12298 ,
12299             'typemap' : typemap(directorout) char *,
12300             'code' : $1 = 0;
12301   if ($input) {
12302     $result = ($1_ltype)jenv->GetStringUTFChars($input, 0);
12303     if (!$result) return $null;
12304   },
12305             'type' : p.char,
12306         }
12307 ,
12308         'tmap:out' : Hash {
12309             'kwargs' : Hash {
12310                 'name' : noblock,
12311                 'value' : 1,
12312             }
12313 ,
12314             'typemap' : typemap(out) char *,
12315             'code' : if($1) $result = jenv->NewStringUTF((const char *)$1);,
12316             'type' : p.char,
12317         }
12318 ,
12319         'tmap:jni' : Hash {
12320             'typemap' : typemap(jni) char *,
12321             'code' : jstring,
12322             'type' : p.char,
12323         }
12324 ,
12325         'tmap:javaout' : Hash {
12326             'typemap' : typemap(javaout) char *,
12327             'code' : {
12328     return $jnicall;
12329   },
12330             'type' : p.char,
12331         }
12332 ,
12333         'tmap:globalin' : Hash {
12334             'typemap' : typemap(globalin) char *,
12335             'code' : {
12336   if ($1) delete [] $1;
12337   if ($input) {
12338      $1 = ($1_type) (new char[strlen((const char *)$input)+1]);
12339      strcpy((char *)$1, (const char *)$input);
12340   } else {
12341      $1 = 0;
12342   }
12343 },
12344             'type' : p.char,
12345         }
12346 ,
12347         'tmap:in' : Hash {
12348             'kwargs' : Hash {
12349                 'name' : numinputs,
12350                 'value' : 1,
12351                 'nextSibling' : Hash {
12352                     'name' : noblock,
12353                     'value' : 1,
12354                 }
12355 ,
12356             }
12357 ,
12358             'typemap' : typemap(in) char *,
12359             'code' : $1 = 0;
12360   if ($input) {
12361     $1 = ($1_ltype)jenv->GetStringUTFChars($input, 0);
12362     if (!$1) return $null;
12363   },
12364             'type' : p.char,
12365         }
12366 ,
12367         'tmap:javain' : Hash {
12368             'typemap' : typemap(javain) char *,
12369             'code' : $javainput,
12370             'type' : p.char,
12371         }
12372 ,
12373         'tmap:jstype' : Hash {
12374             'typemap' : typemap(jstype) char *,
12375             'code' : String,
12376             'type' : p.char,
12377         }
12378 ,
12379         'tmap:freearg' : Hash {
12380             'kwargs' : Hash {
12381                 'name' : noblock,
12382                 'value' : 1,
12383             }
12384 ,
12385             'typemap' : typemap(freearg) char *,
12386             'code' : if ($1) jenv->ReleaseStringUTFChars($input, (const char *)$1);,
12387             'type' : p.char,
12388         }
12389 ,
12390     }
12391 ,
12392     'r.unsigned char' : Hash {
12393         'INOUT' : Hash {
12394             'tmap:freearg' : Hash {
12395                 'pname' : INOUT,
12396                 'typemap' : typemap(freearg) unsigned char &INOUT,
12397                 'code' : ,
12398                 'type' : r.unsigned char,
12399             }
12400 ,
12401             'tmap:jstype' : Hash {
12402                 'pname' : INOUT,
12403                 'typemap' : typemap(jstype) unsigned char &INOUT,
12404                 'code' : short[],
12405                 'type' : r.unsigned char,
12406             }
12407 ,
12408             'tmap:javadirectorin' : Hash {
12409                 'pname' : INOUT,
12410                 'typemap' : typemap(javadirectorin) unsigned char &INOUT,
12411                 'code' : $jniinput,
12412                 'type' : r.unsigned char,
12413             }
12414 ,
12415             'tmap:directorin' : Hash {
12416                 'kwargs' : Hash {
12417                     'name' : descriptor,
12418                     'value' : [Ljava/lang/Short;,
12419                     'nextSibling' : Hash {
12420                         'name' : warning,
12421                         'value' : Need to provide unsigned char *INOUT directorin typemap, unsigned char array length is unknown,
12422                     }
12423 ,
12424                 }
12425 ,
12426                 'pname' : INOUT,
12427                 'typemap' : typemap(directorin) unsigned char &INOUT,
12428                 'code' : {
12429 },
12430                 'type' : r.unsigned char,
12431             }
12432 ,
12433             'tmap:argout' : Hash {
12434                 'pname' : INOUT,
12435                 'typemap' : typemap(argout) unsigned char &INOUT,
12436                 'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); },
12437                 'type' : r.unsigned char,
12438             }
12439 ,
12440             'tmap:javadirectorout' : Hash {
12441                 'pname' : INOUT,
12442                 'typemap' : typemap(javadirectorout) unsigned char &INOUT,
12443                 'code' : $javacall,
12444                 'type' : r.unsigned char,
12445             }
12446 ,
12447             'tmap:in' : Hash {
12448                 'kwargs' : Hash {
12449                     'name' : numinputs,
12450                     'value' : 1,
12451                 }
12452 ,
12453                 'pname' : INOUT,
12454                 'typemap' : typemap(in) unsigned char &INOUT,
12455                 'code' : {
12456   if (!$input) {
12457     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
12458     return $null;
12459   }
12460   if (jenv->GetArrayLength($input) == 0) {
12461     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
12462     return $null;
12463   }
12464   $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0);
12465 },
12466                 'type' : r.unsigned char,
12467             }
12468 ,
12469             'tmap:directorout' : Hash {
12470                 'kwargs' : Hash {
12471                     'name' : warning,
12472                     'value' : Need to provide unsigned char *INOUT directorout typemap,
12473                 }
12474 ,
12475                 'pname' : INOUT,
12476                 'typemap' : typemap(directorout) unsigned char &INOUT,
12477                 'code' : {
12478 },
12479                 'type' : r.unsigned char,
12480             }
12481 ,
12482             'tmap:typecheck' : Hash {
12483                 'kwargs' : Hash {
12484                     'name' : precedence,
12485                     'value' : 1035,
12486                 }
12487 ,
12488                 'pname' : INOUT,
12489                 'typemap' : typemap(typecheck) unsigned char &INOUT,
12490                 'code' : ,
12491                 'type' : r.unsigned char,
12492             }
12493 ,
12494             'tmap:jni' : Hash {
12495                 'pname' : INOUT,
12496                 'typemap' : typemap(jni) unsigned char &INOUT,
12497                 'code' : jshortArray,
12498                 'type' : r.unsigned char,
12499             }
12500 ,
12501             'tmap:jtype' : Hash {
12502                 'pname' : INOUT,
12503                 'typemap' : typemap(jtype) unsigned char &INOUT,
12504                 'code' : short[],
12505                 'type' : r.unsigned char,
12506             }
12507 ,
12508             'tmap:javain' : Hash {
12509                 'pname' : INOUT,
12510                 'typemap' : typemap(javain) unsigned char &INOUT,
12511                 'code' : $javainput,
12512                 'type' : r.unsigned char,
12513             }
12514 ,
12515         }
12516 ,
12517         'INPUT' : Hash {
12518             'tmap:freearg' : Hash {
12519                 'pname' : INPUT,
12520                 'typemap' : typemap(freearg) unsigned char &INPUT,
12521                 'code' : ,
12522                 'type' : r.unsigned char,
12523             }
12524 ,
12525             'tmap:jstype' : Hash {
12526                 'pname' : INPUT,
12527                 'typemap' : typemap(jstype) unsigned char &INPUT,
12528                 'code' : short,
12529                 'type' : r.unsigned char,
12530             }
12531 ,
12532             'tmap:javadirectorin' : Hash {
12533                 'pname' : INPUT,
12534                 'typemap' : typemap(javadirectorin) unsigned char &INPUT,
12535                 'code' : $jniinput,
12536                 'type' : r.unsigned char,
12537             }
12538 ,
12539             'tmap:directorin' : Hash {
12540                 'kwargs' : Hash {
12541                     'name' : descriptor,
12542                     'value' : S,
12543                 }
12544 ,
12545                 'pname' : INPUT,
12546                 'typemap' : typemap(directorin) unsigned char &INPUT,
12547                 'code' :  *(($&1_ltype) $input) = (jshort *) &$1; ,
12548                 'type' : r.unsigned char,
12549             }
12550 ,
12551             'tmap:javadirectorout' : Hash {
12552                 'pname' : INPUT,
12553                 'typemap' : typemap(javadirectorout) unsigned char &INPUT,
12554                 'code' : $javacall,
12555                 'type' : r.unsigned char,
12556             }
12557 ,
12558             'tmap:in' : Hash {
12559                 'kwargs' : Hash {
12560                     'name' : numinputs,
12561                     'value' : 1,
12562                 }
12563 ,
12564                 'pname' : INPUT,
12565                 'typemap' : typemap(in) unsigned char &INPUT,
12566                 'code' :  $1 = ($1_ltype)&$input; ,
12567                 'type' : r.unsigned char,
12568             }
12569 ,
12570             'tmap:directorout' : Hash {
12571                 'pname' : INPUT,
12572                 'typemap' : typemap(directorout) unsigned char &INPUT,
12573                 'code' :  $result = ($1_ltype)&$input; ,
12574                 'type' : r.unsigned char,
12575             }
12576 ,
12577             'tmap:jni' : Hash {
12578                 'pname' : INPUT,
12579                 'typemap' : typemap(jni) unsigned char &INPUT,
12580                 'code' : jshort,
12581                 'type' : r.unsigned char,
12582             }
12583 ,
12584             'tmap:jtype' : Hash {
12585                 'pname' : INPUT,
12586                 'typemap' : typemap(jtype) unsigned char &INPUT,
12587                 'code' : short,
12588                 'type' : r.unsigned char,
12589             }
12590 ,
12591             'tmap:javain' : Hash {
12592                 'pname' : INPUT,
12593                 'typemap' : typemap(javain) unsigned char &INPUT,
12594                 'code' : $javainput,
12595                 'type' : r.unsigned char,
12596             }
12597 ,
12598             'tmap:typecheck' : Hash {
12599                 'kwargs' : Hash {
12600                     'name' : precedence,
12601                     'value' : 35,
12602                 }
12603 ,
12604                 'pname' : INPUT,
12605                 'typemap' : typemap(typecheck) unsigned char &INPUT,
12606                 'code' : ,
12607                 'type' : r.unsigned char,
12608             }
12609 ,
12610         }
12611 ,
12612         'OUTPUT' : Hash {
12613             'tmap:freearg' : Hash {
12614                 'pname' : OUTPUT,
12615                 'typemap' : typemap(freearg) unsigned char &OUTPUT,
12616                 'code' : ,
12617                 'type' : r.unsigned char,
12618             }
12619 ,
12620             'tmap:jstype' : Hash {
12621                 'pname' : OUTPUT,
12622                 'typemap' : typemap(jstype) unsigned char &OUTPUT,
12623                 'code' : short[],
12624                 'type' : r.unsigned char,
12625             }
12626 ,
12627             'tmap:javadirectorin' : Hash {
12628                 'pname' : OUTPUT,
12629                 'typemap' : typemap(javadirectorin) unsigned char &OUTPUT,
12630                 'code' : $jniinput,
12631                 'type' : r.unsigned char,
12632             }
12633 ,
12634             'tmap:directorin' : Hash {
12635                 'kwargs' : Hash {
12636                     'name' : descriptor,
12637                     'value' : [Ljava/lang/Short;,
12638                 }
12639 ,
12640                 'pname' : OUTPUT,
12641                 'typemap' : typemap(directorin) unsigned char &OUTPUT,
12642                 'code' :  *(($&1_ltype) $input = &$1; ,
12643                 'type' : r.unsigned char,
12644             }
12645 ,
12646             'tmap:argout' : Hash {
12647                 'pname' : OUTPUT,
12648                 'typemap' : typemap(argout) unsigned char &OUTPUT,
12649                 'code' : {
12650   jshort jvalue = (jshort)temp$argnum;
12651   jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
12652 },
12653                 'type' : r.unsigned char,
12654             }
12655 ,
12656             'tmap:javadirectorout' : Hash {
12657                 'pname' : OUTPUT,
12658                 'typemap' : typemap(javadirectorout) unsigned char &OUTPUT,
12659                 'code' : $javacall,
12660                 'type' : r.unsigned char,
12661             }
12662 ,
12663             'tmap:in' : Hash {
12664                 'locals' : Hash {
12665                     'name' : temp,
12666                     'type' : $*1_ltype,
12667                 }
12668 ,
12669                 'kwargs' : Hash {
12670                     'name' : numinputs,
12671                     'value' : 1,
12672                 }
12673 ,
12674                 'pname' : OUTPUT,
12675                 'typemap' : typemap(in) unsigned char &OUTPUT,
12676                 'code' : {
12677   if (!$input) {
12678     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
12679     return $null;
12680   }
12681   if (jenv->GetArrayLength($input) == 0) {
12682     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
12683     return $null;
12684   }
12685   $1 = &temp;
12686 },
12687                 'type' : r.unsigned char,
12688             }
12689 ,
12690             'tmap:directorout' : Hash {
12691                 'kwargs' : Hash {
12692                     'name' : warning,
12693                     'value' : Need to provide unsigned char *OUTPUT directorout typemap,
12694                 }
12695 ,
12696                 'pname' : OUTPUT,
12697                 'typemap' : typemap(directorout) unsigned char &OUTPUT,
12698                 'code' : {
12699 },
12700                 'type' : r.unsigned char,
12701             }
12702 ,
12703             'tmap:jni' : Hash {
12704                 'pname' : OUTPUT,
12705                 'typemap' : typemap(jni) unsigned char &OUTPUT,
12706                 'code' : jshortArray,
12707                 'type' : r.unsigned char,
12708             }
12709 ,
12710             'tmap:jtype' : Hash {
12711                 'pname' : OUTPUT,
12712                 'typemap' : typemap(jtype) unsigned char &OUTPUT,
12713                 'code' : short[],
12714                 'type' : r.unsigned char,
12715             }
12716 ,
12717             'tmap:javain' : Hash {
12718                 'pname' : OUTPUT,
12719                 'typemap' : typemap(javain) unsigned char &OUTPUT,
12720                 'code' : $javainput,
12721                 'type' : r.unsigned char,
12722             }
12723 ,
12724         }
12725 ,
12726     }
12727 ,
12728     'p.unsigned char' : Hash {
12729         'INOUT' : Hash {
12730             'tmap:freearg' : Hash {
12731                 'pname' : INOUT,
12732                 'typemap' : typemap(freearg) unsigned char *INOUT,
12733                 'code' : ,
12734                 'type' : p.unsigned char,
12735             }
12736 ,
12737             'tmap:jstype' : Hash {
12738                 'pname' : INOUT,
12739                 'typemap' : typemap(jstype) unsigned char *INOUT,
12740                 'code' : short[],
12741                 'type' : p.unsigned char,
12742             }
12743 ,
12744             'tmap:javadirectorin' : Hash {
12745                 'pname' : INOUT,
12746                 'typemap' : typemap(javadirectorin) unsigned char *INOUT,
12747                 'code' : $jniinput,
12748                 'type' : p.unsigned char,
12749             }
12750 ,
12751             'tmap:directorin' : Hash {
12752                 'kwargs' : Hash {
12753                     'name' : descriptor,
12754                     'value' : [Ljava/lang/Short;,
12755                     'nextSibling' : Hash {
12756                         'name' : warning,
12757                         'value' : Need to provide unsigned char *INOUT directorin typemap, unsigned char array length is unknown,
12758                     }
12759 ,
12760                 }
12761 ,
12762                 'pname' : INOUT,
12763                 'typemap' : typemap(directorin) unsigned char *INOUT,
12764                 'code' : {
12765 },
12766                 'type' : p.unsigned char,
12767             }
12768 ,
12769             'tmap:argout' : Hash {
12770                 'pname' : INOUT,
12771                 'typemap' : typemap(argout) unsigned char *INOUT,
12772                 'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); },
12773                 'type' : p.unsigned char,
12774             }
12775 ,
12776             'tmap:javadirectorout' : Hash {
12777                 'pname' : INOUT,
12778                 'typemap' : typemap(javadirectorout) unsigned char *INOUT,
12779                 'code' : $javacall,
12780                 'type' : p.unsigned char,
12781             }
12782 ,
12783             'tmap:in' : Hash {
12784                 'kwargs' : Hash {
12785                     'name' : numinputs,
12786                     'value' : 1,
12787                 }
12788 ,
12789                 'pname' : INOUT,
12790                 'typemap' : typemap(in) unsigned char *INOUT,
12791                 'code' : {
12792   if (!$input) {
12793     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
12794     return $null;
12795   }
12796   if (jenv->GetArrayLength($input) == 0) {
12797     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
12798     return $null;
12799   }
12800   $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0);
12801 },
12802                 'type' : p.unsigned char,
12803             }
12804 ,
12805             'tmap:directorout' : Hash {
12806                 'kwargs' : Hash {
12807                     'name' : warning,
12808                     'value' : Need to provide unsigned char *INOUT directorout typemap,
12809                 }
12810 ,
12811                 'pname' : INOUT,
12812                 'typemap' : typemap(directorout) unsigned char *INOUT,
12813                 'code' : {
12814 },
12815                 'type' : p.unsigned char,
12816             }
12817 ,
12818             'tmap:typecheck' : Hash {
12819                 'kwargs' : Hash {
12820                     'name' : precedence,
12821                     'value' : 1035,
12822                 }
12823 ,
12824                 'pname' : INOUT,
12825                 'typemap' : typemap(typecheck) unsigned char *INOUT,
12826                 'code' : ,
12827                 'type' : p.unsigned char,
12828             }
12829 ,
12830             'tmap:jni' : Hash {
12831                 'pname' : INOUT,
12832                 'typemap' : typemap(jni) unsigned char *INOUT,
12833                 'code' : jshortArray,
12834                 'type' : p.unsigned char,
12835             }
12836 ,
12837             'tmap:jtype' : Hash {
12838                 'pname' : INOUT,
12839                 'typemap' : typemap(jtype) unsigned char *INOUT,
12840                 'code' : short[],
12841                 'type' : p.unsigned char,
12842             }
12843 ,
12844             'tmap:javain' : Hash {
12845                 'pname' : INOUT,
12846                 'typemap' : typemap(javain) unsigned char *INOUT,
12847                 'code' : $javainput,
12848                 'type' : p.unsigned char,
12849             }
12850 ,
12851         }
12852 ,
12853         'INPUT' : Hash {
12854             'tmap:freearg' : Hash {
12855                 'pname' : INPUT,
12856                 'typemap' : typemap(freearg) unsigned char *INPUT,
12857                 'code' : ,
12858                 'type' : p.unsigned char,
12859             }
12860 ,
12861             'tmap:jstype' : Hash {
12862                 'pname' : INPUT,
12863                 'typemap' : typemap(jstype) unsigned char *INPUT,
12864                 'code' : short,
12865                 'type' : p.unsigned char,
12866             }
12867 ,
12868             'tmap:javadirectorin' : Hash {
12869                 'pname' : INPUT,
12870                 'typemap' : typemap(javadirectorin) unsigned char *INPUT,
12871                 'code' : $jniinput,
12872                 'type' : p.unsigned char,
12873             }
12874 ,
12875             'tmap:directorin' : Hash {
12876                 'kwargs' : Hash {
12877                     'name' : descriptor,
12878                     'value' : S,
12879                 }
12880 ,
12881                 'pname' : INPUT,
12882                 'typemap' : typemap(directorin) unsigned char *INPUT,
12883                 'code' :  *(($&1_ltype) $input) = (jshort *) $1; ,
12884                 'type' : p.unsigned char,
12885             }
12886 ,
12887             'tmap:javadirectorout' : Hash {
12888                 'pname' : INPUT,
12889                 'typemap' : typemap(javadirectorout) unsigned char *INPUT,
12890                 'code' : $javacall,
12891                 'type' : p.unsigned char,
12892             }
12893 ,
12894             'tmap:in' : Hash {
12895                 'kwargs' : Hash {
12896                     'name' : numinputs,
12897                     'value' : 1,
12898                 }
12899 ,
12900                 'pname' : INPUT,
12901                 'typemap' : typemap(in) unsigned char *INPUT,
12902                 'code' :  $1 = ($1_ltype)&$input; ,
12903                 'type' : p.unsigned char,
12904             }
12905 ,
12906             'tmap:directorout' : Hash {
12907                 'pname' : INPUT,
12908                 'typemap' : typemap(directorout) unsigned char *INPUT,
12909                 'code' :  $result = ($1_ltype)&$input; ,
12910                 'type' : p.unsigned char,
12911             }
12912 ,
12913             'tmap:jni' : Hash {
12914                 'pname' : INPUT,
12915                 'typemap' : typemap(jni) unsigned char *INPUT,
12916                 'code' : jshort,
12917                 'type' : p.unsigned char,
12918             }
12919 ,
12920             'tmap:jtype' : Hash {
12921                 'pname' : INPUT,
12922                 'typemap' : typemap(jtype) unsigned char *INPUT,
12923                 'code' : short,
12924                 'type' : p.unsigned char,
12925             }
12926 ,
12927             'tmap:javain' : Hash {
12928                 'pname' : INPUT,
12929                 'typemap' : typemap(javain) unsigned char *INPUT,
12930                 'code' : $javainput,
12931                 'type' : p.unsigned char,
12932             }
12933 ,
12934             'tmap:typecheck' : Hash {
12935                 'kwargs' : Hash {
12936                     'name' : precedence,
12937                     'value' : 35,
12938                 }
12939 ,
12940                 'pname' : INPUT,
12941                 'typemap' : typemap(typecheck) unsigned char *INPUT,
12942                 'code' : ,
12943                 'type' : p.unsigned char,
12944             }
12945 ,
12946         }
12947 ,
12948         'OUTPUT' : Hash {
12949             'tmap:freearg' : Hash {
12950                 'pname' : OUTPUT,
12951                 'typemap' : typemap(freearg) unsigned char *OUTPUT,
12952                 'code' : ,
12953                 'type' : p.unsigned char,
12954             }
12955 ,
12956             'tmap:jstype' : Hash {
12957                 'pname' : OUTPUT,
12958                 'typemap' : typemap(jstype) unsigned char *OUTPUT,
12959                 'code' : short[],
12960                 'type' : p.unsigned char,
12961             }
12962 ,
12963             'tmap:javadirectorin' : Hash {
12964                 'pname' : OUTPUT,
12965                 'typemap' : typemap(javadirectorin) unsigned char *OUTPUT,
12966                 'code' : $jniinput,
12967                 'type' : p.unsigned char,
12968             }
12969 ,
12970             'tmap:directorin' : Hash {
12971                 'kwargs' : Hash {
12972                     'name' : descriptor,
12973                     'value' : [Ljava/lang/Short;,
12974                     'nextSibling' : Hash {
12975                         'name' : warning,
12976                         'value' : Need to provide unsigned char *OUTPUT directorin typemap, unsigned char array length is unknown,
12977                     }
12978 ,
12979                 }
12980 ,
12981                 'pname' : OUTPUT,
12982                 'typemap' : typemap(directorin) unsigned char *OUTPUT,
12983                 'code' : {
12984 },
12985                 'type' : p.unsigned char,
12986             }
12987 ,
12988             'tmap:argout' : Hash {
12989                 'pname' : OUTPUT,
12990                 'typemap' : typemap(argout) unsigned char *OUTPUT,
12991                 'code' : {
12992   jshort jvalue = (jshort)temp$argnum;
12993   jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
12994 },
12995                 'type' : p.unsigned char,
12996             }
12997 ,
12998             'tmap:javadirectorout' : Hash {
12999                 'pname' : OUTPUT,
13000                 'typemap' : typemap(javadirectorout) unsigned char *OUTPUT,
13001                 'code' : $javacall,
13002                 'type' : p.unsigned char,
13003             }
13004 ,
13005             'tmap:in' : Hash {
13006                 'locals' : Hash {
13007                     'name' : temp,
13008                     'type' : $*1_ltype,
13009                 }
13010 ,
13011                 'kwargs' : Hash {
13012                     'name' : numinputs,
13013                     'value' : 1,
13014                 }
13015 ,
13016                 'pname' : OUTPUT,
13017                 'typemap' : typemap(in) unsigned char *OUTPUT,
13018                 'code' : {
13019   if (!$input) {
13020     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
13021     return $null;
13022   }
13023   if (jenv->GetArrayLength($input) == 0) {
13024     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
13025     return $null;
13026   }
13027   $1 = &temp;
13028 },
13029                 'type' : p.unsigned char,
13030             }
13031 ,
13032             'tmap:directorout' : Hash {
13033                 'kwargs' : Hash {
13034                     'name' : warning,
13035                     'value' : Need to provide unsigned char *OUTPUT directorout typemap,
13036                 }
13037 ,
13038                 'pname' : OUTPUT,
13039                 'typemap' : typemap(directorout) unsigned char *OUTPUT,
13040                 'code' : {
13041 },
13042                 'type' : p.unsigned char,
13043             }
13044 ,
13045             'tmap:jni' : Hash {
13046                 'pname' : OUTPUT,
13047                 'typemap' : typemap(jni) unsigned char *OUTPUT,
13048                 'code' : jshortArray,
13049                 'type' : p.unsigned char,
13050             }
13051 ,
13052             'tmap:jtype' : Hash {
13053                 'pname' : OUTPUT,
13054                 'typemap' : typemap(jtype) unsigned char *OUTPUT,
13055                 'code' : short[],
13056                 'type' : p.unsigned char,
13057             }
13058 ,
13059             'tmap:javain' : Hash {
13060                 'pname' : OUTPUT,
13061                 'typemap' : typemap(javain) unsigned char *OUTPUT,
13062                 'code' : $javainput,
13063                 'type' : p.unsigned char,
13064             }
13065 ,
13066         }
13067 ,
13068     }
13069 ,
13070     'r.signed char' : Hash {
13071         'INOUT' : Hash {
13072             'tmap:freearg' : Hash {
13073                 'pname' : INOUT,
13074                 'typemap' : typemap(freearg) signed char &INOUT,
13075                 'code' : ,
13076                 'type' : r.signed char,
13077             }
13078 ,
13079             'tmap:jstype' : Hash {
13080                 'pname' : INOUT,
13081                 'typemap' : typemap(jstype) signed char &INOUT,
13082                 'code' : byte[],
13083                 'type' : r.signed char,
13084             }
13085 ,
13086             'tmap:javadirectorin' : Hash {
13087                 'pname' : INOUT,
13088                 'typemap' : typemap(javadirectorin) signed char &INOUT,
13089                 'code' : $jniinput,
13090                 'type' : r.signed char,
13091             }
13092 ,
13093             'tmap:directorin' : Hash {
13094                 'kwargs' : Hash {
13095                     'name' : descriptor,
13096                     'value' : [Ljava/lang/Byte;,
13097                     'nextSibling' : Hash {
13098                         'name' : warning,
13099                         'value' : Need to provide signed char *INOUT directorin typemap, signed char array length is unknown,
13100                     }
13101 ,
13102                 }
13103 ,
13104                 'pname' : INOUT,
13105                 'typemap' : typemap(directorin) signed char &INOUT,
13106                 'code' : {
13107 },
13108                 'type' : r.signed char,
13109             }
13110 ,
13111             'tmap:argout' : Hash {
13112                 'pname' : INOUT,
13113                 'typemap' : typemap(argout) signed char &INOUT,
13114                 'code' : { jenv->ReleaseByteArrayElements($input, (jbyte *)$1, 0); },
13115                 'type' : r.signed char,
13116             }
13117 ,
13118             'tmap:javadirectorout' : Hash {
13119                 'pname' : INOUT,
13120                 'typemap' : typemap(javadirectorout) signed char &INOUT,
13121                 'code' : $javacall,
13122                 'type' : r.signed char,
13123             }
13124 ,
13125             'tmap:in' : Hash {
13126                 'kwargs' : Hash {
13127                     'name' : numinputs,
13128                     'value' : 1,
13129                 }
13130 ,
13131                 'pname' : INOUT,
13132                 'typemap' : typemap(in) signed char &INOUT,
13133                 'code' : {
13134   if (!$input) {
13135     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
13136     return $null;
13137   }
13138   if (jenv->GetArrayLength($input) == 0) {
13139     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
13140     return $null;
13141   }
13142   $1 = ($1_ltype) jenv->GetByteArrayElements($input, 0);
13143 },
13144                 'type' : r.signed char,
13145             }
13146 ,
13147             'tmap:directorout' : Hash {
13148                 'kwargs' : Hash {
13149                     'name' : warning,
13150                     'value' : Need to provide signed char *INOUT directorout typemap,
13151                 }
13152 ,
13153                 'pname' : INOUT,
13154                 'typemap' : typemap(directorout) signed char &INOUT,
13155                 'code' : {
13156 },
13157                 'type' : r.signed char,
13158             }
13159 ,
13160             'tmap:typecheck' : Hash {
13161                 'kwargs' : Hash {
13162                     'name' : precedence,
13163                     'value' : 1025,
13164                 }
13165 ,
13166                 'pname' : INOUT,
13167                 'typemap' : typemap(typecheck) signed char &INOUT,
13168                 'code' : ,
13169                 'type' : r.signed char,
13170             }
13171 ,
13172             'tmap:jni' : Hash {
13173                 'pname' : INOUT,
13174                 'typemap' : typemap(jni) signed char &INOUT,
13175                 'code' : jbyteArray,
13176                 'type' : r.signed char,
13177             }
13178 ,
13179             'tmap:jtype' : Hash {
13180                 'pname' : INOUT,
13181                 'typemap' : typemap(jtype) signed char &INOUT,
13182                 'code' : byte[],
13183                 'type' : r.signed char,
13184             }
13185 ,
13186             'tmap:javain' : Hash {
13187                 'pname' : INOUT,
13188                 'typemap' : typemap(javain) signed char &INOUT,
13189                 'code' : $javainput,
13190                 'type' : r.signed char,
13191             }
13192 ,
13193         }
13194 ,
13195         'INPUT' : Hash {
13196             'tmap:freearg' : Hash {
13197                 'pname' : INPUT,
13198                 'typemap' : typemap(freearg) signed char &INPUT,
13199                 'code' : ,
13200                 'type' : r.signed char,
13201             }
13202 ,
13203             'tmap:jstype' : Hash {
13204                 'pname' : INPUT,
13205                 'typemap' : typemap(jstype) signed char &INPUT,
13206                 'code' : byte,
13207                 'type' : r.signed char,
13208             }
13209 ,
13210             'tmap:javadirectorin' : Hash {
13211                 'pname' : INPUT,
13212                 'typemap' : typemap(javadirectorin) signed char &INPUT,
13213                 'code' : $jniinput,
13214                 'type' : r.signed char,
13215             }
13216 ,
13217             'tmap:directorin' : Hash {
13218                 'kwargs' : Hash {
13219                     'name' : descriptor,
13220                     'value' : B,
13221                 }
13222 ,
13223                 'pname' : INPUT,
13224                 'typemap' : typemap(directorin) signed char &INPUT,
13225                 'code' :  *(($&1_ltype) $input) = (jbyte *) &$1; ,
13226                 'type' : r.signed char,
13227             }
13228 ,
13229             'tmap:javadirectorout' : Hash {
13230                 'pname' : INPUT,
13231                 'typemap' : typemap(javadirectorout) signed char &INPUT,
13232                 'code' : $javacall,
13233                 'type' : r.signed char,
13234             }
13235 ,
13236             'tmap:in' : Hash {
13237                 'kwargs' : Hash {
13238                     'name' : numinputs,
13239                     'value' : 1,
13240                 }
13241 ,
13242                 'pname' : INPUT,
13243                 'typemap' : typemap(in) signed char &INPUT,
13244                 'code' :  $1 = ($1_ltype)&$input; ,
13245                 'type' : r.signed char,
13246             }
13247 ,
13248             'tmap:directorout' : Hash {
13249                 'pname' : INPUT,
13250                 'typemap' : typemap(directorout) signed char &INPUT,
13251                 'code' :  $result = ($1_ltype)&$input; ,
13252                 'type' : r.signed char,
13253             }
13254 ,
13255             'tmap:jni' : Hash {
13256                 'pname' : INPUT,
13257                 'typemap' : typemap(jni) signed char &INPUT,
13258                 'code' : jbyte,
13259                 'type' : r.signed char,
13260             }
13261 ,
13262             'tmap:jtype' : Hash {
13263                 'pname' : INPUT,
13264                 'typemap' : typemap(jtype) signed char &INPUT,
13265                 'code' : byte,
13266                 'type' : r.signed char,
13267             }
13268 ,
13269             'tmap:javain' : Hash {
13270                 'pname' : INPUT,
13271                 'typemap' : typemap(javain) signed char &INPUT,
13272                 'code' : $javainput,
13273                 'type' : r.signed char,
13274             }
13275 ,
13276             'tmap:typecheck' : Hash {
13277                 'kwargs' : Hash {
13278                     'name' : precedence,
13279                     'value' : 25,
13280                 }
13281 ,
13282                 'pname' : INPUT,
13283                 'typemap' : typemap(typecheck) signed char &INPUT,
13284                 'code' : ,
13285                 'type' : r.signed char,
13286             }
13287 ,
13288         }
13289 ,
13290         'OUTPUT' : Hash {
13291             'tmap:freearg' : Hash {
13292                 'pname' : OUTPUT,
13293                 'typemap' : typemap(freearg) signed char &OUTPUT,
13294                 'code' : ,
13295                 'type' : r.signed char,
13296             }
13297 ,
13298             'tmap:jstype' : Hash {
13299                 'pname' : OUTPUT,
13300                 'typemap' : typemap(jstype) signed char &OUTPUT,
13301                 'code' : byte[],
13302                 'type' : r.signed char,
13303             }
13304 ,
13305             'tmap:javadirectorin' : Hash {
13306                 'pname' : OUTPUT,
13307                 'typemap' : typemap(javadirectorin) signed char &OUTPUT,
13308                 'code' : $jniinput,
13309                 'type' : r.signed char,
13310             }
13311 ,
13312             'tmap:directorin' : Hash {
13313                 'kwargs' : Hash {
13314                     'name' : descriptor,
13315                     'value' : [Ljava/lang/Byte;,
13316                 }
13317 ,
13318                 'pname' : OUTPUT,
13319                 'typemap' : typemap(directorin) signed char &OUTPUT,
13320                 'code' :  *(($&1_ltype) $input = &$1; ,
13321                 'type' : r.signed char,
13322             }
13323 ,
13324             'tmap:argout' : Hash {
13325                 'pname' : OUTPUT,
13326                 'typemap' : typemap(argout) signed char &OUTPUT,
13327                 'code' : {
13328   jbyte jvalue = (jbyte)temp$argnum;
13329   jenv->SetByteArrayRegion($input, 0, 1, &jvalue);
13330 },
13331                 'type' : r.signed char,
13332             }
13333 ,
13334             'tmap:javadirectorout' : Hash {
13335                 'pname' : OUTPUT,
13336                 'typemap' : typemap(javadirectorout) signed char &OUTPUT,
13337                 'code' : $javacall,
13338                 'type' : r.signed char,
13339             }
13340 ,
13341             'tmap:in' : Hash {
13342                 'locals' : Hash {
13343                     'name' : temp,
13344                     'type' : $*1_ltype,
13345                 }
13346 ,
13347                 'kwargs' : Hash {
13348                     'name' : numinputs,
13349                     'value' : 1,
13350                 }
13351 ,
13352                 'pname' : OUTPUT,
13353                 'typemap' : typemap(in) signed char &OUTPUT,
13354                 'code' : {
13355   if (!$input) {
13356     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
13357     return $null;
13358   }
13359   if (jenv->GetArrayLength($input) == 0) {
13360     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
13361     return $null;
13362   }
13363   $1 = &temp;
13364 },
13365                 'type' : r.signed char,
13366             }
13367 ,
13368             'tmap:directorout' : Hash {
13369                 'kwargs' : Hash {
13370                     'name' : warning,
13371                     'value' : Need to provide signed char *OUTPUT directorout typemap,
13372                 }
13373 ,
13374                 'pname' : OUTPUT,
13375                 'typemap' : typemap(directorout) signed char &OUTPUT,
13376                 'code' : {
13377 },
13378                 'type' : r.signed char,
13379             }
13380 ,
13381             'tmap:jni' : Hash {
13382                 'pname' : OUTPUT,
13383                 'typemap' : typemap(jni) signed char &OUTPUT,
13384                 'code' : jbyteArray,
13385                 'type' : r.signed char,
13386             }
13387 ,
13388             'tmap:jtype' : Hash {
13389                 'pname' : OUTPUT,
13390                 'typemap' : typemap(jtype) signed char &OUTPUT,
13391                 'code' : byte[],
13392                 'type' : r.signed char,
13393             }
13394 ,
13395             'tmap:javain' : Hash {
13396                 'pname' : OUTPUT,
13397                 'typemap' : typemap(javain) signed char &OUTPUT,
13398                 'code' : $javainput,
13399                 'type' : r.signed char,
13400             }
13401 ,
13402         }
13403 ,
13404     }
13405 ,
13406     'p.signed char' : Hash {
13407         'INOUT' : Hash {
13408             'tmap:freearg' : Hash {
13409                 'pname' : INOUT,
13410                 'typemap' : typemap(freearg) signed char *INOUT,
13411                 'code' : ,
13412                 'type' : p.signed char,
13413             }
13414 ,
13415             'tmap:jstype' : Hash {
13416                 'pname' : INOUT,
13417                 'typemap' : typemap(jstype) signed char *INOUT,
13418                 'code' : byte[],
13419                 'type' : p.signed char,
13420             }
13421 ,
13422             'tmap:javadirectorin' : Hash {
13423                 'pname' : INOUT,
13424                 'typemap' : typemap(javadirectorin) signed char *INOUT,
13425                 'code' : $jniinput,
13426                 'type' : p.signed char,
13427             }
13428 ,
13429             'tmap:directorin' : Hash {
13430                 'kwargs' : Hash {
13431                     'name' : descriptor,
13432                     'value' : [Ljava/lang/Byte;,
13433                     'nextSibling' : Hash {
13434                         'name' : warning,
13435                         'value' : Need to provide signed char *INOUT directorin typemap, signed char array length is unknown,
13436                     }
13437 ,
13438                 }
13439 ,
13440                 'pname' : INOUT,
13441                 'typemap' : typemap(directorin) signed char *INOUT,
13442                 'code' : {
13443 },
13444                 'type' : p.signed char,
13445             }
13446 ,
13447             'tmap:argout' : Hash {
13448                 'pname' : INOUT,
13449                 'typemap' : typemap(argout) signed char *INOUT,
13450                 'code' : { jenv->ReleaseByteArrayElements($input, (jbyte *)$1, 0); },
13451                 'type' : p.signed char,
13452             }
13453 ,
13454             'tmap:javadirectorout' : Hash {
13455                 'pname' : INOUT,
13456                 'typemap' : typemap(javadirectorout) signed char *INOUT,
13457                 'code' : $javacall,
13458                 'type' : p.signed char,
13459             }
13460 ,
13461             'tmap:in' : Hash {
13462                 'kwargs' : Hash {
13463                     'name' : numinputs,
13464                     'value' : 1,
13465                 }
13466 ,
13467                 'pname' : INOUT,
13468                 'typemap' : typemap(in) signed char *INOUT,
13469                 'code' : {
13470   if (!$input) {
13471     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
13472     return $null;
13473   }
13474   if (jenv->GetArrayLength($input) == 0) {
13475     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
13476     return $null;
13477   }
13478   $1 = ($1_ltype) jenv->GetByteArrayElements($input, 0);
13479 },
13480                 'type' : p.signed char,
13481             }
13482 ,
13483             'tmap:directorout' : Hash {
13484                 'kwargs' : Hash {
13485                     'name' : warning,
13486                     'value' : Need to provide signed char *INOUT directorout typemap,
13487                 }
13488 ,
13489                 'pname' : INOUT,
13490                 'typemap' : typemap(directorout) signed char *INOUT,
13491                 'code' : {
13492 },
13493                 'type' : p.signed char,
13494             }
13495 ,
13496             'tmap:typecheck' : Hash {
13497                 'kwargs' : Hash {
13498                     'name' : precedence,
13499                     'value' : 1025,
13500                 }
13501 ,
13502                 'pname' : INOUT,
13503                 'typemap' : typemap(typecheck) signed char *INOUT,
13504                 'code' : ,
13505                 'type' : p.signed char,
13506             }
13507 ,
13508             'tmap:jni' : Hash {
13509                 'pname' : INOUT,
13510                 'typemap' : typemap(jni) signed char *INOUT,
13511                 'code' : jbyteArray,
13512                 'type' : p.signed char,
13513             }
13514 ,
13515             'tmap:jtype' : Hash {
13516                 'pname' : INOUT,
13517                 'typemap' : typemap(jtype) signed char *INOUT,
13518                 'code' : byte[],
13519                 'type' : p.signed char,
13520             }
13521 ,
13522             'tmap:javain' : Hash {
13523                 'pname' : INOUT,
13524                 'typemap' : typemap(javain) signed char *INOUT,
13525                 'code' : $javainput,
13526                 'type' : p.signed char,
13527             }
13528 ,
13529         }
13530 ,
13531         'INPUT' : Hash {
13532             'tmap:freearg' : Hash {
13533                 'pname' : INPUT,
13534                 'typemap' : typemap(freearg) signed char *INPUT,
13535                 'code' : ,
13536                 'type' : p.signed char,
13537             }
13538 ,
13539             'tmap:jstype' : Hash {
13540                 'pname' : INPUT,
13541                 'typemap' : typemap(jstype) signed char *INPUT,
13542                 'code' : byte,
13543                 'type' : p.signed char,
13544             }
13545 ,
13546             'tmap:javadirectorin' : Hash {
13547                 'pname' : INPUT,
13548                 'typemap' : typemap(javadirectorin) signed char *INPUT,
13549                 'code' : $jniinput,
13550                 'type' : p.signed char,
13551             }
13552 ,
13553             'tmap:directorin' : Hash {
13554                 'kwargs' : Hash {
13555                     'name' : descriptor,
13556                     'value' : B,
13557                 }
13558 ,
13559                 'pname' : INPUT,
13560                 'typemap' : typemap(directorin) signed char *INPUT,
13561                 'code' :  *(($&1_ltype) $input) = (jbyte *) $1; ,
13562                 'type' : p.signed char,
13563             }
13564 ,
13565             'tmap:javadirectorout' : Hash {
13566                 'pname' : INPUT,
13567                 'typemap' : typemap(javadirectorout) signed char *INPUT,
13568                 'code' : $javacall,
13569                 'type' : p.signed char,
13570             }
13571 ,
13572             'tmap:in' : Hash {
13573                 'kwargs' : Hash {
13574                     'name' : numinputs,
13575                     'value' : 1,
13576                 }
13577 ,
13578                 'pname' : INPUT,
13579                 'typemap' : typemap(in) signed char *INPUT,
13580                 'code' :  $1 = ($1_ltype)&$input; ,
13581                 'type' : p.signed char,
13582             }
13583 ,
13584             'tmap:directorout' : Hash {
13585                 'pname' : INPUT,
13586                 'typemap' : typemap(directorout) signed char *INPUT,
13587                 'code' :  $result = ($1_ltype)&$input; ,
13588                 'type' : p.signed char,
13589             }
13590 ,
13591             'tmap:jni' : Hash {
13592                 'pname' : INPUT,
13593                 'typemap' : typemap(jni) signed char *INPUT,
13594                 'code' : jbyte,
13595                 'type' : p.signed char,
13596             }
13597 ,
13598             'tmap:jtype' : Hash {
13599                 'pname' : INPUT,
13600                 'typemap' : typemap(jtype) signed char *INPUT,
13601                 'code' : byte,
13602                 'type' : p.signed char,
13603             }
13604 ,
13605             'tmap:javain' : Hash {
13606                 'pname' : INPUT,
13607                 'typemap' : typemap(javain) signed char *INPUT,
13608                 'code' : $javainput,
13609                 'type' : p.signed char,
13610             }
13611 ,
13612             'tmap:typecheck' : Hash {
13613                 'kwargs' : Hash {
13614                     'name' : precedence,
13615                     'value' : 25,
13616                 }
13617 ,
13618                 'pname' : INPUT,
13619                 'typemap' : typemap(typecheck) signed char *INPUT,
13620                 'code' : ,
13621                 'type' : p.signed char,
13622             }
13623 ,
13624         }
13625 ,
13626         'OUTPUT' : Hash {
13627             'tmap:freearg' : Hash {
13628                 'pname' : OUTPUT,
13629                 'typemap' : typemap(freearg) signed char *OUTPUT,
13630                 'code' : ,
13631                 'type' : p.signed char,
13632             }
13633 ,
13634             'tmap:jstype' : Hash {
13635                 'pname' : OUTPUT,
13636                 'typemap' : typemap(jstype) signed char *OUTPUT,
13637                 'code' : byte[],
13638                 'type' : p.signed char,
13639             }
13640 ,
13641             'tmap:javadirectorin' : Hash {
13642                 'pname' : OUTPUT,
13643                 'typemap' : typemap(javadirectorin) signed char *OUTPUT,
13644                 'code' : $jniinput,
13645                 'type' : p.signed char,
13646             }
13647 ,
13648             'tmap:directorin' : Hash {
13649                 'kwargs' : Hash {
13650                     'name' : descriptor,
13651                     'value' : [Ljava/lang/Byte;,
13652                     'nextSibling' : Hash {
13653                         'name' : warning,
13654                         'value' : Need to provide signed char *OUTPUT directorin typemap, signed char array length is unknown,
13655                     }
13656 ,
13657                 }
13658 ,
13659                 'pname' : OUTPUT,
13660                 'typemap' : typemap(directorin) signed char *OUTPUT,
13661                 'code' : {
13662 },
13663                 'type' : p.signed char,
13664             }
13665 ,
13666             'tmap:argout' : Hash {
13667                 'pname' : OUTPUT,
13668                 'typemap' : typemap(argout) signed char *OUTPUT,
13669                 'code' : {
13670   jbyte jvalue = (jbyte)temp$argnum;
13671   jenv->SetByteArrayRegion($input, 0, 1, &jvalue);
13672 },
13673                 'type' : p.signed char,
13674             }
13675 ,
13676             'tmap:javadirectorout' : Hash {
13677                 'pname' : OUTPUT,
13678                 'typemap' : typemap(javadirectorout) signed char *OUTPUT,
13679                 'code' : $javacall,
13680                 'type' : p.signed char,
13681             }
13682 ,
13683             'tmap:in' : Hash {
13684                 'locals' : Hash {
13685                     'name' : temp,
13686                     'type' : $*1_ltype,
13687                 }
13688 ,
13689                 'kwargs' : Hash {
13690                     'name' : numinputs,
13691                     'value' : 1,
13692                 }
13693 ,
13694                 'pname' : OUTPUT,
13695                 'typemap' : typemap(in) signed char *OUTPUT,
13696                 'code' : {
13697   if (!$input) {
13698     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
13699     return $null;
13700   }
13701   if (jenv->GetArrayLength($input) == 0) {
13702     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
13703     return $null;
13704   }
13705   $1 = &temp;
13706 },
13707                 'type' : p.signed char,
13708             }
13709 ,
13710             'tmap:directorout' : Hash {
13711                 'kwargs' : Hash {
13712                     'name' : warning,
13713                     'value' : Need to provide signed char *OUTPUT directorout typemap,
13714                 }
13715 ,
13716                 'pname' : OUTPUT,
13717                 'typemap' : typemap(directorout) signed char *OUTPUT,
13718                 'code' : {
13719 },
13720                 'type' : p.signed char,
13721             }
13722 ,
13723             'tmap:jni' : Hash {
13724                 'pname' : OUTPUT,
13725                 'typemap' : typemap(jni) signed char *OUTPUT,
13726                 'code' : jbyteArray,
13727                 'type' : p.signed char,
13728             }
13729 ,
13730             'tmap:jtype' : Hash {
13731                 'pname' : OUTPUT,
13732                 'typemap' : typemap(jtype) signed char *OUTPUT,
13733                 'code' : byte[],
13734                 'type' : p.signed char,
13735             }
13736 ,
13737             'tmap:javain' : Hash {
13738                 'pname' : OUTPUT,
13739                 'typemap' : typemap(javain) signed char *OUTPUT,
13740                 'code' : $javainput,
13741                 'type' : p.signed char,
13742             }
13743 ,
13744         }
13745 ,
13746     }
13747 ,
13748     'r.q(const).signed char' : Hash {
13749         'tmap:jstype' : Hash {
13750             'typemap' : typemap(jstype) signed char const &,
13751             'code' : byte,
13752             'type' : r.q(const).signed char,
13753         }
13754 ,
13755         'tmap:directorin' : Hash {
13756             'kwargs' : Hash {
13757                 'name' : descriptor,
13758                 'value' : B,
13759             }
13760 ,
13761             'typemap' : typemap(directorin) signed char const &,
13762             'code' : $input = (jbyte)$1_name;,
13763             'type' : r.q(const).signed char,
13764         }
13765 ,
13766         'tmap:javadirectorin' : Hash {
13767             'locals' : Hash {
13768                 'name' : temp,
13769                 'type' : $*1_ltype,
13770             }
13771 ,
13772             'typemap' : typemap(javadirectorin) signed char const &,
13773             'code' : $jniinput,
13774             'type' : r.q(const).signed char,
13775         }
13776 ,
13777         'tmap:in' : Hash {
13778             'locals' : Hash {
13779                 'name' : temp,
13780                 'type' : $*1_ltype,
13781             }
13782 ,
13783             'kwargs' : Hash {
13784                 'name' : numinputs,
13785                 'value' : 1,
13786             }
13787 ,
13788             'typemap' : typemap(in) signed char const &,
13789             'code' :  temp = ($*1_ltype)$input;
13790    $1 = &temp; ,
13791             'type' : r.q(const).signed char,
13792         }
13793 ,
13794         'tmap:directorout' : Hash {
13795             'kwargs' : Hash {
13796                 'name' : warning,
13797                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
13798             }
13799 ,
13800             'typemap' : typemap(directorout) signed char const &,
13801             'code' :  static $*1_ltype temp;
13802    temp = ($*1_ltype)$input;
13803    $result = &temp; ,
13804             'type' : r.q(const).signed char,
13805         }
13806 ,
13807         'tmap:javadirectorout' : Hash {
13808             'locals' : Hash {
13809                 'name' : temp,
13810                 'type' : $*1_ltype,
13811             }
13812 ,
13813             'typemap' : typemap(javadirectorout) signed char const &,
13814             'code' : $javacall,
13815             'type' : r.q(const).signed char,
13816         }
13817 ,
13818         'tmap:jni' : Hash {
13819             'typemap' : typemap(jni) signed char const &,
13820             'code' : jbyte,
13821             'type' : r.q(const).signed char,
13822         }
13823 ,
13824         'tmap:jtype' : Hash {
13825             'typemap' : typemap(jtype) signed char const &,
13826             'code' : byte,
13827             'type' : r.q(const).signed char,
13828         }
13829 ,
13830         'tmap:out' : Hash {
13831             'typemap' : typemap(out) signed char const &,
13832             'code' :  $result = (jbyte)*$1; ,
13833             'type' : r.q(const).signed char,
13834         }
13835 ,
13836         'tmap:typecheck' : Hash {
13837             'kwargs' : Hash {
13838                 'name' : precedence,
13839                 'value' : 25,
13840             }
13841 ,
13842             'typemap' : typemap(typecheck) signed char const &,
13843             'code' : ,
13844             'type' : r.q(const).signed char,
13845         }
13846 ,
13847         'tmap:javain' : Hash {
13848             'typemap' : typemap(javain) signed char const &,
13849             'code' : $javainput,
13850             'type' : r.q(const).signed char,
13851         }
13852 ,
13853         'tmap:javaout' : Hash {
13854             'typemap' : typemap(javaout) signed char const &,
13855             'code' : {
13856     return $jnicall;
13857   },
13858             'type' : r.q(const).signed char,
13859         }
13860 ,
13861     }
13862 ,
13863     'signed char' : Hash {
13864         'tmap:jstype' : Hash {
13865             'typemap' : typemap(jstype) signed char,
13866             'code' : byte,
13867             'type' : signed char,
13868         }
13869 ,
13870         'tmap:directorin' : Hash {
13871             'kwargs' : Hash {
13872                 'name' : descriptor,
13873                 'value' : B,
13874             }
13875 ,
13876             'typemap' : typemap(directorin) signed char,
13877             'code' : $input = (jbyte) $1;,
13878             'type' : signed char,
13879         }
13880 ,
13881         'tmap:javadirectorin' : Hash {
13882             'typemap' : typemap(javadirectorin) signed char,
13883             'code' : $jniinput,
13884             'type' : signed char,
13885         }
13886 ,
13887         'tmap:in' : Hash {
13888             'kwargs' : Hash {
13889                 'name' : numinputs,
13890                 'value' : 1,
13891             }
13892 ,
13893             'typemap' : typemap(in) signed char,
13894             'code' :  $1 = ($1_ltype)$input; ,
13895             'type' : signed char,
13896         }
13897 ,
13898         'tmap:directorout' : Hash {
13899             'typemap' : typemap(directorout) signed char,
13900             'code' :  $result = ($1_ltype)$input; ,
13901             'type' : signed char,
13902         }
13903 ,
13904         'tmap:javadirectorout' : Hash {
13905             'typemap' : typemap(javadirectorout) signed char,
13906             'code' : $javacall,
13907             'type' : signed char,
13908         }
13909 ,
13910         'tmap:jni' : Hash {
13911             'typemap' : typemap(jni) signed char,
13912             'code' : jbyte,
13913             'type' : signed char,
13914         }
13915 ,
13916         'tmap:jtype' : Hash {
13917             'typemap' : typemap(jtype) signed char,
13918             'code' : byte,
13919             'type' : signed char,
13920         }
13921 ,
13922         'tmap:out' : Hash {
13923             'typemap' : typemap(out) signed char,
13924             'code' :  $result = (jbyte)$1; ,
13925             'type' : signed char,
13926         }
13927 ,
13928         'tmap:typecheck' : Hash {
13929             'kwargs' : Hash {
13930                 'name' : precedence,
13931                 'value' : 25,
13932             }
13933 ,
13934             'typemap' : typemap(typecheck) signed char,
13935             'code' : ,
13936             'type' : signed char,
13937         }
13938 ,
13939         'tmap:javain' : Hash {
13940             'typemap' : typemap(javain) signed char,
13941             'code' : $javainput,
13942             'type' : signed char,
13943         }
13944 ,
13945         'tmap:javaout' : Hash {
13946             'typemap' : typemap(javaout) signed char,
13947             'code' : {
13948     return $jnicall;
13949   },
13950             'type' : signed char,
13951         }
13952 ,
13953     }
13954 ,
13955     'unsigned char' : Hash {
13956         'tmap:jstype' : Hash {
13957             'typemap' : typemap(jstype) unsigned char,
13958             'code' : short,
13959             'type' : unsigned char,
13960         }
13961 ,
13962         'tmap:directorin' : Hash {
13963             'kwargs' : Hash {
13964                 'name' : descriptor,
13965                 'value' : S,
13966             }
13967 ,
13968             'typemap' : typemap(directorin) unsigned char,
13969             'code' : $input = (jshort) $1;,
13970             'type' : unsigned char,
13971         }
13972 ,
13973         'tmap:javadirectorin' : Hash {
13974             'typemap' : typemap(javadirectorin) unsigned char,
13975             'code' : $jniinput,
13976             'type' : unsigned char,
13977         }
13978 ,
13979         'tmap:in' : Hash {
13980             'kwargs' : Hash {
13981                 'name' : numinputs,
13982                 'value' : 1,
13983             }
13984 ,
13985             'typemap' : typemap(in) unsigned char,
13986             'code' :  $1 = ($1_ltype)$input; ,
13987             'type' : unsigned char,
13988         }
13989 ,
13990         'tmap:directorout' : Hash {
13991             'typemap' : typemap(directorout) unsigned char,
13992             'code' :  $result = ($1_ltype)$input; ,
13993             'type' : unsigned char,
13994         }
13995 ,
13996         'tmap:javadirectorout' : Hash {
13997             'typemap' : typemap(javadirectorout) unsigned char,
13998             'code' : $javacall,
13999             'type' : unsigned char,
14000         }
14001 ,
14002         'tmap:jni' : Hash {
14003             'typemap' : typemap(jni) unsigned char,
14004             'code' : jshort,
14005             'type' : unsigned char,
14006         }
14007 ,
14008         'tmap:jtype' : Hash {
14009             'typemap' : typemap(jtype) unsigned char,
14010             'code' : short,
14011             'type' : unsigned char,
14012         }
14013 ,
14014         'tmap:out' : Hash {
14015             'typemap' : typemap(out) unsigned char,
14016             'code' :  $result = (jshort)$1; ,
14017             'type' : unsigned char,
14018         }
14019 ,
14020         'tmap:typecheck' : Hash {
14021             'kwargs' : Hash {
14022                 'name' : precedence,
14023                 'value' : 35,
14024             }
14025 ,
14026             'typemap' : typemap(typecheck) unsigned char,
14027             'code' : ,
14028             'type' : unsigned char,
14029         }
14030 ,
14031         'tmap:javain' : Hash {
14032             'typemap' : typemap(javain) unsigned char,
14033             'code' : $javainput,
14034             'type' : unsigned char,
14035         }
14036 ,
14037         'tmap:javaout' : Hash {
14038             'typemap' : typemap(javaout) unsigned char,
14039             'code' : {
14040     return $jnicall;
14041   },
14042             'type' : unsigned char,
14043         }
14044 ,
14045     }
14046 ,
14047     'r.q(const).unsigned char' : Hash {
14048         'tmap:jstype' : Hash {
14049             'typemap' : typemap(jstype) unsigned char const &,
14050             'code' : short,
14051             'type' : r.q(const).unsigned char,
14052         }
14053 ,
14054         'tmap:directorin' : Hash {
14055             'kwargs' : Hash {
14056                 'name' : descriptor,
14057                 'value' : S,
14058             }
14059 ,
14060             'typemap' : typemap(directorin) unsigned char const &,
14061             'code' : $input = (jshort)$1_name;,
14062             'type' : r.q(const).unsigned char,
14063         }
14064 ,
14065         'tmap:javadirectorin' : Hash {
14066             'locals' : Hash {
14067                 'name' : temp,
14068                 'type' : $*1_ltype,
14069             }
14070 ,
14071             'typemap' : typemap(javadirectorin) unsigned char const &,
14072             'code' : $jniinput,
14073             'type' : r.q(const).unsigned char,
14074         }
14075 ,
14076         'tmap:in' : Hash {
14077             'locals' : Hash {
14078                 'name' : temp,
14079                 'type' : $*1_ltype,
14080             }
14081 ,
14082             'kwargs' : Hash {
14083                 'name' : numinputs,
14084                 'value' : 1,
14085             }
14086 ,
14087             'typemap' : typemap(in) unsigned char const &,
14088             'code' :  temp = ($*1_ltype)$input;
14089    $1 = &temp; ,
14090             'type' : r.q(const).unsigned char,
14091         }
14092 ,
14093         'tmap:directorout' : Hash {
14094             'kwargs' : Hash {
14095                 'name' : warning,
14096                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
14097             }
14098 ,
14099             'typemap' : typemap(directorout) unsigned char const &,
14100             'code' :  static $*1_ltype temp;
14101    temp = ($*1_ltype)$input;
14102    $result = &temp; ,
14103             'type' : r.q(const).unsigned char,
14104         }
14105 ,
14106         'tmap:javadirectorout' : Hash {
14107             'locals' : Hash {
14108                 'name' : temp,
14109                 'type' : $*1_ltype,
14110             }
14111 ,
14112             'typemap' : typemap(javadirectorout) unsigned char const &,
14113             'code' : $javacall,
14114             'type' : r.q(const).unsigned char,
14115         }
14116 ,
14117         'tmap:jni' : Hash {
14118             'typemap' : typemap(jni) unsigned char const &,
14119             'code' : jshort,
14120             'type' : r.q(const).unsigned char,
14121         }
14122 ,
14123         'tmap:jtype' : Hash {
14124             'typemap' : typemap(jtype) unsigned char const &,
14125             'code' : short,
14126             'type' : r.q(const).unsigned char,
14127         }
14128 ,
14129         'tmap:out' : Hash {
14130             'typemap' : typemap(out) unsigned char const &,
14131             'code' :  $result = (jshort)*$1; ,
14132             'type' : r.q(const).unsigned char,
14133         }
14134 ,
14135         'tmap:typecheck' : Hash {
14136             'kwargs' : Hash {
14137                 'name' : precedence,
14138                 'value' : 35,
14139             }
14140 ,
14141             'typemap' : typemap(typecheck) unsigned char const &,
14142             'code' : ,
14143             'type' : r.q(const).unsigned char,
14144         }
14145 ,
14146         'tmap:javain' : Hash {
14147             'typemap' : typemap(javain) unsigned char const &,
14148             'code' : $javainput,
14149             'type' : r.q(const).unsigned char,
14150         }
14151 ,
14152         'tmap:javaout' : Hash {
14153             'typemap' : typemap(javaout) unsigned char const &,
14154             'code' : {
14155     return $jnicall;
14156   },
14157             'type' : r.q(const).unsigned char,
14158         }
14159 ,
14160     }
14161 ,
14162     'a(ANY).signed char' : Hash {
14163         'tmap:freearg' : Hash {
14164             'typemap' : typemap(freearg) signed char [ANY],
14165             'code' :  delete [] $1; ,
14166             'type' : a(ANY).signed char,
14167         }
14168 ,
14169         'tmap:jstype' : Hash {
14170             'typemap' : typemap(jstype) signed char [ANY],
14171             'code' : byte[],
14172             'type' : a(ANY).signed char,
14173         }
14174 ,
14175         'tmap:argout' : Hash {
14176             'typemap' : typemap(argout) signed char [ANY],
14177             'code' :  SWIG_JavaArrayArgoutSchar(jenv, jarr$argnum, $1, $input); ,
14178             'type' : a(ANY).signed char,
14179         }
14180 ,
14181         'tmap:in' : Hash {
14182             'locals' : Hash {
14183                 'name' : jarr,
14184                 'type' : p.jbyte,
14185             }
14186 ,
14187             'kwargs' : Hash {
14188                 'name' : numinputs,
14189                 'value' : 1,
14190             }
14191 ,
14192             'typemap' : typemap(in) signed char [ANY],
14193             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
14194     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
14195     return $null;
14196   }
14197   if (!SWIG_JavaArrayInSchar(jenv, &jarr, &$1, $input)) return $null; ,
14198             'type' : a(ANY).signed char,
14199         }
14200 ,
14201         'tmap:jni' : Hash {
14202             'typemap' : typemap(jni) signed char [ANY],
14203             'code' : jbyteArray,
14204             'type' : a(ANY).signed char,
14205         }
14206 ,
14207         'tmap:jtype' : Hash {
14208             'typemap' : typemap(jtype) signed char [ANY],
14209             'code' : byte[],
14210             'type' : a(ANY).signed char,
14211         }
14212 ,
14213         'tmap:out' : Hash {
14214             'typemap' : typemap(out) signed char [ANY],
14215             'code' : $result = SWIG_JavaArrayOutSchar(jenv, $1, $1_dim0); ,
14216             'type' : a(ANY).signed char,
14217         }
14218 ,
14219         'tmap:javain' : Hash {
14220             'typemap' : typemap(javain) signed char [ANY],
14221             'code' : $javainput,
14222             'type' : a(ANY).signed char,
14223         }
14224 ,
14225         'tmap:typecheck' : Hash {
14226             'kwargs' : Hash {
14227                 'name' : precedence,
14228                 'value' : 1025,
14229             }
14230 ,
14231             'typemap' : typemap(typecheck) signed char [ANY],
14232             'code' : ,
14233             'type' : a(ANY).signed char,
14234         }
14235 ,
14236         'tmap:javaout' : Hash {
14237             'typemap' : typemap(javaout) signed char [ANY],
14238             'code' : {
14239     return $jnicall;
14240   },
14241             'type' : a(ANY).signed char,
14242         }
14243 ,
14244     }
14245 ,
14246     'a().signed char' : Hash {
14247         'tmap:freearg' : Hash {
14248             'typemap' : typemap(freearg) signed char [],
14249             'code' :  delete [] $1; ,
14250             'type' : a().signed char,
14251         }
14252 ,
14253         'tmap:jstype' : Hash {
14254             'typemap' : typemap(jstype) signed char [],
14255             'code' : byte[],
14256             'type' : a().signed char,
14257         }
14258 ,
14259         'tmap:argout' : Hash {
14260             'typemap' : typemap(argout) signed char [],
14261             'code' :  SWIG_JavaArrayArgoutSchar(jenv, jarr$argnum, $1, $input); ,
14262             'type' : a().signed char,
14263         }
14264 ,
14265         'tmap:in' : Hash {
14266             'locals' : Hash {
14267                 'name' : jarr,
14268                 'type' : p.jbyte,
14269             }
14270 ,
14271             'kwargs' : Hash {
14272                 'name' : numinputs,
14273                 'value' : 1,
14274             }
14275 ,
14276             'typemap' : typemap(in) signed char [],
14277             'code' :   if (!SWIG_JavaArrayInSchar(jenv, &jarr, &$1, $input)) return $null; ,
14278             'type' : a().signed char,
14279         }
14280 ,
14281         'tmap:jni' : Hash {
14282             'typemap' : typemap(jni) signed char [],
14283             'code' : jbyteArray,
14284             'type' : a().signed char,
14285         }
14286 ,
14287         'tmap:jtype' : Hash {
14288             'typemap' : typemap(jtype) signed char [],
14289             'code' : byte[],
14290             'type' : a().signed char,
14291         }
14292 ,
14293         'tmap:out' : Hash {
14294             'typemap' : typemap(out) signed char [],
14295             'code' : $result = SWIG_JavaArrayOutSchar(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
14296             'type' : a().signed char,
14297         }
14298 ,
14299         'tmap:javain' : Hash {
14300             'typemap' : typemap(javain) signed char [],
14301             'code' : $javainput,
14302             'type' : a().signed char,
14303         }
14304 ,
14305         'tmap:typecheck' : Hash {
14306             'kwargs' : Hash {
14307                 'name' : precedence,
14308                 'value' : 1025,
14309             }
14310 ,
14311             'typemap' : typemap(typecheck) signed char [],
14312             'code' : ,
14313             'type' : a().signed char,
14314         }
14315 ,
14316         'tmap:javaout' : Hash {
14317             'typemap' : typemap(javaout) signed char [],
14318             'code' : {
14319     return $jnicall;
14320   },
14321             'type' : a().signed char,
14322         }
14323 ,
14324     }
14325 ,
14326     'a(ANY).unsigned char' : Hash {
14327         'tmap:freearg' : Hash {
14328             'typemap' : typemap(freearg) unsigned char [ANY],
14329             'code' :  delete [] $1; ,
14330             'type' : a(ANY).unsigned char,
14331         }
14332 ,
14333         'tmap:jstype' : Hash {
14334             'typemap' : typemap(jstype) unsigned char [ANY],
14335             'code' : short[],
14336             'type' : a(ANY).unsigned char,
14337         }
14338 ,
14339         'tmap:argout' : Hash {
14340             'typemap' : typemap(argout) unsigned char [ANY],
14341             'code' :  SWIG_JavaArrayArgoutUchar(jenv, jarr$argnum, $1, $input); ,
14342             'type' : a(ANY).unsigned char,
14343         }
14344 ,
14345         'tmap:in' : Hash {
14346             'locals' : Hash {
14347                 'name' : jarr,
14348                 'type' : p.jshort,
14349             }
14350 ,
14351             'kwargs' : Hash {
14352                 'name' : numinputs,
14353                 'value' : 1,
14354             }
14355 ,
14356             'typemap' : typemap(in) unsigned char [ANY],
14357             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
14358     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
14359     return $null;
14360   }
14361   if (!SWIG_JavaArrayInUchar(jenv, &jarr, &$1, $input)) return $null; ,
14362             'type' : a(ANY).unsigned char,
14363         }
14364 ,
14365         'tmap:jni' : Hash {
14366             'typemap' : typemap(jni) unsigned char [ANY],
14367             'code' : jshortArray,
14368             'type' : a(ANY).unsigned char,
14369         }
14370 ,
14371         'tmap:jtype' : Hash {
14372             'typemap' : typemap(jtype) unsigned char [ANY],
14373             'code' : short[],
14374             'type' : a(ANY).unsigned char,
14375         }
14376 ,
14377         'tmap:out' : Hash {
14378             'typemap' : typemap(out) unsigned char [ANY],
14379             'code' : $result = SWIG_JavaArrayOutUchar(jenv, $1, $1_dim0); ,
14380             'type' : a(ANY).unsigned char,
14381         }
14382 ,
14383         'tmap:javain' : Hash {
14384             'typemap' : typemap(javain) unsigned char [ANY],
14385             'code' : $javainput,
14386             'type' : a(ANY).unsigned char,
14387         }
14388 ,
14389         'tmap:typecheck' : Hash {
14390             'kwargs' : Hash {
14391                 'name' : precedence,
14392                 'value' : 1035,
14393             }
14394 ,
14395             'typemap' : typemap(typecheck) unsigned char [ANY],
14396             'code' : ,
14397             'type' : a(ANY).unsigned char,
14398         }
14399 ,
14400         'tmap:javaout' : Hash {
14401             'typemap' : typemap(javaout) unsigned char [ANY],
14402             'code' : {
14403     return $jnicall;
14404   },
14405             'type' : a(ANY).unsigned char,
14406         }
14407 ,
14408     }
14409 ,
14410     'a().unsigned char' : Hash {
14411         'tmap:freearg' : Hash {
14412             'typemap' : typemap(freearg) unsigned char [],
14413             'code' :  delete [] $1; ,
14414             'type' : a().unsigned char,
14415         }
14416 ,
14417         'tmap:jstype' : Hash {
14418             'typemap' : typemap(jstype) unsigned char [],
14419             'code' : short[],
14420             'type' : a().unsigned char,
14421         }
14422 ,
14423         'tmap:argout' : Hash {
14424             'typemap' : typemap(argout) unsigned char [],
14425             'code' :  SWIG_JavaArrayArgoutUchar(jenv, jarr$argnum, $1, $input); ,
14426             'type' : a().unsigned char,
14427         }
14428 ,
14429         'tmap:in' : Hash {
14430             'locals' : Hash {
14431                 'name' : jarr,
14432                 'type' : p.jshort,
14433             }
14434 ,
14435             'kwargs' : Hash {
14436                 'name' : numinputs,
14437                 'value' : 1,
14438             }
14439 ,
14440             'typemap' : typemap(in) unsigned char [],
14441             'code' :   if (!SWIG_JavaArrayInUchar(jenv, &jarr, &$1, $input)) return $null; ,
14442             'type' : a().unsigned char,
14443         }
14444 ,
14445         'tmap:jni' : Hash {
14446             'typemap' : typemap(jni) unsigned char [],
14447             'code' : jshortArray,
14448             'type' : a().unsigned char,
14449         }
14450 ,
14451         'tmap:jtype' : Hash {
14452             'typemap' : typemap(jtype) unsigned char [],
14453             'code' : short[],
14454             'type' : a().unsigned char,
14455         }
14456 ,
14457         'tmap:out' : Hash {
14458             'typemap' : typemap(out) unsigned char [],
14459             'code' : $result = SWIG_JavaArrayOutUchar(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
14460             'type' : a().unsigned char,
14461         }
14462 ,
14463         'tmap:javain' : Hash {
14464             'typemap' : typemap(javain) unsigned char [],
14465             'code' : $javainput,
14466             'type' : a().unsigned char,
14467         }
14468 ,
14469         'tmap:typecheck' : Hash {
14470             'kwargs' : Hash {
14471                 'name' : precedence,
14472                 'value' : 1035,
14473             }
14474 ,
14475             'typemap' : typemap(typecheck) unsigned char [],
14476             'code' : ,
14477             'type' : a().unsigned char,
14478         }
14479 ,
14480         'tmap:javaout' : Hash {
14481             'typemap' : typemap(javaout) unsigned char [],
14482             'code' : {
14483     return $jnicall;
14484   },
14485             'type' : a().unsigned char,
14486         }
14487 ,
14488     }
14489 ,
14490     'r.q(const).int' : Hash {
14491         'tmap:jstype' : Hash {
14492             'typemap' : typemap(jstype) int const &,
14493             'code' : int,
14494             'type' : r.q(const).int,
14495         }
14496 ,
14497         'tmap:directorin' : Hash {
14498             'kwargs' : Hash {
14499                 'name' : descriptor,
14500                 'value' : I,
14501             }
14502 ,
14503             'typemap' : typemap(directorin) int const &,
14504             'code' : $input = (jint)$1_name;,
14505             'type' : r.q(const).int,
14506         }
14507 ,
14508         'tmap:javadirectorin' : Hash {
14509             'locals' : Hash {
14510                 'name' : temp,
14511                 'type' : $*1_ltype,
14512             }
14513 ,
14514             'typemap' : typemap(javadirectorin) int const &,
14515             'code' : $jniinput,
14516             'type' : r.q(const).int,
14517         }
14518 ,
14519         'tmap:in' : Hash {
14520             'locals' : Hash {
14521                 'name' : temp,
14522                 'type' : $*1_ltype,
14523             }
14524 ,
14525             'kwargs' : Hash {
14526                 'name' : numinputs,
14527                 'value' : 1,
14528             }
14529 ,
14530             'typemap' : typemap(in) int const &,
14531             'code' :  temp = ($*1_ltype)$input;
14532    $1 = &temp; ,
14533             'type' : r.q(const).int,
14534         }
14535 ,
14536         'tmap:directorout' : Hash {
14537             'kwargs' : Hash {
14538                 'name' : warning,
14539                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
14540             }
14541 ,
14542             'typemap' : typemap(directorout) int const &,
14543             'code' :  static $*1_ltype temp;
14544    temp = ($*1_ltype)$input;
14545    $result = &temp; ,
14546             'type' : r.q(const).int,
14547         }
14548 ,
14549         'tmap:javadirectorout' : Hash {
14550             'locals' : Hash {
14551                 'name' : temp,
14552                 'type' : $*1_ltype,
14553             }
14554 ,
14555             'typemap' : typemap(javadirectorout) int const &,
14556             'code' : $javacall,
14557             'type' : r.q(const).int,
14558         }
14559 ,
14560         'tmap:jni' : Hash {
14561             'typemap' : typemap(jni) int const &,
14562             'code' : jint,
14563             'type' : r.q(const).int,
14564         }
14565 ,
14566         'tmap:jtype' : Hash {
14567             'typemap' : typemap(jtype) int const &,
14568             'code' : int,
14569             'type' : r.q(const).int,
14570         }
14571 ,
14572         'tmap:out' : Hash {
14573             'typemap' : typemap(out) int const &,
14574             'code' :  $result = (jint)*$1; ,
14575             'type' : r.q(const).int,
14576         }
14577 ,
14578         'tmap:typecheck' : Hash {
14579             'kwargs' : Hash {
14580                 'name' : precedence,
14581                 'value' : 45,
14582             }
14583 ,
14584             'typemap' : typemap(typecheck) int const &,
14585             'code' : ,
14586             'type' : r.q(const).int,
14587         }
14588 ,
14589         'tmap:javain' : Hash {
14590             'typemap' : typemap(javain) int const &,
14591             'code' : $javainput,
14592             'type' : r.q(const).int,
14593         }
14594 ,
14595         'tmap:javaout' : Hash {
14596             'typemap' : typemap(javaout) int const &,
14597             'code' : {
14598     return $jnicall;
14599   },
14600             'type' : r.q(const).int,
14601         }
14602 ,
14603     }
14604 ,
14605     'r.q(const).bool' : Hash {
14606         'tmap:jstype' : Hash {
14607             'typemap' : typemap(jstype) bool const &,
14608             'code' : boolean,
14609             'type' : r.q(const).bool,
14610         }
14611 ,
14612         'tmap:javadirectorin' : Hash {
14613             'typemap' : typemap(javadirectorin) bool const &,
14614             'code' : $jniinput,
14615             'type' : r.q(const).bool,
14616         }
14617 ,
14618         'tmap:directorin' : Hash {
14619             'kwargs' : Hash {
14620                 'name' : descriptor,
14621                 'value' : Z,
14622             }
14623 ,
14624             'typemap' : typemap(directorin) bool const &,
14625             'code' : $input = (jboolean)$1_name;,
14626             'type' : r.q(const).bool,
14627         }
14628 ,
14629         'tmap:in' : Hash {
14630             'locals' : Hash {
14631                 'name' : temp,
14632                 'type' : $*1_ltype,
14633             }
14634 ,
14635             'kwargs' : Hash {
14636                 'name' : numinputs,
14637                 'value' : 1,
14638             }
14639 ,
14640             'typemap' : typemap(in) bool const &,
14641             'code' :  temp = $input ? true : false;
14642    $1 = &temp; ,
14643             'type' : r.q(const).bool,
14644         }
14645 ,
14646         'tmap:directorout' : Hash {
14647             'kwargs' : Hash {
14648                 'name' : warning,
14649                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
14650             }
14651 ,
14652             'typemap' : typemap(directorout) bool const &,
14653             'code' :  static $*1_ltype temp;
14654    temp = $input ? true : false;
14655    $result = &temp; ,
14656             'type' : r.q(const).bool,
14657         }
14658 ,
14659         'tmap:javadirectorout' : Hash {
14660             'typemap' : typemap(javadirectorout) bool const &,
14661             'code' : $javacall,
14662             'type' : r.q(const).bool,
14663         }
14664 ,
14665         'tmap:jni' : Hash {
14666             'typemap' : typemap(jni) bool const &,
14667             'code' : jboolean,
14668             'type' : r.q(const).bool,
14669         }
14670 ,
14671         'tmap:jtype' : Hash {
14672             'typemap' : typemap(jtype) bool const &,
14673             'code' : boolean,
14674             'type' : r.q(const).bool,
14675         }
14676 ,
14677         'tmap:out' : Hash {
14678             'typemap' : typemap(out) bool const &,
14679             'code' :  $result = (jboolean)*$1; ,
14680             'type' : r.q(const).bool,
14681         }
14682 ,
14683         'tmap:typecheck' : Hash {
14684             'kwargs' : Hash {
14685                 'name' : precedence,
14686                 'value' : 15,
14687             }
14688 ,
14689             'typemap' : typemap(typecheck) bool const &,
14690             'code' : ,
14691             'type' : r.q(const).bool,
14692         }
14693 ,
14694         'tmap:javain' : Hash {
14695             'typemap' : typemap(javain) bool const &,
14696             'code' : $javainput,
14697             'type' : r.q(const).bool,
14698         }
14699 ,
14700         'tmap:javaout' : Hash {
14701             'typemap' : typemap(javaout) bool const &,
14702             'code' : {
14703     return $jnicall;
14704   },
14705             'type' : r.q(const).bool,
14706         }
14707 ,
14708     }
14709 ,
14710     'a().bool' : Hash {
14711         'tmap:freearg' : Hash {
14712             'typemap' : typemap(freearg) bool [],
14713             'code' :  delete [] $1; ,
14714             'type' : a().bool,
14715         }
14716 ,
14717         'tmap:jstype' : Hash {
14718             'typemap' : typemap(jstype) bool [],
14719             'code' : boolean[],
14720             'type' : a().bool,
14721         }
14722 ,
14723         'tmap:argout' : Hash {
14724             'typemap' : typemap(argout) bool [],
14725             'code' :  SWIG_JavaArrayArgoutBool(jenv, jarr$argnum, $1, $input); ,
14726             'type' : a().bool,
14727         }
14728 ,
14729         'tmap:in' : Hash {
14730             'locals' : Hash {
14731                 'name' : jarr,
14732                 'type' : p.jboolean,
14733             }
14734 ,
14735             'kwargs' : Hash {
14736                 'name' : numinputs,
14737                 'value' : 1,
14738             }
14739 ,
14740             'typemap' : typemap(in) bool [],
14741             'code' :   if (!SWIG_JavaArrayInBool(jenv, &jarr, &$1, $input)) return $null; ,
14742             'type' : a().bool,
14743         }
14744 ,
14745         'tmap:jni' : Hash {
14746             'typemap' : typemap(jni) bool [],
14747             'code' : jbooleanArray,
14748             'type' : a().bool,
14749         }
14750 ,
14751         'tmap:jtype' : Hash {
14752             'typemap' : typemap(jtype) bool [],
14753             'code' : boolean[],
14754             'type' : a().bool,
14755         }
14756 ,
14757         'tmap:out' : Hash {
14758             'typemap' : typemap(out) bool [],
14759             'code' : $result = SWIG_JavaArrayOutBool(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
14760             'type' : a().bool,
14761         }
14762 ,
14763         'tmap:javain' : Hash {
14764             'typemap' : typemap(javain) bool [],
14765             'code' : $javainput,
14766             'type' : a().bool,
14767         }
14768 ,
14769         'tmap:typecheck' : Hash {
14770             'kwargs' : Hash {
14771                 'name' : precedence,
14772                 'value' : 1015,
14773             }
14774 ,
14775             'typemap' : typemap(typecheck) bool [],
14776             'code' : ,
14777             'type' : a().bool,
14778         }
14779 ,
14780         'tmap:javaout' : Hash {
14781             'typemap' : typemap(javaout) bool [],
14782             'code' : {
14783     return $jnicall;
14784   },
14785             'type' : a().bool,
14786         }
14787 ,
14788     }
14789 ,
14790     'r.q(const).size_t' : Hash {
14791         'tmap:jstype' : Hash {
14792             'typemap' : typemap(jstype) size_t const &,
14793             'code' : long,
14794             'type' : r.q(const).size_t,
14795         }
14796 ,
14797         'tmap:directorin' : Hash {
14798             'kwargs' : Hash {
14799                 'name' : descriptor,
14800                 'value' : J,
14801             }
14802 ,
14803             'typemap' : typemap(directorin) size_t const &,
14804             'code' : $input = (jlong)$1_name;,
14805             'type' : r.q(const).size_t,
14806         }
14807 ,
14808         'tmap:javadirectorin' : Hash {
14809             'locals' : Hash {
14810                 'name' : temp,
14811                 'type' : $*1_ltype,
14812             }
14813 ,
14814             'typemap' : typemap(javadirectorin) size_t const &,
14815             'code' : $jniinput,
14816             'type' : r.q(const).size_t,
14817         }
14818 ,
14819         'tmap:in' : Hash {
14820             'locals' : Hash {
14821                 'name' : temp,
14822                 'type' : $*1_ltype,
14823             }
14824 ,
14825             'kwargs' : Hash {
14826                 'name' : numinputs,
14827                 'value' : 1,
14828             }
14829 ,
14830             'typemap' : typemap(in) size_t const &,
14831             'code' :  temp = ($*1_ltype)$input;
14832    $1 = &temp; ,
14833             'type' : r.q(const).size_t,
14834         }
14835 ,
14836         'tmap:directorout' : Hash {
14837             'kwargs' : Hash {
14838                 'name' : warning,
14839                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
14840             }
14841 ,
14842             'typemap' : typemap(directorout) size_t const &,
14843             'code' :  static $*1_ltype temp;
14844    temp = ($*1_ltype)$input;
14845    $result = &temp; ,
14846             'type' : r.q(const).size_t,
14847         }
14848 ,
14849         'tmap:javadirectorout' : Hash {
14850             'locals' : Hash {
14851                 'name' : temp,
14852                 'type' : $*1_ltype,
14853             }
14854 ,
14855             'typemap' : typemap(javadirectorout) size_t const &,
14856             'code' : $javacall,
14857             'type' : r.q(const).size_t,
14858         }
14859 ,
14860         'tmap:jni' : Hash {
14861             'typemap' : typemap(jni) size_t const &,
14862             'code' : jlong,
14863             'type' : r.q(const).size_t,
14864         }
14865 ,
14866         'tmap:jtype' : Hash {
14867             'typemap' : typemap(jtype) size_t const &,
14868             'code' : long,
14869             'type' : r.q(const).size_t,
14870         }
14871 ,
14872         'tmap:out' : Hash {
14873             'typemap' : typemap(out) size_t const &,
14874             'code' :  $result = (jlong)*$1; ,
14875             'type' : r.q(const).size_t,
14876         }
14877 ,
14878         'tmap:typecheck' : Hash {
14879             'kwargs' : Hash {
14880                 'name' : precedence,
14881                 'value' : 55,
14882             }
14883 ,
14884             'typemap' : typemap(typecheck) size_t const &,
14885             'code' : ,
14886             'type' : r.q(const).size_t,
14887         }
14888 ,
14889         'tmap:javain' : Hash {
14890             'typemap' : typemap(javain) size_t const &,
14891             'code' : $javainput,
14892             'type' : r.q(const).size_t,
14893         }
14894 ,
14895         'tmap:javaout' : Hash {
14896             'typemap' : typemap(javaout) size_t const &,
14897             'code' : {
14898     return $jnicall;
14899   },
14900             'type' : r.q(const).size_t,
14901         }
14902 ,
14903     }
14904 ,
14905     'size_t' : Hash {
14906         'tmap:jstype' : Hash {
14907             'typemap' : typemap(jstype) size_t,
14908             'code' : long,
14909             'type' : size_t,
14910         }
14911 ,
14912         'tmap:directorin' : Hash {
14913             'kwargs' : Hash {
14914                 'name' : descriptor,
14915                 'value' : J,
14916             }
14917 ,
14918             'typemap' : typemap(directorin) size_t,
14919             'code' : $input = (jlong) $1;,
14920             'type' : size_t,
14921         }
14922 ,
14923         'tmap:javadirectorin' : Hash {
14924             'typemap' : typemap(javadirectorin) size_t,
14925             'code' : $jniinput,
14926             'type' : size_t,
14927         }
14928 ,
14929         'tmap:in' : Hash {
14930             'kwargs' : Hash {
14931                 'name' : numinputs,
14932                 'value' : 1,
14933             }
14934 ,
14935             'typemap' : typemap(in) size_t,
14936             'code' :  $1 = ($1_ltype)$input; ,
14937             'type' : size_t,
14938         }
14939 ,
14940         'tmap:directorout' : Hash {
14941             'typemap' : typemap(directorout) size_t,
14942             'code' :  $result = ($1_ltype)$input; ,
14943             'type' : size_t,
14944         }
14945 ,
14946         'tmap:javadirectorout' : Hash {
14947             'typemap' : typemap(javadirectorout) size_t,
14948             'code' : $javacall,
14949             'type' : size_t,
14950         }
14951 ,
14952         'tmap:jni' : Hash {
14953             'typemap' : typemap(jni) size_t,
14954             'code' : jlong,
14955             'type' : size_t,
14956         }
14957 ,
14958         'tmap:jtype' : Hash {
14959             'typemap' : typemap(jtype) size_t,
14960             'code' : long,
14961             'type' : size_t,
14962         }
14963 ,
14964         'tmap:out' : Hash {
14965             'typemap' : typemap(out) size_t,
14966             'code' :  $result = (jlong)$1; ,
14967             'type' : size_t,
14968         }
14969 ,
14970         'tmap:typecheck' : Hash {
14971             'kwargs' : Hash {
14972                 'name' : precedence,
14973                 'value' : 55,
14974             }
14975 ,
14976             'typemap' : typemap(typecheck) size_t,
14977             'code' : ,
14978             'type' : size_t,
14979         }
14980 ,
14981         'tmap:throws' : Hash {
14982             'typemap' : typemap(throws) size_t,
14983             'code' :  char error_msg[256];
14984    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
14985    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
14986    return $null; ,
14987             'type' : size_t,
14988         }
14989 ,
14990         'tmap:javain' : Hash {
14991             'typemap' : typemap(javain) size_t,
14992             'code' : $javainput,
14993             'type' : size_t,
14994         }
14995 ,
14996         'tmap:javaout' : Hash {
14997             'typemap' : typemap(javaout) size_t,
14998             'code' : {
14999     return $jnicall;
15000   },
15001             'type' : size_t,
15002         }
15003 ,
15004     }
15005 ,
15006     'p.unsigned short' : Hash {
15007         'INOUT' : Hash {
15008             'tmap:freearg' : Hash {
15009                 'pname' : INOUT,
15010                 'typemap' : typemap(freearg) unsigned short *INOUT,
15011                 'code' : ,
15012                 'type' : p.unsigned short,
15013             }
15014 ,
15015             'tmap:jstype' : Hash {
15016                 'pname' : INOUT,
15017                 'typemap' : typemap(jstype) unsigned short *INOUT,
15018                 'code' : int[],
15019                 'type' : p.unsigned short,
15020             }
15021 ,
15022             'tmap:javadirectorin' : Hash {
15023                 'pname' : INOUT,
15024                 'typemap' : typemap(javadirectorin) unsigned short *INOUT,
15025                 'code' : $jniinput,
15026                 'type' : p.unsigned short,
15027             }
15028 ,
15029             'tmap:directorin' : Hash {
15030                 'kwargs' : Hash {
15031                     'name' : descriptor,
15032                     'value' : [Ljava/lang/Integer;,
15033                     'nextSibling' : Hash {
15034                         'name' : warning,
15035                         'value' : Need to provide unsigned short *INOUT directorin typemap, unsigned short array length is unknown,
15036                     }
15037 ,
15038                 }
15039 ,
15040                 'pname' : INOUT,
15041                 'typemap' : typemap(directorin) unsigned short *INOUT,
15042                 'code' : {
15043 },
15044                 'type' : p.unsigned short,
15045             }
15046 ,
15047             'tmap:argout' : Hash {
15048                 'pname' : INOUT,
15049                 'typemap' : typemap(argout) unsigned short *INOUT,
15050                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
15051                 'type' : p.unsigned short,
15052             }
15053 ,
15054             'tmap:javadirectorout' : Hash {
15055                 'pname' : INOUT,
15056                 'typemap' : typemap(javadirectorout) unsigned short *INOUT,
15057                 'code' : $javacall,
15058                 'type' : p.unsigned short,
15059             }
15060 ,
15061             'tmap:in' : Hash {
15062                 'kwargs' : Hash {
15063                     'name' : numinputs,
15064                     'value' : 1,
15065                 }
15066 ,
15067                 'pname' : INOUT,
15068                 'typemap' : typemap(in) unsigned short *INOUT,
15069                 'code' : {
15070   if (!$input) {
15071     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
15072     return $null;
15073   }
15074   if (jenv->GetArrayLength($input) == 0) {
15075     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
15076     return $null;
15077   }
15078   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
15079 },
15080                 'type' : p.unsigned short,
15081             }
15082 ,
15083             'tmap:directorout' : Hash {
15084                 'kwargs' : Hash {
15085                     'name' : warning,
15086                     'value' : Need to provide unsigned short *INOUT directorout typemap,
15087                 }
15088 ,
15089                 'pname' : INOUT,
15090                 'typemap' : typemap(directorout) unsigned short *INOUT,
15091                 'code' : {
15092 },
15093                 'type' : p.unsigned short,
15094             }
15095 ,
15096             'tmap:typecheck' : Hash {
15097                 'kwargs' : Hash {
15098                     'name' : precedence,
15099                     'value' : 1045,
15100                 }
15101 ,
15102                 'pname' : INOUT,
15103                 'typemap' : typemap(typecheck) unsigned short *INOUT,
15104                 'code' : ,
15105                 'type' : p.unsigned short,
15106             }
15107 ,
15108             'tmap:jni' : Hash {
15109                 'pname' : INOUT,
15110                 'typemap' : typemap(jni) unsigned short *INOUT,
15111                 'code' : jintArray,
15112                 'type' : p.unsigned short,
15113             }
15114 ,
15115             'tmap:jtype' : Hash {
15116                 'pname' : INOUT,
15117                 'typemap' : typemap(jtype) unsigned short *INOUT,
15118                 'code' : int[],
15119                 'type' : p.unsigned short,
15120             }
15121 ,
15122             'tmap:javain' : Hash {
15123                 'pname' : INOUT,
15124                 'typemap' : typemap(javain) unsigned short *INOUT,
15125                 'code' : $javainput,
15126                 'type' : p.unsigned short,
15127             }
15128 ,
15129         }
15130 ,
15131         'INPUT' : Hash {
15132             'tmap:freearg' : Hash {
15133                 'pname' : INPUT,
15134                 'typemap' : typemap(freearg) unsigned short *INPUT,
15135                 'code' : ,
15136                 'type' : p.unsigned short,
15137             }
15138 ,
15139             'tmap:jstype' : Hash {
15140                 'pname' : INPUT,
15141                 'typemap' : typemap(jstype) unsigned short *INPUT,
15142                 'code' : int,
15143                 'type' : p.unsigned short,
15144             }
15145 ,
15146             'tmap:javadirectorin' : Hash {
15147                 'pname' : INPUT,
15148                 'typemap' : typemap(javadirectorin) unsigned short *INPUT,
15149                 'code' : $jniinput,
15150                 'type' : p.unsigned short,
15151             }
15152 ,
15153             'tmap:directorin' : Hash {
15154                 'kwargs' : Hash {
15155                     'name' : descriptor,
15156                     'value' : I,
15157                 }
15158 ,
15159                 'pname' : INPUT,
15160                 'typemap' : typemap(directorin) unsigned short *INPUT,
15161                 'code' :  *(($&1_ltype) $input) = (jint *) $1; ,
15162                 'type' : p.unsigned short,
15163             }
15164 ,
15165             'tmap:javadirectorout' : Hash {
15166                 'pname' : INPUT,
15167                 'typemap' : typemap(javadirectorout) unsigned short *INPUT,
15168                 'code' : $javacall,
15169                 'type' : p.unsigned short,
15170             }
15171 ,
15172             'tmap:in' : Hash {
15173                 'kwargs' : Hash {
15174                     'name' : numinputs,
15175                     'value' : 1,
15176                 }
15177 ,
15178                 'pname' : INPUT,
15179                 'typemap' : typemap(in) unsigned short *INPUT,
15180                 'code' :  $1 = ($1_ltype)&$input; ,
15181                 'type' : p.unsigned short,
15182             }
15183 ,
15184             'tmap:directorout' : Hash {
15185                 'pname' : INPUT,
15186                 'typemap' : typemap(directorout) unsigned short *INPUT,
15187                 'code' :  $result = ($1_ltype)&$input; ,
15188                 'type' : p.unsigned short,
15189             }
15190 ,
15191             'tmap:jni' : Hash {
15192                 'pname' : INPUT,
15193                 'typemap' : typemap(jni) unsigned short *INPUT,
15194                 'code' : jint,
15195                 'type' : p.unsigned short,
15196             }
15197 ,
15198             'tmap:jtype' : Hash {
15199                 'pname' : INPUT,
15200                 'typemap' : typemap(jtype) unsigned short *INPUT,
15201                 'code' : int,
15202                 'type' : p.unsigned short,
15203             }
15204 ,
15205             'tmap:javain' : Hash {
15206                 'pname' : INPUT,
15207                 'typemap' : typemap(javain) unsigned short *INPUT,
15208                 'code' : $javainput,
15209                 'type' : p.unsigned short,
15210             }
15211 ,
15212             'tmap:typecheck' : Hash {
15213                 'kwargs' : Hash {
15214                     'name' : precedence,
15215                     'value' : 45,
15216                 }
15217 ,
15218                 'pname' : INPUT,
15219                 'typemap' : typemap(typecheck) unsigned short *INPUT,
15220                 'code' : ,
15221                 'type' : p.unsigned short,
15222             }
15223 ,
15224         }
15225 ,
15226         'OUTPUT' : Hash {
15227             'tmap:freearg' : Hash {
15228                 'pname' : OUTPUT,
15229                 'typemap' : typemap(freearg) unsigned short *OUTPUT,
15230                 'code' : ,
15231                 'type' : p.unsigned short,
15232             }
15233 ,
15234             'tmap:jstype' : Hash {
15235                 'pname' : OUTPUT,
15236                 'typemap' : typemap(jstype) unsigned short *OUTPUT,
15237                 'code' : int[],
15238                 'type' : p.unsigned short,
15239             }
15240 ,
15241             'tmap:javadirectorin' : Hash {
15242                 'pname' : OUTPUT,
15243                 'typemap' : typemap(javadirectorin) unsigned short *OUTPUT,
15244                 'code' : $jniinput,
15245                 'type' : p.unsigned short,
15246             }
15247 ,
15248             'tmap:directorin' : Hash {
15249                 'kwargs' : Hash {
15250                     'name' : descriptor,
15251                     'value' : [Ljava/lang/Integer;,
15252                     'nextSibling' : Hash {
15253                         'name' : warning,
15254                         'value' : Need to provide unsigned short *OUTPUT directorin typemap, unsigned short array length is unknown,
15255                     }
15256 ,
15257                 }
15258 ,
15259                 'pname' : OUTPUT,
15260                 'typemap' : typemap(directorin) unsigned short *OUTPUT,
15261                 'code' : {
15262 },
15263                 'type' : p.unsigned short,
15264             }
15265 ,
15266             'tmap:argout' : Hash {
15267                 'pname' : OUTPUT,
15268                 'typemap' : typemap(argout) unsigned short *OUTPUT,
15269                 'code' : {
15270   jint jvalue = (jint)temp$argnum;
15271   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
15272 },
15273                 'type' : p.unsigned short,
15274             }
15275 ,
15276             'tmap:javadirectorout' : Hash {
15277                 'pname' : OUTPUT,
15278                 'typemap' : typemap(javadirectorout) unsigned short *OUTPUT,
15279                 'code' : $javacall,
15280                 'type' : p.unsigned short,
15281             }
15282 ,
15283             'tmap:in' : Hash {
15284                 'locals' : Hash {
15285                     'name' : temp,
15286                     'type' : $*1_ltype,
15287                 }
15288 ,
15289                 'kwargs' : Hash {
15290                     'name' : numinputs,
15291                     'value' : 1,
15292                 }
15293 ,
15294                 'pname' : OUTPUT,
15295                 'typemap' : typemap(in) unsigned short *OUTPUT,
15296                 'code' : {
15297   if (!$input) {
15298     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
15299     return $null;
15300   }
15301   if (jenv->GetArrayLength($input) == 0) {
15302     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
15303     return $null;
15304   }
15305   $1 = &temp;
15306 },
15307                 'type' : p.unsigned short,
15308             }
15309 ,
15310             'tmap:directorout' : Hash {
15311                 'kwargs' : Hash {
15312                     'name' : warning,
15313                     'value' : Need to provide unsigned short *OUTPUT directorout typemap,
15314                 }
15315 ,
15316                 'pname' : OUTPUT,
15317                 'typemap' : typemap(directorout) unsigned short *OUTPUT,
15318                 'code' : {
15319 },
15320                 'type' : p.unsigned short,
15321             }
15322 ,
15323             'tmap:jni' : Hash {
15324                 'pname' : OUTPUT,
15325                 'typemap' : typemap(jni) unsigned short *OUTPUT,
15326                 'code' : jintArray,
15327                 'type' : p.unsigned short,
15328             }
15329 ,
15330             'tmap:jtype' : Hash {
15331                 'pname' : OUTPUT,
15332                 'typemap' : typemap(jtype) unsigned short *OUTPUT,
15333                 'code' : int[],
15334                 'type' : p.unsigned short,
15335             }
15336 ,
15337             'tmap:javain' : Hash {
15338                 'pname' : OUTPUT,
15339                 'typemap' : typemap(javain) unsigned short *OUTPUT,
15340                 'code' : $javainput,
15341                 'type' : p.unsigned short,
15342             }
15343 ,
15344         }
15345 ,
15346     }
15347 ,
15348     'unsigned short' : Hash {
15349         'tmap:jstype' : Hash {
15350             'typemap' : typemap(jstype) unsigned short,
15351             'code' : int,
15352             'type' : unsigned short,
15353         }
15354 ,
15355         'tmap:directorin' : Hash {
15356             'kwargs' : Hash {
15357                 'name' : descriptor,
15358                 'value' : I,
15359             }
15360 ,
15361             'typemap' : typemap(directorin) unsigned short,
15362             'code' : $input = (jint) $1;,
15363             'type' : unsigned short,
15364         }
15365 ,
15366         'tmap:javadirectorin' : Hash {
15367             'typemap' : typemap(javadirectorin) unsigned short,
15368             'code' : $jniinput,
15369             'type' : unsigned short,
15370         }
15371 ,
15372         'tmap:in' : Hash {
15373             'kwargs' : Hash {
15374                 'name' : numinputs,
15375                 'value' : 1,
15376             }
15377 ,
15378             'typemap' : typemap(in) unsigned short,
15379             'code' :  $1 = ($1_ltype)$input; ,
15380             'type' : unsigned short,
15381         }
15382 ,
15383         'tmap:directorout' : Hash {
15384             'typemap' : typemap(directorout) unsigned short,
15385             'code' :  $result = ($1_ltype)$input; ,
15386             'type' : unsigned short,
15387         }
15388 ,
15389         'tmap:javadirectorout' : Hash {
15390             'typemap' : typemap(javadirectorout) unsigned short,
15391             'code' : $javacall,
15392             'type' : unsigned short,
15393         }
15394 ,
15395         'tmap:jni' : Hash {
15396             'typemap' : typemap(jni) unsigned short,
15397             'code' : jint,
15398             'type' : unsigned short,
15399         }
15400 ,
15401         'tmap:jtype' : Hash {
15402             'typemap' : typemap(jtype) unsigned short,
15403             'code' : int,
15404             'type' : unsigned short,
15405         }
15406 ,
15407         'tmap:out' : Hash {
15408             'typemap' : typemap(out) unsigned short,
15409             'code' :  $result = (jint)$1; ,
15410             'type' : unsigned short,
15411         }
15412 ,
15413         'tmap:typecheck' : Hash {
15414             'kwargs' : Hash {
15415                 'name' : precedence,
15416                 'value' : 45,
15417             }
15418 ,
15419             'typemap' : typemap(typecheck) unsigned short,
15420             'code' : ,
15421             'type' : unsigned short,
15422         }
15423 ,
15424         'tmap:throws' : Hash {
15425             'typemap' : typemap(throws) unsigned short,
15426             'code' :  char error_msg[256];
15427    sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1);
15428    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg);
15429    return $null; ,
15430             'type' : unsigned short,
15431         }
15432 ,
15433         'tmap:javain' : Hash {
15434             'typemap' : typemap(javain) unsigned short,
15435             'code' : $javainput,
15436             'type' : unsigned short,
15437         }
15438 ,
15439         'tmap:javaout' : Hash {
15440             'typemap' : typemap(javaout) unsigned short,
15441             'code' : {
15442     return $jnicall;
15443   },
15444             'type' : unsigned short,
15445         }
15446 ,
15447     }
15448 ,
15449     'r.q(const).unsigned short' : Hash {
15450         'tmap:jstype' : Hash {
15451             'typemap' : typemap(jstype) unsigned short const &,
15452             'code' : int,
15453             'type' : r.q(const).unsigned short,
15454         }
15455 ,
15456         'tmap:directorin' : Hash {
15457             'kwargs' : Hash {
15458                 'name' : descriptor,
15459                 'value' : I,
15460             }
15461 ,
15462             'typemap' : typemap(directorin) unsigned short const &,
15463             'code' : $input = (jint)$1_name;,
15464             'type' : r.q(const).unsigned short,
15465         }
15466 ,
15467         'tmap:javadirectorin' : Hash {
15468             'locals' : Hash {
15469                 'name' : temp,
15470                 'type' : $*1_ltype,
15471             }
15472 ,
15473             'typemap' : typemap(javadirectorin) unsigned short const &,
15474             'code' : $jniinput,
15475             'type' : r.q(const).unsigned short,
15476         }
15477 ,
15478         'tmap:in' : Hash {
15479             'locals' : Hash {
15480                 'name' : temp,
15481                 'type' : $*1_ltype,
15482             }
15483 ,
15484             'kwargs' : Hash {
15485                 'name' : numinputs,
15486                 'value' : 1,
15487             }
15488 ,
15489             'typemap' : typemap(in) unsigned short const &,
15490             'code' :  temp = ($*1_ltype)$input;
15491    $1 = &temp; ,
15492             'type' : r.q(const).unsigned short,
15493         }
15494 ,
15495         'tmap:directorout' : Hash {
15496             'kwargs' : Hash {
15497                 'name' : warning,
15498                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
15499             }
15500 ,
15501             'typemap' : typemap(directorout) unsigned short const &,
15502             'code' :  static $*1_ltype temp;
15503    temp = ($*1_ltype)$input;
15504    $result = &temp; ,
15505             'type' : r.q(const).unsigned short,
15506         }
15507 ,
15508         'tmap:javadirectorout' : Hash {
15509             'locals' : Hash {
15510                 'name' : temp,
15511                 'type' : $*1_ltype,
15512             }
15513 ,
15514             'typemap' : typemap(javadirectorout) unsigned short const &,
15515             'code' : $javacall,
15516             'type' : r.q(const).unsigned short,
15517         }
15518 ,
15519         'tmap:jni' : Hash {
15520             'typemap' : typemap(jni) unsigned short const &,
15521             'code' : jint,
15522             'type' : r.q(const).unsigned short,
15523         }
15524 ,
15525         'tmap:jtype' : Hash {
15526             'typemap' : typemap(jtype) unsigned short const &,
15527             'code' : int,
15528             'type' : r.q(const).unsigned short,
15529         }
15530 ,
15531         'tmap:out' : Hash {
15532             'typemap' : typemap(out) unsigned short const &,
15533             'code' :  $result = (jint)*$1; ,
15534             'type' : r.q(const).unsigned short,
15535         }
15536 ,
15537         'tmap:typecheck' : Hash {
15538             'kwargs' : Hash {
15539                 'name' : precedence,
15540                 'value' : 45,
15541             }
15542 ,
15543             'typemap' : typemap(typecheck) unsigned short const &,
15544             'code' : ,
15545             'type' : r.q(const).unsigned short,
15546         }
15547 ,
15548         'tmap:javain' : Hash {
15549             'typemap' : typemap(javain) unsigned short const &,
15550             'code' : $javainput,
15551             'type' : r.q(const).unsigned short,
15552         }
15553 ,
15554         'tmap:javaout' : Hash {
15555             'typemap' : typemap(javaout) unsigned short const &,
15556             'code' : {
15557     return $jnicall;
15558   },
15559             'type' : r.q(const).unsigned short,
15560         }
15561 ,
15562     }
15563 ,
15564     'r.unsigned short' : Hash {
15565         'INOUT' : Hash {
15566             'tmap:freearg' : Hash {
15567                 'pname' : INOUT,
15568                 'typemap' : typemap(freearg) unsigned short &INOUT,
15569                 'code' : ,
15570                 'type' : r.unsigned short,
15571             }
15572 ,
15573             'tmap:jstype' : Hash {
15574                 'pname' : INOUT,
15575                 'typemap' : typemap(jstype) unsigned short &INOUT,
15576                 'code' : int[],
15577                 'type' : r.unsigned short,
15578             }
15579 ,
15580             'tmap:javadirectorin' : Hash {
15581                 'pname' : INOUT,
15582                 'typemap' : typemap(javadirectorin) unsigned short &INOUT,
15583                 'code' : $jniinput,
15584                 'type' : r.unsigned short,
15585             }
15586 ,
15587             'tmap:directorin' : Hash {
15588                 'kwargs' : Hash {
15589                     'name' : descriptor,
15590                     'value' : [Ljava/lang/Integer;,
15591                     'nextSibling' : Hash {
15592                         'name' : warning,
15593                         'value' : Need to provide unsigned short *INOUT directorin typemap, unsigned short array length is unknown,
15594                     }
15595 ,
15596                 }
15597 ,
15598                 'pname' : INOUT,
15599                 'typemap' : typemap(directorin) unsigned short &INOUT,
15600                 'code' : {
15601 },
15602                 'type' : r.unsigned short,
15603             }
15604 ,
15605             'tmap:argout' : Hash {
15606                 'pname' : INOUT,
15607                 'typemap' : typemap(argout) unsigned short &INOUT,
15608                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
15609                 'type' : r.unsigned short,
15610             }
15611 ,
15612             'tmap:javadirectorout' : Hash {
15613                 'pname' : INOUT,
15614                 'typemap' : typemap(javadirectorout) unsigned short &INOUT,
15615                 'code' : $javacall,
15616                 'type' : r.unsigned short,
15617             }
15618 ,
15619             'tmap:in' : Hash {
15620                 'kwargs' : Hash {
15621                     'name' : numinputs,
15622                     'value' : 1,
15623                 }
15624 ,
15625                 'pname' : INOUT,
15626                 'typemap' : typemap(in) unsigned short &INOUT,
15627                 'code' : {
15628   if (!$input) {
15629     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
15630     return $null;
15631   }
15632   if (jenv->GetArrayLength($input) == 0) {
15633     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
15634     return $null;
15635   }
15636   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
15637 },
15638                 'type' : r.unsigned short,
15639             }
15640 ,
15641             'tmap:directorout' : Hash {
15642                 'kwargs' : Hash {
15643                     'name' : warning,
15644                     'value' : Need to provide unsigned short *INOUT directorout typemap,
15645                 }
15646 ,
15647                 'pname' : INOUT,
15648                 'typemap' : typemap(directorout) unsigned short &INOUT,
15649                 'code' : {
15650 },
15651                 'type' : r.unsigned short,
15652             }
15653 ,
15654             'tmap:typecheck' : Hash {
15655                 'kwargs' : Hash {
15656                     'name' : precedence,
15657                     'value' : 1045,
15658                 }
15659 ,
15660                 'pname' : INOUT,
15661                 'typemap' : typemap(typecheck) unsigned short &INOUT,
15662                 'code' : ,
15663                 'type' : r.unsigned short,
15664             }
15665 ,
15666             'tmap:jni' : Hash {
15667                 'pname' : INOUT,
15668                 'typemap' : typemap(jni) unsigned short &INOUT,
15669                 'code' : jintArray,
15670                 'type' : r.unsigned short,
15671             }
15672 ,
15673             'tmap:jtype' : Hash {
15674                 'pname' : INOUT,
15675                 'typemap' : typemap(jtype) unsigned short &INOUT,
15676                 'code' : int[],
15677                 'type' : r.unsigned short,
15678             }
15679 ,
15680             'tmap:javain' : Hash {
15681                 'pname' : INOUT,
15682                 'typemap' : typemap(javain) unsigned short &INOUT,
15683                 'code' : $javainput,
15684                 'type' : r.unsigned short,
15685             }
15686 ,
15687         }
15688 ,
15689         'INPUT' : Hash {
15690             'tmap:freearg' : Hash {
15691                 'pname' : INPUT,
15692                 'typemap' : typemap(freearg) unsigned short &INPUT,
15693                 'code' : ,
15694                 'type' : r.unsigned short,
15695             }
15696 ,
15697             'tmap:jstype' : Hash {
15698                 'pname' : INPUT,
15699                 'typemap' : typemap(jstype) unsigned short &INPUT,
15700                 'code' : int,
15701                 'type' : r.unsigned short,
15702             }
15703 ,
15704             'tmap:javadirectorin' : Hash {
15705                 'pname' : INPUT,
15706                 'typemap' : typemap(javadirectorin) unsigned short &INPUT,
15707                 'code' : $jniinput,
15708                 'type' : r.unsigned short,
15709             }
15710 ,
15711             'tmap:directorin' : Hash {
15712                 'kwargs' : Hash {
15713                     'name' : descriptor,
15714                     'value' : I,
15715                 }
15716 ,
15717                 'pname' : INPUT,
15718                 'typemap' : typemap(directorin) unsigned short &INPUT,
15719                 'code' :  *(($&1_ltype) $input) = (jint *) &$1; ,
15720                 'type' : r.unsigned short,
15721             }
15722 ,
15723             'tmap:javadirectorout' : Hash {
15724                 'pname' : INPUT,
15725                 'typemap' : typemap(javadirectorout) unsigned short &INPUT,
15726                 'code' : $javacall,
15727                 'type' : r.unsigned short,
15728             }
15729 ,
15730             'tmap:in' : Hash {
15731                 'kwargs' : Hash {
15732                     'name' : numinputs,
15733                     'value' : 1,
15734                 }
15735 ,
15736                 'pname' : INPUT,
15737                 'typemap' : typemap(in) unsigned short &INPUT,
15738                 'code' :  $1 = ($1_ltype)&$input; ,
15739                 'type' : r.unsigned short,
15740             }
15741 ,
15742             'tmap:directorout' : Hash {
15743                 'pname' : INPUT,
15744                 'typemap' : typemap(directorout) unsigned short &INPUT,
15745                 'code' :  $result = ($1_ltype)&$input; ,
15746                 'type' : r.unsigned short,
15747             }
15748 ,
15749             'tmap:jni' : Hash {
15750                 'pname' : INPUT,
15751                 'typemap' : typemap(jni) unsigned short &INPUT,
15752                 'code' : jint,
15753                 'type' : r.unsigned short,
15754             }
15755 ,
15756             'tmap:jtype' : Hash {
15757                 'pname' : INPUT,
15758                 'typemap' : typemap(jtype) unsigned short &INPUT,
15759                 'code' : int,
15760                 'type' : r.unsigned short,
15761             }
15762 ,
15763             'tmap:javain' : Hash {
15764                 'pname' : INPUT,
15765                 'typemap' : typemap(javain) unsigned short &INPUT,
15766                 'code' : $javainput,
15767                 'type' : r.unsigned short,
15768             }
15769 ,
15770             'tmap:typecheck' : Hash {
15771                 'kwargs' : Hash {
15772                     'name' : precedence,
15773                     'value' : 45,
15774                 }
15775 ,
15776                 'pname' : INPUT,
15777                 'typemap' : typemap(typecheck) unsigned short &INPUT,
15778                 'code' : ,
15779                 'type' : r.unsigned short,
15780             }
15781 ,
15782         }
15783 ,
15784         'OUTPUT' : Hash {
15785             'tmap:freearg' : Hash {
15786                 'pname' : OUTPUT,
15787                 'typemap' : typemap(freearg) unsigned short &OUTPUT,
15788                 'code' : ,
15789                 'type' : r.unsigned short,
15790             }
15791 ,
15792             'tmap:jstype' : Hash {
15793                 'pname' : OUTPUT,
15794                 'typemap' : typemap(jstype) unsigned short &OUTPUT,
15795                 'code' : int[],
15796                 'type' : r.unsigned short,
15797             }
15798 ,
15799             'tmap:javadirectorin' : Hash {
15800                 'pname' : OUTPUT,
15801                 'typemap' : typemap(javadirectorin) unsigned short &OUTPUT,
15802                 'code' : $jniinput,
15803                 'type' : r.unsigned short,
15804             }
15805 ,
15806             'tmap:directorin' : Hash {
15807                 'kwargs' : Hash {
15808                     'name' : descriptor,
15809                     'value' : [Ljava/lang/Integer;,
15810                 }
15811 ,
15812                 'pname' : OUTPUT,
15813                 'typemap' : typemap(directorin) unsigned short &OUTPUT,
15814                 'code' :  *(($&1_ltype) $input = &$1; ,
15815                 'type' : r.unsigned short,
15816             }
15817 ,
15818             'tmap:argout' : Hash {
15819                 'pname' : OUTPUT,
15820                 'typemap' : typemap(argout) unsigned short &OUTPUT,
15821                 'code' : {
15822   jint jvalue = (jint)temp$argnum;
15823   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
15824 },
15825                 'type' : r.unsigned short,
15826             }
15827 ,
15828             'tmap:javadirectorout' : Hash {
15829                 'pname' : OUTPUT,
15830                 'typemap' : typemap(javadirectorout) unsigned short &OUTPUT,
15831                 'code' : $javacall,
15832                 'type' : r.unsigned short,
15833             }
15834 ,
15835             'tmap:in' : Hash {
15836                 'locals' : Hash {
15837                     'name' : temp,
15838                     'type' : $*1_ltype,
15839                 }
15840 ,
15841                 'kwargs' : Hash {
15842                     'name' : numinputs,
15843                     'value' : 1,
15844                 }
15845 ,
15846                 'pname' : OUTPUT,
15847                 'typemap' : typemap(in) unsigned short &OUTPUT,
15848                 'code' : {
15849   if (!$input) {
15850     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
15851     return $null;
15852   }
15853   if (jenv->GetArrayLength($input) == 0) {
15854     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
15855     return $null;
15856   }
15857   $1 = &temp;
15858 },
15859                 'type' : r.unsigned short,
15860             }
15861 ,
15862             'tmap:directorout' : Hash {
15863                 'kwargs' : Hash {
15864                     'name' : warning,
15865                     'value' : Need to provide unsigned short *OUTPUT directorout typemap,
15866                 }
15867 ,
15868                 'pname' : OUTPUT,
15869                 'typemap' : typemap(directorout) unsigned short &OUTPUT,
15870                 'code' : {
15871 },
15872                 'type' : r.unsigned short,
15873             }
15874 ,
15875             'tmap:jni' : Hash {
15876                 'pname' : OUTPUT,
15877                 'typemap' : typemap(jni) unsigned short &OUTPUT,
15878                 'code' : jintArray,
15879                 'type' : r.unsigned short,
15880             }
15881 ,
15882             'tmap:jtype' : Hash {
15883                 'pname' : OUTPUT,
15884                 'typemap' : typemap(jtype) unsigned short &OUTPUT,
15885                 'code' : int[],
15886                 'type' : r.unsigned short,
15887             }
15888 ,
15889             'tmap:javain' : Hash {
15890                 'pname' : OUTPUT,
15891                 'typemap' : typemap(javain) unsigned short &OUTPUT,
15892                 'code' : $javainput,
15893                 'type' : r.unsigned short,
15894             }
15895 ,
15896         }
15897 ,
15898     }
15899 ,
15900     'a(ANY).unsigned short' : Hash {
15901         'tmap:freearg' : Hash {
15902             'typemap' : typemap(freearg) unsigned short [ANY],
15903             'code' :  delete [] $1; ,
15904             'type' : a(ANY).unsigned short,
15905         }
15906 ,
15907         'tmap:jstype' : Hash {
15908             'typemap' : typemap(jstype) unsigned short [ANY],
15909             'code' : int[],
15910             'type' : a(ANY).unsigned short,
15911         }
15912 ,
15913         'tmap:argout' : Hash {
15914             'typemap' : typemap(argout) unsigned short [ANY],
15915             'code' :  SWIG_JavaArrayArgoutUshort(jenv, jarr$argnum, $1, $input); ,
15916             'type' : a(ANY).unsigned short,
15917         }
15918 ,
15919         'tmap:in' : Hash {
15920             'locals' : Hash {
15921                 'name' : jarr,
15922                 'type' : p.jint,
15923             }
15924 ,
15925             'kwargs' : Hash {
15926                 'name' : numinputs,
15927                 'value' : 1,
15928             }
15929 ,
15930             'typemap' : typemap(in) unsigned short [ANY],
15931             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
15932     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
15933     return $null;
15934   }
15935   if (!SWIG_JavaArrayInUshort(jenv, &jarr, &$1, $input)) return $null; ,
15936             'type' : a(ANY).unsigned short,
15937         }
15938 ,
15939         'tmap:jni' : Hash {
15940             'typemap' : typemap(jni) unsigned short [ANY],
15941             'code' : jintArray,
15942             'type' : a(ANY).unsigned short,
15943         }
15944 ,
15945         'tmap:jtype' : Hash {
15946             'typemap' : typemap(jtype) unsigned short [ANY],
15947             'code' : int[],
15948             'type' : a(ANY).unsigned short,
15949         }
15950 ,
15951         'tmap:out' : Hash {
15952             'typemap' : typemap(out) unsigned short [ANY],
15953             'code' : $result = SWIG_JavaArrayOutUshort(jenv, $1, $1_dim0); ,
15954             'type' : a(ANY).unsigned short,
15955         }
15956 ,
15957         'tmap:javain' : Hash {
15958             'typemap' : typemap(javain) unsigned short [ANY],
15959             'code' : $javainput,
15960             'type' : a(ANY).unsigned short,
15961         }
15962 ,
15963         'tmap:typecheck' : Hash {
15964             'kwargs' : Hash {
15965                 'name' : precedence,
15966                 'value' : 1045,
15967             }
15968 ,
15969             'typemap' : typemap(typecheck) unsigned short [ANY],
15970             'code' : ,
15971             'type' : a(ANY).unsigned short,
15972         }
15973 ,
15974         'tmap:javaout' : Hash {
15975             'typemap' : typemap(javaout) unsigned short [ANY],
15976             'code' : {
15977     return $jnicall;
15978   },
15979             'type' : a(ANY).unsigned short,
15980         }
15981 ,
15982     }
15983 ,
15984     'a().unsigned short' : Hash {
15985         'tmap:freearg' : Hash {
15986             'typemap' : typemap(freearg) unsigned short [],
15987             'code' :  delete [] $1; ,
15988             'type' : a().unsigned short,
15989         }
15990 ,
15991         'tmap:jstype' : Hash {
15992             'typemap' : typemap(jstype) unsigned short [],
15993             'code' : int[],
15994             'type' : a().unsigned short,
15995         }
15996 ,
15997         'tmap:argout' : Hash {
15998             'typemap' : typemap(argout) unsigned short [],
15999             'code' :  SWIG_JavaArrayArgoutUshort(jenv, jarr$argnum, $1, $input); ,
16000             'type' : a().unsigned short,
16001         }
16002 ,
16003         'tmap:in' : Hash {
16004             'locals' : Hash {
16005                 'name' : jarr,
16006                 'type' : p.jint,
16007             }
16008 ,
16009             'kwargs' : Hash {
16010                 'name' : numinputs,
16011                 'value' : 1,
16012             }
16013 ,
16014             'typemap' : typemap(in) unsigned short [],
16015             'code' :   if (!SWIG_JavaArrayInUshort(jenv, &jarr, &$1, $input)) return $null; ,
16016             'type' : a().unsigned short,
16017         }
16018 ,
16019         'tmap:jni' : Hash {
16020             'typemap' : typemap(jni) unsigned short [],
16021             'code' : jintArray,
16022             'type' : a().unsigned short,
16023         }
16024 ,
16025         'tmap:jtype' : Hash {
16026             'typemap' : typemap(jtype) unsigned short [],
16027             'code' : int[],
16028             'type' : a().unsigned short,
16029         }
16030 ,
16031         'tmap:out' : Hash {
16032             'typemap' : typemap(out) unsigned short [],
16033             'code' : $result = SWIG_JavaArrayOutUshort(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
16034             'type' : a().unsigned short,
16035         }
16036 ,
16037         'tmap:javain' : Hash {
16038             'typemap' : typemap(javain) unsigned short [],
16039             'code' : $javainput,
16040             'type' : a().unsigned short,
16041         }
16042 ,
16043         'tmap:typecheck' : Hash {
16044             'kwargs' : Hash {
16045                 'name' : precedence,
16046                 'value' : 1045,
16047             }
16048 ,
16049             'typemap' : typemap(typecheck) unsigned short [],
16050             'code' : ,
16051             'type' : a().unsigned short,
16052         }
16053 ,
16054         'tmap:javaout' : Hash {
16055             'typemap' : typemap(javaout) unsigned short [],
16056             'code' : {
16057     return $jnicall;
16058   },
16059             'type' : a().unsigned short,
16060         }
16061 ,
16062     }
16063 ,
16064     'r.short' : Hash {
16065         'INOUT' : Hash {
16066             'tmap:freearg' : Hash {
16067                 'pname' : INOUT,
16068                 'typemap' : typemap(freearg) short &INOUT,
16069                 'code' : ,
16070                 'type' : r.short,
16071             }
16072 ,
16073             'tmap:jstype' : Hash {
16074                 'pname' : INOUT,
16075                 'typemap' : typemap(jstype) short &INOUT,
16076                 'code' : short[],
16077                 'type' : r.short,
16078             }
16079 ,
16080             'tmap:javadirectorin' : Hash {
16081                 'pname' : INOUT,
16082                 'typemap' : typemap(javadirectorin) short &INOUT,
16083                 'code' : $jniinput,
16084                 'type' : r.short,
16085             }
16086 ,
16087             'tmap:directorin' : Hash {
16088                 'kwargs' : Hash {
16089                     'name' : descriptor,
16090                     'value' : [Ljava/lang/Short;,
16091                     'nextSibling' : Hash {
16092                         'name' : warning,
16093                         'value' : Need to provide short *INOUT directorin typemap, short array length is unknown,
16094                     }
16095 ,
16096                 }
16097 ,
16098                 'pname' : INOUT,
16099                 'typemap' : typemap(directorin) short &INOUT,
16100                 'code' : {
16101 },
16102                 'type' : r.short,
16103             }
16104 ,
16105             'tmap:argout' : Hash {
16106                 'pname' : INOUT,
16107                 'typemap' : typemap(argout) short &INOUT,
16108                 'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); },
16109                 'type' : r.short,
16110             }
16111 ,
16112             'tmap:javadirectorout' : Hash {
16113                 'pname' : INOUT,
16114                 'typemap' : typemap(javadirectorout) short &INOUT,
16115                 'code' : $javacall,
16116                 'type' : r.short,
16117             }
16118 ,
16119             'tmap:in' : Hash {
16120                 'kwargs' : Hash {
16121                     'name' : numinputs,
16122                     'value' : 1,
16123                 }
16124 ,
16125                 'pname' : INOUT,
16126                 'typemap' : typemap(in) short &INOUT,
16127                 'code' : {
16128   if (!$input) {
16129     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
16130     return $null;
16131   }
16132   if (jenv->GetArrayLength($input) == 0) {
16133     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
16134     return $null;
16135   }
16136   $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0);
16137 },
16138                 'type' : r.short,
16139             }
16140 ,
16141             'tmap:directorout' : Hash {
16142                 'kwargs' : Hash {
16143                     'name' : warning,
16144                     'value' : Need to provide short *INOUT directorout typemap,
16145                 }
16146 ,
16147                 'pname' : INOUT,
16148                 'typemap' : typemap(directorout) short &INOUT,
16149                 'code' : {
16150 },
16151                 'type' : r.short,
16152             }
16153 ,
16154             'tmap:typecheck' : Hash {
16155                 'kwargs' : Hash {
16156                     'name' : precedence,
16157                     'value' : 1035,
16158                 }
16159 ,
16160                 'pname' : INOUT,
16161                 'typemap' : typemap(typecheck) short &INOUT,
16162                 'code' : ,
16163                 'type' : r.short,
16164             }
16165 ,
16166             'tmap:jni' : Hash {
16167                 'pname' : INOUT,
16168                 'typemap' : typemap(jni) short &INOUT,
16169                 'code' : jshortArray,
16170                 'type' : r.short,
16171             }
16172 ,
16173             'tmap:jtype' : Hash {
16174                 'pname' : INOUT,
16175                 'typemap' : typemap(jtype) short &INOUT,
16176                 'code' : short[],
16177                 'type' : r.short,
16178             }
16179 ,
16180             'tmap:javain' : Hash {
16181                 'pname' : INOUT,
16182                 'typemap' : typemap(javain) short &INOUT,
16183                 'code' : $javainput,
16184                 'type' : r.short,
16185             }
16186 ,
16187         }
16188 ,
16189         'INPUT' : Hash {
16190             'tmap:freearg' : Hash {
16191                 'pname' : INPUT,
16192                 'typemap' : typemap(freearg) short &INPUT,
16193                 'code' : ,
16194                 'type' : r.short,
16195             }
16196 ,
16197             'tmap:jstype' : Hash {
16198                 'pname' : INPUT,
16199                 'typemap' : typemap(jstype) short &INPUT,
16200                 'code' : short,
16201                 'type' : r.short,
16202             }
16203 ,
16204             'tmap:javadirectorin' : Hash {
16205                 'pname' : INPUT,
16206                 'typemap' : typemap(javadirectorin) short &INPUT,
16207                 'code' : $jniinput,
16208                 'type' : r.short,
16209             }
16210 ,
16211             'tmap:directorin' : Hash {
16212                 'kwargs' : Hash {
16213                     'name' : descriptor,
16214                     'value' : S,
16215                 }
16216 ,
16217                 'pname' : INPUT,
16218                 'typemap' : typemap(directorin) short &INPUT,
16219                 'code' :  *(($&1_ltype) $input) = (jshort *) &$1; ,
16220                 'type' : r.short,
16221             }
16222 ,
16223             'tmap:javadirectorout' : Hash {
16224                 'pname' : INPUT,
16225                 'typemap' : typemap(javadirectorout) short &INPUT,
16226                 'code' : $javacall,
16227                 'type' : r.short,
16228             }
16229 ,
16230             'tmap:in' : Hash {
16231                 'kwargs' : Hash {
16232                     'name' : numinputs,
16233                     'value' : 1,
16234                 }
16235 ,
16236                 'pname' : INPUT,
16237                 'typemap' : typemap(in) short &INPUT,
16238                 'code' :  $1 = ($1_ltype)&$input; ,
16239                 'type' : r.short,
16240             }
16241 ,
16242             'tmap:directorout' : Hash {
16243                 'pname' : INPUT,
16244                 'typemap' : typemap(directorout) short &INPUT,
16245                 'code' :  $result = ($1_ltype)&$input; ,
16246                 'type' : r.short,
16247             }
16248 ,
16249             'tmap:jni' : Hash {
16250                 'pname' : INPUT,
16251                 'typemap' : typemap(jni) short &INPUT,
16252                 'code' : jshort,
16253                 'type' : r.short,
16254             }
16255 ,
16256             'tmap:jtype' : Hash {
16257                 'pname' : INPUT,
16258                 'typemap' : typemap(jtype) short &INPUT,
16259                 'code' : short,
16260                 'type' : r.short,
16261             }
16262 ,
16263             'tmap:javain' : Hash {
16264                 'pname' : INPUT,
16265                 'typemap' : typemap(javain) short &INPUT,
16266                 'code' : $javainput,
16267                 'type' : r.short,
16268             }
16269 ,
16270             'tmap:typecheck' : Hash {
16271                 'kwargs' : Hash {
16272                     'name' : precedence,
16273                     'value' : 35,
16274                 }
16275 ,
16276                 'pname' : INPUT,
16277                 'typemap' : typemap(typecheck) short &INPUT,
16278                 'code' : ,
16279                 'type' : r.short,
16280             }
16281 ,
16282         }
16283 ,
16284         'OUTPUT' : Hash {
16285             'tmap:freearg' : Hash {
16286                 'pname' : OUTPUT,
16287                 'typemap' : typemap(freearg) short &OUTPUT,
16288                 'code' : ,
16289                 'type' : r.short,
16290             }
16291 ,
16292             'tmap:jstype' : Hash {
16293                 'pname' : OUTPUT,
16294                 'typemap' : typemap(jstype) short &OUTPUT,
16295                 'code' : short[],
16296                 'type' : r.short,
16297             }
16298 ,
16299             'tmap:javadirectorin' : Hash {
16300                 'pname' : OUTPUT,
16301                 'typemap' : typemap(javadirectorin) short &OUTPUT,
16302                 'code' : $jniinput,
16303                 'type' : r.short,
16304             }
16305 ,
16306             'tmap:directorin' : Hash {
16307                 'kwargs' : Hash {
16308                     'name' : descriptor,
16309                     'value' : [Ljava/lang/Short;,
16310                 }
16311 ,
16312                 'pname' : OUTPUT,
16313                 'typemap' : typemap(directorin) short &OUTPUT,
16314                 'code' :  *(($&1_ltype) $input = &$1; ,
16315                 'type' : r.short,
16316             }
16317 ,
16318             'tmap:argout' : Hash {
16319                 'pname' : OUTPUT,
16320                 'typemap' : typemap(argout) short &OUTPUT,
16321                 'code' : {
16322   jshort jvalue = (jshort)temp$argnum;
16323   jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
16324 },
16325                 'type' : r.short,
16326             }
16327 ,
16328             'tmap:javadirectorout' : Hash {
16329                 'pname' : OUTPUT,
16330                 'typemap' : typemap(javadirectorout) short &OUTPUT,
16331                 'code' : $javacall,
16332                 'type' : r.short,
16333             }
16334 ,
16335             'tmap:in' : Hash {
16336                 'locals' : Hash {
16337                     'name' : temp,
16338                     'type' : $*1_ltype,
16339                 }
16340 ,
16341                 'kwargs' : Hash {
16342                     'name' : numinputs,
16343                     'value' : 1,
16344                 }
16345 ,
16346                 'pname' : OUTPUT,
16347                 'typemap' : typemap(in) short &OUTPUT,
16348                 'code' : {
16349   if (!$input) {
16350     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
16351     return $null;
16352   }
16353   if (jenv->GetArrayLength($input) == 0) {
16354     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
16355     return $null;
16356   }
16357   $1 = &temp;
16358 },
16359                 'type' : r.short,
16360             }
16361 ,
16362             'tmap:directorout' : Hash {
16363                 'kwargs' : Hash {
16364                     'name' : warning,
16365                     'value' : Need to provide short *OUTPUT directorout typemap,
16366                 }
16367 ,
16368                 'pname' : OUTPUT,
16369                 'typemap' : typemap(directorout) short &OUTPUT,
16370                 'code' : {
16371 },
16372                 'type' : r.short,
16373             }
16374 ,
16375             'tmap:jni' : Hash {
16376                 'pname' : OUTPUT,
16377                 'typemap' : typemap(jni) short &OUTPUT,
16378                 'code' : jshortArray,
16379                 'type' : r.short,
16380             }
16381 ,
16382             'tmap:jtype' : Hash {
16383                 'pname' : OUTPUT,
16384                 'typemap' : typemap(jtype) short &OUTPUT,
16385                 'code' : short[],
16386                 'type' : r.short,
16387             }
16388 ,
16389             'tmap:javain' : Hash {
16390                 'pname' : OUTPUT,
16391                 'typemap' : typemap(javain) short &OUTPUT,
16392                 'code' : $javainput,
16393                 'type' : r.short,
16394             }
16395 ,
16396         }
16397 ,
16398     }
16399 ,
16400     'p.short' : Hash {
16401         'INOUT' : Hash {
16402             'tmap:freearg' : Hash {
16403                 'pname' : INOUT,
16404                 'typemap' : typemap(freearg) short *INOUT,
16405                 'code' : ,
16406                 'type' : p.short,
16407             }
16408 ,
16409             'tmap:jstype' : Hash {
16410                 'pname' : INOUT,
16411                 'typemap' : typemap(jstype) short *INOUT,
16412                 'code' : short[],
16413                 'type' : p.short,
16414             }
16415 ,
16416             'tmap:javadirectorin' : Hash {
16417                 'pname' : INOUT,
16418                 'typemap' : typemap(javadirectorin) short *INOUT,
16419                 'code' : $jniinput,
16420                 'type' : p.short,
16421             }
16422 ,
16423             'tmap:directorin' : Hash {
16424                 'kwargs' : Hash {
16425                     'name' : descriptor,
16426                     'value' : [Ljava/lang/Short;,
16427                     'nextSibling' : Hash {
16428                         'name' : warning,
16429                         'value' : Need to provide short *INOUT directorin typemap, short array length is unknown,
16430                     }
16431 ,
16432                 }
16433 ,
16434                 'pname' : INOUT,
16435                 'typemap' : typemap(directorin) short *INOUT,
16436                 'code' : {
16437 },
16438                 'type' : p.short,
16439             }
16440 ,
16441             'tmap:argout' : Hash {
16442                 'pname' : INOUT,
16443                 'typemap' : typemap(argout) short *INOUT,
16444                 'code' : { jenv->ReleaseShortArrayElements($input, (jshort *)$1, 0); },
16445                 'type' : p.short,
16446             }
16447 ,
16448             'tmap:javadirectorout' : Hash {
16449                 'pname' : INOUT,
16450                 'typemap' : typemap(javadirectorout) short *INOUT,
16451                 'code' : $javacall,
16452                 'type' : p.short,
16453             }
16454 ,
16455             'tmap:in' : Hash {
16456                 'kwargs' : Hash {
16457                     'name' : numinputs,
16458                     'value' : 1,
16459                 }
16460 ,
16461                 'pname' : INOUT,
16462                 'typemap' : typemap(in) short *INOUT,
16463                 'code' : {
16464   if (!$input) {
16465     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
16466     return $null;
16467   }
16468   if (jenv->GetArrayLength($input) == 0) {
16469     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
16470     return $null;
16471   }
16472   $1 = ($1_ltype) jenv->GetShortArrayElements($input, 0);
16473 },
16474                 'type' : p.short,
16475             }
16476 ,
16477             'tmap:directorout' : Hash {
16478                 'kwargs' : Hash {
16479                     'name' : warning,
16480                     'value' : Need to provide short *INOUT directorout typemap,
16481                 }
16482 ,
16483                 'pname' : INOUT,
16484                 'typemap' : typemap(directorout) short *INOUT,
16485                 'code' : {
16486 },
16487                 'type' : p.short,
16488             }
16489 ,
16490             'tmap:typecheck' : Hash {
16491                 'kwargs' : Hash {
16492                     'name' : precedence,
16493                     'value' : 1035,
16494                 }
16495 ,
16496                 'pname' : INOUT,
16497                 'typemap' : typemap(typecheck) short *INOUT,
16498                 'code' : ,
16499                 'type' : p.short,
16500             }
16501 ,
16502             'tmap:jni' : Hash {
16503                 'pname' : INOUT,
16504                 'typemap' : typemap(jni) short *INOUT,
16505                 'code' : jshortArray,
16506                 'type' : p.short,
16507             }
16508 ,
16509             'tmap:jtype' : Hash {
16510                 'pname' : INOUT,
16511                 'typemap' : typemap(jtype) short *INOUT,
16512                 'code' : short[],
16513                 'type' : p.short,
16514             }
16515 ,
16516             'tmap:javain' : Hash {
16517                 'pname' : INOUT,
16518                 'typemap' : typemap(javain) short *INOUT,
16519                 'code' : $javainput,
16520                 'type' : p.short,
16521             }
16522 ,
16523         }
16524 ,
16525         'INPUT' : Hash {
16526             'tmap:freearg' : Hash {
16527                 'pname' : INPUT,
16528                 'typemap' : typemap(freearg) short *INPUT,
16529                 'code' : ,
16530                 'type' : p.short,
16531             }
16532 ,
16533             'tmap:jstype' : Hash {
16534                 'pname' : INPUT,
16535                 'typemap' : typemap(jstype) short *INPUT,
16536                 'code' : short,
16537                 'type' : p.short,
16538             }
16539 ,
16540             'tmap:javadirectorin' : Hash {
16541                 'pname' : INPUT,
16542                 'typemap' : typemap(javadirectorin) short *INPUT,
16543                 'code' : $jniinput,
16544                 'type' : p.short,
16545             }
16546 ,
16547             'tmap:directorin' : Hash {
16548                 'kwargs' : Hash {
16549                     'name' : descriptor,
16550                     'value' : S,
16551                 }
16552 ,
16553                 'pname' : INPUT,
16554                 'typemap' : typemap(directorin) short *INPUT,
16555                 'code' :  *(($&1_ltype) $input) = (jshort *) $1; ,
16556                 'type' : p.short,
16557             }
16558 ,
16559             'tmap:javadirectorout' : Hash {
16560                 'pname' : INPUT,
16561                 'typemap' : typemap(javadirectorout) short *INPUT,
16562                 'code' : $javacall,
16563                 'type' : p.short,
16564             }
16565 ,
16566             'tmap:in' : Hash {
16567                 'kwargs' : Hash {
16568                     'name' : numinputs,
16569                     'value' : 1,
16570                 }
16571 ,
16572                 'pname' : INPUT,
16573                 'typemap' : typemap(in) short *INPUT,
16574                 'code' :  $1 = ($1_ltype)&$input; ,
16575                 'type' : p.short,
16576             }
16577 ,
16578             'tmap:directorout' : Hash {
16579                 'pname' : INPUT,
16580                 'typemap' : typemap(directorout) short *INPUT,
16581                 'code' :  $result = ($1_ltype)&$input; ,
16582                 'type' : p.short,
16583             }
16584 ,
16585             'tmap:jni' : Hash {
16586                 'pname' : INPUT,
16587                 'typemap' : typemap(jni) short *INPUT,
16588                 'code' : jshort,
16589                 'type' : p.short,
16590             }
16591 ,
16592             'tmap:jtype' : Hash {
16593                 'pname' : INPUT,
16594                 'typemap' : typemap(jtype) short *INPUT,
16595                 'code' : short,
16596                 'type' : p.short,
16597             }
16598 ,
16599             'tmap:javain' : Hash {
16600                 'pname' : INPUT,
16601                 'typemap' : typemap(javain) short *INPUT,
16602                 'code' : $javainput,
16603                 'type' : p.short,
16604             }
16605 ,
16606             'tmap:typecheck' : Hash {
16607                 'kwargs' : Hash {
16608                     'name' : precedence,
16609                     'value' : 35,
16610                 }
16611 ,
16612                 'pname' : INPUT,
16613                 'typemap' : typemap(typecheck) short *INPUT,
16614                 'code' : ,
16615                 'type' : p.short,
16616             }
16617 ,
16618         }
16619 ,
16620         'OUTPUT' : Hash {
16621             'tmap:freearg' : Hash {
16622                 'pname' : OUTPUT,
16623                 'typemap' : typemap(freearg) short *OUTPUT,
16624                 'code' : ,
16625                 'type' : p.short,
16626             }
16627 ,
16628             'tmap:jstype' : Hash {
16629                 'pname' : OUTPUT,
16630                 'typemap' : typemap(jstype) short *OUTPUT,
16631                 'code' : short[],
16632                 'type' : p.short,
16633             }
16634 ,
16635             'tmap:javadirectorin' : Hash {
16636                 'pname' : OUTPUT,
16637                 'typemap' : typemap(javadirectorin) short *OUTPUT,
16638                 'code' : $jniinput,
16639                 'type' : p.short,
16640             }
16641 ,
16642             'tmap:directorin' : Hash {
16643                 'kwargs' : Hash {
16644                     'name' : descriptor,
16645                     'value' : [Ljava/lang/Short;,
16646                     'nextSibling' : Hash {
16647                         'name' : warning,
16648                         'value' : Need to provide short *OUTPUT directorin typemap, short array length is unknown,
16649                     }
16650 ,
16651                 }
16652 ,
16653                 'pname' : OUTPUT,
16654                 'typemap' : typemap(directorin) short *OUTPUT,
16655                 'code' : {
16656 },
16657                 'type' : p.short,
16658             }
16659 ,
16660             'tmap:argout' : Hash {
16661                 'pname' : OUTPUT,
16662                 'typemap' : typemap(argout) short *OUTPUT,
16663                 'code' : {
16664   jshort jvalue = (jshort)temp$argnum;
16665   jenv->SetShortArrayRegion($input, 0, 1, &jvalue);
16666 },
16667                 'type' : p.short,
16668             }
16669 ,
16670             'tmap:javadirectorout' : Hash {
16671                 'pname' : OUTPUT,
16672                 'typemap' : typemap(javadirectorout) short *OUTPUT,
16673                 'code' : $javacall,
16674                 'type' : p.short,
16675             }
16676 ,
16677             'tmap:in' : Hash {
16678                 'locals' : Hash {
16679                     'name' : temp,
16680                     'type' : $*1_ltype,
16681                 }
16682 ,
16683                 'kwargs' : Hash {
16684                     'name' : numinputs,
16685                     'value' : 1,
16686                 }
16687 ,
16688                 'pname' : OUTPUT,
16689                 'typemap' : typemap(in) short *OUTPUT,
16690                 'code' : {
16691   if (!$input) {
16692     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
16693     return $null;
16694   }
16695   if (jenv->GetArrayLength($input) == 0) {
16696     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
16697     return $null;
16698   }
16699   $1 = &temp;
16700 },
16701                 'type' : p.short,
16702             }
16703 ,
16704             'tmap:directorout' : Hash {
16705                 'kwargs' : Hash {
16706                     'name' : warning,
16707                     'value' : Need to provide short *OUTPUT directorout typemap,
16708                 }
16709 ,
16710                 'pname' : OUTPUT,
16711                 'typemap' : typemap(directorout) short *OUTPUT,
16712                 'code' : {
16713 },
16714                 'type' : p.short,
16715             }
16716 ,
16717             'tmap:jni' : Hash {
16718                 'pname' : OUTPUT,
16719                 'typemap' : typemap(jni) short *OUTPUT,
16720                 'code' : jshortArray,
16721                 'type' : p.short,
16722             }
16723 ,
16724             'tmap:jtype' : Hash {
16725                 'pname' : OUTPUT,
16726                 'typemap' : typemap(jtype) short *OUTPUT,
16727                 'code' : short[],
16728                 'type' : p.short,
16729             }
16730 ,
16731             'tmap:javain' : Hash {
16732                 'pname' : OUTPUT,
16733                 'typemap' : typemap(javain) short *OUTPUT,
16734                 'code' : $javainput,
16735                 'type' : p.short,
16736             }
16737 ,
16738         }
16739 ,
16740     }
16741 ,
16742     'p.int' : Hash {
16743         'INOUT' : Hash {
16744             'tmap:freearg' : Hash {
16745                 'pname' : INOUT,
16746                 'typemap' : typemap(freearg) int *INOUT,
16747                 'code' : ,
16748                 'type' : p.int,
16749             }
16750 ,
16751             'tmap:jstype' : Hash {
16752                 'pname' : INOUT,
16753                 'typemap' : typemap(jstype) int *INOUT,
16754                 'code' : int[],
16755                 'type' : p.int,
16756             }
16757 ,
16758             'tmap:javadirectorin' : Hash {
16759                 'pname' : INOUT,
16760                 'typemap' : typemap(javadirectorin) int *INOUT,
16761                 'code' : $jniinput,
16762                 'type' : p.int,
16763             }
16764 ,
16765             'tmap:directorin' : Hash {
16766                 'kwargs' : Hash {
16767                     'name' : descriptor,
16768                     'value' : [Ljava/lang/Integer;,
16769                     'nextSibling' : Hash {
16770                         'name' : warning,
16771                         'value' : Need to provide int *INOUT directorin typemap, int array length is unknown,
16772                     }
16773 ,
16774                 }
16775 ,
16776                 'pname' : INOUT,
16777                 'typemap' : typemap(directorin) int *INOUT,
16778                 'code' : {
16779 },
16780                 'type' : p.int,
16781             }
16782 ,
16783             'tmap:argout' : Hash {
16784                 'pname' : INOUT,
16785                 'typemap' : typemap(argout) int *INOUT,
16786                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
16787                 'type' : p.int,
16788             }
16789 ,
16790             'tmap:javadirectorout' : Hash {
16791                 'pname' : INOUT,
16792                 'typemap' : typemap(javadirectorout) int *INOUT,
16793                 'code' : $javacall,
16794                 'type' : p.int,
16795             }
16796 ,
16797             'tmap:in' : Hash {
16798                 'kwargs' : Hash {
16799                     'name' : numinputs,
16800                     'value' : 1,
16801                 }
16802 ,
16803                 'pname' : INOUT,
16804                 'typemap' : typemap(in) int *INOUT,
16805                 'code' : {
16806   if (!$input) {
16807     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
16808     return $null;
16809   }
16810   if (jenv->GetArrayLength($input) == 0) {
16811     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
16812     return $null;
16813   }
16814   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
16815 },
16816                 'type' : p.int,
16817             }
16818 ,
16819             'tmap:directorout' : Hash {
16820                 'kwargs' : Hash {
16821                     'name' : warning,
16822                     'value' : Need to provide int *INOUT directorout typemap,
16823                 }
16824 ,
16825                 'pname' : INOUT,
16826                 'typemap' : typemap(directorout) int *INOUT,
16827                 'code' : {
16828 },
16829                 'type' : p.int,
16830             }
16831 ,
16832             'tmap:typecheck' : Hash {
16833                 'kwargs' : Hash {
16834                     'name' : precedence,
16835                     'value' : 1045,
16836                 }
16837 ,
16838                 'pname' : INOUT,
16839                 'typemap' : typemap(typecheck) int *INOUT,
16840                 'code' : ,
16841                 'type' : p.int,
16842             }
16843 ,
16844             'tmap:jni' : Hash {
16845                 'pname' : INOUT,
16846                 'typemap' : typemap(jni) int *INOUT,
16847                 'code' : jintArray,
16848                 'type' : p.int,
16849             }
16850 ,
16851             'tmap:jtype' : Hash {
16852                 'pname' : INOUT,
16853                 'typemap' : typemap(jtype) int *INOUT,
16854                 'code' : int[],
16855                 'type' : p.int,
16856             }
16857 ,
16858             'tmap:javain' : Hash {
16859                 'pname' : INOUT,
16860                 'typemap' : typemap(javain) int *INOUT,
16861                 'code' : $javainput,
16862                 'type' : p.int,
16863             }
16864 ,
16865         }
16866 ,
16867         'INPUT' : Hash {
16868             'tmap:freearg' : Hash {
16869                 'pname' : INPUT,
16870                 'typemap' : typemap(freearg) int *INPUT,
16871                 'code' : ,
16872                 'type' : p.int,
16873             }
16874 ,
16875             'tmap:jstype' : Hash {
16876                 'pname' : INPUT,
16877                 'typemap' : typemap(jstype) int *INPUT,
16878                 'code' : int,
16879                 'type' : p.int,
16880             }
16881 ,
16882             'tmap:javadirectorin' : Hash {
16883                 'pname' : INPUT,
16884                 'typemap' : typemap(javadirectorin) int *INPUT,
16885                 'code' : $jniinput,
16886                 'type' : p.int,
16887             }
16888 ,
16889             'tmap:directorin' : Hash {
16890                 'kwargs' : Hash {
16891                     'name' : descriptor,
16892                     'value' : I,
16893                 }
16894 ,
16895                 'pname' : INPUT,
16896                 'typemap' : typemap(directorin) int *INPUT,
16897                 'code' :  *(($&1_ltype) $input) = (jint *) $1; ,
16898                 'type' : p.int,
16899             }
16900 ,
16901             'tmap:javadirectorout' : Hash {
16902                 'pname' : INPUT,
16903                 'typemap' : typemap(javadirectorout) int *INPUT,
16904                 'code' : $javacall,
16905                 'type' : p.int,
16906             }
16907 ,
16908             'tmap:in' : Hash {
16909                 'kwargs' : Hash {
16910                     'name' : numinputs,
16911                     'value' : 1,
16912                 }
16913 ,
16914                 'pname' : INPUT,
16915                 'typemap' : typemap(in) int *INPUT,
16916                 'code' :  $1 = ($1_ltype)&$input; ,
16917                 'type' : p.int,
16918             }
16919 ,
16920             'tmap:directorout' : Hash {
16921                 'pname' : INPUT,
16922                 'typemap' : typemap(directorout) int *INPUT,
16923                 'code' :  $result = ($1_ltype)&$input; ,
16924                 'type' : p.int,
16925             }
16926 ,
16927             'tmap:jni' : Hash {
16928                 'pname' : INPUT,
16929                 'typemap' : typemap(jni) int *INPUT,
16930                 'code' : jint,
16931                 'type' : p.int,
16932             }
16933 ,
16934             'tmap:jtype' : Hash {
16935                 'pname' : INPUT,
16936                 'typemap' : typemap(jtype) int *INPUT,
16937                 'code' : int,
16938                 'type' : p.int,
16939             }
16940 ,
16941             'tmap:javain' : Hash {
16942                 'pname' : INPUT,
16943                 'typemap' : typemap(javain) int *INPUT,
16944                 'code' : $javainput,
16945                 'type' : p.int,
16946             }
16947 ,
16948             'tmap:typecheck' : Hash {
16949                 'kwargs' : Hash {
16950                     'name' : precedence,
16951                     'value' : 45,
16952                 }
16953 ,
16954                 'pname' : INPUT,
16955                 'typemap' : typemap(typecheck) int *INPUT,
16956                 'code' : ,
16957                 'type' : p.int,
16958             }
16959 ,
16960         }
16961 ,
16962         'OUTPUT' : Hash {
16963             'tmap:freearg' : Hash {
16964                 'pname' : OUTPUT,
16965                 'typemap' : typemap(freearg) int *OUTPUT,
16966                 'code' : ,
16967                 'type' : p.int,
16968             }
16969 ,
16970             'tmap:jstype' : Hash {
16971                 'pname' : OUTPUT,
16972                 'typemap' : typemap(jstype) int *OUTPUT,
16973                 'code' : int[],
16974                 'type' : p.int,
16975             }
16976 ,
16977             'tmap:javadirectorin' : Hash {
16978                 'pname' : OUTPUT,
16979                 'typemap' : typemap(javadirectorin) int *OUTPUT,
16980                 'code' : $jniinput,
16981                 'type' : p.int,
16982             }
16983 ,
16984             'tmap:directorin' : Hash {
16985                 'kwargs' : Hash {
16986                     'name' : descriptor,
16987                     'value' : [Ljava/lang/Integer;,
16988                     'nextSibling' : Hash {
16989                         'name' : warning,
16990                         'value' : Need to provide int *OUTPUT directorin typemap, int array length is unknown,
16991                     }
16992 ,
16993                 }
16994 ,
16995                 'pname' : OUTPUT,
16996                 'typemap' : typemap(directorin) int *OUTPUT,
16997                 'code' : {
16998 },
16999                 'type' : p.int,
17000             }
17001 ,
17002             'tmap:argout' : Hash {
17003                 'pname' : OUTPUT,
17004                 'typemap' : typemap(argout) int *OUTPUT,
17005                 'code' : {
17006   jint jvalue = (jint)temp$argnum;
17007   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
17008 },
17009                 'type' : p.int,
17010             }
17011 ,
17012             'tmap:javadirectorout' : Hash {
17013                 'pname' : OUTPUT,
17014                 'typemap' : typemap(javadirectorout) int *OUTPUT,
17015                 'code' : $javacall,
17016                 'type' : p.int,
17017             }
17018 ,
17019             'tmap:in' : Hash {
17020                 'locals' : Hash {
17021                     'name' : temp,
17022                     'type' : $*1_ltype,
17023                 }
17024 ,
17025                 'kwargs' : Hash {
17026                     'name' : numinputs,
17027                     'value' : 1,
17028                 }
17029 ,
17030                 'pname' : OUTPUT,
17031                 'typemap' : typemap(in) int *OUTPUT,
17032                 'code' : {
17033   if (!$input) {
17034     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
17035     return $null;
17036   }
17037   if (jenv->GetArrayLength($input) == 0) {
17038     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
17039     return $null;
17040   }
17041   $1 = &temp;
17042 },
17043                 'type' : p.int,
17044             }
17045 ,
17046             'tmap:directorout' : Hash {
17047                 'kwargs' : Hash {
17048                     'name' : warning,
17049                     'value' : Need to provide int *OUTPUT directorout typemap,
17050                 }
17051 ,
17052                 'pname' : OUTPUT,
17053                 'typemap' : typemap(directorout) int *OUTPUT,
17054                 'code' : {
17055 },
17056                 'type' : p.int,
17057             }
17058 ,
17059             'tmap:jni' : Hash {
17060                 'pname' : OUTPUT,
17061                 'typemap' : typemap(jni) int *OUTPUT,
17062                 'code' : jintArray,
17063                 'type' : p.int,
17064             }
17065 ,
17066             'tmap:jtype' : Hash {
17067                 'pname' : OUTPUT,
17068                 'typemap' : typemap(jtype) int *OUTPUT,
17069                 'code' : int[],
17070                 'type' : p.int,
17071             }
17072 ,
17073             'tmap:javain' : Hash {
17074                 'pname' : OUTPUT,
17075                 'typemap' : typemap(javain) int *OUTPUT,
17076                 'code' : $javainput,
17077                 'type' : p.int,
17078             }
17079 ,
17080         }
17081 ,
17082     }
17083 ,
17084     'float' : Hash {
17085         'tmap:jstype' : Hash {
17086             'typemap' : typemap(jstype) float,
17087             'code' : float,
17088             'type' : float,
17089         }
17090 ,
17091         'tmap:directorin' : Hash {
17092             'kwargs' : Hash {
17093                 'name' : descriptor,
17094                 'value' : F,
17095             }
17096 ,
17097             'typemap' : typemap(directorin) float,
17098             'code' : $input = (jfloat) $1;,
17099             'type' : float,
17100         }
17101 ,
17102         'tmap:javadirectorin' : Hash {
17103             'typemap' : typemap(javadirectorin) float,
17104             'code' : $jniinput,
17105             'type' : float,
17106         }
17107 ,
17108         'tmap:in' : Hash {
17109             'kwargs' : Hash {
17110                 'name' : numinputs,
17111                 'value' : 1,
17112             }
17113 ,
17114             'typemap' : typemap(in) float,
17115             'code' :  $1 = ($1_ltype)$input; ,
17116             'type' : float,
17117         }
17118 ,
17119         'tmap:directorout' : Hash {
17120             'typemap' : typemap(directorout) float,
17121             'code' :  $result = ($1_ltype)$input; ,
17122             'type' : float,
17123         }
17124 ,
17125         'tmap:javadirectorout' : Hash {
17126             'typemap' : typemap(javadirectorout) float,
17127             'code' : $javacall,
17128             'type' : float,
17129         }
17130 ,
17131         'tmap:jni' : Hash {
17132             'typemap' : typemap(jni) float,
17133             'code' : jfloat,
17134             'type' : float,
17135         }
17136 ,
17137         'tmap:jtype' : Hash {
17138             'typemap' : typemap(jtype) float,
17139             'code' : float,
17140             'type' : float,
17141         }
17142 ,
17143         'tmap:out' : Hash {
17144             'typemap' : typemap(out) float,
17145             'code' :  $result = (jfloat)$1; ,
17146             'type' : float,
17147         }
17148 ,
17149         'tmap:typecheck' : Hash {
17150             'kwargs' : Hash {
17151                 'name' : precedence,
17152                 'value' : 80,
17153             }
17154 ,
17155             'typemap' : typemap(typecheck) float,
17156             'code' : ,
17157             'type' : float,
17158         }
17159 ,
17160         'tmap:javain' : Hash {
17161             'typemap' : typemap(javain) float,
17162             'code' : $javainput,
17163             'type' : float,
17164         }
17165 ,
17166         'tmap:javaout' : Hash {
17167             'typemap' : typemap(javaout) float,
17168             'code' : {
17169     return $jnicall;
17170   },
17171             'type' : float,
17172         }
17173 ,
17174     }
17175 ,
17176     'r.long' : Hash {
17177         'INOUT' : Hash {
17178             'tmap:freearg' : Hash {
17179                 'pname' : INOUT,
17180                 'typemap' : typemap(freearg) long &INOUT,
17181                 'code' : ,
17182                 'type' : r.long,
17183             }
17184 ,
17185             'tmap:jstype' : Hash {
17186                 'pname' : INOUT,
17187                 'typemap' : typemap(jstype) long &INOUT,
17188                 'code' : int[],
17189                 'type' : r.long,
17190             }
17191 ,
17192             'tmap:javadirectorin' : Hash {
17193                 'pname' : INOUT,
17194                 'typemap' : typemap(javadirectorin) long &INOUT,
17195                 'code' : $jniinput,
17196                 'type' : r.long,
17197             }
17198 ,
17199             'tmap:directorin' : Hash {
17200                 'kwargs' : Hash {
17201                     'name' : descriptor,
17202                     'value' : [Ljava/lang/Integer;,
17203                     'nextSibling' : Hash {
17204                         'name' : warning,
17205                         'value' : Need to provide long *INOUT directorin typemap, long array length is unknown,
17206                     }
17207 ,
17208                 }
17209 ,
17210                 'pname' : INOUT,
17211                 'typemap' : typemap(directorin) long &INOUT,
17212                 'code' : {
17213 },
17214                 'type' : r.long,
17215             }
17216 ,
17217             'tmap:argout' : Hash {
17218                 'pname' : INOUT,
17219                 'typemap' : typemap(argout) long &INOUT,
17220                 'code' : { jenv->ReleaseIntArrayElements($input, (jint *)$1, 0); },
17221                 'type' : r.long,
17222             }
17223 ,
17224             'tmap:javadirectorout' : Hash {
17225                 'pname' : INOUT,
17226                 'typemap' : typemap(javadirectorout) long &INOUT,
17227                 'code' : $javacall,
17228                 'type' : r.long,
17229             }
17230 ,
17231             'tmap:in' : Hash {
17232                 'kwargs' : Hash {
17233                     'name' : numinputs,
17234                     'value' : 1,
17235                 }
17236 ,
17237                 'pname' : INOUT,
17238                 'typemap' : typemap(in) long &INOUT,
17239                 'code' : {
17240   if (!$input) {
17241     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
17242     return $null;
17243   }
17244   if (jenv->GetArrayLength($input) == 0) {
17245     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
17246     return $null;
17247   }
17248   $1 = ($1_ltype) jenv->GetIntArrayElements($input, 0);
17249 },
17250                 'type' : r.long,
17251             }
17252 ,
17253             'tmap:directorout' : Hash {
17254                 'kwargs' : Hash {
17255                     'name' : warning,
17256                     'value' : Need to provide long *INOUT directorout typemap,
17257                 }
17258 ,
17259                 'pname' : INOUT,
17260                 'typemap' : typemap(directorout) long &INOUT,
17261                 'code' : {
17262 },
17263                 'type' : r.long,
17264             }
17265 ,
17266             'tmap:typecheck' : Hash {
17267                 'kwargs' : Hash {
17268                     'name' : precedence,
17269                     'value' : 1045,
17270                 }
17271 ,
17272                 'pname' : INOUT,
17273                 'typemap' : typemap(typecheck) long &INOUT,
17274                 'code' : ,
17275                 'type' : r.long,
17276             }
17277 ,
17278             'tmap:jni' : Hash {
17279                 'pname' : INOUT,
17280                 'typemap' : typemap(jni) long &INOUT,
17281                 'code' : jintArray,
17282                 'type' : r.long,
17283             }
17284 ,
17285             'tmap:jtype' : Hash {
17286                 'pname' : INOUT,
17287                 'typemap' : typemap(jtype) long &INOUT,
17288                 'code' : int[],
17289                 'type' : r.long,
17290             }
17291 ,
17292             'tmap:javain' : Hash {
17293                 'pname' : INOUT,
17294                 'typemap' : typemap(javain) long &INOUT,
17295                 'code' : $javainput,
17296                 'type' : r.long,
17297             }
17298 ,
17299         }
17300 ,
17301         'INPUT' : Hash {
17302             'tmap:freearg' : Hash {
17303                 'pname' : INPUT,
17304                 'typemap' : typemap(freearg) long &INPUT,
17305                 'code' : ,
17306                 'type' : r.long,
17307             }
17308 ,
17309             'tmap:jstype' : Hash {
17310                 'pname' : INPUT,
17311                 'typemap' : typemap(jstype) long &INPUT,
17312                 'code' : int,
17313                 'type' : r.long,
17314             }
17315 ,
17316             'tmap:javadirectorin' : Hash {
17317                 'pname' : INPUT,
17318                 'typemap' : typemap(javadirectorin) long &INPUT,
17319                 'code' : $jniinput,
17320                 'type' : r.long,
17321             }
17322 ,
17323             'tmap:directorin' : Hash {
17324                 'kwargs' : Hash {
17325                     'name' : descriptor,
17326                     'value' : I,
17327                 }
17328 ,
17329                 'pname' : INPUT,
17330                 'typemap' : typemap(directorin) long &INPUT,
17331                 'code' :  *(($&1_ltype) $input) = (jint *) &$1; ,
17332                 'type' : r.long,
17333             }
17334 ,
17335             'tmap:javadirectorout' : Hash {
17336                 'pname' : INPUT,
17337                 'typemap' : typemap(javadirectorout) long &INPUT,
17338                 'code' : $javacall,
17339                 'type' : r.long,
17340             }
17341 ,
17342             'tmap:in' : Hash {
17343                 'kwargs' : Hash {
17344                     'name' : numinputs,
17345                     'value' : 1,
17346                 }
17347 ,
17348                 'pname' : INPUT,
17349                 'typemap' : typemap(in) long &INPUT,
17350                 'code' :  $1 = ($1_ltype)&$input; ,
17351                 'type' : r.long,
17352             }
17353 ,
17354             'tmap:directorout' : Hash {
17355                 'pname' : INPUT,
17356                 'typemap' : typemap(directorout) long &INPUT,
17357                 'code' :  $result = ($1_ltype)&$input; ,
17358                 'type' : r.long,
17359             }
17360 ,
17361             'tmap:jni' : Hash {
17362                 'pname' : INPUT,
17363                 'typemap' : typemap(jni) long &INPUT,
17364                 'code' : jint,
17365                 'type' : r.long,
17366             }
17367 ,
17368             'tmap:jtype' : Hash {
17369                 'pname' : INPUT,
17370                 'typemap' : typemap(jtype) long &INPUT,
17371                 'code' : int,
17372                 'type' : r.long,
17373             }
17374 ,
17375             'tmap:javain' : Hash {
17376                 'pname' : INPUT,
17377                 'typemap' : typemap(javain) long &INPUT,
17378                 'code' : $javainput,
17379                 'type' : r.long,
17380             }
17381 ,
17382             'tmap:typecheck' : Hash {
17383                 'kwargs' : Hash {
17384                     'name' : precedence,
17385                     'value' : 45,
17386                 }
17387 ,
17388                 'pname' : INPUT,
17389                 'typemap' : typemap(typecheck) long &INPUT,
17390                 'code' : ,
17391                 'type' : r.long,
17392             }
17393 ,
17394         }
17395 ,
17396         'OUTPUT' : Hash {
17397             'tmap:freearg' : Hash {
17398                 'pname' : OUTPUT,
17399                 'typemap' : typemap(freearg) long &OUTPUT,
17400                 'code' : ,
17401                 'type' : r.long,
17402             }
17403 ,
17404             'tmap:jstype' : Hash {
17405                 'pname' : OUTPUT,
17406                 'typemap' : typemap(jstype) long &OUTPUT,
17407                 'code' : int[],
17408                 'type' : r.long,
17409             }
17410 ,
17411             'tmap:javadirectorin' : Hash {
17412                 'pname' : OUTPUT,
17413                 'typemap' : typemap(javadirectorin) long &OUTPUT,
17414                 'code' : $jniinput,
17415                 'type' : r.long,
17416             }
17417 ,
17418             'tmap:directorin' : Hash {
17419                 'kwargs' : Hash {
17420                     'name' : descriptor,
17421                     'value' : [Ljava/lang/Integer;,
17422                 }
17423 ,
17424                 'pname' : OUTPUT,
17425                 'typemap' : typemap(directorin) long &OUTPUT,
17426                 'code' :  *(($&1_ltype) $input = &$1; ,
17427                 'type' : r.long,
17428             }
17429 ,
17430             'tmap:argout' : Hash {
17431                 'pname' : OUTPUT,
17432                 'typemap' : typemap(argout) long &OUTPUT,
17433                 'code' : {
17434   jint jvalue = (jint)temp$argnum;
17435   jenv->SetIntArrayRegion($input, 0, 1, &jvalue);
17436 },
17437                 'type' : r.long,
17438             }
17439 ,
17440             'tmap:javadirectorout' : Hash {
17441                 'pname' : OUTPUT,
17442                 'typemap' : typemap(javadirectorout) long &OUTPUT,
17443                 'code' : $javacall,
17444                 'type' : r.long,
17445             }
17446 ,
17447             'tmap:in' : Hash {
17448                 'locals' : Hash {
17449                     'name' : temp,
17450                     'type' : $*1_ltype,
17451                 }
17452 ,
17453                 'kwargs' : Hash {
17454                     'name' : numinputs,
17455                     'value' : 1,
17456                 }
17457 ,
17458                 'pname' : OUTPUT,
17459                 'typemap' : typemap(in) long &OUTPUT,
17460                 'code' : {
17461   if (!$input) {
17462     SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
17463     return $null;
17464   }
17465   if (jenv->GetArrayLength($input) == 0) {
17466     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
17467     return $null;
17468   }
17469   $1 = &temp;
17470 },
17471                 'type' : r.long,
17472             }
17473 ,
17474             'tmap:directorout' : Hash {
17475                 'kwargs' : Hash {
17476                     'name' : warning,
17477                     'value' : Need to provide long *OUTPUT directorout typemap,
17478                 }
17479 ,
17480                 'pname' : OUTPUT,
17481                 'typemap' : typemap(directorout) long &OUTPUT,
17482                 'code' : {
17483 },
17484                 'type' : r.long,
17485             }
17486 ,
17487             'tmap:jni' : Hash {
17488                 'pname' : OUTPUT,
17489                 'typemap' : typemap(jni) long &OUTPUT,
17490                 'code' : jintArray,
17491                 'type' : r.long,
17492             }
17493 ,
17494             'tmap:jtype' : Hash {
17495                 'pname' : OUTPUT,
17496                 'typemap' : typemap(jtype) long &OUTPUT,
17497                 'code' : int[],
17498                 'type' : r.long,
17499             }
17500 ,
17501             'tmap:javain' : Hash {
17502                 'pname' : OUTPUT,
17503                 'typemap' : typemap(javain) long &OUTPUT,
17504                 'code' : $javainput,
17505                 'type' : r.long,
17506             }
17507 ,
17508         }
17509 ,
17510     }
17511 ,
17512     'jintArray' : Hash {
17513         'tmap:jstype' : Hash {
17514             'typemap' : typemap(jstype) jintArray,
17515             'code' : int[],
17516             'type' : jintArray,
17517         }
17518 ,
17519         'tmap:directorin' : Hash {
17520             'kwargs' : Hash {
17521                 'name' : descriptor,
17522                 'value' : [I,
17523             }
17524 ,
17525             'typemap' : typemap(directorin) jintArray,
17526             'code' : $input = $1;,
17527             'type' : jintArray,
17528         }
17529 ,
17530         'tmap:javadirectorin' : Hash {
17531             'typemap' : typemap(javadirectorin) jintArray,
17532             'code' : $jniinput,
17533             'type' : jintArray,
17534         }
17535 ,
17536         'tmap:in' : Hash {
17537             'kwargs' : Hash {
17538                 'name' : numinputs,
17539                 'value' : 1,
17540             }
17541 ,
17542             'typemap' : typemap(in) jintArray,
17543             'code' :  $1 = $input; ,
17544             'type' : jintArray,
17545         }
17546 ,
17547         'tmap:directorout' : Hash {
17548             'typemap' : typemap(directorout) jintArray,
17549             'code' :  $result = $input; ,
17550             'type' : jintArray,
17551         }
17552 ,
17553         'tmap:javadirectorout' : Hash {
17554             'typemap' : typemap(javadirectorout) jintArray,
17555             'code' : $javacall,
17556             'type' : jintArray,
17557         }
17558 ,
17559         'tmap:jni' : Hash {
17560             'typemap' : typemap(jni) jintArray,
17561             'code' : jintArray,
17562             'type' : jintArray,
17563         }
17564 ,
17565         'tmap:jtype' : Hash {
17566             'typemap' : typemap(jtype) jintArray,
17567             'code' : int[],
17568             'type' : jintArray,
17569         }
17570 ,
17571         'tmap:out' : Hash {
17572             'typemap' : typemap(out) jintArray,
17573             'code' :  $result = $1; ,
17574             'type' : jintArray,
17575         }
17576 ,
17577         'tmap:typecheck' : Hash {
17578             'kwargs' : Hash {
17579                 'name' : precedence,
17580                 'value' : 1045,
17581             }
17582 ,
17583             'typemap' : typemap(typecheck) jintArray,
17584             'code' : ,
17585             'type' : jintArray,
17586         }
17587 ,
17588         'tmap:javain' : Hash {
17589             'typemap' : typemap(javain) jintArray,
17590             'code' : $javainput,
17591             'type' : jintArray,
17592         }
17593 ,
17594         'tmap:javaout' : Hash {
17595             'typemap' : typemap(javaout) jintArray,
17596             'code' : {
17597     return $jnicall;
17598   },
17599             'type' : jintArray,
17600         }
17601 ,
17602     }
17603 ,
17604     'jshortArray' : Hash {
17605         'tmap:jstype' : Hash {
17606             'typemap' : typemap(jstype) jshortArray,
17607             'code' : short[],
17608             'type' : jshortArray,
17609         }
17610 ,
17611         'tmap:directorin' : Hash {
17612             'kwargs' : Hash {
17613                 'name' : descriptor,
17614                 'value' : [S,
17615             }
17616 ,
17617             'typemap' : typemap(directorin) jshortArray,
17618             'code' : $input = $1;,
17619             'type' : jshortArray,
17620         }
17621 ,
17622         'tmap:javadirectorin' : Hash {
17623             'typemap' : typemap(javadirectorin) jshortArray,
17624             'code' : $jniinput,
17625             'type' : jshortArray,
17626         }
17627 ,
17628         'tmap:in' : Hash {
17629             'kwargs' : Hash {
17630                 'name' : numinputs,
17631                 'value' : 1,
17632             }
17633 ,
17634             'typemap' : typemap(in) jshortArray,
17635             'code' :  $1 = $input; ,
17636             'type' : jshortArray,
17637         }
17638 ,
17639         'tmap:directorout' : Hash {
17640             'typemap' : typemap(directorout) jshortArray,
17641             'code' :  $result = $input; ,
17642             'type' : jshortArray,
17643         }
17644 ,
17645         'tmap:javadirectorout' : Hash {
17646             'typemap' : typemap(javadirectorout) jshortArray,
17647             'code' : $javacall,
17648             'type' : jshortArray,
17649         }
17650 ,
17651         'tmap:jni' : Hash {
17652             'typemap' : typemap(jni) jshortArray,
17653             'code' : jshortArray,
17654             'type' : jshortArray,
17655         }
17656 ,
17657         'tmap:jtype' : Hash {
17658             'typemap' : typemap(jtype) jshortArray,
17659             'code' : short[],
17660             'type' : jshortArray,
17661         }
17662 ,
17663         'tmap:out' : Hash {
17664             'typemap' : typemap(out) jshortArray,
17665             'code' :  $result = $1; ,
17666             'type' : jshortArray,
17667         }
17668 ,
17669         'tmap:typecheck' : Hash {
17670             'kwargs' : Hash {
17671                 'name' : precedence,
17672                 'value' : 1035,
17673             }
17674 ,
17675             'typemap' : typemap(typecheck) jshortArray,
17676             'code' : ,
17677             'type' : jshortArray,
17678         }
17679 ,
17680         'tmap:javain' : Hash {
17681             'typemap' : typemap(javain) jshortArray,
17682             'code' : $javainput,
17683             'type' : jshortArray,
17684         }
17685 ,
17686         'tmap:javaout' : Hash {
17687             'typemap' : typemap(javaout) jshortArray,
17688             'code' : {
17689     return $jnicall;
17690   },
17691             'type' : jshortArray,
17692         }
17693 ,
17694     }
17695 ,
17696     'a(ANY).int' : Hash {
17697         'tmap:freearg' : Hash {
17698             'typemap' : typemap(freearg) int [ANY],
17699             'code' :  delete [] $1; ,
17700             'type' : a(ANY).int,
17701         }
17702 ,
17703         'tmap:jstype' : Hash {
17704             'typemap' : typemap(jstype) int [ANY],
17705             'code' : int[],
17706             'type' : a(ANY).int,
17707         }
17708 ,
17709         'tmap:argout' : Hash {
17710             'typemap' : typemap(argout) int [ANY],
17711             'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, $1, $input); ,
17712             'type' : a(ANY).int,
17713         }
17714 ,
17715         'tmap:in' : Hash {
17716             'locals' : Hash {
17717                 'name' : jarr,
17718                 'type' : p.jint,
17719             }
17720 ,
17721             'kwargs' : Hash {
17722                 'name' : numinputs,
17723                 'value' : 1,
17724             }
17725 ,
17726             'typemap' : typemap(in) int [ANY],
17727             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
17728     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
17729     return $null;
17730   }
17731   if (!SWIG_JavaArrayInInt(jenv, &jarr, &$1, $input)) return $null; ,
17732             'type' : a(ANY).int,
17733         }
17734 ,
17735         'tmap:jni' : Hash {
17736             'typemap' : typemap(jni) int [ANY],
17737             'code' : jintArray,
17738             'type' : a(ANY).int,
17739         }
17740 ,
17741         'tmap:jtype' : Hash {
17742             'typemap' : typemap(jtype) int [ANY],
17743             'code' : int[],
17744             'type' : a(ANY).int,
17745         }
17746 ,
17747         'tmap:out' : Hash {
17748             'typemap' : typemap(out) int [ANY],
17749             'code' : $result = SWIG_JavaArrayOutInt(jenv, $1, $1_dim0); ,
17750             'type' : a(ANY).int,
17751         }
17752 ,
17753         'tmap:javain' : Hash {
17754             'typemap' : typemap(javain) int [ANY],
17755             'code' : $javainput,
17756             'type' : a(ANY).int,
17757         }
17758 ,
17759         'tmap:typecheck' : Hash {
17760             'kwargs' : Hash {
17761                 'name' : precedence,
17762                 'value' : 1045,
17763             }
17764 ,
17765             'typemap' : typemap(typecheck) int [ANY],
17766             'code' : ,
17767             'type' : a(ANY).int,
17768         }
17769 ,
17770         'tmap:javaout' : Hash {
17771             'typemap' : typemap(javaout) int [ANY],
17772             'code' : {
17773     return $jnicall;
17774   },
17775             'type' : a(ANY).int,
17776         }
17777 ,
17778     }
17779 ,
17780     'r.q(const).float' : Hash {
17781         'tmap:jstype' : Hash {
17782             'typemap' : typemap(jstype) float const &,
17783             'code' : float,
17784             'type' : r.q(const).float,
17785         }
17786 ,
17787         'tmap:directorin' : Hash {
17788             'kwargs' : Hash {
17789                 'name' : descriptor,
17790                 'value' : F,
17791             }
17792 ,
17793             'typemap' : typemap(directorin) float const &,
17794             'code' : $input = (jfloat)$1_name;,
17795             'type' : r.q(const).float,
17796         }
17797 ,
17798         'tmap:javadirectorin' : Hash {
17799             'locals' : Hash {
17800                 'name' : temp,
17801                 'type' : $*1_ltype,
17802             }
17803 ,
17804             'typemap' : typemap(javadirectorin) float const &,
17805             'code' : $jniinput,
17806             'type' : r.q(const).float,
17807         }
17808 ,
17809         'tmap:in' : Hash {
17810             'locals' : Hash {
17811                 'name' : temp,
17812                 'type' : $*1_ltype,
17813             }
17814 ,
17815             'kwargs' : Hash {
17816                 'name' : numinputs,
17817                 'value' : 1,
17818             }
17819 ,
17820             'typemap' : typemap(in) float const &,
17821             'code' :  temp = ($*1_ltype)$input;
17822    $1 = &temp; ,
17823             'type' : r.q(const).float,
17824         }
17825 ,
17826         'tmap:directorout' : Hash {
17827             'kwargs' : Hash {
17828                 'name' : warning,
17829                 'value' : 470:Thread/reentrant unsafe wrapping, consider returning by value instead.,
17830             }
17831 ,
17832             'typemap' : typemap(directorout) float const &,
17833             'code' :  static $*1_ltype temp;
17834    temp = ($*1_ltype)$input;
17835    $result = &temp; ,
17836             'type' : r.q(const).float,
17837         }
17838 ,
17839         'tmap:javadirectorout' : Hash {
17840             'locals' : Hash {
17841                 'name' : temp,
17842                 'type' : $*1_ltype,
17843             }
17844 ,
17845             'typemap' : typemap(javadirectorout) float const &,
17846             'code' : $javacall,
17847             'type' : r.q(const).float,
17848         }
17849 ,
17850         'tmap:jni' : Hash {
17851             'typemap' : typemap(jni) float const &,
17852             'code' : jfloat,
17853             'type' : r.q(const).float,
17854         }
17855 ,
17856         'tmap:jtype' : Hash {
17857             'typemap' : typemap(jtype) float const &,
17858             'code' : float,
17859             'type' : r.q(const).float,
17860         }
17861 ,
17862         'tmap:out' : Hash {
17863             'typemap' : typemap(out) float const &,
17864             'code' :  $result = (jfloat)*$1; ,
17865             'type' : r.q(const).float,
17866         }
17867 ,
17868         'tmap:typecheck' : Hash {
17869             'kwargs' : Hash {
17870                 'name' : precedence,
17871                 'value' : 80,
17872             }
17873 ,
17874             'typemap' : typemap(typecheck) float const &,
17875             'code' : ,
17876             'type' : r.q(const).float,
17877         }
17878 ,
17879         'tmap:javain' : Hash {
17880             'typemap' : typemap(javain) float const &,
17881             'code' : $javainput,
17882             'type' : r.q(const).float,
17883         }
17884 ,
17885         'tmap:javaout' : Hash {
17886             'typemap' : typemap(javaout) float const &,
17887             'code' : {
17888     return $jnicall;
17889   },
17890             'type' : r.q(const).float,
17891         }
17892 ,
17893     }
17894 ,
17895     'a(ANY).float' : Hash {
17896         'tmap:freearg' : Hash {
17897             'typemap' : typemap(freearg) float [ANY],
17898             'code' :  delete [] $1; ,
17899             'type' : a(ANY).float,
17900         }
17901 ,
17902         'tmap:jstype' : Hash {
17903             'typemap' : typemap(jstype) float [ANY],
17904             'code' : float[],
17905             'type' : a(ANY).float,
17906         }
17907 ,
17908         'tmap:argout' : Hash {
17909             'typemap' : typemap(argout) float [ANY],
17910             'code' :  SWIG_JavaArrayArgoutFloat(jenv, jarr$argnum, $1, $input); ,
17911             'type' : a(ANY).float,
17912         }
17913 ,
17914         'tmap:in' : Hash {
17915             'locals' : Hash {
17916                 'name' : jarr,
17917                 'type' : p.jfloat,
17918             }
17919 ,
17920             'kwargs' : Hash {
17921                 'name' : numinputs,
17922                 'value' : 1,
17923             }
17924 ,
17925             'typemap' : typemap(in) float [ANY],
17926             'code' :   if ($input && jenv->GetArrayLength($input) != $1_size) {
17927     SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "incorrect array size");
17928     return $null;
17929   }
17930   if (!SWIG_JavaArrayInFloat(jenv, &jarr, &$1, $input)) return $null; ,
17931             'type' : a(ANY).float,
17932         }
17933 ,
17934         'tmap:jni' : Hash {
17935             'typemap' : typemap(jni) float [ANY],
17936             'code' : jfloatArray,
17937             'type' : a(ANY).float,
17938         }
17939 ,
17940         'tmap:jtype' : Hash {
17941             'typemap' : typemap(jtype) float [ANY],
17942             'code' : float[],
17943             'type' : a(ANY).float,
17944         }
17945 ,
17946         'tmap:out' : Hash {
17947             'typemap' : typemap(out) float [ANY],
17948             'code' : $result = SWIG_JavaArrayOutFloat(jenv, $1, $1_dim0); ,
17949             'type' : a(ANY).float,
17950         }
17951 ,
17952         'tmap:javain' : Hash {
17953             'typemap' : typemap(javain) float [ANY],
17954             'code' : $javainput,
17955             'type' : a(ANY).float,
17956         }
17957 ,
17958         'tmap:typecheck' : Hash {
17959             'kwargs' : Hash {
17960                 'name' : precedence,
17961                 'value' : 1080,
17962             }
17963 ,
17964             'typemap' : typemap(typecheck) float [ANY],
17965             'code' : ,
17966             'type' : a(ANY).float,
17967         }
17968 ,
17969         'tmap:javaout' : Hash {
17970             'typemap' : typemap(javaout) float [ANY],
17971             'code' : {
17972     return $jnicall;
17973   },
17974             'type' : a(ANY).float,
17975         }
17976 ,
17977     }
17978 ,
17979     'a().float' : Hash {
17980         'tmap:freearg' : Hash {
17981             'typemap' : typemap(freearg) float [],
17982             'code' :  delete [] $1; ,
17983             'type' : a().float,
17984         }
17985 ,
17986         'tmap:jstype' : Hash {
17987             'typemap' : typemap(jstype) float [],
17988             'code' : float[],
17989             'type' : a().float,
17990         }
17991 ,
17992         'tmap:argout' : Hash {
17993             'typemap' : typemap(argout) float [],
17994             'code' :  SWIG_JavaArrayArgoutFloat(jenv, jarr$argnum, $1, $input); ,
17995             'type' : a().float,
17996         }
17997 ,
17998         'tmap:in' : Hash {
17999             'locals' : Hash {
18000                 'name' : jarr,
18001                 'type' : p.jfloat,
18002             }
18003 ,
18004             'kwargs' : Hash {
18005                 'name' : numinputs,
18006                 'value' : 1,
18007             }
18008 ,
18009             'typemap' : typemap(in) float [],
18010             'code' :   if (!SWIG_JavaArrayInFloat(jenv, &jarr, &$1, $input)) return $null; ,
18011             'type' : a().float,
18012         }
18013 ,
18014         'tmap:jni' : Hash {
18015             'typemap' : typemap(jni) float [],
18016             'code' : jfloatArray,
18017             'type' : a().float,
18018         }
18019 ,
18020         'tmap:jtype' : Hash {
18021             'typemap' : typemap(jtype) float [],
18022             'code' : float[],
18023             'type' : a().float,
18024         }
18025 ,
18026         'tmap:out' : Hash {
18027             'typemap' : typemap(out) float [],
18028             'code' : $result = SWIG_JavaArrayOutFloat(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
18029             'type' : a().float,
18030         }
18031 ,
18032         'tmap:javain' : Hash {
18033             'typemap' : typemap(javain) float [],
18034             'code' : $javainput,
18035             'type' : a().float,
18036         }
18037 ,
18038         'tmap:typecheck' : Hash {
18039             'kwargs' : Hash {
18040                 'name' : precedence,
18041                 'value' : 1080,
18042             }
18043 ,
18044             'typemap' : typemap(typecheck) float [],
18045             'code' : ,
18046             'type' : a().float,
18047         }
18048 ,
18049         'tmap:javaout' : Hash {
18050             'typemap' : typemap(javaout) float [],
18051             'code' : {
18052     return $jnicall;
18053   },
18054             'type' : a().float,
18055         }
18056 ,
18057     }
18058 ,
18059     'a().int' : Hash {
18060         'tmap:freearg' : Hash {
18061             'typemap' : typemap(freearg) int [],
18062             'code' :  delete [] $1; ,
18063             'type' : a().int,
18064         }
18065 ,
18066         'tmap:jstype' : Hash {
18067             'typemap' : typemap(jstype) int [],
18068             'code' : int[],
18069             'type' : a().int,
18070         }
18071 ,
18072         'tmap:argout' : Hash {
18073             'typemap' : typemap(argout) int [],
18074             'code' :  SWIG_JavaArrayArgoutInt(jenv, jarr$argnum, $1, $input); ,
18075             'type' : a().int,
18076         }
18077 ,
18078         'tmap:in' : Hash {
18079             'locals' : Hash {
18080                 'name' : jarr,
18081                 'type' : p.jint,
18082             }
18083 ,
18084             'kwargs' : Hash {
18085                 'name' : numinputs,
18086                 'value' : 1,
18087             }
18088 ,
18089             'typemap' : typemap(in) int [],
18090             'code' :   if (!SWIG_JavaArrayInInt(jenv, &jarr, &$1, $input)) return $null; ,
18091             'type' : a().int,
18092         }
18093 ,
18094         'tmap:jni' : Hash {
18095             'typemap' : typemap(jni) int [],
18096             'code' : jintArray,
18097             'type' : a().int,
18098         }
18099 ,
18100         'tmap:jtype' : Hash {
18101             'typemap' : typemap(jtype) int [],
18102             'code' : int[],
18103             'type' : a().int,
18104         }
18105 ,
18106         'tmap:out' : Hash {
18107             'typemap' : typemap(out) int [],
18108             'code' : $result = SWIG_JavaArrayOutInt(jenv, $1, FillMeInAsSizeCannotBeDeterminedAutomatically); ,
18109             'type' : a().int,
18110         }
18111 ,
18112         'tmap:javain' : Hash {
18113             'typemap' : typemap(javain) int [],
18114             'code' : $javainput,
18115             'type' : a().int,
18116         }
18117 ,
18118         'tmap:typecheck' : Hash {
18119             'kwargs' : Hash {
18120                 'name' : precedence,
18121                 'value' : 1045,
18122             }
18123 ,
18124             'typemap' : typemap(typecheck) int [],
18125             'code' : ,
18126             'type' : a().int,
18127         }
18128 ,
18129         'tmap:javaout' : Hash {
18130             'typemap' : typemap(javaout) int [],
18131             'code' : {
18132     return $jnicall;
18133   },
18134             'type' : a().int,
18135         }
18136 ,
18137     }
18138 ,
18139     'jcharArray' : Hash {
18140         'tmap:jstype' : Hash {
18141             'typemap' : typemap(jstype) jcharArray,
18142             'code' : char[],
18143             'type' : jcharArray,
18144         }
18145 ,
18146         'tmap:directorin' : Hash {
18147             'kwargs' : Hash {
18148                 'name' : descriptor,
18149                 'value' : [C,
18150             }
18151 ,
18152             'typemap' : typemap(directorin) jcharArray,
18153             'code' : $input = $1;,
18154             'type' : jcharArray,
18155         }
18156 ,
18157         'tmap:javadirectorin' : Hash {
18158             'typemap' : typemap(javadirectorin) jcharArray,
18159             'code' : $jniinput,
18160             'type' : jcharArray,
18161         }
18162 ,
18163         'tmap:in' : Hash {
18164             'kwargs' : Hash {
18165                 'name' : numinputs,
18166                 'value' : 1,
18167             }
18168 ,
18169             'typemap' : typemap(in) jcharArray,
18170             'code' :  $1 = $input; ,
18171             'type' : jcharArray,
18172         }
18173 ,
18174         'tmap:directorout' : Hash {
18175             'typemap' : typemap(directorout) jcharArray,
18176             'code' :  $result = $input; ,
18177             'type' : jcharArray,
18178         }
18179 ,
18180         'tmap:javadirectorout' : Hash {
18181             'typemap' : typemap(javadirectorout) jcharArray,
18182             'code' : $javacall,
18183             'type' : jcharArray,
18184         }
18185 ,
18186         'tmap:jni' : Hash {
18187             'typemap' : typemap(jni) jcharArray,
18188             'code' : jcharArray,
18189             'type' : jcharArray,
18190         }
18191 ,
18192         'tmap:jtype' : Hash {
18193             'typemap' : typemap(jtype) jcharArray,
18194             'code' : char[],
18195             'type' : jcharArray,
18196         }
18197 ,
18198         'tmap:out' : Hash {
18199             'typemap' : typemap(out) jcharArray,
18200             'code' :  $result = $1; ,
18201             'type' : jcharArray,
18202         }
18203 ,
18204         'tmap:typecheck' : Hash {
18205             'kwargs' : Hash {
18206                 'name' : precedence,
18207                 'value' : 1130,
18208             }
18209 ,
18210             'typemap' : typemap(typecheck) jcharArray,
18211             'code' : ,
18212             'type' : jcharArray,
18213         }
18214 ,
18215         'tmap:javain' : Hash {
18216             'typemap' : typemap(javain) jcharArray,
18217             'code' : $javainput,
18218             'type' : jcharArray,
18219         }
18220 ,
18221         'tmap:javaout' : Hash {
18222             'typemap' : typemap(javaout) jcharArray,
18223             'code' : {
18224     return $jnicall;
18225   },
18226             'type' : jcharArray,
18227         }
18228 ,
18229     }
18230 ,
18231 }
18232
18233 -----------------------------------------------------------------------------
18234 Compiling...
18235 Linking...
18236 Checking yaz4jlibJNI...
18237   public final static native long ZOOM_record_get_bytes(long jarg1, String jarg2, long jarg3);
18238 Checking yaz4jlib...
18239   public static CharStarByteArray ZOOM_record_get_bytes(SWIGTYPE_p_ZOOM_record rec, String type, SWIGTYPE_p_int len) {
18240     return new CharStarByteArray(yaz4jlibJNI.ZOOM_record_get_bytes(SWIGTYPE_p_ZOOM_record.getCPtr(rec), type, SWIGTYPE_p_int.getCPtr(len)), true);