[apple/security.git] / SecuritySNACCRuntime / c-lib / src / tbl-dbg.c

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */


#ifdef TTBL
#include "tbl-dbg.h"

TdeExceptionCode DBGMinCode = TDEINFO;

void DBGOcts PARAMS ((v),
   AsnOcts* v)
{
    int i;
    for (i = 0; i < v->octetLen; i++)
	fprintf (stdout, "%c", isprint(v->octs[i])?v->octs[i]:'.');
}

char*
Class2ClassStr PARAMS ((class),
    int class)
{
    switch (class)
    {
        case UNIV:
            return "UNIV";
            break;

        case APPL:
            return "APPL";
            break;

        case CNTX:
            return "CNTX";
            break;

        case PRIV:
            return "PRIV";
            break;

        default:
            return "UNKNOWN";
            break;
    }
}

char*
Form2FormStr PARAMS ((form),
    BER_FORM form)
{
    switch (form)
    {
        case PRIM:
            return "PRIM";
            break;

        case CONS:
            return "CONS";
            break;

        default:
            return "UNKNOWN";
            break;
    }
}

char*
Code2UnivCodeStr PARAMS ((code),
    BER_UNIV_CODE code)
{
    switch (code)
    {
      case BOOLEAN_TAG_CODE:
        return "BOOLEAN";
        break;

      case INTEGER_TAG_CODE:
        return "INTEGER";
        break;

      case BITSTRING_TAG_CODE:
        return "BIT STRING";
        break;

      case OCTETSTRING_TAG_CODE:
        return "OCTET STRING";
        break;

      case NULLTYPE_TAG_CODE:
        return "NULL";
        break;

      case OID_TAG_CODE:
        return "OBJECT IDENTIFIER";
        break;

      case OD_TAG_CODE:
        return "OD";
        break;

      case EXTERNAL_TAG_CODE:
        return "EXTERNAL";
        break;

      case REAL_TAG_CODE:
        return "REAL";
        break;

      case ENUM_TAG_CODE:
        return "ENUM";
        break;

      case SEQ_TAG_CODE:
        return "SEQUENCE";
        break;

      case SET_TAG_CODE:
        return "SET";
        break;

      case NUMERICSTRING_TAG_CODE:
        return "NUMERICSTRING";
        break;

      case PRINTABLESTRING_TAG_CODE:
        return "PRINTABLESTRING";
        break;

      case TELETEXSTRING_TAG_CODE:
        return "TELETEXSTRING";
        break;

      case VIDEOTEXSTRING_TAG_CODE:
        return "VIDEOTEXSTRING";
        break;

      case IA5STRING_TAG_CODE:
        return "IA5STRING";
        break;

      case UTCTIME_TAG_CODE:
        return "UTCTIME";
        break;

      case GENERALIZEDTIME_TAG_CODE:
        return "GENERALIZEDTIME";
        break;

      case GRAPHICSTRING_TAG_CODE:
        return "GRAPHICSTRING";
        break;

      case VISIBLESTRING_TAG_CODE:
        return "VISIBLESTRING";
        break;

      case GENERALSTRING_TAG_CODE:
        return "GENERALSTRING";
        break;

      default:
        return "UNKNOWN";

    }
} /* Form2FormStr */

#define SOT 0
#define EOL 1
#define EOLINC 2
#define DECSOTEOL 3
#define SOTSPC 4
#define EOLIF 5

void DBGIndent PARAMS ((mode),
    int mode)
{
    static int indent = 0;
    static int withinline = 0;
    int i;
    
    /*DEC*/
    if (mode==DECSOTEOL)
    	indent--;

    /*SPC*/
    if (mode==SOTSPC && withinline)
    	fprintf(stdout," ");

    /*SOT*/
    if ((mode==SOT || mode==DECSOTEOL || mode==SOTSPC) && !withinline)
    	{
    	for (i=0; i<indent; i++)
    	    fprintf(stdout,"   ");
    	withinline = 1;
    	}

    /*IF*/
    if (mode==EOLIF && withinline)
	fprintf(stdout,"\n");

    /*EOL*/
    if (mode==EOL || mode==EOLINC || mode==DECSOTEOL || mode==EOLIF)
    	withinline = 0;
    
    /*INC*/
    if (mode==EOLINC)
    	indent++;
}

int DBGSimple PARAMS ((tag, v, begin),
    AsnTag tag _AND_
    AsnOcts* v _AND_
    int begin)
{
    BER_CLASS tclass = TAG_ID_CLASS(tag);
    BER_FORM form = TAG_ID_FORM(tag);
    unsigned long int code = tag & 0x1FFFFFFF;
    BER_UNIV_CODE bcode;
    char* codename;
    int i;
    if (tclass==UNIV)
	{
	bcode = code>>24;
	codename = Code2UnivCodeStr(bcode);
	}
    else
	{
	bcode = OCTETSTRING_TAG_CODE;
	codename = "NOT_UNIV";
	}
    if (begin)
    	{
    	DBGIndent(SOTSPC);
	fprintf (stdout, "%s", codename);
	if (TAG_IS_CONS(tag))
	    {
	    if (tclass==UNIV) 
		{
    		fprintf(stdout, " {\n");
		DBGIndent(EOLINC);
		}
    	    }
    	else
    	    {
    	    fprintf(stdout,": ");
    	    PrintAsnOcts(stdout,v,0);
	    fprintf(stdout,"\n");
	    DBGIndent(EOL);
    	    }
	}
    else
    	{
	if (TAG_IS_CONS(tag) && tclass==UNIV)
    	    {
    	    DBGIndent(DECSOTEOL);
    	    fprintf(stdout, "}\n");
    	    }
    	}
    return 0;
}

void DBGNamedValue PARAMS ((tnnl, val, mode),
    TBLNamedNumberList* tnnl _AND_
    AsnInt val _AND_
    int mode)
{
    /* mode 0: Don't print if no named value. postfix print with -- */
    /* mode 0|1: prefix with -- */
    /* mode >1: prefix with , */
    TBLNamedNumber* tnn;
    char* name = NULL;
    FOR_EACH_LIST_ELMT (tnn, tnnl)
	if (tnn->value == val)
	    {
	    name = tnn->name.octs;
	    break;
	    }
    if (!mode && !name)
	return;
    if (mode<=1)
	fprintf(stdout," -- ");
    else
	fprintf(stdout,", ");
    if (name)
	fprintf(stdout,"%s",name);
    fprintf(stdout,"(%d)",val);
    if (!mode)
    	fprintf(stdout," --");
}

void
DBGPrintType PARAMS ((type),
    TBLType* type)
{
    static char* TIN [] = { "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
    	"NULL", "OBJECT IDENTIFIER", "REAL", "ENUMERATED", "SEQUENCE", "SET", 
    	"SEQUENCE OF", "SET OF", "CHOICE", NULL };
    	
    if (type->typeId == TBL_TYPEREF)
	DBGOcts(&type->content->a.typeRef->typeDefPtr->typeName);
    else
	fprintf(stdout,TIN[type->typeId]);
    if (type->fieldName.octetLen)
    {
	fprintf(stdout," ");
	DBGOcts(&type->fieldName);
    }
}

typedef int (*Proc) PROTO (());

int
DBGType PARAMS ((type, val, begin),
    TBLType* type _AND_
    AVal* val _AND_
    int begin)
{
    static Proc printproc [] = {PrintAsnBool, PrintAsnInt, PrintAsnBits,
    PrintAsnOcts,
            PrintAsnNull, PrintAsnOid, PrintAsnReal, PrintAsnInt, NULL, NULL,
            NULL, NULL, NULL,
            NULL};
    
    if (begin)
    {
	DBGIndent(SOTSPC);
	DBGPrintType(type);
	if (type->typeId >= TBL_SEQUENCE && type->typeId <= TBL_CHOICE)
    	{
    	    fprintf(stdout," {\n");
    	    DBGIndent(EOLINC);
    	}
    }
    else
    {
	if (printproc[type->typeId])
	{
    	    DBGIndent(SOT);
    	    fprintf(stdout,": ");
    	    (*printproc[type->typeId])(stdout,val,0);
	    switch (type->typeId)
	    {
	    case TBL_BITSTRING:
		{
		AsnInt i;
		AsnBits* b = (AsnBits*)val;
		int mode = 1;
		for (i=0; i<b->bitLen;i++)
		    if (GetAsnBit(b,i))
			DBGNamedValue(type->values,i,mode++);
		if (mode>1)
	    	    fprintf(stdout," --");
		}
		break;
	    case TBL_ENUMERATED:
		DBGNamedValue(type->values,*(AsnInt*)val,0);
		break;
	    default:
		break;
	    }
	    fprintf(stdout,"\n");
	    DBGIndent(EOL);
	}
	if (type->typeId >= TBL_SEQUENCE && type->typeId <= TBL_CHOICE)
    	{
    	    DBGIndent(DECSOTEOL);
    	    fprintf(stdout,"}\n");
    	}
    }
    return 0;
}

int DBGExc PARAMS ((code, p1, p2, p3),
    TdeExceptionCode code _AND_
    void* p1 _AND_
    void* p2 _AND_
    void* p3)
{
    if (code<DBGMinCode)
	return 0;
    switch (code) 
    {
    case TDEEOC:
	DBGIndent(SOTSPC);
	fprintf(stdout,"[EOC]");
	break;
    case TDEPEEKTAG:
	DBGIndent(SOTSPC);
	fprintf(stdout,"[%08X]",*(AsnTag*)p1);
	break;
    case TDEPUSHTAG:
	DBGIndent(SOTSPC);
	fprintf(stdout,"[%08X/%d(%d)]",*(AsnTag*)p1,*(int*)p2,*(int*)p3);
	break;
    case TDEUNEXPECTED:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"WARNING: Unexpected type encountered");
	if (p2) {
	    fprintf(stdout," when expecting ");
	    DBGPrintType((TBLType*)p2);
	}
	fprintf(stdout," while decoding ");
	DBGPrintType((TBLType*)p1);
	fprintf(stdout,", decoding it in simple mode.\n");
	DBGIndent(EOL);
	break;
    case TDENONOPTIONAL:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"WARNING: Non-optional element ");
	DBGPrintType((TBLType*)p2);
	fprintf(stdout," missing in ");
	DBGPrintType((TBLType*)p1);
	fprintf(stdout,".\n");
	DBGIndent(EOL);
	break;
    case TDEMANDATORY:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"WARNING: Mandatory elements missing in ");
	DBGPrintType((TBLType*)p1);
	fprintf(stdout,".\n");
	DBGIndent(EOL);
	break;
    case TDECONSTRAINT:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"WARNING: Value %d not in SIZE(%d..%d) in ",
		*(AsnInt*)p3,((TBLRange*)p2)->from,((TBLRange*)p2)->to);
	DBGPrintType((TBLType*)p1);
	fprintf(stdout,".\n");
	DBGIndent(EOL);
	break;
    case TDENOMATCH:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"WARNING: Tag [%08X] does not match tag [%08X] of type ",
		*(AsnTag*)p3,*(AsnTag*)p2);
	DBGPrintType((TBLType*)p1);
	fprintf(stdout,".\n");
	DBGIndent(EOL);
	break;
    case TDEERROR:
	DBGIndent(EOLIF);
	DBGIndent(SOT);
	fprintf(stdout,"ERROR: %s.\n",(char*)p1);
	DBGIndent(EOL);
	break;
    }
    return 0;
}
#endif
Commit	Line	Data
bac41a7b A	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	#ifdef TTBL
	20	#include "tbl-dbg.h"
	21
	22	TdeExceptionCode DBGMinCode = TDEINFO;
	23
	24	void DBGOcts PARAMS ((v),
	25	AsnOcts* v)
	26	{
	27	int i;
	28	for (i = 0; i < v->octetLen; i++)
	29	fprintf (stdout, "%c", isprint(v->octs[i])?v->octs[i]:'.');
	30	}
	31
	32	char*
	33	Class2ClassStr PARAMS ((class),
	34	int class)
	35	{
	36	switch (class)
	37	{
	38	case UNIV:
	39	return "UNIV";
	40	break;
	41
	42	case APPL:
	43	return "APPL";
	44	break;
	45
	46	case CNTX:
	47	return "CNTX";
	48	break;
	49
	50	case PRIV:
	51	return "PRIV";
	52	break;
	53
	54	default:
	55	return "UNKNOWN";
	56	break;
	57	}
	58	}
	59
	60	char*
	61	Form2FormStr PARAMS ((form),
	62	BER_FORM form)
	63	{
	64	switch (form)
65	{
66	case PRIM:
67	return "PRIM";
68	break;
69
70	case CONS:
71	return "CONS";
72	break;
73
74	default:
75	return "UNKNOWN";
76	break;
77	}
78	}
79
80	char*
81	Code2UnivCodeStr PARAMS ((code),
82	BER_UNIV_CODE code)
83	{
84	switch (code)
85	{
86	case BOOLEAN_TAG_CODE:
87	return "BOOLEAN";
88	break;
89
90	case INTEGER_TAG_CODE:
91	return "INTEGER";
92	break;
93
94	case BITSTRING_TAG_CODE:
95	return "BIT STRING";
96	break;
97
98	case OCTETSTRING_TAG_CODE:
99	return "OCTET STRING";
100	break;
101
102	case NULLTYPE_TAG_CODE:
103	return "NULL";
104	break;
105
106	case OID_TAG_CODE:
107	return "OBJECT IDENTIFIER";
108	break;
109
110	case OD_TAG_CODE:
111	return "OD";
112	break;
113
114	case EXTERNAL_TAG_CODE:
115	return "EXTERNAL";
116	break;
117
118	case REAL_TAG_CODE:
119	return "REAL";
120	break;
121
122	case ENUM_TAG_CODE:
123	return "ENUM";
124	break;
125
126	case SEQ_TAG_CODE:
127	return "SEQUENCE";
128	break;
129
130	case SET_TAG_CODE:
131	return "SET";
132	break;
133
134	case NUMERICSTRING_TAG_CODE:
135	return "NUMERICSTRING";
136	break;
137
138	case PRINTABLESTRING_TAG_CODE:
139	return "PRINTABLESTRING";
140	break;
141
142	case TELETEXSTRING_TAG_CODE:
143	return "TELETEXSTRING";
144	break;
145
146	case VIDEOTEXSTRING_TAG_CODE:
147	return "VIDEOTEXSTRING";
148	break;
149
150	case IA5STRING_TAG_CODE:
151	return "IA5STRING";
152	break;
153
154	case UTCTIME_TAG_CODE:
155	return "UTCTIME";
156	break;
157
158	case GENERALIZEDTIME_TAG_CODE:
159	return "GENERALIZEDTIME";
160	break;
161
162	case GRAPHICSTRING_TAG_CODE:
163	return "GRAPHICSTRING";
164	break;
165
166	case VISIBLESTRING_TAG_CODE:
167	return "VISIBLESTRING";
168	break;
169
170	case GENERALSTRING_TAG_CODE:
171	return "GENERALSTRING";
172	break;
173
174	default:
175	return "UNKNOWN";
176
177	}
178	} /* Form2FormStr */
179
180	#define SOT 0
181	#define EOL 1
182	#define EOLINC 2
183	#define DECSOTEOL 3
184	#define SOTSPC 4
185	#define EOLIF 5
186
187	void DBGIndent PARAMS ((mode),
188	int mode)
189	{
190	static int indent = 0;
191	static int withinline = 0;
192	int i;
193
194	/DEC/
195	if (mode==DECSOTEOL)
196	indent--;
197
198	/SPC/
199	if (mode==SOTSPC && withinline)
200	fprintf(stdout," ");
201
202	/SOT/
203	if ((mode==SOT \|\| mode==DECSOTEOL \|\| mode==SOTSPC) && !withinline)
204	{
205	for (i=0; i<indent; i++)
206	fprintf(stdout," ");
207	withinline = 1;
208	}
209
210	/IF/
211	if (mode==EOLIF && withinline)
212	fprintf(stdout,"\n");
213
214	/EOL/
215	if (mode==EOL \|\| mode==EOLINC \|\| mode==DECSOTEOL \|\| mode==EOLIF)
216	withinline = 0;
217
218	/INC/
219	if (mode==EOLINC)
220	indent++;
221	}
222
223	int DBGSimple PARAMS ((tag, v, begin),
224	AsnTag tag _AND_
225	AsnOcts* v _AND_
226	int begin)
227	{
228	BER_CLASS tclass = TAG_ID_CLASS(tag);
229	BER_FORM form = TAG_ID_FORM(tag);
230	unsigned long int code = tag & 0x1FFFFFFF;
231	BER_UNIV_CODE bcode;
232	char* codename;
233	int i;
234	if (tclass==UNIV)
235	{
236	bcode = code>>24;
237	codename = Code2UnivCodeStr(bcode);
238	}
239	else
240	{
241	bcode = OCTETSTRING_TAG_CODE;
242	codename = "NOT_UNIV";
243	}
244	if (begin)
245	{
246	DBGIndent(SOTSPC);
247	fprintf (stdout, "%s", codename);
248	if (TAG_IS_CONS(tag))
249	{
250	if (tclass==UNIV)
251	{
252	fprintf(stdout, " {\n");
253	DBGIndent(EOLINC);
254	}
255	}
256	else
257	{
258	fprintf(stdout,": ");
259	PrintAsnOcts(stdout,v,0);
260	fprintf(stdout,"\n");
261	DBGIndent(EOL);
262	}
263	}
264	else
265	{
266	if (TAG_IS_CONS(tag) && tclass==UNIV)
267	{
268	DBGIndent(DECSOTEOL);
269	fprintf(stdout, "}\n");
270	}
271	}
272	return 0;
273	}
274
275	void DBGNamedValue PARAMS ((tnnl, val, mode),
276	TBLNamedNumberList* tnnl _AND_
277	AsnInt val _AND_
278	int mode)
279	{
280	/* mode 0: Don't print if no named value. postfix print with -- */
281	/* mode 0\|1: prefix with -- */
282	/* mode >1: prefix with , */
283	TBLNamedNumber* tnn;
284	char* name = NULL;
285	FOR_EACH_LIST_ELMT (tnn, tnnl)
286	if (tnn->value == val)
287	{
288	name = tnn->name.octs;
289	break;
290	}
291	if (!mode && !name)
292	return;
293	if (mode<=1)
294	fprintf(stdout," -- ");
295	else
296	fprintf(stdout,", ");
297	if (name)
298	fprintf(stdout,"%s",name);
299	fprintf(stdout,"(%d)",val);
300	if (!mode)
301	fprintf(stdout," --");
302	}
303
304	void
305	DBGPrintType PARAMS ((type),
306	TBLType* type)
307	{
308	static char* TIN [] = { "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING",
309	"NULL", "OBJECT IDENTIFIER", "REAL", "ENUMERATED", "SEQUENCE", "SET",
310	"SEQUENCE OF", "SET OF", "CHOICE", NULL };
311
312	if (type->typeId == TBL_TYPEREF)
313	DBGOcts(&type->content->a.typeRef->typeDefPtr->typeName);
314	else
315	fprintf(stdout,TIN[type->typeId]);
316	if (type->fieldName.octetLen)
317	{
318	fprintf(stdout," ");
319	DBGOcts(&type->fieldName);
320	}
321	}
322
323	typedef int (*Proc) PROTO (());
324
325	int
326	DBGType PARAMS ((type, val, begin),
327	TBLType* type _AND_
328	AVal* val _AND_
329	int begin)
330	{
331	static Proc printproc [] = {PrintAsnBool, PrintAsnInt, PrintAsnBits,
332	PrintAsnOcts,
333	PrintAsnNull, PrintAsnOid, PrintAsnReal, PrintAsnInt, NULL, NULL,
334	NULL, NULL, NULL,
335	NULL};
336
337	if (begin)
338	{
339	DBGIndent(SOTSPC);
340	DBGPrintType(type);
341	if (type->typeId >= TBL_SEQUENCE && type->typeId <= TBL_CHOICE)
342	{
343	fprintf(stdout," {\n");
344	DBGIndent(EOLINC);
345	}
346	}
347	else
348	{
349	if (printproc[type->typeId])
350	{
351	DBGIndent(SOT);
352	fprintf(stdout,": ");
353	(*printproc[type->typeId])(stdout,val,0);
354	switch (type->typeId)
355	{
356	case TBL_BITSTRING:
357	{
358	AsnInt i;
359	AsnBits* b = (AsnBits*)val;
360	int mode = 1;
361	for (i=0; i<b->bitLen;i++)
362	if (GetAsnBit(b,i))
363	DBGNamedValue(type->values,i,mode++);
364	if (mode>1)
365	fprintf(stdout," --");
366	}
367	break;
368	case TBL_ENUMERATED:
369	DBGNamedValue(type->values,(AsnInt)val,0);
370	break;
371	default:
372	break;
373	}
374	fprintf(stdout,"\n");
375	DBGIndent(EOL);
376	}
377	if (type->typeId >= TBL_SEQUENCE && type->typeId <= TBL_CHOICE)
378	{
379	DBGIndent(DECSOTEOL);
380	fprintf(stdout,"}\n");
381	}
382	}
383	return 0;
384	}
385
386	int DBGExc PARAMS ((code, p1, p2, p3),
387	TdeExceptionCode code _AND_
388	void* p1 _AND_
389	void* p2 _AND_
390	void* p3)
391	{
392	if (code<DBGMinCode)
393	return 0;
394	switch (code)
395	{
396	case TDEEOC:
397	DBGIndent(SOTSPC);
398	fprintf(stdout,"[EOC]");
399	break;
400	case TDEPEEKTAG:
401	DBGIndent(SOTSPC);
402	fprintf(stdout,"[%08X]",(AsnTag)p1);
403	break;
404	case TDEPUSHTAG:
405	DBGIndent(SOTSPC);
406	fprintf(stdout,"[%08X/%d(%d)]",(AsnTag)p1,(int)p2,(int)p3);
407	break;
408	case TDEUNEXPECTED:
409	DBGIndent(EOLIF);
410	DBGIndent(SOT);
411	fprintf(stdout,"WARNING: Unexpected type encountered");
412	if (p2) {
413	fprintf(stdout," when expecting ");
414	DBGPrintType((TBLType*)p2);
415	}
416	fprintf(stdout," while decoding ");
417	DBGPrintType((TBLType*)p1);
418	fprintf(stdout,", decoding it in simple mode.\n");
419	DBGIndent(EOL);
420	break;
421	case TDENONOPTIONAL:
422	DBGIndent(EOLIF);
423	DBGIndent(SOT);
424	fprintf(stdout,"WARNING: Non-optional element ");
425	DBGPrintType((TBLType*)p2);
426	fprintf(stdout," missing in ");
427	DBGPrintType((TBLType*)p1);
428	fprintf(stdout,".\n");
429	DBGIndent(EOL);
430	break;
431	case TDEMANDATORY:
432	DBGIndent(EOLIF);
433	DBGIndent(SOT);
434	fprintf(stdout,"WARNING: Mandatory elements missing in ");
435	DBGPrintType((TBLType*)p1);
436	fprintf(stdout,".\n");
437	DBGIndent(EOL);
438	break;
439	case TDECONSTRAINT:
440	DBGIndent(EOLIF);
441	DBGIndent(SOT);
442	fprintf(stdout,"WARNING: Value %d not in SIZE(%d..%d) in ",
443	(AsnInt)p3,((TBLRange)p2)->from,((TBLRange)p2)->to);
444	DBGPrintType((TBLType*)p1);
445	fprintf(stdout,".\n");
446	DBGIndent(EOL);
447	break;
448	case TDENOMATCH:
449	DBGIndent(EOLIF);
450	DBGIndent(SOT);
451	fprintf(stdout,"WARNING: Tag [%08X] does not match tag [%08X] of type ",
452	(AsnTag)p3,(AsnTag)p2);
453	DBGPrintType((TBLType*)p1);
454	fprintf(stdout,".\n");
455	DBGIndent(EOL);
456	break;
457	case TDEERROR:
458	DBGIndent(EOLIF);
459	DBGIndent(SOT);
460	fprintf(stdout,"ERROR: %s.\n",(char*)p1);
461	DBGIndent(EOL);
462	break;
463	}
464	return 0;
465	}
466	#endif