1 /* write.c */
2 /*****************************************************************************
3 					�ԣ�������У���������أԣ�
4 
5 								�ν�������
6 *****************************************************************************/
7 
8 #include "xtr.h"
9 
10 #define MAXADJPOSC	80
11 
12 static struct adjpos {
13 	ushort		x;
14 	ushort		mode;
15 } adjposv[MAXADJPOSC+1];
16 
17 static int adjposc = 0;
18 
19 static int migiyoriflag = OFF;
20 			/* ��Ĵ���ǡ�;ʬ�ʶ����ʬ�ۤ�����ߤˤ��뤿�� */
21 
22 #if UNIX
23 #define HanSP	SP
24 #define PAGEHWMODE_SP SP
25 #else
26 #define HanSP	((anktohwmode && !nocntrlmode) ? HWSP : SP)
27 #define PAGEHWMODE_SP (pagehwmode ? HWSP : SP)
28 #endif
29 
30 static void
WidthExpandChg(void)31 WidthExpandChg(void)
32 {
33 	int i;
34 	int i2;
35 	uchar *p;
36 	uchar *p1;
37 
38 	for (i = 0; i < x; i = i2) {
39 		p = lbv[i];
40 		p1 = SkipMoji(p);
41 		i2 = NextCol(i);
42 		if (p1 < lbv[i2] && *p1 == SP) {
43 			if (p1 + 1 < lbv[i2] && *(p1+1) == SP) {
44 				if (p + 2 == p1) {
45 					/* ���Ѥβ����� */
46 					/* ���ڡ�����ξ�Ƥ˰ܤ� */
47 					p[2] = p[1];
48 					p[1] = p[0];
49 					p[0] = SP;
50 				}
51 			} else {
52 				if (p + 1 == p1) {
53 					/* Ⱦ�Ѥβ����� */
54 					/* ���Ѥ��Ѵ����� */
55 					unsigned c = ANKtoZen(p[0]);
56 					p[1] = Moji_2(c);
57 					p[0] = Moji_1(c);
58 				}
59 			}
60 		}
61 	}
62 }
63 
64 static void
ChangePf(void)65 ChangePf(void)
66 {
67 	if (!phpfchgflag)
68 		return;
69 
70 	if (pfleft != newpfleft) {
71 		SFree(pfleft);
72 		pfleft = newpfleft;			/* �������ڡ����եå����åȤ��� */
73 	}
74 	if (pfcenter != newpfcenter) {
75 		SFree(pfcenter);
76 		pfcenter = newpfcenter;
77 	}
78 	if (pfright != newpfright) {
79 		SFree(pfright);
80 		pfright = newpfright;
81 	}
82 }
83 
84 
85 /****************************************************************************/
86 
87 /* �ץ���ؤΥꥻ�åȤ�Ф��Ƥ��뤫�����å����Ƥޤ��ʤ�Ф� */
88 #define MadaResetChk() \
89     do { if (resetmadaflag && c_reset) FMadaResetChk(); } while (0)
90 
91 static void
FMadaResetChk(void)92 FMadaResetChk(void)
93 {
94 	uchar *cbuf0 = DupStrN(cbuf, clength);
95 	int clength0 = clength;
96 
97 	resetmadaflag = OFF;
98 	WriteCntrl(c_reset);
99 	WriteCntrl(c_reset2);
100 	CopyStrN(cbuf, cbuf0, clength0);
101 	clength = clength0;
102 	XFree((voidstar)cbuf0);
103 }
104 
105 
106 /****************************************************************************/
107 /*					�饤��Хåե������Ƥ���Ϥ���							*/
108 /************************** WriteLine ***************************************/
109 
110 void
WriteLine(void)111 WriteLine(void)
112 {
113 	int splineflag = mada_start_of_line;
114 
115 	MadaResetChk();
116 	if (phpfchgflag)	/* �إå�/�եå��ѹ���ľ��Dz��ڡ������Ƥ��ʤ��ʤ� */
117 		ChangePf();		/* �������ڡ����եå����åȤ��� */
118 
119 	if (wexpmodeno == 1 && wexpflag)
120 		/* �⤷���ƥ����Ȳ��̥ץ�ӥ奢�Ѳ�����⡼�ɤʤ� */
121 		WidthExpandChg();
122 
123 	if ((pagecutflag || linespaced) && splineflag && lbv[0] == lbuf) {
124 		/* �ڡ������ڤ줿���Ȥ�����ԥ��ޥ�ɤΤ��Ȥζ���ԤϽ��Ϥ��ʤ� */
125 		;
126 	} else if (lineoverflag) {
127 		/* Ĺ������ʬ�䤷���Ԥξ�� */
128 		if (printpageflag)
129 			WriteLineNCol(x);
130 		if (!nonewlineflag)		/* �ޤ�Ĺ�������褿�ΤǤʤ���� */
131 			WriteNewLine();
132 	} else {
133 		if (!plaintextmode && pagemode && pageendflag) {
134 			/* �ڡ��������äƤ����� */
135 			WritePage();						/* ���ڡ��� */
136 		} else if (vexpflag && !splineflag) {
137 			if (vexpmodeno == 3 ) {
138 				/* �ij���Ԥǥץ�����Դ֤�¿�������Ƥ����⡼�ɤʤ�
139 				   ����ʬ¿��������� */
140 				lineno++;
141 			} else if (vexpmodeno == 1) {
142 				/* �ij���Ԥǽ��˲��Ԥ�ä���⡼�ɤʤ� */
143 				WriteNewLine();
144 			}
145 		}
146 		if (printpageflag) {
147 			WriteCntrl(c_reset2);
148 
149 			WriteChrN(SP, pageoffset);				/* ��;�� */
150 			if (chrexpflag) {						/* ʸ�����Ф�����ʤ� */
151 				WriteLineAdj();
152 			} else if (centeradjmode) {				/* ��������� */
153 				adjposc = 0;
154 				SetChrExpPos(0, CHREXP_PREVCHR);
155 				SetChrExpPos(x, CHREXP_NEXTCHR);
156 				WriteLineAdj();
157 			} else if (rightadjmode) {				/* ���� */
158 				adjposc = 0;
159 				SetChrExpPos(0, CHREXP_PREVCHR);
160 				WriteLineAdj();
161 			} else if (bothadjmode && adjposc) {	/* ξü·�� */
162 				aindent = bindent;
163 				WriteLineAdj();
164 			} else if (linebreak && adjposc) {	/* ɸ���·�� */
165 				WriteLineAdj();
166 			} else {								/* ��·��̵�� */
167 				WriteLineNCol(x);
168 				migiyoriflag = OFF;		/* ��Ĵ��������ߥե饰�ꥻ�å� */
169 			}
170 		}
171 		if (!nonewlineflag) {		/* Ĺ�������褿�ΤǤʤ���� */
172 			WriteNewLine();
173 			if (vexpflag && vexpmodeno == 2 && !pagecutflag && !splineflag) {
174 				/* �ij���ԤǸ�˲��Ԥ�ä���⡼�ɤʤ� */
175 				WriteNewLine();
176 			}
177 			if (splineflag)
178 				spacelines++;
179 			else
180 				spacelines = linespaced = 0;
181 		}
182 	}
183 	InitLine();
184 	nonewlineflag = OFF;
185 }
186 
187 
188 /******************************* Write1 *************************************/
189 
190 #define NBYTES_DISP		2048	/* ���Х��Ƚ�����˷в�ɽ�����뤫 */
191 
192 #define _nocrmode		(nocrmode || (!NL_IS_CRLF && nocntrlmode))
193 
194 #if UNIX
195 
196 #define SS2 0x8e
197 
198 static void
WriteC(uchar c)199 WriteC(uchar c)
200 {
201   static uchar ch = 0;
202 
203   if (ch)
204     {
205       int k;
206       k = (*S2MB)(ch, c);
207       putc(Moji_1(k), ofp);
208       putc(Moji_2(k), ofp);
209       ch = 0;
210     }
211   else if (IsKanji1(c))
212     ch = c;
213   else
214     {
215       if (mbtype == MBTYPE_EUC && iskana(c))
216         putc(SS2, ofp);
217       putc(c, ofp);
218     }
219 }
220 #else
221 #define WriteC(c)		((void)putc((c), ofp))
222 #endif
223 
224 static int kanjiflag = OFF;
225 static int kanji1 = 0;			/* ���������ɤΣ��Х����ܤ������� */
226 static int wlcount = 0;
227 static int wlcutflag = OFF;
228 static int hwflag = OFF;
229 
230 static void
WriteNL(void)231 WriteNL(void)
232 {
233 	if (kanjiflag) {
234 		WriteCntrl(c_kocode);
235 		kanjiflag = OFF;
236 	}
237 	if (hwflag) {
238 		WriteCntrl(c_hocode);
239 		hwflag = OFF;
240 	}
241 	if (kanji1) {
242 		WriteC(kanji1);
243 		kanji1 = 0;
244 	}
245 	wlcount = 0;
246 	if (wlcutflag) {
247 		/* �Х��ȿ��³��Ƕ������Խ��ϤΤ��Ȥʤ� */
248 		wlcutflag = OFF;
249 		return;
250 	}
251 	if (c_newline && (WriteCntrl(c_newline), !nocntrlmode)) {
252 		;	/* ���ز��Խ��Ϥ��� */
253 	} else {
254 		if (!_nocrmode && !binarymode)
255 			WriteC('\r');
256 		WriteC('\n');
257 	}
258 	More();
259 }
260 
261 
262 #define CountWL(n)														\
263     do {																\
264 		if (wlmode && (wlcount += (n)) > wlimit) {						\
265 			WriteNL();													\
266 			wlcutflag = ON;												\
267 		}																\
268 	} while (0)
269 
270 
271 void
Write1(int c)272 Write1(int c)
273 /* ���Х��Ƚ��� */
274 {
275 	unsigned k;
276 
277 	static unsigned dispcount = 0;	/* �в�ɽ���Τ���Υ����� */
278 
279 	wlcutflag = OFF;
280 
281 	if (!dispcount--) {
282 		if (!eotflag)
283 			Disp(0);
284 		dispcount = NBYTES_DISP - 1;
285 	}
286 
287 	if ((!wkmode && !c_kicode) || nokanjimode) {
288 		/* �������Ѵ����ʤ��ʤ餽�Τޤ޽��� */
289 		CountWL(1);
290 		WriteC(c);
291 
292 	} else if (kanji1 && iskanji2(c)) {
293 		/* �裱�Х����ܤ���������Ƥ��ƣ��Х����ܤ���������� */
294 		k = MkMoji(kanji1, c);
295 		if (c_hicode) {
296 			if (IsHW(k)) {
297 				if (!nocntrlmode)
298 					k = HWtoZen(k);
299 				if (!hwflag) {
300 					if (c_kicode && !kanjiflag) {
301 						CountWL(c_kicode->rpllen);
302 						WriteCntrl(c_kicode);	/* �ˣɥ����ɽ��� */
303 					}
304 					CountWL(c_hicode->rpllen);
305 					WriteCntrl(c_hicode);		/* Ⱦ�ѻ������ */
306 					kanjiflag = hwflag = ON;
307 				}
308 			} else if (hwflag) {
309 				WriteCntrl(c_hocode);
310 				hwflag = OFF;
311 			}
312 		}
313 		if (c_kicode && !nocntrlmode)
314 			if (anktohwmode && IsHW(k)) {
315 				/* pj+ �ǣΣţã��Х���Ⱦ��ʸ���ʤ� */
316 				k = HWtoANK(k);
317 				if (!Is1B(k))
318 					k = jmstojis(k);
319 			} else {
320 				k = jmstojis(k);			/* Shift-JIS��JIS �Ѵ� */
321 			}
322 		if (!kanjiflag) {					/* ���������Ǥʤ���� */
323 			if (c_kicode) {
324 				CountWL(c_kicode->rpllen);
325 				WriteCntrl(c_kicode);	/* �ˣɥ����ɽ��� */
326 			} else if (wkmode) {
327 				CountWL(kikosize);
328 			}
329 			kanjiflag = ON;
330 		}
331 		CountWL(2);
332 		WriteC(Moji_1(k));
333 		WriteC(Moji_2(k));
334 		kanji1 = 0;
335 	} else if (!kanji1 && iskanji(c)) {
336 		/* �������Х����ܤξ�� */
337 		kanji1 = c;							/* ���Х����ܤ��褿��������� */
338 	} else {
339 		/* �����Ǥʤ���� */
340 		if (kanjiflag) {
341 			if (c_kocode) {
342 				CountWL(c_kocode->rpllen);
343 				WriteCntrl(c_kocode);	/* ���������ʤ�ˣϥ����ɽ��� */
344 			} else if (wkmode) {
345 				CountWL(kikosize);
346 			}
347 			kanjiflag = OFF;
348 			if (hwflag) {
349 				CountWL(c_hocode->rpllen);
350 				WriteCntrl(c_hocode);
351 				hwflag = OFF;
352 			}
353 		}
354 		if (kanji1) {
355 			/* �⤷�ְ�äƴ������Х����ܤȤ��Ƶ�������Ƥ���ʸ�������ä��� */
356 			CountWL(1);
357 			WriteC(kanji1);
358 		}
359 		if (c == '\n')
360 			wlcount = 0;
361 		else
362 			CountWL(1);
363 		WriteC(c);
364 		kanji1 = 0;
365 	}
366 }
367 
368 
369 
370 void
WriteLineNCol(int n)371 WriteLineNCol(int n)
372 /* �饤��Хåե�����Ƭ���� n �����Ϥ��� */
373 {
374 	uchar *lbufn = lbv[n];
375 	register uchar *p = lbuf;
376 	register int i;
377 
378 	assert(n >= 0);
379 
380 	MadaResetChk();
381 
382 	if (!lineoverflag) {
383 		for (i = 0; p < lbufn && *p == SP; p++, i++);
384 								/* ��Ƭ��Ⱦ�ѥ��ڡ����ο�������� */
385 		WriteIndent(i);
386 	}
387 	WriteN(p, lbufn - p);
388 }
389 
390 
391 
392 void
WriteIndent(int i)393 WriteIndent(int i)
394 /* ��� i �Υ���ǥ�Ȥ��դ���ʶ������ϡ� */
395 {
396 	assert(i >= 0);
397 
398 	if (sptotabmode) {
399 		WriteChrN('\t', i / otabstop);
400 		i = i % otabstop;
401 	}
402 	if (szmode) {
403 		WriteChrN(ZENSP, i / 2);
404 		i = i % 2;
405 	}
406 	WriteChrN(HanSP, i);
407 }
408 
409 
410 void
WriteNC(const uchar * p,int n)411 WriteNC(const uchar *p, int n)
412 /* ʸ���� p ���� n �Х��Ȥ��������Τޤ޽��ʴ����������Ѵ��⤷�ʤ��� */
413 /* ���楳���ɽ����ѡ��ƥ����Ƚ��Ϥˤ� WriteN ��Ȥ� */
414 {
415 	assert(p != NULL);
416 	assert(n >= 0);
417 
418 	MadaResetChk();
419 	if (!nocntrlmode) {
420 		while (--n >= 0)
421 			WriteC(*p++);
422 	}
423 }
424 
425 
426 void
WriteN(const uchar * p,int n)427 WriteN(const uchar *p, int n)
428 /* ʸ���� p ���� n �Х��Ƚ� */
429 {
430 	assert(p != NULL);
431 	assert(n >= 0);
432 
433 	while (--n >= 0)
434 		Write1(*p++);
435 }
436 
437 
438 void
WriteNN(const uchar * p,int n)439 WriteNN(const uchar *p, int n)
440 /* ʸ���� p ���� n �Х��Ƚ������Ԥν�����ȼ���� */
441 {
442 	assert(p != NULL);
443 	assert(n >= 0);
444 
445 	while (--n >= 0) {
446 		if (*p == '\n')
447 			WriteNewLine();
448 		else if (printpageflag)
449 			Write1(*p);
450 		p++;
451 	}
452 }
453 
454 
455 void
WriteChr(unsigned c)456 WriteChr(unsigned c)
457 /* 1 ʸ������ */
458 {
459 	if (Is1B(c)) {
460 		Write1(c);
461 	} else {
462 		Write1(Moji_1(c));
463 		Write1(Moji_2(c));
464 	}
465 }
466 
467 
468 void
WriteCntrl(def_t * cntrl)469 WriteCntrl(def_t *cntrl)
470 /* ���楳���ɡʥꥹ�ȡˤ���� */
471 {
472 	if (cntrl) {
473 		ExtractCntrl(cntrl, 0);
474 		if (!nocntrlmode && clength) {
475 			WriteNC(cbuf, clength);
476 		}
477 	}
478 }
479 
480 
481 void
WriteResetCntrl(def_t * cntrl,def_t * rescntrl)482 WriteResetCntrl(def_t *cntrl, def_t *rescntrl)
483 {
484 	ExtractResetCntrl(cntrl, rescntrl);
485 	WriteNC(cbuf, clength);
486 }
487 
488 
489 
490 void
WriteNHW(const uchar * p,int n,int hwmode)491 WriteNHW(const uchar *p, int n, int hwmode)
492 /* hwmode �ʤ� ANK ���Х���Ⱦ�Ѥ��Ѵ�����ۤ��� WriteN ��Ʊ�� */
493 {
494 	unsigned c;
495 
496 	if (!hwmode)
497 		WriteN(p, n);
498 	else
499 		while (--n >= 0) {
500 			c = Moji(p);
501 			if (Is1B(c)) {
502 				WriteChr(ANKtoHW(c));
503 				p++;
504 			} else {
505 				WriteChr(c);
506 				p += 2;
507 				--n;
508 			}
509 		}
510 }
511 
512 
513 void
WriteChrN(unsigned c,int n)514 WriteChrN(unsigned c, int n)
515 /* c �� n �Ľ� */
516 {
517 	assert(n >= 0);
518 
519 	while (--n >= 0) {
520 		WriteChr(c);
521 	}
522 }
523 
524 
525 /******/
526 
527 void
WriteTerminate(void)528 WriteTerminate(void)
529 {
530 	WriteCntrl(c_terminate);
531 }
532 
533 
534 /************************** WriteNewLine ************************************/
535 
536 void
WriteNewLine(void)537 WriteNewLine(void)
538 /* ���Ԥ���Ϥ��� */
539 {
540 	int n = (linespmode ? splines + 1 : 1);
541 
542 	/* �ޤ�ʸ������������� */
543 	if (!madaindentflag && printpageflag) {
544 		if (c_attr)
545 			WriteResetCntrl(c_attr, c_areset);
546 		if (c_wide)
547 			WriteResetCntrl(c_wide, c_wreset);
548 		if (c_vexpand)
549 			WriteResetCntrl(c_vexpand, c_vreset);
550 		if (c_qexpand)
551 			WriteResetCntrl(c_qexpand, c_qreset);
552 		if (c_half)
553 			WriteResetCntrl(c_half, c_hreset);
554 	}
555 	pagecutflag = OFF;
556 	if (zerolinefeedmode) {			/* �����ԥ⡼�ɤʤ� */
557 		Write1('\r');
558 		--n;
559 	}
560 	while (--n >= 0) {
561 		if (printpageflag)
562 			WriteNL();
563 
564 		lineno++;				/* ���Ϲ��ֹ������� */
565 		if (params != NULL && params->count != -1) {
566 			/* �ѥ�᡼�������å������ꡤ�������դ��ʤ� */
567 			if (--(params->count) == 0) {	/* ������ȥ������ƣ��ˤʤ�� */
568 				PopParam(0);				/* ���Υѥ顼���ξ��֤����� */
569 			}
570 		}
571 		if (!plaintextmode && pagemode && pagelines && (long)lineno > pagelines) {
572 			pageendflag = ON;		/* ���ڡ�����ɬ�פ��Ȥ����ե饰 */
573 			pagecutflag = ON;		/* �ڡ������ڤ줿�Ȥ����ե饰 */
574 			break;					/* ���ڡ�������ΤǶ��ԤϤ⤦�Ф��ʤ� */
575 		}
576 	}
577 }
578 
579 
580 
581 
582 /************************** WritePage ************************************/
583 
584 #define _noffmode		(noffmode || moremode && conoutmode && !coninmode)
585 
586 static uchar *
PageType(const uchar * fstr)587 PageType(const uchar *fstr)
588 {
589 	if (!fstr)
590 		return NULL;
591 
592 	while (*fstr != '\0') {
593 		if (*fstr++ == '%') {
594 			while (isdigit(*fstr))
595 				fstr++;
596 			if (isalpha(*fstr) && !isalnum(*(fstr+1))) {
597 				switch (*fstr) {
598 				case 'p':
599 					return "%p";
600 				case 'i':
601 					return "%i";
602 				case 'I':
603 					return "%I";
604 				}
605 			}
606 			if (*fstr)
607 				fstr++;
608 		}
609 	}
610 	return NULL;
611 }
612 
613 
614 
615 static int
EqPageNo(const uchar * pagenostr)616 EqPageNo(const uchar *pagenostr)
617 {
618 	static uchar *pagetype = "%p";
619 	uchar buf[64];
620 
621 	if (absppmode) {			/* -pp3/�� �λ���褦�ʻ���ξ�� */
622 		pagetype = "%P";		/* ���Хڡ����ֹ� */
623 	} else if (phpfchgflag) {
624 								/* -pp/iv/�� �Τ褦�ʻ���ξ���
625 								   �إå�/�եå��ѹ�ľ��ʤ� */
626 		(pagetype = PageType(pfcenter)) ||
627 			(pagetype = PageType(pfright)) ||
628 			(pagetype = PageType(pfleft)) ||
629 			(pagetype = PageType(phcenter)) ||
630 			(pagetype = PageType(phright)) ||
631 			(pagetype = PageType(phleft)) ||
632 			(pagetype = "%p");	/* �ڡ����ֹ椬̵���ڡ�����ɸ����� */
633 	}
634 
635 	EvalString(buf, pagetype);
636 	return equ(buf, pagenostr);
637 }
638 
639 
640 
641 static void
CheckPrintPage(void)642 CheckPrintPage(void)
643 {
644 	static exitflag = OFF;
645 
646 	if (exitflag) {
647 			WriteTerminate();
648 			exit(EXIT_SUCCESS);				/* �����Ǥ⤦�����ޤ��ˤ��� */
649 	}
650 	if (printpagemadaflag) {
651 		/* �ޤ��������ϥڡ�����ã���Ƥ��ʤ���� */
652 		if (!*pagebegin || EqPageNo(pagebegin) ||
653 					absppmode && !strcmp((char *)pagebegin, "0")) {
654 			/* �������ϥڡ�������ʸ��������
655 			   ���� pageno ��Ʊ���ʤ� */
656 			printpagemadaflag = OFF;
657 			printpageflag = ON;
658 			pagestepcnt = 0;
659 			if (pagestep == 0 || *pageend && EqPageNo(pageend))
660 				exitflag = ON;		/* ��λ�ڡ�����Ʊ���ʤ餳�Υڡ����ǽ��� */
661 		} else {
662 			printpageflag = OFF;
663 		}
664 	} else {
665 		/* ���Ǥ˰������ϥڡ�����ã���Ƥ����� */
666 		if (++pagestepcnt == pagestep) {
667 			pagestepcnt = 0;
668 			printpageflag = ON;
669 		} else {
670 			printpageflag = OFF;
671 		}
672 		if (pagestep == 0 || *pageend && EqPageNo(pageend)) {
673 			/* ������λ�ڡ�������ʸ�������Ǥʤ���
674 			   ���� pageno ��Ʊ���ʤ� */
675 			exitflag = ON;	/* ���줬�Ǹ�Υڡ����ǡ����ˤϽ��� */
676 		}
677 	}
678 }
679 
680 
681 
682 #define SameCntrlSeq(a, b) 	((a) == (b) || (a) && (b) && \
683 							(a)->rpllen == (b)->rpllen && \
684 						 	!memcmp((a)->rpl, (b)->rpl, (a)->rpllen))
685 
686 #define WriteNewPage()													\
687     do {																\
688 		if (!(c_newpage && (WriteCntrl(c_newpage), !nocntrlmode)))		\
689 			WriteC('\f');												\
690 	} while (0)
691 
692 void
WritePage(void)693 WritePage(void)
694 /* �ڡ����եå������ڡ������ڡ����إå�����Ϥ��� */
695 {
696 	def_t  *c_kicode0 = c_kicode;
697 	def_t  *c_kocode0 = c_kocode;
698 
699 	if (plaintextmode)
700 		return;
701 
702 	MadaResetChk();				/* �ޤ��ꥻ�åȥ����ɤ�Ф��Ƥ��ʤ���нФ� */
703 
704 	if (pagewidth == 0) {
705 		PageSetting();
706 	}
707 
708 	/* �ե���Ȥʤɤ��Ѥ��Ƥ���н���������楳���ɽ��� */
709 	if (c_font) {
710 		WriteResetCntrl(c_font, c_freset);	/* ������ʥ⡼�ɤ�ꥻ�å� */
711 	}
712 	if (c_pagefont) {
713 		WriteCntrl(c_pagefont);		/* �Ϥ���λ��Τˤ��� */
714 	}
715 	if (!SameCntrlSeq(c_pagekocode, c_kocode)) {
716 		WriteCntrl(c_pagekocode);
717 	}
718 	c_kicode = c_pagekicode;
719 	c_kocode = c_pagekocode;
720 	if (pagemode && (lineno > 1 || phpfchgflag && !firstphmadaflag)) {
721 		if (printpageflag)
722 			WritePageFooter();
723 	}
724 	if (!pagemode || lineno > 1 || phpfchgflag && !firstphmadaflag) {
725 		if (!_noffmode && printpageflag)		/* _noffmode �Ǥʤ���� */
726 			WriteNewPage();						/* ���ڡ��������ɽ��� */
727 		pageno++;
728 		abspageno++;
729 	}
730 	if (newpageno != -1) {
731 		pageno = newpageno;		/* �ڡ����ֹ�ν���ͤ�Ϳ����줿��� */
732 		newpageno = -1;
733 	}
734 	if (phpfchgflag)			/* �ڡ����إå����եå����ѹ������ä���� */
735 		ChangePf();				/* �������ڡ����եå����åȤ��� */
736 
737 	CheckPrintPage();		/* ��������ڡ������ɤ��������å� */
738 	if (pagemode && (lineno > 1 || phpfchgflag || firstphmadaflag)) {
739 		if (!eotflag) {				/* �ƥ����Ȥν���Ǥʤ���� */
740 			if (printpageflag)
741 				WritePageHeader();
742 		}
743 	}
744 	if (!eotflag && c_font) {
745 		/* �ե���Ȥ�����ʤɤ�����С��������楳���ɽ��� */
746 		WriteCntrl(c_font);
747 	}
748 	c_kicode = c_kicode0;
749 	c_kocode = c_kocode0;
750 	if (!SameCntrlSeq(c_pagekocode, c_kocode)) {
751 		WriteCntrl(c_kocode);
752 	}
753 	phpfchgflag = OFF;
754 	firstphmadaflag = OFF;
755 	pageendflag = OFF;
756 	lineno = 1;
757 	spacelines = linespaced = 0;
758 }
759 
760 void
PageSetting(void)761 PageSetting(void)
762 {
763 	pagewidth = width;
764 	pagehwmode = anktohwmode && !nocntrlmode;
765 	ResetCntrl(&c_pagekicode);
766 	ResetCntrl(&c_pagekocode);
767 	ResetCntrl(&c_pagefont);
768 	c_pagekicode = DupCntrl(c_kicode);
769 	c_pagekocode = DupCntrl(c_kocode);
770 	c_pagefont = DupCntrl(c_font);
771 			/* ���ΤȤ��Υե���Ȥ�ڡ����إå��եå��ѤȤ��Ƶ������� */
772 	c_font = NULL;			/* ���ޤξ��֤�ɸ��ˤ��뤿�ᡢ����ϥ��ꥢ */
773 }
774 
775 
776 void
WritePageHeader(void)777 WritePageHeader(void)
778 {
779 	int n1, n2, n3;
780 	int n;
781 	int m;
782 	unsigned sp = PAGEHWMODE_SP;
783 	uchar *buf = NULL;
784 
785 	for (n = 0; n < pagetopsp; n++) {
786 		WriteNL();						/* �ڡ�����;�� */
787 	}
788 	if (phlines) {
789 		WriteCntrl(c_reset2);
790 		WriteChrN(SP, pageoffset);			/* ��;�� */
791 		buf = AEvalString(&n1, phleft);
792 		WriteNHW(buf, n1, pagehwmode);
793 		XFree((voidstar)buf);
794 		buf = AEvalString(&n2, phcenter);
795 		if (*phcenter || *phright) {
796 			WriteChrN(sp, (m = (pagewidth - n2) / 2 - n1) < 0 ? 0 : m);
797 			WriteNHW(buf, n2, pagehwmode);
798 		}
799 		XFree((voidstar)buf);
800 		buf = AEvalString(&n3, phright);
801 		if (*phright) {
802 			WriteChrN(sp, (pagewidth - n2) / 2 + ((pagewidth - n2) % 2)
803 							 - n3 + (m < 0 ? m : 0));
804 			WriteNHW(buf, n3, pagehwmode);
805 		}
806 		XFree((voidstar)buf);
807 	}
808 	for (n = 0; n < phlines; n++) {
809 		WriteNL();
810 	}
811 }
812 
813 
814 void
WritePageFooter(void)815 WritePageFooter(void)
816 {
817 	int n1, n2, n3;
818 	int n;
819 	int m;
820 	unsigned sp = PAGEHWMODE_SP;
821 	uchar *buf = NULL;
822 	int pagebtmflag = _noffmode || pagebtmmode;	/* ��;����Ϥ��꤫ */
823 
824 	if (!*pfleft && !*pfcenter && !*pfright && !pagebtmflag)
825 		return;
826 
827 	for (n = lineno; n < (pagelines + pflines); n++) {
828 		WriteNL();
829 	}
830 	if (pflines) {
831 		WriteCntrl(c_reset2);
832 		WriteChrN(SP, pageoffset);			/* ��;�� */
833 		buf = AEvalString(&n1, pfleft);
834 		WriteNHW(buf, n1, pagehwmode);
835 		XFree((voidstar)buf);
836 		buf = AEvalString(&n2, pfcenter);
837 		if (*pfcenter || *pfright) {
838 			WriteChrN(sp, (m = (pagewidth - n2) / 2 - n1) < 0 ? 0 : m);
839 			WriteNHW(buf, n2, pagehwmode);
840 		}
841 		XFree((voidstar)buf);
842 		buf = AEvalString(&n3, pfright);
843 		if (*pfright) {
844 			WriteChrN(sp, (pagewidth - n2) / 2 + ((pagewidth - n2) % 2)
845 							 - n3 + (m < 0 ? m : 0));
846 			WriteNHW(buf, n3, pagehwmode);
847 		}
848 		XFree((voidstar)buf);
849 	}
850 	if (pflines || (long)lineno <= pagelines) {
851 		WriteNL();
852 	}
853 	if (pagebtmflag) {
854 		for (n = 0; n < pagebtmsp; n++) {
855 			WriteNL();						/* �ڡ�����;�� */
856 		}
857 	}
858 }
859 
860 /**************************************************************************/
861 
862 
863 static int
IsWide(int col)864 IsWide(int col)
865 {
866 	if (wexpmodeno == 0)
867 		return 0;
868 	else if (col == x)
869 		return (c_wide || c_qexpand ? 1: 0);
870 	else {
871 		unsigned c = Moji(lbv[col]);
872 		return (IsHan(c) ? (lbv[col] == lbv[(col) + 1]) :
873 						   (lbv[col] == lbv[(col) + 2]));
874 	}
875 }
876 
877 static int
IsHalf(int col)878 IsHalf(int col)
879 {
880 	unsigned  c = Moji(lbv[col]);
881 
882 	if (wexpmodeno == 0)
883 		return 0;
884 	if (col == x)
885 		return (c_half ? 1: 0);
886 	return (!IsHan(c) && (lbv[col] != lbv[(col) + 1]));
887 }
888 
889 
890 /****************************** WriteLineAdj ********************************/
891 
892 static int fixpos;		/* ���ΰ��֤��夬����Ĵ����ǽ */
893 
894 static int
NextAdjPos(register int j)895 NextAdjPos(register int j)
896 {
897 	while (++j < adjposc) {
898 		if (chrexpflag) {
899 			if ((adjposv[j].mode == CHREXP_NEXTCHR ||
900 			     adjposv[j].mode == CHREXP_PREVCHR) &&
901 					(int)adjposv[j].x <= x)
902 
903 				return j;
904 		} else {
905 			if (adjposv[j].mode == CHREXP_SPADJ &&
906 					(int)adjposv[j].x > fixpos && (int)adjposv[j].x < x)
907 
908 				return j;
909 		}
910 	}
911 	return adjposc;
912 }
913 
914 void
WriteLineAdj(void)915 WriteLineAdj(void)
916 /* ��·����Ԥ��ʤ���饤��Хåե������Ƥ���Ϥ��� */
917 {
918 	int		i;				/* lbv[]'s index */
919 	int		j;				/* adjposv[]'s index */
920 	int		n;
921 	int		p, r, s;
922 	int		xstart;
923 	int		jstart;
924 	int		n_adjpos;
925 	int		iprev;
926 	int		i2;
927 	int		j2;
928 	int		mode;
929 	int		wide;
930 	uchar	*bp;
931 	uchar	*bp0;
932 	unsigned	c;
933 	unsigned	cprev;
934 	unsigned	expchr;
935 
936 	if (chrexpflag)
937 		/* ~>, ~< �䥻������ξ��Ϻ������Х�����ʤ��Ȥ���
938 		   ��˺����ˤ��� */
939 		migiyoriflag = OFF;
940 
941 	fixpos = (linebreak > 1) ? aindent : max(aindent, first_indent);
942 
943 	/* ���ڡ���Ĵ�����֤ο� n_adjpos ������� */
944 	jstart = NextAdjPos(-1);
945 	for (j2 = j = jstart, n_adjpos = 0; j < adjposc; j = NextAdjPos(j)) {
946 		j2 = j;
947 		n_adjpos++;
948 	}
949 
950 	n = width - x;			/* ʬ�ۤ��٤����ڡ��� */
951 
952 	if (n > 0 && n_adjpos > 0) {
953 		xstart = adjposv[jstart].x;
954 		if (xstart > 0)
955 			xstart = PrevCol(xstart);
956 		p = n / n_adjpos;	/* �����˺����ղä���륹�ڡ��� */
957 		r = n % n_adjpos;	/* p ����ʬ�ۤ���ΤǤ�;�äƤ��ޤ����ڡ��� */
958 		if (!chrexpflag && !bothadjmode && (r ? p+1 : p) > spadjlimit) {
959 			/* �̾��·���ǡ��ղä���륹�ڡ�����¿������ʤ� */
960 			xstart = x;			/* ��·������� */
961 			p = r = 0;
962 		} else if (!migiyoriflag) {
963 			/* �Ϥ���Τۤ��Υ��ڡ�����¿�������� */
964 			r = n_adjpos - r;
965 					/* p+1 ����ʬ�ۤ���ΤǤ�­��ʤ��ʤ륹�ڡ����� */
966 		}
967 	} else {
968 		xstart = x;
969 		p = r = 0;
970 	}
971 
972 	if (!snmode) {
973 		/* �����ˤϥ��ڡ���������ʤ� */
974 		DelSpaces();
975 		if (xstart > x)
976 			xstart = x;
977 	}
978 
979 	if (xstart > 0) {
980 		WriteLineNCol(xstart);			/* �ԤλϤ����ʬ����� */
981 
982 		if (xstart == x)
983 			return;						/* �����ǽ���� */
984 
985 		bp = lbv[xstart];
986 	} else {
987 		bp = lbuf;
988 	}
989 	for (j = jstart; j < adjposc; j = NextAdjPos(j)) {
990 		bp0 = bp;
991 		i = adjposv[j].x;
992 		iprev = i > 0 ? PrevCol(i) : 0;
993 		mode = adjposv[j].mode;
994 		bp = (i == 0) ? bp :
995 			 (mode == CHREXP_NEXTCHR) ? lbv[i] :
996 			 SkipMoji(lbv[iprev]);
997 		c = i < x ? Moji(bp) : SP;
998 		cprev = i > 0 ? Moji(lbv[iprev]) : SP;
999 
1000 		expchr = mode == CHREXP_NEXTCHR ? c :
1001 				 mode == CHREXP_PREVCHR ? cprev :
1002 				 SP;
1003 		if (expchr == SP)
1004 			expchr = HanSP;
1005 
1006 		WriteN(bp0, bp - bp0);
1007 
1008 		/* ʬ�ۤ������ο� n �� n_adjpos �dz���ڤ�ʤ����
1009 		   ��Ⱦ(migiyoriflag==ON)����Ⱦ(migiyoriflag==OFF)��
1010 		   ����¿��ʬ�ۤ��� */
1011 
1012 		s = p;
1013 		if (migiyoriflag ? r : !r)
1014 			s++;
1015 
1016 		wide = IsHan(expchr) ? 1 : 2;
1017 		if (!(mode == CHREXP_PREVCHR && i == 0)) {
1018 			if (IsWide(i2 = mode == CHREXP_NEXTCHR ? i : iprev))
1019 				wide *= 2;
1020 			if (wide > 1 && IsHalf(i2))
1021 				wide /= 2;
1022 		}
1023 		if (wide > 1) {
1024 			/* ���Ѱʾ�ʤ� */
1025 			int rem = s % wide;
1026 			s /= wide;
1027 			if (migiyoriflag)
1028 				r += rem;
1029 			else if (r > rem)
1030 				r -= rem;
1031 			else if (r && j < j2) {
1032 				s++;
1033 				r += wide - rem;
1034 			}
1035 		}
1036 		if (r)
1037 			--r;
1038 
1039 		if (wlmode) {
1040 			/* �Х��ȿ��³�ͭ��Υ⡼�ɤʤ� */
1041 			if (Is1B(expchr) ? (wlrem -= s) >= 0 &&
1042 								!Is1B(cprev) && !Is1B(c)
1043 							 : (wlrem -= 2 * s) >= 0 &&
1044 								Is1B(cprev) && Is1B(c)) {
1045 				/* �����ȴ����δ֤��������������� */
1046 				/* �ޤ����������������δ֤˴������������ */
1047 				wlrem -= (wkmode ? kikosize :
1048 						c_kicode ? c_kicode->rpllen : 0) * 2;
1049 				if (wlrem < 0) {
1050 					s = 0;
1051 				}
1052 			} else if (wlrem < 0) {
1053 				s = 0;
1054 			}
1055 		}
1056 
1057 		if (bp == lbv[x] && IsHanSp(expchr))
1058 			;	/* �����˥��ڡ���������뤳�ȤϤ��ʤ� */
1059 		else
1060 			WriteChrN(expchr, s);
1061 	}
1062 	if (bp != lbv[x])
1063 		WriteN(bp, lbv[x] - bp);
1064 
1065 	if (!chrexpflag)
1066 		migiyoriflag = !migiyoriflag;
1067 }
1068 
1069 
1070 
1071 /**************************************************************************/
1072 
1073 void
SetChrExpPos(int pos,int mode)1074 SetChrExpPos(int pos, int mode)
1075 {
1076 	switch (mode) {
1077 	case CHREXP_NEXTCHR:
1078 	case CHREXP_PREVCHR:
1079 		chrexpflag = ON;
1080 		break;
1081 	default:
1082 		;
1083 	}
1084 	if (adjposc < MAXADJPOSC) {
1085 		adjposv[adjposc].x = pos;
1086 		adjposv[adjposc++].mode = mode;
1087 	}
1088 }
1089 
1090 void
SetSpAdjPos(int pos)1091 SetSpAdjPos(int pos)
1092 {
1093 	SetChrExpPos(pos, CHREXP_SPADJ);
1094 }
1095 
1096 void
ResChrExp(void)1097 ResChrExp(void)
1098 {
1099 	chrexpflag = OFF;
1100 	adjposc = 0;
1101 }
1102 
1103 /*
1104  * Local variables:
1105  * mode: c
1106  * c-indent-level: 4
1107  * c-continued-statement-offset: 4
1108  * c-brace-offset: -4
1109  * c-argdecl-indent: 4
1110  * c-label-offset: -4
1111  * tab-width: 4
1112  * tab-stop-list: (4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80)
1113  * End:
1114  */
1115