static guint8 const *
gsf_input_textline_read (GsfInput *input, size_t num_bytes, guint8 *buffer)
{
GsfInputTextline *textline = GSF_INPUT_TEXTLINE (input);
textline->remainder = NULL;
return gsf_input_read (textline->source, num_bytes, buffer);
}
static gboolean
gsf_input_textline_seek (GsfInput *input, gsf_off_t offset, GSeekType whence)
{
GsfInputTextline *textline = GSF_INPUT_TEXTLINE (input);
textline->remainder = NULL;
return gsf_input_seek (textline->source, offset, whence);
}
GOImage *
go_spectre_new_from_file (char const *filename, GError **error)
{
GOSpectre *spectre = g_object_new (GO_TYPE_SPECTRE, NULL);
guint8 *data;
GsfInput *input = gsf_input_stdio_new (filename, error);
#ifdef GOFFICE_WITH_EPS
int width, height;
#endif
GOImage *image;
if (!input)
return NULL;
image = GO_IMAGE (spectre);
image->data_length = gsf_input_size (input);
data = g_malloc (image->data_length);
if (!data || !gsf_input_read (input, image->data_length, data)) {
g_object_unref (spectre);
g_free (data);
return NULL;
}
image->data = data;
#ifdef GOFFICE_WITH_EPS
spectre->doc = spectre_document_new ();
if (spectre->doc == NULL) {
g_object_unref (spectre);
return NULL;
}
spectre_document_load (spectre->doc, filename);
if (spectre_document_status (spectre->doc) != SPECTRE_STATUS_SUCCESS) {
g_object_unref (spectre);
return NULL;
}
spectre_document_get_page_size (spectre->doc, &width, &height);
image->width = width;
image->height = height;
#else
{
GsfInput *input = gsf_input_memory_new (image->data, image->data_length, FALSE);
GsfInputTextline *text = GSF_INPUT_TEXTLINE (gsf_input_textline_new (input));
guint8 *line;
while ((line = gsf_input_textline_ascii_gets (text)))
if (!strncmp (line, "%%BoundingBox: ", 15)) {
unsigned x0, x1, y0, y1;
if (sscanf (line + 15, "%u %u %u %u", &x0, &y0, &x1, &y1) == 4) {
image->width = x1 - x0;
image->height = y1 - y0;
} else {
image->width = 100;
image->height = 100;
}
break;
}
g_object_unref (text);
g_object_unref (input);
}
#endif
return image;
}
static void
gsf_input_textline_init (GObject *obj)
{
GsfInputTextline *textline = GSF_INPUT_TEXTLINE (obj);
textline->source = NULL;
textline->remainder = NULL;
textline->remainder_size = 0;
textline->max_line_size = 512; /* an initial guess */
textline->buf = NULL;
textline->buf_size = 0;
}
static void
gnm_glpk_read_solution (GnmGlpk *lp)
{
GnmSubSolver *subsol = lp->parent;
GnmSolver *sol = GNM_SOLVER (subsol);
GsfInput *input;
GsfInputTextline *tl = NULL;
const char *line;
GnmSolverResult *result = NULL;
GnmSolverSensitivity *sensitivity = NULL;
enum { SEC_UNKNOWN, SEC_ROWS, SEC_COLUMNS } state;
gboolean has_integer;
GSList *l;
input = gsf_input_stdio_new (lp->result_filename, NULL);
if (!input)
goto fail;
tl = GSF_INPUT_TEXTLINE (gsf_input_textline_new (input));
g_object_unref (input);
result = g_object_new (GNM_SOLVER_RESULT_TYPE, NULL);
result->solution = g_new0 (gnm_float, sol->input_cells->len);
sensitivity = gnm_solver_sensitivity_new (sol);
/*
* glpsol's output format is different if there are any integer
* constraint. Go figure.
*/
has_integer = sol->params->options.assume_discrete;
for (l = sol->params->constraints; !has_integer && l; l = l->next) {
GnmSolverConstraint *c = l->data;
has_integer = (c->type == GNM_SOLVER_INTEGER ||
c->type == GNM_SOLVER_BOOLEAN);
}
switch (gnm_glpk_detect_version (lp, tl)) {
case GLPK_457:
if (gnm_glpk_read_solution_457 (lp, tl, result, sensitivity,
has_integer))
goto fail;
break;
case GLPK_458:
if (gnm_glpk_read_solution_458 (lp, tl, result, sensitivity,
has_integer))
goto fail;
break;
default:
goto fail;
}
g_object_unref (tl);
tl = NULL;
// ----------------------------------------
if (!lp->ranges_filename)
goto done;
input = gsf_input_stdio_new (lp->ranges_filename, NULL);
if (!input)
goto fail;
tl = GSF_INPUT_TEXTLINE (gsf_input_textline_new (input));
g_object_unref (input);
state = SEC_UNKNOWN;
// We are reading a file intended for human consumption.
// That is unfortunately because it implies rounding, for example.
// The information does not appear to be available elsewhere.
while ((line = gsf_input_textline_utf8_gets (tl)) != NULL) {
gchar **items, **items2 = NULL;
int len, len2 = 0;
if (g_str_has_prefix (line, " No. Row name")) {
state = SEC_ROWS;
continue;
} else if (g_str_has_prefix (line, " No. Column name")) {
state = SEC_COLUMNS;
continue;
} else if (g_ascii_isalpha (line[0])) {
state = SEC_UNKNOWN;
continue;
}
if (state == SEC_UNKNOWN)
continue;
items = my_strsplit (line);
len = g_strv_length (items);
if (len == 10 && g_ascii_isdigit (items[0][0])) {
line = gsf_input_textline_utf8_gets (tl);
if (line) {
items2 = my_strsplit (line);
len2 = g_strv_length (items2);
}
}
if (len == 10 && len2 == 6 && state == SEC_COLUMNS) {
gnm_float low = parse_number (items[7]);
gnm_float high = parse_number (items2[3]);
GnmCell const *cell = gnm_sub_solver_find_cell (lp->parent, items[1]);
int idx = gnm_solver_cell_index (sol, cell);
if (idx >= 0) {
sensitivity->vars[idx].low = low;
sensitivity->vars[idx].high = high;
}
}
if (len == 10 && len2 == 6 && state == SEC_ROWS) {
gnm_float low = parse_number (items[6]);
gnm_float high = parse_number (items2[2]);
int cidx = gnm_sub_solver_find_constraint (lp->parent, items[1]);
if (cidx >= 0) {
sensitivity->constraints[cidx].low = low;
sensitivity->constraints[cidx].high = high;
}
}
g_strfreev (items);
g_strfreev (items2);
}
g_object_unref (tl);
// ----------------------------------------
done:
gnm_solver_set_status (sol, GNM_SOLVER_STATUS_DONE);
g_object_set (subsol, "result", result, NULL);
g_object_unref (result);
g_object_set (subsol, "sensitivity", sensitivity, NULL);
g_object_unref (sensitivity);
return;
fail:
if (tl)
g_object_unref (tl);
if (result)
g_object_unref (result);
if (sensitivity)
g_object_unref (sensitivity);
gnm_solver_set_status (sol, GNM_SOLVER_STATUS_ERROR);
}
