scaled_whd scan_alt_rule(void)
{
boolean loop;
scaled_whd alt_rule;
alt_rule.wd = null_flag;
alt_rule.ht = null_flag;
alt_rule.dp = null_flag;
do {
loop = false;
if (scan_keyword("width")) {
scan_normal_dimen();
alt_rule.wd = cur_val;
loop = true;
} else if (scan_keyword("height")) {
scan_normal_dimen();
alt_rule.ht = cur_val;
loop = true;
} else if (scan_keyword("depth")) {
scan_normal_dimen();
alt_rule.dp = cur_val;
loop = true;
}
} while (loop);
return alt_rule;
}
static pdfboxspec_e scan_pdf_box_spec(void)
{
if (scan_keyword("mediabox"))
return PDF_BOX_SPEC_MEDIA;
else if (scan_keyword("cropbox"))
return PDF_BOX_SPEC_CROP;
else if (scan_keyword("bleedbox"))
return PDF_BOX_SPEC_BLEED;
else if (scan_keyword("trimbox"))
return PDF_BOX_SPEC_TRIM;
else if (scan_keyword("artbox"))
return PDF_BOX_SPEC_ART;
else
return PDF_BOX_SPEC_NONE;
}
static int
scan_keyword_assignment(struct misc_file_buffer* file, struct scan_token* token,
int line)
{
int rc;
rc = scan_keyword(file, &token->content.keyword.keyword, line);
if (rc)
return rc;
skip_blanks(file);
if (misc_get_char(file, 0) != '=') {
error_reason("Line %d: unexpected characters after keyword",
line);
return -1;
}
file->pos++;
skip_blanks(file);
rc = scan_value_string(file, &token->content.keyword.value, line);
if (rc)
return rc;
if (skip_trailing_blanks(file)) {
error_reason("Line %d: unexpected characters at end of line",
line);
return -1;
}
token->id = scan_id_keyword_assignment;
token->line = line;
return 0;
}
static void do_extension_dvi(int immediate)
{
if(scan_keyword("literal")){
new_whatsit(special_node);
write_stream(tail)= null;
scan_toks(false,true);
write_tokens(tail)= def_ref;
}else{
tex_error("unexpected use of \\dviextension",null);
}
}
static int run_scan_keyword(lua_State * L)
{
saved_tex_scanner texstate;
const char *s = luaL_checkstring(L, -1);
int v = 0;
if (s) {
save_tex_scanner(texstate);
if (scan_keyword(s)) {
v = 1;
}
unsave_tex_scanner(texstate);
}
lua_pushboolean(L,v);
return 1;
}
void scan_pdfrefximage(PDF pdf)
{
/*tex One could scan transform as well. */
int transform = 0;
/*tex Begin of experiment. */
int open = 0;
/*tex End of experiment. */
image_dict *idict;
/*tex This scans |<rule spec>| to |alt_rule|. */
scaled_whd alt_rule, dim;
alt_rule = scan_alt_rule();
/*tex Begin of experiment. */
if (scan_keyword("keepopen")) {
open = 1;
}
/*tex End of experiment. */
scan_int();
check_obj_type(pdf, obj_type_ximage, cur_val);
tail_append(new_rule(image_rule));
idict = idict_array[obj_data_ptr(pdf, cur_val)];
/*tex Begin of experiment, */
if (open) {
/*tex So we keep the original value when no close is given. */
idict->keepopen = 1;
}
/*tex End of experiment. */
if (img_state(idict) == DICT_NEW) {
normal_warning("image","don't rely on the image data to be okay");
width(tail_par) = 0;
height(tail_par) = 0;
depth(tail_par) = 0;
} else {
if (alt_rule.wd != null_flag || alt_rule.ht != null_flag || alt_rule.dp != null_flag) {
dim = scale_img(idict, alt_rule, transform);
} else {
dim = scale_img(idict, img_dimen(idict), img_transform(idict));
}
width(tail_par) = dim.wd;
height(tail_par) = dim.ht;
depth(tail_par) = dim.dp;
rule_transform(tail_par) = transform;
rule_index(tail_par) = img_index(idict);
}
}
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);
}
}
callin_entry_list* citab_parse (void)
{
int parameter_count, i, fclose_res;
uint4 inp_mask, out_mask, mask;
mstr labref, callnam;
enum gtm_types ret_tok, parameter_types[MAX_ACTUALS], pr;
char str_buffer[MAX_TABLINE_LEN], *tbp, *end;
FILE *ext_table_file_handle;
callin_entry_list *entry_ptr = NULL, *save_entry_ptr = NULL;
ext_table_file_name = GETENV(CALLIN_ENV_NAME);
if (!ext_table_file_name) /* environment variable not set */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_CITABENV, 2, LEN_AND_STR(CALLIN_ENV_NAME));
ext_table_file_handle = Fopen(ext_table_file_name, "r");
if (!ext_table_file_handle) /* call-in table not found */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(11) ERR_CITABOPN, 2, LEN_AND_STR(ext_table_file_name),
ERR_SYSCALL, 5, LEN_AND_LIT("fopen"), CALLFROM, errno);
ext_source_line_num = 0;
while (read_table(LIT_AND_LEN(str_buffer), ext_table_file_handle))
{
if (!*(tbp = exttab_scan_space(str_buffer)))
continue;
if (!(end = scan_ident(tbp)))
ext_stx_error(ERR_CIRCALLNAME, ext_table_file_name);
callnam.addr = tbp;
callnam.len = INTCAST(end - tbp);
tbp = exttab_scan_space(end);
if (':' != *tbp++)
ext_stx_error(ERR_COLON, ext_table_file_name);
ret_tok = scan_keyword(&tbp); /* return type */
switch (ret_tok) /* return type valid ? */
{
case gtm_void:
case gtm_char_star:
case gtm_int_star:
case gtm_uint_star:
case gtm_long_star:
case gtm_ulong_star:
case gtm_float_star:
case gtm_double_star:
case gtm_string_star:
case gtm_jboolean:
case gtm_jint:
case gtm_jlong:
case gtm_jfloat:
case gtm_jdouble:
case gtm_jstring:
case gtm_jbyte_array:
case gtm_jbig_decimal:
break;
default:
ext_stx_error(ERR_CIRTNTYP, ext_table_file_name);
}
labref.addr = tbp;
if ((end = scan_labelref(tbp)))
labref.len = INTCAST(end - tbp);
else
ext_stx_error(ERR_CIENTNAME, ext_table_file_name);
tbp = exttab_scan_space(end);
inp_mask = out_mask = 0;
for (parameter_count = 0; (*tbp && ')' != *tbp); parameter_count++)
{
if (MAX_ACTUALS <= parameter_count)
ext_stx_error(ERR_CIMAXPARAM, ext_table_file_name);
/* must have comma if this is not the first parameter, otherwise '(' */
if (((0 == parameter_count)?'(':',') != *tbp++)
ext_stx_error(ERR_CIRPARMNAME, ext_table_file_name);
tbp = exttab_scan_space(tbp);
if ((0 == parameter_count) && (*tbp == ')')) /* special case () */
break;
/* looking for an I, a O or an IO */
mask = (1 << parameter_count);
inp_mask |= ('I' == *tbp) ? (tbp++, mask) : 0;
out_mask |= ('O' == *tbp) ? (tbp++, mask) : 0;
if ((!(inp_mask & mask) && !(out_mask & mask)) || (':' != *tbp++))
ext_stx_error(ERR_CIDIRECTIVE, ext_table_file_name);
switch ((pr = scan_keyword(&tbp))) /* valid param type? */
{
case gtm_int:
case gtm_uint:
case gtm_long:
case gtm_ulong:
case gtm_float:
case gtm_double:
if (out_mask & mask)
ext_stx_error(ERR_CIPARTYPE, ext_table_file_name);
/* fall-thru */
case gtm_char_star:
case gtm_int_star:
case gtm_uint_star:
case gtm_long_star:
case gtm_ulong_star:
case gtm_float_star:
case gtm_double_star:
case gtm_string_star:
case gtm_jboolean:
case gtm_jint:
case gtm_jlong:
case gtm_jfloat:
case gtm_jdouble:
case gtm_jstring:
case gtm_jbyte_array:
case gtm_jbig_decimal:
break;
default:
ext_stx_error(ERR_CIUNTYPE, ext_table_file_name);
}
parameter_types[parameter_count] = pr;
tbp = exttab_scan_space(tbp);
}
if (!*tbp)
ext_stx_error(ERR_CIRPARMNAME, ext_table_file_name);
entry_ptr = get_memory(SIZEOF(callin_entry_list));
entry_ptr->next_entry = save_entry_ptr;
save_entry_ptr = entry_ptr;
entry_ptr->return_type = ret_tok;
entry_ptr->argcnt = parameter_count;
entry_ptr->input_mask = inp_mask;
entry_ptr->output_mask = out_mask;
entry_ptr->parms = get_memory(parameter_count * SIZEOF(entry_ptr->parms[0]));
for (i = 0 ; i < parameter_count; i++)
entry_ptr->parms[i] = parameter_types[i];
put_mstr(&labref, &entry_ptr->label_ref);
put_mstr(&callnam, &entry_ptr->call_name);
}
FCLOSE(ext_table_file_handle, fclose_res);
return entry_ptr;
}
/* Note: Need condition handler to clean-up allocated structures and close intput file in the event of an error */
struct extcall_package_list *exttab_parse(mval *package)
{
int parameter_alloc_values[MAX_ACTUALS], parameter_count, ret_pre_alloc_val, i, fclose_res;
int len, keywordlen;
boolean_t is_input[MAX_ACTUALS], is_output[MAX_ACTUALS], got_status;
mstr callnam, rtnnam, clnuprtn;
mstr val, trans;
void_ptr_t pakhandle;
enum gtm_types ret_tok, parameter_types[MAX_ACTUALS], pr;
char str_buffer[MAX_TABLINE_LEN], *tbp, *end;
char str_temp_buffer[MAX_TABLINE_LEN];
FILE *ext_table_file_handle;
struct extcall_package_list *pak;
struct extcall_entry_list *entry_ptr;
/* First, construct package name environment variable */
memcpy(str_buffer, PACKAGE_ENV_PREFIX, SIZEOF(PACKAGE_ENV_PREFIX));
tbp = &str_buffer[SIZEOF(PACKAGE_ENV_PREFIX) - 1];
if (package->str.len)
{
/* guaranteed by compiler */
assert(package->str.len < MAX_NAME_LENGTH - SIZEOF(PACKAGE_ENV_PREFIX) - 1);
*tbp++ = '_';
memcpy(tbp, package->str.addr, package->str.len);
tbp += package->str.len;
}
*tbp = 0;
/* Now we have the environment name, lookup file name */
ext_table_file_name = GETENV(str_buffer);
if (NULL == ext_table_file_name)
{
/* Environment variable for the package not found */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_ZCCTENV, 2, LEN_AND_STR(str_buffer));
}
ext_table_file_handle = Fopen(ext_table_file_name, "r");
if (NULL == ext_table_file_handle)
{
/* Package's external call table could not be found */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_ZCCTOPN, 2, LEN_AND_STR(ext_table_file_name));
}
ext_source_line_num = 0;
/* Pick-up name of shareable library */
tbp = read_table(LIT_AND_LEN(str_buffer), ext_table_file_handle);
if (NULL == tbp)
{
/* External call table is a null file */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_ZCCTNULLF, 2, package->str.len, package->str.addr);
}
STRNCPY_STR(str_temp_buffer, str_buffer, MAX_TABLINE_LEN);
val.addr = str_temp_buffer;
val.len = STRLEN(str_temp_buffer);
/* Need to copy the str_buffer into another temp variable since
* TRANS_LOG_NAME requires input and output buffers to be different.
* If there is an env variable present in the pathname, TRANS_LOG_NAME
* expands it and return SS_NORMAL. Else it returns SS_NOLOGNAM.
* Instead of checking 2 return values, better to check against SS_LOG2LONG
* which occurs if the pathname is too long after any kind of expansion.
*/
if (SS_LOG2LONG == TRANS_LOG_NAME(&val, &trans, str_buffer, SIZEOF(str_buffer), dont_sendmsg_on_log2long))
{
/* Env variable expansion in the pathname caused buffer overflow */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.len, val.addr, SIZEOF(str_buffer) - 1);
}
pakhandle = fgn_getpak(str_buffer, INFO);
if (NULL == pakhandle)
{
/* Unable to obtain handle to the shared library */
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) ERR_ZCUNAVAIL, 2, package->str.len, package->str.addr);
}
pak = get_memory(SIZEOF(*pak));
pak->first_entry = 0;
put_mstr(&package->str, &pak->package_name);
pak->package_handle = pakhandle;
pak->package_clnup_rtn = NULL;
len = STRLEN("GTMSHLIBEXIT");
/* At this point, we have a valid package, pointed to by pak */
# ifdef DEBUG_EXTCALL
FPRINTF(stderr, "GT.M external call opened package name: %s\n", pak->package_name.addr);
# endif
for (;;)
{
star_found = FALSE;
tbp = read_table(LIT_AND_LEN(str_buffer), ext_table_file_handle);
if (NULL == tbp)
break;
tbp = exttab_scan_space(str_buffer);
/* Empty line? */
if (!*tbp)
continue;
/* No, must be entryref or keyword */
end = scan_ident(tbp);
if (!end)
ext_stx_error(ERR_ZCENTNAME, ext_table_file_name);
keywordlen = end - tbp;
end = exttab_scan_space(end);
if ('=' == *end)
{ /* Keyword before '=' has a string of size == STRLEN("GTMSHLIBEXIT") */
if (keywordlen == len)
{
if (0 == MEMCMP_LIT(tbp, "GTMSHLIBEXIT"))
{
/* Skip past the '=' char */
tbp = exttab_scan_space(end + 1);
if (*tbp)
{ /* We have a cleanup routine name */
clnuprtn.addr = tbp;
clnuprtn.len = scan_ident(tbp) - tbp;
clnuprtn.addr[clnuprtn.len] = 0;
pak->package_clnup_rtn =
(clnupfptr)fgn_getrtn(pak->package_handle, &clnuprtn, ERROR);
} else
ext_stx_error(ERR_ZCCLNUPRTNMISNG, ext_table_file_name);
continue;
}
}
ext_stx_error(ERR_ZCINVALIDKEYWORD, ext_table_file_name);
continue;
}
if ('^' == *end)
{
end++;
end = scan_ident(end);
if (!end)
ext_stx_error(ERR_ZCENTNAME, ext_table_file_name);
}
rtnnam.addr = tbp;
rtnnam.len = INTCAST(end - tbp);
tbp = exttab_scan_space(end);
if (':' != *tbp++)
ext_stx_error(ERR_ZCCOLON, ext_table_file_name);
/* Get return type */
ret_tok = scan_keyword(&tbp);
/* Check for legal return type */
switch (ret_tok)
{
case gtm_status:
case gtm_void:
case gtm_int:
case gtm_uint:
case gtm_long:
case gtm_ulong:
case gtm_char_star:
case gtm_float_star:
case gtm_string_star:
case gtm_int_star:
case gtm_uint_star:
case gtm_long_star:
case gtm_ulong_star:
case gtm_double_star:
case gtm_char_starstar:
case gtm_pointertofunc:
case gtm_pointertofunc_star:
case gtm_jboolean:
case gtm_jint:
case gtm_jlong:
case gtm_jfloat:
case gtm_jdouble:
case gtm_jstring:
case gtm_jbyte_array:
case gtm_jbig_decimal:
break;
default:
ext_stx_error(ERR_ZCRTNTYP, ext_table_file_name);
}
got_status = (ret_tok == gtm_status);
/* Get call name */
if ('[' == *tbp)
{
if (star_found)
ret_pre_alloc_val = scan_array_bound(&tbp,ret_tok);
else
ext_stx_error(ERR_ZCPREALLVALPAR, ext_table_file_name);
/* We should allow the pre-allocated value upto to the maximum string size (MAX_STRLEN) plus 1 for the
* extra terminating NULL. Negative values would have been caught by scan_array_bound() above.
*/
if (ret_pre_alloc_val > MAX_STRLEN + 1)
ext_stx_error(ERR_ZCPREALLVALINV, ext_table_file_name);
} else
ret_pre_alloc_val = -1;
/* Fix C9E12-002681 */
if ('%' == *tbp)
*tbp = '_';
end = scan_ident(tbp);
if (!end)
ext_stx_error(ERR_ZCRCALLNAME, ext_table_file_name);
callnam.addr = tbp;
callnam.len = INTCAST(end - tbp);
tbp = exttab_scan_space(end);
tbp = exttab_scan_space(tbp);
for (parameter_count = 0;(MAX_ACTUALS > parameter_count) && (')' != *tbp); parameter_count++)
{
star_found = FALSE;
/* Must have comma if this is not the first parameter, otherwise '(' */
if (((0 == parameter_count)?'(':',') != *tbp++)
ext_stx_error(ERR_ZCRPARMNAME, ext_table_file_name);
tbp = exttab_scan_space(tbp);
/* Special case: () is ok */
if ((0 == parameter_count) && (*tbp == ')'))
break;
/* Looking for an I, an O or an IO */
is_input[parameter_count] = is_output[parameter_count] = FALSE;
if ('I' == *tbp)
{
is_input[parameter_count] = TRUE;
tbp++;
}
if ('O' == *tbp)
{
is_output[parameter_count] = TRUE;
tbp++;
}
if (((FALSE == is_input[parameter_count]) && (FALSE == is_output[parameter_count]))
||(':' != *tbp++))
ext_stx_error(ERR_ZCRCALLNAME, ext_table_file_name);
/* Scanned colon--now get type */
pr = scan_keyword(&tbp);
if (gtm_notfound == pr)
ext_stx_error(ERR_ZCUNTYPE, ext_table_file_name);
if (gtm_status == pr)
{
/* Only one type "status" allowed per call */
if (got_status)
ext_stx_error(ERR_ZCMLTSTATUS, ext_table_file_name);
else
got_status = TRUE;
}
parameter_types[parameter_count] = pr;
if ('[' == *tbp)
{
if (star_found && !is_input[parameter_count])
parameter_alloc_values[parameter_count] = scan_array_bound(&tbp, pr);
else
ext_stx_error(ERR_ZCPREALLVALPAR, ext_table_file_name);
/* We should allow the pre-allocated value upto to the maximum string size (MAX_STRLEN) plus 1 for
* the extra terminating NULL. Negative values would have been caught by scan_array_bound() above.
*/
if (parameter_alloc_values[parameter_count] > MAX_STRLEN + 1)
ext_stx_error(ERR_ZCPREALLVALINV, ext_table_file_name);
} else
parameter_alloc_values[parameter_count] = -1;
tbp = exttab_scan_space(tbp);
}
entry_ptr = get_memory(SIZEOF(*entry_ptr));
entry_ptr->next_entry = pak->first_entry;
pak->first_entry = entry_ptr;
entry_ptr->return_type = ret_tok;
entry_ptr->ret_pre_alloc_val = ret_pre_alloc_val;
entry_ptr->argcnt = parameter_count;
entry_ptr->input_mask = array_to_mask(is_input, parameter_count);
entry_ptr->output_mask = array_to_mask(is_output, parameter_count);
entry_ptr->parms = get_memory(parameter_count * SIZEOF(entry_ptr->parms[0]));
entry_ptr->param_pre_alloc_size = get_memory(parameter_count * SIZEOF(intszofptr_t));
entry_ptr->parmblk_size = (SIZEOF(void *) * parameter_count) + SIZEOF(intszofptr_t);
for (i = 0 ; i < parameter_count; i++)
{
entry_ptr->parms[i] = parameter_types[i];
assert(gtm_void != parameter_types[i]);
entry_ptr->parmblk_size += parm_space_needed[parameter_types[i]];
entry_ptr->param_pre_alloc_size[i] = parameter_alloc_values[i];
}
put_mstr(&rtnnam, &entry_ptr->entry_name);
put_mstr(&callnam, &entry_ptr->call_name);
/* The reason for passing INFO severity is that PROFILE has several routines listed in
* the external call table that are not in the shared library. PROFILE folks would
* rather see info/warning messages for such routines at shared library open time,
* than error out. These unimplemented routines, they say were not being called from
* the application and wouldn't cause any application failures. If we fail to open
* the shared libary, or we fail to locate a routine that is called from the
* application, we issue rts_error message (in extab_parse.c).
*/
entry_ptr->fcn = fgn_getrtn(pak->package_handle, &entry_ptr->call_name, INFO);
# ifdef DEBUG_EXTCALL
FPRINTF(stderr, " package entry point: %s, address: %x\n", entry_ptr->entry_name.addr, entry_ptr->fcn);
# endif
}
FCLOSE(ext_table_file_handle, fclose_res);
return pak;
}
/* Note: need condition handler to clean-up allocated structures and close intput file in the event of an error */
struct extcall_package_list *exttab_parse(mval *package)
{
int parameter_alloc_values[MAXIMUM_PARAMETERS], parameter_count, ret_pre_alloc_val, i, fclose_res;
boolean_t is_input[MAXIMUM_PARAMETERS], is_output[MAXIMUM_PARAMETERS], got_status;
mstr callnam, rtnnam;
void_ptr_t pakhandle;
enum xc_types ret_tok, parameter_types[MAXIMUM_PARAMETERS], pr;
char str_buffer[MAX_TABLINE_LEN], *tbp, *end;
FILE *ext_table_file_handle;
struct extcall_package_list *pak;
struct extcall_entry_list *entry_ptr;
error_def(ERR_ZCRTENOTF);
error_def(ERR_ZCALLTABLE);
error_def(ERR_ZCUSRRTN);
error_def(ERR_ZCCTENV);
error_def(ERR_ZCCTOPN);
error_def(ERR_ZCCTNULLF);
error_def(ERR_ZCUNAVAIL);
error_def(ERR_ZCENTNAME);
error_def(ERR_ZCCOLON);
error_def(ERR_ZCRTNTYP);
error_def(ERR_ZCRCALLNAME);
error_def(ERR_ZCUNTYPE);
error_def(ERR_ZCMLTSTATUS);
error_def(ERR_ZCRPARMNAME);
error_def(ERR_ZCPREALLVALPAR);
error_def(ERR_ZCPREALLVALINV);
/* First, construct package name environment variable */
memcpy(str_buffer, PACKAGE_ENV_PREFIX, sizeof(PACKAGE_ENV_PREFIX));
tbp = &str_buffer[sizeof(PACKAGE_ENV_PREFIX) - 1];
if (package->str.len)
{
/* guaranteed by compiler */
assert(package->str.len < MAX_NAME_LENGTH - sizeof(PACKAGE_ENV_PREFIX) - 1);
*tbp++ = '_';
memcpy(tbp, package->str.addr, package->str.len);
tbp += package->str.len;
}
*tbp = 0;
/* Now we have the environment name, lookup file name */
ext_table_file_name = GETENV(str_buffer);
if (NULL == ext_table_file_name)
{
/* Environment variable for the package not found */
rts_error(VARLSTCNT(4) ERR_ZCCTENV, 2, LEN_AND_STR(str_buffer));
}
ext_table_file_handle = Fopen(ext_table_file_name, "r");
if (NULL == ext_table_file_handle)
{
/* Package's external call table could not be found */
rts_error(VARLSTCNT(4) ERR_ZCCTOPN, 2, LEN_AND_STR(ext_table_file_name));
}
ext_source_line_num = 0;
/* pick-up name of shareable library */
tbp = read_table(LIT_AND_LEN(str_buffer), ext_table_file_handle);
if (NULL == tbp)
{
/* External call table is a null file */
rts_error(VARLSTCNT(4) ERR_ZCCTNULLF, 2, package->str.len, package->str.addr);
}
pakhandle = fgn_getpak(str_buffer, INFO);
if (NULL == pakhandle)
{
/* Unable to obtain handle to the shared library */
rts_error(VARLSTCNT(4) ERR_ZCUNAVAIL, 2, package->str.len, package->str.addr);
}
pak = get_memory(sizeof(*pak));
pak->first_entry = 0;
put_mstr(&package->str, &pak->package_name);
pak->package_handle = pakhandle;
/* At this point, we have a valid package, pointed to by pak */
#ifdef DEBUG_EXTCALL
FPRINTF(stderr, "GT.M external call opened package name: %s\n", pak->package_name.addr);
#endif
for (;;)
{
star_found = FALSE;
tbp = read_table(LIT_AND_LEN(str_buffer), ext_table_file_handle);
if (NULL == tbp)
break;
tbp = scan_space(str_buffer);
/* empty line? */
if (!*tbp)
continue;
/* No, must be entryref */
end = scan_ident(tbp);
if (!end)
ext_stx_error(ERR_ZCENTNAME, ext_table_file_name);
if ('^' == *end)
{
end++;
end = scan_ident(end);
if (!end)
ext_stx_error(ERR_ZCENTNAME, ext_table_file_name);
}
rtnnam.addr = tbp;
rtnnam.len = INTCAST(end - tbp);
tbp = scan_space(end);
if (':' != *tbp++)
ext_stx_error(ERR_ZCCOLON, ext_table_file_name);
/* get return type */
ret_tok = scan_keyword(&tbp);
/* check for legal return type */
switch (ret_tok)
{
case xc_status:
case xc_void:
case xc_int:
case xc_uint:
case xc_long:
case xc_ulong:
case xc_char_star:
case xc_float_star:
case xc_string_star:
case xc_int_star:
case xc_uint_star:
case xc_long_star:
case xc_ulong_star:
case xc_double_star:
case xc_char_starstar:
case xc_pointertofunc:
case xc_pointertofunc_star:
break;
default:
ext_stx_error(ERR_ZCRTNTYP, ext_table_file_name);
}
got_status = (ret_tok == xc_status);
/* get call name */
if ('[' == *tbp)
{
if (star_found)
ret_pre_alloc_val = scan_array_bound(&tbp,ret_tok);
else
ext_stx_error(ERR_ZCPREALLVALPAR, ext_table_file_name);
/* We should allow the pre-allocated value upto to the maximum string size (MAX_STRLEN) plus 1 for the
* extra terminating NULL. Negative values would have been caught by scan_array_bound() above */
if (ret_pre_alloc_val > MAX_STRLEN + 1)
ext_stx_error(ERR_ZCPREALLVALINV, ext_table_file_name);
} else
ret_pre_alloc_val = -1;
end = scan_ident(tbp);
if (!end)
ext_stx_error(ERR_ZCRCALLNAME, ext_table_file_name);
callnam.addr = tbp;
callnam.len = INTCAST(end - tbp);
tbp = scan_space(end);
tbp = scan_space(tbp);
for (parameter_count = 0;(MAXIMUM_PARAMETERS > parameter_count) && (')' != *tbp); parameter_count++)
{
star_found = FALSE;
/* must have comma if this is not the first parameter, otherwise '(' */
if (((0 == parameter_count)?'(':',') != *tbp++)
ext_stx_error(ERR_ZCRPARMNAME, ext_table_file_name);
tbp = scan_space(tbp);
/* special case: () is ok */
if ((0 == parameter_count) && (*tbp == ')'))
break;
/* looking for an I, an O or an IO */
is_input[parameter_count] = is_output[parameter_count] = FALSE;
if ('I' == *tbp)
{
is_input[parameter_count] = TRUE;
tbp++;
}
if ('O' == *tbp)
{
is_output[parameter_count] = TRUE;
tbp++;
}
if (((FALSE == is_input[parameter_count]) && (FALSE == is_output[parameter_count]))
||(':' != *tbp++))
ext_stx_error(ERR_ZCRCALLNAME, ext_table_file_name);
/* scanned colon--now get type */
pr = scan_keyword(&tbp);
if (xc_notfound == pr)
ext_stx_error(ERR_ZCUNTYPE, ext_table_file_name);
if (xc_status == pr)
{
/* Only one type "status" allowed per call */
if (got_status)
ext_stx_error(ERR_ZCMLTSTATUS, ext_table_file_name);
else
got_status = TRUE;
}
parameter_types[parameter_count] = pr;
if ('[' == *tbp)
{
if (star_found && !is_input[parameter_count])
parameter_alloc_values[parameter_count] = scan_array_bound(&tbp, pr);
else
ext_stx_error(ERR_ZCPREALLVALPAR, ext_table_file_name);
/* We should allow the pre-allocated value upto to the maximum string size (MAX_STRLEN) plus 1 for
* the extra terminating NULL. Negative values would have been caught by scan_array_bound() above */
if (parameter_alloc_values[parameter_count] > MAX_STRLEN + 1)
ext_stx_error(ERR_ZCPREALLVALINV, ext_table_file_name);
} else
parameter_alloc_values[parameter_count] = -1;
tbp = scan_space(tbp);
}
entry_ptr = get_memory(sizeof(*entry_ptr));
entry_ptr->next_entry = pak->first_entry;
pak->first_entry = entry_ptr;
entry_ptr->return_type = ret_tok;
entry_ptr->ret_pre_alloc_val = ret_pre_alloc_val;
entry_ptr->argcnt = parameter_count;
entry_ptr->input_mask = array_to_mask(is_input, parameter_count);
entry_ptr->output_mask = array_to_mask(is_output, parameter_count);
entry_ptr->parms = get_memory(parameter_count * sizeof(entry_ptr->parms[0]));
entry_ptr->param_pre_alloc_size = get_memory(parameter_count * sizeof(intszofptr_t));
entry_ptr->parmblk_size = (SIZEOF(void *) * parameter_count) + SIZEOF(intszofptr_t);
for (i = 0 ; i < parameter_count ; i++)
{
entry_ptr->parms[i] = parameter_types[i];
entry_ptr->parmblk_size += parm_space_needed[parameter_types[i]];
entry_ptr->param_pre_alloc_size[i] = parameter_alloc_values[i];
}
put_mstr(&rtnnam, &entry_ptr->entry_name);
put_mstr(&callnam, &entry_ptr->call_name);
/* the reason for passing INFO severity is that PROFILE has several routines listed in
* the external call table that are not in the shared library. PROFILE folks would
* rather see info/warning messages for such routines at shared library open time,
* than error out. These unimplemented routines, they say were not being called from
* the application and wouldn't cause any application failures. If we fail to open
* the shared libary, or we fail to locate a routine that is called from the
* application, we issue rts_error message (in extab_parse.c) */
entry_ptr->fcn = fgn_getrtn(pak->package_handle, &entry_ptr->call_name, INFO);
#ifdef DEBUG_EXTCALL
FPRINTF(stderr, " package entry point: %s, address: %x\n", entry_ptr->entry_name.addr, entry_ptr->fcn);
#endif
}
FCLOSE(ext_table_file_handle, fclose_res);
return pak;
}
/* TODO: delete overlapping logic with exec_query */
static grn_rc
scan_query(grn_ctx *ctx, grn_query *q, grn_str *nstr, grn_id section, grn_cell *c, snip_cond **sc,
grn_operator op, int flags, int *found, int *score)
{
int _found = 0, _score = 0;
grn_cell *e, *ope = NIL;
grn_operator op0 = GRN_OP_OR, *opp = &op0, op1 = q->default_op;
while (c != NIL) {
POP(e, c);
switch (e->header.type) {
case GRN_CELL_OP :
if (opp == &op0 && e->u.op.op == GRN_OP_BUT) {
POP(e, c);
} else {
ope = e;
op1 = ope->u.op.op;
}
continue;
case GRN_CELL_STR :
if (ope != NIL) {
q->opt.mode = ope->u.op.mode == -1 ? q->default_mode : ope->u.op.mode;
q->opt.max_interval = q->opt.similarity_threshold = ope->u.op.option;
if (!q->opt.weight_vector) {
q->opt.vector_size = ope->u.op.weight + q->weight_offset;
}
} else {
q->opt.mode = q->default_mode;
q->opt.max_interval = DEFAULT_MAX_INTERVAL;
q->opt.similarity_threshold = DEFAULT_SIMILARITY_THRESHOLD;
if (!q->opt.weight_vector) {
q->opt.vector_size = DEFAULT_WEIGHT + q->weight_offset;
}
}
if ((flags & GRN_QUERY_SCAN_ALLOCCONDS)) {
grn_rc rc;
/* NOTE: GRN_SNIP_NORMALIZE = GRN_QUERY_SCAN_NORMALIZE */
if ((rc = grn_snip_cond_init(ctx, *sc, e->u.b.value, e->u.b.size,
q->encoding, flags & GRN_SNIP_NORMALIZE))) {
return rc;
}
} else {
grn_snip_cond_reinit(*sc);
}
scan_keyword(*sc, nstr, section, *opp, &q->opt, &_found, &_score);
(*sc)++;
break;
case GRN_CELL_LIST :
scan_query(ctx, q, nstr, section, e, sc, *opp, flags, &_found, &_score);
break;
default :
GRN_LOG(ctx, GRN_LOG_NOTICE, "invalid object assigned in query! (%d)", e->header.type);
break;
}
opp = &op1;
ope = NIL;
op1 = q->default_op;
}
switch (op) {
case GRN_OP_OR :
*found |= _found;
*score += _score;
break;
case GRN_OP_AND :
*found &= _found;
*score += _score;
break;
case GRN_OP_BUT :
*found &= !_found;
break;
case GRN_OP_ADJUST :
*score += _score;
break;
default :
break;
}
return GRN_SUCCESS;
}
void scan_pdfximage(PDF pdf)
{
scaled_whd alt_rule;
image_dict *idict;
int transform = 0, page = 1, pagebox, colorspace = 0;
char *named = NULL, *attr = NULL, *file_name = NULL, *user = NULL, *owner = NULL, *visible = NULL;
alt_rule = scan_alt_rule();
if (scan_keyword("attr")) {
scan_toks(false, true);
attr = tokenlist_to_cstring(def_ref, true, NULL);
delete_token_ref(def_ref);
}
if (scan_keyword("named")) {
scan_toks(false, true);
if (0) {
named = tokenlist_to_cstring(def_ref, true, NULL);
page = 0;
} else {
normal_warning("pdf backend","named pages are not supported, using page 1");
page = 1;
}
delete_token_ref(def_ref);
} else if (scan_keyword("page")) {
scan_int();
page = cur_val;
}
if (scan_keyword("userpassword")) {
scan_toks(false, true);
user = tokenlist_to_cstring(def_ref, true, NULL);
delete_token_ref(def_ref);
}
if (scan_keyword("ownerpassword")) {
scan_toks(false, true);
owner = tokenlist_to_cstring(def_ref, true, NULL);
delete_token_ref(def_ref);
}
if (scan_keyword("visiblefilename")) {
scan_toks(false, true);
visible = tokenlist_to_cstring(def_ref, true, NULL);
delete_token_ref(def_ref);
}
if (scan_keyword("colorspace")) {
scan_int();
colorspace = cur_val;
}
pagebox = scan_pdf_box_spec();
if (pagebox == PDF_BOX_SPEC_NONE) {
pagebox = pdf_pagebox;
if (pagebox == PDF_BOX_SPEC_NONE)
pagebox = PDF_BOX_SPEC_CROP;
}
scan_toks(false, true);
file_name = tokenlist_to_cstring(def_ref, true, NULL);
if (file_name == NULL) {
normal_error("pdf backend","no image filename given");
}
delete_token_ref(def_ref);
idict = read_image(file_name, page, named, colorspace, pagebox, user, owner, visible);
img_attr(idict) = attr;
img_dimen(idict) = alt_rule;
img_transform(idict) = transform;
last_saved_image_index = img_objnum(idict);
last_saved_image_pages = img_totalpages(idict);
}
TSP *tsp_read_data(char *fname)
{ struct dsa _dsa, *dsa = &_dsa;
TSP *tsp = NULL;
dsa->fname = fname;
xprintf("tsp_read_data: reading TSP data from `%s'...\n",
dsa->fname);
dsa->fp = fopen(dsa->fname, "r");
if (dsa->fp == NULL)
{ xprintf("tsp_read_data: unable to open `%s' - %s\n",
dsa->fname, strerror(errno));
goto fail;
}
tsp = xmalloc(sizeof(TSP));
tsp->name = NULL;
tsp->type = TSP_UNDEF;
tsp->comment = NULL;
tsp->dimension = 0;
tsp->edge_weight_type = TSP_UNDEF;
tsp->edge_weight_format = TSP_UNDEF;
tsp->display_data_type = TSP_UNDEF;
tsp->node_x_coord = NULL;
tsp->node_y_coord = NULL;
tsp->dply_x_coord = NULL;
tsp->dply_y_coord = NULL;
tsp->tour = NULL;
tsp->edge_weight = NULL;
dsa->seqn = 1;
if (get_char(dsa)) goto fail;
loop: if (scan_keyword(dsa)) goto fail;
if (strcmp(dsa->token, "NAME") == 0)
{ if (tsp->name != NULL)
{ xprintf("%s:%d: NAME entry multiply defined\n", dsa->fname,
dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_token(dsa, 0)) goto fail;
if (strlen(dsa->token) == 0)
{ xprintf("%s:%d: NAME entry incomplete\n", dsa->fname,
dsa->seqn);
goto fail;
}
tsp->name = xmalloc(strlen(dsa->token) + 1);
strcpy(tsp->name, dsa->token);
xprintf("tsp_read_data: NAME: %s\n", tsp->name);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "TYPE") == 0)
{ if (tsp->type != TSP_UNDEF)
{ xprintf("%s:%d: TYPE entry multiply defined\n", dsa->fname,
dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_keyword(dsa)) goto fail;
if (strcmp(dsa->token, "TSP") == 0)
tsp->type = TSP_TSP;
else if (strcmp(dsa->token, "ATSP") == 0)
tsp->type = TSP_ATSP;
else if (strcmp(dsa->token, "TOUR") == 0)
tsp->type = TSP_TOUR;
else
{ xprintf("%s:%d: data type `%s' not recognized\n",
dsa->fname, dsa->seqn, dsa->token);
goto fail;
}
xprintf("tsp_read_data: TYPE: %s\n", dsa->token);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "COMMENT") == 0)
{ if (tsp->comment != NULL)
{ xprintf("%s:%d: COMMENT entry multiply defined\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_comment(dsa)) goto fail;
tsp->comment = xmalloc(strlen(dsa->token) + 1);
strcpy(tsp->comment, dsa->token);
xprintf("tsp_read_data: COMMENT: %s\n", tsp->comment);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "DIMENSION") == 0)
{ if (tsp->dimension != 0)
{ xprintf("%s:%d: DIMENSION entry multiply defined\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_integer(dsa, 0, &tsp->dimension)) goto fail;
if (tsp->dimension < 1)
{ xprintf("%s:%d: invalid dimension\n", dsa->fname,
dsa->seqn);
goto fail;
}
xprintf("tsp_read_data: DIMENSION: %d\n", tsp->dimension);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "EDGE_WEIGHT_TYPE") == 0)
{ if (tsp->edge_weight_type != TSP_UNDEF)
{ xprintf("%s:%d: EDGE_WEIGHT_TYPE entry multiply defined\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_keyword(dsa)) goto fail;
if (strcmp(dsa->token, "GEO") == 0)
tsp->edge_weight_type = TSP_GEO;
else if (strcmp(dsa->token, "EUC_2D") == 0)
tsp->edge_weight_type = TSP_EUC_2D;
else if (strcmp(dsa->token, "ATT") == 0)
tsp->edge_weight_type = TSP_ATT;
else if (strcmp(dsa->token, "EXPLICIT") == 0)
tsp->edge_weight_type = TSP_EXPLICIT;
else if (strcmp(dsa->token, "CEIL_2D") == 0)
tsp->edge_weight_type = TSP_CEIL_2D;
else
{ xprintf("%s:%d: edge weight type `%s' not recognized\n",
dsa->fname, dsa->seqn, dsa->token);
goto fail;
}
xprintf("tsp_read_data: EDGE_WEIGHT_TYPE: %s\n", dsa->token);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "EDGE_WEIGHT_FORMAT") == 0)
{ if (tsp->edge_weight_format != TSP_UNDEF)
{ xprintf(
"%s:%d: EDGE_WEIGHT_FORMAT entry multiply defined\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_keyword(dsa)) goto fail;
if (strcmp(dsa->token, "UPPER_ROW") == 0)
tsp->edge_weight_format = TSP_UPPER_ROW;
else if (strcmp(dsa->token, "FULL_MATRIX") == 0)
tsp->edge_weight_format = TSP_FULL_MATRIX;
else if (strcmp(dsa->token, "FUNCTION") == 0)
tsp->edge_weight_format = TSP_FUNCTION;
else if (strcmp(dsa->token, "LOWER_DIAG_ROW") == 0)
tsp->edge_weight_format = TSP_LOWER_DIAG_ROW;
else
{ xprintf("%s:%d: edge weight format `%s' not recognized\n",
dsa->fname, dsa->seqn, dsa->token);
goto fail;
}
xprintf("tsp_read_data: EDGE_WEIGHT_FORMAT: %s\n", dsa->token);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "DISPLAY_DATA_TYPE") == 0)
{ if (tsp->display_data_type != TSP_UNDEF)
{ xprintf("%s:%d: DISPLAY_DATA_TYPE entry multiply defined\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_colon(dsa)) goto fail;
if (scan_keyword(dsa)) goto fail;
if (strcmp(dsa->token, "COORD_DISPLAY") == 0)
tsp->display_data_type = TSP_COORD_DISPLAY;
else if (strcmp(dsa->token, "TWOD_DISPLAY") == 0)
tsp->display_data_type = TSP_TWOD_DISPLAY;
else
{ xprintf("%s:%d: display data type `%s' not recognized\n",
dsa->fname, dsa->seqn, dsa->token);
goto fail;
}
xprintf("tsp_read_data: DISPLAY_DATA_TYPE: %s\n", dsa->token);
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "NODE_COORD_SECTION") == 0)
{ int n = tsp->dimension, k, node;
if (n == 0)
{ xprintf("%s:%d: DIMENSION entry not specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (tsp->node_x_coord != NULL)
{ xprintf("%s:%d: NODE_COORD_SECTION multiply specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_newline(dsa)) goto fail;
tsp->node_x_coord = xcalloc(1+n, sizeof(double));
tsp->node_y_coord = xcalloc(1+n, sizeof(double));
for (node = 1; node <= n; node++)
tsp->node_x_coord[node] = tsp->node_y_coord[node] = DBL_MAX;
for (k = 1; k <= n; k++)
{ if (scan_integer(dsa, 0, &node)) goto fail;
if (!(1 <= node && node <= n))
{ xprintf("%s:%d: invalid node number %d\n", dsa->fname,
dsa->seqn, node);
goto fail;
}
if (tsp->node_x_coord[node] != DBL_MAX)
{ xprintf("%s:%d: node number %d multiply specified\n",
dsa->fname, dsa->seqn, node);
goto fail;
}
if (scan_number(dsa, 0, &tsp->node_x_coord[node]))
goto fail;
if (scan_number(dsa, 0, &tsp->node_y_coord[node]))
goto fail;
if (check_newline(dsa)) goto fail;
}
}
else if (strcmp(dsa->token, "DISPLAY_DATA_SECTION") == 0)
{ int n = tsp->dimension, k, node;
if (n == 0)
{ xprintf("%s:%d: DIMENSION entry not specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (tsp->dply_x_coord != NULL)
{ xprintf("%s:%d: DISPLAY_DATA_SECTION multiply specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_newline(dsa)) goto fail;
tsp->dply_x_coord = xcalloc(1+n, sizeof(double));
tsp->dply_y_coord = xcalloc(1+n, sizeof(double));
for (node = 1; node <= n; node++)
tsp->dply_x_coord[node] = tsp->dply_y_coord[node] = DBL_MAX;
for (k = 1; k <= n; k++)
{ if (scan_integer(dsa, 0, &node)) goto fail;
if (!(1 <= node && node <= n))
{ xprintf("%s:%d: invalid node number %d\n", dsa->fname,
dsa->seqn, node);
goto fail;
}
if (tsp->dply_x_coord[node] != DBL_MAX)
{ xprintf("%s:%d: node number %d multiply specified\n",
dsa->fname, dsa->seqn, node);
goto fail;
}
if (scan_number(dsa, 0, &tsp->dply_x_coord[node]))
goto fail;
if (scan_number(dsa, 0, &tsp->dply_y_coord[node]))
goto fail;
if (check_newline(dsa)) goto fail;
}
}
else if (strcmp(dsa->token, "TOUR_SECTION") == 0)
{ int n = tsp->dimension, k, node;
if (n == 0)
{ xprintf("%s:%d: DIMENSION entry not specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (tsp->tour != NULL)
{ xprintf("%s:%d: TOUR_SECTION multiply specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_newline(dsa)) goto fail;
tsp->tour = xcalloc(1+n, sizeof(int));
for (k = 1; k <= n; k++)
{ if (scan_integer(dsa, 1, &node)) goto fail;
if (!(1 <= node && node <= n))
{ xprintf("%s:%d: invalid node number %d\n", dsa->fname,
dsa->seqn, node);
goto fail;
}
tsp->tour[k] = node;
}
if (scan_integer(dsa, 1, &node)) goto fail;
if (node != -1)
{ xprintf("%s:%d: extra node(s) detected\n", dsa->fname,
dsa->seqn);
goto fail;
}
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "EDGE_WEIGHT_SECTION") == 0)
{ int n = tsp->dimension, i, j, temp;
if (n == 0)
{ xprintf("%s:%d: DIMENSION entry not specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (tsp->edge_weight_format == TSP_UNDEF)
{ xprintf("%s:%d: EDGE_WEIGHT_FORMAT entry not specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (tsp->edge_weight != NULL)
{ xprintf("%s:%d: EDGE_WEIGHT_SECTION multiply specified\n",
dsa->fname, dsa->seqn);
goto fail;
}
if (check_newline(dsa)) goto fail;
tsp->edge_weight = xcalloc(1+n*n, sizeof(int));
switch (tsp->edge_weight_format)
{ case TSP_FULL_MATRIX:
for (i = 1; i <= n; i++)
{ for (j = 1; j <= n; j++)
{ if (scan_integer(dsa, 1, &temp)) goto fail;
tsp->edge_weight[(i - 1) * n + j] = temp;
}
}
break;
case TSP_UPPER_ROW:
for (i = 1; i <= n; i++)
{ tsp->edge_weight[(i - 1) * n + i] = 0;
for (j = i + 1; j <= n; j++)
{ if (scan_integer(dsa, 1, &temp)) goto fail;
tsp->edge_weight[(i - 1) * n + j] = temp;
tsp->edge_weight[(j - 1) * n + i] = temp;
}
}
break;
case TSP_LOWER_DIAG_ROW:
for (i = 1; i <= n; i++)
{ for (j = 1; j <= i; j++)
{ if (scan_integer(dsa, 1, &temp)) goto fail;
tsp->edge_weight[(i - 1) * n + j] = temp;
tsp->edge_weight[(j - 1) * n + i] = temp;
}
}
break;
default:
goto fail;
}
if (check_newline(dsa)) goto fail;
}
else if (strcmp(dsa->token, "EOF") == 0)
{ if (check_newline(dsa)) goto fail;
goto done;
}
else
{ xprintf("%s:%d: keyword `%s' not recognized\n", dsa->fname,
dsa->seqn, dsa->token);
goto fail;
}
goto loop;
done: xprintf("tsp_read_data: %d lines were read\n", dsa->seqn-1);
fclose(dsa->fp);
return tsp;
fail: if (tsp != NULL)
{ if (tsp->name != NULL) xfree(tsp->name);
if (tsp->comment != NULL) xfree(tsp->comment);
if (tsp->node_x_coord != NULL) xfree(tsp->node_x_coord);
if (tsp->node_y_coord != NULL) xfree(tsp->node_y_coord);
if (tsp->dply_x_coord != NULL) xfree(tsp->dply_x_coord);
if (tsp->dply_y_coord != NULL) xfree(tsp->dply_y_coord);
if (tsp->tour != NULL) xfree(tsp->tour);
if (tsp->edge_weight != NULL) xfree(tsp->edge_weight);
xfree(tsp);
}
if (dsa->fp != NULL) fclose(dsa->fp);
return NULL;
}
void tex::begin_box(int box_context)
{
int k, m, n;
ptr p=0, q;
switch (cur_chr)
{
case BOX_CODE:
scan_eight_bit_int();
cur_box = box(cur_val);
box(cur_val) = null;
break;
case COPY_CODE:
scan_eight_bit_int();
cur_box = copy_node_list(box(cur_val));
break;
case LAST_BOX_CODE:
cur_box = null;
if (abs(mode) == MMODE) {
you_cant();
help_lastbox_m();
error();
} else if (mode == VMODE && head == tail) {
you_cant();
help_lastbox_v();
error();
} else if (type(tail) == HLIST_NODE
|| type(tail) == VLIST_NODE) {
for (q = head; q != tail; q = link(p)) {
p = q;
if (type(q) == DISC_NODE) {
m = 1;
while (m <= replace_count(q)) {
p = link(p);
incr(m);
}
if (p == tail) {
break;
}
}
}
cur_box = tail;
shift_amount(cur_box) = 0;
tail = p;
link(p) = null;
}
break;
case VSPLIT_CODE:
scan_eight_bit_int();
n = cur_val;
if (!scan_keyword("to")) {
print_err("Missing `to' inserted");
help_vsplit();
error();
}
scan_normal_dimen();
cur_box = vsplit(n, cur_val);
break;
default:
k = cur_chr - VTOP_CODE;
saved(0) = box_context;
if (k == HMODE) {
if (box_context < BOX_FLAG && abs(mode) == VMODE) {
scan_spec(ADJUSTED_HBOX_GROUP, TRUE);
} else {
scan_spec(HBOX_GROUP, TRUE);
}
} else {
if (k == VMODE) {
scan_spec(VBOX_GROUP, TRUE);
} else {
scan_spec(VTOP_GROUP, TRUE);
k = VMODE;
}
normal_paragraph();
}
push_nest();
mode = -k;
if (k == VMODE) {
prev_depth = IGNORE_DEPTH;
if (every_vbox != null)
begin_token_list(every_vbox, EVERY_VBOX_TEXT);
} else {
space_factor = 1000;
if (every_hbox != null)
begin_token_list(every_hbox, EVERY_HBOX_TEXT);
}
return;
}
box_end(box_context);
}
