static int run_scan_code(lua_State * L) /* HH */
{
saved_tex_scanner texstate;
int cc = DEFAULT_SCAN_CODE_SET ;
save_tex_scanner(texstate);
get_x_token();
if (cur_cmd < 16) {
if (lua_gettop(L)>0) {
cc = (int) lua_tointeger(L,-1);
if (cc == null) {
/* todo: message that we choose a default */
cc = DEFAULT_SCAN_CODE_SET ;
}
}
if (cc & (1<<(cur_cmd))) {
lua_pushinteger(L,(int)cur_chr);
} else {
lua_pushnil(L);
back_input();
}
} else {
lua_pushnil(L);
back_input();
}
unsave_tex_scanner(texstate);
return 1;
}
void tex::scan_math(ptr p)
{
int c;
restart:
get_nbrx_token();
reswitch:
switch (cur_cmd)
{
case LETTER:
case OTHER_CHAR:
case CHAR_GIVEN:
c = math_code(cur_chr);
if (c == 0100000) {
cur_cs = active_base[cur_chr];
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
x_token();
back_input();
goto restart;
}
break;
case CHAR_NUM:
scan_char_num();
cur_chr = cur_val;
cur_cmd = CHAR_GIVEN;
goto reswitch;
case MATH_CHAR_NUM:
scan_fifteen_bit_int();
c = cur_val;
break;
case MATH_GIVEN:
c = cur_chr;
break;
case DELIM_NUM:
scan_twenty_seven_bit_int();
c = cur_val / 010000;
break;
default:
back_input();
scan_left_brace();
saved(0) = p;
incr(save_ptr);
push_math(MATH_GROUP);
return;
}
math_type(p) = MATH_CHAR;
character(p) = c % 256;
if (c >= VAR_CODE && fam_in_range()) {
fam(p) = cur_fam;
} else {
fam(p) = c / 256 % 16;
}
}
static int run_scan_word(lua_State * L) /* HH */
{
saved_tex_scanner texstate;
save_tex_scanner(texstate);
do {
get_x_token();
} while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
if (cur_cmd == 11 || cur_cmd == 12 ) {
declare_buffer;
while (1) {
add_to_buffer(cur_chr);
get_x_token();
if (cur_cmd != 11 && cur_cmd != 12 ) {
break ;
}
}
back_input();
push_buffer;
} else {
back_input();
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
// Case of \multispan; fully expandable
void Parser::multispan()
{
Token omit = hash_table.locate("omit");
Token span = hash_table.locate("span");
int n = scan_int(cur_tok);
back_input(omit);
while(n>1) { back_input(span); back_input(omit); --n; }
}
// This is executed when we see \end{tabular}
// If true, the \end{tabular} is not executed.
// and we have to push back the `end{tabular}' tokens
bool Parser::false_end_tabular(const string& s)
{
if(the_stack.is_frame(np_cell)) {
TokenList L = token_ns::string_to_list(s,true);
back_input(L);
back_input(hash_table.end_token);
finish_a_cell(hash_table.cr_token,Istring());
return true;
}
return false;
}
void Parser::finish_a_cell(Token T, Istring a)
{
flush_buffer();
the_stack.remove_last_space();
if(!a.null()) {
back_input(hash_table.space_token);
TokenList L = token_ns::string_to_list(a);
back_input(L);
T = hash_table.crwithargs_token;
}
back_input(T);
if(the_stack.is_omit_cell())
return;
TokenList L = the_stack.get_u_or_v(false);
back_input(L);
}
// This is \begin{tabular}. Should be in an environment (not necessarily)
void Parser::T_start_tabular (subtypes c)
{
Istring x = the_names[c==zero_code ? np_tabular : np_tabular_star];
if(the_stack.is_float())
leave_v_mode();
else if(the_stack.is_frame(np_fbox)) {}
else
leave_h_mode();
hash_table.eval_let_local("par","@empty");
the_stack.push1(x,np_table);
the_stack.add_att_to_last(np_rend,np_inline);
Xid id = the_stack.get_xid();
if(c!=0) { // case of tabular*
Token T = cur_tok;
TokenList L = mac_arg();
ScaledInt tab_width = dimen_from_list(T,L);
if(!tab_width.null())
id.add_attribute(the_names[np_tab_width],the_main->SH.find_scaled(tab_width));
get_token(); // eat the relax
if(!cur_cmd_chr.is_relax()) back_input();
}
{
int pos = get_ctb_opt(false); // Lamport does not mention c, who cares
if(pos) id.add_attribute(the_names[np_vpos], the_names[pos]);
}
new_array_object.run(id,true);
the_stack.set_array_mode(); // Is the mode ok ?
start_a_row(-1);
}
void tex::set_math_char(int c)
{
ptr p;
if (c >= 0100000) {
cur_cs = active_base[cur_chr];
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
x_token();
back_input();
} else {
p = new_noad();
math_type(nucleus(p)) = MATH_CHAR;
character(nucleus(p)) = c % 256;
fam(nucleus(p)) = c / 256 % 16;
if (c >= VAR_CODE) {
if (fam_in_range())
fam(nucleus(p)) = cur_fam;
type(p) = ORD_NOAD;
} else {
type(p) = ORD_NOAD + c / 010000;
}
tail_append(p);
}
}
void tex::insert_dollar_sign ()
{
back_input();
cur_tok = MATH_SHIFT_TOKEN + '$';
print_err("Missing $ inserted");
help_dollar();
ins_error();
}
void tex::head_for_vmode ()
{
if (mode < 0) {
if (cur_cmd != HRULE) {
off_save();
}
else {
print_err("You can't use `");
print_esc("hrule");
print("' here except with leaders");
help_head_for_vmode();
error();
}
}
else {
back_input();
cur_tok = par_tok;
back_input();
token_type = INSERTED;
}
}
// \\cline{3-4} : put a hrule on cells 3 to 4.
void Parser::T_cline()
{
Token T = cur_tok;
TokenList arg = mac_arg();
back_input(hash_table.space_token);
back_input(arg);
int a = scan_int(T);
get_token(); // should be a dash
int b = scan_int(T);
b = b-a;
if(a>0 && b>=0) {
Xmlp R = the_stack.top_stack()->last_addr();
if(R) {
if(R->ok_to_span(a,b,false)) {
R->ok_to_span(a,b,true);
return;
}
}
the_stack.add_border(a,b);
}
}
void tex::make_accent ()
{
fnt f;
qcell i;
ptr p, q, r;
scal a, h, w, x;
float s, t;
scal delta;
scan_char_num();
f = cur_font;
p = new_character(f, cur_val);
if (p != null) {
x = x_height(f);
s = (float) slant(f) / 65536.0;
a = char_width(f, char_info(f, character(p)));
do_assignments();
q = null;
f = cur_font;
if (cur_cmd == LETTER
|| cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN) {
q = new_character(f, cur_chr);
} else if (cur_cmd == CHAR_NUM) {
scan_char_num();
q = new_character(f, cur_val);
} else {
back_input();
}
if (q != null) {
t = (float) slant(f) / 65536.0;
i = char_info(f, character(q));
w = char_width(f, i);
h = char_height(f, height_depth(i));
if (h != x) {
p = hpack(p, 0, ADDITIONAL);
shift_amount(p) = x - h;
}
delta = round((float) (w - a) / 2.0 + h * t - x * s);
r = new_kern(delta);
subtype(r) = ACC_KERN;
link(tail) = r;
link(r) = p;
tail = new_kern(-a - delta);
subtype(tail) = ACC_KERN;
link(p) = tail;
p = q;
}
tail_append(p);
space_factor = 1000;
}
}
static int run_scan_string(lua_State * L) /* HH */
{ /* can be simplified, no need for intermediate list */
saved_tex_scanner texstate;
halfword t, saved_defref;
save_tex_scanner(texstate);
do {
get_x_token();
} while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
if (cur_cmd == left_brace_cmd) {
back_input();
saved_defref = def_ref;
(void) scan_toks(false, true);
t = def_ref;
def_ref = saved_defref;
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == call_cmd) {
t = token_link(cur_chr);
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == 11 || cur_cmd == 12 ) {
declare_buffer;
while (1) {
add_to_buffer(cur_chr);
get_x_token();
if (cur_cmd != 11 && cur_cmd != 12 ) {
break ;
}
}
back_input();
push_buffer;
} else {
back_input();
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
void history_cmd_roll_next()
{
if (cur_histotry_cmds_num>0 && cur_histotry_cmds_roll_idx<(cur_histotry_cmds_num-1))
{
cur_histotry_cmds_roll_idx++;
strcpy(shell_buf, histotry_cmds[cur_histotry_cmds_roll_idx].name);
if (histotry_cmds[cur_histotry_cmds_roll_idx].len<shell_buf_cur_len)
back_input(shell_buf_cur_len -
histotry_cmds[cur_histotry_cmds_roll_idx].len);
shell_buf_cur_len = histotry_cmds[cur_histotry_cmds_roll_idx].len;
refresh_shell_buf_display();
}
}
int read_input(int is_password)
{
char c, two_byes[2];
int ret;
READ_BYTE:
if (!fd_readable(fd_pty_slave, 0, 50000))
return 0;
ret=read_reliable(fd_pty_slave, &c, 1);
if (ret<0) return -1;
if (ret!=1) goto READ_BYTE;
if (c==0x00 || c==0x0a) goto READ_BYTE;
if (c==0x08 && shell_buf_cur_len>0)
{
back_input(1);
goto READ_BYTE;
}
if (c==0x1b)
{
ret=read_certain_bytes(fd_pty_slave, two_byes, 2);
if (ret<0) return -1;
if (two_byes[0]==0x5b && two_byes[1]==0x41)
history_cmd_roll_prev();
else if (two_byes[0]==0x5b && two_byes[1]==0x42)
history_cmd_roll_next();
goto READ_BYTE;
}
if (c==0x0d) goto EXIT;
if (c!=' ' && !isgraph(c)) goto READ_BYTE;
shell_buf[shell_buf_cur_len++]=c;
if (is_password) c='*';
printf_to_fd(fd_pty_slave, "%c", c);
goto READ_BYTE;
EXIT:
printf_to_fd(fd_pty_slave, "\n");
shell_buf[shell_buf_cur_len] = 0;
return 1;
}
bool tex::its_all_over ()
{
if (privileged()) {
if (page_head == page_tail
&& head == tail
&& dead_cycles == 0) {
return TRUE;
}
back_input();
tail_append(new_null_box());
box_width(tail) = hsize;
tail_append(new_glue(fill_glue));
tail_append(new_penalty(-010000000000));
build_page();
}
return FALSE;
}
void tex::scan_file_name ()
{
name_in_progress = TRUE;
get_nbx_token();
begin_name();
loop {
if (cur_cmd > OTHER_CHAR || cur_chr > 255) {
back_input();
break;
}
if (!more_name(cur_chr))
break;
get_x_token();
}
end_name();
name_in_progress = FALSE;
}
// Implements \newcolumntype{C}[opt]{body}
// as \newcommand\cmd[opt]{body}
// Here \cmd is some internal name, stored in nct_tok[C]
void Parser::T_newcolumn_type()
{
TokenList L = mac_arg();
uint c = 0;
if(L.empty()) parse_error("Empty argument to \\newcolumntype");
else if(L.size() != 1)
parse_error("More than one token in argument to \\newcolumntype");
else {
if(L.front().is_a_char())
c = L.front().char_val().get_value();
if(!(c>0 && c<nb_newcolumn)) {
parse_error("Argument to \\newcolumntype is not a 7bit character");
c= 0;
}
}
Buffer& B = hash_table.my_buffer();
B.reset();
B.push_back("newcolumtype@");
B.push_back(uchar(c)); // special hack if c=0 !
cur_tok = hash_table.locate(B);
new_array_object.add_a_type(c,cur_tok);
back_input();
get_new_command(rd_always,false); // definition is local
}
void tex::align_error ()
{
if (abs(align_state) > 2) {
print_err("Misplaced ");
print_cmd_chr(cur_cmd, cur_chr);
if (cur_tok == TAB_TOKEN + '&')
help_tab();
else help_align_error();
error();
} else {
back_input();
if (align_state < 0) {
print_err("Missing { inserted");
incr(align_state);
cur_tok = LEFT_BRACE_TOKEN + '{';
} else {
print_err("Missing } inserted");
decr(align_state);
cur_tok = RIGHT_BRACE_TOKEN + '}';
}
help_fix_alignment();
ins_error();
}
}
// If started is true, we have already started one
void Parser::start_a_cell(bool started)
{
if(!started) {
the_stack.push_pop_cell(push_only);
push_level(bt_cell);
}
remove_initial_space_and_back_input();
symcodes S = cur_cmd_chr.get_cmd();
if(S==unimp_cmd && cur_cmd_chr.get_chr()==omit_code) {
get_token();
the_stack.mark_omit_cell();
} else if(S==end_cmd) { // has to be \end{tabular}
the_stack.mark_omit_cell();
} else if(S==multicolumn_cmd) {
the_stack.mark_omit_cell();
get_token();
unprocessed_xml.remove_last_space();
Xid cid = the_stack.get_top_id();
new_array_object.run(cid,false);
} else {
TokenList L= the_stack.get_u_or_v(true);
back_input(L);
}
}
void tex::init_math ()
{
fnt f;
int m, n;
ptr p, q;
scal d, l, s, v, w;
get_token();
if (cur_cmd == MATH_SHIFT && mode > 0) {
if (head == tail) {
pop_nest();
w = -MAX_DIMEN;
} else {
line_break(display_widow_penalty);
v = shift_amount(just_box) + 2 * quad(cur_font);
w = -MAX_DIMEN;
p = list_ptr(just_box);
while (p != null) {
reswitch:
if (is_char_node(p)) {
f = font(p);
d = char_width(f,
char_info(f, character(p)));
goto found;
}
switch (type(p))
{
case HLIST_NODE:
case VLIST_NODE:
case RULE_NODE:
d = box_width(p);
goto found;
case LIGATURE_NODE:
p = make_char_from_lig(p);
goto reswitch;
case KERN_NODE:
d = kern_width(p);
break;
case MATH_NODE:
d = box_width(p);
break;
case GLUE_NODE:
q = glue_ptr(p);
d = box_width(q);
if (glue_sign(just_box) ==
STRETCHING) {
if (glue_order(just_box) ==
stretch_order(q)
&& stretch(q) != 0)
v = MAX_DIMEN;
} else if (glue_sign(just_box) ==
SHRINKING) {
if (glue_order(just_box) ==
shrink_order(q)
&& shrink(q) != 0)
v = MAX_DIMEN;
}
if (subtype(p) >= A_LEADERS)
goto found;
break;
case WHATSIT_NODE:
d = 0;
break;
default:
d = 0;
break;
}
if (v < MAX_DIMEN)
v += d;
goto not_found;
found:
if (v < MAX_DIMEN) {
v += d;
w = v;
} else {
w = MAX_DIMEN;
break;
}
not_found:
p = link(p);
}
}
if (par_shape_ptr == null) {
if (hang_indent != 0
&& (hang_after >= 0
&& prev_graf + 2 > hang_after
|| prev_graf + 1 < -hang_after)) {
l = hsize - abs(hang_indent);
s = (hang_indent > 0) ? hang_indent : 0;
} else {
l = hsize;
s = 0;
}
} else {
n = info(par_shape_ptr);
if (prev_graf + 2 >= n)
m = n;
else m = prev_graf + 2;
l = par_shape_width(m);
s = par_shape_indent(m);
}
push_math(MATH_SHIFT_GROUP);
mode = MMODE;
reg_define(int_reg[CUR_FAM_CODE], INT_REG, -1);
reg_define(dimen_reg[PRE_DISPLAY_SIZE_CODE], DIMEN_REG, w);
reg_define(dimen_reg[DISPLAY_WIDTH_CODE], DIMEN_REG, l);
reg_define(dimen_reg[DISPLAY_INDENT_CODE], DIMEN_REG, s);
if (every_display != null)
begin_token_list(every_display, EVERY_DISPLAY_TEXT);
if (nest_ptr == nest + 1)
build_page();
} else {
back_input();
push_math(MATH_SHIFT_GROUP);
reg_define(int_reg[CUR_FAM_CODE], INT_REG, -1);
if (every_math != null)
begin_token_list(every_math, EVERY_MATH_TEXT);
}
}
void tex::handle_right_brace ()
{
scal d;
int f;
ptr p;
ptr q;
switch (cur_group)
{
case SIMPLE_GROUP:
unsave();
break;
case BOTTOM_LEVEL:
print_err("Too many }'s");
help_close_group();
error();
break;
case SEMI_SIMPLE_GROUP:
case MATH_SHIFT_GROUP:
case MATH_LEFT_GROUP:
extra_right_brace();
break;
case HBOX_GROUP:
package(0);
break;
case ADJUSTED_HBOX_GROUP:
tex::adjust_tail = tex::adjust_head;
package(0);
break;
case VBOX_GROUP:
end_graf();
package(0);
break;
case VTOP_GROUP:
end_graf();
package(VTOP_CODE);
break;
case INSERT_GROUP:
end_graf();
q = split_top_skip;
add_glue_ref(q);
d = split_max_depth;
f = floating_penalty;
unsave();
decr(save_ptr);
p = vpack(link(head), 0, ADDITIONAL);
pop_nest();
if (saved(0) < 255) {
tail_append(new_node(INS_NODE_SIZE));
type(tail) = INS_NODE;
subtype(tail) = saved(0);
ins_height(tail) = box_height(p) + box_depth(p);
ins_ptr(tail) = list_ptr(p);
split_top_ptr(tail) = q;
ins_depth(tail) = d;
float_cost(tail) = f;
} else {
tail_append(new_node(SMALL_NODE_SIZE));
type(tail) = ADJUST_NODE;
subtype(tail) = 0;
adjust_ptr(tail) = list_ptr(p);
delete_glue_ref(q);
}
free_node(p, BOX_NODE_SIZE);
if (nest_ptr == nest)
build_page();
break;
case OUTPUT_GROUP:
if (loc != null
|| (token_type != OUTPUT_TEXT && token_type != BACKED_UP)) {
print_err("Unbalanced output routine");
help_output_balance();
error();
do get_token();
while (loc != null);
}
end_token_list();
end_graf();
unsave();
output_active = FALSE;
insert_penalties = 0;
if (box(255) != null) {
print_err("Output routine didn't use all of ");
print_esc("box255");
help_output();
box_error(255);
}
if (tail != head) {
link(page_tail) = link(head);
page_tail = tail;
}
if (link(page_head) != null) {
if (link(contrib_head) == null)
contrib_tail = page_tail;
link(page_tail) = link(contrib_head);
link(contrib_head) = link(page_head);
link(page_head) = null;
page_tail = page_head;
}
pop_nest();
build_page();
break;
case DISC_GROUP:
build_discretionary();
break;
case ALIGN_GROUP:
back_input();
cur_tok = sym2tok(FROZEN_CR);
print_err("Missing ");
print_esc("cr");
print(" inserted");
help_align_cr();
ins_error();
break;
case NO_ALIGN_GROUP:
end_graf();
unsave();
align_peek();
break;
case VCENTER_GROUP:
end_graf();
unsave();
save_ptr -= 2;
p = vpackage(link(head), saved(1), saved(0), MAX_DIMEN);
pop_nest();
tail_append(new_noad());
type(tail) = VCENTER_NOAD;
math_type(nucleus(tail)) = SUB_BOX;
info(nucleus(tail)) = p;
break;
case MATH_CHOICE_GROUP:
build_choices();
break;
case MATH_GROUP:
unsave();
decr(save_ptr);
math_type(saved(0)) = SUB_MLIST;
p = fin_mlist(null);
math_link(saved(0)) = p;
if (p != null) {
if (link(p) == null) {
if (type(p) == ORD_NOAD) {
if (math_type(subscr(p)) == EMPTY
&& math_type(supscr(p)) == EMPTY) {
mcopy(saved(0), nucleus(p));
free_node(p, NOAD_SIZE);
}
} else if (type(p) == ACCENT_NOAD
&& saved(0) == nucleus(tail)
&& type(tail) == ORD_NOAD) {
q = head;
while (link(q) != tail)
q = link(q);
link(q) = p;
free_node(tail, NOAD_SIZE);
tail = p;
}
}
}
break;
default:
confusion("rightbrace");
break;
}
}
static int run_scan_float_indeed(lua_State * L, boolean exponent)
{
saved_tex_scanner texstate;
int ok;
boolean negative = false;
double d;
declare_buffer;
save_tex_scanner(texstate);
/* we collapse as in scan_dimen */
while(1) {
do {
get_x_token();
} while (cur_cmd == spacer_cmd);
if (cur_tok == minus_token) {
negative = !negative;
} else if (cur_tok != plus_token) {
break;
}
}
if (negative) {
add_to_buffer('-');
}
/* we accept [.,]digits */
if (cur_tok == point_token || cur_tok == comma_token) {
add_to_buffer('.');
while (1) {
get_x_token();
if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
add_to_buffer(cur_chr);
} else if (exponent) {
goto EXPONENT;
} else {
back_input();
goto DONE;
}
}
} else {
back_input();
while (1) {
get_x_token();
if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
add_to_buffer(cur_chr);
} else {
if (cur_tok == point_token || cur_tok == comma_token) {
add_to_buffer('.');
while (1) {
get_x_token();
if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
add_to_buffer(cur_chr);
} else {
back_input();
break;
}
}
} else if (exponent) {
goto EXPONENT;
} else {
back_input();
goto DONE;
}
}
}
}
EXPONENT:
if ((cur_chr == 'E') || (cur_chr == 'e')) {
add_to_buffer(cur_chr);
get_x_token();
if ((cur_tok == minus_token) || (cur_tok == plus_token)) {
add_to_buffer(cur_chr);
} else if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
add_to_buffer(cur_chr);
}
while (1) {
get_x_token();
if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
add_to_buffer(cur_chr);
} else {
break;
}
}
}
back_input();
DONE:
push_buffer;
d = lua_tonumberx(L,1,&ok);
if (ok) {
lua_pushnumber(L,d);
} else {
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
void do_extension(int immediate)
{
halfword p;
if(cur_cmd==extension_cmd){
switch(cur_chr){
case open_code:
p= tail;
new_write_whatsit(open_node_size,1);
scan_optional_equals();
scan_file_name();
open_name(tail)= cur_name;
open_area(tail)= cur_area;
open_ext(tail)= cur_ext;
if(immediate){
out_what(static_pdf,tail);
flush_node_list(tail);
tail= p;
vlink(p)= null;
}
break;
case write_code:
p= tail;
new_write_whatsit(write_node_size,0);
cur_cs= write_stream(tail);
scan_toks(false,false);
write_tokens(tail)= def_ref;
if(immediate){
out_what(static_pdf,tail);
flush_node_list(tail);
tail= p;
vlink(p)= null;
}
break;
case close_code:
p= tail;
new_write_whatsit(close_node_size,1);
write_tokens(tail)= null;
if(immediate){
out_what(static_pdf,tail);
flush_node_list(tail);
tail= p;
vlink(p)= null;
}
break;
case special_code:
new_whatsit(special_node);
write_stream(tail)= null;
p= scan_toks(false,true);
write_tokens(tail)= def_ref;
break;
case immediate_code:
get_x_token();
do_extension(1);
break;
case use_box_resource_code:
case use_image_resource_code:
case save_box_resource_code:
case save_image_resource_code:
switch(get_o_mode()){
case OMODE_DVI:
do_resource_dvi(immediate,cur_chr);
break;
case OMODE_PDF:
do_resource_pdf(immediate,cur_chr);
break;
default:
break;
}
break;
case dvi_extension_code:
if(get_o_mode()==OMODE_DVI)
do_extension_dvi(immediate);
break;
case pdf_extension_code:
if(get_o_mode()==OMODE_PDF)
do_extension_pdf(immediate);
break;
default:
if(immediate){
back_input();
}else{
confusion("invalid extension");
}
break;
}
}else{
back_input();
}
}
void tex::main_control()
{
if (every_job != null)
begin_token_list(every_job, EVERY_JOB_TEXT);
big_switch:
get_x_token();
reswitch:
if (tracing_commands > 0)
show_cur_cmd_chr();
switch(abs(mode) + cur_cmd) {
hmode(LETTER):
hmode(OTHER_CHAR):
hmode(CHAR_GIVEN):
goto main_loop;
hmode(CHAR_NUM):
scan_char_num();
cur_chr = cur_val;
goto main_loop;
hmode(NO_BOUNDARY):
get_x_token();
if (cur_cmd == LETTER || cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN || cur_cmd == CHAR_NUM) {
cancel_boundary = TRUE;
}
goto reswitch;
hmode(SPACER):
if (space_factor == 1000) {
goto append_normal_space;
}
else {
app_space();
}
break;
hmode(EX_SPACE):
mmode(EX_SPACE):
goto append_normal_space;
any_mode(RELAX):
vmode(SPACER):
mmode(SPACER):
mmode(NO_BOUNDARY):
break;
any_mode(IGNORE_SPACES):
get_nbx_token();
goto reswitch;
vmode(STOP):
if (its_all_over())
return;
break;
any_mode(LAST_ITEM):
any_mode(MAC_PARAM):
non_math(EQ_NO):
vmode(VMOVE):
hmode(HMOVE):
mmode(HMOVE):
vmode(VADJUST):
vmode(ITAL_CORR):
report_illegal_case();
break;
non_math(SUP_MARK):
non_math(SUB_MARK):
non_math(MATH_CHAR_NUM):
non_math(MATH_GIVEN):
non_math(MATH_COMP):
non_math(DELIM_NUM):
non_math(LEFT_RIGHT):
non_math(ABOVE):
non_math(RADICAL):
non_math(MATH_STYLE):
non_math(MATH_CHOICE):
non_math(VCENTER):
non_math(NON_SCRIPT):
non_math(MKERN):
non_math(LIMIT_SWITCH):
non_math(MSKIP):
non_math(MATH_ACCENT):
mmode(ENDV):
mmode(PAR_END):
mmode(STOP):
mmode(VSKIP):
mmode(UN_VBOX):
mmode(VALIGN):
mmode(HRULE):
insert_dollar_sign();
break;
vmode(HRULE):
hmode(VRULE):
mmode(VRULE):
tail_append(scan_rule_spec());
if (abs(mode) == VMODE)
prev_depth = IGNORE_DEPTH;
else if (abs(mode) == HMODE)
space_factor = 1000;
break;
vmode(VSKIP):
hmode(HSKIP):
mmode(HSKIP):
mmode(MSKIP):
append_glue();
break;
any_mode(KERN):
mmode(MKERN):
append_kern();
break;
non_math(LEFT_BRACE):
new_save_level(SIMPLE_GROUP);
break;
any_mode(BEGIN_GROUP):
new_save_level(SEMI_SIMPLE_GROUP);
break;
any_mode(END_GROUP):
if (cur_group == SEMI_SIMPLE_GROUP) {
unsave();
} else {
off_save();
}
break;
any_mode(RIGHT_BRACE):
handle_right_brace();
break;
vmode(HMOVE):
hmode(VMOVE):
mmode(VMOVE): {
int t;
t = cur_chr;
scan_normal_dimen();
if (t == 0) {
scan_box(cur_val);
} else {
scan_box(-cur_val);
}
break;
}
any_mode(LEADER_SHIP):
scan_box(LEADER_FLAG + cur_chr - A_LEADERS);
break;
any_mode(MAKE_BOX):
begin_box(0);
break;
vmode(START_PAR):
new_graf(cur_chr > 0);
break;
vmode(LETTER):
vmode(OTHER_CHAR):
vmode(CHAR_NUM):
vmode(CHAR_GIVEN):
vmode(MATH_SHIFT):
vmode(UN_HBOX):
vmode(VRULE):
vmode(ACCENT):
vmode(DISCRETIONARY):
vmode(HSKIP):
vmode(VALIGN):
vmode(EX_SPACE):
vmode(NO_BOUNDARY):
back_input();
new_graf(TRUE);
break;
hmode(START_PAR):
mmode(START_PAR):
indent_in_hmode();
break;
vmode(PAR_END):
normal_paragraph();
if (mode > 0)
build_page();
break;
hmode(PAR_END):
if (align_state < 0)
off_save();
end_graf();
if (mode == VMODE)
build_page();
break;
hmode(STOP):
hmode(VSKIP):
hmode(HRULE):
hmode(UN_VBOX):
hmode(HALIGN):
head_for_vmode();
break;
any_mode(INSERT):
hmode(VADJUST):
mmode(VADJUST):
begin_insert_or_adjust();
break;
any_mode(MARK):
make_mark();
break;
any_mode(BREAK_PENALTY):
append_penalty();
break;
any_mode(REMOVE_ITEM):
delete_last();
break;
vmode(UN_VBOX):
hmode(UN_HBOX):
mmode(UN_HBOX):
unpackage();
break;
hmode(ITAL_CORR):
append_italic_correction();
break;
mmode(ITAL_CORR):
tail_append(new_kern(0));
break;
hmode(DISCRETIONARY):
mmode(DISCRETIONARY):
append_discretionary();
break;
hmode(ACCENT):
make_accent();
break;
any_mode(CAR_RET):
any_mode(TAB_MARK):
align_error();
break;
any_mode(NO_ALIGN):
no_align_error();
break;
any_mode(OMIT):
omit_error();
break;
vmode(HALIGN):
hmode(VALIGN):
init_align();
break;
mmode(HALIGN):
if (privileged()) {
if (cur_group == MATH_SHIFT_GROUP) {
init_align();
} else {
off_save();
}
}
break;
vmode(ENDV):
hmode(ENDV):
do_endv();
break;
any_mode(END_CS_NAME):
cs_error();
break;
hmode(MATH_SHIFT):
init_math();
break;
mmode(EQ_NO):
if (privileged()) {
if (cur_group == MATH_SHIFT_GROUP) {
start_eq_no();
} else {
off_save();
}
}
break;
mmode(LEFT_BRACE):
tail_append(new_noad());
back_input();
scan_math(nucleus(tail));
break;
mmode(LETTER):
mmode(OTHER_CHAR):
mmode(CHAR_GIVEN):
if (cur_chr < 256)
set_math_char(math_code(cur_chr));
else set_math_char(cur_chr);
break;
mmode(CHAR_NUM):
scan_char_num();
cur_chr = cur_val;
if (cur_chr < 256)
set_math_char(math_code(cur_chr));
else set_math_char(cur_chr);
break;
mmode(MATH_CHAR_NUM):
scan_fifteen_bit_int();
set_math_char(cur_val);
break;
mmode(MATH_GIVEN):
set_math_char(cur_chr);
break;
mmode(DELIM_NUM):
scan_twenty_seven_bit_int();
set_math_char(cur_val / 010000);
break;
mmode(MATH_COMP):
tail_append(new_noad());
type(tail) = cur_chr;
scan_math(nucleus(tail));
break;
mmode(LIMIT_SWITCH):
math_limit_switch();
break;
mmode(RADICAL):
math_radical();
break;
mmode(ACCENT):
mmode(MATH_ACCENT):
math_ac();
break;
mmode(VCENTER):
scan_spec(VCENTER_GROUP, FALSE);
normal_paragraph();
push_nest();
mode = -VMODE;
prev_depth = IGNORE_DEPTH;
if (every_vbox != null)
begin_token_list(every_vbox, EVERY_VBOX_TEXT);
break;
mmode(MATH_STYLE):
tail_append(new_style(cur_chr));
break;
mmode(NON_SCRIPT):
tail_append(new_glue(zero_glue));
subtype(tail) = COND_MATH_GLUE;
break;
mmode(MATH_CHOICE):
append_choices();
break;
mmode(SUB_MARK):
mmode(SUP_MARK):
sub_sup();
break;
mmode(ABOVE):
math_fraction();
break;
mmode(LEFT_RIGHT):
math_left_right();
break;
mmode(MATH_SHIFT):
if (cur_group == MATH_SHIFT_GROUP) {
after_math();
} else {
off_save();
}
break;
any_mode(AFTER_ASSIGNMENT):
get_token();
after_token = cur_tok;
break;
any_mode(AFTER_GROUP):
get_token();
save_for_after(cur_tok);
break;
any_mode(IN_STREAM):
clopen_stream();
break;
any_mode(MESSAGE):
issue_message();
break;
any_mode(CASE_SHIFT):
shift_case();
break;
any_mode(XRAY):
show_whatever();
break;
any_mode(EXTENSION):
do_extension();
break;
default:
prefixed_command();
break;
}
goto big_switch;
#define adjust_space_factor() \
{ \
main_s = sf_code(cur_chr); \
if (main_s == 1000) { \
space_factor = 1000; \
} else if (main_s < 1000) { \
if (main_s > 0) { \
space_factor = main_s; \
} \
} else if (space_factor < 1000) { \
space_factor = 1000; \
} else { \
space_factor = main_s; \
} \
}
main_loop:
adjust_space_factor();
main_f = cur_font;
bchar = font_bchar(main_f);
false_bchar = font_false_bchar(main_f);
if (mode > 0 && language != clang)
fix_language();
fast_new_avail(lig_stack);
font(lig_stack) = main_f;
character(lig_stack) = cur_l = cur_chr;
cur_q = tail;
if (cancel_boundary) {
cancel_boundary = FALSE;
main_k = NON_ADDRESS;
} else {
main_k = bchar_label(main_f);
}
if (main_k == NON_ADDRESS)
goto main_loop_move_2;
cur_r = cur_l;
cur_l = NON_CHAR;
goto main_lig_loop_1;
#define pack_lig(RT_HIT) \
{ \
main_p = new_ligature(main_f, cur_l, link(cur_q)); \
if (lft_hit) { \
subtype(main_p) = 2; \
lft_hit = FALSE; \
} \
if (RT_HIT && lig_stack == null) { \
incr(subtype(main_p)); \
rt_hit = FALSE; \
} \
tail = link(cur_q) = main_p; \
ligature_present = FALSE; \
}
#define wrapup(RT_HIT) \
{ \
if (cur_l < NON_CHAR) { \
if (character(tail) == hyphen_char(main_f) \
&& link(cur_q) != null) \
ins_disc = TRUE; \
if (ligature_present) \
pack_lig(RT_HIT); \
if (ins_disc) { \
ins_disc = FALSE; \
if (mode > 0) \
tail_append(new_disc()); \
} \
} \
}
main_loop_wrapup:
wrapup(rt_hit);
main_loop_move:
if (lig_stack == null)
goto reswitch;
cur_q = tail;
cur_l = cur_r;
main_loop_move_1:
if (!is_char_node(lig_stack))
goto main_loop_move_lig;
main_loop_move_2:
if (cur_chr < font_bc(main_f) || cur_chr > font_ec(main_f)) {
char_warning(main_f, cur_chr);
free_avail(lig_stack);
goto big_switch;
}
main_i = char_info(main_f, cur_l);
if (!char_exists(main_i)) {
char_warning(main_f, cur_chr);
free_avail(lig_stack);
goto big_switch;
}
tail_append(lig_stack);
main_loop_lookahead:
get_next();
if (cur_cmd == LETTER
|| cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN) {
goto main_loop_lookahead_1;
}
x_token();
if (cur_cmd == LETTER
|| cur_cmd == OTHER_CHAR
|| cur_cmd == CHAR_GIVEN) {
goto main_loop_lookahead_1;
}
if (cur_cmd == CHAR_NUM) {
scan_char_num();
cur_chr = cur_val;
goto main_loop_lookahead_1;
}
if (cur_cmd == NO_BOUNDARY) {
bchar = NON_CHAR;
}
cur_r = bchar;
lig_stack = null;
goto main_lig_loop;
main_loop_lookahead_1:
adjust_space_factor();
fast_new_avail(lig_stack);
font(lig_stack) = main_f;
character(lig_stack) = cur_r = cur_chr;
if (cur_r == false_bchar) {
cur_r = NON_CHAR;
}
main_lig_loop:
if (char_tag(main_i) != LIG_TAG) {
goto main_loop_wrapup;
}
main_k = lig_kern_start(main_f, main_i);
main_j = *main_k;
if (skip_byte(main_j) <= STOP_FLAG) {
goto main_lig_loop_2;
}
main_k = lig_kern_restart(main_f, main_j);
main_lig_loop_1:
main_j = *main_k;
main_lig_loop_2:
if (next_char(main_j) == cur_r
&& skip_byte(main_j) <= STOP_FLAG) {
if (op_byte(main_j) >= KERN_FLAG) {
wrapup(rt_hit);
tail_append(new_kern(char_kern(main_f, main_j)));
goto main_loop_move;
}
if (cur_l == NON_CHAR) {
lft_hit = TRUE;
} else if (lig_stack == null) {
rt_hit = TRUE;
}
if(interrupted) throw std::logic_error("interrupted");
switch (op_byte(main_j))
{
case 1: case 5:
cur_l = rem_byte(main_j);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
break;
case 2: case 6:
cur_r = rem_byte(main_j);
if (lig_stack == null) {
lig_stack = new_lig_item(cur_r);
bchar = NON_CHAR;
} else if (is_char_node(lig_stack)) {
main_p = lig_stack;
lig_stack = new_lig_item(cur_r);
lig_ptr(lig_stack) = main_p;
} else {
character(lig_stack) = cur_r;
}
break;
case 3:
cur_r = rem_byte(main_j);
main_p = lig_stack;
lig_stack = new_lig_item(cur_r);
link(lig_stack) = main_p;
break;
case 7: case 11:
wrapup(FALSE);
cur_q = tail;
cur_l = rem_byte(main_j);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
break;
default:
cur_l = rem_byte(main_j);
ligature_present = TRUE;
if (lig_stack == null) {
goto main_loop_wrapup;
} else {
goto main_loop_move_1;
}
break;
}
if (op_byte(main_j) > 4 && op_byte(main_j) != 7)
goto main_loop_wrapup;
if (cur_l < NON_CHAR)
goto main_lig_loop;
main_k = bchar_label(main_f);
goto main_lig_loop_1;
}
if (skip_byte(main_j) == 0) {
incr(main_k);
} else {
if (skip_byte(main_j) >= STOP_FLAG)
goto main_loop_wrapup;
main_k += skip_byte(main_j) + 1;
}
goto main_lig_loop_1;
main_loop_move_lig:
main_p = lig_ptr(lig_stack);
if (main_p != null) {
tail_append(main_p);
}
main_t = lig_stack;
lig_stack = link(main_t);
free_node(main_t, SMALL_NODE_SIZE);
main_i = char_info(main_f, cur_l);
ligature_present = TRUE;
if (lig_stack == null) {
if (main_p != null) {
goto main_loop_lookahead;
} else {
cur_r = bchar;
}
} else {
cur_r = character(lig_stack);
}
goto main_lig_loop;
append_normal_space:
if (space_skip == zero_glue) {
main_p = font_glue(cur_font);
if (main_p == null)
main_p = find_font_glue(cur_font);
main_t = new_glue(main_p);
} else {
main_t = new_param_glue(SPACE_SKIP_CODE);
}
tail_append(main_t);
goto big_switch;
}