static int g_iofile(lua_State * L, int f, const char *mode)
{
if (!lua_isnoneornil(L, 1)) {
const char *filename = lua_tostring(L, 1);
if (filename) {
FILE **pf = newfile(L);
*pf = fopen(filename, mode);
if (*pf == NULL) {
fileerror(L, 1, filename);
} else {
if (mode[0]=='r')
recorder_record_input(filename);
else
recorder_record_output(filename);
}
} else {
tofile(L); /* check that it's a valid file handle */
lua_pushvalue(L, 1);
}
lua_rawseti(L, LUA_ENVIRONINDEX, f);
}
/* return current value */
lua_rawgeti(L, LUA_ENVIRONINDEX, f);
return 1;
}
static int io_open (lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
const char *mode = luaL_optstring(L, 2, "r");
LStream *p = newfile(L);
int i = 0;
/* check whether 'mode' matches '[rwa]%+?b?' */
if (!(mode[i] != '\0' && strchr("rwa", mode[i++]) != NULL &&
(mode[i] != '+' || ++i) && /* skip if char is '+' */
(mode[i] != 'b' || ++i) && /* skip if char is 'b' */
(mode[i] == '\0')))
return luaL_error(L, "invalid mode " LUA_QS
" (should match " LUA_QL("[rwa]%%+?b?") ")", mode);
p->f = fopen(filename, mode);
if (p->f == NULL) {
return luaL_fileresult(L, 0, filename) ;
} else {
#ifdef WIN32
_setmode (fileno (p->f), _O_BINARY);
#endif
if (mode[0]=='r')
recorder_record_input(filename);
else
recorder_record_output(filename);
return 1;
}
}
static int io_open_ro(lua_State * L)
{
FILE **pf;
const char *filename = luaL_checkstring(L, 1);
const char *mode = luaL_optstring(L, 2, "rb");
if ((strcmp(mode, "r") != 0) && (strcmp(mode, "rb") != 0))
return pushresult(L, 0, filename);
pf = newfile(L);
*pf = fopen(filename, mode);
if (*pf == NULL)
return pushresult(L, 0, filename);
recorder_record_input(filename);
return 1;
}
static int io_open(lua_State * L)
{
const char *filename = luaL_checkstring(L, 1);
const char *mode = luaL_optstring(L, 2, "rb");
FILE **pf = newfile(L);
*pf = fopen(filename, mode);
if (*pf == NULL)
return pushresult(L, 0, filename);
if (mode[0]=='r')
recorder_record_input(filename);
else
recorder_record_output(filename);
return 1;
}
static void opencheck (lua_State *L, const char *fname, const char *mode) {
LStream *p = newfile(L);
p->f = fopen(fname, mode);
if (p->f == NULL) {
luaL_error(L, "cannot open file " LUA_QS " (%s)", fname, strerror(errno));
} else {
#ifdef WIN32
_setmode (fileno (p->f), _O_BINARY);
#endif
if (mode[0]=='r')
recorder_record_input(fname);
else
recorder_record_output(fname);
}
}
static int io_lines(lua_State * L)
{
if (lua_isnoneornil(L, 1)) { /* no arguments? */
/* will iterate over default input */
lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
return f_lines(L);
} else {
const char *filename = luaL_checkstring(L, 1);
FILE **pf = newfile(L);
*pf = fopen(filename, "rb");
if (*pf == NULL)
fileerror(L, 1, filename);
else
recorder_record_input(filename);
aux_lines(L, lua_gettop(L), 1);
return 1;
}
}
LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
LoadF lf;
int status, readstatus;
int c;
int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
lf.extraline = 0;
if (filename == NULL) {
lua_pushliteral(L, "=stdin");
lf.f = stdin;
}
else {
lua_pushfstring(L, "@%s", filename);
lf.f = fopen(filename, "r");
if (lf.f != NULL)
recorder_record_input (filename);
if (lf.f == NULL) return errfile(L, "open", fnameindex);
}
c = getc(lf.f);
if (c == '#') { /* Unix exec. file? */
lf.extraline = 1;
while ((c = getc(lf.f)) != EOF && c != '\n') ; /* skip first line */
if (c == '\n') c = getc(lf.f);
}
if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
/* skip eventual `#!...' */
while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
lf.extraline = 0;
}
ungetc(c, lf.f);
status = lua_load(L, getF, &lf, lua_tostring(L, -1));
readstatus = ferror(lf.f);
if (filename) fclose(lf.f); /* close file (even in case of errors) */
if (readstatus) {
lua_settop(L, fnameindex); /* ignore results from `lua_load' */
return errfile(L, "read", fnameindex);
}
lua_remove(L, fnameindex);
return status;
}
boolean
open_input (FILE **f_ptr, int filefmt, const_string fopen_mode)
{
string fname = NULL;
#ifdef FUNNY_CORE_DUMP
/* This only applies if a preloaded TeX/Metafont is being made;
it allows automatic creation of the core dump (typing ^\ loses
since that requires manual intervention). */
if ((filefmt == kpse_tex_format || filefmt == kpse_mf_format
|| filefmt == kpse_mp_format)
&& STREQ (nameoffile + 1, "HackyInputFileNameForCoreDump.tex"))
funny_core_dump ();
#endif
/* We havent found anything yet. */
*f_ptr = NULL;
if (fullnameoffile)
free(fullnameoffile);
fullnameoffile = NULL;
/* Look in -output-directory first, if the filename is not
absolute. This is because .aux and other such files will get
written to the output directory, and we have to be able to read
them from there. We only look for the name as-is. */
if (output_directory && !kpse_absolute_p (nameoffile+1, false)) {
fname = concat3 (output_directory, DIR_SEP_STRING, nameoffile + 1);
*f_ptr = fopen (fname, fopen_mode);
if (*f_ptr) {
free (nameoffile);
namelength = strlen (fname);
nameoffile = xmalloc (namelength + 2);
strcpy (nameoffile + 1, fname);
fullnameoffile = fname;
} else {
free (fname);
}
}
/* No file means do the normal search. */
if (*f_ptr == NULL) {
/* A negative FILEFMT means don't use a path. */
if (filefmt < 0) {
/* no_file_path, for BibTeX .aux files and MetaPost things. */
*f_ptr = fopen(nameoffile + 1, fopen_mode);
/* FIXME... fullnameoffile = xstrdup(nameoffile + 1); */
} else {
/* The only exception to `must_exist' being true is \openin, for
which we set `tex_input_type' to 0 in the change file. */
/* According to the pdfTeX people, pounding the disk for .vf files
is overkill as well. A more general solution would be nice. */
boolean must_exist = (filefmt != kpse_tex_format || texinputtype)
&& (filefmt != kpse_vf_format);
fname = kpse_find_file (nameoffile + 1,
(kpse_file_format_type)filefmt,
must_exist);
if (fname) {
fullnameoffile = xstrdup(fname);
/* If we found the file in the current directory, don't leave
the `./' at the beginning of `nameoffile', since it looks
dumb when `tex foo' says `(./foo.tex ... )'. On the other
hand, if the user said `tex ./foo', and that's what we
opened, then keep it -- the user specified it, so we
shouldn't remove it. */
if (fname[0] == '.' && IS_DIR_SEP (fname[1])
&& (nameoffile[1] != '.' || !IS_DIR_SEP (nameoffile[2])))
{
unsigned i = 0;
while (fname[i + 2] != 0) {
fname[i] = fname[i + 2];
i++;
}
fname[i] = 0;
}
/* kpse_find_file always returns a new string. */
free (nameoffile);
namelength = strlen (fname);
nameoffile = xmalloc (namelength + 2);
strcpy (nameoffile + 1, fname);
free (fname);
/* This fopen is not allowed to fail. */
#if defined(PTEX) && !defined(WIN32)
if (filefmt == kpse_tex_format ||
filefmt == kpse_bib_format) {
*f_ptr = nkf_open (nameoffile + 1, fopen_mode);
} else
#endif
*f_ptr = xfopen (nameoffile + 1, fopen_mode);
}
}
}
if (*f_ptr) {
recorder_record_input (nameoffile + 1);
/* If we just opened a TFM file, we have to read the first
byte, to pretend we're Pascal. See tex.ch and mp.ch.
Ditto for the ocp/ofm Omega file formats. */
if (filefmt == kpse_tfm_format) {
tfmtemp = getc (*f_ptr);
/* We intentionally do not check for EOF here, i.e., an
empty TFM file. TeX will see the 255 byte and complain
about a bad TFM file, which is what we want. */
} else if (filefmt == kpse_ocp_format) {
ocptemp = getc (*f_ptr);
} else if (filefmt == kpse_ofm_format) {
tfmtemp = getc (*f_ptr);
}
}
return *f_ptr != NULL;
}
void read_img(image_dict * idict)
{
char *filepath = NULL;
int callback_id;
if (img_filename(idict) == NULL) {
normal_error("pdf backend","image file name missing");
}
callback_id = callback_defined(find_image_file_callback);
if (img_filepath(idict) == NULL) {
if (callback_id > 0) {
/*tex We always callback, also for a mem stream. */
if (run_callback(callback_id, "S->S", img_filename(idict),&filepath)) {
if (filepath && (strlen(filepath) > 0)) {
img_filepath(idict) = strdup(filepath);
}
}
}
if (img_filepath(idict) == NULL && (strstr(img_filename(idict),"data:application/pdf,") != NULL)) {
/*tex We need to check here for a pdf memstream. */
img_filepath(idict) = strdup(img_filename(idict));
} else if (callback_id == 0) {
/*tex Otherwise we use kpse but only when we don't callback. */
img_filepath(idict) = kpse_find_file(img_filename(idict), kpse_tex_format, true);
}
if (img_filepath(idict) == NULL) {
/*tex In any case we need a name. */
formatted_error("pdf backend","cannot find image file '%s'", img_filename(idict));
}
}
recorder_record_input(img_filepath(idict));
/*tex A few type checks. */
check_type_by_header(idict);
check_type_by_extension(idict);
/*tex Now we're ready to read the image. */
switch (img_type(idict)) {
case IMG_TYPE_PDFMEMSTREAM:
case IMG_TYPE_PDF:
read_pdf_info(idict);
break;
case IMG_TYPE_PNG:
read_png_info(idict);
break;
case IMG_TYPE_JPG:
read_jpg_info(idict);
break;
case IMG_TYPE_JP2:
read_jp2_info(idict);
break;
case IMG_TYPE_JBIG2:
read_jbig2_info(idict);
break;
default:
img_type(idict) = IMG_TYPE_NONE;
if (pdf_ignore_unknown_images) {
normal_warning("pdf backend","internal error: ignoring unknown image type");
} else {
normal_error("pdf backend","internal error: unknown image type");
}
break;
}
cur_file_name = NULL;
if (img_type(idict) == IMG_TYPE_NONE) {
img_state(idict) = DICT_NEW;
} else if (img_state(idict) < DICT_FILESCANNED) {
img_state(idict) = DICT_FILESCANNED;
}
}
