int settoks (lua_State *L) {
int i,j;
size_t k,len;
int cur_cs;
int texstr;
char *s, *st;
i = lua_gettop(L);
if (!lua_isstring(L,i)) {
lua_pushstring(L, "unsupported value type");
lua_error(L);
}
st = (char *)lua_tolstring(L,i,&len);
if (lua_type(L,i-1)==LUA_TSTRING) {
s = (char *)lua_tolstring(L,i-1, &k);
texstr = maketexlstring(s,k);
cur_cs = string_lookup(texstr);
flush_str(texstr);
k = zget_equiv(cur_cs)-get_toks_base();
} else {
k = (int)luaL_checkinteger(L,i-1);
}
check_index_range(k);
j = maketexlstring(st,len);
if(zset_tex_toks_register(k,j)) {
flush_str(j);
lua_pushstring(L, "incorrect value");
lua_error(L);
}
return 0;
}
int gettoks (lua_State *L) {
int i;
size_t k;
strnumber t;
int cur_cs;
int texstr;
char *s;
i = lua_gettop(L);
if (lua_type(L,i)==LUA_TSTRING) {
s = (char *)lua_tolstring(L,i, &k);
texstr = maketexlstring(s,k);
cur_cs = string_lookup(texstr);
flush_str(texstr);
if (is_undefined_cs(cur_cs)) {
lua_pushnil(L);
return 1;
}
k = zget_equiv(cur_cs)-get_toks_base();
} else {
k = (int)luaL_checkinteger(L,i);
}
check_index_range(k);
t = get_tex_toks_register(k);
lua_pushstring(L, makecstring(t));
flush_str(t);
return 1;
}
int
gettex (lua_State *L) {
char *st;
int i,texstr;
size_t k;
char *str;
int cur_cs, cur_cmd, cur_code;
i = lua_gettop(L);
if (lua_isstring(L,i)) {
st = (char *)lua_tolstring(L,i, &k);
texstr = maketexlstring(st,k);
cur_cs = zprim_lookup(texstr);
flush_str(texstr);
if (cur_cs) {
cur_cmd = zget_prim_eq_type(cur_cs);
cur_code = zget_prim_equiv(cur_cs);
if (is_convert(cur_cmd))
str = get_convert(cur_code);
else
str = get_something_internal(cur_cmd,cur_code);
if (str)
lua_pushstring(L,str);
else
lua_pushnil(L);
return 1;
} else {
lua_rawget(L,(i-1));
return 1;
}
} else {
lua_rawget(L,(i-1));
return 1;
}
return 0; /* not reached */
}
int setdimen (lua_State *L) {
int i,j;
size_t k;
int cur_cs;
int texstr;
char *s;
i = lua_gettop(L);
j = 0;
/* find the value*/
if (!lua_isnumber(L,i))
if (lua_isstring(L,i)) {
j = dimen_to_number(L,(char *)lua_tostring(L,i));
} else {
lua_pushstring(L, "unsupported value type");
lua_error(L);
}
else
j = (int)lua_tonumber(L,i);
/* find the index*/
if (lua_type(L,i-1)==LUA_TSTRING) {
s = (char *)lua_tolstring(L,i-1, &k);
texstr = maketexlstring(s,k);
cur_cs = string_lookup(texstr);
flush_str(texstr);
k = zget_equiv(cur_cs)-get_scaled_base();
} else {
k = (int)luaL_checkinteger(L,i-1);
}
check_index_range(k);
if(set_tex_dimen_register(k,j)) {
lua_pushstring(L, "incorrect value");
lua_error(L);
}
return 0;
}
char *
get_convert (int cur_code) {
int texstr;
char *str = NULL;
texstr = the_convert_string(cur_code);
if (texstr) {
str = makecstring(texstr);
flush_str(texstr);
}
return str;
}
void tex::show_box(ptr p)
{
depth_threshold = show_box_depth;
breadth_max = show_box_breadth;
if (breadth_max <= 0)
breadth_max = 5;
flush_str();
if (cur_str_ptr + depth_threshold >= cur_str_end)
depth_threshold = cur_str_end - cur_str_ptr - 1;
show_node_list(p);
}
NO_INLINE void G_GNUC_COLD
assertion_failure_log(const assertion_data * const data,
const char * const fmt, ...)
{
va_list args;
const char *msg;
assertion_message(data, TRUE);
/*
* Record the root cause of the assertion failure to be able to log it
* in the crash log in case they don't have gdb available.
*/
crash_assert_failure(data);
/*
* Record additional message in the crash log as well.
*/
va_start(args, fmt);
msg = crash_assert_logv(fmt, args);
va_end(args);
/*
* Log additional message.
*/
if (msg != NULL) {
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (FATAL-): ")];
unsigned stid = thread_small_id();
DECLARE_STR(4);
crash_time(time_buf, sizeof time_buf);
print_str(time_buf);
if (0 == stid) {
print_str(" (FATAL): ");
} else {
str_bprintf(prefix, sizeof prefix, " (FATAL-%u): ", stid);
print_str(prefix);
}
print_str(msg);
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
assertion_abort();
}
char *
get_something_internal (int cur_cmd, int cur_code) {
int texstr;
char *str;
int save_cur_val,save_cur_val_level;
save_cur_val = cur_val;
save_cur_val_level = cur_val_level;
zscan_something_simple(cur_cmd,cur_code);
texstr = the_scanned_result();
cur_val = save_cur_val;
cur_val_level = save_cur_val_level;
str = makecstring(texstr);
flush_str(texstr);
return str;
}
int settex (lua_State *L) {
char *st;
int i,j,texstr;
size_t k;
int cur_cs, cur_cmd;
j = 0;
i = lua_gettop(L);
if (lua_isstring(L,(i-1))) {
st = (char *)lua_tolstring(L,(i-1), &k);
texstr = maketexlstring(st,k);
if (zis_primitive(texstr)) {
cur_cs = string_lookup(texstr);
flush_str(texstr);
cur_cmd = zget_eq_type(cur_cs);
if (is_int_assign(cur_cmd)) {
if (lua_isnumber(L,i)) {
assign_internal_int(zget_equiv(cur_cs),lua_tonumber(L,i));
} else {
lua_pushstring(L, "unsupported value type");
lua_error(L);
}
} else if (is_dim_assign(cur_cmd)) {
if (!lua_isnumber(L,i))
if (lua_isstring(L,i)) {
j = dimen_to_number(L,(char *)lua_tostring(L,i));
} else {
lua_pushstring(L, "unsupported value type");
lua_error(L);
}
else
j = (int)lua_tonumber(L,i);
assign_internal_dim(zget_equiv(cur_cs),j);
} else {
lua_pushstring(L, "unsupported tex internal assignment");
lua_error(L);
}
} else {
lua_rawset(L,(i-2));
}
} else {
lua_rawset(L,(i-2));
}
return 0;
}
NO_INLINE void G_GNUC_COLD
assertion_warning_log(const assertion_data * const data,
const char * const fmt, ...)
{
static str_t *str;
va_list args;
assertion_message(data, FALSE);
if G_UNLIKELY(NULL == str)
str = str_new_not_leaking(512);
/*
* Log additional message.
*/
va_start(args, fmt);
str_vprintf(str, fmt, args);
va_end(args);
{
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid = thread_small_id();
DECLARE_STR(4);
crash_time(time_buf, sizeof time_buf);
print_str(time_buf);
if (0 == stid) {
print_str(" (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (WARNING-%u): ", stid);
print_str(prefix);
}
print_str(str_2c(str));
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
assertion_stacktrace();
}
static int get_box_id (lua_State *L, int i) {
const char *s;
integer cur_cs, cur_cmd;
str_number texstr;
size_t k = 0;
int j = -1;
if (lua_type(L,i)==LUA_TSTRING) {
s = (char *)lua_tolstring(L,i, &k);
texstr = maketexlstring(s,k);
cur_cs = string_lookup(texstr);
cur_cmd = zget_eq_type(cur_cs);
flush_str(texstr);
if (cur_cmd==char_given ||
cur_cmd==math_given ||
cur_cmd==omath_given) {
j = zget_equiv(cur_cs);
}
} else {
j = (int)lua_tonumber(L,(i));
}
return j;
}
/**
* @note For maximum safety this is kept signal-safe, so that we can
* even use assertions in signal handlers. See also:
* http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html
*/
static G_GNUC_COLD void
assertion_message(const assertion_data * const data, int fatal)
{
char line_buf[22];
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid;
DECLARE_STR(16);
crash_time(time_buf, sizeof time_buf);
stid = thread_small_id();
print_str(time_buf);
if (0 == stid) {
print_str(fatal ? " (FATAL): " : " (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (%s-%u): ",
fatal ? "FATAL" : "WARNING", stid);
print_str(prefix);
}
if (data->expr) {
print_str("Assertion failure at ");
} else {
print_str("Code should not have been reached at ");
}
print_str(data->file);
print_str(":");
print_str(print_number(line_buf, sizeof line_buf, data->line));
if (data->expr) {
print_str(": \"");
print_str(data->expr);
print_str("\"");
}
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
static int
do_texio_print (lua_State *L, texio_printer printfunction) {
strnumber texs,u;
char *s;
char save_selector;
int n,i;
size_t k;
u = 0;
n = lua_gettop(L);
if (n==0 || !lua_isstring(L, -1)) {
lua_pushstring(L, "no string to print");
lua_error(L);
}
save_selector = selector;
i = 1;
if (n>1) {
s=(char *)lua_tostring(L, 1);
if (strcmp(s,"log") == 0) { i++; selector = log_only; }
else if (strcmp(s,"term") == 0) { i++; selector = term_only; }
else if (strcmp(s,"term and log") == 0) { i++; selector = term_and_log; }
}
if (selector!=log_only && selector!=term_only && selector != term_and_log) {
normalize_selector(); /* sets selector */
}
/* just in case there is a string in progress */
if (str_start[str_ptr-0x200000]<pool_ptr)
u=make_string();
for (;i<=n;i++) {
s = (char *)lua_tolstring(L, i, &k);
texs = maketexlstring(s,k);
printfunction(texs);
flush_str(texs);
}
selector = save_selector;
if (u!=0) str_ptr--;
return 0;
}
int setattribute (lua_State *L) {
int i,j;
size_t k;
int cur_cs;
int texstr;
char *s;
i = lua_gettop(L);
j = (int)luaL_checkinteger(L,i);
if (lua_type(L,i-1)==LUA_TSTRING) {
s = (char *)lua_tolstring(L,i-1, &k);
texstr = maketexlstring(s,k);
cur_cs = string_lookup(texstr);
flush_str(texstr);
k = zget_equiv(cur_cs)-get_attribute_base();
} else {
k = (int)luaL_checkinteger(L,i-1);
}
check_index_range(k);
if (set_tex_attribute_register(k,j)) {
lua_pushstring(L, "incorrect value");
lua_error(L);
}
return 0;
}
static void do_extension_pdf(int immediate)
{
int i;
if(scan_keyword("literal")){
new_whatsit(pdf_literal_node);
if(scan_keyword("direct"))
set_pdf_literal_mode(tail,direct_always);
else if(scan_keyword("page"))
set_pdf_literal_mode(tail,direct_page);
else
set_pdf_literal_mode(tail,set_origin);
scan_toks(false,true);
set_pdf_literal_type(tail,normal);
set_pdf_literal_data(tail,def_ref);
}else if(scan_keyword("dest")){
scan_pdfdest(static_pdf);
}else if(scan_keyword("annot")){
scan_annot(static_pdf);
}else if(scan_keyword("save")){
new_whatsit(pdf_save_node);
}else if(scan_keyword("restore")){
new_whatsit(pdf_restore_node);
}else if(scan_keyword("setmatrix")){
new_whatsit(pdf_setmatrix_node);
scan_toks(false,true);
set_pdf_setmatrix_data(tail,def_ref);
}else if(scan_keyword("obj")){
scan_obj(static_pdf);
if(immediate){
if(obj_data_ptr(static_pdf,pdf_last_obj)==0)
normal_error("pdf backend","\\pdfextension obj 'reserveobjnum' cannot be used with \\immediate");
pdf_write_obj(static_pdf,pdf_last_obj);
}
}else if(scan_keyword("refobj")){
scan_refobj(static_pdf);
}else if(scan_keyword("colorstack")){
scan_int();
if(cur_val>=colorstackused()){
print_err("Unknown color stack number ");
print_int(cur_val);
help3
("Allocate and initialize a color stack with \\pdfextension colorstackinit.",
"I'll use default color stack 0 here.",
"Proceed, with fingers crossed.");
error();
cur_val= 0;
}
if(cur_val<0){
print_err("Invalid negative color stack number");
help2("I'll use default color stack 0 here.",
"Proceed, with fingers crossed.");
error();
cur_val= 0;
}
if(scan_keyword("set"))
i= colorstack_set;
else if(scan_keyword("push"))
i= colorstack_push;
else if(scan_keyword("pop"))
i= colorstack_pop;
else if(scan_keyword("current"))
i= colorstack_current;
else
i= -1;
if(i>=0){
new_whatsit(pdf_colorstack_node);
set_pdf_colorstack_stack(tail,cur_val);
set_pdf_colorstack_cmd(tail,i);
set_pdf_colorstack_data(tail,null);
if(i<=colorstack_data){
scan_toks(false,true);
set_pdf_colorstack_data(tail,def_ref);
}
}else{
print_err("Color stack action is missing");
help3("The expected actions for \\pdfextension colorstack:",
" set, push, pop, current",
"I'll ignore the color stack command.");
error();
}
}else if(scan_keyword("startlink")){
scan_startlink(static_pdf);
}else if(scan_keyword("endlink")){
if(abs(mode)==vmode)
normal_error("pdf backend","\\pdfextension endlink cannot be used in vertical mode");
new_whatsit(pdf_end_link_node);
}else if(scan_keyword("startthread")){
new_annot_whatsit(pdf_start_thread_node);
scan_thread_id();
}else if(scan_keyword("endthread")){
new_whatsit(pdf_end_thread_node);
}else if(scan_keyword("thread")){
new_annot_whatsit(pdf_thread_node);
scan_thread_id();
}else if(scan_keyword("outline")){
scan_pdfoutline(static_pdf);
}else if(scan_keyword("glyphtounicode")){
glyph_to_unicode();
}else if(scan_keyword("catalog")){
scan_pdfcatalog(static_pdf);
}else if(scan_keyword("fontattr")){
scan_font_ident();
i= cur_val;
if(i==null_font)
normal_error("pdf backend","invalid font identifier");
scan_toks(false,true);
set_pdf_font_attr(i,tokens_to_string(def_ref));
if(str_length(pdf_font_attr(i))==0){
flush_str((str_ptr-1));
set_pdf_font_attr(i,0);
}
}else if(scan_keyword("mapfile")){
scan_toks(false,true);
pdfmapfile(def_ref);
delete_token_ref(def_ref);
}else if(scan_keyword("mapline")){
scan_toks(false,true);
pdfmapline(def_ref);
delete_token_ref(def_ref);
}else if(scan_keyword("includechars")){
pdf_include_chars(static_pdf);
}else if(scan_keyword("info")){
scan_toks(false,true);
pdf_info_toks= concat_tokens(pdf_info_toks,def_ref);
}else if(scan_keyword("names")){
scan_toks(false,true);
pdf_names_toks= concat_tokens(pdf_names_toks,def_ref);
}else if(scan_keyword("trailer")){
scan_toks(false,true);
pdf_trailer_toks= concat_tokens(pdf_trailer_toks,def_ref);
}else{
tex_error("unexpected use of \\pdfextension",null);
}
}
void pdfmapline(integer t)
{
process_map_item(makecstring(tokens_to_string(t)), MAPLINE);
flush_str(last_tokens_string);
}
void
do_vf_packet (internal_font_number vf_f, integer c) {
internal_font_number lf;
charinfo *co;
scaled save_cur_h, save_cur_v;
real_eight_bits *vf_packets;
integer cur_packet_byte;
integer cmd, fs_f;
scaled i;
unsigned k;
str_number s;
packet_cur_s++;
if (packet_cur_s >= packet_max_recursion)
overflow_string("max level recursion of virtual fonts", packet_max_recursion);
save_cur_v = cur_v;
save_cur_h = cur_h;
lf = 0; /* for -Wall */
co = get_charinfo(vf_f,c);
vf_packets = get_charinfo_packets(co);
if (vf_packets == NULL) {
packet_cur_s--;
return ;
}
cur_packet_byte = 0;
fs_f = font_size(vf_f);
while ((cmd = vf_packets[cur_packet_byte]) != packet_end_code) {
cur_packet_byte++;
/*
if (cmd>packet_end_code) {
fprintf(stdout, "do_vf_packet(%i,%i) command code = illegal \n", vf_f,c);
} else {
fprintf(stdout, "do_vf_packet(%i,%i) command code = %s\n",vf_f, c, packet_command_names[cmd]);
}
*/
switch (cmd) {
case packet_font_code:
packet_number(lf);
break;
case packet_push_code:
packet_stack[packet_stack_ptr].stack_h = cur_h;
packet_stack[packet_stack_ptr].stack_v = cur_v;
packet_stack_ptr++;
break;
case packet_pop_code:
packet_stack_ptr--;
cur_h = packet_stack[packet_stack_ptr].stack_h;
cur_v = packet_stack[packet_stack_ptr].stack_v;
break;
case packet_char_code:
packet_number(k);
if (!char_exists(lf,k)) {
char_warning(lf, k);
} else {
output_one_char(lf, k);
}
cur_h = cur_h + char_width(lf,k);
break;
case packet_rule_code:
packet_scaled(rule_ht,fs_f);
packet_scaled(rule_wd,fs_f);
if ((rule_wd > 0) && (rule_ht > 0)) {
pdf_set_rule(cur_h, cur_v, rule_wd, rule_ht);
cur_h = cur_h + rule_wd;
}
break;
case packet_right_code:
packet_scaled(i,fs_f);
cur_h = cur_h + i;
break;
case packet_down_code:
packet_scaled(i,fs_f);
cur_v = cur_v + i;
break;
case packet_special_code:
packet_number(k);
string_room(k);
while (k > 0) {
k--;
append_pool_char(do_packet_byte());
}
s = make_string();
literal(s, scan_special, false);
flush_str(s);
break;
case packet_node_code:
packet_number(k);
temp_ptr = k;
pdf_hlist_out();
break;
case packet_nop_code:
break;
default:
pdf_error(maketexstring("vf"), maketexstring("invalid DVI command"));
}
};
cur_h = save_cur_h;
cur_v = save_cur_v;
packet_cur_s--;
}
