SecuritySNACCRuntime/compiler/boot/tbl.c

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20  *    tbl.c
  21  *
  22  *    "TBL" ASN.1 module encode/decode/print/free C src.
  23  *
  24  *    This file was generated by snacc on Mon Jun  2 11:23:51 1997
  25  *
  26  *    UBC snacc written by Mike Sample
  27  *
  28  *    NOTE: This is a machine generated file - editing not recommended
  29  */
  30
  31
  32
  33 #include "asn-incl.h"
  34 #include "tbl.h"
  35
  36
  37 AsnLen
  38 BEncTBLRangeContent PARAMS ((b, v),
  39 BUF_TYPE b _AND_
  40 TBLRange *v)
  41 {
  42     AsnLen totalLen = 0;
  43     AsnLen itemLen;
  44     AsnLen listLen;
  45     void *component;
  46
  47     itemLen = BEncAsnIntContent (b, (&v->to));
  48     BEncDefLenTo127 (b, itemLen);
  49     itemLen++;
  50     itemLen += BEncTag1 (b, CNTX, PRIM, 1);
  51
  52     totalLen += itemLen;
  53
  54     itemLen = BEncAsnIntContent (b, (&v->from));
  55     BEncDefLenTo127 (b, itemLen);
  56     itemLen++;
  57     itemLen += BEncTag1 (b, CNTX, PRIM, 0);
  58
  59     totalLen += itemLen;
  60
  61     return totalLen;
  62
  63 }  /* BEncTBLRangeContent */
  64
  65
  66
  67
  68 AsnLen
  69 BEncTBLNamedNumberContent PARAMS ((b, v),
  70 BUF_TYPE b _AND_
  71 TBLNamedNumber *v)
  72 {
  73     AsnLen totalLen = 0;
  74     AsnLen itemLen;
  75     AsnLen listLen;
  76     void *component;
  77
  78     itemLen = BEncAsnIntContent (b, (&v->value));
  79     BEncDefLenTo127 (b, itemLen);
  80     itemLen++;
  81     itemLen += BEncTag1 (b, CNTX, PRIM, 1);
  82
  83     totalLen += itemLen;
  84
  85     itemLen = BEncPrintableStringContent (b, (&v->name));
  86     itemLen += BEncDefLen (b, itemLen);
  87     itemLen += BEncTag1 (b, CNTX, PRIM, 0);
  88
  89     totalLen += itemLen;
  90
  91     return totalLen;
  92
  93 }  /* BEncTBLNamedNumberContent */
  94
  95
  96
  97
  98 AsnLen
  99 BEncTBLNamedNumberListContent PARAMS ((b, v),
 100 BUF_TYPE b _AND_
 101 TBLNamedNumberList *v)
 102 {
 103     AsnLen totalLen = 0;
 104     AsnLen itemLen;
 105     AsnLen listLen;
 106     void *component;
 107
 108         listLen = 0;
 109     FOR_EACH_LIST_ELMT_RVS (component, v)
 110     {
 111     BEncEocIfNec (b);
 112     itemLen = BEncTBLNamedNumberContent (b, component);
 113     itemLen += BEncConsLen (b, itemLen);
 114     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 115
 116         listLen += itemLen;
 117     }
 118     return listLen;
 119
 120 }  /* BEncTBLNamedNumberListContent */
 121
 122
 123
 124
 125 AsnLen
 126 BEncTBLTypeRefContent PARAMS ((b, v),
 127 BUF_TYPE b _AND_
 128 TBLTypeRef *v)
 129 {
 130     AsnLen totalLen = 0;
 131     AsnLen itemLen;
 132     AsnLen listLen;
 133     void *component;
 134
 135     itemLen = BEncAsnBoolContent (b, (&v->implicit));
 136     BEncDefLenTo127 (b, itemLen);
 137     itemLen++;
 138     itemLen += BEncTag1 (b, UNIV, PRIM, 1);
 139
 140     totalLen += itemLen;
 141
 142     itemLen = BEncTBLTypeDefIdContent (b, (&v->typeDef));
 143     BEncDefLenTo127 (b, itemLen);
 144     itemLen++;
 145     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 146
 147     totalLen += itemLen;
 148
 149     return totalLen;
 150
 151 }  /* BEncTBLTypeRefContent */
 152
 153
 154
 155
 156 AsnLen
 157 BEncTBLTagContent PARAMS ((b, v),
 158 BUF_TYPE b _AND_
 159 TBLTag *v)
 160 {
 161     AsnLen totalLen = 0;
 162     AsnLen itemLen;
 163     AsnLen listLen;
 164     void *component;
 165
 166     itemLen = BEncAsnIntContent (b, (&v->code));
 167     BEncDefLenTo127 (b, itemLen);
 168     itemLen++;
 169     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 170
 171     totalLen += itemLen;
 172
 173     itemLen = BEncTBLTagClassContent (b, (&v->tclass));
 174     BEncDefLenTo127 (b, itemLen);
 175     itemLen++;
 176     itemLen += BEncTag1 (b, UNIV, PRIM, 10);
 177
 178     totalLen += itemLen;
 179
 180     return totalLen;
 181
 182 }  /* BEncTBLTagContent */
 183
 184
 185
 186
 187 AsnLen
 188 BEncTBLTypeSeqOfContent PARAMS ((b, v),
 189 BUF_TYPE b _AND_
 190 TBLTypeSeqOf *v)
 191 {
 192     AsnLen totalLen = 0;
 193     AsnLen itemLen;
 194     AsnLen listLen;
 195     void *component;
 196
 197         listLen = 0;
 198     FOR_EACH_LIST_ELMT_RVS (component, v)
 199     {
 200     BEncEocIfNec (b);
 201     itemLen = BEncTBLTagContent (b, component);
 202     itemLen += BEncConsLen (b, itemLen);
 203     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 204
 205         listLen += itemLen;
 206     }
 207     return listLen;
 208
 209 }  /* BEncTBLTypeSeqOfContent */
 210
 211
 212
 213
 214 AsnLen
 215 BEncTBLTypeContentSeqOfContent PARAMS ((b, v),
 216 BUF_TYPE b _AND_
 217 TBLTypeContentSeqOf *v)
 218 {
 219     AsnLen totalLen = 0;
 220     AsnLen itemLen;
 221     AsnLen listLen;
 222     void *component;
 223
 224         listLen = 0;
 225     FOR_EACH_LIST_ELMT_RVS (component, v)
 226     {
 227     BEncEocIfNec (b);
 228     itemLen = BEncTBLTypeContent (b, component);
 229     itemLen += BEncConsLen (b, itemLen);
 230     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 231
 232         listLen += itemLen;
 233     }
 234     return listLen;
 235
 236 }  /* BEncTBLTypeContentSeqOfContent */
 237
 238
 239
 240
 241 AsnLen
 242 BEncTBLTypeContent PARAMS ((b, v),
 243 BUF_TYPE b _AND_
 244 TBLType *v)
 245 {
 246     AsnLen totalLen = 0;
 247     AsnLen itemLen;
 248     AsnLen listLen;
 249     void *component;
 250
 251     if (NOT_NULL ((v->values)))
 252     {
 253     BEncEocIfNec (b);
 254     itemLen = BEncTBLNamedNumberListContent (b, (v->values));
 255     itemLen += BEncConsLen (b, itemLen);
 256     itemLen += BEncTag1 (b, CNTX, CONS, 6);
 257
 258     totalLen += itemLen;
 259     }
 260
 261     if (NOT_NULL ((v->constraint)))
 262     {
 263     BEncEocIfNec (b);
 264     itemLen = BEncTBLRangeContent (b, (v->constraint));
 265     itemLen += BEncConsLen (b, itemLen);
 266     itemLen += BEncTag1 (b, CNTX, CONS, 5);
 267
 268     totalLen += itemLen;
 269     }
 270
 271     if (ASNOCTS_PRESENT ((&v->fieldName)))
 272     {
 273     itemLen = BEncPrintableStringContent (b, (&v->fieldName));
 274     itemLen += BEncDefLen (b, itemLen);
 275     itemLen += BEncTag1 (b, CNTX, PRIM, 4);
 276
 277     totalLen += itemLen;
 278     }
 279
 280     BEncEocIfNec (b);
 281     itemLen = BEncTBLTypeContentContent (b, (v->content));
 282     itemLen += BEncConsLen (b, itemLen);
 283     itemLen += BEncTag1 (b, CNTX, CONS, 3);
 284
 285     totalLen += itemLen;
 286
 287     if (NOT_NULL ((v->tagList)))
 288     {
 289     BEncEocIfNec (b);
 290     itemLen = BEncTBLTypeSeqOfContent (b, (v->tagList));
 291     itemLen += BEncConsLen (b, itemLen);
 292     itemLen += BEncTag1 (b, CNTX, CONS, 2);
 293
 294     totalLen += itemLen;
 295     }
 296
 297     itemLen = BEncAsnBoolContent (b, (&v->optional));
 298     BEncDefLenTo127 (b, itemLen);
 299     itemLen++;
 300     itemLen += BEncTag1 (b, CNTX, PRIM, 1);
 301
 302     totalLen += itemLen;
 303
 304     itemLen = BEncTBLTypeIdContent (b, (&v->typeId));
 305     BEncDefLenTo127 (b, itemLen);
 306     itemLen++;
 307     itemLen += BEncTag1 (b, CNTX, PRIM, 0);
 308
 309     totalLen += itemLen;
 310
 311     return totalLen;
 312
 313 }  /* BEncTBLTypeContent */
 314
 315
 316
 317
 318 AsnLen
 319 BEncTBLTypeContentContent PARAMS ((b, v),
 320 BUF_TYPE b _AND_
 321 TBLTypeContent *v)
 322 {
 323     AsnLen totalLen = 0;
 324     AsnLen itemLen;
 325     AsnLen listLen;
 326     void *component;
 327
 328     switch (v->choiceId)
 329     {
 330        case TBLTYPECONTENT_PRIMTYPE:
 331     itemLen = BEncAsnNullContent (b, (&v->a.primType));
 332     BEncDefLenTo127 (b, itemLen);
 333     itemLen++;
 334     itemLen += BEncTag1 (b, CNTX, PRIM, 0);
 335
 336     totalLen += itemLen;
 337
 338     break;
 339
 340        case TBLTYPECONTENT_ELMTS:
 341     BEncEocIfNec (b);
 342     itemLen = BEncTBLTypeContentSeqOfContent (b, (v->a.elmts));
 343     itemLen += BEncConsLen (b, itemLen);
 344     itemLen += BEncTag1 (b, CNTX, CONS, 1);
 345
 346     totalLen += itemLen;
 347
 348     break;
 349
 350        case TBLTYPECONTENT_TYPEREF:
 351     BEncEocIfNec (b);
 352     itemLen = BEncTBLTypeRefContent (b, (v->a.typeRef));
 353     itemLen += BEncConsLen (b, itemLen);
 354     itemLen += BEncTag1 (b, CNTX, CONS, 2);
 355
 356     totalLen += itemLen;
 357
 358     break;
 359
 360     }
 361     return totalLen;
 362
 363 }  /* BEncTBLTypeContentContent */
 364
 365
 366
 367
 368 AsnLen
 369 BEncTBLTypeDefContent PARAMS ((b, v),
 370 BUF_TYPE b _AND_
 371 TBLTypeDef *v)
 372 {
 373     AsnLen totalLen = 0;
 374     AsnLen itemLen;
 375     AsnLen listLen;
 376     void *component;
 377
 378     if (NOT_NULL ((v->isPdu)))
 379     {
 380     itemLen = BEncAsnNullContent (b, (v->isPdu));
 381     BEncDefLenTo127 (b, itemLen);
 382     itemLen++;
 383     itemLen += BEncTag1 (b, UNIV, PRIM, 5);
 384
 385     totalLen += itemLen;
 386     }
 387
 388     BEncEocIfNec (b);
 389     itemLen = BEncTBLTypeContent (b, (v->type));
 390     itemLen += BEncConsLen (b, itemLen);
 391     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 392
 393     totalLen += itemLen;
 394
 395     itemLen = BEncPrintableStringContent (b, (&v->typeName));
 396     itemLen += BEncDefLen (b, itemLen);
 397     itemLen += BEncTag1 (b, UNIV, PRIM, 19);
 398
 399     totalLen += itemLen;
 400
 401     itemLen = BEncTBLTypeDefIdContent (b, (&v->typeDefId));
 402     BEncDefLenTo127 (b, itemLen);
 403     itemLen++;
 404     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 405
 406     totalLen += itemLen;
 407
 408     return totalLen;
 409
 410 }  /* BEncTBLTypeDefContent */
 411
 412
 413
 414
 415 AsnLen
 416 BEncTBLModuleSeqOfContent PARAMS ((b, v),
 417 BUF_TYPE b _AND_
 418 TBLModuleSeqOf *v)
 419 {
 420     AsnLen totalLen = 0;
 421     AsnLen itemLen;
 422     AsnLen listLen;
 423     void *component;
 424
 425         listLen = 0;
 426     FOR_EACH_LIST_ELMT_RVS (component, v)
 427     {
 428     BEncEocIfNec (b);
 429     itemLen = BEncTBLTypeDefContent (b, component);
 430     itemLen += BEncConsLen (b, itemLen);
 431     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 432
 433         listLen += itemLen;
 434     }
 435     return listLen;
 436
 437 }  /* BEncTBLModuleSeqOfContent */
 438
 439
 440
 441
 442 AsnLen
 443 BEncTBLModuleContent PARAMS ((b, v),
 444 BUF_TYPE b _AND_
 445 TBLModule *v)
 446 {
 447     AsnLen totalLen = 0;
 448     AsnLen itemLen;
 449     AsnLen listLen;
 450     void *component;
 451
 452     BEncEocIfNec (b);
 453     itemLen = BEncTBLModuleSeqOfContent (b, (v->typeDefs));
 454     itemLen += BEncConsLen (b, itemLen);
 455     itemLen += BEncTag1 (b, CNTX, CONS, 3);
 456
 457     totalLen += itemLen;
 458
 459     itemLen = BEncAsnBoolContent (b, (&v->isUseful));
 460     BEncDefLenTo127 (b, itemLen);
 461     itemLen++;
 462     itemLen += BEncTag1 (b, CNTX, PRIM, 2);
 463
 464     totalLen += itemLen;
 465
 466     if (ASNOID_PRESENT ((&v->id)))
 467     {
 468     itemLen = BEncAsnOidContent (b, (&v->id));
 469     itemLen += BEncDefLen (b, itemLen);
 470     itemLen += BEncTag1 (b, CNTX, PRIM, 1);
 471
 472     totalLen += itemLen;
 473     }
 474
 475     itemLen = BEncPrintableStringContent (b, (&v->name));
 476     itemLen += BEncDefLen (b, itemLen);
 477     itemLen += BEncTag1 (b, CNTX, PRIM, 0);
 478
 479     totalLen += itemLen;
 480
 481     return totalLen;
 482
 483 }  /* BEncTBLModuleContent */
 484
 485
 486
 487
 488 AsnLen
 489 BEncTBLSeqOfContent PARAMS ((b, v),
 490 BUF_TYPE b _AND_
 491 TBLSeqOf *v)
 492 {
 493     AsnLen totalLen = 0;
 494     AsnLen itemLen;
 495     AsnLen listLen;
 496     void *component;
 497
 498         listLen = 0;
 499     FOR_EACH_LIST_ELMT_RVS (component, v)
 500     {
 501     BEncEocIfNec (b);
 502     itemLen = BEncTBLModuleContent (b, component);
 503     itemLen += BEncConsLen (b, itemLen);
 504     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 505
 506         listLen += itemLen;
 507     }
 508     return listLen;
 509
 510 }  /* BEncTBLSeqOfContent */
 511
 512
 513
 514
 515 AsnLen BEncTBL PARAMS ((b, v),
 516 BUF_TYPE b _AND_
 517 TBL *v)
 518 {
 519     AsnLen l;
 520     BEncEocIfNec (b);
 521     l = BEncTBLContent (b, v);
 522     l += BEncConsLen (b, l);
 523     l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
 524     return l;
 525 } /* BEncTBL */
 526
 527 AsnLen
 528 BEncTBLContent PARAMS ((b, v),
 529 BUF_TYPE b _AND_
 530 TBL *v)
 531 {
 532     AsnLen totalLen = 0;
 533     AsnLen itemLen;
 534     AsnLen listLen;
 535     void *component;
 536
 537     BEncEocIfNec (b);
 538     itemLen = BEncTBLSeqOfContent (b, (v->modules));
 539     itemLen += BEncConsLen (b, itemLen);
 540     itemLen += BEncTag1 (b, UNIV, CONS, 16);
 541
 542     totalLen += itemLen;
 543
 544     itemLen = BEncAsnIntContent (b, (&v->totalLenStrings));
 545     BEncDefLenTo127 (b, itemLen);
 546     itemLen++;
 547     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 548
 549     totalLen += itemLen;
 550
 551     itemLen = BEncAsnIntContent (b, (&v->totalNumStrings));
 552     BEncDefLenTo127 (b, itemLen);
 553     itemLen++;
 554     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 555
 556     totalLen += itemLen;
 557
 558     itemLen = BEncAsnIntContent (b, (&v->totalNumTags));
 559     BEncDefLenTo127 (b, itemLen);
 560     itemLen++;
 561     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 562
 563     totalLen += itemLen;
 564
 565     itemLen = BEncAsnIntContent (b, (&v->totalNumTypes));
 566     BEncDefLenTo127 (b, itemLen);
 567     itemLen++;
 568     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 569
 570     totalLen += itemLen;
 571
 572     itemLen = BEncAsnIntContent (b, (&v->totalNumTypeDefs));
 573     BEncDefLenTo127 (b, itemLen);
 574     itemLen++;
 575     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 576
 577     totalLen += itemLen;
 578
 579     itemLen = BEncAsnIntContent (b, (&v->totalNumModules));
 580     BEncDefLenTo127 (b, itemLen);
 581     itemLen++;
 582     itemLen += BEncTag1 (b, UNIV, PRIM, 2);
 583
 584     totalLen += itemLen;
 585
 586     return totalLen;
 587
 588 }  /* BEncTBLContent */
 589
 590
 591
 592