"reverted to the magnification you used earlier on this run.");
int_error(mag_set);
geq_word_define(int_base + mag_code, mag_set);
- }
+ }
+
if ((mag <= 0) || (mag > 32768L))
{
print_err("Illegal magnification has been changed to 1000");
print_char(':');
print_ln();
token_show(cur_chr);
- }
+ }
else if (cur_cmd == top_bot_mark)
{
print_char(':');
{
begin_diagnostic();
print_nl("{");
+
if (mode != shown_mode)
{
print_mode(mode);
print_string(": ");
shown_mode = mode;
}
+
print_cmd_chr(cur_cmd, cur_chr);
print_char('}');
end_diagnostic(false);
input_stack[base_ptr] = cur_input;
nn = -1;
bottomline = false;
- while (true) {
+
+ while (true)
+ {
cur_input = input_stack[base_ptr];
+
if ((cur_input.state_field != 0))
if ((cur_input.name_field > 17) || (base_ptr == 0))
bottomline = true;
+
if ((base_ptr == input_ptr) || bottomline || (nn < error_context_lines))
{
if ((base_ptr == input_ptr) || (cur_input.state_field != token_list) ||
{
tally = 0;
old_setting = selector;
+
if (cur_input.state_field != 0)
{
if (cur_input.name_field <= 17)
print_int(cur_input.name_field - 1);
print_char('>');
}
- else {
+ else
+ {
if (c_style_flag)
{
print_ln();
/* show current input file name - ignore if from terminal */
if (cur_input.name_field > 17) /* redundant ? */
print(cur_input.name_field);
+
print_char('(');
print_int(line); /* line number */
print_char(')');
print_int(line); /* line number */
}
}
+
print_char(' ');
+
{
l = tally;
tally = 0;
selector = pseudo;
trick_count = 1000000L;
}
+
if (buffer[cur_input.limit_field] == end_line_char)
j = cur_input.limit_field;
else
j = cur_input.limit_field + 1;
+
if (j > 0)
for (i = cur_input.start_field; i <= j - 1; i++)
{
{
first_count = tally;
trick_count = tally + 1 + error_line - half_error_line;
+
if (trick_count < error_line)
trick_count = error_line;
}
case parameter:
print_nl("<argument> ");
break;
+
case u_template:
case v_template:
print_nl("<template> ");
break;
+
case backed_up:
if (cur_input.loc_field == 0)
print_nl("<recently read> ");
else
print_nl("<to be read again> ");
break;
+
case inserted:
print_nl("<inserted text> ");
break;
+
case macro:
print_ln();
print_cs(cur_input.name_field);
break;
+
case output_text:
print_nl("<output> ");
break;
+
case every_par_text:
print_nl("<everypar> ");
break;
+
case every_math_text:
print_nl("<everymath> ");
break;
+
case every_display_text:
print_nl("<everydisplay> ");
break;
+
case every_hbox_text:
print_nl("<everyhbox> ");
break;
+
case every_vbox_text:
print_nl("<everyvbox> ");
break;
+
case every_job_text:
print_nl("<everyjob> ");
break;
+
case every_cr_text:
print_nl("<everycr> ");
break;
+
case mark_text:
print_nl("<mark> ");
break;
+
case write_text:
print_nl("<write> ");
break;
+
default:
print_nl("?");
break;
}
+
{
l = tally;
tally = 0;
selector = pseudo;
trick_count = 1000000L;
}
+
if (cur_input.index_field < macro)
show_token_list(cur_input.start_field, cur_input.loc_field, 100000L);
else
show_token_list(link(cur_input.start_field), cur_input.loc_field, 100000L);
}
+
selector = old_setting;
+
if (trick_count == 1000000L)
{
first_count = tally;
trick_count = tally + 1 + error_line - half_error_line;
+
if (trick_count < error_line)
trick_count = error_line;
}
print_nl("...");
incr(nn);
}
+
if (bottomline)
goto lab30;
+
decr(base_ptr);
}
lab30:
if (input_ptr > max_in_stack)
{
max_in_stack = input_ptr;
+
#ifdef ALLOCATEINPUTSTACK
if (input_ptr == current_stack_size)
input_stack = realloc_input_stack(increment_stack_size);
- if (input_ptr == current_stack_size)
- { /* check again after allocation */
+
+ if (input_ptr == current_stack_size) /* check again after allocation */
+ {
overflow("input stack size", current_stack_size);
return; // abort_flag set
}
#else
- if (input_ptr == stack_size)
- { /* input stack - not dynamic */
+ if (input_ptr == stack_size) /* input stack - not dynamic */
+ {
overflow("input stack size", stack_size);
return; // abort_flag set
}
#endif
}
+
input_stack[input_ptr] = cur_input;
incr(input_ptr);
}
+
cur_input.state_field = token_list;
cur_input.start_field = p;
cur_input.index_field = t;
+
if (t >= macro)
{
add_token_ref(p);
+
if (t == macro)
cur_input.limit_field = param_ptr;
else
{
cur_input.loc_field = link(p);
+
if (tracing_macros > 1)
{
begin_diagnostic();
print_nl("");
+
switch (t)
{
case mark_text:
print_esc("mark");
break;
+
case write_text:
print_esc("write");
break;
+
default:
print_cmd_chr(assign_toks, t + (hash_size + 1307));
break;
}
+
print_string("->");
token_show(p);
end_diagnostic(false);
{
delete_token_ref(cur_input.start_field);
if (cur_input.index_field == macro)
- while (param_ptr > cur_input.limit_field) {
+ while (param_ptr > cur_input.limit_field)
+ {
decr(param_ptr);
flush_list(param_stack[param_ptr]);
}
else if (cur_input.index_field == u_template)
if (align_state > 500000L)
align_state = 0;
- else {
+ else
+ {
fatal_error("(interwoven alignment preambles are not allowed)");
return; // abort_flag set
}
+
{
decr(input_ptr);
cur_input = input_stack[input_ptr];
}
+
{
if (interrupt != 0)
{
void back_input (void)
{
halfword p;
+
while ((cur_input.state_field == 0) && (cur_input.loc_field == 0) &&
- (cur_input.index_field != v_template)) {
+ (cur_input.index_field != v_template))
+ {
end_token_list();
}
+
p = get_avail();
info(p) = cur_tok;
- if (cur_tok < 768)
- if (cur_tok < 512)
+
+ if (cur_tok < right_brace_limit)
+ if (cur_tok < left_brace_limit)
decr(align_state);
else
incr(align_state);
+
{
if (input_ptr > max_in_stack)
{
#ifdef ALLOCATEINPUTSTACK
if (input_ptr == current_stack_size)
input_stack = realloc_input_stack(increment_stack_size);
- if (input_ptr == current_stack_size)
- { /* check again after allocation */
+
+ if (input_ptr == current_stack_size) /* check again after allocation */
+ {
overflow("input stack size", current_stack_size);
return; // abort_flag set
}
#else
- if (input_ptr == stack_size)
- { /* stack size - not dynamic */
+ if (input_ptr == stack_size) /* stack size - not dynamic */
+ {
overflow("input stack size", stack_size);
return; // abort_flag set
}
input_stack[input_ptr] = cur_input;
incr(input_ptr);
}
+
cur_input.state_field = token_list;
cur_input.start_field = p;
cur_input.index_field = backed_up;
#ifdef ALLOCATEBUFFER
if (first == current_buf_size)
buffer = realloc_buffer(increment_buf_size);
- if (first == current_buf_size)
- { /* check again after allocation */
+
+ if (first == current_buf_size) /* check again after allocation */
+ {
overflow("buffer size", current_buf_size);
return; // abort_flag set
}
{
first = cur_input.start_field;
line = line_stack[cur_input.index_field];
+
if (cur_input.name_field > 17)
(void) a_close(input_file[cur_input.index_field]);
+
{
decr(input_ptr);
cur_input = input_stack[input_ptr];
void clear_for_error_prompt (void)
{
while ((cur_input.state_field != 0) &&
- (cur_input.name_field == 0) &&
- (input_ptr > 0) &&
+ (cur_input.name_field == 0) && (input_ptr > 0) &&
(cur_input.loc_field > cur_input.limit_field))
end_file_reading();
+
print_ln();
}
/* sec 0336 */
if (scanner_status != 0)
{
deletions_allowed = false;
+
if (cur_cs != 0)
{
- if ((cur_input.state_field == 0) ||
- (cur_input.name_field < 1) ||
- (cur_input.name_field > 17))
+ if ((cur_input.state_field == 0) || (cur_input.name_field < 1) || (cur_input.name_field > 17))
{
p = get_avail();
- info(p) = 4095 + cur_cs;
- begin_token_list(p, 3);
+ info(p) = cs_token_flag + cur_cs;
+ back_list(p);
}
+
cur_cmd = spacer;
cur_chr = ' ';
}
if (scanner_status > skipping)
{
runaway();
+
if (cur_cs == 0)
print_err("File ended");
else
cur_cs = 0;
print_err("Forbidden control sequence found");
}
+
print_string(" while scanning ");
p = get_avail();
+
switch (scanner_status)
{
case defining:
print_string("definition");
- info(p) = 637;
+ info(p) = right_brace_token + '}';
break;
+
case matching:
print_string("use");
info(p) = par_token;
long_state = outer_call;
break;
+
case aligning:
print_string("preamble");
- info(p) = 637;
+ info(p) = right_brace_token + '}';
q = p;
p = get_avail();
link(p) = q;
-/* mem[p].hh.v.LH = (hash_size + 4610); */
-/* mem[p].hh.v.LH = (hash_size + 4095 + 515); */
- info(p) = (hash_size + hash_extra + 4095 + 515); /*96/Jan/10*/
+ info(p) = cs_token_flag + frozen_cr; /*96/Jan/10*/
align_state = -1000000L;
break;
+
case absorbing:
print_string("text");
- info(p) = 637;
+ info(p) = right_brace_token + '}';
break;
}
- begin_token_list(p, 4);
+ ins_list(p);
print_string(" of ");
sprint_cs(warning_index);
help4("I suspect you have forgotten a `}', causing me",
help3("A forbidden control sequence occurred in skipped text.",
"This kind of error happens when you say `\\if...' and forget",
"the matching `\\fi'. I've inserted a `\\fi'; this might work.");
+
if (cur_cs != 0)
cur_cs = 0;
else
help_line[2] = "The file ended while I was skipping conditional text.";
-/* cur_tok = (hash_size + 4613); */
-/* cur_tok = (hash_size + 4095 + 518); */
- cur_tok = (hash_size + hash_extra + 4095 + 518); /* 96/Jan/10 */
+
+ cur_tok = cs_token_flag + frozen_fi; /* 96/Jan/10 */
ins_error();
}
deletions_allowed = true;
integer k;
cur_input.limit_field = last;
+
if (pausing > 0)
- if (interaction > 1)
+ if (interaction > nonstop_mode)
{
;
print_ln();
+
if (cur_input.start_field < cur_input.limit_field)
for (k = cur_input.start_field; k <= cur_input.limit_field - 1; k++)
print(buffer[k]);
+
first = cur_input.limit_field;
+
{
;
print_string("=>");
term_input("=>", 0);
}
+
if (last > first)
{
for (k = first; k <= last - 1; k++)
buffer[k + cur_input.start_field - first] = buffer[k];
+
cur_input.limit_field = cur_input.start_field + last - first;
}
}
no_new_control_sequence = false;
get_next();
no_new_control_sequence = true;
+
if (cur_cs == 0)
cur_tok = (cur_cmd * 256) + cur_chr;
else
- cur_tok = 4095 + cur_cs;
+ cur_tok = cs_token_flag + cur_cs;
}
/* sec 0389 */
void macro_call (void)
token_show(refcount);
end_diagnostic(false);
}
- if (info(r) != 3584)
+
+ if (info(r) != end_match_token)
{
scanner_status = matching;
unbalance = 0;
long_state = eq_type(cur_cs);
+
if (long_state >= outer_call)
long_state = long_state - 2;
- do {
- link(temp_head) = 0;
- if ((info(r) > 3583) || (info(r) < 3328))
- s = 0;
- else
- {
- match_chr = info(r) - 3328;
- s = link(r);
- r = s;
- p = temp_head;
- m = 0;
- }
-lab22:
- get_token();
- if (cur_tok == info(r))
+
+ do
{
- r = link(r);
- if ((info(r) >= 3328) && (info(r) <= 3584))
+ link(temp_head) = 0;
+
+ if ((info(r) > match_token + 255) || (info(r) < match_token))
+ s = 0;
+ else
{
- if (cur_tok < 512)
- decr(align_state);
- goto lab40;
+ match_chr = info(r) - match_token;
+ s = link(r);
+ r = s;
+ p = temp_head;
+ m = 0;
}
- else
- goto lab22;
- }
- if (s != r)
- if (s == 0)
+lab22:
+ get_token();
+
+ if (cur_tok == info(r))
{
- print_err("Use of ");
- sprint_cs(warning_index);
- print_string(" doesn't match its definition");
- help4("If you say, e.g., `\\def\\a1{...}', then you must always",
+ r = link(r);
+
+ if ((info(r) >= match_token) && (info(r) <= end_match_token))
+ {
+ if (cur_tok < left_brace_limit)
+ decr(align_state);
+
+ goto lab40;
+ }
+ else
+ goto lab22;
+ }
+
+ if (s != r)
+ if (s == 0)
+ {
+ print_err("Use of ");
+ sprint_cs(warning_index);
+ print_string(" doesn't match its definition");
+ help4("If you say, e.g., `\\def\\a1{...}', then you must always",
"put `1' after `\\a', since control sequence names are",
"made up of letters only. The macro here has not been",
"followed by the required stuff, so I'm ignoring it.");
- error();
- goto lab10;
- }
- else
- {
- t = s;
- do {
- {
- q = get_avail();
- mem[p].hh.v.RH = q;
- mem[q].hh.v.LH = mem[t].hh.v.LH;
- p = q;
- }
- incr(m);
- u = link(t);
- v = s;
- while (true) {
- if (u == r)
- if (cur_tok != info(v))
- goto lab30;
- else
+ error();
+ goto lab10;
+ }
+ else
+ {
+ t = s;
+ do
+ {
{
- r = link(v);
- goto lab22;
+ q = get_avail();
+ mem[p].hh.v.RH = q;
+ mem[q].hh.v.LH = mem[t].hh.v.LH;
+ p = q;
+ }
+
+ incr(m);
+ u = link(t);
+ v = s;
+
+ while (true)
+ {
+ if (u == r)
+ if (cur_tok != info(v))
+ goto lab30;
+ else
+ {
+ r = link(v);
+ goto lab22;
+ }
+
+ if (info(u) != info(v))
+ goto lab30;
+
+ u = link(u);
+ v = link(v);
}
- if (info(u) != info(v))
- goto lab30;
- u = link(u);
- v = link(v);
- }
lab30:
- t = link(t);
- } while(!(t == r));
- r = s;
- }
- if (cur_tok == par_token)
- if (long_state != long_call)
- {
- if (long_state == call)
+ t = link(t);
+ }
+ while(!(t == r));
+
+ r = s;
+ }
+
+ if (cur_tok == par_token)
+ if (long_state != long_call)
{
- runaway();
- print_err("Paragraph ended before ");
- sprint_cs(warning_index);
- print_string("was complete");
- help3("I suspect you've forgotten a `}', causing me to apply this",
- "control sequence to too much text. How can we recover?",
- "My plan is to forget the whole thing and hope for the best.");
- back_error();
+ if (long_state == call)
+ {
+ runaway();
+ print_err("Paragraph ended before ");
+ sprint_cs(warning_index);
+ print_string("was complete");
+ help3("I suspect you've forgotten a `}', causing me to apply this",
+ "control sequence to too much text. How can we recover?",
+ "My plan is to forget the whole thing and hope for the best.");
+ back_error();
+ }
+
+ pstack[n] = link(temp_head);
+ align_state = align_state - unbalance;
+
+ for (m = 0; m <= n; m++)
+ flush_list(pstack[m]);
+
+ goto lab10;
}
- pstack[n] = link(temp_head);
- align_state = align_state - unbalance;
- for (m = 0; m <= n; m++)
- flush_list(pstack[m]);
- goto lab10;
- }
- if (cur_tok < 768)
- if (cur_tok < 512)
- {
- unbalance = 1;
- while (true) {
+
+ if (cur_tok < right_brace_limit)
+ if (cur_tok < left_brace_limit)
+ {
+ unbalance = 1;
+
+ while (true)
{
{
- q = avail;
- if (q == 0)
- q = get_avail();
- else
{
- avail = mem[q].hh.v.RH;
- mem[q].hh.v.RH = 0;
+ q = avail;
+
+ if (q == 0)
+ q = get_avail();
+ else
+ {
+ avail = mem[q].hh.v.RH;
+ mem[q].hh.v.RH = 0;
#ifdef STAT
- incr(dyn_used);
+ incr(dyn_used);
#endif /* STAT */
+ }
}
+
+ mem[p].hh.v.RH = q;
+ mem[q].hh.v.LH = cur_tok;
+ p = q;
}
+
+ get_token();
+
+ if (cur_tok == par_token)
+ if (long_state != long_call)
+ {
+ if (long_state == call)
+ {
+ runaway();
+ print_err("Paragraph ended before ");
+ sprint_cs(warning_index);
+ print_string(" was complete");
+ help3("I suspect you've forgotten a `}', causing me to apply this",
+ "control sequence to too much text. How can we recover?",
+ "My plan is to forget the whole thing and hope for the best.");
+ back_error();
+ }
+
+ pstack[n] = link(temp_head);
+ align_state = align_state - unbalance;
+
+ for (m = 0; m <= n; m++)
+ flush_list(pstack[m]);
+ goto lab10;
+ }
+
+ if (cur_tok < right_brace_limit)
+ if (cur_tok < left_brace_limit)
+ incr(unbalance);
+ else
+ {
+ decr(unbalance);
+
+ if (unbalance == 0)
+ goto lab31;
+ }
+ }
+lab31:
+ rbraceptr = p;
+
+ {
+ q = get_avail();
mem[p].hh.v.RH = q;
mem[q].hh.v.LH = cur_tok;
p = q;
}
- get_token();
- if (cur_tok == par_token)
- if (long_state != long_call)
- {
- if (long_state == call)
- {
- runaway();
- print_err("Paragraph ended before ");
- sprint_cs(warning_index);
- print_string(" was complete");
- help3("I suspect you've forgotten a `}', causing me to apply this",
- "control sequence to too much text. How can we recover?",
- "My plan is to forget the whole thing and hope for the best.");
- back_error();
- }
- pstack[n] = link(temp_head);
- align_state = align_state - unbalance;
- for (m = 0; m <= n; m++)
- flush_list(pstack[m]);
- goto lab10;
- }
- if (cur_tok < 768)
- if (cur_tok < 512)
- incr(unbalance);
- else
- {
- decr(unbalance);
- if (unbalance == 0)
- goto lab31;
- }
}
-lab31:
- rbraceptr = p;
+ else
+ {
+ back_input();
+ print_err("Argument of ");
+ sprint_cs(warning_index);
+ print_string(" has an extra }");
+ help6("I've run across a `}' that doesn't seem to match anything.",
+ "For example, `\\def\\a#1{...}' and `\\a}' would produce",
+ "this error. If you simply proceed now, the `\\par' that",
+ "I've just inserted will cause me to report a runaway",
+ "argument that might be the root of the problem. But if",
+ "your `}' was spurious, just type `2' and it will go away.");
+ incr(align_state);
+ long_state = call;
+ cur_tok = par_token;
+ ins_error();
+ goto lab22;
+ }
+ else
+ {
+ if (cur_tok == space_token)
+ if (info(r) <= end_match_token)
+ if (info(r) >= match_token)
+ goto lab22;
+
{
q = get_avail();
- mem[p].hh.v.RH = q;
+ mem[p].hh.v.RH = q; /* p may be used without having ... */
mem[q].hh.v.LH = cur_tok;
p = q;
}
}
- else
- {
- back_input();
- print_err("Argument of ");
- sprint_cs(warning_index);
- print_string(" has an extra }");
- help6("I've run across a `}' that doesn't seem to match anything.",
- "For example, `\\def\\a#1{...}' and `\\a}' would produce",
- "this error. If you simply proceed now, the `\\par' that",
- "I've just inserted will cause me to report a runaway",
- "argument that might be the root of the problem. But if",
- "your `}' was spurious, just type `2' and it will go away.");
- incr(align_state);
- long_state = call;
- cur_tok = par_token;
- ins_error();
+
+ incr(m); /* m may be used without having been ... */
+
+ if (info(r) > end_match_token)
+ goto lab22;
+
+ if (info(r) < match_token)
goto lab22;
- }
- else
- {
- if (cur_tok == 2592)
- if (info(r) <= 3584)
- if (info(r) >= 3328)
- goto lab22;
- {
- q = get_avail();
- mem[p].hh.v.RH = q; /* p may be used without having ... */
- mem[q].hh.v.LH = cur_tok;
- p = q;
- }
- }
- incr(m); /* m may be used without having been ... */
- if (info(r) > 3584)
- goto lab22;
- if (info(r) < 3328)
- goto lab22;
lab40:
- if (s != 0)
- {
- if ((m == 1) && (info(p) < 768) && (p != temp_head))
- {
- link(rbraceptr) = 0; /* rbraceptr may be used without ... */
- free_avail(p);
- p = link(temp_head);
- pstack[n]= link(p);
- free_avail(p);
- }
- else
- pstack[n] = link(temp_head);
- incr(n);
- if (tracing_macros > 0)
+ if (s != 0)
{
- begin_diagnostic();
- //print_nl(match_chr); /* matchchar may be used without ... */
- print_nl(""); print(match_chr);
- print_int(n);
- print_string("<-");
- show_token_list(pstack[n - 1], 0, 1000);
- end_diagnostic(false);
+ if ((m == 1) && (info(p) < right_brace_limit) && (p != temp_head))
+ {
+ link(rbraceptr) = 0; /* rbraceptr may be used without ... */
+ free_avail(p);
+ p = link(temp_head);
+ pstack[n] = link(p);
+ free_avail(p);
+ }
+ else
+ pstack[n] = link(temp_head);
+
+ incr(n);
+
+ if (tracing_macros > 0)
+ {
+ begin_diagnostic();
+ //print_nl(match_chr); /* matchchar may be used without ... */
+ print_nl(""); print(match_chr);
+ print_int(n);
+ print_string("<-");
+ show_token_list(pstack[n - 1], 0, 1000);
+ end_diagnostic(false);
+ }
}
}
- } while(!(info(r) == 3584));
+ while(!(info(r) == end_match_token));
}
while((cur_input.state_field == token_list) && (cur_input.loc_field == 0) &&
(cur_input.index_field != v_template))
end_token_list();
+
begin_token_list(refcount, macro);
cur_input.name_field = warning_index;
cur_input.loc_field = link(r);
+
if (n > 0)
{
if (param_ptr + n > max_param_stack)
{
max_param_stack = param_ptr + n;
+
#ifdef ALLOCATEPARAMSTACK
if (max_param_stack > current_param_size)
param_stack = realloc_param_stack(increment_param_size);
- if (max_param_stack > current_param_size)
- { /* check again after allocation */
+
+ if (max_param_stack > current_param_size) /* check again after allocation */
+ {
overflow("parameter stack size", current_param_size);
return; // abort_flag set
}
}
#endif
}
+
for (m = 0; m <= n - 1; m++)
param_stack[param_ptr + m] = pstack[m];
+
param_ptr = param_ptr + n;
}
lab10:
warning_index = savewarningindex;
}
/* sec 0379 */
-void insert_relax (void)
+void insert_relax (void)
{
- cur_tok = 4095 + cur_cs;
+ cur_tok = cs_token_flag + cur_cs;
back_input();
-/* cur_tok = (hash_size + 4616); */
-/* cur_tok = (hash_size + 4095 + 521); */
- cur_tok = (hash_size + hash_extra + 4095 + 521); /* 96/Jan/10 */
+ cur_tok = cs_token_flag + frozen_relax; /* 96/Jan/10 */
back_input();
cur_input.index_field = inserted;
}
radixbackup = radix;
cobackup = cur_order;
backupbackup = link(backup_head);
+
if (cur_cmd < call)
{
if (tracing_commands > 1)
show_cur_cmd_chr();
+
switch (cur_cmd)
{
case top_bot_mark:
if (cur_mark[cur_chr] != 0)
begin_token_list(cur_mark[cur_chr], mark_text);
break;
+
case expand_after:
get_token();
t = cur_tok;
get_token();
+
if (cur_cmd > max_command)
expand();
else
back_input();
+
cur_tok = t;
back_input();
break;
+
case no_expand:
savescannerstatus = scanner_status;
scanner_status = normal;
scanner_status = savescannerstatus;
t = cur_tok;
back_input();
- if (t >= 4095) /* if t>=cs_token_flag then */
+
+ if (t >= cs_token_flag)
{
-/* begin p:=get_avail; info(p):=cs_token_flag+frozen_dont_expand; */
p = get_avail();
-/* mem[p].hh.v.LH = (hash_size + 4618); */
-/* mem[p].hh.v.LH = (hash_size + 4095 + 523); */
- mem[p].hh.v.LH = (hash_size + hash_extra + 4095 + 523); /*96/Jan/10*/
- mem[p].hh.v.RH = cur_input.loc_field;
+ info(p) = cs_token_flag + frozen_dont_expand; /*96/Jan/10*/
+ link(p) = cur_input.loc_field;
cur_input.start_field = p;
cur_input.loc_field = p;
}
break;
+
case cs_name:
r = get_avail();
p = r;
- do {
- get_x_token();
- if (cur_cs == 0)
+ do
{
- q = get_avail();
- mem[p].hh.v.RH = q;
- mem[q].hh.v.LH = cur_tok;
- p = q;
+ get_x_token();
+
+ if (cur_cs == 0)
+ {
+ q = get_avail();
+ mem[p].hh.v.RH = q;
+ mem[q].hh.v.LH = cur_tok;
+ p = q;
+ }
}
- } while(!(cur_cs != 0));
+ while(!(cur_cs != 0));
+
if (cur_cmd != end_cs_name)
{
print_err("Missing ");
"not appear between \\csname and \\endcsname.");
back_error();
}
+
j = first;
p = link(r);
- while (p != 0) { /* while p<>null do l.7742 */
+
+ while (p != 0)
+ {
if (j >= max_buf_stack)
{
max_buf_stack = j + 1;
+
#ifdef ALLOCATEBUFFER
if (max_buf_stack == current_buf_size)
buffer = realloc_buffer (increment_buf_size);
- if (max_buf_stack == current_buf_size)
- { /* check again after allocation */
+
+ if (max_buf_stack == current_buf_size) /* check again after allocation */
+ {
overflow("buffer size", current_buf_size);
return; // abort_flag set
}
}
#endif
}
+
buffer[j] = info(p) % 256;
incr(j);
p = link(p);
}
+
if (j > first + 1)
{
no_new_control_sequence = false;
cur_cs = null_cs;
else
cur_cs = single_base + buffer[first];
+
flush_list(r);
+
if (eq_type(cur_cs) == undefined_cs)
{
eq_define(cur_cs, relax, 256);
}
- cur_tok = cur_cs + 4095;
+
+ cur_tok = cur_cs + cs_token_flag;
back_input();
break;
+
case convert:
conv_toks();
break;
+
case the:
ins_the_toks();
break;
+
case if_test:
conditional();
break;
+
case fi_or_else:
if (cur_chr > if_limit)
if (if_limit == 1)
}
else
{
- while(cur_chr != 2)
+ while(cur_chr != fi_code)
pass_text();
+
{
p = cond_ptr;
- if_line = mem[p + 1].cint;
- cur_if = mem[p].hh.b1;
- if_limit = mem[p].hh.b0;
- cond_ptr = mem[p].hh.v.RH;
- free_node(p, 2);
+ if_line = if_line_field(p);
+ cur_if = subtype(p);
+ if_limit = type(p);
+ cond_ptr = link(p);
+ free_node(p, if_node_size);
}
}
break;
+
case input:
if (cur_chr > 0)
force_eof = true;
else if (name_in_progress)
insert_relax();
- else start_input();
+ else
+ start_input();
break;
+
default:
print_err("Undefined control sequence");
help5("The control sequence at the end of the top line",
}
else
{
-/* cur_tok = (hash_size + 4615); */
-/* cur_tok = (hash_size + 4095 + 520); */
- cur_tok = (hash_size + hash_extra + 4095 + 520); /* 96/Jan/10 */
+ cur_tok = cs_token_flag + frozen_endv; /* 96/Jan/10 */
back_input();
}
+
cur_val = cvbackup;
cur_val_level = cvlbackup;
radix = radixbackup;
{
lab20:
get_next();
+
if (cur_cmd <= max_command)
goto lab30;
if (cur_cmd >= call)
if (cur_cmd < end_template)
macro_call();
- else {
-/* cur_cs = (hash_size + 520); */
- cur_cs = (hash_size + hash_extra + 520); /* 96/Jan/10 */
+ else
+ {
+ cur_cs = frozen_endv; /* 96/Jan/10 */
cur_cmd = endv;
goto lab30;
}
else
expand();
+
goto lab20;
lab30:
if (cur_cs == 0)
cur_tok = (cur_cmd * 256) + cur_chr;
else
- cur_tok = 4095 + cur_cs;
+ cur_tok = cs_token_flag + cur_cs;
}
/* sec 0381 */
void x_token (void)
{
- while (cur_cmd > max_command) {
+ while (cur_cmd > max_command)
+ {
expand();
get_next();
}
+
if (cur_cs == 0)
cur_tok = (cur_cmd * 256) + cur_chr;
else
- cur_tok = 4095 + cur_cs;
+ cur_tok = cs_token_flag + cur_cs;
}
/* sec 0403 */
void scan_left_brace (void)
{
- do {
+ do
+ {
get_x_token();
- } while(!((cur_cmd != spacer) && (cur_cmd != relax)));
+ }
+ while(!((cur_cmd != spacer) && (cur_cmd != relax)));
if (cur_cmd != left_brace)
{
"so that I will find a matching right brace soon.",
"(If you're confused by all this, try typing `I}' now.)");
back_error();
- cur_tok = 379;
+ cur_tok = left_brace_token + '{';
cur_cmd = left_brace;
cur_chr = '{';
incr(align_state);
/* sec 0405 */
void scan_optional_equals (void)
{
- do {
+ do
+ {
get_x_token();
- } while(!(cur_cmd != spacer));
+ }
+ while(!(cur_cmd != spacer));
- if (cur_tok != 3133)
+ if (cur_tok != other_token + '=')
back_input();
}
/* sec 0407 */
bool scan_keyword_(char * s)
{
- register bool Result;
halfword p;
halfword q;
char * k;
link(p) = 0;
k = s;
- while (*k) {
+ while (*k)
+ {
get_x_token();
- if ((cur_cs == 0) && ((cur_chr == (*k)) || (cur_chr == (*k) - 32)))
+
+ if ((cur_cs == 0) && ((cur_chr == (*k)) || (cur_chr == (*k) - 'a' + 'A')))
{
{
q = get_avail();
mem[q].hh.v.LH = cur_tok;
p = q;
}
+
incr(k);
}
else if ((cur_cmd != spacer) || (p != backup_head))
{
back_input();
+
if (p != backup_head)
- begin_token_list(link(backup_head), 3);
- Result = false;
- return(Result);
+ back_list(link(backup_head));
+
+ return false;
}
}
+
flush_list(link(backup_head));
- Result = true;
- return Result;
+
+ return true;
}
/* sec 0408 */
void mu_error (void)
void scan_eight_bit_int (void)
{
scan_int();
+
if ((cur_val < 0) || (cur_val > 255))
{
print_err("Bad register code");
void scan_char_num (void)
{
scan_int();
+
if ((cur_val < 0) || (cur_val > 255))
{
print_err("Bad character code");
void scan_four_bit_int (void)
{
scan_int();
+
if ((cur_val < 0) || (cur_val > 15))
{
print_err("Bad number");
void scan_twenty_seven_bit_int (void)
{
scan_int();
+
if ((cur_val < 0) || (cur_val > 134217727L)) /* 2^27 - 1 */
{
print_err("Bad delimiter code");
internal_font_number f;
halfword m;
- do {
+ do
+ {
get_x_token();
- } while (!(cur_cmd != spacer));
+ }
+ while (!(cur_cmd != spacer));
if (cur_cmd == def_font)
f = cur_font;
help2("I was looking for a control sequence whose",
"current meaning has been defined by \\font.");
back_error();
- f = 0;
+ f = null_font;
}
+
cur_val = f;
}
/* sec 0578 */
n = cur_val;
scan_font_ident();
f = cur_val;
-/* if (n <= 0)*/ /* change 98/Oct/5 */
- if (n < 0 || (n == 0 && font_dimen_zero == 0))
+
+ if (n < 0 || (n == 0 && font_dimen_zero == 0)) /* change 98/Oct/5 */
cur_val = fmem_ptr;
else
{
-/* else begin if writing and(n<=space_shrink_code)and@|
- (n>=space_code)and(font_glue[f]<>null) then
- begin delete_glue_ref(font_glue[f]); l.11225 */
- if (writing && (n <= 4) && (n >= 2) && (font_glue[f]!= 0))
+ if (writing && (n <= space_shrink_code) && (n >= space_code) && (font_glue[f] != 0))
{
delete_glue_ref(font_glue[f]);
- font_glue[f]= 0; /* font_glue[f]:=null */
+ font_glue[f] = 0;
}
+
if (n > font_params[f])
if (f < font_ptr)
cur_val = fmem_ptr;
else
{
- do {
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
+ do
+ {
#ifdef ALLOCATEFONT
- if (fmem_ptr == current_font_mem_size)
- { /* 93/Nov/28 ??? */
- font_info = realloc_font_info(increment_font_mem_size);
- }
- if (fmem_ptr == current_font_mem_size)
- { /* 94/Jan/24 */
- overflow("font memory", current_font_mem_size); /* font memory */
- return; // abort_flag set
- }
+ if (fmem_ptr == current_font_mem_size) /* 93/Nov/28 ??? */
+ {
+ font_info = realloc_font_info(increment_font_mem_size);
+ }
+
+ if (fmem_ptr == current_font_mem_size) /* 94/Jan/24 */
+ {
+ overflow("font memory", current_font_mem_size); /* font memory */
+ return; // abort_flag set
+ }
#else
-/* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
- if (fmem_ptr == font_mem_size)
- {
- overflow("font memory", font_mem_size); /* font memory */
- return; // abort_flag set
- }
+ if (fmem_ptr == font_mem_size)
+ {
+ overflow("font memory", font_mem_size); /* font memory */
+ return; // abort_flag set
+ }
#endif
- font_info[fmem_ptr].cint = 0;
- incr(fmem_ptr);
- incr(font_params[f]);
- } while(!(n == font_params[f]));
+ font_info[fmem_ptr].cint = 0;
+ incr(fmem_ptr);
+ incr(font_params[f]);
+ }
+ while(!(n == font_params[f]));
+
cur_val = fmem_ptr - 1;
}
-/* else cur_val = n + param_base[f]; */ /* 98/Oct/5 */
else if (n > 0)
cur_val = n + param_base[f]; /* 98/Oct/5 */
- else cur_val = &font_check[f] - &font_info[0]; /* 98/Oct/5 */
+ else
+ cur_val = (&font_check[f] - &font_info[0]); /* 98/Oct/5 */
/* checksum = (((font_check[f].b0) << 8 | font_check[f].b1) << 8 |
font_check[f].b2) << 8 | font_check[f].b3; */
- }
+ }
/* compiler error: '-' : incompatible types - from 'union fmemoryword *' to 'struct fourunsignedchars *' */
if (cur_val == fmem_ptr)
{
print_err("Font ");
/* print_esc(hash[(hash_size + 524) + f].v.RH); */
- //print_esc(hash[(hash_size + hash_extra + 524) + f].v.RH); /*96/Jan/10*/
- print_esc(""); print(hash[(hash_size + hash_extra + 524) + f].v.RH);
+ print_esc(""); print(font_id_text(f));
print_string(" has only ");
print_int(font_params[f]);
print_string(" fontdimen parameters");
{
halfword m;
integer p;
+
m = cur_chr;
switch (cur_cmd)
{
case def_code:
- scan_char_num();
- if (m == math_code_base)
{
- cur_val = math_code(cur_val);
- cur_val_level = 0;
+ scan_char_num();
+
+ if (m == math_code_base)
+ {
+ cur_val = math_code(cur_val);
+ cur_val_level = int_val;
+ }
+ else if (m < math_code_base)
+ {
+ cur_val = equiv(m + cur_val);
+ cur_val_level = int_val;
+ }
+ else
+ {
+ cur_val = eqtb[m + cur_val].cint;
+ cur_val_level = int_val;
+ }
}
- else if (m < math_code_base)
+ break;
+
+ case toks_register:
+ case assign_toks:
+ case def_family:
+ case set_font:
+ case def_font:
+ if (level != tok_val)
{
- cur_val = equiv(m + cur_val);
- cur_val_level = 0;
+ print_err("Missing number, treated as zero");
+ help3("A number should have been here; I inserted `0'.",
+ "(If you can't figure out why I needed to see a number,",
+ "look up `weird error' in the index to The TeXbook.)");
+ back_error();
+ {
+ cur_val = 0;
+ cur_val_level = dimen_val;
+ }
+ }
+ else if (cur_cmd <= assign_toks)
+ {
+ if (cur_cmd < assign_toks)
+ {
+ scan_eight_bit_int();
+ m = toks_base + cur_val;
+ }
+
+ {
+ cur_val = eqtb[m].hh.v.RH;
+ cur_val_level = tok_val;
+ }
}
else
{
- cur_val = eqtb[m + cur_val].cint;
- cur_val_level = 0;
+ back_input();
+ scan_font_ident();
+
+ {
+ cur_val = font_id_base + cur_val; /* 96/Jan/10 */
+ cur_val_level = ident_val;
+ }
}
break;
- case toks_register:
- case assign_toks:
- case def_family:
- case set_font:
- case def_font:
- if (level != 5)
- {
- print_err("Missing number, treated as zero");
- help3("A number should have been here; I inserted `0'.",
- "(If you can't figure out why I needed to see a number,",
- "look up `weird error' in the index to The TeXbook.)");
- back_error();
+
+ case assign_int:
{
- cur_val = 0;
- cur_val_level = 1;
+ cur_val = eqtb[m].cint;
+ cur_val_level = int_val;
}
- }
- else if (cur_cmd <= assign_toks)
- {
- if (cur_cmd < assign_toks)
+ break;
+
+ case assign_dimen:
{
- scan_eight_bit_int();
- m = toks_base + cur_val;
+ cur_val = eqtb[m].cint;
+ cur_val_level = dimen_val;
}
+ break;
+
+ case assign_glue:
{
cur_val = eqtb[m].hh.v.RH;
- cur_val_level = 5;
+ cur_val_level = glue_val;
}
- }
- else
- {
- back_input();
- scan_font_ident();
+ break;
+
+ case assign_mu_glue:
{
-/* cur_val = (hash_size + 524) + cur_val; */
- cur_val = (hash_size + hash_extra + 524) + cur_val; /* 96/Jan/10 */
- cur_val_level = 4;
+ cur_val = eqtb[m].hh.v.RH;
+ cur_val_level = mu_val;
}
- }
- break;
- case assign_int:
- {
- cur_val = eqtb[m].cint;
- cur_val_level = 0;
- }
- break;
- case assign_dimen:
- {
- cur_val = eqtb[m].cint;
- cur_val_level = 1;
- }
- break;
- case assign_glue:
- {
- cur_val = eqtb[m].hh.v.RH;
- cur_val_level = 2;
- }
- break;
- case assign_mu_glue:
- {
- cur_val = eqtb[m].hh.v.RH;
- cur_val_level = 3;
- }
- break;
- case set_aux:
- if (abs(mode)!= m)
- {
- print_err("Improper ");
- print_cmd_chr(set_aux, m);
- help4("You can refer to \\spacefactor only in horizontal mode;",
- "you can refer to \\prevdepth only in vertical mode; and",
- "neither of these is meaningful inside \\write. So",
- "I'm forgetting what you said and using zero instead.");
- error();
- if (level != 5)
+ break;
+
+ case set_aux:
+ if (abs(mode)!= m)
{
- cur_val = 0;
- cur_val_level = 1;
+ print_err("Improper ");
+ print_cmd_chr(set_aux, m);
+ help4("You can refer to \\spacefactor only in horizontal mode;",
+ "you can refer to \\prevdepth only in vertical mode; and",
+ "neither of these is meaningful inside \\write. So",
+ "I'm forgetting what you said and using zero instead.");
+ error();
+
+ if (level != tok_val)
+ {
+ cur_val = 0;
+ cur_val_level = dimen_val;
+ }
+ else
+ {
+ cur_val = 0;
+ cur_val_level = int_val;
+ }
+ }
+ else if (m == vmode)
+ {
+ cur_val = cur_list.aux_field.cint;
+ cur_val_level = dimen_val;
}
else
{
- cur_val = 0;
- cur_val_level = 0;
+ cur_val = space_factor;
+ cur_val_level = int_val;
}
- }
- else if (m == 1)
- {
- cur_val = cur_list.aux_field.cint;
- cur_val_level = 1;
- }
- else
- {
- cur_val = space_factor;
- cur_val_level = 0;
- }
- break;
- case set_prev_graf:
- if (mode == 0)
- {
- cur_val = 0;
- cur_val_level = 0;
- }
- else
- {
- nest[nest_ptr] = cur_list;
- p = nest_ptr;
- while (abs(nest[p].mode_field)!= 1)
- decr(p);
+ break;
+
+ case set_prev_graf:
+ if (mode == 0)
{
- cur_val = nest[p].pg_field;
- cur_val_level = 0;
+ cur_val = 0;
+ cur_val_level = int_val;
}
- }
- break;
- case set_page_int:
- {
- if (m == 0)
- cur_val = dead_cycles;
else
- cur_val = insert_penalties;
- cur_val_level = 0;
- }
- break;
- case set_page_dimen:
- {
- if ((page_contents == 0) && (! output_active))
+ {
+ nest[nest_ptr] = cur_list;
+ p = nest_ptr;
+
+ while (abs(nest[p].mode_field)!= vmode)
+ decr(p);
+
+ {
+ cur_val = nest[p].pg_field;
+ cur_val_level = int_val;
+ }
+ }
+ break;
+
+ case set_page_int:
+ {
if (m == 0)
- cur_val = 1073741823L; /* 2^30 - 1 */
+ cur_val = dead_cycles;
else
- cur_val = 0;
- else
- cur_val = page_so_far[m];
- cur_val_level = 1;
- }
- break;
- case set_shape:
- {
- if (par_shape_ptr == 0)
- cur_val = 0;
- else
- cur_val = mem[par_shape_ptr].hh.v.LH;
- cur_val_level = 0;
- }
- break;
- case set_box_dimen:
- {
- scan_eight_bit_int();
+ cur_val = insert_penalties;
- if (box(cur_val) == 0)
- cur_val = 0;
- else
- cur_val = mem[box(cur_val) + m].cint;
+ cur_val_level = 0;
+ }
+ break;
- cur_val_level = dimen_val;
- }
- break;
- case char_given:
- case math_given:
- {
- cur_val = cur_chr;
- cur_val_level = 0;
- }
- break;
- case assign_font_dimen:
- {
- find_font_dimen(false);
- font_info[fmem_ptr].cint = 0;
+ case set_page_dimen:
{
- cur_val = font_info[cur_val].cint;
- cur_val_level = 1;
+ if ((page_contents == 0) && (! output_active))
+ if (m == 0)
+ cur_val = 1073741823L; /* 2^30 - 1 */
+ else
+ cur_val = 0;
+ else
+ cur_val = page_so_far[m];
+
+ cur_val_level = dimen_val;
}
- }
- break;
- case assign_font_int:
- {
- scan_font_ident();
- if (m == 0)
+ break;
+
+ case set_shape:
{
- cur_val = hyphen_char[cur_val];
- cur_val_level = 0;
+ if (par_shape_ptr == 0)
+ cur_val = 0;
+ else
+ cur_val = info(par_shape_ptr);
+
+ cur_val_level = int_val;
}
- else
+ break;
+
+ case set_box_dimen:
{
- cur_val = skew_char[cur_val];
- cur_val_level = 0;
+ scan_eight_bit_int();
+
+ if (box(cur_val) == 0)
+ cur_val = 0;
+ else
+ cur_val = mem[box(cur_val) + m].cint;
+
+ cur_val_level = dimen_val;
}
- }
- break;
- case tex_register:
- {
- scan_eight_bit_int();
+ break;
- switch(m)
+ case char_given:
+ case math_given:
{
- case int_val:
- cur_val = count(cur_val);
- break;
- case dimen_val:
- cur_val = dimen(cur_val);
- break;
- case glue_val:
- cur_val = skip(cur_val);
- break;
- case mu_val:
- cur_val = mu_skip(cur_val);
- break;
+ cur_val = cur_chr;
+ cur_val_level = int_val;
}
+ break;
- cur_val_level = m;
- }
- break;
- case last_item:
- if (cur_chr > 2)
- {
- if (cur_chr == 3)
- cur_val = line;
- else
- cur_val = last_badness;
- cur_val_level = 0;
- }
- else
- {
- if (cur_chr == 2)
- cur_val = 0;
- else
- cur_val = 0;
- cur_val_level = cur_chr;
- if (!(tail >= hi_mem_min) && (mode != 0))
- switch(cur_chr)
+ case assign_font_dimen:
+ {
+ find_font_dimen(false);
+ font_info[fmem_ptr].cint = 0;
{
- case 0:
- if (mem[tail].hh.b0 == 12)
- cur_val = mem[tail + 1].cint;
- break;
- case 1:
- if (mem[tail].hh.b0 == 11)
- cur_val = mem[tail + 1].cint;
- break;
- case 2:
- if (mem[tail].hh.b0 == 10)
- {
- cur_val = mem[tail + 1].hh.v.LH;
- if (mem[tail].hh.b1 == 99)
- cur_val_level = 3;
- }
- break;
+ cur_val = font_info[cur_val].cint;
+ cur_val_level = dimen_val;
}
- else if ((mode == 1) && (tail == cur_list.head_field))
- switch (cur_chr)
+ }
+ break;
+
+ case assign_font_int:
+ {
+ scan_font_ident();
+
+ if (m == 0)
{
- case 0:
- cur_val = last_penalty;
+ cur_val = hyphen_char[cur_val];
+ cur_val_level = int_val;
+ }
+ else
+ {
+ cur_val = skew_char[cur_val];
+ cur_val_level = int_val;
+ }
+ }
+ break;
+
+ case tex_register:
+ {
+ scan_eight_bit_int();
+
+ switch(m)
+ {
+ case int_val:
+ cur_val = count(cur_val);
+ break;
+
+ case dimen_val:
+ cur_val = dimen(cur_val);
break;
- case 1:
- cur_val = last_kern;
+
+ case glue_val:
+ cur_val = skip(cur_val);
break;
- case 2:
-/* if (last_glue != 262143L) */ /* NO! */
- if (last_glue != empty_flag)
- cur_val = last_glue;
+
+ case mu_val:
+ cur_val = mu_skip(cur_val);
break;
}
- }
- break;
- default:
- {
- print_err("You can't use `");
- print_cmd_chr(cur_cmd, cur_chr);
- print_string("' after ");
- print_esc("the");
- help1("I'm forgetting what you said and using zero instead.");
- error();
- if (level != 5)
+
+ cur_val_level = m;
+ }
+ break;
+
+ case last_item:
+ if (cur_chr > glue_val)
{
- cur_val = 0;
- cur_val_level = 1;
+ if (cur_chr == input_line_no_code)
+ cur_val = line;
+ else
+ cur_val = last_badness;
+
+ cur_val_level = int_val;
}
else
{
- cur_val = 0;
- cur_val_level = 0;
+ if (cur_chr == glue_val)
+ cur_val = zero_glue;
+ else
+ cur_val = 0;
+
+ cur_val_level = cur_chr;
+
+ if (!(tail >= hi_mem_min) && (mode != 0))
+ switch(cur_chr)
+ {
+ case int_val:
+ if (type(tail) == penalty_node)
+ cur_val = penalty(tail);
+ break;
+
+ case dimen_val:
+ if (type(tail) == kern_node)
+ cur_val = width(tail);
+ break;
+
+ case glue_val:
+ if (type(tail) == glue_node)
+ {
+ cur_val = glue_ptr(tail);
+
+ if (subtype(tail) == mu_glue)
+ cur_val_level = mu_val;
+ }
+ break;
+ }
+ else if ((mode == 1) && (tail == cur_list.head_field))
+ switch (cur_chr)
+ {
+ case int_val:
+ cur_val = last_penalty;
+ break;
+
+ case dimen_val:
+ cur_val = last_kern;
+ break;
+
+ case glue_val:
+ if (last_glue != empty_flag)
+ cur_val = last_glue;
+ break;
+ }
}
- }
- break;
+ break;
+
+ default:
+ {
+ print_err("You can't use `");
+ print_cmd_chr(cur_cmd, cur_chr);
+ print_string("' after ");
+ print_esc("the");
+ help1("I'm forgetting what you said and using zero instead.");
+ error();
+
+ if (level != tok_val)
+ {
+ cur_val = 0;
+ cur_val_level = dimen_val;
+ }
+ else
+ {
+ cur_val = 0;
+ cur_val_level = int_val;
+ }
+ }
+ break;
}
- while (cur_val_level > level) {
- if (cur_val_level == 2)
- cur_val = mem[cur_val + 1].cint;
- else if (cur_val_level == 3)
- {
+
+ while (cur_val_level > level)
+ {
+ if (cur_val_level == glue_val)
+ cur_val = width(cur_val);
+ else if (cur_val_level == mu_val)
mu_error();
- }
+
decr(cur_val_level);
}
+
if (negative)
if (cur_val_level >= 2)
{
cur_val = new_spec(cur_val);
+
{
- mem[cur_val + 1].cint = - (integer) mem[cur_val + 1].cint;
- mem[cur_val + 2].cint = - (integer) mem[cur_val + 2].cint;
- mem[cur_val + 3].cint = - (integer) mem[cur_val + 3].cint;
+ width(cur_val) = - (integer) width(cur_val);
+ stretch(cur_val) = - (integer) stretch(cur_val);
+ shrink(cur_val) = - (integer) shrink(cur_val);
}
}
- else cur_val = - (integer) cur_val;
- else if ((cur_val_level >= 2) && (cur_val_level <= 3))
- incr(mem[cur_val].hh.v.RH);
+ else
+ cur_val = - (integer) cur_val;
+ else if ((cur_val_level >= glue_val) && (cur_val_level <= mu_val))
+ add_glue_ref(cur_val);
}
-
/*****************************************************************************/
-
/* Moved here to avoid question about pragma optimize 96/Sep/12 */
/* sec 0341 */
void get_next (void)
char d;
lab20:
- cur_cs = 0;
+ cur_cs = 0;
+
if (cur_input.state_field != token_list)
{
lab25:
incr(cur_input.loc_field);
lab21:
cur_cmd = cat_code(cur_chr);
+
switch (cur_input.state_field + cur_cmd)
{
case any_state_plus(ignore):
case new_line + spacer:
goto lab25;
break;
+
case any_state_plus(escape):
{
if (cur_input.loc_field > cur_input.limit_field)
cur_chr = buffer[k];
cat = cat_code(cur_chr);
incr(k);
+
if (cat == letter)
cur_input.state_field = skip_blanks;
else if (cat == spacer)
if ((cat == letter) && (k <= cur_input.limit_field))
{
- do {
- cur_chr = buffer[k];
- cat = cat_code(cur_chr);
- incr(k);
- } while(!((cat != letter) || (k > cur_input.limit_field)));
+ do
+ {
+ cur_chr = buffer[k];
+ cat = cat_code(cur_chr);
+ incr(k);
+ }
+ while(!((cat != letter) || (k > cur_input.limit_field)));
+
{
if (buffer[k]== cur_chr)
if (cat == sup_mark)
if (k < cur_input.limit_field)
{
c = buffer[k + 1];
+
if (c < 128)
{
d = 2;
- if ((((c >= 48) && (c <= 57)) ||
- ((c >= 97) && (c <= 102))))
+ if ((((c >= 48) && (c <= 57)) || ((c >= 97) && (c <= 102))))
if (k + 2 <= cur_input.limit_field)
{
cc = buffer[k + 2];
- if ((((cc >= 48) && (cc <= 57)) ||
- ((cc >= 97) && (cc <= 102))))
+
+ if ((((cc >= 48) && (cc <= 57)) || ((cc >= 97) && (cc <= 102))))
incr(d);
}
+
if (d > 2)
{
if (c <= 57)
cur_chr = c - 48;
else
cur_chr = c - 87;
+
if (cc <= 57)
cur_chr = 16 * cur_chr + cc - 48;
else
cur_chr = 16 * cur_chr + cc - 87;
+
buffer[k - 1] = cur_chr;
}
else if (c < 64)
buffer[k - 1] = c + 64;
else
buffer[k - 1] = c - 64;
+
cur_input.limit_field = cur_input.limit_field - d;
first = first - d;
- while (k <= cur_input.limit_field) {
+
+ while (k <= cur_input.limit_field)
+ {
buffer[k] = buffer[k + d];
incr(k);
}
+
goto lab26;
}
}
}
+
if (cat != letter)
decr(k);
+
if (k > cur_input.loc_field + 1)
{
cur_cs = id_lookup(cur_input.loc_field, k - cur_input.loc_field);
if (k < cur_input.limit_field)
{
c = buffer[k + 1];
+
if (c < 128) /* ? */
{
d = 2;
- if ((((c >= 48) && (c <= 57)) ||
- ((c >= 97) && (c <= 102))))
+ if ((((c >= 48) && (c <= 57)) || ((c >= 97) && (c <= 102))))
if (k + 2 <= cur_input.limit_field)
{
cc = buffer[k + 2];
- if ((((cc >= 48) && (cc <= 57)) ||
- ((cc >= 97) && (cc <= 102))))
+
+ if ((((cc >= 48) && (cc <= 57)) || ((cc >= 97) && (cc <= 102))))
incr(d);
}
+
if (d > 2)
{
if (c <= 57)
cur_chr = c - 48;
else
cur_chr = c - 87;
+
if (cc <= 57) /* cc may be used without ... */
cur_chr = 16 * cur_chr + cc - 48;
else
cur_chr = 16 * cur_chr + cc - 87;
+
buffer[k - 1] = cur_chr;
}
else if (c < 64)
buffer[k - 1] = c + 64;
else
buffer[k - 1] = c - 64;
+
cur_input.limit_field = cur_input.limit_field - d;
first = first - d;
- while (k <= cur_input.limit_field) {
+
+ while (k <= cur_input.limit_field)
+ {
buffer[k] = buffer[k + d];
incr(k);
}
cur_chr = equiv(cur_cs);
if (cur_cmd >= outer_call)
- {
check_outer_validity();
- }
}
break;
+
case any_state_plus(active_char):
{
cur_cs = cur_chr + active_base;
cur_input.state_field = mid_line;
if (cur_cmd >= outer_call)
- {
check_outer_validity();
- }
}
break;
+
case any_state_plus(sup_mark):
{
if (cur_chr == buffer[cur_input.loc_field])
if (cur_input.loc_field < cur_input.limit_field)
{
c = buffer[cur_input.loc_field + 1];
+
if (c < 128)
{
cur_input.loc_field = cur_input.loc_field + 2;
- if ((((c >= 48) && (c <= 57)) ||
- ((c >= 97) && (c <= 102))))
+
+ if ((((c >= 48) && (c <= 57)) || ((c >= 97) && (c <= 102))))
if (cur_input.loc_field <= cur_input.limit_field)
{
cc = buffer[cur_input.loc_field];
- if ((((cc >= 48) && (cc <= 57)) ||
- ((cc >= 97) && (cc <= 102))))
+
+ if ((((cc >= 48) && (cc <= 57)) || ((cc >= 97) && (cc <= 102))))
{
incr(cur_input.loc_field);
+
if (c <= 57)
cur_chr = c - 48;
else
cur_chr = c - 87;
+
if (cc <= 57)
cur_chr = 16 * cur_chr + cc - 48;
else
cur_chr = 16 * cur_chr + cc - 87;
+
goto lab21;
}
}
+
if (c < 64)
cur_chr = c + 64;
else
cur_chr = c - 64;
+
goto lab21;
}
}
- cur_input.state_field = mid_line;
+
+ cur_input.state_field = mid_line;
}
break;
+
case any_state_plus(invalid_char):
{
print_err("Text line contains an invalid character");
goto lab20;
}
break;
+
case mid_line + spacer:
{
cur_input.state_field = skip_blanks;
cur_chr = ' ';
}
break;
+
case mid_line + car_ret:
{
cur_input.loc_field = cur_input.limit_field + 1;
cur_chr = ' ';
}
break;
+
case skip_blanks + car_ret:
case any_state_plus(comment):
{
goto lab25;
}
break;
+
case new_line + car_ret:
{
cur_input.loc_field = cur_input.limit_field + 1;
cur_chr = equiv(cur_cs);
if (cur_cmd >= outer_call)
- {
check_outer_validity();
- }
}
break;
+
case mid_line + left_brace:
incr(align_state);
break;
+
case skip_blanks + left_brace:
case new_line + left_brace:
{
incr(align_state);
}
break;
+
case mid_line + right_brace:
decr(align_state);
break;
+
case skip_blanks + right_brace:
case new_line + right_brace:
{
decr(align_state);
}
break;
+
case add_delims_to(skip_blanks):
case add_delims_to(new_line):
cur_input.state_field = 1;
break;
+
default:
break;
}
{
incr(line);
first = cur_input.start_field;
+
if (!force_eof)
{
if (input_ln(input_file[cur_input.index_field], true))
- {
firm_up_the_line();
- }
else
force_eof = true;
}
check_outer_validity();
goto lab20;
}
+
if ((end_line_char < 0) || (end_line_char > 255))
decr(cur_input.limit_field);
else
buffer[cur_input.limit_field] = end_line_char;
+
first = cur_input.limit_field + 1;
cur_input.loc_field = cur_input.start_field;
}
cur_chr = 0;
return;
}
+
if (input_ptr > 0)
{
end_file_reading();
goto lab20;
}
+
if (selector < log_only)
open_log_file();
+
if (interaction > nonstop_mode)
{
if ((end_line_char < 0) || (end_line_char > 255))
incr(cur_input.limit_field);
+
if (cur_input.limit_field == cur_input.start_field)
print_nl("(Please type a command or say `\\end')");
+
print_ln();
first = cur_input.start_field;
+
{
;
print_string("*");
term_input("*", 0);
}
+
cur_input.limit_field = last;
+
if ((end_line_char < 0) || (end_line_char > 255))
decr(cur_input.limit_field);
else
buffer[cur_input.limit_field]= end_line_char;
+
first = cur_input.limit_field + 1;
cur_input.loc_field = cur_input.start_field;
}
return; // abort_flag set
}
}
+
{
if (interrupt != 0)
{
pause_for_instructions();
}
}
+
goto lab25;
}
}
{
t = info(cur_input.loc_field);
cur_input.loc_field = link(cur_input.loc_field);
- if (t >= 4095)
+
+ if (t >= cs_token_flag)
{
- cur_cs = t - 4095;
+ cur_cs = t - cs_token_flag;
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
+
if (cur_cmd >= outer_call)
if (cur_cmd == dont_expand)
{
- cur_cs = info(cur_input.loc_field) - 4095;
+ cur_cs = info(cur_input.loc_field) - cs_token_flag;
cur_input.loc_field = 0;
cur_cmd = eq_type(cur_cs);
cur_chr = equiv(cur_cs);
if (cur_cmd > max_command)
{
cur_cmd = relax;
- cur_chr = 257;
+ cur_chr = no_expand_flag;
}
}
else
{
cur_cmd = t / 256;
cur_chr = t % 256;
+
switch (cur_cmd)
{
case left_brace:
incr(align_state);
break;
+
case right_brace:
decr(align_state);
break;
+
case out_param:
{
begin_token_list(param_stack[cur_input.limit_field + cur_chr - 1], parameter);
goto lab20;
}
break;
+
default:
break;
}
end_token_list();
goto lab20;
}
+
if (cur_cmd <= car_ret)
if (cur_cmd >= tab_mark)
if (align_state == 0)
fatal_error("(interwoven alignment preambles are not allowed)");
return; // abort_flag set
}
+
cur_cmd = extra_info(cur_align);
extra_info(cur_align) = cur_chr;
+
if (cur_cmd == omit)
begin_token_list(omit_template, v_template);
else
begin_token_list(v_part(cur_align), v_template);
+
align_state = 1000000L;
goto lab20;
}
}
-#pragma optimize ("", on) /* 96/Sep/12 */
+#pragma optimize ("", on) /* 96/Sep/12 */
\ No newline at end of file
OSDN Git Service
