aboutsummaryrefslogtreecommitdiffstats
path: root/z17.c
diff options
context:
space:
mode:
authorJeffrey H. Kingston <jeff@it.usyd.edu.au>2010-09-14 19:21:41 +0000
committerJeffrey H. Kingston <jeff@it.usyd.edu.au>2010-09-14 19:21:41 +0000
commit71bdb35d52747e6d7d9f55df4524d57c2966be94 (patch)
tree480ee5eefccc40d5f3331cc52d66f722fd19bfb9 /z17.c
parentb41263ea7578fa9742486135c762803b52794105 (diff)
downloadlout-71bdb35d52747e6d7d9f55df4524d57c2966be94.tar.gz
Lout 3.17.
git-svn-id: http://svn.savannah.nongnu.org/svn/lout/trunk@2 9365b830-b601-4143-9ba8-b4a8e2c3339c
Diffstat (limited to 'z17.c')
-rw-r--r--z17.c407
1 files changed, 407 insertions, 0 deletions
diff --git a/z17.c b/z17.c
new file mode 100644
index 0000000..f57c92b
--- /dev/null
+++ b/z17.c
@@ -0,0 +1,407 @@
+/*@z17.c:Gap Widths:GetGap()@*************************************************/
+/* */
+/* THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.17) */
+/* COPYRIGHT (C) 1991, 1999 Jeffrey H. Kingston */
+/* */
+/* Jeffrey H. Kingston (jeff@cs.usyd.edu.au) */
+/* Basser Department of Computer Science */
+/* The University of Sydney 2006 */
+/* AUSTRALIA */
+/* */
+/* This program is free software; you can redistribute it and/or modify */
+/* it under the terms of the GNU General Public License as published by */
+/* the Free Software Foundation; either Version 2, or (at your option) */
+/* any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU General Public License */
+/* along with this program; if not, write to the Free Software */
+/* Foundation, Inc., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA */
+/* */
+/* FILE: z17.c */
+/* MODULE: Gap Widths */
+/* EXTERNS: GetGap(), MinGap(), ExtraGap(), ActualGap(), EchoGap() */
+/* */
+/*****************************************************************************/
+#include "externs.h"
+
+
+/*****************************************************************************/
+/* */
+/* GetGap(x, style, res_gap, res_inc) */
+/* */
+/* Object x is expected to be a WORD or QWORD containing a gap: */
+/* */
+/* <gap> ::= [ <increment> ] <width> [ <mode> ] [ <nobreak> ] */
+/* ::= */
+/* */
+/* <nobreak> ::= u */
+/* <increment> ::= + | - */
+/* <width> ::= <unsigned number> <units> */
+/* <units> ::= c | i | p | m | f | s */
+/* ::= v | w | b | r | d | y | z */
+/* <mode> ::= e | h | x | o | k | t | n */
+/* */
+/* Set *res_gap to the gap in the strings of x; *res_inc is the increment. */
+/* The gap is calculated using the given style. */
+/* If the gap is empty, this is a synonym for 0ie. */
+/* If there is an error, GetGap prints a message and returns 0ie. */
+/* */
+/*****************************************************************************/
+#define setwidths(x, y) w = x; units(*res_gap) = y; break;
+
+void GetGap(OBJECT x, STYLE *style, GAP *res_gap, unsigned *res_inc)
+{ int w; float num;
+ FULL_CHAR *str;
+
+ debug2(DGW, DD, "GetGap( %s, %s, res_gap, res_inc )",
+ EchoObject(x), EchoStyle(style));
+
+ nobreak(*res_gap) = FALSE;
+ width(*res_gap) = 0; units(*res_gap) = FIXED_UNIT;
+ mode(*res_gap) = EDGE_MODE; *res_inc = GAP_ABS;
+
+ /* make sure we have a WORD or QWORD argument */
+ if( !is_word(type(x)) )
+ { Error(17, 1, "gap is not a simple word", WARN, &fpos(x));
+ debug1(DGW, DD, "GetGap failing (type(x) = %s)", Image(type(x)));
+ return;
+ }
+ str = string(x);
+
+ /* if word is empty, return 0ie */
+ if( *str == '\0' )
+ { debug0(DGW, DD, "GetGap returning (null word)");
+ return;
+ }
+
+ /* read the optional gap increment */
+ if( *str == CH_INCGAP ) *res_inc = GAP_INC, str++;
+ else if( *str == CH_DECGAP ) *res_inc = GAP_DEC, str++;
+
+ /* read the gap width */
+ if( sscanf((char *) str, "%f", &num) != 1 )
+ { Error(17, 2, "width missing from %s", WARN, &fpos(x), string(x));
+ Error(17, 3, "%s, %s and %s must be enclosed in double quotes",
+ WARN, &fpos(x), KW_VCAT_NJ, KW_HCAT_NJ, KW_ACAT_NJ);
+ debug0(DGW, DD, "GetGap failing (width missing)");
+ return;
+ }
+ while( numericchar(*str) ) str++;
+
+ /* read the compulsory units, calculate length, and check reasonableness */
+ switch( *str++ )
+ {
+ case CH_UNIT_CM: setwidths( num*CM, FIXED_UNIT );
+ case CH_UNIT_IN: setwidths( num*IN, FIXED_UNIT );
+ case CH_UNIT_PT: setwidths( num*PT, FIXED_UNIT );
+ case CH_UNIT_EM: setwidths( num*EM, FIXED_UNIT );
+ case CH_UNIT_FT: setwidths( num*FontSize(font(*style), x), FIXED_UNIT );
+ case CH_UNIT_SP: setwidths( num*width(space_gap(*style)), FIXED_UNIT );
+ case CH_UNIT_VS: setwidths( num*width(line_gap(*style)), FIXED_UNIT );
+ case CH_UNIT_YU: setwidths( num*yunit(*style), FIXED_UNIT );
+ case CH_UNIT_ZU: setwidths( num*zunit(*style), FIXED_UNIT );
+ case CH_UNIT_WD: setwidths( num*FR, NEXT_UNIT );
+ case CH_UNIT_BD: setwidths( num*FR, FRAME_UNIT );
+ case CH_UNIT_RL: setwidths( num*FR, AVAIL_UNIT );
+
+ case CH_UNIT_DG: if( *res_inc == GAP_DEC ) num = - num;
+ *res_inc = GAP_ABS;
+ while( num > 180.0 ) num -= 360.0;
+ while( num < -180.0 ) num += 360.0;
+ assert((num>=-180.0) && (num<=180.0), "GetGap: dg!");
+ setwidths( num*DG, DEG_UNIT );
+
+ default: Error(17, 4, "units letter missing from %s",
+ WARN, &fpos(x), string(x));
+ debug0(DGW, DD, "GetGap failing (units letter missing)");
+ return;
+ }
+
+ if( units(*res_gap) == AVAIL_UNIT && w > FR )
+ { Error(17, 5, "%.1fr too large (1.0r substituted)", WARN, &fpos(x), num);
+ w = FR;
+ }
+ width(*res_gap) = w;
+
+ /* read the optional gap mode */
+ switch( *str )
+ {
+ case CH_NOBREAK:
+ case '\0': mode(*res_gap) = EDGE_MODE; break;
+ case CH_MODE_EDGE: mode(*res_gap) = EDGE_MODE; str++; break;
+ case CH_MODE_HYPH: mode(*res_gap) = HYPH_MODE; str++; break;
+ case CH_MODE_MARK: mode(*res_gap) = MARK_MODE; str++; break;
+ case CH_MODE_OVER: mode(*res_gap) = OVER_MODE; str++; break;
+ case CH_MODE_KERN: mode(*res_gap) = KERN_MODE; str++; break;
+ case CH_MODE_TABL: mode(*res_gap) = TAB_MODE; str++; break;
+
+ default: Error(17, 7, "unknown gap mode in %s",
+ WARN, &fpos(x), string(x));
+ debug0(DGW, DD, "GetGap failing (spacing mode)");
+ return;
+ }
+
+ /* read the optional nobreak */
+ if( *str == CH_NOBREAK )
+ {
+ if( mode(*res_gap) == HYPH_MODE )
+ Error(17, 9, "replacing self-contradictory gap %s by breakable version",
+ WARN, &fpos(x), string(x));
+ else nobreak(*res_gap) = TRUE;
+ str++;
+ }
+
+ /* if string has not terminated, error */
+ if( *str != '\0' )
+ Error(17, 8, "invalid width or gap %s", WARN, &fpos(x), string(x));
+
+ debug2(DGW, DD, "GetGap returning (res_gap = %s, res_inc = %s)",
+ EchoGap(res_gap), Image( (int) *res_inc) );
+} /* end GetGap */
+
+
+/*@::MinGap()@****************************************************************/
+/* */
+/* FULL_LENGTH MinGap(a, b, c, xgap) */
+/* */
+/* Returns the minimum possible separation between the marks of two */
+/* objects with the given intervening gap. */
+/* The first object has fwd value a, the second has back value b and fwd c. */
+/* */
+/*****************************************************************************/
+
+FULL_LENGTH MinGap(FULL_LENGTH a, FULL_LENGTH b, FULL_LENGTH c, GAP *xgap)
+{ FULL_LENGTH res; int w;
+ switch( units(*xgap) )
+ {
+ case FIXED_UNIT: w = width(*xgap);
+ break;
+
+ case FRAME_UNIT: w = 0;
+ break;
+
+ case AVAIL_UNIT: w = 0;
+ break;
+
+ case NEXT_UNIT: w = width(*xgap) * (b + c) / FR;
+ break;
+
+ default: assert(FALSE, "MinGap: units");
+ break;
+ }
+ switch( mode(*xgap) )
+ {
+ case NO_MODE: assert(FALSE, "MinGap: NO_MODE");
+ res = 0;
+ break;
+
+ case ADD_HYPH:
+ case HYPH_MODE:
+ case EDGE_MODE: res = find_min(MAX_FULL_LENGTH, a + w + b);
+ break;
+
+ case MARK_MODE: if( BackEnd != PLAINTEXT )
+ res = find_max(w, a + b + (FULL_LENGTH) (0.1 * w) );
+ else
+ res = find_max(w, a + b);
+ break;
+
+ case OVER_MODE: res = w;
+ break;
+
+ case KERN_MODE: res = find_max(find_max(a, b), w);
+ break;
+
+ case TAB_MODE: res = a + b;
+ break;
+
+ default: assert(FALSE, "MinGap: mode");
+ res = 0;
+ break;
+
+ }
+ debug5(DGW, DD, "MinGap( _,%s %s %s,%s ) = %s", EchoLength(a),
+ EchoGap(xgap), EchoLength(b), EchoLength(c), EchoLength(res) );
+ return res;
+} /* end MinGap */
+
+
+/*@::ExtraGap()@**************************************************************/
+/* */
+/* FULL_LENGTH ExtraGap(a, b, xgap, dir) */
+/* */
+/* Consider two objects, the first with forward length a, the second with */
+/* back length b. The objects are separated by the given gap. */
+/* If dir == FWD, ExtraGap returns the maximum amount that a could be */
+/* increased without increasing MinGap(a, b, c, xgap). */
+/* If dir == BACK, similarly for b. */
+/* */
+/*****************************************************************************/
+
+FULL_LENGTH ExtraGap(FULL_LENGTH a, FULL_LENGTH b, GAP *xgap, int dir)
+{ FULL_LENGTH tmp, res;
+ FULL_LENGTH w = units(*xgap) == FIXED_UNIT ? width(*xgap) : 0;
+ switch( mode(*xgap) )
+ {
+ case NO_MODE: assert(FALSE, "ExtraGap: NO_MODE");
+ res = 0;
+ break;
+
+ case ADD_HYPH:
+ case HYPH_MODE:
+ case EDGE_MODE: res = 0;
+ break;
+
+ case MARK_MODE: if( BackEnd != PLAINTEXT )
+ res = find_max(0, (FULL_LENGTH) (0.9 * w) - a - b);
+ else
+ res = find_max(0, w - a - b);
+ break;
+
+ case OVER_MODE: res = MAX_FULL_LENGTH;
+ break;
+
+ case KERN_MODE: tmp = find_max(a, find_max(b, w));
+ res = dir == BACK ? tmp - b : tmp - a;
+ break;
+
+ case TAB_MODE: res = 0;
+ break;
+
+ default: assert(FALSE, "ExtraGap: mode");
+ res = 0;
+ break;
+
+ }
+ debug5(DGW, DD, "ExtraGap( %s, %s, %s, %s ) = %s", EchoLength(a),
+ EchoLength(b), EchoGap(xgap), Image(dir), EchoLength(res));
+ return res;
+} /* end ExtraGap */
+
+
+/*@::ActualGap()@*************************************************************/
+/* */
+/* FULL_LENGTH ActualGap(prevf, b, f, xgap, frame_size, mk) */
+/* */
+/* Returns the actual separation between the marks of an object of size */
+/* (?, prevf) and an object of size (b, f) separated by gap *xgap in a */
+/* frame of size frame_size; the first object lies at mk in the frame, */
+/* where 0 <= mk <= frame_size. */
+/* */
+/*****************************************************************************/
+
+FULL_LENGTH ActualGap(FULL_LENGTH prevf, FULL_LENGTH b, FULL_LENGTH f,
+ GAP *xgap, FULL_LENGTH frame_size, FULL_LENGTH mk)
+{ FULL_LENGTH res; int w, w2;
+ switch( units(*xgap) )
+ {
+ case FIXED_UNIT: w = width(*xgap);
+ break;
+
+ case FRAME_UNIT: if( width(*xgap) > FR )
+ w = MAX_FULL_LENGTH;
+ else
+ w = (width(*xgap) * frame_size) / FR;
+ break;
+
+ case AVAIL_UNIT: w = (width(*xgap) * (frame_size - b - f)) / FR;
+ w = find_max(w, 0);
+ break;
+
+ case NEXT_UNIT: w = width(*xgap) * (b + f) / FR;
+ break;
+
+ default: assert(FALSE, "ActualGap: units");
+ break;
+ }
+ switch( mode(*xgap) )
+ {
+ case NO_MODE: Error(17, 10, "cannot continue after previous error(s)", FATAL, no_fpos);
+ assert(FALSE, "ActualGap: NO_MODE");
+ w2 = 0;
+ break;
+
+ case ADD_HYPH:
+ case HYPH_MODE:
+ case EDGE_MODE: w2 = prevf + w + b;
+ break;
+
+ case MARK_MODE: if( BackEnd != PLAINTEXT )
+ w2 = find_max(w, prevf + b + (FULL_LENGTH) (0.1 * w) );
+ else
+ w2 = find_max(w, prevf + b);
+ break;
+
+ case OVER_MODE: w2 = w;
+ break;
+
+ case KERN_MODE: w2 = find_max( find_max(prevf, b), w);
+ break;
+
+ case TAB_MODE: w2 = w + b - mk;
+ w2 = find_max(w2, prevf + b );
+ break;
+
+ default: assert(FALSE, "ActualGap: mode");
+ w2 = 0;
+ break;
+ }
+ res = find_min(MAX_FULL_LENGTH, w2);
+ debug7(DGW, D, "ActualGap( _,%s %s %s,%s; frame_size %s, mk %s ) = %s",
+ EchoLength(prevf), EchoGap(xgap), EchoLength(b), EchoLength(f),
+ EchoLength(frame_size), EchoLength(mk), EchoLength(res));
+ return res;
+} /* end ActualGap */
+
+
+/*@::EchoGap()@***************************************************************/
+/* */
+/* FULL_CHAR *EchoGap(xgap) */
+/* */
+/* Returns a static string showing the indicated xgap. */
+/* */
+/*****************************************************************************/
+#if DEBUG_ON
+
+FULL_CHAR *EchoGap(GAP *xgap)
+{ char *letter = "?ehxokt"; char c; FULL_CHAR *res;
+ char *u;
+ static int i = 0;
+ static char buff[3][20];
+ assert( mode(*xgap) <= 6, "EchoGap: mode(*xgap)" );
+ c = letter[mode(*xgap)];
+ u = nobreak(*xgap) ? "u" : "";
+ switch( units(*xgap) )
+ {
+ case 0: sprintf(buff[i], "(none)%c", c);
+ break;
+
+ case FIXED_UNIT: sprintf(buff[i], "%.1fc%c%s", (float) width(*xgap)/CM, c,u);
+ break;
+
+ case NEXT_UNIT: sprintf(buff[i], "%.1fw%c%s", (float) width(*xgap)/FR, c,u);
+ break;
+
+ case FRAME_UNIT: sprintf(buff[i], "%.1fb%c%s", (float) width(*xgap)/FR, c,u);
+ break;
+
+ case AVAIL_UNIT: sprintf(buff[i], "%.1fr%c%s", (float) width(*xgap)/FR, c,u);
+ break;
+
+ case DEG_UNIT: sprintf(buff[i], "%.1fd", (float) width(*xgap) / DG);
+ break;
+
+ default: assert(FALSE, "EchoGap: units");
+ break;
+
+ }
+ res = AsciiToFull(buff[i]);
+ i = (i + 1) % 3;
+ return res;
+} /* end EchoGap */
+#endif