static GnmValue * qpro_new_string (QProReadState *state, gchar const *data) { return value_new_string_nocopy ( g_convert_with_iconv (data, -1, state->converter, NULL, NULL, NULL)); }
/** * string_range_function: * @argc: * @argv: * @ei: * @func: (scope call): * @flags: * @func_error: * * Returns: (transfer full): **/ GnmValue * string_range_function (int argc, GnmExprConstPtr const *argv, GnmFuncEvalInfo *ei, string_range_function_t func, CollectFlags flags, GnmStdError func_error) { GnmValue *error = NULL; GPtrArray *vals; char *res = NULL; int err; vals = collect_strings (argc, argv, ei->pos, flags, &error); if (!vals) return error; err = func (vals, &res); collect_strings_free (vals); if (err) { g_free (res); return value_new_error_std (ei->pos, func_error); } else { return value_new_string_nocopy (res); } }
static GnmValue * gnumeric_hdate_heb (GnmFuncEvalInfo * ei, GnmValue const * const *argv) { int year, month, day; int hyear, hmonth, hday; GString *res; gnumeric_hdate_get_date (argv, &year, &month, &day); if (0 != hdate_gdate_to_hdate (day, month, year, &hday, &hmonth, &hyear)) return value_new_error_VALUE (ei->pos); res = g_string_new (NULL); build_hdate (res, hyear, hmonth, hday); return value_new_string_nocopy (g_string_free (res, FALSE)); }
static GnmValue * gnumeric_hdate (GnmFuncEvalInfo * ei, GnmValue const * const *argv) { int year, month, day; int hyear, hmonth, hday; char *res; gnumeric_hdate_get_date (argv, &year, &month, &day); if (0 != hdate_gdate_to_hdate (day, month, year, &hday, &hmonth, &hyear)) return value_new_error_VALUE (ei->pos); res = g_strdup_printf ("%d %s %d", hday + 1, hdate_get_hebrew_month_name (hmonth), hyear); return value_new_string_nocopy (res); }
static GnmValue * sylk_parse_value (SylkReader *state, const char *str) { GnmValue *val; if ('\"' == *str) { /* quoted string */ size_t len; str++; len = strlen (str); if (len > 0 && str[len - 1] == '\"') len--; return value_new_string_nocopy (g_strndup (str, len)); } val = format_match_simple (str); if (val) return val; return value_new_string (str); }
static GnmValue * psi_new_string (psiconv_ucs2 const *data) { return value_new_string_nocopy ( g_utf16_to_utf8 (data, -1, NULL, NULL, NULL)); }
G_MODULE_EXPORT void paradox_file_open (GOFileOpener const *fo, GOIOContext *io_context, WorkbookView *wb_view, GsfInput *input) { Workbook *wb; pxdoc_t *pxdoc; pxhead_t *pxh; pxfield_t *pxf; char *data; char *name; Sheet *sheet; GnmCell *cell; GnmValue *val = NULL; GOErrorInfo *open_error = NULL; guint row, i, j, offset; #ifdef PX_MEMORY_DEBUGGING PX_mp_init (); #endif #ifdef PX_MEMORY_DEBUGGING pxdoc = PX_new2 (gn_errorhandler, PX_mp_malloc, PX_mp_realloc, PX_mp_free); #else pxdoc = PX_new2 (gn_errorhandler, gn_malloc, gn_realloc, gn_free); #endif if (PX_open_gsf (pxdoc, input) < 0) { go_io_error_info_set (io_context, go_error_info_new_str_with_details ( _("Error while opening Paradox file."), open_error)); return; } pxh = pxdoc->px_head; PX_set_targetencoding (pxdoc, "UTF-8"); wb = wb_view_get_workbook (wb_view); name = workbook_sheet_get_free_name (wb, pxh->px_tablename, FALSE, TRUE); sheet = sheet_new (wb, name, 256, 65536); g_free (name); workbook_sheet_attach (wb, sheet); pxf = pxh->px_fields; for (i = 0 ; i < (guint) pxh->px_numfields; i++) { char str[30], *str2; char ctypes[26] = {'?', 'A', 'D', 'S', 'I', '$', 'N', '?', '?', 'L', '?', '?', 'M', 'B', 'F', 'O', 'G', '?', '?', '?', 'T', '@', '+', '#', 'Y', }; cell = sheet_cell_fetch (sheet, i, 0); if (pxf->px_ftype == pxfBCD) snprintf (str, 30, "%s,%c,%d", pxf->px_fname, ctypes[(int)pxf->px_ftype], pxf->px_fdc); else snprintf (str, 30, "%s,%c,%d", pxf->px_fname, ctypes[(int)pxf->px_ftype], pxf->px_flen); #if PXLIB_MAJOR_VERSION == 0 && (PXLIB_MINOR_VERION < 3 || (PXLIB_MAJOR_VERSION == 3 && PXLIB_MICRO_VERSION == 0)) /* Convert the field names to utf-8. This is actually in pxlib * responsibility, but hasn't been implemented yet. For the mean time * we *misuse* PX_get_data_alpha() */ PX_get_data_alpha (pxdoc, str, strlen (str), &str2); gnm_cell_set_text (cell, str2); pxdoc->free (pxdoc, str2); #else gnm_cell_set_text (cell, str); #endif pxf++; } { GnmRange r; GnmStyle *bold = gnm_style_new (); gnm_style_set_font_bold (bold, TRUE); sheet_style_apply_range (sheet, range_init (&r, 0, 0, pxh->px_numfields-1, 0), bold); } if ((data = (char *) pxdoc->malloc (pxdoc, pxh->px_recordsize, _("Could not allocate memory for record."))) == NULL) { go_io_error_info_set (io_context, go_error_info_new_str_with_details ( _("Error while opening Paradox file."), open_error)); return; } row = 1; for (j = 0; j < (guint)pxh->px_numrecords; j++) { pxdatablockinfo_t pxdbinfo; int isdeleted = 0; if (NULL != PX_get_record2 (pxdoc, j, data, &isdeleted, &pxdbinfo)) { offset = 0; pxf = pxh->px_fields; for (i = 0; i < (guint) pxh->px_numfields ; i++) { cell = sheet_cell_fetch (sheet, i, row); val = NULL; switch (pxf->px_ftype) { case pxfAlpha: { char *value; if (0 < PX_get_data_alpha (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_string_nocopy (value); /* value_set_fmt (val, field->fmt); */ } break; } case pxfShort: { short int value; if (0 < PX_get_data_short (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_int (value); } break; } case pxfAutoInc: case pxfLong: { long value; if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_int (value); } break; } case pxfCurrency: case pxfNumber: { double value; if (0 < PX_get_data_double (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_float (value); if (pxf->px_ftype == pxfCurrency) value_set_fmt (val, go_format_default_money ()); } break; } case pxfTimestamp: { double value; if (0 < PX_get_data_double (pxdoc, &data[offset], pxf->px_flen, &value)) { value = value / 86400000.0; /* 693594 = number of days up to 31.12.1899 */ value -= 693594; val = value_new_float (value); value_set_fmt (val, go_format_default_date_time ()); } break; } case pxfLogical: { char value; if (0 < PX_get_data_byte (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_bool (value ? TRUE : FALSE); } break; } case pxfDate: { long value; int year, month, day; GDate *date; if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) { PX_SdnToGregorian (value+1721425, &year, &month, &day); date = g_date_new_dmy (day, month, year); val = value_new_int (go_date_g_to_serial (date, NULL)); value_set_fmt (val, go_format_default_date ()); g_date_free (date); } break; } case pxfTime: { long value; if (0 < PX_get_data_long (pxdoc, &data[offset], pxf->px_flen, &value)) { val = value_new_float (value/86400000.0); value_set_fmt (val, go_format_default_time ()); } break; } case pxfBCD: { char *value; if (0 < PX_get_data_bcd (pxdoc, &data[offset], pxf->px_fdc, &value)) { val = value_new_string_nocopy (value); } break; } case pxfMemoBLOb: { char *value; int size, mod_nr; if (0 < PX_get_data_blob (pxdoc, &data[offset], pxf->px_flen, &mod_nr, &size, &value)) { val = value_new_string_nocopy (value); } break; } default: val = value_new_string_nocopy ( g_strdup_printf (_("Field type %d is not supported."), pxf->px_ftype)); } if (val) gnm_cell_set_value (cell, val); offset += pxf->px_flen; pxf++; } if (pxh->px_filetype == pxfFileTypPrimIndex) { short int value; cell = sheet_cell_fetch (sheet, i++, row); if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) { val = value_new_int (value); gnm_cell_set_value (cell, val); } offset += 2; cell = sheet_cell_fetch (sheet, i++, row); if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) { val = value_new_int (value); gnm_cell_set_value (cell, val); } offset += 2; cell = sheet_cell_fetch (sheet, i++, row); if (0 < PX_get_data_short (pxdoc, &data[offset], 2, &value)) { val = value_new_int (value); gnm_cell_set_value (cell, val); } cell = sheet_cell_fetch (sheet, i++, row); val = value_new_int (pxdbinfo.number); gnm_cell_set_value (cell, val); } } row++; } pxdoc->free (pxdoc, data); PX_close (pxdoc); PX_delete (pxdoc); sheet_flag_recompute_spans (sheet); }
static GODataCache * build_cache(void) { Workbook *wb; Sheet *sheet; GODataCache *cache; GnmRange *range; int row, col, numRows = 60, numCols = 5; wb = workbook_new(); sheet = workbook_sheet_add (wb, -1, 1024, 1024); for (row = 0; row < numRows; row++) { for (col = 0; col < numCols; col++) { GnmCell * tempCell = sheet_cell_create(sheet, col, row); GnmValue * tempVal; if (col == 0) { if (row%4 == 0) { tempVal = value_new_string_nocopy((char *)"A"); } else if (row%4 == 1) { tempVal = value_new_string_nocopy((char *)"B"); } else if (row%4 == 2) { tempVal = value_new_string_nocopy((char *)"C"); } else { tempVal = value_new_string_nocopy((char *)"D"); } } else if (col == 1) { tempVal = value_new_int(row); } else if (col == 2) { if (row%5 == 0) { tempVal = value_new_float(14.4); } else if (row%5 == 1) { tempVal = value_new_float(18.8); } else if (row%5 == 2) { tempVal = value_new_float(7.6); } else if (row%5 == 3) { tempVal = value_new_float(3.3); } else { tempVal = value_new_float(11.6); } } else if (col == 3) { tempVal = value_new_int(row % 10); } else if (col == 4) { if (row == 0) { GnmEvalPos *pos = g_new(GnmEvalPos, 1); pos = eval_pos_init(pos, sheet, col, row); tempVal = value_new_error_DIV0(pos); } else if (row == 1) { GnmEvalPos *pos = g_new(GnmEvalPos, 1); pos = eval_pos_init(pos, sheet, col, row); tempVal = value_new_error_NA(pos); } else if (row == 2) { GnmEvalPos *pos = g_new(GnmEvalPos, 1); pos = eval_pos_init(pos, sheet, col, row); tempVal = value_new_error_REF(pos); } else if (row == 3) { tempVal = value_new_bool(TRUE); } else if (row == 4) { tempVal = value_new_bool(FALSE); } else if (row == 5) { tempVal = value_new_empty(); } else { if (row%5 == 1) { tempVal = value_new_string_nocopy((char *)"a"); } else if (row%5 == 2) { tempVal = value_new_string_nocopy((char *)"b"); } else if (row%5 == 3) { tempVal = value_new_string_nocopy((char *)"c"); } else if (row%5 == 4) { tempVal = value_new_string_nocopy((char *)"d"); } else { tempVal = value_new_string_nocopy((char *)"e"); } } } sheet_cell_set_value(tempCell, tempVal); } } cache = g_object_new(GO_DATA_CACHE_TYPE, NULL); range = g_new(GnmRange, 1); range = range_init(range, 0, 0, numCols - 1, numRows - 1); go_data_cache_build_cache(cache, sheet, range); g_object_unref (wb); return cache; }
static GnmValue * new_gnm_value_from_xloper (const XLOPER*x) { GnmValue * g = NULL; if (NULL != x) { switch (x->xltype & xltypeType) { case xltypeNum: g = value_new_float (x->val.num); break; case xltypeStr: { char *o = NULL; const char *s = x->val.str; if (NULL != s) { guint m = ((unsigned char)s[0]) + 1U; o = g_new (char, m); g_strlcpy (o, s + 1, m); } g = value_new_string_nocopy (o); break; } case xltypeBool: g = value_new_bool (x->val.boolean); break; case xltypeRef: unsupported_xloper_type (x); break; case xltypeErr: g = value_new_error_std (NULL, gnm_value_error_from_xloper (x)); break; case xltypeFlow: unsupported_xloper_type (x); break; case xltypeMulti: { guint m = x->val.array.columns; guint n = x->val.array.rows; if (m > 0 && n > 0) { guint i; g = value_new_array_empty (m,n); for (i = 0; i < m; ++i) { guint j; for (j = 0; j < n; ++j) { g->v_array.vals[i][j] = new_gnm_value_from_xloper (x->val.array.lparray + i + j * m); } } } else { g = value_new_error_std (NULL, GNM_ERROR_VALUE); } break; } case xltypeMissing: break; case xltypeNil: g = value_new_empty (); break; case xltypeSRef: unsupported_xloper_type (x); break; case xltypeInt: g = value_new_int (x->val.w); break; default: unsupported_xloper_type (x); } } else {
/** * FIXME: In the long term this needs optimising. **/ static GnmValue * val_to_base (GnmFuncEvalInfo *ei, GnmValue const *value, GnmValue const *aplaces, int src_base, int dest_base, gnm_float min_value, gnm_float max_value, Val2BaseFlags flags) { int digit, min, max, places; gnm_float v; GString *buffer; GnmValue *vstring = NULL; g_return_val_if_fail (src_base > 1 && src_base <= 36, value_new_error_VALUE (ei->pos)); g_return_val_if_fail (dest_base > 1 && dest_base <= 36, value_new_error_VALUE (ei->pos)); /* func.c ought to take care of this. */ if (VALUE_IS_BOOLEAN (value)) return value_new_error_VALUE (ei->pos); if (aplaces && VALUE_IS_BOOLEAN (aplaces)) return value_new_error_VALUE (ei->pos); switch (value->type) { default: return value_new_error_NUM (ei->pos); case VALUE_STRING: if (flags & V2B_STRINGS_GENERAL) { vstring = format_match_number (value_peek_string (value), NULL, workbook_date_conv (ei->pos->sheet->workbook)); if (!vstring || !VALUE_IS_FLOAT (vstring)) { value_release (vstring); return value_new_error_VALUE (ei->pos); } } else { char const *str = value_peek_string (value); size_t len; gboolean hsuffix = FALSE; char *err; if ((flags & V2B_STRINGS_BLANK_ZERO) && *str == 0) str = "0"; /* This prevents leading spaces, signs, etc, and "". */ if (!g_ascii_isalnum (*str)) return value_new_error_NUM (ei->pos); len = strlen (str); /* We check length in bytes. Since we are going to require nothing but digits, that is fine. */ if ((flags & V2B_STRINGS_MAXLEN) && len > 10) return value_new_error_NUM (ei->pos); if (flags & V2B_STRINGS_0XH) { if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) str += 2; else if (str[len - 1] == 'h' || str[len - 1] == 'H') hsuffix = TRUE; } v = g_ascii_strtoll (str, &err, src_base); if (err == str || err[hsuffix] != 0) return value_new_error_NUM (ei->pos); if (v < min_value || v > max_value) return value_new_error_NUM (ei->pos); break; } /* Fall through. */ case VALUE_FLOAT: { gnm_float val = gnm_fake_trunc (value_get_as_float (vstring ? vstring : value)); char buf[GNM_MANT_DIG + 10]; char *err; value_release (vstring); if (val < min_value || val > max_value) return value_new_error_NUM (ei->pos); g_ascii_formatd (buf, sizeof (buf) - 1, "%.0" GNM_FORMAT_f, val); v = g_ascii_strtoll (buf, &err, src_base); if (*err != 0) return value_new_error_NUM (ei->pos); break; } } if (src_base != 10) { gnm_float b10 = gnm_pow (src_base, 10); if (v >= b10 / 2) /* N's complement */ v = v - b10; } if (flags & V2B_NUMBER) return value_new_float (v); if (v < 0) { min = 1; max = 10; v += gnm_pow (dest_base, max); } else { if (v == 0) min = max = 1; else min = max = (int)(gnm_log (v + 0.5) / gnm_log (dest_base)) + 1; } if (aplaces) { gnm_float fplaces = value_get_as_float (aplaces); if (fplaces < min || fplaces > 10) return value_new_error_NUM (ei->pos); places = (int)fplaces; if (v >= 0 && places > max) max = places; } else places = 1; buffer = g_string_sized_new (max); g_string_set_size (buffer, max); for (digit = max - 1; digit >= 0; digit--) { int thisdigit = gnm_fmod (v + 0.5, dest_base); v = gnm_floor ((v + 0.5) / dest_base); buffer->str[digit] = thisdigit["0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"]; } return value_new_string_nocopy (g_string_free (buffer, FALSE)); }