xref: /illumos-gate/usr/src/lib/iconv_modules/ko/common/nbyte_to_euc.c (revision 16d86563)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1995 by Sun Microsystems, Inc.
 * All Rights Reserved.
 */


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "kdefs.h"
#include <errno.h>
#include "ktable.h"
#include "nbyte_euc.h"

extern KCHAR getc_12();
extern KCHAR packtocomp();

struct _cv_state {
	char temp_ibuf[5];
	int  ibuf_left;
	int  istart, iend;
	char temp_obuf[1];
	int  flush_obuf;
};

int is_SI(char **inbuf, size_t *inbytesleft, struct _cv_state *st);

static int _johap_to_wansung(unsigned short* wcode, unsigned short code);

/****  _ I C V _ O P E N  ****/

void* _icv_open()
{
	_conv_desc* cd = (_conv_desc*)malloc(sizeof(_conv_desc));

	if (cd == (_conv_desc*)NULL)
	{
		errno = ENOMEM;
		return((void*)-1);
	}

	cd->cur_stat = 1;
	cd->hbuf[1] = cd->hbuf[2] = cd->hbuf[3] = cd->hbuf[4] = '\0';
	cd->cur_act = 0;

	return((void*)cd);
}  /* end of int _icv_open(). */


/****  _ I C V _ C L O S E  ****/

void _icv_close(_conv_desc* cd)
{
	if (!cd)
		errno = EBADF;
	else
		free((void*)cd);
}  /* end of void _icv_close(_conv_desc*). */


/****  _ I C V _ I C O N V  ****/

size_t _icv_iconv(_conv_desc* cd, char** inbuf, size_t* inbufleft,
			char** outbuf, size_t* outbufleft)
{
	size_t		ret_val = 0;
	unsigned char*	ib;
	unsigned char*	ob;
	unsigned char*	ibtail;
	unsigned char*	obtail;

	if (!cd)
	{
		errno = EBADF;
		return((size_t)-1);
	}

	if (!inbuf || !(*inbuf))
	{
		cd->cur_stat = 1;
		cd->hbuf[1] = cd->hbuf[2] = cd->hbuf[3] = cd->hbuf[4] = '\0';
		cd->cur_act = 0;
		return((size_t)0);
	}

	ib = (unsigned char*)*inbuf;
	ob = (unsigned char*)*outbuf;
	ibtail = ib + *inbufleft;
	obtail = ob + *outbufleft;

	while (ib < ibtail)
	{
		int		cur_input, action, state;
		char		result;
		int		input_conv(char);
		unsigned short	make_johap_code(int, char*);
		int		_johap_to_wansung(unsigned short*,
							unsigned short);

		cur_input = input_conv(*ib);
		action = next_act[cd->cur_stat][cur_input];
		state = next_stat[cd->cur_stat][cur_input];
		if (action == 4)
		{
			if (ob >= obtail)
			{
				errno = E2BIG;
				ret_val = (size_t)-1;
				break;
			}
			*ob++ = *ib;
		}
		else if (action >= 5 && action <= 8)
			cd->hbuf[action - 4] = *ib;
		else if (action == 9)
		{
			ADD_CONVERTED_CODE(0, 0);
			cd->hbuf[1] = *ib;
		}
		else if (action == 10)
		{
			ADD_CONVERTED_CODE(0, 0);
			cd->hbuf[2] = *ib;
			ADD_CONVERTED_CODE(0, 0);
		}
		else if (action == 11 || action == 12)
		{
			ADD_CONVERTED_CODE(0, 0);
		}
		else if (action == 13)
		{
			ADD_CONVERTED_CODE(0, 1);
			*ob++ = *ib;
		}
		else if (action == 14)
		{
			register char c1 = cd->hbuf[2], c2 = *ib;

			if (c1 == 'l' && c2 == 'b')  /* _|_ && |- */
				cd->hbuf[2] = 'm';
			else if (c1 == 'l' && c2 == 'c')  /* _|_ && H */
				cd->hbuf[2] = 'n';
			else if (c1 == 'l' && c2 == '|')  /* _|_ && | */
				cd->hbuf[2] = 'o';
			else if (c1 == 's' && c2 == 'f')  /* T && -| */
				cd->hbuf[2] = 't';
			else if (c1 == 's' && c2 == 'g')  /* T && -|| */
				cd->hbuf[2] = 'u';
			else if (c1 == 's' && c2 == '|')  /* T && | */
				cd->hbuf[2] = 'v';
			else if (c1 == 'z' && c2 == '|')  /* __ && | */
				cd->hbuf[2] = '{';
			else
				cd->hbuf[2] = *ib;  /* Just in case. */
		}
		else if (action == 15)
		{
			cd->hbuf[2] = *ib;
			ADD_CONVERTED_CODE(0, 0);
		}
		else if (action == 16)
		{
			ADD_CONVERTED_CODE(0, 0);
		}
		else if (action == 17)
		{
			ADD_CONVERTED_CODE(1, 0);
			cd->hbuf[2] = *ib;
		}
		cd->cur_act = action;
		cd->cur_stat = state;
		ib++;
	}

	*inbuf = (char*)ib;
	*inbufleft = ibtail - ib;
	*outbuf = (char*)ob;
	*outbufleft = obtail - ob;

	return(ret_val);
}  /* end of size_t _icv_iconv(_conv_desc*, char**, size_t*, char**, size_t*).*/


/****  I N P U T _ C O N V  ****/

int input_conv(char c)
{
	switch (c)
	{
		case 'H':	/* dd */
		case 'S':	/* bb */
		case 'Y':	/* jj */
			return(1);

		case 'A':	/* g */
			return(2);

		case 'D':	/* n */
			return(3);

		case 'I':	/* r */
			return(4);

		case 'R':	/* b */
			return(5);

		case 'B':	/* gg */
		case 'G':	/* d */
		case 'V':	/* ss */
		case 'W':	/* o */
		case 'Z':	/* ch */
		case '[':	/* k */
			return(6);

		case 'U':	/* s */
			return(7);

		case 'X':	/* j */
			return(8);

		case '^':	/* h */
			return(9);

		case 'Q':	/* m */
		case ']':	/* p */
		case '\\':	/* t */
			return(10);

		case 'k':	/* =|| */
		case 'd':	/* |= */
		case 'e':	/* |=| */
		case 'j':	/* =| */
		case 'r':	/* _||_ */
		case 'w':	/* TT */
			return(11);

		case 'b':	/* |- */
		case 'c':	/* H */
			return(12);

		case 'f':	/* -| */
		case 'g':	/* -|| */
			return(13);

		case '|':	/* | */
			return(14);

		case 'l':	/* _|_ */
			return(15);

		case 's':	/* T */
			return(16);

		case 'z':	/* __ */
			return(17);

		case '\016':
			return(18);

		case '\017':
		case '\024':
			return(19);

		default:
			return(20);
	}
}  /* end of int input_conv(char). */


/****  M A K E _ J O H A P _ C O D E  ****/

unsigned short make_johap_code(int n, char* temp)
{
	register unsigned short code = 0;
	char 			save ='\0';

	if (n == 1)
	{
		if (temp[4] == '\0')
		{
			save = temp[3];
			temp[3] = '\0';
		}
		else
		{
			save = temp[4];
			temp[4] = '\0';
		}
	}

	code = (temp[1] >= 'A' && temp[1] <= '^') ?
			(unsigned short)X32_19[temp[1] - '@']
			: (unsigned short)9;
	code = (code << 5) | (unsigned short)((temp[2] >= 'b' &&
				temp[2] <= '|') ? X32_21[temp[2] - '`']
						    : 1);
	code = (code << 5) | (unsigned short)((temp[3] >= 'A' &&
				temp[3] <= '^') ? X32_28[temp[3] - '@']
						    : 1);

	if (temp[4] >= 'A')
	{
		if (temp[3] == 'A' && temp[4] == 'U')  /* gs */
			code += 2;
		else if (temp[3] == 'D' && temp[4] == 'X')  /* nj */
			code++;
		else if (temp[3] == 'D' && temp[4] == '^')  /* nh */
			code += 2;
		else if (temp[3] == 'I' && temp[4] == 'A')  /* rg */
			code++;
		else if (temp[3] == 'I' && temp[4] == 'Q')  /* rm */
			code += 2;
		else if (temp[3] == 'I' && temp[4] == 'R')  /* rb */
			code += 3;
		else if (temp[3] == 'I' && temp[4] == 'U')  /* rs */
			code += 4;
		else if (temp[3] == 'I' && temp[4] == '\\')  /* rt */
			code += 5;
		else if (temp[3] == 'I' && temp[4] == ']')  /* rp */
			code += 6;
		else if (temp[3] == 'I' && temp[4] == '^')  /* rh */
			code += 7;
		else if (temp[3] == 'R' && temp[4] == 'U')  /* bs */
			code++;
		else if (temp[3] == 'U' && temp[4] == 'U')  /* ss */
			code++;
	}

	temp[1] = (n == 1) ? save : '\0';
	temp[2] = temp[3] = temp[4] = '\0';
	return(code | 0x8000);
}  /* end of unsigned short make_johap_code(int, char*). */


/****  _ J O H A P _ T O _ W A N S U N G  ****/

static int _johap_to_wansung(unsigned short* wcode, unsigned short code)
{
	register unsigned short	i;
	unsigned short 		ci, v, cf;
	unsigned short		mask, disp;
	long			cfbit;

	*wcode = 0;
	ci = CHOSUNG(code) - 0x0A;
	v = JOONGSUNG(code) - ((unsigned short)JOONGSUNG(code) / 4 + 2);
	cf = JONGSUNG(code);

	if (JOONGSUNG(code) - ((unsigned short)JOONGSUNG(code) / 4 + 2) < 0)
		*wcode = 0xA4A0 + Y19_32[ci + 1];
	else if (CHOSUNG(code) - 0x0A < 0)
	{
		if (cf <= 1)
			*wcode = 0xA4BF + v;
		else
			return(FAILED);
	}
	else
	{
		 if (cf < 2)
			cf = 1;

		cfbit = cmp_bitmap[ci][v];
		for (disp = 0, i = 0; i < cf; i++)
		{
			if (cfbit & BIT_MASK)
				disp++;
			cfbit >>= 1;
		}
		if (!(cfbit & BIT_MASK))
			return(FAILED);

		*wcode = cmp_srchtbl[ci][v] + disp;
		mask = cmp_srchtbl[ci][v] & 0xFF;

		*wcode += (((short)(mask + disp) > 0xFE) ? SKIP : 0);
	}

	return(HANGUL);
}  /* end of unsigned short _johap_to_wansung(unsigned short, unsigned short,
    *						unsigned short). */

void *
_cv_open()
{
        struct _cv_state *st;

        if ((st = (struct _cv_state *)malloc(sizeof(struct _cv_state))) == NULL)
                return ((void *)-1);

	st->ibuf_left = 0;
	st->istart = 0;
	st->iend = 0;
	st->flush_obuf = 0;

        return (st);
}

void
_cv_close(st)
struct _cv_state *st;
{
        free(st);
}

size_t
_cv_enconv(st, inbuf, inbytesleft, outbuf, outbytesleft)
struct _cv_state *st;
char **inbuf;
size_t*inbytesleft;
char **outbuf;
size_t*outbytesleft;
{
	unsigned short code;

        if (inbuf == NULL || *inbuf == NULL) { /* Reset request. */
		st->ibuf_left = 0;
		st->istart = 0;
		st->iend = 0;
		st->flush_obuf = 0;
                return (0);
        }

	if (st->flush_obuf) {
		**outbuf = st->temp_obuf[0];
		(*outbuf)++;
		(*outbytesleft)--;
		st->flush_obuf = 0;
		if (*outbytesleft <= 0) {
			return(*inbytesleft);
		}
	}

	while (*inbytesleft > 0 && *outbytesleft > 0) {
		if (!is_SI(inbuf, inbytesleft, st))
			break;

		code = getc_12(inbuf, inbytesleft, st);

		if (code&0x8000) {
			code = packtocomp(code);
			**outbuf = code>>8;
			(*outbuf)++, (*outbytesleft)--;
			if (*outbytesleft <= 0) {
				st->flush_obuf = 1;
				st->temp_obuf[0] = code&0xFF;
			} else {
				**outbuf = code&0xFF;
				(*outbuf)++, (*outbytesleft)--;
			}
		} else {
			**outbuf = code&0xFF;
			(*outbuf)++, (*outbytesleft)--;
		}
	}
        return (*inbytesleft);
}

int
is_SI(inbuf, inbytesleft, st)
char **inbuf;
size_t *inbytesleft;
struct _cv_state *st;
{
	size_t i, x;
	char *buf;
	int SO_found = 0, SI_found = 0;

	buf = *inbuf;
	for (i = *inbytesleft; i > 0; i--) {
	    /* if SO is found */
	    if (*buf == 0x0e) {
		SO_found = 1;
		break;
	    } else
		buf++;
	}

	if (SO_found || st->ibuf_left) {
	    while (i > 0) {
		i--;
	        /* if SI is found */
	        if (*buf == 0x0f) {
		    SI_found = 1;
		    break;
	        } else
		    buf++;
	    }
	}


	/* if input buffer is not complete, i.e., last SI is not there */
	/* NEED to check for size of left buffer vs. temp_ibuf[] size */
	if ((SO_found && !SI_found) || (st->ibuf_left && !SI_found)) {
		st->ibuf_left = 1;
		x = *inbytesleft;
		for (i = 0; i < x; i++) {
			st->temp_ibuf[st->iend] = **inbuf;
			st->iend++;
			(*inbuf)++;
			(*inbytesleft)--;
		}
		return(0);
	}
	return(1);
}

#ifdef TEST

/* test case 1 */
char ibuf1[] = {0x0e, 0x57, 0x6c, 0x0f, 0x0e, 0x55, 0x67, 0x0f, 0x0e, 0x5a, 0x62, 0x57, 0x0f};
char obuf1[20];

/* test case 2 */
char ibuf2[] = {0x0e, 0x57, 0x6c, 0x0f, 0x0e, 0x55};
char ibuf21[] = {0x67, 0x0f, 0x0e, 0x5a, 0x62, 0x57, 0x0f};
char obuf2[20];

/* test case 3 */
char ibuf3[] = {0x0e, 0x57, 0x6c, 0x0f, 0x0e, 0x55, 0x67, 0x0f, 0x0e, 0x5a, 0x62, 0x57, 0x0f};
char obuf3[4];

/* test case 3+ */
char obuf31[5];

main()
{
        int i;
        struct _cv_state *st;
        size_t oleft, ileft;
        char *ip1 = &ibuf1[0], *op1 = &obuf1[0],
             *ip2 = &ibuf2[0], *ip21 = &ibuf21[0], *op2 = &obuf2[0],
             *ip3 = &ibuf3[0], *op3 = &obuf3[0];

        /****************************** test case 1 *************************/
        ileft = sizeof(ibuf1);
        oleft = sizeof(obuf1);

        st = _cv_open();

        printf("TEST 1\n INPUT BUFFER: ");
        for (i = 0; i < ileft ; i++) {
            printf("%x ", 0xff&ibuf1[i]);
        }
        printf("\n");
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip1, &ileft, &op1, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf1) - oleft) ; i++) {
            printf("%x ", 0xff&obuf1[i]);
        }
        printf("\n\n\n");
        _cv_close(st);

        /************************ test case 2 ******************************/
        ileft = sizeof(ibuf2);
        oleft = sizeof(obuf2);

        st = _cv_open();

        printf("TEST 2\nINPUT BUFFER: ");
        for (i = 0; i < ileft ; i++) {
            printf("%x ", 0xff&ibuf2[i]);
        }
        printf("\n");
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip2, &ileft, &op2, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf2) - oleft) ; i++) {
            printf("%x ", 0xff&obuf2[i]);
        }
        printf("\n\n");

        ileft = sizeof(ibuf21);
        oleft = sizeof(obuf2);
        op2 = &obuf2[0];
        printf("INPUT BUFFER: ");
        for (i = 0; i < ileft ; i++) {
            printf("%x ", 0xff&ibuf21[i]);
        }
        printf("\n");
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip21, &ileft, &op2, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf2) - oleft) ; i++) {
            printf("%x ", 0xff&obuf2[i]);
        }
        printf("\n\n\n");
        _cv_close(st);

        /************************ test case 3 ******************************/
        ileft = sizeof(ibuf3);
        oleft = sizeof(obuf3);

        st = _cv_open();

        printf("TEST 3\nINPUT BUFFER: ");
        for (i = 0; i < ileft ; i++) {
            printf("%x ", 0xff&ibuf3[i]);
        }
        printf("\n");
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf3) - oleft) ; i++) {
            printf("%x ", 0xff&obuf3[i]);
        }
        printf("\n\n");

        op3 = &obuf3[0];
        oleft = sizeof(obuf3);
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf3) - oleft) ; i++) {
            printf("%x ", 0xff&obuf3[i]);
        }
        printf("\n\n");

        op3 = &obuf3[0];
        oleft = sizeof(obuf3);
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf3) - oleft) ; i++) {
            printf("%x ", 0xff&obuf3[i]);
        }
        printf("\n\n\n");
        _cv_close(st);

        /************************ test case 3+ ******************************/
        ip3 = &ibuf3[0];
	op3 = &obuf31[0];
        ileft = sizeof(ibuf3);
        oleft = sizeof(obuf31);

        st = _cv_open();

        printf("TEST 3+\nINPUT BUFFER: ");
        for (i = 0; i < ileft ; i++) {
            printf("%x ", 0xff&ibuf3[i]);
        }
        printf("\n");
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf31) - oleft) ; i++) {
            printf("%x ", 0xff&obuf31[i]);
        }
        printf("\n\n");

        op3 = &obuf31[0];
        oleft = sizeof(obuf31);
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf31) - oleft) ; i++) {
            printf("%x ", 0xff&obuf31[i]);
        }
        printf("\n\n");

        op3 = &obuf31[0];
        oleft = sizeof(obuf31);
        printf("OUTPUT: return value %d ",
                _cv_enconv(st, &ip3, &ileft, &op3, &oleft));
        printf("ileft %d  oleft %d\n", ileft, oleft);
        printf("        flush_obuf %d  ibuf_left %d\n", st->flush_obuf,
                                                        st->ibuf_left);
        printf("        strat_cnt %d   end_cnt %d\n", st->istart,
                                                        st->iend);
        printf("OUTPUT BUFFER: ");
        for (i = 0; i < (sizeof(obuf31) - oleft) ; i++) {
            printf("%x ", 0xff&obuf31[i]);
        }
        printf("\n\n\n");
        _cv_close(st);
}

/* expected output

TEST 1
 INPUT BUFFER: e 57 6c f e 55 67 f e 5a 62 57 f
OUTPUT: return value 0 ileft 0  oleft 14
        flush_obuf 0  ibuf_left 0
OUTPUT BUFFER: bf c0 bc bc c3 a2


TEST 2
INPUT BUFFER: e 57 6c f e 55
OUTPUT: return value 0 ileft 0  oleft 18
        flush_obuf 0  ibuf_left 1
OUTPUT BUFFER: bf c0

INPUT BUFFER: 67 f e 5a 62 57 f
OUTPUT: return value 0 ileft 0  oleft 16
        flush_obuf 0  ibuf_left 0
OUTPUT BUFFER: bc bc c3 a2


TEST 3
INPUT BUFFER: e 57 6c f e 55 67 f e 5a 62 57 f
OUTPUT: return value 5 ileft 5  oleft 0
        flush_obuf 0  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER: bf c0 bc bc

OUTPUT: return value 0 ileft 0  oleft 2
        flush_obuf 0  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER: c3 a2

OUTPUT: return value 0 ileft 0  oleft 4
        flush_obuf 0  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER:


TEST 3+
INPUT BUFFER: e 57 6c f e 55 67 f e 5a 62 57 f
OUTPUT: return value 0 ileft 0  oleft 0
        flush_obuf 1  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER: bf c0 bc bc c3

OUTPUT: return value 0 ileft 0  oleft 4
        flush_obuf 0  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER: a2

OUTPUT: return value 0 ileft 0  oleft 5
        flush_obuf 0  ibuf_left 0
        strat_cnt 0   end_cnt 0
OUTPUT BUFFER:

*/

#endif /* TEST */