|
DataMuseum.dkPresents historical artifacts from the history of: DKUUG/EUUG Conference tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about DKUUG/EUUG Conference tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: T m
Length: 67829 (0x108f5)
Types: TextFile
Names: »main.c«
└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
└─⟦041b9c0f8⟧ »EurOpenD22/isode/pepsy.system-6.0.Z«
└─⟦d49939f05⟧
└─⟦6a28ec38e⟧ »pepsy.tar«
└─⟦this⟧ »pepsy/main.c«
/* Copyright 1989 CSIRO Division of Information Technology
* May be given away but not sold for profit - See Copyright file for details
*/
#include <stdio.h>
#include "../h/psap.h"
#define PEPYPATH
#include "T1-types.h"
#include "T2-types.h"
#ifndef PEPYPARM
#define PEPYPARM char *
#endif
#include "test_table.h"
/* compactly generate the new item of data */
#define new(x) ((x *)calloc(1, sizeof (x)))
#define NULLQB (struct qbuf *)0
extern int _pverbose;
char *fill();
extern int print_pe();
extern modtyp _ZBIT_1;
extern char *bitstr2strb();
extern PE mkpelist(), mkpe();
extern OID mkoid();
extern struct type_UNIV_EXTERNAL *mkext();
static int t_test = 1; /* Iteration of the test */
#define NullParm ((char *) 0)
/*ARGSUSED*/
main(argc, argv)
int argc;
char **argv;
{
int i;
int succ, fail;
if (_pverbose)
printf("%d pdus\n", MAXTCASE);
succ = fail = 0;
for (i = MAXTCASE - 1; i >= 0; i--) {
if (t_case[i].tst_entry < 0)
continue;
for (t_test = t_case[i].tst_tests; t_test > 0; t_test--) {
if (_pverbose)
printf("%s:test %d\n", t_case[i].tst_name, t_test);
if (ed_tst(i) < 0)
fail++;
else
succ++;
}
}
if (fail > 0)
printf("Failed\n");
printf("Total %d = %d successes %d failures\n", fail + succ, succ, fail);
}
/*
* Perform a test of encoding/decoding on type number tynum
*/
ed_tst(tynum)
int tynum;
{
PE pe;
char *parm1, *parm2;
char *parm3;
if (tynum < 0 || tynum >= MAXTCASE)
ferrd(1, "ed_tst illegal type %d\n", tynum);
if ((parm1 = fill(tynum)) == NULL) {
ferr(1, "calloc did not work\n");
}
#if 0
if ((parm2 = calloc(1, t_case[tynum].tst_size)) == NULL) {
ferr(1, "calloc did not work\n");
}
#endif
#define encode(tynum, x, parm) \
enc_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, 0, NULLCP, (parm))
if (encode(tynum, &pe, parm1) == NOTOK) {
printf("encode:failed on %s\n", t_case[tynum].tst_name);
exit(1);
}
if (_pverbose >= 2) {
printf("Encoded item:%s \n", t_case[tynum].tst_name);
print_pe(pe, 1);
}
#define decode(tynum, x, parm) \
dec_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, NULL, (char **)NULL, (parm))
if (decode(tynum, pe, &parm2) == NOTOK) {
printf("decode:failed on %s\n", t_case[tynum].tst_name);
exit(2);
}
if (tcmp(tynum, parm1, parm2)) {
printf("%s: not transfered properly\n", t_case[tynum].tst_name);
return (-1);
}
if ((parm3 = fill(tynum)) == NULL) {
ferr(1, "calloc did not work\n");
}
#if PRNT
#define print(tynum, x) \
prnt_f(t_case[tynum].tst_entry, &_ZT1_mod, (x), 1, NULL, (char **)NULL, (&parm3))
if (print(tynum, pe) == NOTOK) {
printf("Print:failed on %s\n", t_case[tynum].tst_name);
exit(2);
}
#endif
#define fre_space(tynum, parm) \
fre_obj(parm, _ZT1_mod.md_dtab[t_case[tynum].tst_entry], &_ZT1_mod)
fre_space(tynum, parm1);
fre_space(tynum, parm2);
pe_free(pe);
if (_pverbose)
printf("%s Success\n", t_case[tynum].tst_name);
return (0);
}
/*SUPPRESS 218*/
/*
* fill in some test data for the given type
*/
char *
fill(tynum)
int tynum;
{
char *parm;
static int count;
if ((parm = calloc(1, t_case[tynum].tst_size)) == NULL) {
ferr(1, "calloc did not work\n");
}
switch (tynum) {
case TY_MPDU:
#define Xparm ((struct type_T1_MPDU *)parm)
if ((Xparm->a__seq = new(struct element_T1_1)) == NULL) {
printf("calloc did not work\n");
return NULL;
}
Xparm->a__seq->fred = 10;
Xparm->a__seq->george = 1;
break;
#undef Xparm
case TY_EMBEDDED:
#define Xparm ((struct type_T1_Embedded *)parm)
Xparm->anMPDU = (struct type_T1_MPDU *)fill(TY_MPDU);
Xparm->ei = 6966;
break;
#undef Xparm
case TY_STRINGS:
#define Xparm ((struct type_T1_Strings *)parm)
Xparm->ostring = str2qb("12\376\0\377a6", 7, 1);
Xparm->bstring = strb2bitstr("\270\017\010\020\040\100", 50, 0, 0);
Xparm->nstring = str2qb("123456", 6, 1);
Xparm->pstring = str2qb("hello, world", 12, 1);
Xparm->tstring = str2qb("teletex", 7, 1);
Xparm->t61string = str2qb("T.61", 4, 1);
Xparm->vstring = str2qb("visible", 7, 1);
Xparm->vis__string = str2qb("visible again", 13, 1);
Xparm->i646string = str2qb("who knows what this is", 22, 1);
Xparm->ia5string = str2qb("This is ASCII\n\r", 15, 1);
Xparm->graphstring = str2qb("This is a graphic string", 24, 1);
Xparm->genstring = str2qb("This is a general string", 24, 1);
break;
#undef Xparm
case TY_EMB_STRINGS:
#define Xparm ((struct type_T1_Emb__Strings *)parm)
Xparm->atest = 2001;
Xparm->ctest = strb2bitstr("\03\010\252\125", 24, 0, 0);
Xparm->btest = str2qb("Good bye", 8, 1);
Xparm->big__test = (struct type_T1_Strings *)fill(TY_STRINGS);
if ((Xparm->emb__test = new(struct element_T1_0)) == NULL) {
printf("calloc did not work\n");
return NULL;
}
Xparm->emb__test->em__int = -101;
Xparm->emb__test->em__oct = str2qb("Embedded octet string", 21, 1);
Xparm->emb__test->em__bit = strb2bitstr("\377\252\125\370\01", 40, 0,0);
break;
#undef Xparm
case TY_IMPLICIT:
#define Xparm ((struct type_T1_Impl__Tags *)parm)
Xparm->i__impl = -1;
Xparm->o__impl = str2qb("I'm an implicit tagged octet string", 36, 1);
Xparm->b__impl = strb2bitstr("\0\0\01\230\01", 40, 0, 0);
Xparm->f__impl = 0xff; /* True */
Xparm->obj__impl = (struct type_T1_Emb__Strings *)fill(TY_EMB_STRINGS);
if ((Xparm->i__emb__test = new(struct element_T1_2)) == NULL) {
printf("calloc did not work\n");
return NULL;
}
Xparm->i__emb__test->i__em__int = -101;
Xparm->i__emb__test->i__em__oct = str2qb("Implicit Embedded", 18, 1);
Xparm->i__emb__test->i__em__bit = strb2bitstr("\200\200\200\200", 32, 0, 0);
#undef Xparm
break;
case TY_EXPLICIT:
#define Xparm ((struct type_T1_Expl__Tags *)parm)
Xparm->i__expl = 35051;
Xparm->o__expl = str2qb("explicit tagged octet string", 28, 1);
Xparm->b__expl = strb2bitstr("\070\070\070\077", 32, 0, 0);
Xparm->f__expl = 0xf0; /* True */
Xparm->obj__expl = (struct type_T1_Emb__Strings *)fill(TY_EMB_STRINGS);
if ((Xparm->i__exp__test = new(struct element_T1_3)) == NULL) {
printf("calloc did not work\n");
return NULL;
}
Xparm->i__exp__test->i__ex__int = -9;
Xparm->i__exp__test->i__ex__oct = str2qb("Explicit Embedded", 18, 1);
Xparm->i__exp__test->i__ex__bit = strb2bitstr("\03\03\03\03\277", 40, 0, 0);
#undef Xparm
break;
case TY_SEQOF:
#define Xparm ((struct type_T1_Seqof__Test *)parm)
count = 2;
Xparm->sqof__test1 = (struct element_T1_4 *) fill(TY_ELEMENT4);
count = 2;
Xparm->stof__test1 = (struct member_T1_2 *) fill(TY_MEMBER2);
Xparm->i__test1 = 33;
count = 2;
Xparm->sqof__test2 = (struct element_T1_6 *) fill(TY_ELEMENT6);
count = 2;
Xparm->stof__test2 = (struct member_T1_4 *) fill(TY_MEMBER4);
Xparm->i__test2 = 99;
break;
#undef Xparm
case TY_ELEMENT4:
#define Xparm ((struct element_T1_4 *)parm)
Xparm->element_T1_5 = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
if (count-- > 0)
Xparm->next = (struct element_T1_4 *) fill(TY_ELEMENT4);
else
Xparm->next = NULL;
break;
#undef Xparm
case TY_MEMBER2:
#define Xparm ((struct member_T1_2 *)parm)
Xparm->member_T1_3 = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
if (count-- > 0)
Xparm->next = (struct member_T1_2 *) fill(TY_MEMBER2);
else
Xparm->next = NULL;
break;
#undef Xparm
case TY_ELEMENT6:
#define Xparm ((struct element_T1_6 *)parm)
Xparm->element_T1_7 = (struct element_T1_8 *)fill(TY_ELEMENT8);
if (count-- > 0)
Xparm->next = (struct element_T1_6 *) fill(TY_ELEMENT6);
else
Xparm->next = NULL;
break;
#undef Xparm
case TY_ELEMENT8:
#define Xparm ((struct element_T1_8 *)parm)
Xparm->sqof__in = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
Xparm->sqof__i = 212121;
Xparm->sqof__o = str2qb("Element8 Embedded", 18, 1);
break;
#undef Xparm
case TY_MEMBER4:
#define Xparm ((struct member_T1_4 *)parm)
Xparm->member_T1_5 = (struct element_T1_9 *)fill(TY_ELEMENT9);
if (count-- > 0)
Xparm->next = (struct member_T1_4 *) fill(TY_MEMBER4);
else
Xparm->next = NULL;
break;
#undef Xparm
case TY_ELEMENT9:
#define Xparm ((struct element_T1_9 *)parm)
Xparm->stof__in = (struct type_T1_Expl__Tags *)fill(TY_EXPLICIT);
Xparm->stof__i = -12345;
Xparm->stof__o = str2qb("XYZabcde Embedded", 18, 1);
break;
#undef Xparm
case TY_CHOICE:
#define Xparm ((struct type_T1_Choice__Test *)parm)
Xparm->c1 = (struct choice_T1_0 *) fill(TY_CHOICE0);
Xparm->c2 = (struct choice_T1_1 *) fill(TY_CHOICE1);
Xparm->c3 = (struct choice_T1_2 *) fill(TY_CHOICE2);
Xparm->c4 = (struct element_T1_11 *) fill(TY_ELEMENT11);
break;
#undef Xparm
case TY_CHOICE0:
#define Xparm ((struct choice_T1_0 *)parm)
switch (Xparm->offset = (t_test + 10)%choice_T1_0_obj__c1 + 1) {
case choice_T1_0_i__c1:
Xparm->un.i__c1 = 10101;
break;
case choice_T1_0_o__c1:
Xparm->un.o__c1 = str2qb("Andrew Worsley!!!", 18, 1);
break;
case choice_T1_0_b__c1:
Xparm->un.b__c1 = strb2bitstr("\02\02\02\07\077", 40, 0, 0);
break;
case choice_T1_0_f__c1:
Xparm->un.f__c1 = 0x11;
break;
case choice_T1_0_obj__c1:
Xparm->un.obj__c1 = (struct type_T1_Emb__Strings *) fill(TY_EMB_STRINGS);
break;
default:
ferrd(1, "TY_CHOICE0:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
case TY_CHOICE1:
#define Xparm ((struct choice_T1_1 *)parm)
switch (Xparm->offset = (t_test + 11)%choice_T1_1_obj__c2 + 1) {
case choice_T1_1_i__c2:
Xparm->un.i__c2 = 1212;
break;
case choice_T1_1_o__c2:
Xparm->un.o__c2 = str2qb("Richard Worsley!!", 18, 1);
break;
case choice_T1_1_b__c2:
Xparm->un.b__c2 = strb2bitstr("\02\01\01\07\077", 40, 0, 0);
break;
case choice_T1_1_f__c2:
Xparm->un.f__c2 = 0x12;
break;
case choice_T1_1_obj__c2:
Xparm->un.obj__c2 = (struct type_T1_Emb__Strings *) fill(TY_EMB_STRINGS);
break;
default:
ferrd(1, "TY_CHOICE1:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
case TY_CHOICE2:
#define Xparm ((struct choice_T1_2 *)parm)
switch (Xparm->offset = (t_test + 12)%choice_T1_2_i__c3 + 1) {
case choice_T1_2_i__c3:
Xparm->un.i__c3 = 689364;
break;
case choice_T1_2_seq__c3:
Xparm->un.seq__c3 = (struct element_T1_10 *) fill(TY_ELEMENT10);
break;
case choice_T1_2_set__c3:
Xparm->un.set__c3 = (struct member_T1_6 *) fill(TY_MEMBER6);
break;
default:
ferrd(1, "TY_CHOICE2:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
case TY_CHOICE3:
#define Xparm ((struct choice_T1_3 *)parm)
switch (Xparm->offset = (t_test + 13)%choice_T1_3_sc__b__i + 1) {
case choice_T1_3_sc__a__i:
Xparm->un.sc__a__i = 16891;
break;
case choice_T1_3_sc__b__i:
Xparm->un.sc__b__i = 13151;
break;
case choice_T1_3_c4__i:
Xparm->un.c4__i = 10938;
break;
case choice_T1_3_c4__obj:
Xparm->un.c4__obj = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
break;
default:
ferrd(1, "TY_CHOICE3:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
case TY_ELEMENT10:
#define Xparm ((struct element_T1_10 *)parm)
Xparm->seq__c3__in = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
Xparm->seq__c3__i = 40938;
Xparm->seq__c3__o = str2qb("James Worsley!!!!", 18, 1);
break;
#undef Xparm
case TY_MEMBER6:
#define Xparm ((struct member_T1_6 *)parm)
Xparm->set__c3__in = (struct type_T1_Expl__Tags *) fill(TY_EXPLICIT);
Xparm->set__c3__i = 0x40938;
Xparm->set__c3__o = str2qb("Patrick Worsley!!", 18, 1);
break;
#undef Xparm
case TY_ELEMENT11:
#define Xparm ((struct element_T1_11 *)parm)
Xparm->c4__choice = (struct choice_T1_3 *) fill(TY_CHOICE3);
break;
#undef Xparm
case TY_OPTIONAL:
#define Xparm ((struct type_T1_Opt__Strings *)parm)
if (t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->optionals |= opt_T1_Opt__Strings_a__opt;
Xparm->a__opt = 192837;
}
if (t_test & opt_T1_Opt__Strings_d__opt) {
Xparm->optionals |= opt_T1_Opt__Strings_d__opt;
Xparm->d__opt = 1;
}
Xparm->b__opt = str2qb("Susan Hannah Sibel", 19, 1);
if (t_test*(t_test + 1) & opt_T1_Opt__Strings_d__opt) {
Xparm->c__opt = strb2bitstr("\012\017\02\07\077", 40, 0, 0);
}
if (t_test & opt_T1_Opt__Strings_e__opt) {
Xparm->optionals |= opt_T1_Opt__Strings_e__opt;
Xparm->e__opt = 0;
}
if ((t_test + 12)*t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->big__opt = (struct type_T1_Strings *) fill(TY_STRINGS);
}
if ((t_test + 2)*t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->emb__opt = (struct element_T1_12 *) fill(TY_ELEMENT12);
}
if ((t_test + 4)*t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->st__opt = (struct member_T1_7 *) fill(TY_MEMBER7);
}
if ((t_test + 8)*t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->obj__opt = (struct type_T1_MPDU *) fill(TY_MPDU);
}
if (t_test & opt_T1_Opt__Strings_etag__opt) {
Xparm->optionals |= opt_T1_Opt__Strings_etag__opt;
Xparm->etag__opt = 2983461;
}
if ((t_test + 6)*t_test & opt_T1_Opt__Strings_a__opt) {
Xparm->ch__opt = (struct choice_T1_4 *) fill(TY_CHOICE4);
}
break;
#undef Xparm
case TY_ELEMENT12:
#define Xparm ((struct element_T1_12 *)parm)
if ((t_test + 10)*t_test & opt_T1_element_T1_12_oem__int) {
Xparm->optionals |= opt_T1_element_T1_12_oem__int;
Xparm->oem__int = 197336;
}
if (t_test*(t_test + 22) & opt_T1_Opt__Strings_a__opt) {
Xparm->oem__oct = str2qb("Ling Worsley", 13, 1);
}
if (t_test*(t_test + 16) & opt_T1_Opt__Strings_d__opt) {
Xparm->oem__bit = strb2bitstr("\0142\0117\02\017\07", 40, 0, 0);
}
break;
#undef Xparm
case TY_MEMBER7:
#define Xparm ((struct member_T1_7 *)parm)
if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int0) {
Xparm->optionals |= opt_T1_member_T1_7_st__int0;
Xparm->st__int0 = 85659;
}
if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int1) {
Xparm->optionals |= opt_T1_member_T1_7_st__int1;
Xparm->st__int1 = 664388;
}
if ((t_test + 12)*t_test & opt_T1_member_T1_7_st__int2) {
Xparm->optionals |= opt_T1_member_T1_7_st__int2;
Xparm->st__int2 = 967768;
}
break;
#undef Xparm
case TY_CHOICE4:
#define Xparm ((struct choice_T1_4 *)parm)
switch (Xparm->offset = (t_test + 14)%choice_T1_4_ch__2 + 1) {
case choice_T1_4_ch__1:
Xparm->un.ch__1 = 74576;
break;
case choice_T1_4_ch__2:
Xparm->un.ch__2 = 28828;
break;
default:
ferrd(1, "TY_CHOICE4:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
case TY_EXTREF:
#define Xparm ((struct type_T1_E__ref *)parm)
Xparm->a__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
Xparm->b__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
Xparm->c__ref = (struct type_T1_Choice__Test *) fill(TY_CHOICE);
if ((t_test + 20)*t_test & 0x2) {
Xparm->d__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
}
if ((t_test + 20)*t_test & 0x1) {
Xparm->e__ref = (struct type_T2_Info *) fill(TY_T2_INFO);
}
break;
#undef Xparm
case TY_T2_INFO:
#define Xparm ((struct type_T2_Info *)parm)
Xparm->a1 = 101910;
Xparm->a2 = -304985;
Xparm->a3 = 13;
Xparm->a4 = (struct type_T2_MPDU *) fill(TY_T2_MPDU);
break;
#undef Xparm
case TY_T2_MPDU:
#define Xparm ((struct type_T2_MPDU *)parm)
Xparm->a__seq = (struct element_T2_0 *) fill(TY_T2_ELEM0);
break;
#undef Xparm
case TY_T2_ELEM0:
#define Xparm ((struct element_T2_0 *)parm)
Xparm->fred = 998877;
break;
#undef Xparm
case TY_OPTIMISED:
#define Xparm ((struct type_T1_Optimised *)parm)
Xparm->o1 = strb2bitstr("\0241\0227\032\011\0237", 40, 0, 0);
Xparm->o2 = str2qb("Peckling Worsley!!!!", 20, 1);
Xparm->o3 = (struct type_T1_MPDU *) fill(TY_MPDU);
Xparm->o4 = (PE ) mkpelist(t_test);
Xparm->element_T1_14 = (struct member_T1_9 *) fill(TY_MEMBER9);
break;
#undef Xparm
case TY_MEMBER9:
#define Xparm ((struct member_T1_9 *)parm)
Xparm->o5 = mkpelist(t_test);
Xparm->o6 = mkpelist(t_test);
Xparm->o7 = mkoid(t_test);
break;
#undef Xparm
case TY_EXTERNAL:
#define Xparm ((struct type_T1_Ext__typ *)parm)
Xparm->ext = mkext(t_test*8 + 1);
Xparm->a__ny = mkpe(t_test*8 + 1);
Xparm->ext__impl = mkext(t_test*6 + 1);
Xparm->any__impl = mkpe(t_test*8 + 3);
Xparm->ext__expl = mkext(t_test*4 + 1);
Xparm->any__expl = mkpe(t_test*8 + 5);
break;
#undef Xparm
case TY_SEXTERNAL:
#define Xparm ((struct type_T1_SExt *)parm)
free(parm); /* don't need it */
Xparm = mkext(21);
break;
#undef Xparm
case TY_ETAGOBJ:
#define Xparm ((struct type_T1_Etags *)parm)
switch (Xparm->offset = (t_test + 4)%type_T1_Etags_bE + 1) {
case type_T1_Etags_aE:
Xparm->un.aE = 10283;
break;
case type_T1_Etags_bE:
Xparm->un.bE = 40986;
break;
default:
ferrd(1, "TY_ETAGOBJ:illegal offset %d\n", Xparm->offset);
}
break;
#undef Xparm
/* This has to be changed when posy is upgraded to handle DEFAULTS properly */
case TY_DEFAULT:
#define Xparm ((struct type_T1_Def__Strings *)parm)
if (t_test*t_test & 2)
Xparm->a__def = int_T1_a__def_a__def__0;
else
Xparm->a__def = int_T1_a__def_a__def__1;
if (t_test*t_test & 4)
Xparm->b__def = str2qb("Susan Sibel !!!!", 17, 1);
else if (t_test*t_test & 8)
Xparm->b__def = str2qb("hello, world", 12, 1);
else
Xparm->b__def = NULLQB;
if (t_test*t_test & 8)
Xparm->c__def = strb2bitstr(int2strb(bit_T1_c__def_c__def__two, 9),
9, 0, 0);
else
Xparm->c__def = NULLPE;
if (t_test*t_test & 0x10)
Xparm->okay = 0;
else
Xparm->okay = 1;
if (t_test*t_test & 0x20)
Xparm->e__def = 0;
else
Xparm->e__def = 1;
Xparm->big__def = (struct type_T1_Strings *) fill(TY_STRINGS);
if (t_test*t_test*t_test & 0x10)
Xparm->emb__def = NULL;
else
Xparm->emb__def = (struct element_T1_13 *) fill(TY_ELEMENT13);
if (t_test*t_test*t_test & 0x20)
Xparm->st__def = NULL;
else
Xparm->st__def = (struct member_T1_8 *) fill(TY_MEMBER8);
break;
#undef Xparm
case TY_ELEMENT13:
#define Xparm ((struct element_T1_13 *)parm)
if (t_test*t_test*t_test & 1)
Xparm->colour = int_T1_colour_green;
else
Xparm->colour = int_T1_colour_red;
if (t_test*t_test & 040)
Xparm->oem__oct = str2qb("Julia Dzuikas !!!!", 19, 1);
else
Xparm->oem__oct = NULLQB;
if (t_test*t_test*t_test & 2)
Xparm->version = strb2bitstr(int2strb((1 << bit_T1_version_basic)
|(1 << bit_T1_version_patch1), 3),
3, 0, 0);
else
Xparm->version = strb2bitstr(int2strb((1 << bit_T1_version_basic),
3), 3, 0, 0);
break;
#undef Xparm
case TY_MEMBER8:
#define Xparm ((struct member_T1_8 *)parm)
if (t_test*t_test*t_test & 4)
Xparm->wine = int_T1_wine_burgundy;
else
Xparm->wine = int_T1_wine_claret;
if (t_test*t_test*t_test & 010)
Xparm->beer = int_T1_beer_vb;
else
Xparm->beer = int_T1_beer_hieneken;
if (t_test*t_test*t_test & 020)
Xparm->spirit = int_T1_spirit_vodka;
else
Xparm->spirit = int_T1_spirit_brandy;
break;
#undef Xparm
case TY_STEST:
#define Xparm ((struct type_T1_Stest *)parm)
if (t_test*(t_test + 2)*t_test & 4)
Xparm->st1 = (struct type_T1_Sint *)fill(TY_SINT);
else
Xparm->st1 = (struct type_T1_Sint *)NULL;
if (t_test*(t_test + 2)*t_test & 010)
Xparm->st2 = str2qb("goodbye, world", 14, 1);
else
Xparm->st2 = str2qb("xxxxxxx, world", 14, 1);
break;
#undef Xparm
case TY_SINT:
#define Xparm ((struct type_T1_Sint *)parm)
if (t_test*(t_test + 4)*t_test & 4)
Xparm->parm = 33;
else
Xparm->parm = 44;
break;
#undef Xparm
default:
ferrd(1, "fill:unknown type\n", tynum);
}
return (parm);
}
#if 0
/*
* encode each given type
*/
encode(tynum, ppe, parm)
int tynum;
PE *ppe;
char *parm;
{
int d;
switch (tynum) {
case TY_MPDU:
d = encode_T1_MPDU(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_EMBEDDED:
d = encode_T1_Embedded(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_STRINGS:
d = encode_T1_Strings(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_EMB_STRINGS:
d = encode_T1_Emb__Strings(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_IMPLICIT:
d = encode_T1_Impl__Tags(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_EXPLICIT:
d = encode_T1_Expl__Tags(ppe, 1, NULLVP, NULLCP, parm);
break;
case TY_EXTERNAL:
d = encode_T1_E__ref(ppe, 1, NULLVP, NULLCP, parm);
break;
default:
ferrd(1, "encode:unknown type\n", tynum);
}
if (d == NOTOK) {
printf("encode:failed on %s\n", t_case[tynum].tst_name);
exit(1);
}
}
/*
* decode each given type
*/
decode(tynum, pe, parm)
int tynum;
PE pe;
char **parm;
{
int d;
switch (tynum) {
case TY_MPDU:
d = decode_T1_MPDU(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_EMBEDDED:
d = decode_T1_Embedded(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_STRINGS:
d = decode_T1_Strings(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_EMB_STRINGS:
d = decode_T1_Emb__Strings(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_IMPLICIT:
d = decode_T1_Impl__Tags(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_EXPLICIT:
d = decode_T1_Expl__Tags(pe, 1, NULLVP, NULLCP, parm);
break;
case TY_EXTERNAL:
d = decode_T1_E__ref(pe, 1, NULLVP, NULLCP, parm);
break;
default:
ferrd(1, "decode:unknown type\n", tynum);
}
if (d == NOTOK) {
printf("decode:failed on %s\n", t_case[tynum].tst_name);
exit(2);
}
}
#endif
/*
* compare two structures for differences of fields indicating an
* error
*/
tcmp(tynum, parm1, parm2)
int tynum;
char *parm1, *parm2;
{
int d;
d = 0;
switch (tynum) {
case TY_MPDU:
#define Xparm1 ((struct type_T1_MPDU *)parm1)
#define Xparm2 ((struct type_T1_MPDU *)parm2)
if (Xparm1->a__seq && !Xparm2->a__seq
|| !Xparm1->a__seq && Xparm2->a__seq) {
printf("a__seq missing/present\n");
d++;
}
if (Xparm1->a__seq && Xparm2->a__seq) {
if (Xparm1->a__seq->fred != Xparm2->a__seq->fred) {
printf("%s->a__seq->fred %d != %d\n",
Xparm1->a__seq->fred, Xparm2->a__seq->fred);
d++;
}
if (Xparm1->a__seq->george != Xparm2->a__seq->george) {
printf("%s a__seq->george %d != %d\n", t_case[tynum].tst_name,
Xparm1->a__seq->george, Xparm2->a__seq->george);
d++;
}
}
break;
#undef Xparm1
#undef Xparm2
case TY_EMBEDDED:
#define Xparm1 ((struct type_T1_Embedded *)parm1)
#define Xparm2 ((struct type_T1_Embedded *)parm2)
if (Xparm1->anMPDU && !Xparm2->anMPDU ||!Xparm1->anMPDU && Xparm2->anMPDU) {
printf("anMPDU missing/present\n");
d++;
}
if (Xparm1->anMPDU && Xparm2->anMPDU) {
d += tcmp(TY_MPDU, (char *)Xparm1->anMPDU, (char *)Xparm2->anMPDU);
}
if (Xparm1->ei != Xparm2->ei) {
printf("%s ei %d != %d\n",
t_case[tynum].tst_name, Xparm1->ei, Xparm2->ei);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_STRINGS:
#define Xparm1 ((struct type_T1_Strings *)parm1)
#define Xparm2 ((struct type_T1_Strings *)parm2)
if (qb_cmp(Xparm1->ostring, Xparm2->ostring)) {
printf("ostring octet string different\n");
d++;
}
if (bit_cmp(Xparm1->bstring, Xparm2->bstring)) {
printf("bstring bitstring different\n");
d++;
}
if (qb_cmp(Xparm1->nstring, Xparm2->nstring)) {
printf("nstring octet string different\n");
d++;
}
if (qb_cmp(Xparm1->pstring, Xparm2->pstring)) {
printf("pstring octet string different\n");
d++;
}
if (qb_cmp(Xparm1->tstring, Xparm2->tstring)) {
printf("tstring octet string different\n");
d++;
}
if (qb_cmp(Xparm1->t61string, Xparm2->t61string)) {
printf("t61string octet string different\n");
d++;
}
if (qb_cmp(Xparm1->vstring, Xparm2->vstring)) {
printf("vstring octet string different\n");
d++;
}
if (qb_cmp(Xparm1->vis__string, Xparm2->vis__string)) {
printf("vis__string octet string different\n");
d++;
}
if (qb_cmp(Xparm1->i646string, Xparm2->i646string)) {
printf("i646string octet string different\n");
d++;
}
if (qb_cmp(Xparm1->ia5string, Xparm2->ia5string)) {
printf("ia5string octet string different\n");
d++;
}
if (qb_cmp(Xparm1->graphstring, Xparm2->graphstring)) {
printf("graphstring octet string different\n");
d++;
}
if (qb_cmp(Xparm1->genstring, Xparm2->genstring)) {
printf("genstring octet string different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_EMB_STRINGS:
#define Xparm1 ((struct type_T1_Emb__Strings *)parm1)
#define Xparm2 ((struct type_T1_Emb__Strings *)parm2)
if (qb_cmp(Xparm1->btest, Xparm2->btest)) {
printf("btest octet string different\n");
d++;
}
if (bit_cmp(Xparm1->ctest, Xparm2->ctest)) {
printf("ctest bitstring different\n");
d++;
}
if (Xparm1->atest != Xparm2->atest) {
printf("atest integers different\n");
d++;
}
if (Xparm1->big__test && Xparm2->big__test) {
d += tcmp(TY_STRINGS, (char *)Xparm1->big__test, (char *)Xparm2->big__test);
} else if (Xparm1->big__test || Xparm2->big__test) {
printf("big__test one Strings missing!\n");
d++;
}
if (qb_cmp(Xparm1->emb__test->em__oct, Xparm2->emb__test->em__oct)) {
printf("emb__test->em__oct octet string different\n");
d++;
}
if (bit_cmp(Xparm1->emb__test->em__bit, Xparm2->emb__test->em__bit)) {
printf("emb__test->em__bit bitstring different\n");
d++;
}
if (Xparm1->emb__test->em__int != Xparm2->emb__test->em__int) {
printf("emb__test->em__int integers different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_IMPLICIT:
#define Xparm1 ((struct type_T1_Impl__Tags *)parm1)
#define Xparm2 ((struct type_T1_Impl__Tags *)parm2)
if (qb_cmp(Xparm1->o__impl, Xparm2->o__impl)) {
printf("o__impl octet string different\n");
d++;
}
if (bit_cmp(Xparm1->b__impl, Xparm2->b__impl)) {
printf("b__impl bitstring different\n");
d++;
}
if (Xparm1->i__impl != Xparm2->i__impl) {
printf("i__impl integers different\n");
d++;
}
if (Xparm1->obj__impl && Xparm2->obj__impl) {
d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->obj__impl, (char *)Xparm2->obj__impl);
} else if (Xparm1->obj__impl || Xparm2->obj__impl) {
printf("obj__impl one Embedded Strings missing!\n");
d++;
}
if (qb_cmp(Xparm1->i__emb__test->i__em__oct, Xparm2->i__emb__test->i__em__oct)) {
printf("i__emb__test->i__em__oct octet string different\n");
d++;
}
if (bit_cmp(Xparm1->i__emb__test->i__em__bit, Xparm2->i__emb__test->i__em__bit)) {
printf("i__emb__test->i__em__bit bitstring different\n");
d++;
}
if (Xparm1->i__emb__test->i__em__int != Xparm2->i__emb__test->i__em__int) {
printf("i__emb__test->i__em__int integers different\n");
d++;
}
#undef Xparm1
#undef Xparm2
break;
case TY_EXPLICIT:
#define Xparm1 ((struct type_T1_Expl__Tags *)parm1)
#define Xparm2 ((struct type_T1_Expl__Tags *)parm2)
if (qb_cmp(Xparm1->o__expl, Xparm2->o__expl)) {
printf("o__expl octet string different\n");
d++;
}
if (bit_cmp(Xparm1->b__expl, Xparm2->b__expl)) {
printf("b__expl bitstring different\n");
d++;
}
if (Xparm1->i__expl != Xparm2->i__expl) {
printf("i__expl integers different\n");
d++;
}
if (Xparm1->obj__expl && Xparm2->obj__expl) {
d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->obj__expl, (char *)Xparm2->obj__expl);
} else if (Xparm1->obj__expl || Xparm2->obj__expl) {
printf("obj__expl one Embedded Strings missing!\n");
d++;
}
if (qb_cmp(Xparm1->i__exp__test->i__ex__oct, Xparm2->i__exp__test->i__ex__oct)) {
printf("i__exp__test->i__ex__oct octet string different\n");
d++;
}
if (bit_cmp(Xparm1->i__exp__test->i__ex__bit, Xparm2->i__exp__test->i__ex__bit)) {
printf("i__exp__test->i__ex__bit bitstring different\n");
d++;
}
if (Xparm1->i__exp__test->i__ex__int != Xparm2->i__exp__test->i__ex__int) {
printf("i__exp__test->i__ex__int integers different\n");
d++;
}
#undef Xparm1
#undef Xparm2
break;
case TY_SEQOF:
#define Xparm1 ((struct type_T1_Seqof__Test *)parm1)
#define Xparm2 ((struct type_T1_Seqof__Test *)parm2)
if (Xparm1->sqof__test1 && Xparm2->sqof__test1) {
d += tcmp(TY_ELEMENT4, (char *)Xparm1->sqof__test1, (char *)Xparm2->sqof__test1);
} else if (Xparm1->sqof__test1 || Xparm2->sqof__test1) {
printf("sqof__test1 one missing");
d++;
}
if (Xparm1->stof__test1 && Xparm2->stof__test1) {
d += tcmp(TY_MEMBER2, (char *)Xparm1->stof__test1, (char *)Xparm2->stof__test1);
} else if (Xparm1->stof__test1 || Xparm2->stof__test1) {
printf("stof__test1 one missing");
d++;
}
if (Xparm1->i__test1 != Xparm2->i__test1) {
printf("i__test1 integers different\n");
d++;
}
if (Xparm1->sqof__test2 && Xparm2->sqof__test2) {
d += tcmp(TY_ELEMENT6, (char *)Xparm1->sqof__test2, (char *)Xparm2->sqof__test2);
} else if (Xparm1->sqof__test2 || Xparm2->sqof__test2) {
printf("sqof__test2 one missing");
d++;
}
if (Xparm1->stof__test2 && Xparm2->stof__test2) {
d += tcmp(TY_MEMBER4, (char *)Xparm1->stof__test2, (char *)Xparm2->stof__test2);
} else if (Xparm1->stof__test2 || Xparm2->stof__test2) {
printf("stof__test2 one missing");
d++;
}
if (Xparm1->i__test2 != Xparm2->i__test2) {
printf("i__test2 integers different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT4:
#define Xparm1 ((struct element_T1_4 *)parm1)
#define Xparm2 ((struct element_T1_4 *)parm2)
if (Xparm1->element_T1_5 && Xparm2->element_T1_5) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->element_T1_5, (char *)Xparm2->element_T1_5);
} else if (Xparm1->element_T1_5 || Xparm2->element_T1_5) {
printf("element_T1_5 one missing");
d++;
}
if (Xparm1->next && Xparm2->next) {
d += tcmp(TY_ELEMENT4, (char *)Xparm1->next, (char *)Xparm2->next);
} else if (Xparm1->next || Xparm2->next) {
printf("%s: next one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER2:
#define Xparm1 ((struct member_T1_2 *)parm1)
#define Xparm2 ((struct member_T1_2 *)parm2)
if (Xparm1->member_T1_3 && Xparm2->member_T1_3) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->member_T1_3, (char *)Xparm2->member_T1_3);
} else if (Xparm1->member_T1_3 || Xparm2->member_T1_3) {
printf("%s: member_T1_3 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->next && Xparm2->next) {
d += tcmp(TY_MEMBER2, (char *)Xparm1->next, (char *)Xparm2->next);
} else if (Xparm1->next || Xparm2->next) {
printf("%s: next one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT6:
#define Xparm1 ((struct element_T1_6 *)parm1)
#define Xparm2 ((struct element_T1_6 *)parm2)
if (Xparm1->element_T1_7 && Xparm2->element_T1_7) {
d += tcmp(TY_ELEMENT8, (char *)Xparm1->element_T1_7, (char *)Xparm2->element_T1_7);
} else if (Xparm1->element_T1_7 || Xparm2->element_T1_7) {
printf("%s: element_T1_7 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->next && Xparm2->next) {
d += tcmp(TY_ELEMENT6, (char *)Xparm1->next, (char *)Xparm2->next);
} else if (Xparm1->next || Xparm2->next) {
printf("%s: next one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT8:
#define Xparm1 ((struct element_T1_8 *)parm1)
#define Xparm2 ((struct element_T1_8 *)parm2)
if (Xparm1->sqof__in && Xparm2->sqof__in) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->sqof__in, (char *)Xparm2->sqof__in);
} else if (Xparm1->sqof__in || Xparm2->sqof__in) {
printf("%s: sqof__in one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->sqof__i != Xparm2->sqof__i) {
printf("sqof__i integers different\n");
d++;
}
if (qb_cmp(Xparm1->sqof__o, Xparm2->sqof__o)) {
printf("sqof__o octet string different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER4:
#define Xparm1 ((struct member_T1_4 *)parm1)
#define Xparm2 ((struct member_T1_4 *)parm2)
if (Xparm1->member_T1_5 && Xparm2->member_T1_5) {
d += tcmp(TY_ELEMENT9, (char *)Xparm1->member_T1_5, (char *)Xparm2->member_T1_5);
} else if (Xparm1->member_T1_5 || Xparm2->member_T1_5) {
printf("%s: member_T1_5 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->next && Xparm2->next) {
d += tcmp(TY_MEMBER4, (char *)Xparm1->next, (char *)Xparm2->next);
} else if (Xparm1->next || Xparm2->next) {
printf("%s: next one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT9:
#define Xparm1 ((struct element_T1_9 *)parm1)
#define Xparm2 ((struct element_T1_9 *)parm2)
if (Xparm1->stof__in && Xparm2->stof__in) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->stof__in, (char *)Xparm2->stof__in);
} else if (Xparm1->stof__in || Xparm2->stof__in) {
printf("%s: stof__in one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->stof__i != Xparm2->stof__i) {
printf("stof__i integers different\n");
d++;
}
if (qb_cmp(Xparm1->stof__o, Xparm2->stof__o)) {
printf("stof__o octet string different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE:
#define Xparm1 ((struct type_T1_Choice__Test *)parm1)
#define Xparm2 ((struct type_T1_Choice__Test *)parm2)
if (Xparm1->c1 && Xparm2->c1) {
d += tcmp(TY_CHOICE0, (char *)Xparm1->c1, (char *)Xparm2->c1);
} else if (Xparm1->c1 || Xparm2->c1) {
printf("%s: c1 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c2 && Xparm2->c2) {
d += tcmp(TY_CHOICE1, (char *)Xparm1->c2, (char *)Xparm2->c2);
} else if (Xparm1->c2 || Xparm2->c2) {
printf("%s: c2 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c3 && Xparm2->c3) {
d += tcmp(TY_CHOICE2, (char *)Xparm1->c3, (char *)Xparm2->c3);
} else if (Xparm1->c3 || Xparm2->c3) {
printf("%s: c3 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c4 && Xparm2->c4) {
d += tcmp(TY_ELEMENT11, (char *)Xparm1->c4, (char *)Xparm2->c4);
} else if (Xparm1->c4 || Xparm2->c4) {
printf("%s: c4 one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE0:
#define Xparm1 ((struct choice_T1_0 *)parm1)
#define Xparm2 ((struct choice_T1_0 *)parm2)
if (Xparm1->offset != Xparm2->offset) {
d++;
printf("%s: offset mismatch %d != %d\n", t_case[tynum].tst_name,
Xparm1->offset, Xparm2->offset);
break;
}
switch (Xparm1->offset) {
case choice_T1_0_i__c1:
if (Xparm1->un.i__c1 != Xparm2->un.i__c1) {
d++;
printf("%s: i__c1 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.i__c1, Xparm2->un.i__c1);
}
break;
case choice_T1_0_o__c1:
if (qb_cmp(Xparm1->un.o__c1, Xparm2->un.o__c1)) {
printf("o__c1 octet string different\n");
d++;
}
break;
case choice_T1_0_b__c1:
if (bit_cmp(Xparm1->un.b__c1, Xparm2->un.b__c1)) {
printf("un.b__c1 bitstring different\n");
d++;
}
break;
case choice_T1_0_f__c1:
if (Xparm1->un.f__c1 && !Xparm2->un.f__c1
|| !Xparm1->un.f__c1 && Xparm2->un.f__c1) {
printf("f__c1 Boolean different\n");
d++;
}
break;
case choice_T1_0_obj__c1:
if (Xparm1->un.obj__c1 && Xparm2->un.obj__c1) {
d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->un.obj__c1,
(char *)Xparm2->un.obj__c1);
} else if (Xparm1->un.obj__c1 || Xparm2->un.obj__c1) {
printf("%s: un.obj__c1 one missing", t_case[tynum].tst_name);
d++;
}
break;
default:
ferrd(1, "TY_CHOICE0:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE1:
#define Xparm1 ((struct choice_T1_1 *)parm1)
#define Xparm2 ((struct choice_T1_1 *)parm2)
if (Xparm1->offset != Xparm2->offset) {
d++;
printf("%s: offset mismatch %d != %d\n", t_case[tynum].tst_name,
Xparm1->offset, Xparm2->offset);
break;
}
switch (Xparm1->offset) {
case choice_T1_1_i__c2:
if (Xparm1->un.i__c2 != Xparm2->un.i__c2) {
d++;
printf("%s: i__c2 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.i__c2, Xparm2->un.i__c2);
}
break;
case choice_T1_1_o__c2:
if (qb_cmp(Xparm1->un.o__c2, Xparm2->un.o__c2)) {
printf("o__c2 octet string different\n");
d++;
}
break;
case choice_T1_1_b__c2:
if (bit_cmp(Xparm1->un.b__c2, Xparm2->un.b__c2)) {
printf("un.b__c2 bitstring different\n");
d++;
}
break;
case choice_T1_1_f__c2:
if (Xparm1->un.f__c2 && !Xparm2->un.f__c2
|| !Xparm1->un.f__c2 && Xparm2->un.f__c2) {
d++;
printf("%s: f__c2 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.f__c2, Xparm2->un.f__c2);
}
break;
case choice_T1_1_obj__c2:
if (Xparm1->un.obj__c2 && Xparm2->un.obj__c2) {
d += tcmp(TY_EMB_STRINGS, (char *)Xparm1->un.obj__c2,
(char *)Xparm2->un.obj__c2);
} else if (Xparm1->un.obj__c2 || Xparm2->un.obj__c2) {
printf("%s: un.obj__c2 one missing", t_case[tynum].tst_name);
d++;
}
break;
default:
ferrd(1, "TY_CHOICE1:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE2:
#define Xparm1 ((struct choice_T1_2 *)parm1)
#define Xparm2 ((struct choice_T1_2 *)parm2)
switch (Xparm1->offset) {
case choice_T1_2_i__c3:
if (Xparm1->un.i__c3 != Xparm2->un.i__c3) {
d++;
printf("%s: i__c3 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.i__c3, Xparm2->un.i__c3);
}
break;
case choice_T1_2_seq__c3:
if (Xparm1->un.seq__c3 && Xparm2->un.seq__c3) {
d += tcmp(TY_ELEMENT10, (char *)Xparm1->un.seq__c3, (char *)Xparm2->un.seq__c3);
} else if (Xparm1->un.seq__c3 || Xparm2->un.seq__c3) {
printf("%s: un.seq__c3 one missing", t_case[tynum].tst_name);
d++;
}
break;
case choice_T1_2_set__c3:
if (Xparm1->un.set__c3 && Xparm2->un.set__c3) {
d += tcmp(TY_MEMBER6, (char *)Xparm1->un.set__c3, (char *)Xparm2->un.set__c3);
} else if (Xparm1->un.set__c3 || Xparm2->un.set__c3) {
printf("%s: un.set__c3 one missing", t_case[tynum].tst_name);
d++;
}
break;
default:
ferrd(1, "TY_CHOICE2:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE3:
#define Xparm1 ((struct choice_T1_3 *)parm1)
#define Xparm2 ((struct choice_T1_3 *)parm2)
switch (Xparm1->offset) {
case choice_T1_3_sc__a__i:
if (Xparm1->un.sc__a__i != Xparm2->un.sc__a__i) {
d++;
printf("%s: sc__a__i mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.sc__a__i, Xparm2->un.sc__a__i);
}
break;
case choice_T1_3_sc__b__i:
if (Xparm1->un.sc__b__i != Xparm2->un.sc__b__i) {
d++;
printf("%s: sc__b__i mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.sc__b__i, Xparm2->un.sc__b__i);
}
break;
case choice_T1_3_c4__i:
if (Xparm1->un.c4__i != Xparm2->un.c4__i) {
d++;
printf("%s: c4__i mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.c4__i, Xparm2->un.c4__i);
}
break;
case choice_T1_3_c4__obj:
if (Xparm1->un.c4__obj && Xparm2->un.c4__obj) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->un.c4__obj, (char *)Xparm2->un.c4__obj);
} else if (Xparm1->un.c4__obj || Xparm2->un.c4__obj) {
printf("%s: un.c4__obj one missing", t_case[tynum].tst_name);
d++;
}
break;
default:
ferrd(1, "TY_CHOICE3:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT10:
#define Xparm1 ((struct element_T1_10 *)parm1)
#define Xparm2 ((struct element_T1_10 *)parm2)
if (Xparm1->seq__c3__in && Xparm2->seq__c3__in) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->seq__c3__in, (char *)Xparm2->seq__c3__in);
} else if (Xparm1->seq__c3__in || Xparm2->seq__c3__in) {
printf("%s: seq__c3__in one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->seq__c3__i != Xparm2->seq__c3__i) {
d++;
printf("%s: seq__c3__i mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->seq__c3__i, Xparm2->seq__c3__i);
}
if (qb_cmp(Xparm1->seq__c3__o, Xparm2->seq__c3__o)) {
printf("seq__c3__o octet string different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER6:
#define Xparm1 ((struct member_T1_6 *)parm1)
#define Xparm2 ((struct member_T1_6 *)parm2)
if (Xparm1->set__c3__in && Xparm2->set__c3__in) {
d += tcmp(TY_EXPLICIT, (char *)Xparm1->set__c3__in, (char *)Xparm2->set__c3__in);
} else if (Xparm1->set__c3__in || Xparm2->set__c3__in) {
printf("%s: set__c3__in one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->set__c3__i != Xparm2->set__c3__i) {
d++;
printf("%s: set__c3__i mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->set__c3__i, Xparm2->set__c3__i);
}
if (qb_cmp(Xparm1->set__c3__o, Xparm2->set__c3__o)) {
printf("set__c3__o octet string different\n");
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT11:
#define Xparm1 ((struct element_T1_11 *)parm1)
#define Xparm2 ((struct element_T1_11 *)parm2)
if (Xparm1->c4__choice && Xparm2->c4__choice) {
d += tcmp(TY_CHOICE3, (char *)Xparm1->c4__choice, (char *)Xparm2->c4__choice);
} else if (Xparm1->c4__choice || Xparm2->c4__choice) {
printf("%s: c4__choice one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_OPTIONAL:
#define Xparm1 ((struct type_T1_Opt__Strings *)parm1)
#define Xparm2 ((struct type_T1_Opt__Strings *)parm2)
if (Xparm1->optionals & opt_T1_Opt__Strings_a__opt) {
if (Xparm1->a__opt != Xparm2->a__opt) {
d++;
printf("%s: a__opt mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->a__opt, Xparm2->a__opt);
}
}
if (Xparm1->optionals & opt_T1_Opt__Strings_d__opt) {
if (Xparm1->d__opt && !Xparm2->d__opt
|| !Xparm1->d__opt && Xparm2->d__opt) {
d++;
printf("%s: d__opt mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->d__opt, Xparm2->d__opt);
}
}
if (Xparm1->b__opt != NULLQB && Xparm2->b__opt != NULLQB) {
if (qb_cmp(Xparm1->b__opt, Xparm2->b__opt)) {
printf("b__opt octet string different\n");
d++;
}
}
if (Xparm1->b__opt != NULLQB && Xparm2->b__opt == NULLQB
|| Xparm1->b__opt == NULLQB && Xparm2->b__opt != NULLQB) {
printf("%s: b__opt one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c__opt != NULLPE && Xparm2->c__opt != NULLPE) {
if (bit_cmp(Xparm1->c__opt, Xparm2->c__opt)) {
printf("%s:c__opt bitstring different\n",
t_case[tynum].tst_name);
d++;
}
}
if (Xparm1->optionals & opt_T1_Opt__Strings_e__opt) {
if (Xparm1->e__opt && !Xparm2->e__opt
|| !Xparm1->e__opt && Xparm2->e__opt) {
d++;
printf("%s: e__opt mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->e__opt, Xparm2->e__opt);
}
}
if (Xparm1->big__opt && Xparm2->big__opt) {
d += tcmp(TY_STRINGS, (char *)Xparm1->big__opt,
(char *)Xparm2->big__opt);
} else if (Xparm1->big__opt && !Xparm2->big__opt
|| !Xparm1->big__opt && Xparm2->big__opt) {
printf("%s: big__opt one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->emb__opt && Xparm2->emb__opt) {
d += tcmp(TY_ELEMENT12, (char *)Xparm1->emb__opt,
(char *)Xparm2->emb__opt);
} else if (Xparm1->emb__opt && !Xparm2->emb__opt
|| !Xparm1->emb__opt && Xparm2->emb__opt) {
printf("%s: emb__opt one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->st__opt && Xparm2->st__opt) {
d += tcmp(TY_MEMBER7, (char *)Xparm1->st__opt,
(char *)Xparm2->st__opt);
} else if (Xparm1->st__opt && !Xparm2->st__opt
|| !Xparm1->st__opt && Xparm2->st__opt) {
printf("%s: st__opt one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->obj__opt && Xparm2->obj__opt) {
d += tcmp(TY_MPDU, (char *)Xparm1->obj__opt,
(char *)Xparm2->obj__opt);
} else if (Xparm1->obj__opt && !Xparm2->obj__opt
|| !Xparm1->obj__opt && Xparm2->obj__opt) {
printf("%s: obj__opt one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->optionals & opt_T1_Opt__Strings_etag__opt) {
if (Xparm1->etag__opt != Xparm2->etag__opt) {
d++;
printf("%s: etag__opt mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->etag__opt, Xparm2->etag__opt);
}
}
if (Xparm1->ch__opt && Xparm2->ch__opt) {
d += tcmp(TY_CHOICE4, (char *)Xparm1->ch__opt,
(char *)Xparm2->ch__opt);
} else if (Xparm1->ch__opt && !Xparm2->ch__opt
|| !Xparm1->ch__opt && Xparm2->ch__opt) {
printf("%s: ch__opt one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT12:
#define Xparm1 ((struct element_T1_12 *)parm1)
#define Xparm2 ((struct element_T1_12 *)parm2)
if (Xparm1->optionals & opt_T1_element_T1_12_oem__int) {
if (Xparm1->oem__int != Xparm2->oem__int) {
d++;
printf("%s: oem__int mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->oem__int, Xparm2->oem__int);
}
}
if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct != NULLQB) {
if (qb_cmp(Xparm1->oem__oct, Xparm2->oem__oct)) {
printf("oem__oct octet string different\n");
d++;
}
}
if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct == NULLQB
|| Xparm1->oem__oct == NULLQB && Xparm2->oem__oct != NULLQB) {
printf("%s: oem__oct one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->oem__bit != NULLPE && Xparm2->oem__bit != NULLPE) {
if (bit_cmp(Xparm1->oem__bit, Xparm2->oem__bit)) {
printf("%s:oem__bit bitstring different\n",
t_case[tynum].tst_name);
d++;
}
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER7:
#define Xparm1 ((struct member_T1_7 *)parm1)
#define Xparm2 ((struct member_T1_7 *)parm2)
if (Xparm1->optionals & opt_T1_member_T1_7_st__int0) {
if (Xparm1->st__int0 != Xparm2->st__int0) {
d++;
printf("%s: st__int0 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->st__int0, Xparm2->st__int0);
}
}
if (Xparm1->optionals & opt_T1_member_T1_7_st__int1) {
if (Xparm1->st__int1 != Xparm2->st__int1) {
d++;
printf("%s: st__int1 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->st__int1, Xparm2->st__int1);
}
}
if (Xparm1->optionals & opt_T1_member_T1_7_st__int2) {
if (Xparm1->st__int2 != Xparm2->st__int2) {
d++;
printf("%s: st__int2 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->st__int2, Xparm2->st__int2);
}
}
break;
#undef Xparm1
#undef Xparm2
case TY_CHOICE4:
#define Xparm1 ((struct choice_T1_4 *)parm1)
#define Xparm2 ((struct choice_T1_4 *)parm2)
if (Xparm1->offset != Xparm2->offset) {
d++;
printf("%s: offset mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->offset, Xparm2->offset);
break;
}
switch (Xparm1->offset) {
case choice_T1_4_ch__1:
if (Xparm1->un.ch__1 != Xparm2->un.ch__1) {
d++;
printf("%s: ch__1 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.ch__1, Xparm2->un.ch__1);
}
break;
case choice_T1_4_ch__2:
if (Xparm1->un.ch__2 != Xparm2->un.ch__2) {
d++;
printf("%s: ch__2 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.ch__2, Xparm2->un.ch__2);
}
break;
default:
ferrd(1, "tcmp:TY_CHOICE4:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
case TY_EXTREF:
#define Xparm1 ((struct type_T1_E__ref *)parm1)
#define Xparm2 ((struct type_T1_E__ref *)parm2)
if (Xparm1->a__ref && Xparm2->a__ref) {
d += tcmp(TY_T2_INFO, (char *)Xparm1->a__ref,
(char *)Xparm2->a__ref);
} else if (Xparm1->a__ref == NULL || Xparm2->a__ref == NULL) {
printf("%s: a__ref one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->b__ref && Xparm2->b__ref) {
d += tcmp(TY_T2_INFO, (char *)Xparm1->b__ref,
(char *)Xparm2->b__ref);
} else if (Xparm1->b__ref == NULL || Xparm2->b__ref == NULL) {
printf("%s: b__ref one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c__ref && Xparm2->c__ref) {
d += tcmp(TY_CHOICE, (char *)Xparm1->c__ref,
(char *)Xparm2->c__ref);
} else if (Xparm1->c__ref == NULL || Xparm2->c__ref == NULL) {
printf("%s: c__ref one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->d__ref && Xparm2->d__ref) {
d += tcmp(TY_T2_INFO, (char *)Xparm1->d__ref,
(char *)Xparm2->d__ref);
} else if (Xparm1->d__ref && !Xparm2->d__ref
|| !Xparm1->d__ref && Xparm2->d__ref) {
printf("%s: d__ref one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->e__ref && Xparm2->e__ref) {
d += tcmp(TY_T2_INFO, (char *)Xparm1->e__ref,
(char *)Xparm2->e__ref);
} else if (Xparm1->e__ref && !Xparm2->e__ref
|| !Xparm1->e__ref && Xparm2->e__ref) {
printf("%s: e__ref one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_T2_INFO:
#define Xparm1 ((struct type_T2_Info *)parm1)
#define Xparm2 ((struct type_T2_Info *)parm2)
if (Xparm1->a1 != Xparm2->a1) {
d++;
printf("%s: a1 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->a1, Xparm2->a1);
}
if (Xparm1->a2 != Xparm2->a2) {
d++;
printf("%s: a2 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->a2, Xparm2->a2);
}
if (Xparm1->a3 != Xparm2->a3) {
d++;
printf("%s: a3 mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->a3, Xparm2->a3);
}
if (Xparm1->a4 && Xparm2->a4) {
d += tcmp(TY_T2_MPDU, (char *)Xparm1->a4, (char *)Xparm2->a4);
} else if (Xparm1->a4 == NULL || Xparm2->a4 == NULL) {
printf("%s: a4 one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_T2_MPDU:
#define Xparm1 ((struct type_T2_MPDU *)parm1)
#define Xparm2 ((struct type_T2_MPDU *)parm2)
if (Xparm1->a__seq && Xparm2->a__seq) {
d += tcmp(TY_T2_ELEM0, (char *)Xparm1->a__seq,
(char *)Xparm2->a__seq);
} else if (Xparm1->a__seq == NULL || Xparm2->a__seq == NULL) {
printf("%s: a__seq one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_T2_ELEM0:
#define Xparm1 ((struct element_T2_0 *)parm1)
#define Xparm2 ((struct element_T2_0 *)parm2)
if (Xparm1->fred != Xparm2->fred) {
d++;
printf("%s: fred mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->fred, Xparm2->fred);
}
break;
#undef Xparm1
#undef Xparm2
case TY_OPTIMISED:
#define Xparm1 ((struct type_T1_Optimised *)parm1)
#define Xparm2 ((struct type_T1_Optimised *)parm2)
if (Xparm1->o1 == NULLPE || Xparm2->o1 == NULLPE) {
printf("%s: o1 one missing\n", t_case[tynum].tst_name);
d++;
} else if (bit_cmp(Xparm1->o1, Xparm2->o1)) {
printf("%s:o1 bitstring different\n",
t_case[tynum].tst_name);
d++;
}
if (Xparm1->o2 != NULLQB && Xparm2->o2 != NULLQB) {
if (qb_cmp(Xparm1->o2, Xparm2->o2)) {
printf("o2 octet string different\n");
d++;
}
} else {
printf("%s: o2 one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->o3 && Xparm2->o3) {
d += tcmp(TY_MPDU, (char *)Xparm1->o3, (char *)Xparm2->o3);
} else if (Xparm1->o3 == NULL || Xparm2->o3 == NULL) {
printf("%s: o3 one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->o4 != NULLPE && Xparm2->o4 == NULLPE
|| Xparm1->o4 == NULLPE && Xparm2->o4 != NULLPE) {
printf("%s: o4 one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->o4 != NULLPE && Xparm2->o4 != NULLPE) {
if (pe_cmp(Xparm1->o4, Xparm2->o4)) {
printf("%s:o4 SET of ANY different\n",
t_case[tynum].tst_name);
d++;
}
}
if (Xparm1->element_T1_14 && Xparm2->element_T1_14) {
d += tcmp(TY_MEMBER9, (char *)Xparm1->element_T1_14,
(char *)Xparm2->element_T1_14);
} else if (Xparm1->element_T1_14 == NULL
|| Xparm2->element_T1_14 == NULL) {
printf("%s: element_T1_14 one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER9:
#define Xparm1 ((struct member_T1_9 *)parm1)
#define Xparm2 ((struct member_T1_9 *)parm2)
if (Xparm1->o5 != NULLPE && Xparm2->o5 != NULLPE) {
if (pe_cmp(Xparm1->o5, Xparm2->o5)) {
printf("%s:o5 SET of ANY different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: o5 one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->o6 != NULLPE && Xparm2->o6 != NULLPE) {
if (pe_cmp(Xparm1->o6, Xparm2->o6)) {
printf("%s:o6 SET of ANY different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: o6 one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->o7 != NULLOID && Xparm2->o7 != NULLOID) {
if (oid_cmp(Xparm1->o7, Xparm2->o7)) {
printf("%s:o7 OID different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: o7 one missing\n", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_EXTERNAL:
#define Xparm1 ((struct type_T1_Ext__typ *)parm1)
#define Xparm2 ((struct type_T1_Ext__typ *)parm2)
if (Xparm1->ext != NULL && Xparm2->ext != NULL) {
if (ext_cmp(Xparm1->ext, Xparm2->ext)) {
printf("%s:ext EXTERNAL different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: ext one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->a__ny != NULLPE && Xparm2->a__ny != NULLPE) {
if (pe_cmp(Xparm1->a__ny, Xparm2->a__ny)) {
printf("%s:a__ny ANY different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: a__ny one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->ext__impl != NULL && Xparm2->ext__impl != NULL) {
if (ext_cmp(Xparm1->ext__impl, Xparm2->ext__impl)) {
printf("%s:ext__impl EXTERNAL different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: ext__impl one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->any__impl != NULLPE && Xparm2->any__impl != NULLPE) {
if (pe_cmp(Xparm1->any__impl, Xparm2->any__impl)) {
printf("%s:any__impl ANY different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: any__impl one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->ext__expl != NULL && Xparm2->ext__expl != NULL) {
if (ext_cmp(Xparm1->ext__expl, Xparm2->ext__expl)) {
printf("%s:ext__expl EXTERNAL different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: ext__expl one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->any__expl != NULLPE && Xparm2->any__expl != NULLPE) {
if (pe_cmp(Xparm1->any__expl, Xparm2->any__expl)) {
printf("%s:any__expl ANY different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: any__expl one missing\n", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_SEXTERNAL:
#define Xparm1 ((struct type_T1_SExt *)parm1)
#define Xparm2 ((struct type_T1_SExt *)parm2)
if (Xparm1 != NULL && Xparm2 != NULL) {
if (ext_cmp(Xparm1, Xparm2)) {
printf("%s:ext EXTERNAL different\n",
t_case[tynum].tst_name);
d++;
}
} else {
printf("%s: ext one missing\n", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ETAGOBJ:
#define Xparm1 ((struct type_T1_Etags *)parm1)
#define Xparm2 ((struct type_T1_Etags *)parm2)
if (Xparm1->offset != Xparm2->offset) {
d++;
printf("%s: offset mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->offset, Xparm2->offset);
break;
}
switch (Xparm1->offset) {
case type_T1_Etags_aE:
if (Xparm1->un.aE != Xparm2->un.aE) {
d++;
printf("%s: un.aE mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.aE, Xparm2->un.aE);
}
break;
case type_T1_Etags_bE:
if (Xparm1->un.bE != Xparm2->un.bE) {
d++;
printf("%s: un.bE mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->un.bE, Xparm2->un.bE);
}
break;
default:
ferrd(1, "TY_ETAGOBJ:illegal offset %d\n", Xparm1->offset);
}
break;
#undef Xparm1
#undef Xparm2
/* This has to be changed when posy is upgraded to handle DEFAULTS properly */
case TY_DEFAULT:
#define Xparm1 ((struct type_T1_Def__Strings *)parm1)
#define Xparm2 ((struct type_T1_Def__Strings *)parm2)
if (Xparm1->a__def != Xparm2->a__def) {
d++;
printf("%s: a__def mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->a__def, Xparm2->a__def);
}
if (Xparm1->b__def != NULLQB && Xparm2->b__def != NULLQB) {
if (qb_cmp(Xparm1->b__def, Xparm2->b__def)) {
printf("b__def octet string different\n");
d++;
}
} else if (Xparm2->b__def == NULLQB) {
printf("%s: b__def one missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->c__def != NULLPE && Xparm2->c__def != NULLPE) {
if (bit_cmp(Xparm1->c__def, Xparm2->c__def)) {
printf("%s:c__def bitstring different\n",
t_case[tynum].tst_name);
d++;
}
} else if (Xparm2->c__def == NULLPE) {
printf("%s: c__def restored version missing\n", t_case[tynum].tst_name);
d++;
}
if (Xparm1->okay != Xparm2->okay) {
d++;
printf("%s: okay mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->okay, Xparm2->okay);
}
/* Can't test NULL ....
if (Xparm1->e__opt != Xparm2->e__opt) {
d++;
printf("%s: e__opt mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->e__opt, Xparm2->e__opt);
}
*/
if (Xparm1->big__def && Xparm2->big__def) {
d += tcmp(TY_STRINGS, (char *)Xparm1->big__def,
(char *)Xparm2->big__def);
} else {
printf("%s: big__def one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->emb__def && Xparm2->emb__def) {
d += tcmp(TY_ELEMENT13, (char *)Xparm1->emb__def,
(char *)Xparm2->emb__def);
} else if (Xparm1->emb__def != NULL || Xparm2->emb__def != NULL) {
printf("%s: emb__def one missing", t_case[tynum].tst_name);
d++;
}
if (Xparm1->st__def && Xparm2->st__def) {
d += tcmp(TY_MEMBER8, (char *)Xparm1->st__def,
(char *)Xparm2->st__def);
} else if (Xparm1->st__def != NULL || Xparm2->st__def != NULL) {
printf("%s: st__def one missing", t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_ELEMENT13:
#define Xparm1 ((struct element_T1_13 *)parm1)
#define Xparm2 ((struct element_T1_13 *)parm2)
if (Xparm1->colour != Xparm2->colour) {
d++;
printf("%s: colour mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->colour, Xparm2->colour);
}
if (Xparm1->oem__oct != NULLQB && Xparm2->oem__oct != NULLQB) {
if (qb_cmp(Xparm1->oem__oct, Xparm2->oem__oct)) {
printf("oem__oct octet string different\n");
d++;
}
} else if (Xparm1->oem__oct != NULLQB || Xparm2->oem__oct != NULLQB) {
printf("oem__oct: one missing 0x%x, 0x%x\n", Xparm1->oem__oct,
Xparm1->oem__oct);
d++;
}
if (Xparm1->version != NULLPE && Xparm2->version != NULLPE) {
if (bit_cmp(Xparm1->version, Xparm2->version)) {
printf("%s:version bitstring different\n",
t_case[tynum].tst_name);
d++;
}
} else if (Xparm2->version == NULLPE) {
printf("%s: version decoded version missing\n",
t_case[tynum].tst_name);
d++;
}
break;
#undef Xparm1
#undef Xparm2
case TY_MEMBER8:
#define Xparm1 ((struct member_T1_8 *)parm1)
#define Xparm2 ((struct member_T1_8 *)parm2)
if (Xparm1->wine != Xparm2->wine) {
d++;
printf("%s: wine mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->wine, Xparm2->wine);
}
if (Xparm1->beer != Xparm2->beer) {
d++;
printf("%s: beer mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->beer, Xparm2->beer);
}
if (Xparm1->spirit != Xparm2->spirit) {
d++;
printf("%s: spirit mismatch %d != %d", t_case[tynum].tst_name,
Xparm1->spirit, Xparm2->spirit);
}
break;
#undef Xparm1
#undef Xparm2
case TY_STEST:
#define Xparm1 ((struct type_T1_Stest *)parm1)
#define Xparm2 ((struct type_T1_Stest *)parm2)
if (Xparm1->st1 != NULL && Xparm2->st1 != NULL) {
d += tcmp(TY_SINT, (char *)Xparm1->st1, (char *)Xparm2->st1);
} else if (Xparm2->st1 == NULL) {
d++;
printf("%s: missing", t_case[tynum].tst_name);
}
if (Xparm1->st2 != NULL && Xparm2->st2 != NULL) {
if (qb_cmp(Xparm1->st2, Xparm2->st2)) {
printf("%s:st2 octet string different\n",
t_case[tynum].tst_name);
d++;
}
} else if (Xparm2->st2 == NULL) {
d++;
printf("%s: missing", t_case[tynum].tst_name);
}
break;
#undef Xparm1
#undef Xparm2
case TY_SINT:
#define Xparm1 ((struct type_T1_Sint *)parm1)
#define Xparm2 ((struct type_T1_Sint *)parm2)
if (Xparm1->parm != Xparm2->parm) {
printf("%s:parm %d != %d\n", t_case[tynum].tst_name, Xparm1->parm,
Xparm2->parm);
d++;
}
break;
#undef Xparm1
#undef Xparm2
default:
ferrd(1, "tcmp:unknown type\n", tynum);
}
if (d) {
printf("tcmp:failed on %s\n", t_case[tynum].tst_name);
}
return (d);
}
/*
* Compare two possible null qbuf lists and return non zero if they are
* different
* Pretty complex to allow for all sorts of weird cases
* Doesn't work for a qbuf which doesn't have a head ! Don't really know what
* is the proper form of a queue buf. MArshall's doco doesn't say
*/
qb_cmp(qb1, qb2)
struct qbuf *qb1, *qb2;
{
struct qbuf *qp1, *qp2;
char *po1, *po2;
int len1, len2;
if (qb1 == NULL && qb2 == NULL)
return (0);
if (qb1 == NULL || qb2 == NULL)
return (1);
qp1 = qb1->qb_forw;
qp2 = qb2->qb_forw;
po1 = qp1->qb_data;
po2 = qp2->qb_data;
len1 = qp1->qb_len;
len2 = qp2->qb_len;
while (qp1 != qb1 && qp2 != qb2) {
if (len1 < len2) {
if (bcmp(po1, po2, len1))
return (1);
len2 -= len1;
po2 += len1;
qp1 = qp1->qb_forw;
po1 = qp1->qb_data;
len1 = qp1->qb_len;
} else {
if (bcmp(po1, po2, len1))
return (1);
len1 -= len2;
po1 += len2;
qp2 = qp2->qb_forw;
po2 = qp2->qb_data;
len2 = qp2->qb_len;
}
}
if (len1 == 0)
qp1 = qp1->qb_forw;
if (len2 == 0)
qp2 = qp2->qb_forw;
while (qp1 != qb1 && qp1->qb_len == 0)
qp1 = qp1->qb_forw;
while (qp2 != qb2 && qp2->qb_len == 0)
qp2 = qp2->qb_forw;
if (qp1 == qb1 && qp2 == qb2)
return (0); /* perfect match */
return (1);
}
/*
* compare two bitstrings. Including the little bits left at the end but
* not the bits not in the strings
*/
bit_cmp(b1, b2)
PE b1, b2;
{
int len1, len2;
register char *cp1, *cp2;
if (b1 == NULLPE && b2 == NULLPE)
return (0);
if (b1 == NULLPE || b2 == NULLPE)
goto fail;
if ((cp1 = bitstr2strb(b1, &len1)) == NULL)
goto fail;
if ((cp2 = bitstr2strb(b2, &len2)) == NULL) {
free(cp1);
goto fail;
}
if (len1 != len2 || bcmp(cp1, cp2, len1/8)) {
free(cp1);
free(cp2);
goto fail;
}
if (len1 % 8) {
int i;
int mask;
/* Check those last few bits */
i = len1/8;
mask = (0xff00 >> len1 % 8) & 0xff;
if (cp1[i] & mask != cp2[i] & mask) {
free(cp1);
free(cp2);
goto fail;
}
}
free(cp1);
free(cp2);
return (0);
fail:
return (1);
}
#define MKMASK 0x7
#define MKSHIFT 6
/*
* Generate a randomish list of PElement s for use as ANY or SET OF ANY ....
*/
PE
mkpelist(i)
{
PE pe, fpe = NULL;
fpe = pe_alloc(PE_CLASS_PRIV, PE_FORM_CONS, i);
while (i > 0) {
pe = mkpe(i);
pe->pe_next = fpe->pe_cons;
fpe->pe_cons = pe;
i--;
}
return (fpe);
}
/*
* generate a randomish PElement
*/
PE
mkpe(i)
{
int id, class;
PE pe;
id = i * i + 1;
class = PE_CLASS_PRIV;
switch ((i*i >> MKSHIFT) & MKMASK) {
case 5:
case 0:
pe = flag2prim(i & 0x1, class, id);
break;
case 6:
case 1:
pe = num2prim(i, class, id);
break;
case 7:
case 2:
pe = str2prim("mkpelist:testdata", 17, class, id);
break;
case 3:
pe = strb2bitstr("\021\0245\375\0124", 4, class, id);
break;
case 4:
pe = mkpelist(i - 1);
break;
default:
ferrd(1, "mkpelist:internal error %d case not handled\n",
(i*i >> MKSHIFT) & MKMASK);
}
return (pe);
}
#define OID_SIZE 6
/*
* make an OID for testing
*/
OID
mkoid(i)
int i;
{
OID oid;
int oid_cnt = i % OID_SIZE;
if ((oid = new(struct OIDentifier)) == NULL) {
printf("mkoid:calloc did not work\n");
return NULL;
}
if (oid_cnt < 2)
oid_cnt = 2; /* At least two integers long */
oid->oid_nelem = oid_cnt;
if ((oid->oid_elements = (unsigned int *)calloc(oid_cnt, sizeof (int)))
== NULL) {
printf("mkoid:calloc 2 did not work\n");
return NULL;
}
while (oid_cnt > 2)
oid->oid_elements[--oid_cnt] = oid_cnt*i + 33;
oid->oid_elements[0] = 1;
oid->oid_elements[1] = 17;
return (oid);
}
/*
* Produce an External structure initialised to test values
* for testing EXTERNAL encoding routines
*/
struct type_UNIV_EXTERNAL *
mkext(i)
int i;
{
int k;
struct type_UNIV_EXTERNAL *p;
k = i + 2;
k *= k; /* generate a more random looking number */
if ((p = new(struct type_UNIV_EXTERNAL)) == NULL
|| (p->encoding = new(struct choice_UNIV_0)) == NULL)
ferr(1, "mkext:malloc:out of memory\n");
if (i & 0x1)
p->direct__reference = mkoid(i*3);
p->indirect__reference = k & 0x7c;
p->data__value__descriptor = str2qb("A very wild type of data", 25, 1);
switch (p->encoding->offset = (k % choice_UNIV_0_arbitrary) + 1) {
case choice_UNIV_0_arbitrary:
p->encoding->un.single__ASN1__type = mkpe(k % 7);
break;
case choice_UNIV_0_single__ASN1__type:
p->encoding->un.single__ASN1__type = mkpe(k % 5);
break;
case choice_UNIV_0_octet__aligned:
p->encoding->un.octet__aligned = str2qb("Some test data", 15, 1);
break;
default:
ferrd(1, "mkext:internal error: bad offset %d\n", p->encoding->offset);
}
return (p);
}
/*
* compare two external types to see if they are identical - return zero if
* they are and non zero if they are different
*/
ext_cmp(e1, e2)
register struct type_UNIV_EXTERNAL *e1, *e2;
{
if (e1->direct__reference != NULLOID && e2->direct__reference != NULLOID) {
if (oid_cmp(e1->direct__reference, e2->direct__reference))
return (1);
} else {
if (e1->direct__reference != NULLOID || e2->direct__reference != NULLOID)
return (1);
if (e1->indirect__reference != e2->indirect__reference)
return (1);
}
if (e1->data__value__descriptor != NULLQB
&& e2->data__value__descriptor != NULLQB) {
if (qb_cmp(e1->data__value__descriptor, e2->data__value__descriptor))
return (1);
} else if (e1->data__value__descriptor != NULLQB
|| e2->data__value__descriptor != NULLQB)
return (1);
if (e1->encoding == NULL || e2->encoding == NULL)
return (1);
if (e1->encoding->offset != e2->encoding->offset)
return (1);
switch (e1->encoding->offset) {
case choice_UNIV_0_single__ASN1__type:
if (e1->encoding->un.single__ASN1__type == NULLPE
|| e2->encoding->un.single__ASN1__type == NULLPE)
return (1);
if (pe_cmp(e1->encoding->un.single__ASN1__type,
e2->encoding->un.single__ASN1__type))
return (1);
break;
case choice_UNIV_0_octet__aligned:
if (e1->encoding->un.octet__aligned == NULLQB
|| e2->encoding->un.octet__aligned == NULLQB)
return (1);
if (qb_cmp(e1->encoding->un.octet__aligned,
e2->encoding->un.octet__aligned))
return (1);
break;
case choice_UNIV_0_arbitrary:
if (e1->encoding->un.arbitrary == NULLPE
|| e2->encoding->un.arbitrary == NULLPE)
return (1);
if (pe_cmp(e1->encoding->un.arbitrary,
e2->encoding->un.arbitrary))
return (1);
break;
default:
ferrd(1, "ext_cmp:illegal offset value %d\n", e1->encoding->offset);
}
return (0);
}