summaryrefslogtreecommitdiff
path: root/Build/source/texk/web2c/xetexdir/xetex.web
diff options
context:
space:
mode:
authorKhaled Hosny <khaledhosny@eglug.org>2014-08-16 10:06:31 +0000
committerKhaled Hosny <khaledhosny@eglug.org>2014-08-16 10:06:31 +0000
commitcf417274d82f73f673cc9295d58e5f5190973edb (patch)
tree66429e222ddb03216c3b8b96d7354bd84d6a010b /Build/source/texk/web2c/xetexdir/xetex.web
parent5142e474120bd1dbb6b95524a28bb653ca73b139 (diff)
Update XeTeX
git-svn-id: svn://tug.org/texlive/trunk@34946 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/texk/web2c/xetexdir/xetex.web')
-rw-r--r--Build/source/texk/web2c/xetexdir/xetex.web2854
1 files changed, 1389 insertions, 1465 deletions
diff --git a/Build/source/texk/web2c/xetexdir/xetex.web b/Build/source/texk/web2c/xetexdir/xetex.web
index e3e179d4377..f3b9cbf809b 100644
--- a/Build/source/texk/web2c/xetexdir/xetex.web
+++ b/Build/source/texk/web2c/xetexdir/xetex.web
@@ -155,8 +155,11 @@
\font\ninerm=cmr9
\let\mc=\ninerm % medium caps for names like SAIL
-\input graphicx % \relectbox for XeTeX logo
-\def\XeTeX{X\kern-.125em\lower.5ex\hbox{\reflectbox{E}}\kern-.1667em\TeX}
+\def\mirror#1{%
+ \phantom{#1}%
+ \rlap{\special{pdf:btrans xscale -1}#1\special{pdf:etrans}}%
+}
+\def\XeTeX{X\kern-.125em\lower.5ex\hbox{\mirror{E}}\kern-.1667em\TeX}
\def\eTeX{$\varepsilon$-\TeX}
\font\revrm=xbmc10 % for right-to-left text
@@ -169,19 +172,7 @@
% "reflectedabout((.5[l,r],0),(.5[l,r],1));";
% input cmbx10
%+++++++++++++++++++++++++++++++++++++++++++++++++
-\ifx\beginL\undefined % this is TeX
- \def\XeT{X\kern-.125em\lower.5ex\hbox{E}\kern-.1667emT}
- \def\TeXeT{\TeX-\hbox{\revrm \XeT}} % for TeX-XeT
- \def\TeXXeT{\TeX-\hbox{\revrm -\XeT}} % for TeX--XeT
-\else
- \ifx\eTeXversion\undefined % this is \TeXeT
- \def\TeXeT{\TeX-{\revrm\beginR\TeX\endR}} % for TeX-XeT
- \def\TeXXeT{\TeX-{\revrm\beginR\TeX-\endR}} % for TeX--XeT
- \else % this is \eTeX
- \def\TeXeT{\TeX-{\TeXXeTstate=1\revrm\beginR\TeX\endR}} % for TeX-XeT
- \def\TeXXeT{\TeX-{\TeXXeTstate=1\revrm\beginR\TeX-\endR}} % for TeX--XeT
- \fi
-\fi
+\def\TeXeT{\TeX-{\revrm\beginR\TeX\endR}} % for TeX-XeT
\def\PASCAL{Pascal}
\def\ph{\hbox{Pascal-H}}
\def\pct!{{\char`\%}} % percent sign in ordinary text
@@ -3225,8 +3216,8 @@ material.
@d adjust_node=5 {|type| of an adjust node}
@d adjust_pre == subtype {|if subtype <>0| it is pre-adjustment}
@#{|append_list| is used to append a list to |tail|}
-@d append_list(#) == begin link(tail) := link(#); append_list_end
-@d append_list_end(#) == tail := #; end
+@d append_list(#) == begin link(tail):=link(#); append_list_end
+@d append_list_end(#) == tail:=#; end
@d adjust_ptr(#)==mem[#+1].int
{vertical list to be moved out of horizontal list}
@@ -3350,8 +3341,8 @@ than size and length fields, and there's no subsidiary C pointer.
begin
if native_glyph_info_ptr(#) <> null_ptr then begin
libc_free(native_glyph_info_ptr(#));
- native_glyph_info_ptr(#) := null_ptr;
- native_glyph_count(#) := 0;
+ native_glyph_info_ptr(#):=null_ptr;
+ native_glyph_count(#):=0;
end
end
@@ -3359,10 +3350,10 @@ than size and length fields, and there's no subsidiary C pointer.
var glyph_count:integer;
begin
if native_glyph_info_ptr(src) <> null_ptr then begin
- glyph_count := native_glyph_count(src);
- native_glyph_info_ptr(dest) := xmalloc_array(char, glyph_count * native_glyph_info_size);
+ glyph_count:=native_glyph_count(src);
+ native_glyph_info_ptr(dest):=xmalloc_array(char, glyph_count * native_glyph_info_size);
memcpy(native_glyph_info_ptr(dest), native_glyph_info_ptr(src), glyph_count * native_glyph_info_size);
- native_glyph_count(dest) := glyph_count;
+ native_glyph_count(dest):=glyph_count;
end
end;
@@ -3379,16 +3370,9 @@ A |pdf_node| is just like |pic_node|, but generate a different \.{XDV} file code
@d pic_node=42 {|subtype| in whatsits that hold picture file references}
@d pdf_node=43 {|subtype| in whatsits that hold PDF page references}
@#
-@d pdfbox_crop=1 {|pic_box_type| values in PDF nodes}
-@d pdfbox_media=2
-@d pdfbox_bleed=3
-@d pdfbox_trim=4
-@d pdfbox_art=5
-@#
@d pic_node_size=8 {must sync with \.{xetex.h}}
@d pic_path_length(#)==mem[#+4].hh.b0
@d pic_page(#)==mem[#+4].hh.b1
-@d pic_box_type(#)==mem[#+4].hh.rh {for PDF, unused in picfile}
@d pic_transform1(#)==mem[#+5].hh.lh
@d pic_transform2(#)==mem[#+5].hh.rh
@d pic_transform3(#)==mem[#+6].hh.lh
@@ -3859,15 +3843,15 @@ gubed
@p
procedure pdf_error(t, p: str_number);
begin
- normalize_selector;
- print_err("Error");
- if t <> 0 then begin
- print(" (");
- print(t);
- print(")");
- end;
- print(": "); print(p);
- succumb;
+ normalize_selector;
+ print_err("Error");
+ if t <> 0 then begin
+ print(" (");
+ print(t);
+ print(")");
+ end;
+ print(": "); print(p);
+ succumb;
end;
function prev_rightmost(s, e: pointer): pointer;
@@ -3875,16 +3859,16 @@ function prev_rightmost(s, e: pointer): pointer;
before |e|}
var p: pointer;
begin
- prev_rightmost := null;
- p := s;
+ prev_rightmost:=null;
+ p:=s;
+ if p = null then
+ return;
+ while link(p) <> e do begin
+ p:=link(p);
if p = null then
- return;
- while link(p) <> e do begin
- p := link(p);
- if p = null then
- return;
- end;
- prev_rightmost := p;
+ return;
+ end;
+ prev_rightmost:=p;
end;
function round_xn_over_d(@!x:scaled; @!n,@!d:integer):scaled;
@@ -3898,13 +3882,13 @@ u:=(x div @'100000)*n+(t div @'100000);
v:=(u mod d)*@'100000 + (t mod @'100000);
if u div d>=@'100000 then arith_error:=true
else u:=@'100000*(u div d) + (v div d);
-v := v mod d;
+v:=v mod d;
if 2*v >= d then
incr(u);
if positive then
- round_xn_over_d := u
+ round_xn_over_d:=u
else
- round_xn_over_d := -u;
+ round_xn_over_d:=-u;
end;
@* \[12] Displaying boxes.
@@ -4121,9 +4105,9 @@ else case type(p) of
print_esc("kern");
print_scaled(width(p));
if subtype(p) = left_side then
- print(" (left margin)")
+ print(" (left margin)")
else
- print(" (right margin)");
+ print(" (right margin)");
end;
math_node: @<Display math node |p|@>;
ligature_node: @<Display ligature |p|@>;
@@ -4304,9 +4288,9 @@ end;
procedure short_display_n(@!p, m:integer); {prints highlights of list |p|}
begin
- breadth_max := m;
- depth_threshold:=pool_size-pool_ptr-1;
- show_node_list(p); {the show starts at |p|}
+ breadth_max:=m;
+ depth_threshold:=pool_size-pool_ptr-1;
+ show_node_list(p); {the show starts at |p|}
end;
@* \[13] Destroying boxes.
@@ -4458,8 +4442,8 @@ kern_node,math_node,penalty_node: begin r:=get_node(small_node_size);
words:=small_node_size;
end;
margin_kern_node: begin
- r := get_node(margin_kern_node_size);
- words := margin_kern_node_size;
+ r:=get_node(margin_kern_node_size);
+ words:=margin_kern_node_size;
end;
ligature_node: begin r:=get_node(small_node_size);
mem[lig_char(r)]:=mem[lig_char(p)]; {copy |font| and |character|}
@@ -5330,8 +5314,8 @@ cat_code(invalid_code):=invalid_char; cat_code(null_code):=ignore;
for k:="0" to "9" do math_code(k):=hi(k + set_class_field(var_fam_class));
for k:="A" to "Z" do
begin cat_code(k):=letter; cat_code(k+"a"-"A"):=letter;@/
- math_code(k) := hi(k + set_family_field(1) + set_class_field(var_fam_class));
- math_code(k+"a"-"A") := hi(k+"a"-"A" + set_family_field(1) + set_class_field(var_fam_class));@/
+ math_code(k):=hi(k + set_family_field(1) + set_class_field(var_fam_class));
+ math_code(k+"a"-"A"):=hi(k+"a"-"A" + set_family_field(1) + set_class_field(var_fam_class));@/
lc_code(k):=k+"a"-"A"; lc_code(k+"a"-"A"):=k+"a"-"A";@/
uc_code(k):=k; uc_code(k+"a"-"A"):=k;@/
sf_code(k):=999;
@@ -6076,9 +6060,9 @@ A global boolean variable called |no_new_control_sequence| is set to
no_new_control_sequence:=true; {new identifiers are usually forbidden}
prim_next(0):=0; prim_text(0):=0;
for k:=1 to prim_size do prim[k]:=prim[0];
-prim_eq_level(0) := level_zero;
-prim_eq_type(0) := undefined_cs;
-prim_equiv(0) := null;
+prim_eq_level(0):=level_zero;
+prim_eq_type(0):=undefined_cs;
+prim_equiv(0):=null;
for k:=1 to prim_size do prim_eqtb[k]:=prim_eqtb[0];
next(hash_base):=0; text(hash_base):=0;
for k:=hash_base+1 to undefined_control_sequence-1 do hash[k]:=hash[hash_base];
@@ -6174,13 +6158,13 @@ var h:integer; {hash code}
@!j,@!l:integer;
begin
if s<256 then begin
- p := s;
+ p:=s;
if (p<0) or (prim_eq_level(p)<>level_one) then
- p := undefined_primitive;
+ p:=undefined_primitive;
end
else begin
j:=str_start_macro(s);
- if s = str_ptr then l := cur_length else l := length(s);
+ if s = str_ptr then l:=cur_length else l:=length(s);
@<Compute the primitive code |h|@>;
p:=h+prim_base; {we start searching here; note that |0<=h<hash_prime|}
loop@+begin if prim_text(p)>0 then if length(prim_text(p))=l then
@@ -8538,7 +8522,7 @@ end;
@!is_in_csname: boolean;
@ @<Set init...@>=
-is_in_csname := false;
+is_in_csname:=false;
@ @<Expand a nonmacro@>=
begin if tracing_commands>1 then show_cur_cmd_chr;
@@ -8598,19 +8582,19 @@ does not work, because approach would not survive roundtripping to a
temporary file.
@<Implement \.{\\primitive}@>=
-begin save_scanner_status := scanner_status; scanner_status:=normal;
+begin save_scanner_status:=scanner_status; scanner_status:=normal;
get_token; scanner_status:=save_scanner_status;
if cur_cs < hash_base then
- cur_cs := prim_lookup(cur_cs-257)
+ cur_cs:=prim_lookup(cur_cs-257)
else
- cur_cs := prim_lookup(text(cur_cs));
+ cur_cs:=prim_lookup(text(cur_cs));
if cur_cs<>undefined_primitive then begin
- t := prim_eq_type(cur_cs);
+ t:=prim_eq_type(cur_cs);
if t>max_command then begin
- cur_cmd := t;
- cur_chr := prim_equiv(cur_cs);
- cur_tok := (cur_cmd*max_char_val)+cur_chr;
- cur_cs := 0;
+ cur_cmd:=t;
+ cur_chr:=prim_equiv(cur_cs);
+ cur_tok:=(cur_cmd*max_char_val)+cur_chr;
+ cur_cs :=0;
goto reswitch;
end
else begin
@@ -8645,12 +8629,12 @@ the variables |p| and |q| are reserved for token-list building.
@ @<Manufacture a control...@>=
begin r:=get_avail; p:=r; {head of the list of characters}
-b := is_in_csname; is_in_csname := true;
+b:=is_in_csname; is_in_csname:=true;
repeat get_x_token;
if cur_cs=0 then store_new_token(cur_tok);
until cur_cs<>0;
if cur_cmd<>end_cs_name then @<Complain about missing \.{\\endcsname}@>;
-is_in_csname := b;
+is_in_csname:=b;
@<Look up the characters of list |r| in the hash table, and set |cur_cs|@>;
flush_list(r);
if eq_type(cur_cs)=undefined_cs then
@@ -9435,12 +9419,12 @@ the codes for its extensions: |eTeX_version_code|, \dots\ .
@d XeTeX_count_glyphs_code=XeTeX_int+1
-@d XeTeX_count_variations_code=XeTeX_int+2
-@d XeTeX_variation_code=XeTeX_int+3
-@d XeTeX_find_variation_by_name_code=XeTeX_int+4
-@d XeTeX_variation_min_code=XeTeX_int+5
-@d XeTeX_variation_max_code=XeTeX_int+6
-@d XeTeX_variation_default_code=XeTeX_int+7
+@d XeTeX_count_variations_code=XeTeX_int+2 {Deprecated}
+@d XeTeX_variation_code=XeTeX_int+3 {Deprecated}
+@d XeTeX_find_variation_by_name_code=XeTeX_int+4 {Deprecated}
+@d XeTeX_variation_min_code=XeTeX_int+5 {Deprecated}
+@d XeTeX_variation_max_code=XeTeX_int+6 {Deprecated}
+@d XeTeX_variation_default_code=XeTeX_int+7 {Deprecated}
@d XeTeX_count_features_code=XeTeX_int+8
@d XeTeX_feature_code_code=XeTeX_int+9
@@ -9606,10 +9590,10 @@ if m>=input_line_no_code then
pdf_shell_escape_code:
begin
if shellenabledp then begin
- if restrictedshell then cur_val := 2
- else cur_val := 1;
+ if restrictedshell then cur_val:=2
+ else cur_val:=1;
end
- else cur_val := 0;
+ else cur_val:=0;
end;
@/@<Cases for fetching an integer value@>@/
end; {there are no other cases}
@@ -9651,14 +9635,14 @@ begin scan_font_ident;
if m=0 then scanned_result(hyphen_char[cur_val])(int_val)
else if m=1 then scanned_result(skew_char[cur_val])(int_val)
else begin
- n := cur_val;
- if is_native_font(n) then scan_glyph_number(n)
- else scan_char_num;
- k := cur_val;
- case m of
- lp_code_base: scanned_result(get_cp_code(n, k, left_side))(int_val);
- rp_code_base: scanned_result(get_cp_code(n, k, right_side))(int_val);
- end;
+ n:=cur_val;
+ if is_native_font(n) then scan_glyph_number(n)
+ else scan_char_num;
+ k:=cur_val;
+ case m of
+ lp_code_base: scanned_result(get_cp_code(n, k, left_side))(int_val);
+ rp_code_base: scanned_result(get_cp_code(n, k, right_side))(int_val);
+ end;
end;
end
@@ -9803,7 +9787,7 @@ begin scan_int;
print_err("Bad active XeTeX math code");
help2("Since I ignore class and family for active math chars,")@/
("I changed this one to ""1FFFFF."); int_error(cur_val);
- cur_val := active_math_char;
+ cur_val:=active_math_char;
end
end else if math_char_field(cur_val)>biggest_usv then begin
print_err("Bad XeTeX math character code");
@@ -9916,7 +9900,7 @@ end;
negative:=false;
repeat @<Get the next non-blank non-call token@>;
if cur_tok=other_token+"-" then
- begin negative := not negative; cur_tok:=other_token+"+";
+ begin negative:=not negative; cur_tok:=other_token+"+";
end;
until cur_tok<>other_token+"+"
@@ -10054,7 +10038,7 @@ if not shortcut then
end;
end;
if cur_val<0 then {in this case |f=0|}
- begin negative := not negative; negate(cur_val);
+ begin negative:=not negative; negate(cur_val);
end;
if requires_units then begin
@<Scan units and set |cur_val| to $x\cdot(|cur_val|+f/2^{16})$, where there
@@ -11062,9 +11046,9 @@ if_primitive_code: begin
get_next;
scanner_status:=save_scanner_status;
if cur_cs < hash_base then
- m := prim_lookup(cur_cs-257)
+ m:=prim_lookup(cur_cs-257)
else
- m := prim_lookup(text(cur_cs));
+ m:=prim_lookup(text(cur_cs));
b :=((cur_cmd<>undefined_cs) and
(m<>undefined_primitive) and
(cur_cmd=prim_eq_type(m)) and
@@ -13025,30 +13009,21 @@ file. Parameters |i|, |num|, |den|, |mag|, |k|, and |x| are explained below.
\yskip\noindent Commands 250--255 are undefined in normal \.{DVI} files, but
the following commands are used in \.{XDV} files.
-\yskip\hang|reflect| 250 |b[1]|. Begin (|b=0|) or end (|b=1|) a (possibly
-recursive) reflected segment.
+\yskip\hang|begin_reflect| 250. Begin a (possibly recursive) reflected segment.
-\yskip\hang|pic_file| 251 |flags[1]| |t[4][6]| |p[2]| |len[2]| |path[l]|.
- |flags=0| for raster image, and |1| for \.{PDF}.
- |t| is transform matrix.
- |p| is page number from the graphic file (0-based).
- |len| is length of pathname.
- |path| is pathname of graphic file.
+\yskip\hang|end_reflect| 251. End a (possibly recursive) reflected segment.
\yskip\hang\vbox{\halign{#&#\hfil\cr
-|define_native_font| 252 & |k[4]| |s[4]| |flags[2]| |lenps[1]| |lenfam[1]| |lensty[1]| |ps[lenps]| |fam[lenfam]| |sty[lensty]|\cr
+|define_native_font| 252 & |k[4]| |s[4]| |flags[2]| |l[1]| |n[l]| |i[4]|\cr
& |if (flags and COLORED) then| |rgba[4]|\cr
& |if (flags and EXTEND) then| |extend[4]|\cr
& |if (flags and SLANT) then| |slant[4]|\cr
& |if (flags and EMBOLDEN) then| |embolden[4]|\cr
-& |if (flags and VARIATIONS) then| |numvars[2]| |axes[4nv]| |values[4nv]|\cr
}}
-\yskip\hang|set_glyph_array| 253 |w[4]| |k[2]| |xy[8k]| |g[2k]|.
+\yskip\hang|set_glyphs| 253 |w[4]| |k[2]| |xy[8k]| |g[2k]|.
-\yskip\hang|set_glyph_string| 254 |w[4]| |k[2]| |x[4k]| |g[2k]|.
-
-\yskip\noindent Command 255 is undefined in normal \.{XDV} files.
+\yskip\noindent Commands 254--255 is undefined in normal \.{XDV} files.
@ @d set_char_0=0 {typeset character 0 and move right}
@d set1=128 {typeset a character and move right}
@@ -13077,21 +13052,18 @@ recursive) reflected segment.
@d pre=247 {preamble}
@d post=248 {postamble beginning}
@d post_post=249 {postamble ending}
-
-@d reflect=250 {begin or end a reflected segment}
-@d pic_file=251 {embed picture or PDF}
+@d begin_reflect=250 {begin a reflected segment (not normally allowed)}
+@d end_reflect=251 {end a reflected segment (not normally allowed)}
@d define_native_font=252 {define native font}
-@d set_glyph_array=253 {sequence of glyphs with individual x-y coordinates}
-@d set_glyph_string=254 {sequence of glyphs, all at the current y-position}
+@d set_glyphs=253 {sequence of glyphs with individual x-y coordinates}
@ The preamble contains basic information about the file as a whole. As
stated above, there are six parameters:
$$\hbox{|@!i[1]| |@!num[4]| |@!den[4]| |@!mag[4]| |@!k[1]| |@!x[k]|.}$$
-The |i| byte identifies \.{DVI} format; in \XeTeX\ this byte is set to~5, as we
+The |i| byte identifies \.{DVI} format; in \XeTeX\ this byte is set to~6, as we
have new \.{DVI} opcodes, while in \TeX82 it is always set to~2. (The value
|i=3| is used for an extended format that allows a mixture of right-to-left and
-left-to-right typesetting. Prre-1.0 \XeTeX\ releases using Mac~OS~X-specific
-data types used |i=4|.)
+left-to-right typesetting. Older versions of \XeTeX\ used |i=4| and |i=5|.)
The next two parameters, |num| and |den|, are positive integers that define
the units of measurement; they are the numerator and denominator of a
@@ -13114,7 +13086,7 @@ users to override the |mag|~setting when a \.{DVI} file is being printed.)
Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not
interpreted further. The length of comment |x| is |k|, where |0<=k<256|.
-@d id_byte=5 {identifies the kind of \.{DVI} files described here}
+@d id_byte=6 {identifies the kind of \.{DVI} files described here}
@ Font definitions for a given font number |k| contain further parameters
$$\hbox{|c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.}$$
@@ -13403,12 +13375,12 @@ most 256 different fonts per job, |fnt_def1| is always used as the command code.
@p procedure dvi_native_font_def(@!f:internal_font_number);
var
- font_def_length, i: integer;
+ font_def_length, i: integer;
begin
- dvi_out(define_native_font);
- dvi_four(f-font_base-1);
- font_def_length := make_font_def(f);
- for i := 0 to font_def_length - 1 do dvi_out(xdv_buffer[i]);
+ dvi_out(define_native_font);
+ dvi_four(f-font_base-1);
+ font_def_length:=make_font_def(f);
+ for i:=0 to font_def_length - 1 do dvi_out(xdv_buffer[i]);
end;
procedure dvi_font_def(@!f:internal_font_number);
@@ -13821,91 +13793,91 @@ end;
@d is_glyph_node(#) == (((#)<>null and (not is_char_node(#)) and (type(#) = whatsit_node) and (subtype(#) = glyph_node)))
@<Merge sequences of words using AAT fonts and inter-word spaces into single nodes@>=
-p := list_ptr(this_box);
-prev_p := this_box+list_offset;
+p:=list_ptr(this_box);
+prev_p:=this_box+list_offset;
while p<>null do begin
if link(p) <> null then begin {not worth looking ahead at the end}
if is_native_word_node(p) and (font_area[native_font(p)] = aat_font_flag)
and (font_letter_space[native_font(p)] = 0) then begin
{got a word in an AAT font, might be the start of a run}
- r := p; {|r| is start of possible run}
- k := native_length(r);
- q := link(p);
+ r:=p; {|r| is start of possible run}
+ k:=native_length(r);
+ q:=link(p);
check_next:
@<Advance |q| past ignorable nodes@>;
if (q <> null) and not is_char_node(q) then begin
if (type(q) = glue_node) and (subtype(q) = normal) and (glue_ptr(q) = font_glue[native_font(r)]) then begin
{found a normal space; if the next node is another word in the same font, we'll merge}
- q := link(q);
+ q:=link(q);
@<Advance |q| past ignorable nodes@>;
if is_native_word_node(q) and (native_font(q) = native_font(r)) then begin
- p := q; {record new tail of run in |p|}
- k := k + 1 + native_length(q);
- q := link(q);
+ p:=q; {record new tail of run in |p|}
+ k:=k + 1 + native_length(q);
+ q:=link(q);
goto check_next;
end;
goto end_node_run;
end;
if is_native_word_node(q) and (native_font(q) = native_font(r)) then begin
- p := q; {record new tail of run in |p|}
- q := link(q);
+ p:=q; {record new tail of run in |p|}
+ q:=link(q);
goto check_next;
end
end;
end_node_run: {now |r| points to first |native_word_node| of the run, and |p| to the last}
if p <> r then begin {merge nodes from |r| to |p| inclusive; total text length is |k|}
str_room(k);
- k := 0; {now we'll use this as accumulator for total width}
- q := r;
+ k:=0; {now we'll use this as accumulator for total width}
+ q:=r;
loop begin
if type(q) = whatsit_node then begin
if subtype(q) = native_word_node then begin
- for j := 0 to native_length(q)-1 do
+ for j:=0 to native_length(q)-1 do
append_char(get_native_char(q, j));
- k := k + width(q);
+ k:=k + width(q);
end
end else if type(q) = glue_node then begin
append_char(" ");
- g := glue_ptr(q);
- k := k + width(g);
+ g:=glue_ptr(q);
+ k:=k + width(g);
if g_sign <> normal then begin
if g_sign = stretching then begin
if stretch_order(g) = g_order then begin
- k := k + round(float(glue_set(this_box)) * stretch(g))
+ k:=k + round(float(glue_set(this_box)) * stretch(g))
end
end else begin
if shrink_order(g) = g_order then begin
- k := k - round(float(glue_set(this_box)) * shrink(g))
+ k:=k - round(float(glue_set(this_box)) * shrink(g))
end
end
end
end;
{discretionary and deleted nodes can be discarded here}
if q = p then break
- else q := link(q);
+ else q:=link(q);
end;
done:
- q := new_native_word_node(native_font(r), cur_length);
- link(prev_p) := q;
- for j := 0 to cur_length - 1 do
+ q:=new_native_word_node(native_font(r), cur_length);
+ link(prev_p):=q;
+ for j:=0 to cur_length - 1 do
set_native_char(q, j, str_pool[str_start_macro(str_ptr) + j]);
- link(q) := link(p);
- link(p) := null;
+ link(q):=link(p);
+ link(p):=null;
flush_node_list(r);
- width(q) := k;
+ width(q):=k;
set_justified_native_glyphs(q);
- p := q;
- pool_ptr := str_start_macro(str_ptr); {flush the temporary string data}
+ p:=q;
+ pool_ptr:=str_start_macro(str_ptr); {flush the temporary string data}
end
end;
- prev_p := p;
+ prev_p:=p;
end;
- p := link(p);
+ p:=link(p);
end
@ @<Advance |q| past ignorable nodes@>=
while (q <> null) and (not is_char_node(q)) and (type(q) = disc_node) do
- q := link(q)
+ q:=link(q)
@ We ought to give special care to the efficiency of one part of |hlist_out|,
since it belongs to \TeX's inner loop. When a |char_node| is encountered,
@@ -14493,59 +14465,58 @@ function char_pw(p: pointer; side: small_number): scaled;
var f: internal_font_number;
c: integer;
begin
- char_pw := 0;
- if side = left_side then
- last_leftmost_char := null
- else
- last_rightmost_char := null;
- if p = null then
- return;
+ char_pw:=0;
+ if side = left_side then
+ last_leftmost_char:=null
+ else
+ last_rightmost_char:=null;
+ if p = null then
+ return;
- { native word }
- if is_native_word_node(p) then begin
- if native_glyph_info_ptr(p) <> null_ptr then begin
- f := native_font(p);
- char_pw := round_xn_over_d(quad(f), get_native_word_cp(p, side), 1000);
- end;
- return;
+ { native word }
+ if is_native_word_node(p) then begin
+ if native_glyph_info_ptr(p) <> null_ptr then begin
+ f:=native_font(p);
+ char_pw:=round_xn_over_d(quad(f), get_native_word_cp(p, side), 1000);
end;
+ return;
+ end;
- { glyph node }
- if is_glyph_node(p) then begin
- f := native_font(p);
- char_pw := round_xn_over_d(quad(f), get_cp_code(f, native_glyph(p), side), 1000);
- return;
- end;
+ { glyph node }
+ if is_glyph_node(p) then begin
+ f:=native_font(p);
+ char_pw:=round_xn_over_d(quad(f), get_cp_code(f, native_glyph(p), side), 1000);
+ return;
+ end;
- { char node or ligature; same like pdftex }
- if not is_char_node(p) then begin
- if type(p) = ligature_node then
- p := lig_char(p)
- else
- return;
- end;
- f := font(p);
- c := get_cp_code(f, character(p), side);
- case side of
- left_side:
- last_leftmost_char := p;
- right_side:
- last_rightmost_char := p;
- endcases;
- if c = 0 then
- return;
- char_pw :=
- round_xn_over_d(quad(f), c, 1000);
+ { char node or ligature; same like pdftex }
+ if not is_char_node(p) then begin
+ if type(p) = ligature_node then
+ p:=lig_char(p)
+ else
+ return;
+ end;
+ f:=font(p);
+ c:=get_cp_code(f, character(p), side);
+ case side of
+ left_side:
+ last_leftmost_char:=p;
+ right_side:
+ last_rightmost_char:=p;
+ endcases;
+ if c = 0 then
+ return;
+ char_pw:=round_xn_over_d(quad(f), c, 1000);
end;
function new_margin_kern(w: scaled; p: pointer; side: small_number): pointer;
var k: pointer;
begin
- k := get_node(margin_kern_node_size);
- type(k) := margin_kern_node;
- subtype(k) := side;
- width(k) := w;
- new_margin_kern := k;
+ k:=get_node(margin_kern_node_size);
+ type(k):=margin_kern_node;
+ subtype(k):=side;
+ width(k):=w;
+ new_margin_kern:=k;
end;
@ Here now is |hpack|, which contains few if any surprises.
@@ -14656,7 +14627,7 @@ to make a deletion.
@!pre_adjust_tail: pointer;
@ @<Set init...@>=
-pre_adjust_tail := null;
+pre_adjust_tail:=null;
@ Materials in \.{\\vadjust} used with \.{pre} keyword will be appended to
|pre_adjust_tail| instead of |adjust_tail|.
@@ -14664,9 +14635,9 @@ pre_adjust_tail := null;
@d update_adjust_list(#) == begin
if # = null then
confusion("pre vadjust");
- link(#) := adjust_ptr(p);
+ link(#):=adjust_ptr(p);
while link(#) <> null do
- # := link(#);
+ #:=link(#);
end
@<Transfer node |p| to the adjustment list@>=
@@ -14676,7 +14647,7 @@ begin while link(q)<>p do q:=link(q);
update_adjust_list(pre_adjust_tail)
else
update_adjust_list(adjust_tail);
- p := link(p); free_node(link(q), small_node_size);
+ p:=link(p); free_node(link(q), small_node_size);
end
else begin link(adjust_tail):=p; adjust_tail:=p; p:=link(p);
end;
@@ -15569,18 +15540,18 @@ macro capabilities. This seems a bit ugly, but it works.
@d mathsy(#)==font_info[#+param_base[f]].sc
@d define_mathsy_end(#)==
- # := rval;
+ #:=rval;
end
@d define_mathsy_body(#)==
var
f: integer;
rval: scaled;
begin
- f := fam_fnt(2 + size_code);
+ f:=fam_fnt(2 + size_code);
if is_new_mathfont(cur_f) then
- rval := get_native_mathsy_param(cur_f, #)
+ rval:=get_native_mathsy_param(cur_f, #)
else
- rval := mathsy(#);
+ rval:=mathsy(#);
define_mathsy_end
@d define_mathsy_accessor(#)==function #(size_code: integer): scaled; define_mathsy_body
@@ -15612,18 +15583,18 @@ omitted (since it is always |cur_size| when we refer to such parameters).
@d mathex(#)==font_info[#+param_base[f]].sc
@d define_mathex_end(#)==
- # := rval;
+ #:=rval;
end
@d define_mathex_body(#)==
var
f: integer;
rval: scaled;
begin
- f := fam_fnt(3 + cur_size);
+ f:=fam_fnt(3 + cur_size);
if is_new_mathfont(cur_f) then
- rval := get_native_mathex_param(cur_f, #)
+ rval:=get_native_mathex_param(cur_f, #)
else
- rval := mathex(#);
+ rval:=mathex(#);
define_mathex_end
@d define_mathex_accessor(#)==function #:scaled; define_mathex_body
@@ -15642,348 +15613,348 @@ call |set_native_metrics(node)| if that is required.
@<Declare subroutines for |new_character|@>=
function new_native_word_node(@!f:internal_font_number;@!n:integer):pointer;
var
- l: integer;
- q: pointer;
+ l: integer;
+ q: pointer;
begin
- l := native_node_size + (n * sizeof(UTF16_code) + sizeof(memory_word) - 1) div sizeof(memory_word);
+ l:=native_node_size + (n * sizeof(UTF16_code) + sizeof(memory_word) - 1) div sizeof(memory_word);
- q := get_node(l);
- type(q) := whatsit_node;
- subtype(q) := native_word_node;
+ q:=get_node(l);
+ type(q):=whatsit_node;
+ subtype(q):=native_word_node;
- native_size(q) := l;
- native_font(q) := f;
- native_length(q) := n;
+ native_size(q):=l;
+ native_font(q):=f;
+ native_length(q):=n;
- native_glyph_count(q) := 0;
- native_glyph_info_ptr(q) := null_ptr;
+ native_glyph_count(q):=0;
+ native_glyph_info_ptr(q):=null_ptr;
- new_native_word_node := q;
+ new_native_word_node:=q;
end;
function new_native_character(@!f:internal_font_number;@!c:UnicodeScalar):pointer;
var
- p: pointer;
- i, len: integer;
+ p: pointer;
+ i, len: integer;
begin
- if font_mapping[f] <> 0 then begin
- if c > @"FFFF then begin
- str_room(2);
- append_char((c - @"10000) div 1024 + @"D800);
- append_char((c - @"10000) mod 1024 + @"DC00);
- end
- else begin
- str_room(1);
- append_char(c);
+ if font_mapping[f] <> 0 then begin
+ if c > @"FFFF then begin
+ str_room(2);
+ append_char((c - @"10000) div 1024 + @"D800);
+ append_char((c - @"10000) mod 1024 + @"DC00);
+ end
+ else begin
+ str_room(1);
+ append_char(c);
+ end;
+ len:=apply_mapping(font_mapping[f], addressof(str_pool[str_start_macro(str_ptr)]), cur_length);
+ pool_ptr:=str_start_macro(str_ptr); { flush the string, as we'll be using the mapped text instead }
+
+ i:=0;
+ while i < len do begin
+ if (mapped_text[i] >= @"D800) and (mapped_text[i] < @"DC00) then begin
+ c:=(mapped_text[i] - @"D800) * 1024 + mapped_text[i+1] - @"DC00 + @"10000;
+ if map_char_to_glyph(f, c) = 0 then begin
+ char_warning(f, c);
end;
- len := apply_mapping(font_mapping[f], addressof(str_pool[str_start_macro(str_ptr)]), cur_length);
- pool_ptr := str_start_macro(str_ptr); { flush the string, as we'll be using the mapped text instead }
-
- i := 0;
- while i < len do begin
- if (mapped_text[i] >= @"D800) and (mapped_text[i] < @"DC00) then begin
- c := (mapped_text[i] - @"D800) * 1024 + mapped_text[i+1] - @"DC00 + @"10000;
- if map_char_to_glyph(f, c) = 0 then begin
- char_warning(f, c);
- end;
- i := i + 2;
- end
- else begin
- if map_char_to_glyph(f, mapped_text[i]) = 0 then begin
- char_warning(f, mapped_text[i]);
- end;
- i := i + 1;
- end;
+ i:=i + 2;
+ end
+ else begin
+ if map_char_to_glyph(f, mapped_text[i]) = 0 then begin
+ char_warning(f, mapped_text[i]);
end;
+ i:=i + 1;
+ end;
+ end;
- p := new_native_word_node(f, len);
- for i := 0 to len-1 do begin
- set_native_char(p, i, mapped_text[i]);
- end
+ p:=new_native_word_node(f, len);
+ for i:=0 to len-1 do begin
+ set_native_char(p, i, mapped_text[i]);
+ end
+ end
+ else begin
+ if tracing_lost_chars > 0 then
+ if map_char_to_glyph(f, c) = 0 then begin
+ char_warning(f, c);
+ end;
+
+ p:=get_node(native_node_size + 1);
+ type(p):=whatsit_node;
+ subtype(p):=native_word_node;
+
+ native_size(p):=native_node_size + 1;
+ native_glyph_count(p):=0;
+ native_glyph_info_ptr(p):=null_ptr;
+ native_font(p):=f;
+
+ if c > @"FFFF then begin
+ native_length(p):=2;
+ set_native_char(p, 0, (c - @"10000) div 1024 + @"D800);
+ set_native_char(p, 1, (c - @"10000) mod 1024 + @"DC00);
end
else begin
- if tracing_lost_chars > 0 then
- if map_char_to_glyph(f, c) = 0 then begin
- char_warning(f, c);
- end;
-
- p := get_node(native_node_size + 1);
- type(p) := whatsit_node;
- subtype(p) := native_word_node;
-
- native_size(p) := native_node_size + 1;
- native_glyph_count(p) := 0;
- native_glyph_info_ptr(p) := null_ptr;
- native_font(p) := f;
-
- if c > @"FFFF then begin
- native_length(p) := 2;
- set_native_char(p, 0, (c - @"10000) div 1024 + @"D800);
- set_native_char(p, 1, (c - @"10000) mod 1024 + @"DC00);
- end
- else begin
- native_length(p) := 1;
- set_native_char(p, 0, c);
- end;
+ native_length(p):=1;
+ set_native_char(p, 0, c);
end;
+ end;
- set_native_metrics(p, XeTeX_use_glyph_metrics);
+ set_native_metrics(p, XeTeX_use_glyph_metrics);
- new_native_character := p;
+ new_native_character:=p;
end;
procedure font_feature_warning(featureNameP:void_pointer; featLen:integer;
- settingNameP:void_pointer; setLen:integer);
+ settingNameP:void_pointer; setLen:integer);
var
- i: integer;
+ i: integer;
begin
- begin_diagnostic;
- print_nl("Unknown ");
- if setLen > 0 then begin
- print("selector `");
- print_utf8_str(settingNameP, setLen);
- print("' for ");
- end;
- print("feature `");
- print_utf8_str(featureNameP, featLen);
- print("' in font `");
- i := 1;
- while ord(name_of_file[i]) <> 0 do begin
- print_visible_char(name_of_file[i]); { this is already UTF-8 }
- incr(i);
- end;
- print("'.");
- end_diagnostic(false);
+ begin_diagnostic;
+ print_nl("Unknown ");
+ if setLen > 0 then begin
+ print("selector `");
+ print_utf8_str(settingNameP, setLen);
+ print("' for ");
+ end;
+ print("feature `");
+ print_utf8_str(featureNameP, featLen);
+ print("' in font `");
+ i:=1;
+ while ord(name_of_file[i]) <> 0 do begin
+ print_visible_char(name_of_file[i]); { this is already UTF-8 }
+ incr(i);
+ end;
+ print("'.");
+ end_diagnostic(false);
end;
procedure font_mapping_warning(mappingNameP:void_pointer;
- mappingNameLen:integer;
- warningType:integer); { 0: just logging; 1: file not found; 2: can't load }
+ mappingNameLen:integer;
+ warningType:integer); { 0: just logging; 1: file not found; 2: can't load }
var
- i: integer;
+ i: integer;
begin
- begin_diagnostic;
- if warningType=0 then print_nl("Loaded mapping `")
- else print_nl("Font mapping `");
- print_utf8_str(mappingNameP, mappingNameLen);
- print("' for font `");
- i := 1;
- while ord(name_of_file[i]) <> 0 do begin
- print_visible_char(name_of_file[i]); { this is already UTF-8 }
- incr(i);
- end;
- case warningType of
- 1: print("' not found.");
- 2: begin print("' not usable;");
- print_nl("bad mapping file or incorrect mapping type.");
- end;
- othercases print("'.")
- endcases;
- end_diagnostic(false);
+ begin_diagnostic;
+ if warningType=0 then print_nl("Loaded mapping `")
+ else print_nl("Font mapping `");
+ print_utf8_str(mappingNameP, mappingNameLen);
+ print("' for font `");
+ i:=1;
+ while ord(name_of_file[i]) <> 0 do begin
+ print_visible_char(name_of_file[i]); { this is already UTF-8 }
+ incr(i);
+ end;
+ case warningType of
+ 1: print("' not found.");
+ 2: begin print("' not usable;");
+ print_nl("bad mapping file or incorrect mapping type.");
+ end;
+ othercases print("'.")
+ endcases;
+ end_diagnostic(false);
end;
procedure graphite_warning;
var
- i: integer;
+ i: integer;
begin
- begin_diagnostic;
- print_nl("Font `");
- i := 1;
- while ord(name_of_file[i]) <> 0 do begin
- print_visible_char(name_of_file[i]); { this is already UTF-8 }
- incr(i);
- end;
- print("' does not support Graphite. Trying OpenType layout instead.");
- end_diagnostic(false);
+ begin_diagnostic;
+ print_nl("Font `");
+ i:=1;
+ while ord(name_of_file[i]) <> 0 do begin
+ print_visible_char(name_of_file[i]); { this is already UTF-8 }
+ incr(i);
+ end;
+ print("' does not support Graphite. Trying OpenType layout instead.");
+ end_diagnostic(false);
end;
function load_native_font(u: pointer; nom, aire:str_number; s: scaled): internal_font_number;
label
- done;
+ done;
const
- first_math_fontdimen = 10;
+ first_math_fontdimen = 10;
var
- k, num_font_dimens: integer;
- font_engine: void_pointer; {really an CFDictionaryRef or XeTeXLayoutEngine}
- actual_size: scaled; {|s| converted to real size, if it was negative}
- p: pointer; {for temporary |native_char| node we'll create}
- ascent, descent, font_slant, x_ht, cap_ht: scaled;
- f: internal_font_number;
- full_name: str_number;
+ k, num_font_dimens: integer;
+ font_engine: void_pointer; {really an CFDictionaryRef or XeTeXLayoutEngine}
+ actual_size: scaled; {|s| converted to real size, if it was negative}
+ p: pointer; {for temporary |native_char| node we'll create}
+ ascent, descent, font_slant, x_ht, cap_ht: scaled;
+ f: internal_font_number;
+ full_name: str_number;
begin
- { on entry here, the full name is packed into |name_of_file| in UTF8 form }
+ { on entry here, the full name is packed into |name_of_file| in UTF8 form }
- load_native_font := null_font;
+ load_native_font:=null_font;
- font_engine := find_native_font(name_of_file + 1, s);
- if font_engine = 0 then goto done;
+ font_engine:=find_native_font(name_of_file + 1, s);
+ if font_engine = 0 then goto done;
- if s>=0 then
- actual_size := s
- else begin
- if (s <> -1000) then
- actual_size := xn_over_d(loaded_font_design_size,-s,1000)
- else
- actual_size := loaded_font_design_size;
- end;
+ if s>=0 then
+ actual_size:=s
+ else begin
+ if (s <> -1000) then
+ actual_size:=xn_over_d(loaded_font_design_size,-s,1000)
+ else
+ actual_size:=loaded_font_design_size;
+ end;
- { look again to see if the font is already loaded, now that we know its canonical name }
- str_room(name_length);
- for k := 1 to name_length do
- append_char(name_of_file[k]);
- full_name := make_string; { not |slow_make_string| because we'll flush it if the font was already loaded }
+ { look again to see if the font is already loaded, now that we know its canonical name }
+ str_room(name_length);
+ for k:=1 to name_length do
+ append_char(name_of_file[k]);
+ full_name:=make_string; { not |slow_make_string| because we'll flush it if the font was already loaded }
- for f:=font_base+1 to font_ptr do
- if (font_area[f] = native_font_type_flag) and str_eq_str(font_name[f], full_name) and (font_size[f] = actual_size) then begin
- release_font_engine(font_engine, native_font_type_flag);
- flush_string;
- load_native_font := f;
- goto done;
- end;
+ for f:=font_base+1 to font_ptr do
+ if (font_area[f] = native_font_type_flag) and str_eq_str(font_name[f], full_name) and (font_size[f] = actual_size) then begin
+ release_font_engine(font_engine, native_font_type_flag);
+ flush_string;
+ load_native_font:=f;
+ goto done;
+ end;
- if (native_font_type_flag = otgr_font_flag) and isOpenTypeMathFont(font_engine) then
- num_font_dimens := first_math_fontdimen + lastMathConstant
- else
- num_font_dimens := 8;
+ if (native_font_type_flag = otgr_font_flag) and isOpenTypeMathFont(font_engine) then
+ num_font_dimens:=first_math_fontdimen + lastMathConstant
+ else
+ num_font_dimens:=8;
- if (font_ptr = font_max) or (fmem_ptr + num_font_dimens > font_mem_size) then begin
- @<Apologize for not loading the font, |goto done|@>;
- end;
+ if (font_ptr = font_max) or (fmem_ptr + num_font_dimens > font_mem_size) then begin
+ @<Apologize for not loading the font, |goto done|@>;
+ end;
- { we've found a valid installed font, and have room }
- incr(font_ptr);
- font_area[font_ptr] := native_font_type_flag; { set by |find_native_font| to either |aat_font_flag| or |ot_font_flag| }
+ { we've found a valid installed font, and have room }
+ incr(font_ptr);
+ font_area[font_ptr]:=native_font_type_flag; { set by |find_native_font| to either |aat_font_flag| or |ot_font_flag| }
- { store the canonical name }
- font_name[font_ptr] := full_name;
+ { store the canonical name }
+ font_name[font_ptr]:=full_name;
- font_check[font_ptr].b0 := 0;
- font_check[font_ptr].b1 := 0;
- font_check[font_ptr].b2 := 0;
- font_check[font_ptr].b3 := 0;
- font_glue[font_ptr] := null;
- font_dsize[font_ptr] := loaded_font_design_size;
- font_size[font_ptr] := actual_size;
+ font_check[font_ptr].b0:=0;
+ font_check[font_ptr].b1:=0;
+ font_check[font_ptr].b2:=0;
+ font_check[font_ptr].b3:=0;
+ font_glue[font_ptr]:=null;
+ font_dsize[font_ptr]:=loaded_font_design_size;
+ font_size[font_ptr]:=actual_size;
- if (native_font_type_flag = aat_font_flag) then begin
- aat_get_font_metrics(font_engine, addressof(ascent), addressof(descent),
- addressof(x_ht), addressof(cap_ht), addressof(font_slant))
- end else begin
- ot_get_font_metrics(font_engine, addressof(ascent), addressof(descent),
- addressof(x_ht), addressof(cap_ht), addressof(font_slant));
- end;
+ if (native_font_type_flag = aat_font_flag) then begin
+ aat_get_font_metrics(font_engine, addressof(ascent), addressof(descent),
+ addressof(x_ht), addressof(cap_ht), addressof(font_slant))
+ end else begin
+ ot_get_font_metrics(font_engine, addressof(ascent), addressof(descent),
+ addressof(x_ht), addressof(cap_ht), addressof(font_slant));
+ end;
- height_base[font_ptr] := ascent;
- depth_base[font_ptr] := -descent;
+ height_base[font_ptr]:=ascent;
+ depth_base[font_ptr]:=-descent;
- font_params[font_ptr] := num_font_dimens; {we add an extra \.{\\fontdimen8} |:= cap_height|; then OT math fonts have a bunch more}
- font_bc[font_ptr] := 0;
- font_ec[font_ptr] := 65535;
- font_used[font_ptr] := false;
- hyphen_char[font_ptr] := default_hyphen_char;
- skew_char[font_ptr] := default_skew_char;
- param_base[font_ptr] := fmem_ptr-1;
+ font_params[font_ptr]:=num_font_dimens; {we add an extra \.{\\fontdimen8} |:= cap_height|; then OT math fonts have a bunch more}
+ font_bc[font_ptr]:=0;
+ font_ec[font_ptr]:=65535;
+ font_used[font_ptr]:=false;
+ hyphen_char[font_ptr]:=default_hyphen_char;
+ skew_char[font_ptr]:=default_skew_char;
+ param_base[font_ptr]:=fmem_ptr-1;
- font_layout_engine[font_ptr] := font_engine;
- font_mapping[font_ptr] := 0; {don't use the mapping, if any, when measuring space here}
- font_letter_space[font_ptr] := loaded_font_letter_space;
+ font_layout_engine[font_ptr]:=font_engine;
+ font_mapping[font_ptr]:=0; {don't use the mapping, if any, when measuring space here}
+ font_letter_space[font_ptr]:=loaded_font_letter_space;
@# {measure the width of the space character and set up font parameters}
- p := new_native_character(font_ptr, " ");
- s := width(p) + loaded_font_letter_space;
- free_node(p, native_size(p));
-
- font_info[fmem_ptr].sc := font_slant; {|slant|}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := s; {|space| = width of space character}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := s div 2; {|space_stretch| = 1/2 * space}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := s div 3; {|space_shrink| = 1/3 * space}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := x_ht; {|x_height|}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := font_size[font_ptr]; {|quad| = font size}
+ p:=new_native_character(font_ptr, " ");
+ s:=width(p) + loaded_font_letter_space;
+ free_node(p, native_size(p));
+
+ font_info[fmem_ptr].sc:=font_slant; {|slant|}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=s; {|space| = width of space character}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=s div 2; {|space_stretch| = 1/2 * space}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=s div 3; {|space_shrink| = 1/3 * space}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=x_ht; {|x_height|}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=font_size[font_ptr]; {|quad| = font size}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=s div 3; {|extra_space| = 1/3 * space}
+ incr(fmem_ptr);
+ font_info[fmem_ptr].sc:=cap_ht; {|cap_height|}
+ incr(fmem_ptr);
+
+ if num_font_dimens = first_math_fontdimen + lastMathConstant then begin
+ font_info[fmem_ptr].int:=num_font_dimens; { \.{\\fontdimen9} |:=| number of assigned fontdimens }
incr(fmem_ptr);
- font_info[fmem_ptr].sc := s div 3; {|extra_space| = 1/3 * space}
- incr(fmem_ptr);
- font_info[fmem_ptr].sc := cap_ht; {|cap_height|}
- incr(fmem_ptr);
-
- if num_font_dimens = first_math_fontdimen + lastMathConstant then begin
- font_info[fmem_ptr].int := num_font_dimens; { \.{\\fontdimen9} |:=| number of assigned fontdimens }
- incr(fmem_ptr);
- for k := 0 to lastMathConstant do begin
- font_info[fmem_ptr].sc := get_ot_math_constant(font_ptr, k);
- incr(fmem_ptr);
- end;
+ for k:=0 to lastMathConstant do begin
+ font_info[fmem_ptr].sc:=get_ot_math_constant(font_ptr, k);
+ incr(fmem_ptr);
end;
+ end;
- font_mapping[font_ptr] := loaded_font_mapping;
- font_flags[font_ptr] := loaded_font_flags;
+ font_mapping[font_ptr]:=loaded_font_mapping;
+ font_flags[font_ptr]:=loaded_font_flags;
- load_native_font := font_ptr;
+ load_native_font:=font_ptr;
done:
end;
procedure do_locale_linebreaks(s: integer; len: integer);
var
- offs, prevOffs, i: integer;
- use_penalty, use_skip: boolean;
+ offs, prevOffs, i: integer;
+ use_penalty, use_skip: boolean;
begin
- if (XeTeX_linebreak_locale = 0) or (len = 1) then begin
- link(tail) := new_native_word_node(main_f, len);
- tail := link(tail);
- for i := 0 to len - 1 do
- set_native_char(tail, i, native_text[s + i]);
+ if (XeTeX_linebreak_locale = 0) or (len = 1) then begin
+ link(tail):=new_native_word_node(main_f, len);
+ tail:=link(tail);
+ for i:=0 to len - 1 do
+ set_native_char(tail, i, native_text[s + i]);
+ set_native_metrics(tail, XeTeX_use_glyph_metrics);
+ end else begin
+ use_skip:=XeTeX_linebreak_skip <> zero_glue;
+ use_penalty:=XeTeX_linebreak_penalty <> 0 or not use_skip;
+ linebreak_start(main_f, XeTeX_linebreak_locale, native_text + s, len);
+ offs:=0;
+ repeat
+ prevOffs:=offs;
+ offs:=linebreak_next;
+ if offs > 0 then begin
+ if prevOffs <> 0 then begin
+ if use_penalty then
+ tail_append(new_penalty(XeTeX_linebreak_penalty));
+ if use_skip then
+ tail_append(new_param_glue(XeTeX_linebreak_skip_code));
+ end;
+ link(tail):=new_native_word_node(main_f, offs - prevOffs);
+ tail:=link(tail);
+ for i:=prevOffs to offs - 1 do
+ set_native_char(tail, i - prevOffs, native_text[s + i]);
set_native_metrics(tail, XeTeX_use_glyph_metrics);
- end else begin
- use_skip := XeTeX_linebreak_skip <> zero_glue;
- use_penalty := XeTeX_linebreak_penalty <> 0 or not use_skip;
- linebreak_start(main_f, XeTeX_linebreak_locale, native_text + s, len);
- offs := 0;
- repeat
- prevOffs := offs;
- offs := linebreak_next;
- if offs > 0 then begin
- if prevOffs <> 0 then begin
- if use_penalty then
- tail_append(new_penalty(XeTeX_linebreak_penalty));
- if use_skip then
- tail_append(new_param_glue(XeTeX_linebreak_skip_code));
- end;
- link(tail) := new_native_word_node(main_f, offs - prevOffs);
- tail := link(tail);
- for i := prevOffs to offs - 1 do
- set_native_char(tail, i - prevOffs, native_text[s + i]);
- set_native_metrics(tail, XeTeX_use_glyph_metrics);
- end;
- until offs < 0;
- end
+ end;
+ until offs < 0;
+ end
end;
procedure bad_utf8_warning;
begin
- begin_diagnostic;
- print_nl("Invalid UTF-8 byte or sequence");
- if terminal_input then print(" in terminal input")
- else begin
- print(" at line ");
- print_int(line);
- end;
- print(" replaced by U+FFFD.");
- end_diagnostic(false);
+ begin_diagnostic;
+ print_nl("Invalid UTF-8 byte or sequence");
+ if terminal_input then print(" in terminal input")
+ else begin
+ print(" at line ");
+ print_int(line);
+ end;
+ print(" replaced by U+FFFD.");
+ end_diagnostic(false);
end;
function get_input_normalization_state: integer;
begin
- if eqtb=nil then get_input_normalization_state:=0 { may be called before eqtb is initialized }
- else get_input_normalization_state:=XeTeX_input_normalization_state;
+ if eqtb=nil then get_input_normalization_state:=0 { may be called before eqtb is initialized }
+ else get_input_normalization_state:=XeTeX_input_normalization_state;
end;
function get_tracing_fonts_state: integer;
begin
- get_tracing_fonts_state:=XeTeX_tracing_fonts_state;
+ get_tracing_fonts_state:=XeTeX_tracing_fonts_state;
end;
@ We also need to compute the change in style between mlists and their
@@ -19015,81 +18986,81 @@ distinguishable by the condition |cur_p=null|.
@<Declare subprocedures for |line_break|@>=
procedure push_node(p: pointer);
begin
- if hlist_stack_level > max_hlist_stack then
- pdf_error("push_node", "stack overflow");
- hlist_stack[hlist_stack_level] := p;
- hlist_stack_level := hlist_stack_level + 1;
+ if hlist_stack_level > max_hlist_stack then
+ pdf_error("push_node", "stack overflow");
+ hlist_stack[hlist_stack_level]:=p;
+ hlist_stack_level:=hlist_stack_level + 1;
end;
function pop_node: pointer;
begin
- hlist_stack_level := hlist_stack_level - 1;
- if hlist_stack_level < 0 then {would point to some bug}
- pdf_error("pop_node", "stack underflow (internal error)");
- pop_node := hlist_stack[hlist_stack_level];
+ hlist_stack_level:=hlist_stack_level - 1;
+ if hlist_stack_level < 0 then {would point to some bug}
+ pdf_error("pop_node", "stack underflow (internal error)");
+ pop_node:=hlist_stack[hlist_stack_level];
end;
function find_protchar_left(l: pointer; d: boolean): pointer;
{searches left to right from list head |l|, returns 1st non-skipable item}
var t: pointer;
- run: boolean;
+ run: boolean;
begin
- if (link(l) <> null) and (type(l) = hlist_node) and (width(l) = 0)
- and (height(l) = 0) and (depth(l) = 0) and (list_ptr(l) = null) then
- l := link(l) {for paragraph start with \.{\\parindent = 0pt}}
- else if d then
- while (link(l) <> null) and (not (is_char_node(l) or non_discardable(l))) do
- l := link(l); {std.\ discardables at line break, \TeX book, p 95}
- hlist_stack_level := 0;
- run := true;
- repeat
- t := l;
- while run and (type(l) = hlist_node) and (list_ptr(l) <> null) do begin
- push_node(l);
- l := list_ptr(l);
- end;
- while run and cp_skipable(l) do begin
- while (link(l) = null) and (hlist_stack_level > 0) do begin
- l := pop_node; {don't visit this node again}
- end;
- if link(l) <> null then
- l := link(l)
- else if hlist_stack_level = 0 then run := false
- end;
- until t = l;
- find_protchar_left := l;
+ if (link(l) <> null) and (type(l) = hlist_node) and (width(l) = 0)
+ and (height(l) = 0) and (depth(l) = 0) and (list_ptr(l) = null) then
+ l:=link(l) {for paragraph start with \.{\\parindent = 0pt}}
+ else if d then
+ while (link(l) <> null) and (not (is_char_node(l) or non_discardable(l))) do
+ l:=link(l); {std.\ discardables at line break, \TeX book, p 95}
+ hlist_stack_level:=0;
+ run:=true;
+ repeat
+ t:=l;
+ while run and (type(l) = hlist_node) and (list_ptr(l) <> null) do begin
+ push_node(l);
+ l:=list_ptr(l);
+ end;
+ while run and cp_skipable(l) do begin
+ while (link(l) = null) and (hlist_stack_level > 0) do begin
+ l:=pop_node; {don't visit this node again}
+ end;
+ if link(l) <> null then
+ l:=link(l)
+ else if hlist_stack_level = 0 then run:=false
+ end;
+ until t = l;
+ find_protchar_left:=l;
end;
function find_protchar_right(l, r: pointer): pointer;
{searches right to left from list tail |r| to head |l|, returns 1st non-skipable item}
var t: pointer;
- run: boolean;
+ run: boolean;
begin
- find_protchar_right := null;
- if r = null then return;
- hlist_stack_level := 0;
- run := true;
- repeat
- t := r;
- while run and (type(r) = hlist_node) and (list_ptr(r) <> null) do begin
- push_node(l);
- push_node(r);
- l := list_ptr(r);
- r := l;
- while link(r) <> null do
- r := link(r);
- end;
- while run and cp_skipable(r) do begin
- while (r = l) and (hlist_stack_level > 0) do begin
- r := pop_node; {don't visit this node again}
- l := pop_node;
- end;
- if (r <> l) and (r <> null) then
- r := prev_rightmost(l, r)
- else if (r = l) and (hlist_stack_level = 0) then run := false
- end;
- until t = r;
- find_protchar_right := r;
+ find_protchar_right:=null;
+ if r = null then return;
+ hlist_stack_level:=0;
+ run:=true;
+ repeat
+ t:=r;
+ while run and (type(r) = hlist_node) and (list_ptr(r) <> null) do begin
+ push_node(l);
+ push_node(r);
+ l:=list_ptr(r);
+ r:=l;
+ while link(r) <> null do
+ r:=link(r);
+ end;
+ while run and cp_skipable(r) do begin
+ while (r = l) and (hlist_stack_level > 0) do begin
+ r:=pop_node; {don't visit this node again}
+ l:=pop_node;
+ end;
+ if (r <> l) and (r <> null) then
+ r:=prev_rightmost(l, r)
+ else if (r = l) and (hlist_stack_level = 0) then run:=false
+ end;
+ until t = r;
+ find_protchar_right:=r;
end;
function total_pw(q, p: pointer): scaled;
@@ -19097,40 +19068,40 @@ function total_pw(q, p: pointer): scaled;
|cur_break(break_node(q))| and |p| is the leftmost resp. rightmost node in the
horizontal list representing the actual line}
var l, r: pointer;
- n: integer;
+ n: integer;
begin
- if break_node(q) = null then
- l := first_p
- else
- l := cur_break(break_node(q));
- r := prev_rightmost(global_prev_p, p); {get |link(r)=p|}
- {let's look at the right margin first}
- if (p <> null) and (type(p) = disc_node) and (pre_break(p) <> null) then
- {a |disc_node| with non-empty |pre_break|, protrude the last char of |pre_break|}
+ if break_node(q) = null then
+ l:=first_p
+ else
+ l:=cur_break(break_node(q));
+ r:=prev_rightmost(global_prev_p, p); {get |link(r)=p|}
+ {let's look at the right margin first}
+ if (p <> null) and (type(p) = disc_node) and (pre_break(p) <> null) then
+ {a |disc_node| with non-empty |pre_break|, protrude the last char of |pre_break|}
+ begin
+ r:=pre_break(p);
+ while link(r) <> null do
+ r:=link(r);
+ end else r:=find_protchar_right(l, r);
+ {now the left margin}
+ if (l <> null) and (type(l) = disc_node) then begin
+ if post_break(l) <> null then begin
+ l:=post_break(l); {protrude the first char}
+ goto done;
+ end else {discard |replace_count(l)| nodes}
begin
- r := pre_break(p);
- while link(r) <> null do
- r := link(r);
- end else r := find_protchar_right(l, r);
- {now the left margin}
- if (l <> null) and (type(l) = disc_node) then begin
- if post_break(l) <> null then begin
- l := post_break(l); {protrude the first char}
- goto done;
- end else {discard |replace_count(l)| nodes}
- begin
- n := replace_count(l);
- l := link(l);
- while n > 0 do begin
- if link(l) <> null then
- l := link(l);
- decr(n);
- end;
- end;
+ n:=replace_count(l);
+ l:=link(l);
+ while n > 0 do begin
+ if link(l) <> null then
+ l:=link(l);
+ decr(n);
+ end;
end;
- l := find_protchar_left(l, true);
+ end;
+ l:=find_protchar_left(l, true);
done:
- total_pw := left_pw(l) + right_pw(r);
+ total_pw:=left_pw(l) + right_pw(r);
end;
procedure try_break(@!pi:integer;@!break_type:small_number);
label exit,done,done1,continue,deactivate,found,not_found;
@@ -19552,7 +19523,7 @@ begin artificial_demerits:=false;@/
@^inner loop@>
shortfall:=line_width-cur_active_width[1]; {we're this much too short}
if XeTeX_protrude_chars > 1 then
- shortfall := shortfall + total_pw(r, cur_p);
+ shortfall:=shortfall + total_pw(r, cur_p);
if shortfall>0 then
@<Set the value of |b| to the badness for stretching the line,
and compute the corresponding |fit_class|@>
@@ -19785,8 +19756,8 @@ thrice per call of |line_break|, since it is actually a pass over the
entire paragraph.
@d update_prev_p == begin
- prev_p := cur_p;
- global_prev_p := cur_p;
+ prev_p:=cur_p;
+ global_prev_p:=cur_p;
end
@<Find optimal breakpoints@>=
@@ -19805,7 +19776,7 @@ loop@+ begin if threshold>inf_bad then threshold:=inf_bad;
@<Create an active breakpoint representing the beginning of the paragraph@>;
cur_p:=link(temp_head); auto_breaking:=true;@/
update_prev_p; {glue at beginning is not a legal breakpoint}
- first_p := cur_p; {to access the first node of paragraph as the first active
+ first_p:=cur_p; {to access the first node of paragraph as the first active
node has |break_node=null|}
while (cur_p<>null)and(link(active)<>last_active) do
@<Call |try_break| if |cur_p| is a legal breakpoint;
@@ -20178,13 +20149,13 @@ list about to be justified.
@<Modify the end of the line...@>=
q:=cur_break(cur_p); disc_break:=false; post_disc_break:=false;
-glue_break := false;
+glue_break:=false;
if q<>null then {|q| cannot be a |char_node|}
if type(q)=glue_node then
begin delete_glue_ref(glue_ptr(q));
glue_ptr(q):=right_skip;
subtype(q):=right_skip_code+1; add_glue_ref(right_skip);
- glue_break := true;
+ glue_break:=true;
goto done;
end
else begin if type(q)=disc_node then
@@ -20200,30 +20171,30 @@ done:
of a discretionary break with non-empty |pre_break|, then |q| has been changed
to the last node of the |pre_break| list}
if XeTeX_protrude_chars > 0 then begin
- if disc_break and (is_char_node(q) or (type(q) <> disc_node))
- {|q| has been reset to the last node of |pre_break|}
- then begin
- p := q;
- ptmp := p;
- end else begin
- p := prev_rightmost(link(temp_head), q); {get |link(p) = q|}
- ptmp := p;
- p := find_protchar_right(link(temp_head), p);
- end;
- w := right_pw(p);
- if w <> 0 then {we have found a marginal kern, append it after |ptmp|}
- begin
- k := new_margin_kern(-w, last_rightmost_char, right_side);
- link(k) := link(ptmp);
- link(ptmp) := k;
- if (ptmp = q) then
- q := link(q);
- end;
+ if disc_break and (is_char_node(q) or (type(q) <> disc_node))
+ {|q| has been reset to the last node of |pre_break|}
+ then begin
+ p:=q;
+ ptmp:=p;
+ end else begin
+ p:=prev_rightmost(link(temp_head), q); {get |link(p) = q|}
+ ptmp:=p;
+ p:=find_protchar_right(link(temp_head), p);
+ end;
+ w:=right_pw(p);
+ if w <> 0 then {we have found a marginal kern, append it after |ptmp|}
+ begin
+ k:=new_margin_kern(-w, last_rightmost_char, right_side);
+ link(k):=link(ptmp);
+ link(ptmp):=k;
+ if (ptmp = q) then
+ q:=link(q);
+ end;
end;
{if |q| was not a breakpoint at glue and has been reset to |rightskip| then
we append |rightskip| after |q| now}
if not glue_break then begin
- @<Put the \(r)\.{\\rightskip} glue after node |q|@>;
+ @<Put the \(r)\.{\\rightskip} glue after node |q|@>;
end;
@ @<Change discretionary to compulsory...@>=
@@ -20275,14 +20246,14 @@ justified. It ends with |q| at the beginning of that list, and with
r:=link(q); link(q):=null; q:=link(temp_head); link(temp_head):=r;
{at this point |q| is the leftmost node; all discardable nodes have been discarded}
if XeTeX_protrude_chars > 0 then begin
- p := q;
- p := find_protchar_left(p, false); {no more discardables}
- w := left_pw(p);
- if w <> 0 then begin
- k := new_margin_kern(-w, last_leftmost_char, left_side);
- link(k) := q;
- q := k;
- end;
+ p:=q;
+ p:=find_protchar_left(p, false); {no more discardables}
+ w:=left_pw(p);
+ if w <> 0 then begin
+ k:=new_margin_kern(-w, last_leftmost_char, left_side);
+ link(k):=q;
+ q:=k;
+ end;
end;
if left_skip<>zero_glue then
begin r:=new_param_glue(left_skip_code);
@@ -20292,7 +20263,7 @@ if left_skip<>zero_glue then
@ @<Append the new box to the current vertical list...@>=
if pre_adjust_head <> pre_adjust_tail then
append_list(pre_adjust_head)(pre_adjust_tail);
-pre_adjust_tail := null;
+pre_adjust_tail:=null;
append_to_vlist(just_box);
if adjust_head <> adjust_tail then
append_list(adjust_head)(adjust_tail);
@@ -20314,7 +20285,7 @@ else begin cur_width:=mem[par_shape_ptr+2*cur_line].sc;
cur_indent:=mem[par_shape_ptr+2*cur_line-1].sc;
end;
adjust_tail:=adjust_head;
-pre_adjust_tail := pre_adjust_head;
+pre_adjust_tail:=pre_adjust_head;
just_box:=hpack(q,cur_width,exactly);
shift_amount(just_box):=cur_indent
@@ -20482,9 +20453,9 @@ begin @<Find hyphen locations for the word in |hc|, or |return|@>;
exit:end;
@ @<Check that nodes after |native_word| permit hyphenation; if not, |goto done1|@>=
-s := link(ha);
+s:=link(ha);
loop@+ begin if not(is_char_node(s)) then
- case type(s) of
+ case type(s) of
ligature_node: do_nothing;
kern_node: if subtype(s)<>normal then goto done6;
whatsit_node,glue_node,penalty_node,ins_node,adjust_node,mark_node:
@@ -20497,10 +20468,10 @@ done6:
@ @<Prepare a |native_word_node| for hyphenation@>=
{ note that if there are chars with |lccode = 0|, we split them out into separate |native_word| nodes }
-hn := 0;
+hn:=0;
restart:
-for l := 0 to native_length(ha)-1 do begin
- c := get_native_usv(ha, l);
+for l:=0 to native_length(ha)-1 do begin
+ c:=get_native_usv(ha, l);
set_lc_code(c);
if (hc[0] = 0) then begin
if (hn > 0) then begin
@@ -20512,7 +20483,7 @@ for l := 0 to native_length(ha)-1 do begin
end else if (hn = 0) and (l > 0) then begin
{ we've found the first letter after some non-letters, so break off the head of the |native_word| and restart }
@<Split the |native_word_node| at |l| and link the second part after |ha|@>;
- ha := link(ha);
+ ha:=link(ha);
goto restart;
end else if (hn = 63) then
{ reached max hyphenatable length }
@@ -20521,29 +20492,29 @@ for l := 0 to native_length(ha)-1 do begin
{ found a letter that is part of a potentially hyphenatable sequence }
incr(hn);
if c<@"10000 then begin
- hu[hn] := c; hc[hn] := hc[0];
+ hu[hn]:=c; hc[hn]:=hc[0];
end
else begin
- hu[hn] := (c - @"10000) div @"400 + @"D800;
- hc[hn] := (hc[0] - @"10000) div @"400 + @"D800;
+ hu[hn]:=(c - @"10000) div @"400 + @"D800;
+ hc[hn]:=(hc[0] - @"10000) div @"400 + @"D800;
incr(hn);
- hu[hn] := c mod @"400 + @"DC00;
- hc[hn] := hc[0] mod @"400 + @"DC00;
+ hu[hn]:=c mod @"400 + @"DC00;
+ hc[hn]:=hc[0] mod @"400 + @"DC00;
incr(l);
end;
- hyf_bchar := non_char;
+ hyf_bchar:=non_char;
end
end;
@ @<Split the |native_word_node| at |l| and link the second part after |ha|@>=
- q := new_native_word_node(hf, native_length(ha) - l);
- for i := l to native_length(ha) - 1 do
+ q:=new_native_word_node(hf, native_length(ha) - l);
+ for i:=l to native_length(ha) - 1 do
set_native_char(q, i - l, get_native_char(ha, i));
set_native_metrics(q, XeTeX_use_glyph_metrics);
- link(q) := link(ha);
- link(ha) := q;
+ link(q):=link(ha);
+ link(ha):=q;
{ truncate text in node |ha| }
- native_length(ha) := l;
+ native_length(ha):=l;
set_native_metrics(ha, XeTeX_use_glyph_metrics);
@ @<Local variables for line breaking@>=
@@ -20567,10 +20538,10 @@ loop@+ begin if is_char_node(s) then
if subtype(s) = native_word_node then begin
{ we only consider the node if it contains at least one letter, otherwise we'll skip it }
for l:=0 to native_length(s) - 1 do begin
- c := get_native_usv(s, l);
+ c:=get_native_usv(s, l);
if lc_code(c) <> 0 then begin
- hf := native_font(s);
- prev_s := s;
+ hf:=native_font(s);
+ prev_s:=s;
goto done2;
end;
if c>=@"10000 then incr(l);
@@ -20640,7 +20611,7 @@ end
@ @<Check that the nodes following |hb| permit hyphenation...@>=
if hn<l_hyf+r_hyf then goto done1; {|l_hyf| and |r_hyf| are |>=1|}
loop@+ begin if not(is_char_node(s)) then
- case type(s) of
+ case type(s) of
ligature_node: do_nothing;
kern_node: if subtype(s)<>normal then goto done4;
whatsit_node,glue_node,penalty_node,ins_node,adjust_node,mark_node:
@@ -20727,50 +20698,50 @@ end
@ @<Hyphenate the |native_word_node| at |ha|@>=
{ find the node immediately before the word to be hyphenated }
-s := cur_p; {we have |cur_p<>ha| because |type(cur_p)=glue_node|}
-while link(s) <> ha do s := link(s);
+s:=cur_p; {we have |cur_p<>ha| because |type(cur_p)=glue_node|}
+while link(s) <> ha do s:=link(s);
{ for each hyphen position,
create a |native_word_node| fragment for the text before this point,
and a |disc_node| for the break, with the |hyf_char| in the |pre_break| text
}
-hyphen_passed := 0; { location of last hyphen we saw }
+hyphen_passed:=0; { location of last hyphen we saw }
-for j := l_hyf to hn - r_hyf do begin
+for j:=l_hyf to hn - r_hyf do begin
{ if this is a valid break.... }
if odd(hyf[j]) then begin
{ make a |native_word_node| for the fragment before the hyphen }
- q := new_native_word_node(hf, j - hyphen_passed);
- for i := 0 to j - hyphen_passed - 1 do
+ q:=new_native_word_node(hf, j - hyphen_passed);
+ for i:=0 to j - hyphen_passed - 1 do
set_native_char(q, i, get_native_char(ha, i + hyphen_passed));
set_native_metrics(q, XeTeX_use_glyph_metrics);
- link(s) := q; { append the new node }
- s := q;
+ link(s):=q; { append the new node }
+ s:=q;
{ make the |disc_node| for the hyphenation point }
- q := new_disc;
- pre_break(q) := new_native_character(hf, hyf_char);
- link(s) := q;
- s := q;
+ q:=new_disc;
+ pre_break(q):=new_native_character(hf, hyf_char);
+ link(s):=q;
+ s:=q;
- hyphen_passed := j;
+ hyphen_passed:=j;
end
end;
{ make a |native_word_node| for the last fragment of the word }
-hn := native_length(ha); { ensure trailing punctuation is not lost! }
-q := new_native_word_node(hf, hn - hyphen_passed);
-for i := 0 to hn - hyphen_passed - 1 do
+hn:=native_length(ha); { ensure trailing punctuation is not lost! }
+q:=new_native_word_node(hf, hn - hyphen_passed);
+for i:=0 to hn - hyphen_passed - 1 do
set_native_char(q, i, get_native_char(ha, i + hyphen_passed));
set_native_metrics(q, XeTeX_use_glyph_metrics);
-link(s) := q; { append the new node }
-s := q;
+link(s):=q; { append the new node }
+s:=q;
-q := link(ha);
-link(s) := q;
-link(ha) := null;
+q:=link(ha);
+link(s):=q;
+link(ha):=null;
flush_node_list(ha);
@ We must now face the fact that the battle is not over, even though the
@@ -21379,9 +21350,9 @@ else begin set_lc_code(cur_chr);
begin incr(n);
if hc[0]<@"10000 then hc[n]:=hc[0]
else begin
- hc[n] := (hc[0] - @"10000) div @"400 + @"D800;
+ hc[n]:=(hc[0] - @"10000) div @"400 + @"D800;
incr(n);
- hc[n] := hc[0] mod @"400 + @"DC00;
+ hc[n]:=hc[0] mod @"400 + @"DC00;
end;
end;
end
@@ -23139,6 +23110,12 @@ consideration of the other cases until later.
@d main_loop_lookahead=100 {go here to bring in another character, if any}
@d main_lig_loop=110 {go here to check for ligatures or kerning}
@d append_normal_space=120 {go here to append a normal space between words}
+@#
+@d pdfbox_crop=1 {|pdf_box_type| passed to |find_pic_file|}
+@d pdfbox_media=2
+@d pdfbox_bleed=3
+@d pdfbox_trim=4
+@d pdfbox_art=5
@p @t\4@>@<Declare action procedures for use by |main_control|@>@;
@t\4@>@<Declare the procedure called |handle_right_brace|@>@;
@@ -23254,251 +23231,245 @@ are inside the individual sections.
@d check_for_inter_char_toks(#)=={check for a spacing token list, goto |#| if found,
or |big_switch| in case of the initial letter of a run}
- cur_ptr:=null;
- space_class:=sf_code(cur_chr) div @"10000;
-
- if XeTeX_inter_char_tokens_en and space_class <> 256 then begin {class 256 = ignored (for combining marks etc)}
- if prev_class = 255 then begin {boundary}
- if (state<>token_list) or (token_type<>backed_up_char) then begin
- find_sa_element(inter_char_val, 255*@"100 + space_class, false);
- if cur_ptr<>null then begin
- if cur_cmd<>letter then cur_cmd:=other_char;
- cur_tok:=(cur_cmd*max_char_val)+cur_chr;
- back_input; token_type:=backed_up_char;
- begin_token_list(sa_ptr(cur_ptr), inter_char_text);
- goto big_switch;
- end
- end
- end else begin
- find_sa_element(inter_char_val, prev_class*@"100 + space_class, false);
- if cur_ptr<>null then begin
- if cur_cmd<>letter then cur_cmd:=other_char;
- cur_tok:=(cur_cmd*max_char_val)+cur_chr;
- back_input; token_type:=backed_up_char;
- begin_token_list(sa_ptr(cur_ptr), inter_char_text);
- prev_class:=255;
- goto #;
- end;
- end;
- prev_class:=space_class;
- end
+ cur_ptr:=null;
+ space_class:=sf_code(cur_chr) div @"10000;
-@d check_for_post_char_toks(#)==
- if XeTeX_inter_char_tokens_en and (space_class<>256) and (prev_class<>255) then begin
- prev_class:=255;
- find_sa_element(inter_char_val, space_class*@"100 + 255, false); {boundary}
+ if XeTeX_inter_char_tokens_en and space_class <> 256 then begin {class 256 = ignored (for combining marks etc)}
+ if prev_class = 255 then begin {boundary}
+ if (state<>token_list) or (token_type<>backed_up_char) then begin
+ find_sa_element(inter_char_val, 255*@"100 + space_class, false);
if cur_ptr<>null then begin
- if cur_cs=0 then begin
- if cur_cmd=char_num then cur_cmd:=other_char;
- cur_tok:=(cur_cmd*max_char_val)+cur_chr;
- end else cur_tok:=cs_token_flag+cur_cs;
- back_input;
- begin_token_list(sa_ptr(cur_ptr), inter_char_text);
- goto #;
- end;
- end
+ if cur_cmd<>letter then cur_cmd:=other_char;
+ cur_tok:=(cur_cmd*max_char_val)+cur_chr;
+ back_input; token_type:=backed_up_char;
+ begin_token_list(sa_ptr(cur_ptr), inter_char_text);
+ goto big_switch;
+ end
+ end
+ end else begin
+ find_sa_element(inter_char_val, prev_class*@"100 + space_class, false);
+ if cur_ptr<>null then begin
+ if cur_cmd<>letter then cur_cmd:=other_char;
+ cur_tok:=(cur_cmd*max_char_val)+cur_chr;
+ back_input; token_type:=backed_up_char;
+ begin_token_list(sa_ptr(cur_ptr), inter_char_text);
+ prev_class:=255;
+ goto #;
+ end;
+ end;
+ prev_class:=space_class;
+ end
+
+@d check_for_post_char_toks(#)==
+ if XeTeX_inter_char_tokens_en and (space_class<>256) and (prev_class<>255) then begin
+ prev_class:=255;
+ find_sa_element(inter_char_val, space_class*@"100 + 255, false); {boundary}
+ if cur_ptr<>null then begin
+ if cur_cs=0 then begin
+ if cur_cmd=char_num then cur_cmd:=other_char;
+ cur_tok:=(cur_cmd*max_char_val)+cur_chr;
+ end else cur_tok:=cs_token_flag+cur_cs;
+ back_input;
+ begin_token_list(sa_ptr(cur_ptr), inter_char_text);
+ goto #;
+ end;
+ end
@<Append character |cur_chr|...@>=
-prev_class := 255; {boundary}
+prev_class:=255; {boundary}
{ added code for native font support }
if is_native_font(cur_font) then begin
- if mode>0 then if language<>clang then fix_language;
+ if mode>0 then if language<>clang then fix_language;
- main_h := 0;
- main_f := cur_font;
- native_len := 0;
+ main_h:=0;
+ main_f:=cur_font;
+ native_len:=0;
collect_native:
- adjust_space_factor;
+ adjust_space_factor;
- check_for_inter_char_toks(collected);
+ check_for_inter_char_toks(collected);
- if (cur_chr > @"FFFF) then begin
- native_room(2);
- append_native((cur_chr - @"10000) div 1024 + @"D800);
- append_native((cur_chr - @"10000) mod 1024 + @"DC00);
- end else begin
- native_room(1);
- append_native(cur_chr);
- end;
- is_hyph := (cur_chr = hyphen_char[main_f])
- or (XeTeX_dash_break_en and ((cur_chr = @"2014) or (cur_chr = @"2013)));
- if (main_h = 0) and is_hyph then main_h := native_len;
+ if (cur_chr > @"FFFF) then begin
+ native_room(2);
+ append_native((cur_chr - @"10000) div 1024 + @"D800);
+ append_native((cur_chr - @"10000) mod 1024 + @"DC00);
+ end else begin
+ native_room(1);
+ append_native(cur_chr);
+ end;
+ is_hyph:=(cur_chr = hyphen_char[main_f])
+ or (XeTeX_dash_break_en and ((cur_chr = @"2014) or (cur_chr = @"2013)));
+ if (main_h = 0) and is_hyph then main_h:=native_len;
- {try to collect as many chars as possible in the same font}
- get_next;
- if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native;
- x_token;
- if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native;
- if cur_cmd=char_num then begin
- scan_usv_num;
- cur_chr:=cur_val;
- goto collect_native;
- end;
+ {try to collect as many chars as possible in the same font}
+ get_next;
+ if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native;
+ x_token;
+ if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native;
+ if cur_cmd=char_num then begin
+ scan_usv_num;
+ cur_chr:=cur_val;
+ goto collect_native;
+ end;
- check_for_post_char_toks(collected);
+ check_for_post_char_toks(collected);
collected:
- if (font_mapping[main_f] <> 0) then begin
- main_k := apply_mapping(font_mapping[main_f], native_text, native_len);
- native_len := 0;
- native_room(main_k);
- main_h := 0;
- for main_p := 0 to main_k - 1 do begin
- append_native(mapped_text[main_p]);
- if (main_h = 0) and ((mapped_text[main_p] = hyphen_char[main_f])
- or (XeTeX_dash_break_en and ((mapped_text[main_p] = @"2014) or (mapped_text[main_p] = @"2013)) ) )
- then main_h := native_len;
- end
- end;
+ if (font_mapping[main_f] <> 0) then begin
+ main_k:=apply_mapping(font_mapping[main_f], native_text, native_len);
+ native_len:=0;
+ native_room(main_k);
+ main_h:=0;
+ for main_p:=0 to main_k - 1 do begin
+ append_native(mapped_text[main_p]);
+ if (main_h = 0) and ((mapped_text[main_p] = hyphen_char[main_f])
+ or (XeTeX_dash_break_en and ((mapped_text[main_p] = @"2014) or (mapped_text[main_p] = @"2013)) ) )
+ then main_h:=native_len;
+ end
+ end;
- if tracing_lost_chars > 0 then begin
- temp_ptr := 0;
- while (temp_ptr < native_len) do begin
- main_k := native_text[temp_ptr];
- incr(temp_ptr);
- if (main_k >= @"D800) and (main_k < @"DC00) then begin
- main_k := @"10000 + (main_k - @"D800) * 1024;
- main_k := main_k + native_text[temp_ptr] - @"DC00;
- incr(temp_ptr);
- end;
- if map_char_to_glyph(main_f, main_k) = 0 then
- char_warning(main_f, main_k);
- end
- end;
+ if tracing_lost_chars > 0 then begin
+ temp_ptr:=0;
+ while (temp_ptr < native_len) do begin
+ main_k:=native_text[temp_ptr];
+ incr(temp_ptr);
+ if (main_k >= @"D800) and (main_k < @"DC00) then begin
+ main_k:=@"10000 + (main_k - @"D800) * 1024;
+ main_k:=main_k + native_text[temp_ptr] - @"DC00;
+ incr(temp_ptr);
+ end;
+ if map_char_to_glyph(main_f, main_k) = 0 then
+ char_warning(main_f, main_k);
+ end
+ end;
- main_k := native_len;
- main_pp := tail;
+ main_k:=native_len;
+ main_pp:=tail;
- if mode=hmode then begin
+ if mode=hmode then begin
+ main_ppp:=head;
+ if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries }
+ while (link(main_ppp)<>main_pp) do begin
+ if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin
+ temp_ptr:=main_ppp;
+ for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp);
+ end;
+ if main_ppp<>main_pp then main_ppp:=link(main_ppp);
+ end;
- main_ppp := head;
- if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries }
- while (link(main_ppp)<>main_pp) do begin
- if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin
- temp_ptr:=main_ppp;
- for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp);
- end;
- if main_ppp<>main_pp then main_ppp:=link(main_ppp);
- end;
+ temp_ptr:=0;
+ repeat
+ if main_h = 0 then main_h:=main_k;
+
+ if is_native_word_node(main_pp)
+ and (native_font(main_pp)=main_f)
+ and (main_ppp<>main_pp)
+ and (not is_char_node(main_ppp))
+ and (type(main_ppp)<>disc_node)
+ then begin
+ { make a new temp string that contains the concatenated text of |tail| + the current word/fragment }
+ main_k:=main_h + native_length(main_pp);
+ native_room(main_k);
- temp_ptr := 0;
- repeat
- if main_h = 0 then main_h := main_k;
-
- if is_native_word_node(main_pp)
- and (native_font(main_pp)=main_f)
- and (main_ppp<>main_pp)
- and (not is_char_node(main_ppp))
- and (type(main_ppp)<>disc_node)
- then begin
-
- { make a new temp string that contains the concatenated text of |tail| + the current word/fragment }
- main_k := main_h + native_length(main_pp);
- native_room(main_k);
-
- save_native_len := native_len;
- for main_p := 0 to native_length(main_pp) - 1 do
- append_native(get_native_char(main_pp, main_p));
- for main_p := 0 to main_h - 1 do
- append_native(native_text[temp_ptr + main_p]);
-
- do_locale_linebreaks(save_native_len, main_k);
-
- native_len := save_native_len; { discard the temp string }
- main_k := native_len - main_h - temp_ptr; { and set |main_k| to remaining length of new word }
- temp_ptr := main_h; { pointer to remaining fragment }
-
- main_h := 0;
- while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f])
- and ( (not XeTeX_dash_break_en)
- or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) )
- do incr(main_h); { look for next hyphen or end of text }
- if (main_h < main_k) then incr(main_h);
-
- { remove the preceding node from the list }
- link(main_ppp) := link(main_pp);
- link(main_pp) := null;
- flush_node_list(main_pp);
- main_pp := tail;
- while (link(main_ppp)<>main_pp) do
- main_ppp:=link(main_ppp);
-
- end else begin
-
- do_locale_linebreaks(temp_ptr, main_h); { append fragment of current word }
-
- temp_ptr := temp_ptr + main_h; { advance ptr to remaining fragment }
- main_k := main_k - main_h; { decrement remaining length }
-
- main_h := 0;
- while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f])
- and ( (not XeTeX_dash_break_en)
- or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) )
- do incr(main_h); { look for next hyphen or end of text }
- if (main_h < main_k) then incr(main_h);
-
- end;
-
- if (main_k > 0) or is_hyph then begin
- tail_append(new_disc); { add a break if we aren't at end of text (must be a hyphen),
- or if last char in original text was a hyphen }
- main_pp:=tail;
- end;
- until main_k = 0;
+ save_native_len:=native_len;
+ for main_p:=0 to native_length(main_pp) - 1 do
+ append_native(get_native_char(main_pp, main_p));
+ for main_p:=0 to main_h - 1 do
+ append_native(native_text[temp_ptr + main_p]);
+
+ do_locale_linebreaks(save_native_len, main_k);
+
+ native_len:=save_native_len; { discard the temp string }
+ main_k:=native_len - main_h - temp_ptr; { and set |main_k| to remaining length of new word }
+ temp_ptr:=main_h; { pointer to remaining fragment }
+
+ main_h:=0;
+ while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f])
+ and ( (not XeTeX_dash_break_en)
+ or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) )
+ do incr(main_h); { look for next hyphen or end of text }
+ if (main_h < main_k) then incr(main_h);
+
+ { remove the preceding node from the list }
+ link(main_ppp):=link(main_pp);
+ link(main_pp):=null;
+ flush_node_list(main_pp);
+ main_pp:=tail;
+ while (link(main_ppp)<>main_pp) do
+ main_ppp:=link(main_ppp);
+ end else begin
+ do_locale_linebreaks(temp_ptr, main_h); { append fragment of current word }
+
+ temp_ptr:=temp_ptr + main_h; { advance ptr to remaining fragment }
+ main_k:=main_k - main_h; { decrement remaining length }
+
+ main_h:=0;
+ while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f])
+ and ( (not XeTeX_dash_break_en)
+ or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) )
+ do incr(main_h); { look for next hyphen or end of text }
+ if (main_h < main_k) then incr(main_h);
+ end;
+ if (main_k > 0) or is_hyph then begin
+ tail_append(new_disc); { add a break if we aren't at end of text (must be a hyphen),
+ or if last char in original text was a hyphen }
+ main_pp:=tail;
+ end;
+ until main_k = 0;
+ end else begin
+ { must be restricted hmode, so no need for line-breaking or discretionaries }
+ { but there might already be explicit |disc_node|s in the list }
+ main_ppp:=head;
+ if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries }
+ while (link(main_ppp)<>main_pp) do begin
+ if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin
+ temp_ptr:=main_ppp;
+ for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp);
+ end;
+ if main_ppp<>main_pp then main_ppp:=link(main_ppp);
+ end;
+ if is_native_word_node(main_pp)
+ and (native_font(main_pp)=main_f)
+ and (main_ppp<>main_pp)
+ and (not is_char_node(main_ppp))
+ and (type(main_ppp)<>disc_node)
+ then begin
+ { total string length for the new merged whatsit }
+ link(main_pp):=new_native_word_node(main_f, main_k + native_length(main_pp));
+ tail:=link(main_pp);
+
+ { copy text from the old one into the new }
+ for main_p:=0 to native_length(main_pp) - 1 do
+ set_native_char(tail, main_p, get_native_char(main_pp, main_p));
+ { append the new text }
+ for main_p:=0 to main_k - 1 do
+ set_native_char(tail, main_p + native_length(main_pp), native_text[main_p]);
+ set_native_metrics(tail, XeTeX_use_glyph_metrics);
+
+ { remove the preceding node from the list }
+ main_p:=head;
+ if main_p<>main_pp then
+ while link(main_p)<>main_pp do
+ main_p:=link(main_p);
+ link(main_p):=link(main_pp);
+ link(main_pp):=null;
+ flush_node_list(main_pp);
end else begin
- { must be restricted hmode, so no need for line-breaking or discretionaries }
- { but there might already be explicit |disc_node|s in the list }
- main_ppp := head;
- if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries }
- while (link(main_ppp)<>main_pp) do begin
- if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin
- temp_ptr:=main_ppp;
- for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp);
- end;
- if main_ppp<>main_pp then main_ppp:=link(main_ppp);
- end;
- if is_native_word_node(main_pp)
- and (native_font(main_pp)=main_f)
- and (main_ppp<>main_pp)
- and (not is_char_node(main_ppp))
- and (type(main_ppp)<>disc_node)
- then begin
- { total string length for the new merged whatsit }
- link(main_pp) := new_native_word_node(main_f, main_k + native_length(main_pp));
- tail := link(main_pp);
-
- { copy text from the old one into the new }
- for main_p := 0 to native_length(main_pp) - 1 do
- set_native_char(tail, main_p, get_native_char(main_pp, main_p));
- { append the new text }
- for main_p := 0 to main_k - 1 do
- set_native_char(tail, main_p + native_length(main_pp), native_text[main_p]);
- set_native_metrics(tail, XeTeX_use_glyph_metrics);
-
- { remove the preceding node from the list }
- main_p := head;
- if main_p<>main_pp then
- while link(main_p)<>main_pp do
- main_p := link(main_p);
- link(main_p) := link(main_pp);
- link(main_pp) := null;
- flush_node_list(main_pp);
- end else begin
- { package the current string into a |native_word| whatsit }
- link(main_pp) := new_native_word_node(main_f, main_k);
- tail := link(main_pp);
- for main_p := 0 to main_k - 1 do
- set_native_char(tail, main_p, native_text[main_p]);
- set_native_metrics(tail, XeTeX_use_glyph_metrics);
- end
- end;
+ { package the current string into a |native_word| whatsit }
+ link(main_pp):=new_native_word_node(main_f, main_k);
+ tail:=link(main_pp);
+ for main_p:=0 to main_k - 1 do
+ set_native_char(tail, main_p, native_text[main_p]);
+ set_native_metrics(tail, XeTeX_use_glyph_metrics);
+ end
+ end;
- if cur_ptr<>null then goto big_switch
- else goto reswitch;
+ if cur_ptr<>null then goto big_switch
+ else goto reswitch;
end;
{ End of added code for native fonts }
@@ -23766,12 +23737,12 @@ any_mode(ignore_spaces): begin
get_next;
scanner_status:=t;
if cur_cs < hash_base then
- cur_cs := prim_lookup(cur_cs-257)
+ cur_cs:=prim_lookup(cur_cs-257)
else
- cur_cs := prim_lookup(text(cur_cs));
+ cur_cs :=prim_lookup(text(cur_cs));
if cur_cs<>undefined_primitive then begin
- cur_cmd := prim_eq_type(cur_cs);
- cur_chr := prim_equiv(cur_cs);
+ cur_cmd:=prim_eq_type(cur_cs);
+ cur_chr:=prim_equiv(cur_cs);
goto reswitch;
end;
end;
@@ -24293,7 +24264,7 @@ begin if cur_box<>null then
if pre_adjust_tail <> null then begin
if pre_adjust_head <> pre_adjust_tail then
append_list(pre_adjust_head)(pre_adjust_tail);
- pre_adjust_tail := null;
+ pre_adjust_tail:=null;
end;
append_to_vlist(cur_box);
if adjust_tail <> null then begin
@@ -24618,12 +24589,12 @@ else begin scan_eight_bit_int;
error; cur_val:=0;
end;
end;
-saved(0) := cur_val;
+saved(0):=cur_val;
if (cur_cmd = vadjust) and scan_keyword("pre") then
- saved(1) := 1
+ saved(1):=1
else
- saved(1) := 0;
-save_ptr := save_ptr + 2;
+ saved(1):=0;
+save_ptr:=save_ptr + 2;
new_save_level(insert_group); scan_left_brace; normal_paragraph;
push_nest; mode:=-vmode; prev_depth:=ignore_depth;
end;
@@ -24641,7 +24612,7 @@ insert_group: begin end_graf; q:=split_top_skip; add_glue_ref(q);
end
else begin tail_append(get_node(small_node_size));
type(tail):=adjust_node;@/
- adjust_pre(tail) := saved(1); {the |subtype| is used for |adjust_pre|}
+ adjust_pre(tail):=saved(1); {the |subtype| is used for |adjust_pre|}
adjust_ptr(tail):=list_ptr(p); delete_glue_ref(q);
end;
free_node(p,box_node_size);
@@ -24777,9 +24748,9 @@ else begin link(tail):=list_ptr(p); change_box(null);
end;
done:
while link(tail) <> null do begin
- r := link(tail);
+ r:=link(tail);
if not is_char_node(r) and (type(r) = margin_kern_node) then begin
- link(tail) := link(r);
+ link(tail):=link(r);
free_node(r, margin_kern_node_size);
end;
tail:=link(tail);
@@ -25356,31 +25327,31 @@ char_num: begin scan_char_num; cur_chr:=cur_val; cur_cmd:=char_given;
end;
math_char_num:
if cur_chr = 2 then begin {\.{\\Umathchar}}
- scan_math_class_int; c := set_class_field(cur_val);
- scan_math_fam_int; c := c + set_family_field(cur_val);
- scan_usv_num; c := c + cur_val;
+ scan_math_class_int; c:=set_class_field(cur_val);
+ scan_math_fam_int; c:=c + set_family_field(cur_val);
+ scan_usv_num; c:=c + cur_val;
end else if cur_chr = 1 then begin {\.{\\Umathcharnum}}
- scan_xetex_math_char_int; c := cur_val;
+ scan_xetex_math_char_int; c:=cur_val;
end else begin scan_fifteen_bit_int;
- c := set_class_field(cur_val div @"1000) +
+ c:=set_class_field(cur_val div @"1000) +
set_family_field((cur_val mod @"1000) div @"100) +
(cur_val mod @"100);
end;
math_given: begin
- c := set_class_field(cur_chr div @"1000) +
+ c:=set_class_field(cur_chr div @"1000) +
set_family_field((cur_chr mod @"1000) div @"100) +
(cur_chr mod @"100);
end;
XeTeX_math_given: c:=cur_chr;
delim_num: begin
if cur_chr=1 then begin {\.{\\Udelimiter <class> <fam> <usv>}}
- scan_math_class_int; c := set_class_field(cur_val);
- scan_math_fam_int; c := c + set_family_field(cur_val);
- scan_usv_num; c := c + cur_val;
+ scan_math_class_int; c:=set_class_field(cur_val);
+ scan_math_fam_int; c:=c + set_family_field(cur_val);
+ scan_usv_num; c:=c + cur_val;
end else begin {\.{\\delimiter <27-bit delcode>}}
scan_delimiter_int;
- c := cur_val div @'10000; {get the `small' delimiter field}
- c := set_class_field(c div @"1000) +
+ c:=cur_val div @'10000; {get the `small' delimiter field}
+ c:=set_class_field(c div @"1000) +
set_family_field((c mod @"1000) div @"100) +
(c mod @"100); {and convert it to a \XeTeX\ mathchar code}
end;
@@ -25390,7 +25361,7 @@ endcases;@/
math_type(p):=math_char; character(p):=qi(c mod @"10000);
if (is_var_family(c)) and fam_in_range then plane_and_fam_field(p):=cur_fam
else plane_and_fam_field(p):=(math_fam_field(c));
-plane_and_fam_field(p) := plane_and_fam_field(p) + (math_char_field(c) div @"10000) * @"100;
+plane_and_fam_field(p):=plane_and_fam_field(p) + (math_char_field(c) div @"10000) * @"100;
exit:end;
@ An active character that is an |outer_call| is allowed here.
@@ -25423,9 +25394,9 @@ mmode+char_num: begin scan_char_num; cur_chr:=cur_val;
set_math_char(ho(math_code(cur_chr)));
end;
mmode+math_char_num: if cur_chr = 2 then begin {\.{\\Umathchar}}
- scan_math_class_int; t := set_class_field(cur_val);
- scan_math_fam_int; t := t + set_family_field(cur_val);
- scan_usv_num; t := t + cur_val;
+ scan_math_class_int; t:=set_class_field(cur_val);
+ scan_math_fam_int; t:=t + set_family_field(cur_val);
+ scan_usv_num; t:=t + cur_val;
set_math_char(t);
end else if cur_chr = 1 then begin {\.{\\Umathcharnum}}
scan_xetex_math_char_int; set_math_char(cur_val);
@@ -25442,9 +25413,9 @@ mmode+math_given: begin
mmode+XeTeX_math_given: set_math_char(cur_chr);
mmode+delim_num: begin
if cur_chr=1 then begin {\.{\\Udelimiter}}
- scan_math_class_int; t := set_class_field(cur_val);
- scan_math_fam_int; t := t + set_family_field(cur_val);
- scan_usv_num; t := t + cur_val;
+ scan_math_class_int; t:=set_class_field(cur_val);
+ scan_math_fam_int; t:=t + set_family_field(cur_val);
+ scan_usv_num; t:=t + cur_val;
set_math_char(t);
end else begin
scan_delimiter_int;
@@ -25475,7 +25446,7 @@ else begin p:=new_noad; math_type(nucleus(p)):=math_char;
type(p):=ord_noad;
end
else type(p):=ord_noad+math_class_field(c);
- plane_and_fam_field(nucleus(p)) := plane_and_fam_field(nucleus(p)) + (ch div @"10000) * @"100;
+ plane_and_fam_field(nucleus(p)):=plane_and_fam_field(nucleus(p)) + (ch div @"10000) * @"100;
link(tail):=p; tail:=p;
end;
end;
@@ -25556,9 +25527,9 @@ procedure scan_delimiter(@!p:pointer;@!r:boolean);
begin
if r then begin
if cur_chr=1 then begin {\.{\\Uradical}}
- cur_val1 := @"40000000; {extended delimiter code flag}
- scan_math_fam_int; cur_val1 := cur_val1 + cur_val * @"200000;
- scan_usv_num; cur_val := cur_val1 + cur_val;
+ cur_val1:=@"40000000; {extended delimiter code flag}
+ scan_math_fam_int; cur_val1:=cur_val1 + cur_val * @"200000;
+ scan_usv_num; cur_val:=cur_val1 + cur_val;
end else {radical}
scan_delimiter_int;
end
@@ -25568,10 +25539,10 @@ else begin @<Get the next non-blank non-relax...@>;
cur_val:=del_code(cur_chr);
end;
delim_num: if cur_chr=1 then begin {\.{\\Udelimiter}}
- cur_val1 := @"40000000; {extended delimiter code flag}
+ cur_val1:=@"40000000; {extended delimiter code flag}
scan_math_class_int; {discarded}
- scan_math_fam_int; cur_val1 := cur_val1 + cur_val * @"200000;
- scan_usv_num; cur_val := cur_val1 + cur_val;
+ scan_math_fam_int; cur_val1:=cur_val1 + cur_val * @"200000;
+ scan_usv_num; cur_val:=cur_val1 + cur_val;
end else scan_delimiter_int; {normal delimiter}
othercases begin cur_val:=-1; end;
endcases;
@@ -25580,16 +25551,16 @@ if cur_val<0 then begin @<Report that an invalid delimiter code is being changed
to null; set~|cur_val:=0|@>;
end;
if cur_val>=@"40000000 then begin {extended delimiter code, only one size}
- small_plane_and_fam_field(p) := ((cur_val mod @"200000) div @"10000) * @"100 {plane}
+ small_plane_and_fam_field(p):=((cur_val mod @"200000) div @"10000) * @"100 {plane}
+ (cur_val div @"200000) mod @"100; {family}
- small_char_field(p) := qi(cur_val mod @"10000);
- large_plane_and_fam_field(p) := 0;
- large_char_field(p) := 0;
+ small_char_field(p):=qi(cur_val mod @"10000);
+ large_plane_and_fam_field(p):=0;
+ large_char_field(p):=0;
end else begin {standard delimiter code, 4-bit families and 8-bit char codes}
- small_plane_and_fam_field(p) := (cur_val div @'4000000) mod 16;
- small_char_field(p) := qi((cur_val div @'10000) mod 256);
- large_plane_and_fam_field(p) := (cur_val div 256) mod 16;
- large_char_field(p) := qi(cur_val mod 256);
+ small_plane_and_fam_field(p):=(cur_val div @'4000000) mod 16;
+ small_char_field(p):=qi((cur_val div @'10000) mod 256);
+ large_plane_and_fam_field(p):=(cur_val div 256) mod 16;
+ large_char_field(p):=qi(cur_val mod 256);
end;
end;
@@ -25641,13 +25612,13 @@ if cur_chr=1 then begin
else
subtype(tail):=bottom_acc;
end;
- scan_math_class_int; c := set_class_field(cur_val);
- scan_math_fam_int; c := c + set_family_field(cur_val);
- scan_usv_num; cur_val := cur_val + c;
+ scan_math_class_int; c:=set_class_field(cur_val);
+ scan_math_fam_int; c:=c + set_family_field(cur_val);
+ scan_usv_num; cur_val:=cur_val + c;
end
else begin
scan_fifteen_bit_int;
- cur_val := set_class_field(cur_val div @"1000) +
+ cur_val:=set_class_field(cur_val div @"1000) +
set_family_field((cur_val mod @"1000) div @"100) +
(cur_val mod @"100);
end;
@@ -25655,7 +25626,7 @@ character(accent_chr(tail)):=qi(cur_val mod @"10000);
if (is_var_family(cur_val))and fam_in_range then plane_and_fam_field(accent_chr(tail)):=cur_fam
else plane_and_fam_field(accent_chr(tail)):=math_fam_field(cur_val);
plane_and_fam_field(accent_chr(tail))
- := plane_and_fam_field(accent_chr(tail)) + (math_char_field(cur_val) div @"10000) * @"100;
+ :=plane_and_fam_field(accent_chr(tail)) + (math_char_field(cur_val) div @"10000) * @"100;
scan_math(nucleus(tail));
end;
@@ -26545,9 +26516,9 @@ shorthand_def: begin n:=cur_chr; get_r_token; p:=cur_cs; define(p,relax,256);
define(p, XeTeX_math_given, cur_val);
end;
XeTeX_math_char_def_code: begin
- scan_math_class_int; n := set_class_field(cur_val);
- scan_math_fam_int; n := n + set_family_field(cur_val);
- scan_usv_num; n := n + cur_val;
+ scan_math_class_int; n:=set_class_field(cur_val);
+ scan_math_fam_int; n:=n + set_family_field(cur_val);
+ scan_usv_num; n:=n + cur_val;
define(p, XeTeX_math_given, n);
end;
othercases begin scan_register_num;
@@ -26753,9 +26724,9 @@ XeTeX_def_code: begin
p:=cur_chr-1; scan_usv_num;
p:=p+cur_val;
scan_optional_equals;
- scan_math_class_int; n := set_class_field(cur_val);
- scan_math_fam_int; n := n + set_family_field(cur_val);
- scan_usv_num; n := n + cur_val;
+ scan_math_class_int; n:=set_class_field(cur_val);
+ scan_math_fam_int; n:=n + set_family_field(cur_val);
+ scan_usv_num; n:=n + cur_val;
define(p,data,hi(n));
end
else if cur_chr = del_code_base then begin
@@ -26768,9 +26739,9 @@ XeTeX_def_code: begin
p:=cur_chr-1; scan_usv_num;
p:=p+cur_val;
scan_optional_equals;
- n := @"40000000; {extended delimiter code flag}
- scan_math_fam_int; n := n + cur_val * @"200000; {extended delimiter code family}
- scan_usv_num; n := n + cur_val; {extended delimiter code USV}
+ n:=@"40000000; {extended delimiter code flag}
+ scan_math_fam_int; n:=n + cur_val * @"200000; {extended delimiter code family}
+ scan_usv_num; n:=n + cur_val; {extended delimiter code USV}
word_define(p,hi(n));
end;
end;
@@ -27097,7 +27068,7 @@ assign_font_int: begin n:=cur_chr; scan_font_ident; f:=cur_val;
if is_native_font(f) then
scan_glyph_number(f) {for native fonts, the value is a glyph id}
else scan_char_num; {for |tfm| fonts it's the same like pdftex}
- p := cur_val;
+ p:=cur_val;
scan_optional_equals; scan_int;
case n of
lp_code_base: set_cp_code(f, p, left_side, cur_val);
@@ -28634,51 +28605,51 @@ end;
function tokens_to_string(p: pointer): str_number; {return a string from tokens
list}
begin
- if selector = new_string then
- pdf_error("tokens", "tokens_to_string() called while selector = new_string");
- old_setting:=selector; selector:=new_string;
- show_token_list(link(p),null,pool_size-pool_ptr);
- selector:=old_setting;
- tokens_to_string := make_string;
+ if selector = new_string then
+ pdf_error("tokens", "tokens_to_string() called while selector = new_string");
+ old_setting:=selector; selector:=new_string;
+ show_token_list(link(p),null,pool_size-pool_ptr);
+ selector:=old_setting;
+ tokens_to_string:=make_string;
end;
procedure compare_strings; {to implement \.{\\strcmp}}
label done;
var s1, s2: str_number;
- i1, i2, j1, j2: pool_pointer;
+ i1, i2, j1, j2: pool_pointer;
begin
- call_func(scan_toks(false, true));
- s1 := tokens_to_string(def_ref);
- delete_token_ref(def_ref);
- call_func(scan_toks(false, true));
- s2 := tokens_to_string(def_ref);
- delete_token_ref(def_ref);
- i1 := str_start_macro(s1);
- j1 := str_start_macro(s1 + 1);
- i2 := str_start_macro(s2);
- j2 := str_start_macro(s2 + 1);
- while (i1 < j1) and (i2 < j2) do begin
- if str_pool[i1] < str_pool[i2] then begin
- cur_val := -1;
- goto done;
- end;
- if str_pool[i1] > str_pool[i2] then begin
- cur_val := 1;
- goto done;
- end;
- incr(i1);
- incr(i2);
- end;
- if (i1 = j1) and (i2 = j2) then
- cur_val := 0
- else if i1 < j1 then
- cur_val := 1
- else
- cur_val := -1;
+ call_func(scan_toks(false, true));
+ s1:=tokens_to_string(def_ref);
+ delete_token_ref(def_ref);
+ call_func(scan_toks(false, true));
+ s2:=tokens_to_string(def_ref);
+ delete_token_ref(def_ref);
+ i1:=str_start_macro(s1);
+ j1:=str_start_macro(s1 + 1);
+ i2:=str_start_macro(s2);
+ j2:=str_start_macro(s2 + 1);
+ while (i1 < j1) and (i2 < j2) do begin
+ if str_pool[i1] < str_pool[i2] then begin
+ cur_val:=-1;
+ goto done;
+ end;
+ if str_pool[i1] > str_pool[i2] then begin
+ cur_val:=1;
+ goto done;
+ end;
+ incr(i1);
+ incr(i2);
+ end;
+ if (i1 = j1) and (i2 = j2) then
+ cur_val:=0
+ else if i1 < j1 then
+ cur_val:=1
+ else
+ cur_val:=-1;
done:
- flush_str(s2);
- flush_str(s1);
- cur_val_level := int_val;
+ flush_str(s2);
+ flush_str(s1);
+ cur_val_level:=int_val;
end;
@ Each new type of node that appears in our data structure must be capable
@@ -28698,22 +28669,22 @@ end;
procedure print_native_word(@!p:pointer);
var i,c,cc:integer;
begin
- for i:=0 to native_length(p) - 1 do begin
- c:=get_native_char(p,i);
- if (c >= @"D800) and (c <= @"DBFF) then begin
- if i < native_length(p) - 1 then begin
- cc:=get_native_char(p, i+1);
- if (cc >= @"DC00) and (cc <= @"DFFF) then begin
- c := @"10000 + (c - @"D800) * @"400 + (cc - @"DC00);
- print_char(c);
- incr(i);
- end else
- print(".");
- end else
- print(".");
+ for i:=0 to native_length(p) - 1 do begin
+ c:=get_native_char(p,i);
+ if (c >= @"D800) and (c <= @"DBFF) then begin
+ if i < native_length(p) - 1 then begin
+ cc:=get_native_char(p, i+1);
+ if (cc >= @"DC00) and (cc <= @"DFFF) then begin
+ c:=@"10000 + (c - @"D800) * @"400 + (cc - @"DC00);
+ print_char(c);
+ incr(i);
end else
- print_char(c);
- end
+ print(".");
+ end else
+ print(".");
+ end else
+ print_char(c);
+ end
end;
@ @<Display the whatsit...@>=
@@ -28733,23 +28704,21 @@ language_node:begin print_esc("setlanguage");
print_int(what_lhm(p)); print_char(",");
print_int(what_rhm(p)); print_char(")");
end;
-native_word_node:begin
- print_esc(font_id_text(native_font(p)));
- print_char(" ");
- print_native_word(p);
+native_word_node:begin print_esc(font_id_text(native_font(p)));
+ print_char(" ");
+ print_native_word(p);
end;
-glyph_node:begin
- print_esc(font_id_text(native_font(p)));
- print(" glyph#");
- print_int(native_glyph(p));
+glyph_node:begin print_esc(font_id_text(native_font(p)));
+ print(" glyph#");
+ print_int(native_glyph(p));
end;
pic_node,pdf_node: begin
- if subtype(p) = pic_node then print_esc("XeTeXpicfile")
- else print_esc("XeTeXpdffile");
- print(" """);
- for i:=0 to pic_path_length(p)-1 do
- print_visible_char(pic_path_byte(p, i));
- print("""");
+ if subtype(p) = pic_node then print_esc("XeTeXpicfile")
+ else print_esc("XeTeXpdffile");
+ print(" """);
+ for i:=0 to pic_path_length(p)-1 do
+ print_visible_char(pic_path_byte(p, i));
+ print("""");
end;
pdf_save_pos_node: print_esc("pdfsavepos");
LR_node: case LR_type(p) of
@@ -28788,7 +28757,7 @@ pic_node,pdf_node: begin words:=total_pic_node_size(p);
r:=get_node(words);
end;
pdf_save_pos_node:
- r := get_node(small_node_size);
+ r:=get_node(small_node_size);
othercases confusion("ext2")
@:this can't happen ext2}{\quad ext2@>
endcases
@@ -28804,7 +28773,7 @@ native_word_node: begin free_native_glyph_info(p); free_node(p,native_size(p));
glyph_node: free_node(p,glyph_node_size);
pic_node,pdf_node: free_node(p,total_pic_node_size(p));
pdf_save_pos_node:
- free_node(p, small_node_size);
+ free_node(p, small_node_size);
othercases confusion("ext3")
@:this can't happen ext3}{\quad ext3@>
endcases;@/
@@ -28813,109 +28782,100 @@ end
@ @<Incorporate a whatsit node into a vbox@>=
begin
- if (subtype(p)=pic_node)
- or (subtype(p)=pdf_node)
- then begin
- x := x + d + height(p);
- d := depth(p);
- if width(p) > w then w := width(p);
- end;
+ if (subtype(p)=pic_node)
+ or (subtype(p)=pdf_node)
+ then begin
+ x:=x + d + height(p);
+ d:=depth(p);
+ if width(p) > w then w:=width(p);
+ end;
end
@ @<Incorporate a whatsit node into an hbox@>=
begin
- case subtype(p) of
-
- native_word_node:
- begin
- { merge with any following word fragments in same font, discarding discretionary breaks }
- if type(q) = disc_node then k:=replace_count(q) else k:=0;
- while (link(q) <> p) do begin
- decr(k);
- q := link(q); { bring q up in preparation for deletion of nodes starting at p }
- if type(q) = disc_node then k:=replace_count(q);
- end;
- pp := link(p);
- restart:
- if (k <= 0) and (pp <> null) and (not is_char_node(pp)) then begin
- if (type(pp) = whatsit_node)
- and (subtype(pp) = native_word_node)
- and (native_font(pp) = native_font(p)) then begin
- pp := link(pp);
- goto restart;
- end
- else if (type(pp) = disc_node) then begin
- ppp := link(pp);
- if is_native_word_node(ppp)
- and (native_font(ppp) = native_font(p)) then begin
- pp := link(ppp);
- goto restart;
- end
- end
- end;
-
- { now pp points to the non-|native_word| node that ended the chain, or null }
-
- { we can just check type(p)=|whatsit_node| below, as we know that the chain
- contains only discretionaries and |native_word| nodes, no other whatsits or |char_node|s }
-
- if (pp <> link(p)) then begin
- { found a chain of at least two pieces starting at p }
- total_chars := 0;
- p := link(q); { the first fragment }
- while (p <> pp) do begin
- if (type(p) = whatsit_node) then
- total_chars := total_chars + native_length(p); { accumulate char count }
- ppp := p; { remember last node seen }
- p := link(p); { point to next fragment or discretionary or terminator }
- end;
-
- p := link(q); { the first fragment again }
- pp := new_native_word_node(native_font(p), total_chars); { make new node for merged word }
- link(q) := pp; { link to preceding material }
- link(pp) := link(ppp); { attach remainder of hlist to it }
- link(ppp) := null; { and detach from the old fragments }
-
- { copy the chars into new node }
- total_chars := 0;
- ppp := p;
- repeat
- if (type(ppp) = whatsit_node) then
- for k := 0 to native_length(ppp)-1 do begin
- set_native_char(pp, total_chars, get_native_char(ppp, k));
- incr(total_chars);
- end;
- ppp := link(ppp);
- until (ppp = null);
-
- flush_node_list(p); { delete the fragments }
- p := link(q); { update p to point to the new node }
- set_native_metrics(p, XeTeX_use_glyph_metrics); { and measure it (i.e., re-do the OT layout) }
- end;
-
- { now incorporate the |native_word| node measurements into the box we're packing }
- if height(p) > h then
- h := height(p);
- if depth(p) > d then
- d := depth(p);
- x := x + width(p);
- end;
+ case subtype(p) of
+ native_word_node: begin
+ { merge with any following word fragments in same font, discarding discretionary breaks }
+ if type(q) = disc_node then k:=replace_count(q) else k:=0;
+ while (link(q) <> p) do begin
+ decr(k);
+ q:=link(q); { bring q up in preparation for deletion of nodes starting at p }
+ if type(q) = disc_node then k:=replace_count(q);
+ end;
+ pp:=link(p);
+ restart:
+ if (k <= 0) and (pp <> null) and (not is_char_node(pp)) then begin
+ if (type(pp) = whatsit_node)
+ and (subtype(pp) = native_word_node)
+ and (native_font(pp) = native_font(p)) then begin
+ pp:=link(pp);
+ goto restart;
+ end
+ else if (type(pp) = disc_node) then begin
+ ppp:=link(pp);
+ if is_native_word_node(ppp) and (native_font(ppp) = native_font(p)) then begin
+ pp:=link(ppp);
+ goto restart;
+ end
+ end
+ end;
- glyph_node, pic_node, pdf_node:
- begin
- if height(p) > h then
- h := height(p);
- if depth(p) > d then
- d := depth(p);
- x := x + width(p);
- end;
+ { now pp points to the non-|native_word| node that ended the chain, or null }
+
+ { we can just check type(p)=|whatsit_node| below, as we know that the chain
+ contains only discretionaries and |native_word| nodes, no other whatsits or |char_node|s }
- LR_node: @<Adjust the LR stack for the |hpack| routine@>;
+ if (pp <> link(p)) then begin
+ { found a chain of at least two pieces starting at p }
+ total_chars:=0;
+ p:=link(q); { the first fragment }
+ while (p <> pp) do begin
+ if (type(p) = whatsit_node) then
+ total_chars:=total_chars + native_length(p); { accumulate char count }
+ ppp:=p; { remember last node seen }
+ p:=link(p); { point to next fragment or discretionary or terminator }
+ end;
- othercases
- do_nothing
+ p:=link(q); { the first fragment again }
+ pp:=new_native_word_node(native_font(p), total_chars); { make new node for merged word }
+ link(q):=pp; { link to preceding material }
+ link(pp):=link(ppp); { attach remainder of hlist to it }
+ link(ppp):=null; { and detach from the old fragments }
+
+ { copy the chars into new node }
+ total_chars:=0;
+ ppp:=p;
+ repeat
+ if (type(ppp) = whatsit_node) then
+ for k:=0 to native_length(ppp)-1 do begin
+ set_native_char(pp, total_chars, get_native_char(ppp, k));
+ incr(total_chars);
+ end;
+ ppp:=link(ppp);
+ until (ppp = null);
- endcases
+ flush_node_list(p); { delete the fragments }
+ p:=link(q); { update p to point to the new node }
+ set_native_metrics(p, XeTeX_use_glyph_metrics); { and measure it (i.e., re-do the OT layout) }
+ end;
+
+ { now incorporate the |native_word| node measurements into the box we're packing }
+ if height(p) > h then
+ h:=height(p);
+ if depth(p) > d then
+ d:=depth(p);
+ x:=x + width(p);
+ end;
+ glyph_node, pic_node, pdf_node: begin
+ if height(p) > h then
+ h:=height(p);
+ if depth(p) > d then
+ d:=depth(p);
+ x:=x + width(p);
+ end;
+ LR_node: @<Adjust the LR stack for the |hpack| routine@>;
+ othercases do_nothing
+ endcases;
end
@ @<Let |d| be the width of the whatsit |p|, and |goto found| if ``visible''@>=
@@ -28924,10 +28884,10 @@ or (subtype(p)=glyph_node)
or (subtype(p)=pic_node)
or (subtype(p)=pdf_node)
then begin
- d:=width(p);
- goto found;
+ d:=width(p);
+ goto found;
end else
- d := 0
+ d:=0
@ @d adv_past_linebreak(#)==@+if subtype(#)=language_node then
begin cur_lang:=what_lang(#); l_hyf:=what_lhm(#); r_hyf:=what_rhm(#);
@@ -28953,82 +28913,73 @@ adv_past_prehyph(s)
@ @<Prepare to move whatsit |p| to the current page, then |goto contribute|@>=
begin
- if (subtype(p)=pic_node)
- or (subtype(p)=pdf_node)
- then begin
- page_total := page_total + page_depth + height(p);
- page_depth := depth(p);
- end;
- goto contribute;
+ if (subtype(p)=pic_node)
+ or (subtype(p)=pdf_node)
+ then begin
+ page_total:=page_total + page_depth + height(p);
+ page_depth:=depth(p);
+ end;
+ goto contribute;
end
@ @<Process whatsit |p| in |vert_break| loop, |goto not_found|@>=
begin
- if (subtype(p)=pic_node)
- or (subtype(p)=pdf_node)
- then begin
- cur_height := cur_height + prev_dp + height(p); prev_dp := depth(p);
- end;
- goto not_found;
+ if (subtype(p)=pic_node)
+ or (subtype(p)=pdf_node)
+ then begin
+ cur_height:=cur_height + prev_dp + height(p); prev_dp:=depth(p);
+ end;
+ goto not_found;
end
@ @<Output the whatsit node |p| in a vlist@>=
begin
- case subtype(p) of
- glyph_node: begin
- cur_v:=cur_v+height(p);
- cur_h:=left_edge;
-
- { synch DVI state to TeX state }
- synch_h; synch_v;
- f := native_font(p);
- if f<>dvi_f then @<Change font |dvi_f| to |f|@>;
-
- dvi_out(set_glyph_string);
- dvi_four(0); { width }
- dvi_two(1); { glyph count }
- dvi_four(0); { x-offset as fixed point }
- dvi_two(native_glyph(p));
-
- cur_v:=cur_v+depth(p);
- cur_h:=left_edge;
- end;
- pic_node, pdf_node: begin
- save_h:=dvi_h; save_v:=dvi_v;
- cur_v:=cur_v+height(p);
- pic_out(p, subtype(p) = pdf_node);
- dvi_h:=save_h; dvi_v:=save_v;
- cur_v:=save_v+depth(p); cur_h:=left_edge;
- end;
-
- pdf_save_pos_node:
- @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>;
-
- LR_node: @<Output a reflection instruction if the direction has changed@>;
-
- othercases
- out_what(p)
-
- endcases
+ case subtype(p) of
+ glyph_node: begin
+ cur_v:=cur_v+height(p);
+ cur_h:=left_edge;
+ synch_h; synch_v; {Sync DVI state to TeX state}
+ f:=native_font(p);
+ if f<>dvi_f then @<Change font |dvi_f| to |f|@>;
+ dvi_out(set_glyphs);
+ dvi_four(0); { width }
+ dvi_two(1); { glyph count }
+ dvi_four(0); { x-offset as fixed point }
+ dvi_four(0); { y-offset as fixed point }
+ dvi_two(native_glyph(p));
+ cur_v:=cur_v+depth(p);
+ cur_h:=left_edge;
+ end;
+ pic_node, pdf_node: begin
+ save_h:=dvi_h; save_v:=dvi_v;
+ cur_v:=cur_v+height(p);
+ pic_out(p);
+ dvi_h:=save_h; dvi_v:=save_v;
+ cur_v:=save_v+depth(p); cur_h:=left_edge;
+ end;
+ pdf_save_pos_node: @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>;
+ LR_node: @<Output a reflection instruction if the direction has changed@>;
+ othercases out_what(p)
+ endcases
end
@ @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>=
begin
- pdf_last_x_pos := cur_h + cur_h_offset;
- pdf_last_y_pos := cur_page_height - cur_v - cur_v_offset
+ pdf_last_x_pos:=cur_h + cur_h_offset;
+ pdf_last_y_pos:=cur_page_height - cur_v - cur_v_offset
end
@ @<Calculate page dimensions and margins@>=
-cur_h_offset := h_offset + (unity * 7227) / 100;
-cur_v_offset := v_offset + (unity * 7227) / 100;
+cur_h_offset:=h_offset + (unity * 7227) / 100;
+cur_v_offset:=v_offset + (unity * 7227) / 100;
if pdf_page_width <> 0 then
- cur_page_width := pdf_page_width
+ cur_page_width:=pdf_page_width
else
- cur_page_width := width(p) + 2*cur_h_offset;
+ cur_page_width:=width(p) + 2*cur_h_offset;
if pdf_page_height <> 0 then
- cur_page_height := pdf_page_height
+ cur_page_height:=pdf_page_height
else
- cur_page_height := height(p) + depth(p) + 2*cur_v_offset
+ cur_page_height:=height(p) + depth(p) + 2*cur_v_offset
@ @<Glob...@>=
@!cur_page_width: scaled; {width of page being shipped}
@@ -29038,50 +28989,42 @@ else
@ @<Output the whatsit node |p| in an hlist@>=
begin
- case subtype(p) of
- native_word_node, glyph_node: begin
- { synch DVI state to TeX state }
- synch_h; synch_v;
- f := native_font(p);
- if f<>dvi_f then @<Change font |dvi_f| to |f|@>;
-
- if subtype(p) = glyph_node then begin
- dvi_out(set_glyph_string);
- dvi_four(width(p));
- dvi_two(1); { glyph count }
- dvi_four(0); { x-offset as fixed point }
- dvi_two(native_glyph(p));
- cur_h := cur_h + width(p);
- end else begin
- if native_glyph_info_ptr(p) <> null_ptr then begin
- len := make_xdv_glyph_array_data(p);
- for k := 0 to len-1 do
- dvi_out(xdv_buffer_byte(k));
- end;
- cur_h := cur_h + width(p);
- end;
-
- dvi_h := cur_h;
- end;
-
- pic_node, pdf_node: begin
- save_h:=dvi_h; save_v:=dvi_v;
- cur_v:=base_line;
- edge:=cur_h+width(p);
- pic_out(p, subtype(p) = pdf_node);
- dvi_h:=save_h; dvi_v:=save_v;
- cur_h:=edge; cur_v:=base_line;
+ case subtype(p) of
+ native_word_node, glyph_node: begin
+ synch_h; synch_v; {Sync DVI state to TeX state}
+ f:=native_font(p);
+ if f<>dvi_f then @<Change font |dvi_f| to |f|@>;
+ if subtype(p) = glyph_node then begin
+ dvi_out(set_glyphs);
+ dvi_four(width(p));
+ dvi_two(1); { glyph count }
+ dvi_four(0); { x-offset as fixed point }
+ dvi_four(0); { y-offset as fixed point }
+ dvi_two(native_glyph(p));
+ cur_h:=cur_h + width(p);
+ end else begin
+ if native_glyph_info_ptr(p) <> null_ptr then begin
+ dvi_out(set_glyphs);
+ len:=make_xdv_glyph_array_data(p);
+ for k:=0 to len-1 do
+ dvi_out(xdv_buffer_byte(k));
+ end;
+ cur_h:=cur_h + width(p);
end;
-
- pdf_save_pos_node:
- @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>;
-
- LR_node: @<Output a reflection instruction if the direction has changed@>;
-
- othercases
- out_what(p)
-
- endcases
+ dvi_h:=cur_h;
+ end;
+ pic_node, pdf_node: begin
+ save_h:=dvi_h; save_v:=dvi_v;
+ cur_v:=base_line;
+ edge:=cur_h+width(p);
+ pic_out(p);
+ dvi_h:=save_h; dvi_v:=save_v;
+ cur_h:=edge; cur_v:=base_line;
+ end;
+ pdf_save_pos_node: @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>;
+ LR_node: @<Output a reflection instruction if the direction has changed@>;
+ othercases out_what(p)
+ endcases
end
@ After all this preliminary shuffling, we come finally to the routines
@@ -29093,7 +29036,7 @@ procedure special_out(@!p:pointer);
var old_setting:0..max_selector; {holds print |selector|}
@!k:pool_pointer; {index into |str_pool|}
begin synch_h; synch_v;@/
-doing_special := true;
+doing_special:=true;
old_setting:=selector; selector:=new_string;
show_token_list(link(write_tokens(p)),null,pool_size-pool_ptr);
selector:=old_setting;
@@ -29105,7 +29048,7 @@ else begin dvi_out(xxx4); dvi_four(cur_length);
end;
for k:=str_start_macro(str_ptr) to pool_ptr-1 do dvi_out(so(str_pool[k]));
pool_ptr:=str_start_macro(str_ptr); {erase the string}
-doing_special := false;
+doing_special:=false;
end;
@ To write a token list, we must run it through \TeX's scanner, expanding
@@ -29178,26 +29121,34 @@ end
|vlist_out| and |hlist_out|\kern-.3pt.
@<Declare procedures needed in |hlist_out|, |vlist_out|@>=
-procedure pic_out(@!p:pointer; @!is_pdf:boolean);
-var
+procedure pic_out(@!p:pointer);
+var old_setting:0..max_selector; {holds print |selector|}
i:integer;
+ k:pool_pointer; {index into |str_pool|}
begin
synch_h; synch_v;
-dvi_out(pic_file);
-if is_pdf then
- dvi_out(pic_box_type(p))
-else
- dvi_out(0);
-dvi_four(pic_transform1(p));
-dvi_four(pic_transform2(p));
-dvi_four(pic_transform3(p));
-dvi_four(pic_transform4(p));
-dvi_four(pic_transform5(p));
-dvi_four(pic_transform6(p));
-dvi_two(pic_page(p));
-dvi_two(pic_path_length(p));
+old_setting:=selector; selector:=new_string;
+print("pdf:image ");
+print("matrix ");
+print_scaled(pic_transform1(p)); print(" ");
+print_scaled(pic_transform2(p)); print(" ");
+print_scaled(pic_transform3(p)); print(" ");
+print_scaled(pic_transform4(p)); print(" ");
+print_scaled(pic_transform5(p)); print(" ");
+print_scaled(pic_transform6(p)); print(" ");
+print("page "); print_int(pic_page(p)); print(" ");
+print("(");
for i:=0 to pic_path_length(p)-1 do
- dvi_out(pic_path_byte(p, i));
+ print_visible_char(pic_path_byte(p, i));
+print(")");
+selector:=old_setting;
+if cur_length<256 then
+ begin dvi_out(xxx1); dvi_out(cur_length);
+ end
+else begin dvi_out(xxx4); dvi_four(cur_length);
+ end;
+for k:=str_start_macro(str_ptr) to pool_ptr-1 do dvi_out(so(str_pool[k]));
+pool_ptr:=str_start_macro(str_ptr); {erase the string}
end;
procedure out_what(@!p:pointer);
@@ -29317,202 +29268,196 @@ end
@ Load a picture file and handle following keywords.
@d calc_min_and_max==
- begin
- xmin := 1000000.0;
- xmax := -xmin;
- ymin := xmin;
- ymax := xmax;
- for i := 0 to 3 do begin
- if xCoord(corners[i]) < xmin then xmin := xCoord(corners[i]);
- if xCoord(corners[i]) > xmax then xmax := xCoord(corners[i]);
- if yCoord(corners[i]) < ymin then ymin := yCoord(corners[i]);
- if yCoord(corners[i]) > ymax then ymax := yCoord(corners[i]);
- end;
- end
+ begin
+ xmin:=1000000.0;
+ xmax:=-xmin;
+ ymin:=xmin;
+ ymax:=xmax;
+ for i:=0 to 3 do begin
+ if xCoord(corners[i]) < xmin then xmin:=xCoord(corners[i]);
+ if xCoord(corners[i]) > xmax then xmax:=xCoord(corners[i]);
+ if yCoord(corners[i]) < ymin then ymin:=yCoord(corners[i]);
+ if yCoord(corners[i]) > ymax then ymax:=yCoord(corners[i]);
+ end;
+ end
@d update_corners==
- for i := 0 to 3 do
- transform_point(addressof(corners[i]), addressof(t2))
+ for i:=0 to 3 do
+ transform_point(addressof(corners[i]), addressof(t2))
@d do_size_requests==begin
- { calculate current width and height }
- calc_min_and_max;
- if x_size_req = 0.0 then begin
- make_scale(addressof(t2), y_size_req / (ymax - ymin), y_size_req / (ymax - ymin));
- end else if y_size_req = 0.0 then begin
- make_scale(addressof(t2), x_size_req / (xmax - xmin), x_size_req / (xmax - xmin));
- end else begin
- make_scale(addressof(t2), x_size_req / (xmax - xmin), y_size_req / (ymax - ymin));
- end;
- update_corners;
- x_size_req := 0.0;
- y_size_req := 0.0;
- transform_concat(addressof(t), addressof(t2));
+ { calculate current width and height }
+ calc_min_and_max;
+ if x_size_req = 0.0 then begin
+ make_scale(addressof(t2), y_size_req / (ymax - ymin), y_size_req / (ymax - ymin));
+ end else if y_size_req = 0.0 then begin
+ make_scale(addressof(t2), x_size_req / (xmax - xmin), x_size_req / (xmax - xmin));
+ end else begin
+ make_scale(addressof(t2), x_size_req / (xmax - xmin), y_size_req / (ymax - ymin));
+ end;
+ update_corners;
+ x_size_req:=0.0;
+ y_size_req:=0.0;
+ transform_concat(addressof(t), addressof(t2));
end
@<Declare procedures needed in |do_extension|@>=
procedure load_picture(@!is_pdf:boolean);
var
- pic_path: ^char;
- bounds: real_rect;
- t, t2: transform;
- corners: array[0..3] of real_point;
- x_size_req,y_size_req: real;
- check_keywords: boolean;
- xmin,xmax,ymin,ymax: real;
- i: small_number;
- page: integer;
- pdf_box_type: integer;
- result: integer;
+ pic_path: ^char;
+ bounds: real_rect;
+ t, t2: transform;
+ corners: array[0..3] of real_point;
+ x_size_req,y_size_req: real;
+ check_keywords: boolean;
+ xmin,xmax,ymin,ymax: real;
+ i: small_number;
+ page: integer;
+ pdf_box_type: integer;
+ result: integer;
begin
- { scan the filename and pack into |name_of_file| }
- scan_file_name;
- pack_cur_name;
+ { scan the filename and pack into |name_of_file| }
+ scan_file_name;
+ pack_cur_name;
- pdf_box_type := 0;
- page := 0;
- if is_pdf then begin
- if scan_keyword("page") then begin
- scan_int;
- page := cur_val;
- end;
- pdf_box_type := pdfbox_crop;
- if scan_keyword("crop") then do_nothing
- else if scan_keyword("media") then pdf_box_type := pdfbox_media
- else if scan_keyword("bleed") then pdf_box_type := pdfbox_bleed
- else if scan_keyword("trim") then pdf_box_type := pdfbox_trim
- else if scan_keyword("art") then pdf_box_type := pdfbox_art;
- end;
-
- { access the picture file and check its size }
- result := find_pic_file(addressof(pic_path), addressof(bounds), pdf_box_type, page);
-
- setPoint(corners[0], xField(bounds), yField(bounds));
- setPoint(corners[1], xField(corners[0]), yField(bounds) + htField(bounds));
- setPoint(corners[2], xField(bounds) + wdField(bounds), yField(corners[1]));
- setPoint(corners[3], xField(corners[2]), yField(corners[0]));
-
- x_size_req := 0.0;
- y_size_req := 0.0;
-
- { look for any scaling requests for this picture }
- make_identity(addressof(t));
-
- check_keywords := true;
- while check_keywords do begin
- if scan_keyword("scaled") then begin
- scan_int;
- if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
- make_scale(addressof(t2), float(cur_val) / 1000.0, float(cur_val) / 1000.0);
- update_corners;
- transform_concat(addressof(t), addressof(t2));
- end
- end else if scan_keyword("xscaled") then begin
- scan_int;
- if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
- make_scale(addressof(t2), float(cur_val) / 1000.0, 1.0);
- update_corners;
- transform_concat(addressof(t), addressof(t2));
- end
- end else if scan_keyword("yscaled") then begin
- scan_int;
- if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
- make_scale(addressof(t2), 1.0, float(cur_val) / 1000.0);
- update_corners;
- transform_concat(addressof(t), addressof(t2));
- end
- end else if scan_keyword("width") then begin
- scan_normal_dimen;
- if cur_val <= 0 then begin
- print_err("Improper image ");
- print("size (");
- print_scaled(cur_val);
- print("pt) will be ignored");
- help2("I can't scale images to zero or negative sizes,")@/
- ("so I'm ignoring this.");
- error;
- end else
- x_size_req := Fix2D(cur_val);
- end else if scan_keyword("height") then begin
- scan_normal_dimen;
- if cur_val <= 0 then begin
- print_err("Improper image ");
- print("size (");
- print_scaled(cur_val);
- print("pt) will be ignored");
- help2("I can't scale images to zero or negative sizes,")@/
- ("so I'm ignoring this.");
- error;
- end else
- y_size_req := Fix2D(cur_val);
- end else if scan_keyword("rotated") then begin
- scan_decimal;
- if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests;
- make_rotation(addressof(t2), Fix2D(cur_val) * 3.141592653589793 / 180.0);
- update_corners;
- calc_min_and_max;
- setPoint(corners[0], xmin, ymin);
- setPoint(corners[1], xmin, ymax);
- setPoint(corners[2], xmax, ymax);
- setPoint(corners[3], xmax, ymin);
- transform_concat(addressof(t), addressof(t2));
- end else
- check_keywords := false;
+ pdf_box_type:=0;
+ page:=0;
+ if is_pdf then begin
+ if scan_keyword("page") then begin
+ scan_int;
+ page:=cur_val;
end;
+ pdf_box_type:=pdfbox_crop;
+ if scan_keyword("crop") then do_nothing
+ else if scan_keyword("media") then pdf_box_type:=pdfbox_media
+ else if scan_keyword("bleed") then pdf_box_type:=pdfbox_bleed
+ else if scan_keyword("trim") then pdf_box_type:=pdfbox_trim
+ else if scan_keyword("art") then pdf_box_type:=pdfbox_art;
+ end;
- if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests;
+ { access the picture file and check its size }
+ result:=find_pic_file(addressof(pic_path), addressof(bounds), pdf_box_type, page);
- calc_min_and_max;
- make_translation(addressof(t2), -xmin * 72 / 72.27, -ymin * 72 / 72.27);
- transform_concat(addressof(t), addressof(t2));
+ setPoint(corners[0], xField(bounds), yField(bounds));
+ setPoint(corners[1], xField(corners[0]), yField(bounds) + htField(bounds));
+ setPoint(corners[2], xField(bounds) + wdField(bounds), yField(corners[1]));
+ setPoint(corners[3], xField(corners[2]), yField(corners[0]));
- if result = 0 then begin
+ x_size_req:=0.0;
+ y_size_req:=0.0;
- new_whatsit(pic_node, pic_node_size + (strlen(pic_path) + sizeof(memory_word) - 1) div sizeof(memory_word));
- if is_pdf then begin
- subtype(tail) := pdf_node;
- pic_box_type(tail) := pdf_box_type;
- end;
- pic_path_length(tail) := strlen(pic_path);
- pic_page(tail) := page;
+ { look for any scaling requests for this picture }
+ make_identity(addressof(t));
+
+ check_keywords:=true;
+ while check_keywords do begin
+ if scan_keyword("scaled") then begin
+ scan_int;
+ if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
+ make_scale(addressof(t2), float(cur_val) / 1000.0, float(cur_val) / 1000.0);
+ update_corners;
+ transform_concat(addressof(t), addressof(t2));
+ end
+ end else if scan_keyword("xscaled") then begin
+ scan_int;
+ if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
+ make_scale(addressof(t2), float(cur_val) / 1000.0, 1.0);
+ update_corners;
+ transform_concat(addressof(t), addressof(t2));
+ end
+ end else if scan_keyword("yscaled") then begin
+ scan_int;
+ if (x_size_req = 0.0) and (y_size_req = 0.0) then begin
+ make_scale(addressof(t2), 1.0, float(cur_val) / 1000.0);
+ update_corners;
+ transform_concat(addressof(t), addressof(t2));
+ end
+ end else if scan_keyword("width") then begin
+ scan_normal_dimen;
+ if cur_val <= 0 then begin
+ print_err("Improper image ");
+ print("size (");
+ print_scaled(cur_val);
+ print("pt) will be ignored");
+ help2("I can't scale images to zero or negative sizes,")@/
+ ("so I'm ignoring this.");
+ error;
+ end else
+ x_size_req:=Fix2D(cur_val);
+ end else if scan_keyword("height") then begin
+ scan_normal_dimen;
+ if cur_val <= 0 then begin
+ print_err("Improper image ");
+ print("size (");
+ print_scaled(cur_val);
+ print("pt) will be ignored");
+ help2("I can't scale images to zero or negative sizes,")@/
+ ("so I'm ignoring this.");
+ error;
+ end else
+ y_size_req:=Fix2D(cur_val);
+ end else if scan_keyword("rotated") then begin
+ scan_decimal;
+ if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests;
+ make_rotation(addressof(t2), Fix2D(cur_val) * 3.141592653589793 / 180.0);
+ update_corners;
+ calc_min_and_max;
+ setPoint(corners[0], xmin, ymin);
+ setPoint(corners[1], xmin, ymax);
+ setPoint(corners[2], xmax, ymax);
+ setPoint(corners[3], xmax, ymin);
+ transform_concat(addressof(t), addressof(t2));
+ end else
+ check_keywords:=false;
+ end;
- width(tail) := D2Fix(xmax - xmin);
- height(tail) := D2Fix(ymax - ymin);
- depth(tail) := 0;
+ if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests;
- pic_transform1(tail) := D2Fix(aField(t));
- pic_transform2(tail) := D2Fix(bField(t));
- pic_transform3(tail) := D2Fix(cField(t));
- pic_transform4(tail) := D2Fix(dField(t));
- pic_transform5(tail) := D2Fix(xField(t));
- pic_transform6(tail) := D2Fix(yField(t));
+ calc_min_and_max;
+ make_translation(addressof(t2), -xmin * 72 / 72.27, -ymin * 72 / 72.27);
+ transform_concat(addressof(t), addressof(t2));
- memcpy(addressof(mem[tail + pic_node_size]), pic_path, strlen(pic_path));
- libc_free(pic_path);
+ if result = 0 then begin
+ new_whatsit(pic_node, pic_node_size + (strlen(pic_path) + sizeof(memory_word) - 1) div sizeof(memory_word));
+ if is_pdf then begin
+ subtype(tail):=pdf_node;
+ end;
+ pic_path_length(tail):=strlen(pic_path);
+ pic_page(tail):=page;
- end else begin
+ width(tail):=D2Fix(xmax - xmin);
+ height(tail):=D2Fix(ymax - ymin);
+ depth(tail):=0;
- print_err("Unable to load picture or PDF file '");
- print_file_name(cur_name,cur_area,cur_ext); print("'");
- if result = -43 then begin { Mac OS file not found error }
- help2("The requested image couldn't be read because")@/
- ("the file was not found.");
- end
- else begin { otherwise assume GraphicImport failed }
- help2("The requested image couldn't be read because")@/
- ("it was not a recognized image format.");
- end;
- error;
+ pic_transform1(tail):=D2Fix(aField(t));
+ pic_transform2(tail):=D2Fix(bField(t));
+ pic_transform3(tail):=D2Fix(cField(t));
+ pic_transform4(tail):=D2Fix(dField(t));
+ pic_transform5(tail):=D2Fix(xField(t));
+ pic_transform6(tail):=D2Fix(yField(t));
+ memcpy(addressof(mem[tail + pic_node_size]), pic_path, strlen(pic_path));
+ libc_free(pic_path);
+ end else begin
+ print_err("Unable to load picture or PDF file '");
+ print_file_name(cur_name,cur_area,cur_ext); print("'");
+ if result = -43 then begin { Mac OS file not found error }
+ help2("The requested image couldn't be read because")@/
+ ("the file was not found.");
+ end
+ else begin { otherwise assume GraphicImport failed }
+ help2("The requested image couldn't be read because")@/
+ ("it was not a recognized image format.");
end;
-
+ error;
+ end;
end;
@ @<Implement \.{\\XeTeXinputencoding}@>=
begin
scan_and_pack_name; {scan a filename-like arg for the input encoding}
- i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values}
+ i:=get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values}
if i = XeTeX_input_mode_auto then begin
print_err("Encoding mode `auto' is not valid for \XeTeXinputencoding");
help2("You can't use `auto' encoding here, only for \XeTeXdefaultencoding.")@/
@@ -29523,18 +29468,18 @@ end
@ @<Implement \.{\\XeTeXdefaultencoding}@>=
begin
- scan_and_pack_name; {scan a filename-like arg for the input encoding}
+ scan_and_pack_name; {scan a filename-like arg for the input encoding}
- i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values}
- XeTeX_default_input_mode := i; {store them as defaults for new input files}
- XeTeX_default_input_encoding := j;
+ i:=get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values}
+ XeTeX_default_input_mode:=i; {store them as defaults for new input files}
+ XeTeX_default_input_encoding:=j;
end
@ @<Implement \.{\\XeTeXlinebreaklocale}@>=
begin
- scan_file_name; {scan a filename-like arg for the locale name}
- if length(cur_name) = 0 then XeTeX_linebreak_locale := 0
- else XeTeX_linebreak_locale := cur_name; {we ignore the area and extension!}
+ scan_file_name; {scan a filename-like arg for the locale name}
+ if length(cur_name) = 0 then XeTeX_linebreak_locale:=0
+ else XeTeX_linebreak_locale:=cur_name; {we ignore the area and extension!}
end
@ @<Glob...@>=
@@ -29543,7 +29488,7 @@ end
@ @<Implement \.{\\pdfsavepos}@>=
begin
- new_whatsit(pdf_save_pos_node, small_node_size);
+ new_whatsit(pdf_save_pos_node, small_node_size);
end
@@ -29709,15 +29654,6 @@ XeTeX_count_glyphs_code:
cur_val:=0;
end;
-XeTeX_count_variations_code:
- begin
- scan_font_ident; n:=cur_val;
- if is_aat_font(n) then
- cur_val:=aat_font_get(m - XeTeX_int, font_layout_engine[n])
- else begin
- cur_val:=0;
- end;
- end;
XeTeX_count_features_code:
begin
scan_font_ident; n:=cur_val;
@@ -29732,16 +29668,9 @@ XeTeX_count_features_code:
XeTeX_variation_code,
XeTeX_variation_min_code,
XeTeX_variation_max_code,
-XeTeX_variation_default_code:
- begin
- scan_font_ident; n:=cur_val;
- if is_aat_font(n) then begin
- scan_int; k:=cur_val;
- cur_val:=aat_font_get_1(m - XeTeX_int, font_layout_engine[n], k);
- end else begin
- not_aat_font_error(last_item, m, n); cur_val:=-1;
- end;
- end;
+XeTeX_variation_default_code,
+XeTeX_count_variations_code:
+ cur_val:=0; {Deprecated}
XeTeX_feature_code_code,
XeTeX_is_exclusive_feature_code,
@@ -29897,8 +29826,8 @@ XeTeX_first_char_code,XeTeX_last_char_code:
end
end;
- pdf_last_x_pos_code: cur_val := pdf_last_x_pos;
- pdf_last_y_pos_code: cur_val := pdf_last_y_pos;
+ pdf_last_x_pos_code: cur_val:=pdf_last_x_pos;
+ pdf_last_y_pos_code: cur_val:=pdf_last_y_pos;
XeTeX_pdf_page_count_code:
begin
@@ -29982,14 +29911,14 @@ XeTeX_glyph_name_code: print_esc("XeTeXglyphname");
eTeX_revision_code: do_nothing;
pdf_strcmp_code:
begin
- save_scanner_status := scanner_status;
- save_warning_index := warning_index;
- save_def_ref := def_ref;
+ save_scanner_status:=scanner_status;
+ save_warning_index:=warning_index;
+ save_def_ref:=def_ref;
save_cur_string;
compare_strings;
- def_ref := save_def_ref;
- warning_index := save_warning_index;
- scanner_status := save_scanner_status;
+ def_ref:=save_def_ref;
+ warning_index:=save_warning_index;
+ scanner_status:=save_scanner_status;
restore_cur_string;
end;
XeTeX_revision_code: do_nothing;
@@ -30043,48 +29972,46 @@ pdf_strcmp_code: print_int(cur_val);
XeTeX_revision_code: print(XeTeX_revision);
XeTeX_variation_name_code:
- if is_aat_font(fnt) then
- aat_print_font_name(c, font_layout_engine[fnt], arg1, arg2);
+ if is_aat_font(fnt) then
+ aat_print_font_name(c, font_layout_engine[fnt], arg1, arg2);
XeTeX_feature_name_code,
XeTeX_selector_name_code:
- if is_aat_font(fnt) then
- aat_print_font_name(c, font_layout_engine[fnt], arg1, arg2)
- else if is_gr_font(fnt) then
- gr_print_font_name(c, font_layout_engine[fnt], arg1, arg2);
+ if is_aat_font(fnt) then
+ aat_print_font_name(c, font_layout_engine[fnt], arg1, arg2)
+ else if is_gr_font(fnt) then
+ gr_print_font_name(c, font_layout_engine[fnt], arg1, arg2);
XeTeX_glyph_name_code:
- if is_native_font(fnt) then print_glyph_name(fnt, arg1);
+ if is_native_font(fnt) then print_glyph_name(fnt, arg1);
left_margin_kern_code: begin
- p := list_ptr(p);
- while (p <> null) and
- (cp_skipable(p) or
- ((not is_char_node(p)) and (type(p) = glue_node) and (subtype(p) = left_skip_code + 1)))
- do
- p := link(p);
- if (p <> null) and (not is_char_node(p)) and
- (type(p) = margin_kern_node) and (subtype(p) = left_side) then
- print_scaled(width(p))
- else
- print("0");
- print("pt");
+ p:=list_ptr(p);
+ while (p <> null) and
+ (cp_skipable(p) or
+ ((not is_char_node(p)) and (type(p) = glue_node) and (subtype(p) = left_skip_code + 1)))
+ do
+ p:=link(p);
+ if (p <> null) and (not is_char_node(p)) and (type(p) = margin_kern_node) and (subtype(p) = left_side) then
+ print_scaled(width(p))
+ else
+ print("0");
+ print("pt");
end;
right_margin_kern_code: begin
- q := list_ptr(p);
- p := prev_rightmost(q, null);
- while (p <> null) and
- (cp_skipable(p) or
- ((not is_char_node(p)) and (type(p) = glue_node) and (subtype(p) = right_skip_code + 1)))
- do
- p := prev_rightmost(q, p);
- if (p <> null) and (not is_char_node(p)) and
- (type(p) = margin_kern_node) and (subtype(p) = right_side) then
- print_scaled(width(p))
- else
- print("0");
- print("pt");
+ q:=list_ptr(p);
+ p:=prev_rightmost(q, null);
+ while (p <> null) and
+ (cp_skipable(p) or
+ ((not is_char_node(p)) and (type(p) = glue_node) and (subtype(p) = right_skip_code + 1)))
+ do
+ p:=prev_rightmost(q, p);
+ if (p <> null) and (not is_char_node(p)) and (type(p) = margin_kern_node) and (subtype(p) = right_side) then
+ print_scaled(width(p))
+ else
+ print("0");
+ print("pt");
end;
@ @d eTeX_ex==(eTeX_mode=1) {is this extended mode?}
@@ -30312,10 +30239,10 @@ font_char_dp_code,
font_char_ic_code: begin scan_font_ident; q:=cur_val; scan_usv_num;
if is_native_font(q) then begin
case m of
- font_char_wd_code: cur_val := getnativecharwd(q, cur_val);
- font_char_ht_code: cur_val := getnativecharht(q, cur_val);
- font_char_dp_code: cur_val := getnativechardp(q, cur_val);
- font_char_ic_code: cur_val := getnativecharic(q, cur_val);
+ font_char_wd_code: cur_val:=getnativecharwd(q, cur_val);
+ font_char_ht_code: cur_val:=getnativecharht(q, cur_val);
+ font_char_dp_code: cur_val:=getnativechardp(q, cur_val);
+ font_char_ic_code: cur_val:=getnativecharic(q, cur_val);
end; {there are no other cases}
end else begin
if (font_bc[q]<=cur_val)and(font_ec[q]>=cur_val) then
@@ -30651,7 +30578,7 @@ primitive("middle",left_right,middle_noad);
@ @<Cases of |left_right| for |print_cmd_chr|@>=
else if chr_code=middle_noad then print_esc("middle")
-@ @d TeXXeT_state==eTeX_state(TeXXeT_code)
+@
@d XeTeX_upwards_state==eTeX_state(XeTeX_upwards_code)
@d XeTeX_upwards==(XeTeX_upwards_state>0)
@@ -30683,19 +30610,19 @@ eTeX_state_code+XeTeX_tracing_fonts_code:print_esc("XeTeXtracingfonts");
@ @<Generate all \eTeX...@>=
primitive("suppressfontnotfounderror",assign_int,int_base+suppress_fontnotfound_error_code);@/
primitive("TeXXeTstate",assign_int,eTeX_state_base+TeXXeT_code);
-@!@:TeXXeT_state_}{\.{\\TeXXeT_state} primitive@>
+@!@:TeXXeT_state_}{\.{\\TeXXeTstate} primitive@>
primitive("XeTeXupwardsmode",assign_int,eTeX_state_base+XeTeX_upwards_code);
-@!@:XeTeX_upwards_mode_}{\.{\\XeTeX_upwards_mode} primitive@>
+@!@:XeTeX_upwards_mode_}{\.{\\XeTeXupwardsmode} primitive@>
primitive("XeTeXuseglyphmetrics",assign_int,eTeX_state_base+XeTeX_use_glyph_metrics_code);
-@!@:XeTeX_use_glyph_metrics_}{\.{\\XeTeX_use_glyph_metrics} primitive@>
+@!@:XeTeX_use_glyph_metrics_}{\.{\\XeTeXuseglyphmetrics} primitive@>
primitive("XeTeXinterchartokenstate",assign_int,eTeX_state_base+XeTeX_inter_char_tokens_code);
-@!@:XeTeX_use_inter_char_tokens_}{\.{\\XeTeX_use_inter_char_tokens} primitive@>
+@!@:XeTeX_use_inter_char_tokens_}{\.{\\XeTeXinterchartokenstate} primitive@>
primitive("XeTeXdashbreakstate",assign_int,eTeX_state_base+XeTeX_dash_break_code);
-@!@:XeTeX_dash_break_state_}{\.{\\XeTeX_dash_break_state} primitive@>
+@!@:XeTeX_dash_break_state_}{\.{\\XeTeXdashbreakstate} primitive@>
primitive("XeTeXinputnormalization",assign_int,eTeX_state_base+XeTeX_input_normalization_code);
-@!@:XeTeX_input_normalization_}{\.{\\XeTeX_input_normalization} primitive@>
+@!@:XeTeX_input_normalization_}{\.{\\XeTeXinputnormalization} primitive@>
primitive("XeTeXtracingfonts",assign_int,eTeX_state_base+XeTeX_tracing_fonts_code);
@@ -30917,7 +30844,7 @@ preceding the mandatory \.{\\endcsname} have been expanded).
@<Cases for |conditional|@>=
if_cs_code:begin n:=get_avail; p:=n; {head of the list of characters}
- e := is_in_csname; is_in_csname := true;
+ e:=is_in_csname; is_in_csname:=true;
repeat get_x_token;
if cur_cs=0 then store_new_token(cur_tok);
until cur_cs<>0;
@@ -30925,7 +30852,7 @@ if_cs_code:begin n:=get_avail; p:=n; {head of the list of characters}
@<Look up the characters of list |n| in the hash table, and set |cur_cs|@>;
flush_list(n);
b:=(eq_type(cur_cs)<>undefined_cs);
- is_in_csname := e;
+ is_in_csname:=e;
end;
@ @<Look up the characters of list |n| in the hash table...@>=
@@ -30948,10 +30875,10 @@ else cur_cs:=single_base+buffer[first] {the list has length one}
a font.
@<Cases for |conditional|@>=
-if_in_csname_code: b := is_in_csname;
+if_in_csname_code: b:=is_in_csname;
if_font_char_code:begin scan_font_ident; n:=cur_val; scan_usv_num;
if is_native_font(n) then
- b := (map_char_to_glyph(n, cur_val) > 0)
+ b:=(map_char_to_glyph(n, cur_val) > 0)
else begin
if (font_bc[n]<=cur_val)and(font_ec[n]>=cur_val) then
b:=char_exists(char_info(n)(qi(cur_val)))
@@ -32616,20 +32543,17 @@ if LR_problems>0 then
LR_problems:=0; goto common_ending;
end
-@ @d begin_reflect=0 {begin a reflcted segment value of |reflect| \.{XDV} command}
-@d end_reflect=1 {end a reflcted segment value of |reflect| \.{XDV} command}
-
-@<Output a reflection instruction if the direction has changed@>=
+@ @<Output a reflection instruction if the direction has changed@>=
if begin_LR(p) then
begin if safe_info(LR_ptr)<>LR_type(p) then
- begin synch_h; synch_v; dvi_out(reflect); dvi_out(begin_reflect);
+ begin synch_h; synch_v; dvi_out(begin_reflect);
end;
push_LR(p);
end
else if safe_info(LR_ptr)=begin_LR_type(p) then
begin pop_LR;
if info(LR_ptr)+end_L_code<>LR_type(p) then
- begin synch_h; synch_v; dvi_out(reflect); dvi_out(end_reflect);
+ begin synch_h; synch_v; dvi_out(end_reflect);
end;
end
else confusion("LR")