static PRN *get_dotdir_printer (char **pfname, int *err)
{
const char *dotdir = gretl_dotdir();
char *fname = NULL;
FILE *fp = NULL;
PRN *prn = NULL;
fname = malloc(strlen(dotdir) + 16);
if (fname == NULL) {
*err = E_ALLOC;
} else {
sprintf(fname, "%sprntmp.XXXXXX", dotdir);
fp = gretl_mktemp(fname, "w");
if (fp == NULL) {
*err = E_FOPEN;
free(fname);
fname = NULL;
}
}
if (fp != NULL) {
prn = gretl_print_new_with_stream(fp);
*pfname = fname;
}
return prn;
}
int gretl_bundle_write_to_file (gretl_bundle *b,
const char *fname,
int to_dotdir)
{
char fullname[FILENAME_MAX];
FILE *fp;
int err = 0;
if (to_dotdir) {
build_path(fullname, gretl_dotdir(), fname, NULL);
} else {
strcpy(fullname, fname);
gretl_maybe_switch_dir(fullname);
}
fp = gretl_fopen(fullname, "wb");
if (fp == NULL) {
err = E_FOPEN;
} else {
gretl_xml_header(fp);
gretl_bundle_serialize(b, "temp", fp);
}
return err;
}
static void gpage_filenames_init (const char *base)
{
if (base == NULL) {
strcpy(gpage_base, gretl_dotdir());
strcat(gpage_base, "gretl_graphpage");
strcpy(gpage_tex_base, "gretl_graphpage");
} else {
const char *p;
strcpy(gpage_base, base);
if (has_suffix(gpage_base, ".tex") ||
has_suffix(gpage_base, ".pdf") ||
has_suffix(gpage_base, ".eps")) {
gpage_base[strlen(gpage_base) - 4] = '\0';
} else if (has_suffix(gpage_base, ".ps")) {
gpage_base[strlen(gpage_base) - 3] = '\0';
}
p = strrchr(gpage_base, SLASH);
if (p != NULL) {
strcpy(gpage_tex_base, p + 1);
} else {
strcpy(gpage_tex_base, gpage_base);
}
}
}
static int prn_add_tempfile (PRN *prn)
{
const char *dotdir = gretl_dotdir();
int n = strlen(dotdir) + 16;
int err = 0;
prn->fname = malloc(n);
if (prn->fname == NULL) {
return E_ALLOC;
}
sprintf(prn->fname, "%sprntmp.XXXXXX", dotdir);
prn->fp = gretl_mktemp(prn->fname, "w");
#if PRN_DEBUG
fprintf(stderr, "prn_add_tempfile: '%s' at %p\n",
prn->fname, (void *) prn->fp);
#endif
if (prn->fp == NULL) {
free(prn->fname);
prn->fname = NULL;
err = E_FOPEN;
}
return err;
}
void do_nistcheck (GtkAction *action)
{
void *handle;
int (*run_nist_tests)(const char *, const char *, int);
gchar *datadir = NULL;
gchar *fname = NULL;
run_nist_tests = gui_get_plugin_function("run_nist_tests",
&handle);
if (run_nist_tests == NULL) {
return;
}
datadir = g_strdup_printf("%sdata%s", gretl_home(), SLASHSTR);
fname = g_strdup_printf("%snist.out", gretl_dotdir());
(*run_nist_tests)(datadir, fname, nist_verbosity(action));
close_plugin(handle);
view_file(fname, 0, 1, 78, 400, VIEW_CODEBOOK);
g_free(datadir);
g_free(fname);
}
void send_file (char *fullname)
{
int (*email_file) (const char *, const char *);
void *handle;
email_file = gui_get_plugin_function("email_file", &handle);
if (email_file == NULL) {
return;
}
email_file(fullname, gretl_dotdir());
close_plugin(handle);
}
static void remove_temp_dir (char *dname)
{
const char *udir = gretl_dotdir();
# ifdef G_OS_WIN32
char *fullpath = g_strdup_printf("%s%s", udir, dname);
gretl_chdir(udir);
win32_delete_dir(fullpath);
g_free(fullpath);
# else
gretl_chdir(udir);
gretl_deltree(dname);
# endif
}
static int spawn_dvips (char *texsrc)
{
GError *error = NULL;
gchar *sout = NULL;
gchar *argv[5];
char outfile[MAXLEN];
int ok, status;
int ret = 0;
sprintf(outfile, "%s.ps", texsrc);
argv[0] = "dvips";
argv[1] = "-o";
argv[2] = outfile;
argv[3] = texsrc;
argv[4] = NULL;
ok = g_spawn_sync(gretl_dotdir(),
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, /* child_setup */
NULL, /* user_data */
&sout, /* standard output */
NULL, /* standard error */
&status, /* exit status */
&error);
if (!ok) {
errbox(error->message);
g_error_free(error);
ret = LATEX_EXEC_FAILED;
} else if (status != 0) {
gchar *errmsg;
errmsg = g_strdup_printf("%s\n%s",
_("Failed to process TeX file"),
sout);
errbox(errmsg);
g_free(errmsg);
ret = 1;
}
if (sout != NULL) g_free(sout);
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;
}
gretl_bundle *gretl_bundle_read_from_file (const char *fname,
int from_dotdir,
int *err)
{
xmlDocPtr doc = NULL;
xmlNodePtr cur = NULL;
char fullname[FILENAME_MAX];
gretl_bundle *b;
b = gretl_bundle_new();
if (b == NULL) {
*err = E_ALLOC;
return NULL;
}
if (from_dotdir) {
build_path(fullname, gretl_dotdir(), fname, NULL);
} else {
strcpy(fullname, fname);
}
*err = gretl_xml_open_doc_root(fullname, "gretl-bundle", &doc, &cur);
if (!*err) {
gretl_push_c_numeric_locale();
cur = cur->xmlChildrenNode;
*err = load_bundled_items(b, cur, doc);
gretl_pop_c_numeric_locale();
xmlFreeDoc(doc);
}
if (*err) {
gretl_bundle_destroy(b);
b = NULL;
}
return b;
}
int dvips_compile (char *texshort)
{
#ifdef G_OS_WIN32
static char dvips_path[MAXLEN];
char tmp[MAXLEN];
#endif
int err = 0;
#if defined(G_OS_WIN32)
if (*dvips_path == 0 && get_dvips_path(dvips_path)) {
win_show_last_error();
return 1;
}
sprintf(tmp, "\"%s\" -o %s.ps %s", dvips_path, texshort, texshort);
if (win_run_sync(tmp, gretl_dotdir())) {
return 1;
}
#else
err = spawn_dvips(texshort);
#endif
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;
}
