static stp_array_t *
xml_doc_get_dither_array(stp_mxml_node_t *doc)
{
stp_mxml_node_t *cur;
stp_mxml_node_t *xmlseq;
if (doc == NULL )
{
stp_erprintf("xml_doc_get_dither_array: XML file not parsed successfully.\n");
return NULL;
}
cur = doc->child;
if (cur == NULL)
{
stp_erprintf("xml_doc_get_dither_array: empty document\n");
return NULL;
}
xmlseq = stp_xml_get_node(cur, "gutenprint", "dither-matrix", NULL);
if (xmlseq == NULL )
{
stp_erprintf("xml-doc-get-dither-array: XML file is not a dither matrix.\n");
return NULL;
}
return stpi_dither_array_create_from_xmltree(xmlseq);
}
/*
* Parse a single XML file.
*/
int
stp_xml_parse_file(const char *file) /* File to parse */
{
stp_mxml_node_t *doc;
stp_mxml_node_t *cur;
FILE *fp;
stp_deprintf(STP_DBG_XML, "stp_xml_parse_file: reading `%s'...\n", file);
fp = fopen(file, "r");
if (!fp)
{
stp_erprintf("stp_xml_parse_file: unable to open %s: %s\n", file,
strerror(errno));
return 1;
}
stp_xml_init();
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
fclose(fp);
cur = doc->child;
while (cur &&
(cur->type != STP_MXML_ELEMENT ||
strcmp(cur->value.element.name, "gimp-print") != 0))
cur = cur->next;
if (cur == NULL || cur->type != STP_MXML_ELEMENT)
{
stp_erprintf("stp_xml_parse_file: %s: parse error\n", file);
stp_mxmlDelete(doc);
return 1;
}
if (strcmp(cur->value.element.name, "gimp-print") != 0)
{
stp_erprintf
("XML file of the wrong type, root node is %s != gimp-print",
cur->value.element.name);
stp_mxmlDelete(doc);
return 1;
}
/* The XML file was read and is the right format */
stpi_xml_process_gimpprint(cur, file);
stp_mxmlDelete(doc);
stp_xml_exit();
return 0;
}
static stp_array_t *
stpi_dither_array_create_from_file(const char* file)
{
stp_mxml_node_t *doc;
stp_array_t *ret = NULL;
FILE *fp = fopen(file, "r");
if (!fp)
{
stp_erprintf("stp_curve_create_from_file: unable to open %s: %s\n",
file, strerror(errno));
return NULL;
}
stp_xml_init();
stp_deprintf(STP_DBG_XML,
"stpi_dither_array_create_from_file: reading `%s'...\n", file);
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
(void) fclose(fp);
if (doc)
{
ret = xml_doc_get_dither_array(doc);
stp_mxmlDelete(doc);
}
stp_xml_exit();
return ret;
}
/*
* We could do more sanity checks here if we want.
*/
static inline void
check_array(const stp_array_t *array)
{
if (array == NULL)
{
stp_erprintf("Null stp_array_t! Please report this bug.\n");
stp_abort();
}
}
static stp_array_t *
stpi_dither_array_create_from_xmltree(stp_mxml_node_t *dm) /* Dither matrix node */
{
const char *stmp;
stp_mxml_node_t *child;
int x_aspect, y_aspect; /* Dither matrix size */
/* Get x-size */
stmp = stp_mxmlElementGetAttr(dm, "x-aspect");
if (stmp)
{
x_aspect = (int) stp_xmlstrtoul(stmp);
}
else
{
stp_erprintf("stpi_dither_array_create_from_xmltree: \"x-aspect\" missing\n");
goto error;
}
/* Get y-size */
stmp = stp_mxmlElementGetAttr(dm, "y-aspect");
if (stmp)
{
y_aspect = (int) stp_xmlstrtoul(stmp);
}
else
{
stp_erprintf("stpi_dither_array_create_from_xmltree: \"y-aspect\" missing\n");
goto error;
}
/* Now read in the array */
child = stp_mxmlFindElement(dm, dm, "array", NULL, NULL, STP_MXML_DESCEND);
if (child)
return stp_array_create_from_xmltree(child);
else
stp_erprintf("stpi_dither_array_create_from_xmltree: cannot find root\n");
error:
return NULL;
}
void
stp_string_list_add_string(stp_string_list_t *list,
const char *name,
const char *text)
{
stp_param_string_t *new_string = stp_malloc(sizeof(stp_param_string_t));
do
{
const char *xname = name;
while (*xname)
{
if (!isalnum(*xname) &&
*xname != '_' && *xname != '-' && *xname != '+')
{
stp_erprintf("Gutenprint: bad string %s (%s)\n", name, text);
break;
}
xname++;
}
} while(0);
new_string->name = stp_strdup(name);
new_string->text = stp_strdup(text);
stp_list_item_create((stp_list_t *) list, NULL, new_string);
}
/*
* Load all available modules. Return nonzero on failure.
*/
int stp_module_load(void)
{
/* initialise libltdl */
#ifdef USE_LTDL
static int ltdl_is_initialised = 0; /* Is libltdl initialised? */
#endif
static int module_list_is_initialised = 0; /* Is the module list initialised? */
#if defined(USE_LTDL) || defined(USE_DLOPEN)
stp_list_t *dir_list; /* List of directories to scan */
stp_list_t *file_list; /* List of modules to open */
stp_list_item_t *file; /* Pointer to current module */
#endif
#ifdef USE_LTDL
if (!ltdl_is_initialised)
{
if (lt_dlinit())
{
stp_erprintf("Error initialising libltdl: %s\n", DLERROR());
return 1;
}
ltdl_is_initialised = 1;
}
/* set default search paths */
lt_dladdsearchdir(PKGMODULEDIR);
#endif
/* initialise module_list */
if (!module_list_is_initialised)
{
if (!(module_list = stp_list_create()))
return 1;
stp_list_set_freefunc(module_list, module_list_freefunc);
module_list_is_initialised = 1;
}
/* search for available modules */
#if defined (USE_LTDL) || defined (USE_DLOPEN)
if (!(dir_list = stp_list_create()))
return 1;
stp_list_set_freefunc(dir_list, stp_list_node_free_data);
if (getenv("STP_MODULE_PATH"))
{
stp_path_split(dir_list, getenv("STP_MODULE_PATH"));
}
else
{
#ifdef USE_LTDL
stp_path_split(dir_list, getenv("LTDL_LIBRARY_PATH"));
stp_path_split(dir_list, lt_dlgetsearchpath());
#else
stp_path_split(dir_list, PKGMODULEDIR);
#endif
}
#ifdef USE_LTDL
file_list = stp_path_search(dir_list, ".la");
#else
file_list = stp_path_search(dir_list, ".so");
#endif
stp_list_destroy(dir_list);
/* load modules */
file = stp_list_get_start(file_list);
while (file)
{
stp_module_open((const char *) stp_list_item_get_data(file));
file = stp_list_item_next(file);
}
stp_list_destroy(file_list);
#else /* use a static module list */
{
int i=0;
while (static_modules[i])
{
stp_module_register(static_modules[i]);
i++;
}
}
#endif
return 0;
}
stp_array_t *
stp_array_create_from_xmltree(stp_mxml_node_t *array) /* The array node */
{
const char *stmp; /* Temporary string */
stp_mxml_node_t *child; /* Child sequence node */
int x_size, y_size;
size_t count;
stp_sequence_t *seq = NULL;
stp_array_t *ret = NULL;
stmp = stp_mxmlElementGetAttr(array, "x-size");
if (stmp)
{
x_size = (int) strtoul(stmp, NULL, 0);
}
else
{
stp_erprintf("stp_array_create_from_xmltree: \"x-size\" missing\n");
goto error;
}
/* Get y-size */
stmp = stp_mxmlElementGetAttr(array, "y-size");
if (stmp)
{
y_size = (int) strtoul(stmp, NULL, 0);
}
else
{
stp_erprintf("stp_array_create_from_xmltree: \"y-size\" missing\n");
goto error;
}
/* Get the sequence data */
child = stp_mxmlFindElement(array, array, "sequence", NULL, NULL, STP_MXML_DESCEND);
if (child)
seq = stp_sequence_create_from_xmltree(child);
if (seq == NULL)
goto error;
ret = stp_array_create(x_size, y_size);
if (ret->data)
stp_sequence_destroy(ret->data);
ret->data = seq;
count = stp_sequence_get_size(seq);
if (count != (x_size * y_size))
{
stp_erprintf("stp_array_create_from_xmltree: size mismatch between array and sequence\n");
goto error;
}
return ret;
error:
stp_erprintf("stp_array_create_from_xmltree: error during array read\n");
if (ret)
stp_array_destroy(ret);
return NULL;
}
