/*  PPPP  U   U TTTTT EEEEE N   N TTTTT        CCCC 
**  P   P U   U   T   E     NN  N   T         C     
**  PPPP  U   U   T   EEEE  N N N   T         C     
**  P     U   U   T   E     N  NN   T    ..   C     
**  P      UUU    T   EEEEE N   N   T    ..    CCCC 
**
**  Copyright (c) 1989,1993 by WIZ WORX (DAHarrod) Concord, MA
*/

#include <stdio.h>
#include <string.h>
#include "igespeek.h"

PNTR    put000(), put100(), put102(), put104(), put106(), put108(),
	put110(), put112(), put114(), put116(), put118(), put120(),
	put122(), put124(), put125(), put126(), put128(), put130(),
	put132(), put134(), put136(), put138(), put140(), put142(),
	put144(), put146(), put148(), put150(), put152(), put154(),
	put156(), put158(), put160(), put162(), put164(), put168(),
	put180(), put184(), put202(), put206(), put208(), put210(),
	put212(), put214(), put216(), put218(), put220(), put222(),
	put228(), put230(), put302(), put304(), put306(), put308(),
	put310(), put312(), put314(), put320(), put322(), put402(),
	put404(), put406(), put408(), put410(), put412(), put414(),
	put416(), put418(), put420(), put422(), put430(), put182(),
	put123(), put141(), put143(), put316(), put190(), put192(),
	put194(), put196(), put198(), put204(), put213(), put186(),
	put502(), put504(), put508(), put510(), put514();

NUMFNC put_func[] = {
	{ 0, put000 },          { 100, put100 },        { 102, put102 },
	{ 104, put104 },        { 106, put106 },        { 108, put108 },
	{ 110, put110 },        { 112, put112 },        { 114, put114 },
	{ 116, put116 },        { 118, put118 },        { 120, put120 },
	{ 122, put122 },        { 124, put124 },        { 125, put125 },
	{ 126, put126 },        { 128, put128 },        { 130, put130 },
	{ 132, put132 },        { 134, put134 },        { 136, put136 },
	{ 138, put138 },        { 140, put140 },        { 142, put142 },
	{ 144, put144 },        { 146, put146 },        { 148, put148 },
	{ 150, put150 },        { 152, put152 },        { 154, put154 },
	{ 156, put156 },        { 158, put158 },        { 160, put160 },
	{ 162, put162 },        { 164, put164 },        { 168, put168 },
	{ 180, put180 },        { 184, put184 },        { 202, put202 },
	{ 206, put206 },        { 208, put208 },        { 210, put210 },
	{ 212, put212 },        { 214, put214 },        { 216, put216 },
	{ 218, put218 },        { 220, put220 },        { 222, put222 },
	{ 228, put228 },        { 230, put230 },        { 302, put302 },
	{ 304, put304 },        { 306, put306 },        { 308, put308 },
	{ 310, put310 },        { 312, put312 },        { 314, put314 },
	{ 320, put320 },        { 322, put322 },        { 402, put402 },
	{ 404, put404 },        { 406, put406 },        { 408, put408 },
	{ 410, put410 },        { 412, put412 },        { 414, put414 },
	{ 416, put416 },        { 418, put418 },        { 420, put420 },
	{ 422, put422 },        { 430, put430 },        { 182, put182 },
	{ 123, put123 },        { 141, put141 },        { 143, put143 },
	{ 316, put316 },        { 190, put190 },        { 192, put192 },
	{ 194, put194 },        { 196, put196 },        { 198, put198 },
	{ 204, put204 },        { 213, put213 },        { 186, put186 },
	{ 502, put502 },        { 504, put504 },        { 508, put508 },
	{ 510, put510 },        { 514, put514 }
	};

#define TBLSIZ  (sizeof(put_func)/sizeof(NUMFNC))

/**************************************************************/

PNTR putent(ENTITY *ent)
{
int k;

    ent_init(ent);                              /* set up DE & PD buffers */

    if (ent->e_strct.ival > 0)
	ent->e_strct.ival = 0;                  /* FORCE IT! */

    for (k=0; k<TBLSIZ; k++) {
	if (put_func[k].entnum == ent->e_type) {
	    (*put_func[k].entfnc)(ent);         /* output PD record */
	    break;
	}
    }
    if (k == TBLSIZ)                            /* no match found */
	put000(ent);

    if ((ent->e_acnt.ival + ent->e_pcnt.ival) > 0) {
	putintg(ent->e_acnt);                   /* output associativities */
	if (ent->e_acnt.ival > 0)
	    for (k=0; k<ent->e_acnt.ival; k++)
		putintg(ent->e_assoc[k]);
	putintg(ent->e_pcnt);                   /* output properties */
	if (ent->e_pcnt.ival > 0)
	    for (k=0; k<ent->e_pcnt.ival; k++)
		putintg(ent->e_prop[k]);
    }
    return(ent_flush(ent));                     /* write buffers to temp files */
}