xref: /dports/japanese/xtr/xtr1.50e-0.2/src/cntrl.c

/* cntrl.c */
/*****************************************************************************
					�ԣ�������У���������أԣ�

							�����楳���ɽ�����
*****************************************************************************/

#include "xtr.h"

#define SameSeq(a, b) 	((a)->rpllen == (b)->rpllen && \
						 !memcmp((a)->rpl, (b)->rpl, (a)->rpllen))

#define SameGrp(a, b)	((a)->grp == (b)->grp)
#define SameGrp1(a, b)	(SameGrp((a), (b)) && \
							((a)->grp || (a)->cmode == (b)->cmode))
#define SameGrpS(a, b) 	(SameGrp((a), (b)) && \
							((a)->grp || (a)->cmode == (b)->cmode && \
											SameSeq((a), (b))))

#define FreeCntrl1(obj)	(XFree((voidstar)(obj)->fnd), XFree((voidstar)(obj)->rpl), XFree((voidstar)(obj)))


static int
MemberSameGrp(def_t *obj, def_t *clist)
/* obj ��Ʊ�����롼�פ����Ǥ� clist �ˤ��뤫 */
{
	if (obj != NULL) {
		for (; clist != NULL; clist = clist->prev) {
			if (SameGrpS(obj, clist))
				return TRUE;
		}
	}
	return FALSE;
}

static int
MemberCntrl(def_t *obj, def_t *clist)
/* obj �� clist �����Ǥ� */
{
	if (obj != NULL) {
		for (; clist != NULL; clist = clist->prev) {
			if (obj == clist)
				return TRUE;
		}
	}
	return FALSE;
}

static void
FreeCntrl(def_t *cntrl)
/* ���楳���ɥꥹ�� cntrl �������� */
{
	def_t *pprev;

	while (cntrl) {
		pprev = cntrl->prev;
		FreeCntrl1(cntrl);
		cntrl = pprev;
	}
}

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

void
ResetCntrl(def_t **cntrlp)
/* ���楳���ɥꥹ�� *cntrlp �������ƶ��ˤ��� */
{
	assert(cntrlp != NULL);

	FreeCntrl(*cntrlp);
	*cntrlp = NULL;
}

def_t *
DupCntrl1(def_t *org)
{
	if (org == NULL) {
		return NULL;
	} else {
		def_t *cntrl = (def_t *)XMalloc(sizeof(def_t));
#if 0
		cntrl->fnd = DupStrN(org->fnd, org->fndlen);
		cntrl->fndlen = org->fndlen;
#else
		cntrl->fnd = NULL;
		cntrl->fndlen = 0;
#endif
		cntrl->rpl = DupStrN(org->rpl, org->rpllen);
		cntrl->rpllen = org->rpllen;
		cntrl->mode = org->mode;
		cntrl->cmode = org->cmode;
		cntrl->grp = org->grp;
		cntrl->prev = NULL;
		return cntrl;
	}
}

def_t *
DupCntrl(def_t *org)
{
	if (org == NULL) {
		return NULL;
	} else {
		def_t *cntrl = DupCntrl1(org);
		cntrl->prev = DupCntrl(org->prev);
		return cntrl;
	}
}


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

def_t *
AddCntrl(def_t *org, def_t *add)
{
	assert(add != NULL);

	if (org != NULL && SameGrp(org, add) && SameSeq(org, add)) {
		return org;
	} else {
		def_t *cntrl = DupCntrl1(add);
		cntrl->prev = org;
		return cntrl;
	}
}

static def_t *
RemCntrlSub(def_t *org, def_t *rem)
{
	assert(rem != NULL);

	if (org == NULL)
		return NULL;
	else if (SameGrpS(org, rem))
		return org->prev;
	else
		return AddCntrl(RemCntrlSub(org->prev, rem), org);
}

def_t *
RemCntrl(def_t *org, def_t *rem)
/* ���楳���ɥꥹ�� org ���� rem �ޤ��ϡ�
   rem ��Ʊ�����롼�פ����楳���ɤ��ļ�������
   ���楳���ɥꥹ�Ȥ��֤��������˲�Ū�� */
{
	assert(rem != NULL);

	if (MemberSameGrp(rem, org))
		return RemCntrlSub(org, rem);
	else
		return org;
}


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

int
RemFCntrl(def_t **cntrlp, def_t *rem)
/* ���楳���ɥꥹ�� *cntrlp ���� rem �ޤ��ϡ�*/
/* rem ��Ʊ�����롼�פ����楳���ɤ��ļ����� */
/* ���������� 1 ���Ǥʤ��ä��� 0 ���֤� */
{
	def_t **cp = cntrlp;
	def_t *p = *cntrlp;

	assert(cntrlp != NULL);
	assert(rem != NULL);

	while (p) {
		if (SameGrpS(p, rem)) {
			/* ���Ĥ��ä��� */
			*cp = p->prev;
			FreeCntrl1(p);
			return 1;
		}
		cp = &(p->prev);
		p = *cp;
	}
	return 0;
}


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

/* SGR���������ʤ鿿���֤� */
#define IsSGRseq(seq, len)	\
	(seq[0] == '\033' && seq[1] == '[' && seq[len-1] == 'm')

static int
WasSGRseq(void)
/* ľ����PC98��SGR���������Ǥ��뤫��Ĵ�٤� */
{
	uchar *p = cbufp;
	if (--p <= cbuf || *p != 'm')
		return 0;				/* �Ǹ��ʸ���� 'm' �Ǥʤ��ʤ鵶 */

	while (--p > cbuf)			/* ����鸫�Ƥ��� */
		if (*p == '[')
			return 1;			/* '[' �����ä��鿿 */
		else if (*p < 0x30 || *p > 0x3b)
			return 0;			/* ������ ';' �ʳ�������е� */
	return 0;
}

static void
ExtractCntrl1(def_t *cntrl)
/* ��Ĥ����楳���ɤ����Ƥ���Ф� */
{
	uchar *rpl = cntrl->rpl;
	int	   len = cntrl->rpllen;

	if (cntrl->mode & R_EVAL) {
		/* ʸ����ɾ�����꤬����� */
		marg_t	*margv0 = margv;
		int		margc0 = margc;
		margv = NULL;
		margc = 0;
		rpl = AEvalStringN(&len, rpl, len);					/* %-�Ѵ� */
		margc = margc0;
		margv = margv0;
	}
	if (cbufp - len >= cbuf && memcmp(rpl, cbufp - len, len)==0) {
		/* ľ���Υ����ɤ�Ʊ�����Ƥʤ��ά */
		;
	} else {
		/* @@ ���ν����Ǥ��Խ�ʬ */
		if (sgr98mode && IsSGRseq(rpl, len) && WasSGRseq()) {
			/* �⤷��PC98 SGR mode �ǡ����Τ�ľ�������楳���ɤ�
			   SGR �����������ä��顢���Ĥ� SGR seq ��Ϣ�뤹�� */
			/* �㡧 "\x1b[7m" + "\x1b[32m" �� "\x1b[7;32m" */
			*(cbufp - 1) = ';';		/* ���� SGR seq �� "m" �� ";" ���Ѥ��� */
			rpl += 2;				/* ��� "\x1b[" ������ */
			len -= 2;
		}
		memcpy(cbufp, rpl, len);
		cbufp += len;
		if (cbufp > cbuf + CBUFSIZE)
			FError("Code buffer over");
	}
	if (cntrl->mode & R_EVAL)
		XFree((voidstar)rpl);
}


static void
ExtractCntrl2(def_t *cntrls, int grp)
/* ���楳���ɥꥹ�� cntrls �����Ƥ���Ф��ƥХåե� cbufp ���Ÿ������ */
/* 0 �ʳ��� grp ��Ϳ�����Ƥ����顢���� grp �Ȱ��פ����ΤΤ߼��Ф� */
/* ���楳���ɤ�Ĺ����ʬ�������ݥ��� cbufp ��ʤ�� */
{
	if (cntrls == NULL)
		return;
	else {
		ExtractCntrl2(cntrls->prev, grp);	/* �ޤ��������Ρ����Ǥ���� */
		if (!grp || grp == cntrls->grp) {
			/* ���롼�׻���̵����̵���ˤ����롼�פ����פ���� */
			ExtractCntrl1(cntrls);
		}
	}
}


int
ExtractCntrl(def_t *cntrls, int grp)
/* ���楳���ɥꥹ�� cntrls �����Ƥ���Ф��ƥХåե� cbuf[] ���Ÿ������ */
/* 0 �ʳ��� grp ��Ϳ�����Ƥ����顢���� grp �Ȱ��פ����ΤΤ߼��Ф� */
/* Ĺ�����֤� */
{
	cbufp = cbuf;
	ExtractCntrl2(cntrls, grp);
	*cbufp = 0;
	return clength = cbufp - cbuf;
}


int
ExtractResetCntrl(def_t *cntrls, def_t *rescntrls)
/* ���ߤ�ʸ�����������楳���ɥꥹ�Ȥ� cntrls��
   ʸ��������������楳���ɥꥹ�Ȥ� rescntrls �Ȥ��ơ�
   ���ߤ�ʸ��������������Τ�ɬ�פ����楳���ɤΤߤ� cbuf[] ��Ÿ������ */
{
	cbufp = cbuf;
	for ( ; cntrls; cntrls = cntrls->prev)
		ExtractCntrl2(rescntrls, cntrls->grp);

	*cbufp = 0;
	return clength = cbufp - cbuf;
}


static void
ExtractReputCntrl2(def_t *cntrls,def_t *rescntrls,def_t *rescntrl)
{
	assert(rescntrl != NULL);

	if (cntrls == NULL)
		return;

	ExtractReputCntrl2(cntrls->prev, rescntrls, rescntrl); /* ���Τ���˽��� */
	for ( ; rescntrls ; rescntrls = rescntrls->prev) {
		if (SameGrp1(cntrls, rescntrls) && SameSeq(rescntrls, rescntrl)) {
			/* ���롼�פ����פ���ʸ����������Υ����ɡ�rescntrls �����ǡˤ�
			   ���˽��Ϥ���ʸ����������Υ����� rescntrl �ȥ��������Ƥ�
			   Ʊ��Ǥ������楳���ɤ� cntrls �����ǤȤ���¸�ߤ����
			   �������� */
			ExtractCntrl1(cntrls);
		}
	}
}


int
ExtractReputCntrl(def_t *rescntrl)
/* rescntrl ����Ϥ������Ȥǰ��˲������Ƥ��ޤä�ʸ��������
   �����������楳���ɤ�Ȥ���� */
{
	assert(rescntrl != NULL);

	cbufp = cbuf;

	if (c_attr)
		ExtractReputCntrl2(c_attr, c_areset, rescntrl);
	if (c_wide)
		ExtractReputCntrl2(c_wide, c_wreset, rescntrl);
	if (c_vexpand)
		ExtractReputCntrl2(c_vexpand, c_vreset, rescntrl);
	if (c_qexpand)
		ExtractReputCntrl2(c_qexpand, c_qreset, rescntrl);
	if (c_half)
		ExtractReputCntrl2(c_half, c_hreset, rescntrl);
	if (c_font)
		ExtractReputCntrl2(c_font, c_freset, rescntrl);

	*cbufp = 0;
	return clength = cbufp - cbuf;
}

static void InitCntrlPosVects ARGS((void));

void
ResetCntrlLists(void)
{
	ResetCntrl(&c_reset);
	ResetCntrl(&c_terminate);
	ResetCntrl(&c_newline);
	ResetCntrl(&c_newpage);
	ResetCntrl(&c_reset2);
	ResetCntrl(&c_areset);
	ResetCntrl(&c_vreset);
	ResetCntrl(&c_qreset);
	ResetCntrl(&c_wreset);
	ResetCntrl(&c_hreset);
	ResetCntrl(&c_freset);
	ResetCntrl(&c_kicode);
	ResetCntrl(&c_kocode);
	ResetCntrl(&c_hicode);
	ResetCntrl(&c_hocode);
	ResetCntrl(&c_attr);
	ResetCntrl(&c_wide);
	ResetCntrl(&c_vexpand);
	ResetCntrl(&c_qexpand);
	ResetCntrl(&c_half);
	ResetCntrl(&c_font);
	ResetCntrl(&c_pagefont);
	ResetCntrl(&c_pagekicode);
	ResetCntrl(&c_pagekocode);

	InitCntrlPosVects();
}


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


/* ���楳���������߰��ֵ����٥��������� */
typedef struct cpos {
	ushort		x;		/* ���楳���������߰��� */
	struct def	*cntrl;		/* ���楳���ɥꥹ�� */
} cpos_t;

/* ���楳���������߰��ֵ����٥��� */
static cpos_t cposv_a[CPOSVSIZE];
static cpos_t cposv_w[CPOSVSIZE];
static cpos_t cposv_v[CPOSVSIZE];
static cpos_t cposv_q[CPOSVSIZE];
static cpos_t cposv_h[CPOSVSIZE];
static cpos_t cposv_f[CPOSVSIZE];
static int cposc_a = 0;
static int cposc_w = 0;
static int cposc_v = 0;
static int cposc_q = 0;
static int cposc_h = 0;
static int cposc_f = 0;

static def_t *c_a = NULL;
static def_t *c_w = NULL;
static def_t *c_v = NULL;
static def_t *c_q = NULL;
static def_t *c_h = NULL;
static def_t *c_f = NULL;

static def_t *
CntrlWrapSub(int cposc, cpos_t *cposv)
{
	while (cposc > 0 && (int)cposv[cposc].x > x)
		cposc--;

	return cposv[cposc].cntrl;
}

void
CntrlWrapBefor(void)
/* ���������楳���ɤΥ�ɥ�å������� */
/* ��ɥ�åפ����������楳���ɤޤǼ��Ԥ������Ƥ�����
   ʸ�������������֤��Υ����ɤ����ξ��֤��᤹ */
{
	c_a = c_attr;
	c_w = c_wide;
	c_v = c_vexpand;
	c_q = c_qexpand;
	c_h = c_half;
	c_f = c_font;
	c_attr = CntrlWrapSub(cposc_a, cposv_a);
	c_wide = CntrlWrapSub(cposc_w, cposv_w);
	c_vexpand = CntrlWrapSub(cposc_v, cposv_v);
	c_qexpand = CntrlWrapSub(cposc_q, cposv_q);
	c_half = CntrlWrapSub(cposc_h, cposv_h);
	c_font = CntrlWrapSub(cposc_f, cposv_f);
}

void
CntrlWrapAfter(void)
/* ���������楳���ɤΥ�ɥ�å׸���� */
{
	c_attr 	= c_a;
	c_wide 	= c_w;
	c_vexpand = c_v;
	c_qexpand = c_q;
	c_half 	= c_h;
	c_font 	= c_f;
	c_a = NULL;
	c_w = NULL;
	c_v = NULL;
	c_q = NULL;
	c_h = NULL;
	c_f = NULL;
	SetCntrlPosVects();
}



static void
FreeCntrlPosv(int cposc, cpos_t *cposv, def_t *c1, def_t *c2)
{
	def_t *p;
	def_t *pprev;
	int i, j;

	for (i = cposc; i >= 0; i--) {
		p = cposv[i].cntrl;
		cposv[i].x = 0;
		cposv[i].cntrl = NULL;

		while (p) {
			if (MemberCntrl(p, c2) || (c1 != c2 && MemberCntrl(p, c1)))
				goto next;

			for (j = i - 1; j >= 0; j--) {
				if (MemberCntrl(p, cposv[j].cntrl))
					goto next;
			}
			pprev = p->prev;
			FreeCntrl1(p);
			p = pprev;
		}
	next:;
	}
}


static void
InitCntrlPosVects(void)
{
	cposc_a = cposc_w = cposc_v = cposc_q = cposc_h = cposc_f = 0;
	cposv_a[0].x = 0;
	cposv_a[0].cntrl = c_attr;
	cposv_w[0].x = 0;
	cposv_w[0].cntrl = c_wide;
	cposv_v[0].x = 0;
	cposv_v[0].cntrl = c_vexpand;
	cposv_q[0].x = 0;
	cposv_q[0].cntrl = c_qexpand;
	cposv_h[0].x = 0;
	cposv_h[0].cntrl = c_half;
	cposv_f[0].x = 0;
	cposv_f[0].cntrl = c_font;
}


void
ResCntrlPosVects(void)
{
	FreeCntrlPosv(cposc_a, cposv_a, c_attr, c_a);
	FreeCntrlPosv(cposc_w, cposv_w, c_wide, c_w);
	FreeCntrlPosv(cposc_v, cposv_v, c_vexpand, c_v);
	FreeCntrlPosv(cposc_q, cposv_q, c_qexpand, c_q);
	FreeCntrlPosv(cposc_h, cposv_h, c_half, c_h);
	FreeCntrlPosv(cposc_f, cposv_f, c_font, c_f);

	InitCntrlPosVects();
}

void
SetCntrlPosVects(void)
{
	if (cposv_a[cposc_a].cntrl != c_attr && ++cposc_a < CPOSVSIZE) {
		cposv_a[cposc_a].x = x;
		cposv_a[cposc_a].cntrl = c_attr;
	}
	if (cposv_w[cposc_w].cntrl != c_wide && ++cposc_w < CPOSVSIZE) {
		cposv_w[cposc_w].x = x;
		cposv_w[cposc_w].cntrl = c_wide;
	}
	if (cposv_v[cposc_v].cntrl != c_vexpand && ++cposc_v < CPOSVSIZE) {
		cposv_v[cposc_v].x = x;
		cposv_v[cposc_v].cntrl = c_vexpand;
	}
	if (cposv_q[cposc_q].cntrl != c_qexpand && ++cposc_q < CPOSVSIZE) {
		cposv_q[cposc_q].x = x;
		cposv_q[cposc_q].cntrl = c_qexpand;
	}
	if (cposv_h[cposc_h].cntrl != c_half && ++cposc_h < CPOSVSIZE) {
		cposv_h[cposc_h].x = x;
		cposv_h[cposc_h].cntrl = c_half;
	}
	if (cposv_f[cposc_f].cntrl != c_font && ++cposc_f < CPOSVSIZE) {
		cposv_f[cposc_f].x = x;
		cposv_f[cposc_f].cntrl = c_font;
	}
}

/*
 * Local variables:
 * mode: c
 * c-indent-level: 4
 * c-continued-statement-offset: 4
 * c-brace-offset: -4
 * c-argdecl-indent: 4
 * c-label-offset: -4
 * tab-width: 4
 * tab-stop-list: (4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80)
 * End:
 */