perl/lib/IDZebra.pm

   1 # This file was automatically generated by SWIG
   2 package IDZebra;
   3 require Exporter;
   4 require DynaLoader;
   5 @ISA = qw(Exporter DynaLoader);
   6 package IDZebrac;
   7 bootstrap IDZebra;
   8 package IDZebra;
   9 @EXPORT = qw( );
  10
  11 # ---------- BASE METHODS -------------
  12
  13 package IDZebra;
  14
  15 sub TIEHASH {
  16     my ($classname,$obj) = @_;
  17     return bless $obj, $classname;
  18 }
  19
  20 sub CLEAR { }
  21
  22 sub FIRSTKEY { }
  23
  24 sub NEXTKEY { }
  25
  26 sub this {
  27     my $ptr = shift;
  28     return tied(%$ptr);
  29 }
  30
  31
  32 # ------- FUNCTION WRAPPERS --------
  33
  34 package IDZebra;
  35
  36 *DESTROY = *IDZebrac::DESTROY;
  37 *logLevel = *IDZebrac::logLevel;
  38 *logFile = *IDZebrac::logFile;
  39 *logMsg = *IDZebrac::logMsg;
  40 *odr_createmem = *IDZebrac::odr_createmem;
  41 *odr_reset = *IDZebrac::odr_reset;
  42 *odr_destroy = *IDZebrac::odr_destroy;
  43 *odr_malloc = *IDZebrac::odr_malloc;
  44 *start = *IDZebrac::start;
  45 *open = *IDZebrac::open;
  46 *close = *IDZebrac::close;
  47 *stop = *IDZebrac::stop;
  48 *errCode = *IDZebrac::errCode;
  49 *errString = *IDZebrac::errString;
  50 *errAdd = *IDZebrac::errAdd;
  51 *init_recordGroup = *IDZebrac::init_recordGroup;
  52 *res_get_recordGroup = *IDZebrac::res_get_recordGroup;
  53 *set_group = *IDZebrac::set_group;
  54 *select_database = *IDZebrac::select_database;
  55 *select_databases = *IDZebrac::select_databases;
  56 *begin_trans = *IDZebrac::begin_trans;
  57 *end_trans = *IDZebrac::end_trans;
  58 *begin_read = *IDZebrac::begin_read;
  59 *end_read = *IDZebrac::end_read;
  60 *commit = *IDZebrac::commit;
  61 *get_shadow_enable = *IDZebrac::get_shadow_enable;
  62 *set_shadow_enable = *IDZebrac::set_shadow_enable;
  63 *init = *IDZebrac::init;
  64 *compact = *IDZebrac::compact;
  65 *repository_update = *IDZebrac::repository_update;
  66 *repository_delete = *IDZebrac::repository_delete;
  67 *repository_show = *IDZebrac::repository_show;
  68 *update_record = *IDZebrac::update_record;
  69 *delete_record = *IDZebrac::delete_record;
  70 *search_PQF = *IDZebrac::search_PQF;
  71 *records_retrieve = *IDZebrac::records_retrieve;
  72 *record_retrieve = *IDZebrac::record_retrieve;
  73 *sort = *IDZebrac::sort;
  74 *nmem_create = *IDZebrac::nmem_create;
  75 *nmem_destroy = *IDZebrac::nmem_destroy;
  76 *data1_create = *IDZebrac::data1_create;
  77 *data1_createx = *IDZebrac::data1_createx;
  78 *data1_destroy = *IDZebrac::data1_destroy;
  79 *get_parent_tag = *IDZebrac::get_parent_tag;
  80 *data1_read_node = *IDZebrac::data1_read_node;
  81 *data1_read_nodex = *IDZebrac::data1_read_nodex;
  82 *data1_read_record = *IDZebrac::data1_read_record;
  83 *data1_read_absyn = *IDZebrac::data1_read_absyn;
  84 *data1_gettagbynum = *IDZebrac::data1_gettagbynum;
  85 *data1_empty_tagset = *IDZebrac::data1_empty_tagset;
  86 *data1_read_tagset = *IDZebrac::data1_read_tagset;
  87 *data1_getelementbytagname = *IDZebrac::data1_getelementbytagname;
  88 *data1_nodetogr = *IDZebrac::data1_nodetogr;
  89 *data1_gettagbyname = *IDZebrac::data1_gettagbyname;
  90 *data1_free_tree = *IDZebrac::data1_free_tree;
  91 *data1_nodetobuf = *IDZebrac::data1_nodetobuf;
  92 *data1_mk_tag_data_wd = *IDZebrac::data1_mk_tag_data_wd;
  93 *data1_mk_tag_data = *IDZebrac::data1_mk_tag_data;
  94 *data1_maptype = *IDZebrac::data1_maptype;
  95 *data1_read_varset = *IDZebrac::data1_read_varset;
  96 *data1_getvartypebyct = *IDZebrac::data1_getvartypebyct;
  97 *data1_read_espec1 = *IDZebrac::data1_read_espec1;
  98 *data1_doespec1 = *IDZebrac::data1_doespec1;
  99 *data1_getesetbyname = *IDZebrac::data1_getesetbyname;
 100 *data1_getelementbyname = *IDZebrac::data1_getelementbyname;
 101 *data1_mk_node2 = *IDZebrac::data1_mk_node2;
 102 *data1_mk_tag = *IDZebrac::data1_mk_tag;
 103 *data1_mk_tag_n = *IDZebrac::data1_mk_tag_n;
 104 *data1_tag_add_attr = *IDZebrac::data1_tag_add_attr;
 105 *data1_mk_text_n = *IDZebrac::data1_mk_text_n;
 106 *data1_mk_text_nf = *IDZebrac::data1_mk_text_nf;
 107 *data1_mk_text = *IDZebrac::data1_mk_text;
 108 *data1_mk_comment_n = *IDZebrac::data1_mk_comment_n;
 109 *data1_mk_comment = *IDZebrac::data1_mk_comment;
 110 *data1_mk_preprocess = *IDZebrac::data1_mk_preprocess;
 111 *data1_mk_root = *IDZebrac::data1_mk_root;
 112 *data1_set_root = *IDZebrac::data1_set_root;
 113 *data1_mk_tag_data_int = *IDZebrac::data1_mk_tag_data_int;
 114 *data1_mk_tag_data_oid = *IDZebrac::data1_mk_tag_data_oid;
 115 *data1_mk_tag_data_text = *IDZebrac::data1_mk_tag_data_text;
 116 *data1_mk_tag_data_text_uni = *IDZebrac::data1_mk_tag_data_text_uni;
 117 *data1_get_absyn = *IDZebrac::data1_get_absyn;
 118 *data1_search_tag = *IDZebrac::data1_search_tag;
 119 *data1_mk_tag_uni = *IDZebrac::data1_mk_tag_uni;
 120 *data1_get_attset = *IDZebrac::data1_get_attset;
 121 *data1_read_maptab = *IDZebrac::data1_read_maptab;
 122 *data1_map_record = *IDZebrac::data1_map_record;
 123 *data1_read_marctab = *IDZebrac::data1_read_marctab;
 124 *data1_nodetomarc = *IDZebrac::data1_nodetomarc;
 125 *data1_nodetoidsgml = *IDZebrac::data1_nodetoidsgml;
 126 *data1_nodetoexplain = *IDZebrac::data1_nodetoexplain;
 127 *data1_nodetosummary = *IDZebrac::data1_nodetosummary;
 128 *data1_nodetosoif = *IDZebrac::data1_nodetosoif;
 129 *data1_get_wrbuf = *IDZebrac::data1_get_wrbuf;
 130 *data1_get_read_buf = *IDZebrac::data1_get_read_buf;
 131 *data1_get_map_buf = *IDZebrac::data1_get_map_buf;
 132 *data1_absyn_cache_get = *IDZebrac::data1_absyn_cache_get;
 133 *data1_attset_cache_get = *IDZebrac::data1_attset_cache_get;
 134 *data1_nmem_get = *IDZebrac::data1_nmem_get;
 135 *data1_pr_tree = *IDZebrac::data1_pr_tree;
 136 *data1_print_tree = *IDZebrac::data1_print_tree;
 137 *data1_insert_string = *IDZebrac::data1_insert_string;
 138 *data1_insert_string_n = *IDZebrac::data1_insert_string_n;
 139 *data1_read_sgml = *IDZebrac::data1_read_sgml;
 140 *data1_absyn_trav = *IDZebrac::data1_absyn_trav;
 141 *data1_attset_search_id = *IDZebrac::data1_attset_search_id;
 142 *data1_getNodeValue = *IDZebrac::data1_getNodeValue;
 143 *data1_LookupNode = *IDZebrac::data1_LookupNode;
 144 *data1_CountOccurences = *IDZebrac::data1_CountOccurences;
 145 *data1_path_fopen = *IDZebrac::data1_path_fopen;
 146 *data1_set_tabpath = *IDZebrac::data1_set_tabpath;
 147 *data1_set_tabroot = *IDZebrac::data1_set_tabroot;
 148 *data1_get_tabpath = *IDZebrac::data1_get_tabpath;
 149 *data1_get_tabroot = *IDZebrac::data1_get_tabroot;
 150 *grs_perl_readf = *IDZebrac::grs_perl_readf;
 151 *grs_perl_seekf = *IDZebrac::grs_perl_seekf;
 152 *grs_perl_tellf = *IDZebrac::grs_perl_tellf;
 153 *grs_perl_endf = *IDZebrac::grs_perl_endf;
 154 *grs_perl_get_dh = *IDZebrac::grs_perl_get_dh;
 155 *grs_perl_get_mem = *IDZebrac::grs_perl_get_mem;
 156 *grs_perl_set_res = *IDZebrac::grs_perl_set_res;
 157
 158 ############# Class : IDZebra::recordGroup ##############
 159
 160 package IDZebra::recordGroup;
 161 @ISA = qw( IDZebra );
 162 %OWNER = ();
 163 %BLESSEDMEMBERS = (
 164 );
 165
 166 %ITERATORS = ();
 167 *swig_groupName_get = *IDZebrac::recordGroup_groupName_get;
 168 *swig_groupName_set = *IDZebrac::recordGroup_groupName_set;
 169 *swig_databaseName_get = *IDZebrac::recordGroup_databaseName_get;
 170 *swig_databaseName_set = *IDZebrac::recordGroup_databaseName_set;
 171 *swig_path_get = *IDZebrac::recordGroup_path_get;
 172 *swig_path_set = *IDZebrac::recordGroup_path_set;
 173 *swig_recordId_get = *IDZebrac::recordGroup_recordId_get;
 174 *swig_recordId_set = *IDZebrac::recordGroup_recordId_set;
 175 *swig_recordType_get = *IDZebrac::recordGroup_recordType_get;
 176 *swig_recordType_set = *IDZebrac::recordGroup_recordType_set;
 177 *swig_flagStoreData_get = *IDZebrac::recordGroup_flagStoreData_get;
 178 *swig_flagStoreData_set = *IDZebrac::recordGroup_flagStoreData_set;
 179 *swig_flagStoreKeys_get = *IDZebrac::recordGroup_flagStoreKeys_get;
 180 *swig_flagStoreKeys_set = *IDZebrac::recordGroup_flagStoreKeys_set;
 181 *swig_flagRw_get = *IDZebrac::recordGroup_flagRw_get;
 182 *swig_flagRw_set = *IDZebrac::recordGroup_flagRw_set;
 183 *swig_fileVerboseLimit_get = *IDZebrac::recordGroup_fileVerboseLimit_get;
 184 *swig_fileVerboseLimit_set = *IDZebrac::recordGroup_fileVerboseLimit_set;
 185 *swig_databaseNamePath_get = *IDZebrac::recordGroup_databaseNamePath_get;
 186 *swig_databaseNamePath_set = *IDZebrac::recordGroup_databaseNamePath_set;
 187 *swig_explainDatabase_get = *IDZebrac::recordGroup_explainDatabase_get;
 188 *swig_explainDatabase_set = *IDZebrac::recordGroup_explainDatabase_set;
 189 *swig_followLinks_get = *IDZebrac::recordGroup_followLinks_get;
 190 *swig_followLinks_set = *IDZebrac::recordGroup_followLinks_set;
 191 sub new {
 192     my $pkg = shift;
 193     my @args = @_;
 194     my $self = IDZebrac::new_recordGroup(@args);
 195     return undef if (!defined($self));
 196     $OWNER{$self} = 1;
 197     my %retval;
 198     tie %retval, "IDZebra::recordGroup", $self;
 199     return bless \%retval, $pkg;
 200 }
 201
 202 sub DESTROY {
 203     return unless $_[0]->isa('HASH');
 204     my $self = tied(%{$_[0]});
 205     return unless defined $self;
 206     delete $ITERATORS{$self};
 207     if (exists $OWNER{$self}) {
 208         IDZebrac::delete_recordGroup($self);
 209         delete $OWNER{$self};
 210     }
 211 }
 212
 213 sub DISOWN {
 214     my $self = shift;
 215     my $ptr = tied(%$self);
 216     delete $OWNER{$ptr};
 217     };
 218
 219 sub ACQUIRE {
 220     my $self = shift;
 221     my $ptr = tied(%$self);
 222     $OWNER{$ptr} = 1;
 223     };
 224
 225 sub FETCH {
 226     my ($self,$field) = @_;
 227     my $member_func = "swig_${field}_get";
 228     my $val = $self->$member_func();
 229     if (exists $BLESSEDMEMBERS{$field}) {
 230         return undef if (!defined($val));
 231         my %retval;
 232         tie %retval,$BLESSEDMEMBERS{$field},$val;
 233         return bless \%retval, $BLESSEDMEMBERS{$field};
 234     }
 235     return $val;
 236 }
 237
 238 sub STORE {
 239     my ($self,$field,$newval) = @_;
 240     my $member_func = "swig_${field}_set";
 241     if (exists $BLESSEDMEMBERS{$field}) {
 242         $self->$member_func(tied(%{$newval}));
 243     } else {
 244         $self->$member_func($newval);
 245     }
 246 }
 247
 248
 249 ############# Class : IDZebra::RetrievalObj ##############
 250
 251 package IDZebra::RetrievalObj;
 252 @ISA = qw( IDZebra );
 253 %OWNER = ();
 254 %BLESSEDMEMBERS = (
 255 );
 256
 257 %ITERATORS = ();
 258 *swig_noOfRecords_get = *IDZebrac::RetrievalObj_noOfRecords_get;
 259 *swig_noOfRecords_set = *IDZebrac::RetrievalObj_noOfRecords_set;
 260 *swig_records_get = *IDZebrac::RetrievalObj_records_get;
 261 *swig_records_set = *IDZebrac::RetrievalObj_records_set;
 262 sub new {
 263     my $pkg = shift;
 264     my @args = @_;
 265     my $self = IDZebrac::new_RetrievalObj(@args);
 266     return undef if (!defined($self));
 267     $OWNER{$self} = 1;
 268     my %retval;
 269     tie %retval, "IDZebra::RetrievalObj", $self;
 270     return bless \%retval, $pkg;
 271 }
 272
 273 sub DESTROY {
 274     return unless $_[0]->isa('HASH');
 275     my $self = tied(%{$_[0]});
 276     return unless defined $self;
 277     delete $ITERATORS{$self};
 278     if (exists $OWNER{$self}) {
 279         IDZebrac::delete_RetrievalObj($self);
 280         delete $OWNER{$self};
 281     }
 282 }
 283
 284 sub DISOWN {
 285     my $self = shift;
 286     my $ptr = tied(%$self);
 287     delete $OWNER{$ptr};
 288     };
 289
 290 sub ACQUIRE {
 291     my $self = shift;
 292     my $ptr = tied(%$self);
 293     $OWNER{$ptr} = 1;
 294     };
 295
 296 sub FETCH {
 297     my ($self,$field) = @_;
 298     my $member_func = "swig_${field}_get";
 299     my $val = $self->$member_func();
 300     if (exists $BLESSEDMEMBERS{$field}) {
 301         return undef if (!defined($val));
 302         my %retval;
 303         tie %retval,$BLESSEDMEMBERS{$field},$val;
 304         return bless \%retval, $BLESSEDMEMBERS{$field};
 305     }
 306     return $val;
 307 }
 308
 309 sub STORE {
 310     my ($self,$field,$newval) = @_;
 311     my $member_func = "swig_${field}_set";
 312     if (exists $BLESSEDMEMBERS{$field}) {
 313         $self->$member_func(tied(%{$newval}));
 314     } else {
 315         $self->$member_func($newval);
 316     }
 317 }
 318
 319
 320 ############# Class : IDZebra::RetrievalRecord ##############
 321
 322 package IDZebra::RetrievalRecord;
 323 @ISA = qw( IDZebra );
 324 %OWNER = ();
 325 %BLESSEDMEMBERS = (
 326 );
 327
 328 %ITERATORS = ();
 329 *swig_errCode_get = *IDZebrac::RetrievalRecord_errCode_get;
 330 *swig_errCode_set = *IDZebrac::RetrievalRecord_errCode_set;
 331 *swig_errString_get = *IDZebrac::RetrievalRecord_errString_get;
 332 *swig_errString_set = *IDZebrac::RetrievalRecord_errString_set;
 333 *swig_position_get = *IDZebrac::RetrievalRecord_position_get;
 334 *swig_position_set = *IDZebrac::RetrievalRecord_position_set;
 335 *swig_base_get = *IDZebrac::RetrievalRecord_base_get;
 336 *swig_base_set = *IDZebrac::RetrievalRecord_base_set;
 337 *swig_format_get = *IDZebrac::RetrievalRecord_format_get;
 338 *swig_format_set = *IDZebrac::RetrievalRecord_format_set;
 339 *swig_buf_get = *IDZebrac::RetrievalRecord_buf_get;
 340 *swig_buf_set = *IDZebrac::RetrievalRecord_buf_set;
 341 sub new {
 342     my $pkg = shift;
 343     my @args = @_;
 344     my $self = IDZebrac::new_RetrievalRecord(@args);
 345     return undef if (!defined($self));
 346     $OWNER{$self} = 1;
 347     my %retval;
 348     tie %retval, "IDZebra::RetrievalRecord", $self;
 349     return bless \%retval, $pkg;
 350 }
 351
 352 sub DESTROY {
 353     return unless $_[0]->isa('HASH');
 354     my $self = tied(%{$_[0]});
 355     return unless defined $self;
 356     delete $ITERATORS{$self};
 357     if (exists $OWNER{$self}) {
 358         IDZebrac::delete_RetrievalRecord($self);
 359         delete $OWNER{$self};
 360     }
 361 }
 362
 363 sub DISOWN {
 364     my $self = shift;
 365     my $ptr = tied(%$self);
 366     delete $OWNER{$ptr};
 367     };
 368
 369 sub ACQUIRE {
 370     my $self = shift;
 371     my $ptr = tied(%$self);
 372     $OWNER{$ptr} = 1;
 373     };
 374
 375 sub FETCH {
 376     my ($self,$field) = @_;
 377     my $member_func = "swig_${field}_get";
 378     my $val = $self->$member_func();
 379     if (exists $BLESSEDMEMBERS{$field}) {
 380         return undef if (!defined($val));
 381         my %retval;
 382         tie %retval,$BLESSEDMEMBERS{$field},$val;
 383         return bless \%retval, $BLESSEDMEMBERS{$field};
 384     }
 385     return $val;
 386 }
 387
 388 sub STORE {
 389     my ($self,$field,$newval) = @_;
 390     my $member_func = "swig_${field}_set";
 391     if (exists $BLESSEDMEMBERS{$field}) {
 392         $self->$member_func(tied(%{$newval}));
 393     } else {
 394         $self->$member_func($newval);
 395     }
 396 }
 397
 398
 399 ############# Class : IDZebra::ScanEntry ##############
 400
 401 package IDZebra::ScanEntry;
 402 @ISA = qw( IDZebra );
 403 %OWNER = ();
 404 %BLESSEDMEMBERS = (
 405 );
 406
 407 %ITERATORS = ();
 408 *swig_occurrences_get = *IDZebrac::ScanEntry_occurrences_get;
 409 *swig_occurrences_set = *IDZebrac::ScanEntry_occurrences_set;
 410 *swig_term_get = *IDZebrac::ScanEntry_term_get;
 411 *swig_term_set = *IDZebrac::ScanEntry_term_set;
 412 sub new {
 413     my $pkg = shift;
 414     my @args = @_;
 415     my $self = IDZebrac::new_ScanEntry(@args);
 416     return undef if (!defined($self));
 417     $OWNER{$self} = 1;
 418     my %retval;
 419     tie %retval, "IDZebra::ScanEntry", $self;
 420     return bless \%retval, $pkg;
 421 }
 422
 423 sub DESTROY {
 424     return unless $_[0]->isa('HASH');
 425     my $self = tied(%{$_[0]});
 426     return unless defined $self;
 427     delete $ITERATORS{$self};
 428     if (exists $OWNER{$self}) {
 429         IDZebrac::delete_ScanEntry($self);
 430         delete $OWNER{$self};
 431     }
 432 }
 433
 434 sub DISOWN {
 435     my $self = shift;
 436     my $ptr = tied(%$self);
 437     delete $OWNER{$ptr};
 438     };
 439
 440 sub ACQUIRE {
 441     my $self = shift;
 442     my $ptr = tied(%$self);
 443     $OWNER{$ptr} = 1;
 444     };
 445
 446 sub FETCH {
 447     my ($self,$field) = @_;
 448     my $member_func = "swig_${field}_get";
 449     my $val = $self->$member_func();
 450     if (exists $BLESSEDMEMBERS{$field}) {
 451         return undef if (!defined($val));
 452         my %retval;
 453         tie %retval,$BLESSEDMEMBERS{$field},$val;
 454         return bless \%retval, $BLESSEDMEMBERS{$field};
 455     }
 456     return $val;
 457 }
 458
 459 sub STORE {
 460     my ($self,$field,$newval) = @_;
 461     my $member_func = "swig_${field}_set";
 462     if (exists $BLESSEDMEMBERS{$field}) {
 463         $self->$member_func(tied(%{$newval}));
 464     } else {
 465         $self->$member_func($newval);
 466     }
 467 }
 468
 469
 470 # ------- VARIABLE STUBS --------
 471
 472 package IDZebra;
 473
 474 *LOG_FATAL = *IDZebrac::LOG_FATAL;
 475 *LOG_DEBUG = *IDZebrac::LOG_DEBUG;
 476 *LOG_WARN = *IDZebrac::LOG_WARN;
 477 *LOG_LOG = *IDZebrac::LOG_LOG;
 478 *LOG_ERRNO = *IDZebrac::LOG_ERRNO;
 479 *LOG_FILE = *IDZebrac::LOG_FILE;
 480 *LOG_APP = *IDZebrac::LOG_APP;
 481 *LOG_MALLOC = *IDZebrac::LOG_MALLOC;
 482 *LOG_ALL = *IDZebrac::LOG_ALL;
 483 *LOG_DEFAULT_LEVEL = *IDZebrac::LOG_DEFAULT_LEVEL;
 484 *ODR_DECODE = *IDZebrac::ODR_DECODE;
 485 *ODR_ENCODE = *IDZebrac::ODR_ENCODE;
 486 *ODR_PRINT = *IDZebrac::ODR_PRINT;
 487 *DATA1K_unknown = *IDZebrac::DATA1K_unknown;
 488 *DATA1K_structured = *IDZebrac::DATA1K_structured;
 489 *DATA1K_string = *IDZebrac::DATA1K_string;
 490 *DATA1K_numeric = *IDZebrac::DATA1K_numeric;
 491 *DATA1K_bool = *IDZebrac::DATA1K_bool;
 492 *DATA1K_oid = *IDZebrac::DATA1K_oid;
 493 *DATA1K_generalizedtime = *IDZebrac::DATA1K_generalizedtime;
 494 *DATA1K_intunit = *IDZebrac::DATA1K_intunit;
 495 *DATA1K_int = *IDZebrac::DATA1K_int;
 496 *DATA1K_octetstring = *IDZebrac::DATA1K_octetstring;
 497 *DATA1K_null = *IDZebrac::DATA1K_null;
 498 *DATA1T_numeric = *IDZebrac::DATA1T_numeric;
 499 *DATA1T_string = *IDZebrac::DATA1T_string;
 500 *DATA1N_root = *IDZebrac::DATA1N_root;
 501 *DATA1N_tag = *IDZebrac::DATA1N_tag;
 502 *DATA1N_data = *IDZebrac::DATA1N_data;
 503 *DATA1N_variant = *IDZebrac::DATA1N_variant;
 504 *DATA1N_comment = *IDZebrac::DATA1N_comment;
 505 *DATA1N_preprocess = *IDZebrac::DATA1N_preprocess;
 506 *DATA1I_inctxt = *IDZebrac::DATA1I_inctxt;
 507 *DATA1I_incbin = *IDZebrac::DATA1I_incbin;
 508 *DATA1I_text = *IDZebrac::DATA1I_text;
 509 *DATA1I_num = *IDZebrac::DATA1I_num;
 510 *DATA1I_oid = *IDZebrac::DATA1I_oid;
 511 *DATA1_LOCALDATA = *IDZebrac::DATA1_LOCALDATA;
 512 *DATA1_FLAG_XML = *IDZebrac::DATA1_FLAG_XML;
 513 1;