char *retrieve_public_file_as_buffer (const char *uri, size_t *len,
int *err)
{
char *buf = NULL;
if (proto_length(uri) == 0) {
*err = E_DATA;
return NULL;
} else {
urlinfo u;
urlinfo_init(&u, NULL, SAVE_TO_BUFFER, NULL);
urlinfo_set_url(&u, uri);
*err = curl_get(&u);
urlinfo_finalize(&u, &buf, err);
*len = (*err)? 0 : u.datalen;
}
if (*err) {
const char *s = gretl_errmsg_get();
if (*s == '\0') {
/* no error message in place */
gretl_errmsg_sprintf("%s\ndownload failed", uri);
}
}
return buf;
}
int gretl_print_rename_file (PRN *prn, const char *oldpath,
const char *newpath)
{
int err = 0;
if (prn == NULL) {
fprintf(stderr, "gretl_print_rename_file: prn is NULL\n");
return E_DATA;
}
if (prn->fp == NULL || prn_fp_list_active(prn)) {
return E_DATA;
}
#if PRN_DEBUG
fprintf(stderr, "gretl_print_rename_file, prn at %p:\n oldpath='%s'\n"
" newpath='%s'\n prn->fp=%p (closing)\n", (void *) prn,
oldpath, newpath, (void *) prn->fp);
fprintf(stderr, " (old prn->fname = '%s')\n", prn->fname);
#endif
fclose(prn->fp);
prn->fp = NULL;
if (oldpath == NULL && prn->fname != NULL) {
/* renaming from tempfile */
err = gretl_rename(prn->fname, newpath);
} else {
err = gretl_rename(oldpath, newpath);
}
if (err) {
fprintf(stderr, "%s\n", gretl_errmsg_get());
} else {
/* re-open the stream under its new name */
prn->fp = gretl_fopen(newpath, "a");
#if PRN_DEBUG
fprintf(stderr, "gretl_print_rename_file: new fp=%p\n", prn->fp);
#endif
if (prn->fname != NULL) {
/* @prn originally used a tempfile: the record of
the temporary filename should be deleted
*/
free(prn->fname);
prn->fname = NULL;
}
}
return err;
}
static int check_imported_varname (char *vname, int vnum,
int row, int col,
PRN *prn)
{
int err = 0;
if (*vname == '\0') {
if (vnum > 0) {
fprintf(stderr, "variable name %d is missing\n", vnum);
sprintf(vname, "v%d", vnum);
} else {
err = missing_varname();
}
} else if (numeric_string(vname)) {
err = check_varname(vname);
} else {
char *s, tmp[VNAMELEN];
strcpy(tmp, vname);
s = tmp;
*vname = '\0';
while (*s && !isalpha(*s)) s++;
if (*s == '\0') {
if (vnum > 0) {
fprintf(stderr, "variable name %d is garbage\n", vnum);
sprintf(vname, "v%d", vnum);
} else {
err = missing_varname();
}
} else {
strncat(vname, s, VNAMELEN - 1);
}
iso_to_ascii(vname);
strip_vname_illegals(vname);
err = check_varname(vname);
}
if (err) {
err = E_DATA;
if (row >= 0 && col >= 0) {
pprintf(prn, _("At row %d, column %d:\n"), row, col);
}
pputs(prn, gretl_errmsg_get());
}
return err;
}
int gretl_spawn (char *cmdline)
{
GError *error = NULL;
gchar *errout = NULL;
gchar *sout = NULL;
int ok, status;
int ret = 0;
gretl_error_clear();
ok = g_spawn_command_line_sync(cmdline,
&sout, /* standard output */
&errout, /* standard error */
&status, /* exit status */
&error);
if (!ok) {
gretl_errmsg_set(error->message);
fprintf(stderr, "gretl_spawn: '%s'\n", error->message);
g_error_free(error);
ret = 1;
} else if (errout && *errout) {
fprintf(stderr, "stderr: '%s'\n", errout);
if (!non_fatal(errout)) {
gretl_errmsg_set(errout);
fprintf(stderr, "gretl_errmsg: '%s'\n", gretl_errmsg_get());
ret = 1;
}
} else if (status != 0) {
if (sout != NULL && *sout) {
gretl_errmsg_set(sout);
fprintf(stderr, "gretl_spawn: status = %d: '%s'\n", status, sout);
} else {
gretl_errmsg_set(_("Command failed"));
fprintf(stderr, "gretl_spawn: status = %d\n", status);
}
ret = 1;
}
if (errout != NULL) g_free(errout);
if (sout != NULL) g_free(sout);
if (ret) {
fprintf(stderr, "Failed command: '%s'\n", cmdline);
}
return ret;
}
int retrieve_public_file (const char *uri, char *localname)
{
int pl = proto_length(uri);
int err = 0;
if (pl == 0) {
return E_DATA;
} else if (*localname == '\0') {
/* extract the filename from the uri */
const char *s = strrchr(uri + pl, '/');
if (s == NULL || *(s+1) == '\0') {
err = E_DATA;
} else {
/* save to user's dotdir by default */
strcat(localname, gretl_dotdir());
strcat(localname, s + 1);
}
}
if (!err) {
urlinfo u;
urlinfo_init(&u, NULL, SAVE_TO_FILE, localname);
urlinfo_set_url(&u, uri);
if (gretl_in_gui_mode()) {
urlinfo_set_show_progress(&u);
}
err = curl_get(&u);
urlinfo_finalize(&u, NULL, &err);
}
if (err) {
const char *s = gretl_errmsg_get();
if (*s == '\0') {
/* no error message in place */
gretl_errmsg_sprintf("%s\ndownload failed", uri);
}
} else {
err = check_downloaded_file(localname, uri);
}
return err;
}
static int xlsx_read_shared_strings (xlsx_info *xinfo, PRN *prn)
{
xmlDocPtr doc = NULL;
xmlNodePtr cur = NULL;
xmlNodePtr val;
char *tmp;
int i, n = 0;
int err = 0;
err = gretl_xml_open_doc_root(xinfo->stringsfile, "sst",
&doc, &cur);
if (err) {
pprintf(prn, "Couldn't find shared strings table\n");
pprintf(prn, "%s", gretl_errmsg_get());
return err;
}
tmp = (char *) xmlGetProp(cur, (XUC) "uniqueCount");
if (tmp == NULL) {
tmp = (char *) xmlGetProp(cur, (XUC) "count");
}
if (tmp == NULL) {
pprintf(prn, "didn't get sst count\n");
err = E_DATA;
} else {
n = atoi(tmp);
if (n <= 0) {
pprintf(prn, "didn't get valid sst count\n");
err = E_DATA;
}
free(tmp);
}
if (!err) {
xinfo->strings = strings_array_new(n);
if (xinfo->strings == NULL) {
err = E_ALLOC;
}
}
cur = cur->xmlChildrenNode;
/* The strings in an <sst> are mostly set up as
<si><t>XXX</t></si>
<si><t>YYY</t></si> ...
But there are also weird cases where junk is interposed
and the structure becomes
<si><r>...<t>XXX</t></r><r>...<t>YYY</t></r></si> ...
That is, an <si> element may contain more than one <r>
element, which embeds a <t> along with formatting crap.
*/
i = 0;
while (cur != NULL && !err) {
if (!xmlStrcmp(cur->name, (XUC) "si")) {
int gotstr = 0;
val = cur->xmlChildrenNode;
while (val != NULL && !err && !gotstr) {
if (!xmlStrcmp(val->name, (XUC) "t")) {
/* got a regular <t> element */
tmp = (char *) xmlNodeGetContent(val);
if (tmp == NULL) {
pprintf(prn, "failed reading string %d\n", i);
err = E_DATA;
} else {
xinfo->strings[i++] = tmp;
gotstr = 1;
}
} else if (!xmlStrcmp(val->name, (XUC) "r")) {
/* hunt for <t> inside an <r> element */
xmlNodePtr sub = val->xmlChildrenNode;
while (sub != NULL && !err && i < n) {
if (!xmlStrcmp(sub->name, (XUC) "t")) {
tmp = (char *) xmlNodeGetContent(sub);
if (tmp == NULL) {
pprintf(prn, "failed reading string %d\n", i);
err = E_DATA;
} else {
xinfo->strings[i++] = tmp;
gotstr = 1;
}
}
sub = sub->next;
}
}
val = val->next;
}
}
if (i == n) {
break;
}
cur = cur->next;
}
if (!err && i < n) {
pprintf(prn, "expected %d shared strings but only found %d\n",
n, i);
err = E_DATA;
}
if (!err) {
xinfo->n_strings = i;
} else if (xinfo->strings != NULL) {
strings_array_free(xinfo->strings, n);
xinfo->strings = NULL;
}
xmlFreeDoc(doc);
return err;
}
static int xlsx_read_worksheet (xlsx_info *xinfo, PRN *prn)
{
xmlDocPtr doc = NULL;
xmlNodePtr data_node = NULL;
xmlNodePtr cur = NULL;
xmlNodePtr c1;
int gotdata = 0;
int err = 0;
sprintf(xinfo->sheetfile, "xl%c%s", SLASH,
xinfo->filenames[xinfo->selsheet]);
#if XDEBUG
fprintf(stderr, "xlsx_read_worksheet: sheetnum=%d, name='%s'\n",
xinfo->selsheet, xinfo->filenames[xinfo->selsheet]);
#endif
sprintf(xinfo->stringsfile, "xl%csharedStrings.xml", SLASH);
err = gretl_xml_open_doc_root(xinfo->sheetfile, "worksheet",
&doc, &cur);
if (err) {
pprintf(prn, "didn't get worksheet\n");
pprintf(prn, "%s", gretl_errmsg_get());
return err;
}
/* walk the tree, first pass */
cur = cur->xmlChildrenNode;
while (cur != NULL && !err && !gotdata) {
if (!xmlStrcmp(cur->name, (XUC) "sheetData")) {
data_node = c1 = cur->xmlChildrenNode;
while (c1 != NULL && !err) {
if (!xmlStrcmp(c1->name, (XUC) "row")) {
err = xlsx_read_row(c1, xinfo, prn);
}
c1 = c1->next;
}
gotdata = 1;
}
cur = cur->next;
}
#if XDEBUG
if (!err) {
pprintf(prn, "Max row = %d, max col = %d\n", xinfo->maxrow,
xinfo->maxcol);
pprintf(prn, "Accessed %d shared strings\n", xinfo->n_strings);
}
#endif
if (!err && xinfo->dset == NULL) {
err = xlsx_check_dimensions(xinfo, prn);
if (!err) {
gretl_push_c_numeric_locale();
c1 = data_node;
while (c1 != NULL && !err) {
if (!xmlStrcmp(c1->name, (XUC) "row")) {
err = xlsx_read_row(c1, xinfo, prn);
}
c1 = c1->next;
}
gretl_pop_c_numeric_locale();
}
}
xmlFreeDoc(doc);
return err;
}
static int open_import_zipfile (const char *fname, char *dname,
PRN *prn)
{
const char *udir = gretl_dotdir();
const char *real_fname = fname;
char *recoded_fname = NULL;
char *abspath = NULL;
FILE *fp;
int err = 0;
errno = 0;
*dname = '\0';
/* In case @fname is in UTF-8 but we're on MS Windows (or
conceivably on an old non-UTF-8 *nix system), grab the
appropriately recoded filename to pass into the
zipfile apparatus, since in that context a filename
that works with plain system stdio is expected.
FIXME: is this right if we're using libgsf to do the
unzipping? Maybe this doesn't matter if we're using
libgsf only on UTF-8 systems (e.g. modern Linux), in
which case no recoding will be required.
*/
fp = gretl_fopen_with_recode(fname, "r", &recoded_fname);
if (fp == NULL) {
return E_FOPEN;
}
fclose(fp);
if (recoded_fname != NULL) {
real_fname = recoded_fname;
}
/* by doing chdir, we may lose track of the file if
its path is relative */
if (!g_path_is_absolute(real_fname)) {
abspath = get_absolute_path(real_fname);
if (abspath != NULL) {
real_fname = abspath;
}
}
/* cd to user dir and make temporary dir */
if (gretl_chdir(udir)) {
gretl_errmsg_set_from_errno(udir);
err = E_FOPEN;
} else {
err = gretl_make_tempdir(dname);
if (!err) {
err = gretl_chdir(dname);
if (err) {
gretl_remove(dname);
}
}
}
if (!err) {
/* if all has gone OK, we're now "in" the temporary
directory under dotdir, and @real_fname is the
absolute path to the file to be unzipped.
*/
err = gretl_unzip(real_fname);
if (err) {
pprintf(prn, "gretl_unzip: %s\n", gretl_errmsg_get());
}
}
free(abspath);
free(recoded_fname);
return err;
}
int main (void)
{
DATASET *dataset; /* pointer to dataset struct */
int *list; /* list of regressors etc. */
MODEL *model; /* pointer to model struct */
PRN *prn; /* pointer to struct for printing */
int model_count = 0; /* keep a tally of models estimated */
int i; /* index variable */
/* the first data series to load */
double z1[] = {
199.9, 228, 235, 285, 239, 293, 285,
365, 295, 290, 385, 505, 425, 415
};
/* and the second series */
double z2[] = {
1065, 1254, 1300, 1577, 1600, 1750, 1800,
1870, 1935, 1948, 2254, 2600, 2800, 3000
};
/* basic initialization of library */
libgretl_init();
prn = gretl_print_new(GRETL_PRINT_STDOUT, NULL); /* simple printing */
/* allocate the dataset struct: the parameters are the number of
variables (here 3, allowing for the constant in position 0),
the number of observations on each variable (here 14), and
a 0/1 flag indicating whether we want to supply "case marker"
strings for the observations (here we don't).
*/
dataset = create_new_dataset(3, 14, 0);
if (dataset == NULL) noalloc();
/* copy in the names of the variables (starting at [1]
because [0] refers to the constant) */
strcpy(dataset->varname[1], "price");
strcpy(dataset->varname[2], "sqft");
/* Fill in the data array, starting at variable 1. Note that
this array may be a superset of the data actually used in
the regression equation. Note that dataset->n records the
number of observations.
*/
for (i=0; i<dataset->n; i++) {
dset_set_data(dataset, 1, i, z1[i]);
dset_set_data(dataset, 2, i, z2[i]);
}
/* Set up the "list", which is fed to the regression function.
The first element of list represents the length of the list
vector itself, counting from zero. The second entry is the ID
number of the dependent variable (i.e. its place in the data
set Z) counting from one (zero being reserved for the
constant). The third entry (and there can be more) is the ID
number of the first independent variable.
*/
list = gretl_list_new(3); /* number of terms will be 3 */
list[1] = 1; /* the dependent variable is the one with ID# 1 */
list[2] = 0; /* we include a constant (ID# 0) */
list[3] = 2; /* the independent variable has ID# 2 */
/* Now we call the lsq function from libgretl to get least squares
estimates and associated statistics. */
model = gretl_model_new();
if (model == NULL) noalloc();
*model = lsq(list, /* regressand and regressors */
dataset, /* the dataset */
OLS, /* use Ordinary Least Squares */
OPT_NONE /* no special options */
);
/* Handle case where lsq bombed */
if (model->errcode) {
printf("model->errcode: %d\n", model->errcode);
printf("error message: %s\n", gretl_errmsg_get());
return 1;
}
/* Otherwise give this model an ID number for reference */
model->ID = ++model_count;
/* and print the regression results */
printmodel(model, dataset, OPT_NONE, prn);
/* memory management check -- try explicitly freeing all allocated
memory */
gretl_model_free(model);
free(list);
destroy_dataset(dataset);
gretl_print_destroy(prn);
libgretl_cleanup();
return 0;
}
