JezK
Edit File: epspdf
#!/usr/bin/env texlua kpse.set_program_name('texlua') --[[ epspdf conversion utility 0.6.0: first texlua version 0.6.1: allow TeX installation on path with spaces 0.6.2: compatibility fix for luatex 0.81 0.6.3: compatibility fixes for luatex 0.9x 0.6.4: adaptations for newer versions of LuaTeX and ghostscript; some refactoring; better handling of some corner cases 0.6.5: eliminate .setpdfwrite from ghostscript commandlines, since this is now considered obsolete 0.6.5.1: eliminate faulty check for writability system_tmpdir; just error out when no tempdir for epspdf can be created. Avoid spawn for MiKTeX. Copyright (C) 2006-2023 Siep Kroonenberg siepo at bitmuis nl This program is free software, licensed under the GNU GPL, >=2.0. This software comes with absolutely NO WARRANTY. Use at your own risk! Note. TeX code for cropping pdfs adapted from Heiko Oberdiek's pdfcrop utility Program structure - early initialization - functions for: - error handling - file- and path utilities - other general utilities - infrastructure: logging and temporary files - reading and writing settings - gui function for communicating with frontend - boundingboxes - manipulating [e]ps- and pdf files - the PsPdf object: - creator functions - boundingbox handling - one-step conversion methods - any_to_any function. this function checks options, the one-step converters check for success. - main initialization section: - collecting system information - infrastructure: setting up logging and temp directory - settings: - defining settings-, descriptions-, options- and auxiliary tables - read settings - defining commandline options and help function - parsing commandline and performing non-conversion options - calling any_to_any - finishing up all calls to external programs work on temporary files with a simple generated filename. The current directory is a newly-created temporary directory. So no need to quote names of input- and output filenames. POSSIBLE EXTENSIONS - duplicating epstopdf options - custom options for gs and pdftops --]] -- some general utilities and globals --------------------------- -- early initializations eol = false path_sep = false if os.type=='unix' then eol='\n' path_sep = ':' else eol='\r\n' path_sep = ';' end infile = false outfile = false bufsize=16000 -- for reading and writing files -- these `declarations' are not really needed; -- they are here mainly for my own peace of mind from_gui = false -- whether epspdf is run from the epspsdtk gui cwd = '' -- Windows: miktex, TL or neither. -- Actual values determined during system-dependent initialization is_miktex = false is_tl_w32 = false -- Luatex 1.09 and later replace epdf with pdfe -- some global file- and directory names gs_prog = false pdftops = false epsdir = false rcfile = false logfile = false tempdir = false tempfiles = {} -- childpath = false -- os.getenv('path') returns the parents path, -- so we need to keep track ourselves of the child path options = false -- actual conversion options settings = false -- persistent settings; may be stored in config file descriptions = false -- help strings for settings gs_options = false pdf_options = false pdf_tail_options = false ps_options = false gray_options = false -- logging ------------------------ -- we open and close the logfile anew for each write. -- failure to open does not constitute an error. function print_log(s) local f = io.open(logfile, 'a') if f then f:write(s,eol) f:close() end if from_gui then print(s) -- intercepted by the gui end end function write_log(s) print_log(string.format('%s %s', os.date('%Y/%m/%d %H:%M:%S', os.time()), s)) end function log_cmd(cmd) write_log('[' .. table.concat(cmd, '] [') .. ']') end -- error- and debug ------------------------- -- Simple-minded error handling. At most, we call a function which -- tries to write the error message to log before re-raising the error. -- When run from the Tcl/Tk gui, this gui will capture error messages. function errror(mess) if infile and outfile then mess = 'Failure to convert '..infile..' to '..outfile..':\n'..mess end if logfile then pcall(write_log, mess) end -- ignore result of pcall: we can do nothing about failure error(mess, 2) end function warn(mess) if logfile then write_log(mess) end print(mess) end -- function dbg(mess) -- if options.debug then -- warn(mess) -- end -- end -- file- and path utilities ---------------- -- function ep_shortname(path) -- if os.type=='unix' then -- return path -- else -- -- shortname appears not to work under miktex -- -- so return original path as a fallback -- local sp = lfs.shortname(path) -- return sp or path -- end -- end -- prepend or append dir to path if necessary function maybe_add_path(dir, append) local dircmp = path_sep .. dir .. path_sep local pathcmp = path_sep .. kpse.var_value('PATH') .. path_sep -- case folding if os.name=='windows' or os.name=='cygwin' or os.name=='macosx' then dircmp = string.lower(dir) pathcmp = string.lower(pathcmp) end -- slash flipping if os.type=='windows' then pathcmp = (string.gsub(pathcmp, '/', '\\')) dircmp = (string.gsub(dircmp, '/', '\\')) end if not string.find(pathcmp, dircmp, 1, true) then if not append then -- prepend os.setenv('PATH', dir..path_sep..kpse.var_value('PATH')) else -- append os.setenv('PATH', kpse.var_value('PATH')..path_sep..dir) end end end function fw(path) if os.type=='windows' then return string.gsub(path, '\\', '/') else return path end end function absolute_path(path) --[[ Return absolute normalized version of path, interpreted from the directory from where the program was called. We use the fact that lfs.currentdir() always returns an absolute and normalized path. So we go to the parent directory of path, ask for the current directory and then combine the current directory with the base filename. On windows, texlua has no trouble cd-ing into a UNC path. The function returns nil if there is no valid parent path. This might be an issue if path is a directory, but we shall apply this function only on files. It is ok if path itself does not exist. --]] path = fw(path) local present_dir = fw(lfs.currentdir()) lfs.chdir(cwd) local parentdir local filename if string.match(path, '/') then parentdir, filename = string.match(path,'^(.*)/([^/]*)$') if parentdir=='' then parentdir = '/' -- on unix, this is an absolute path. on windows, it is not if os.type=='windows' then lfs.chdir('/') parentdir = fw(lfs.currentdir()) end elseif os.type=='windows' and string.match(parentdir,'^[a-zA-Z]:$') then parentdir = string.sub(parentdir,1,2)..'/' else if not lfs.chdir(parentdir) then parentdir = nil else parentdir = fw(lfs.currentdir()) end end elseif os.type=='windows' and string.match(path,'^[a-zA-Z]:') then -- windows: d:file parentdir = string.sub(path,1,2) if not lfs.chdir(parentdir) then parentdir = nil else parentdir = fw(lfs.currentdir()) filename = string.sub(path,3) end else parentdir = fw(lfs.currentdir()) filename = path end lfs.chdir(present_dir) if not parentdir then return nil elseif string.sub(parentdir,-1)=='/' then return parentdir..filename, parentdir else return parentdir..'/'..filename, parentdir end end -- absolute_path -- check whether prog is on the searchpath. -- we need it only under unix, -- so we save ourselves the trouble of accommodating windows. -- we return the original string, although we only need a yes or no answer function find_on_path (prog) if os.type == 'unix' then for d in string.gmatch(os.getenv('PATH'), '[^:]+') do if lfs.isfile(d..'/'..prog) then return prog end end else for d in string.gmatch(os.getenv('PATH'), '[^;]+') do if lfs.isfile(d..'\\'..prog) then return prog end end end return false end -- find_on_path function system_tempdir () local d = false if os.type=='windows' then d = os.getenv('TEMP') if not d then d = os.getenv('TMP') end else d = os.getenv('TMPDIR') if not d then d = '/tmp' end end -- cygwin: $TEMP=/tmp, root '/' being root of cygwin installation return d end -- other general utilities --------------------------- -- check whether el occurs in array lst function in_list (el, lst) if not lst then return false end for _,p in ipairs(lst) do if el == p then return true end end return false end -- in_list -- remove leading and trailing, but not embedded spaces function strip_outer_spaces(s) s = string.gsub(s, '%s*$', '') s = string.gsub(s, '^%s*', '') return s end -- strip_outer_spaces function join(t, sep, lastsep) -- there is a table function concat which does this, -- but without optional different lastsep if t==nil or #t<1 then return '' end -- or should we return nil? local s = t[1] for i=2,#t do -- ok if #t<2 if i==#t and lastsep then s = s .. lastsep .. t[i] else s = s .. sep .. t[i] end end return s end -- join -- combine several tables into one. -- the parameter is a table of tables. function tab_combine (t) local res = {} for _,tt in ipairs(t) do for __, ttt in ipairs(tt) do table.insert(res, ttt) end end return res end -- tab_combine -- workaround for miktex spawn problem function spawnexec(cmd) if is_miktex then if type(cmd)=='table' then return os.execute(table.concat(cmd, ' ')) -- there is no need for quoting in the cases used else return os.execute(cmd) end else return os.spawn(cmd) end end -- files ---------------------------------------------------- -- Copy a file in chunks, with optional length and offset. -- Since files may be very large, we copy them piecemeal. -- An initial chunk of size bufsize should be plenty to include -- any interesting header information. function slice_file(source, dest, len, offset, mode) -- The final three parameters can be independently left out by -- specifying false as value -- Assume caller ensured parameters of correct type. -- We do not allow negative offsets. local copy2self = false if source==dest then copy2self = true end if os.type=='unix' and lfs.attributes(source,'ino')==lfs.attributes(dest,'ino') then copy2self = true end if copy2self and not len and not offset and mode~='ab' then return -- nothing to do elseif copy2self then errror('slice_file invoked with identical source and destination '.. source..' and non-simple copy') end -- in practice any_to_any already checks for this. -- in addition, the main program makes a backup if infile==outfile local sz = lfs.attributes(source, 'size') if not offset then offset = 0 elseif offset>sz then offset = sz end if not len or len>sz-offset then len = sz - offset end if not mode then mode = 'wb' end local buffer='' local s=io.open(source, 'rb') s:seek('set', offset) local copied = 0 local d=io.open(dest, mode) if not d then errror('slice_file: failed to copy to '..dest) end local slen = len while slen>0 do if slen>=bufsize then buffer = s:read(bufsize) slen = slen - bufsize else buffer = s:read(slen) slen = 0 end if not d:write(buffer) then errror('slice_file: failed to copy to '..dest) end end s:close() d:close() end -- slice_file function move_or_copy(source, dest) if lfs.isfile(dest) and lfs.attributes(dest, 'size')>0 then warn('Removing old '..dest) os.remove(dest) -- in case of failure, go ahead anyway end -- Windows: try first renaming in-place before moving to the right directory if os.type == 'windows' then if os.rename(source, source..'.renamed') then source = source..'.renamed' end end if not os.rename(source, dest) then slice_file(source, dest) -- bails out on failure local ok, err_mess = os.remove(source) if not ok then warn('Failed to remove old ' .. source .. ': ' .. err_mess) end end end -- temporary files ---------------------------------------- -- tempdir = false -- will be created later and chdir-ed into -- tempfiles initialized early to empty table -- We just name our temporary files nn.<ext> with successive nn. -- We cannot exclude that another process uses our tempdir -- so we have to first check for each new file whether it already exists. -- Epspdf does all the real work from the temp directory. function mktemp(ext) local froot, fname, f, g for i=0,99 do froot = string.format('%02d.', i) fname = froot..ext if ext~='tex' then if not lfs.isfile(fname) then f = io.open(fname, 'wb') if not f then errror('Cannot create temporary file '..fname) end f:close() table.insert(tempfiles, fname) return froot..ext -- no need to record pdf name end else -- tex; we also need a pdf if not lfs.isfile(fname) and not lfs.isfile(froot..'pdf') then local f = io.open(fname, 'wb') if not f then errror('Cannot create temporary file '..fname) end f:close() table.insert(tempfiles, fname) fname = froot..'pdf' g = io.open(fname, 'wb') if not g then errror('Cannot create temporary file '..fname) end g:close() table.insert(tempfiles, fname) table.insert(tempfiles, froot..'log') return froot..ext -- no need to record pdf name end end -- if end -- for errror('Cannot create temporary file in '..tempdir) end function waitasec() -- stupid windows file locking; assume vista or later if os.type=='windows' then os.execute('timeout /t 1 /nobreak >nul') -- else do nothing end -- error checking pointless end function cleantemp() lfs.chdir(tempdir) if os.type=='windows' then waitasec() end for _,f in ipairs(tempfiles) do if lfs.isfile(f) then local success, mess = os.remove(f) if not success then write_log(mess) end end end local empty = true for f in lfs.dir('.') do if f ~= '.' and f ~= '..' then empty = false write_log('Temp dir '..tempdir..' contains '..f..' therefore not removed') break end end if os.type=='windows' then waitasec() end lfs.chdir('..') if empty then local res, mess res, mess = lfs.rmdir(tempdir) if not res then write_log('Failed to remove empty '..tempdir..'\n'..mess) end end end -- gs_epsdevice ----------------------- function gs_epsdevice() local gh = io.popen(gs_prog..' -help') local s = gh:read("*a") gh:close() if string.find(s,'eps2write') then return 'eps2write' elseif string.find(s,'epswrite') then return 'epswrite' else return false end end -- settings ----------------------- function write_settings (file) local f if file then f = io.open(file, 'wb') if not f then return end else -- stdout to be captured by epspdftk f = io.output() end for k, v in pairs(settings) do if descriptions[k] and file then f:write(eol, '# ', descriptions[k], eol) end f:write(k, ' = ', tostring(v), eol) end if file then f:close() end end function read_settings(file) -- read and interpret rcfile -- we shall ignore illegal entries. local contents local f if file then f = io.open(rcfile, 'rb') if not f then return end else f = io.input() end contents = f:read(10000) if file then f:close() end if not contents or contents=='' then return end -- remove initial \r and \n characters contents = string.gsub(contents, '^[\r\n]*', ''); -- gmatch chops contents into series of non-line-ending characters -- possibly followed by line-ending characters i.e. in lines local k, v, vl, vnum for l in string.gmatch(contents, '[^\r\n]+[\r\n]*') do l = string.match(l,'[^\r\n]*') if not string.match(l, '^#') then k, v = string.match(l, '^%s*([^%s]+)%s*=%s*(.*)$') if v then v = string.gsub(v,'%s*$', '') end -- now handle k and v if k == 'pdf_target' then -- ignore unless valid option if in_list(v, pdf_targets) then settings[k] = v end elseif k == 'pdf_version' then -- ignore unless valid option if in_list(v, pdf_versions) then settings[k] = v end elseif k == 'ignore_pdftops' then vl = string.lower(string.sub(v,1,1)) if v == 0 or vl == 'n' or vl == 'f' then settings.use_pdftops = true elseif v == 1 or vl == 'y' or vl == 't' then settings.use_pdftops = false end elseif k == 'use_pdftops' then vl = string.lower(string.sub(v,1,1)) if v == '0' or vl == 'n' or vl == 'f' then settings.use_pdftops = false elseif v == '1' or vl == 'y' or vl == 't' then settings.use_pdftops = true end -- final three settings not used by epspdf itself but -- passed along to epspdftk elseif k == 'ps_viewer' then settings.ps_viewer = v elseif k == 'pdf_viewer' then settings.pdf_viewer = v elseif k == 'default_dir' then settings.default_dir = v end -- test for k end -- not matching ^# end -- for end -- read settings function version_added() for _, v in pairs(pdf_options) do if string.find(v, '-dCompatibilityLevel') then return true end end return false end function maybe_add_version_parameter() if options.type=='pdf' and not options.bbox and settings.pdf_version and settings.pdf_version~='default' and not version_added() then table.insert(pdf_options, '-dCompatibilityLevel#'..settings.pdf_version) end end -- gui: reading and writing settings ----------- function gui(action) -- use stdin for reading settings from gui, and stdout for writing if action=='config_w' then -- called at start of epspdftk write_settings() -- to pipe epspdf => epspdftk os.exit() elseif action=='config_r' then read_settings() -- from 'pipe' epspdftk => epspdf write_settings(rcfile) os.exit() else from_gui = true end end -- boundingboxes --------------------------------------------------- -- [HR]Bb.coords names same as those of epdf PDFRectangle -- but the new pdfe simply uses an array Bb = {} Bb.coords = {'x1', 'y1', 'x2', 'y2'} function Bb:from_rect(r) -- also handle the case that r is a 4-element array: if not r.x1 then r.x1 = r[1] end if not r.y1 then r.y1 = r[2] end if not r.x2 then r.x2 = r[3] end if not r.y2 then r.y2 = r[4] end for _,k in ipairs(self.coords) do if not r[k] or type(r[k])~='number' then errror('from_rect called with illegal parameters') end -- sanity check on size -- FIXME: this limit is far too high if r[k]+.5==r[k] or r[k]-.5==r[k] then errror('Bb:from_rect: ' .. r[k] ..' greater than maxint') end local b = {} local eps = 0.000001 b.x1, b.x2 = math.floor(math.min(r.x1, r.x2) + eps), math.ceil(math.max(r.x1, r.x2) - eps) b.y1, b.y2 = math.floor(math.min(r.y1, r.y2) + eps), math.ceil(math.max(r.y1, r.y2) - eps) if b.x1==b.x2 or b.y1==b.y2 then errror('from_rect: width or height is zero') end setmetatable(b, {__index=self}) return b end end Bb.bb_pat = '^%s*%%%%BoundingBox:' Bb.bb_end = '^%s*%%%%BoundingBox:%s*%(%s*atend%s*%)' function Bb:from_comment(s) local p = self.bb_pat..'%s*([-+%d]+)'..string.rep('%s+([-+%d]+)',3) local b = {} b.x1, b.y1, b.x2, b.y2 = string.match(s, p) if not b.y2 then errror('Bb.from_comment: illegal boundingbox string ' .. s) end for _,k in ipairs(self.coords) do b[k] = tonumber(b[k]) end return Bb:from_rect(b) end function Bb:nonnegative () return self.x1>=0 and self.y1>=0 end function Bb:comment() -- if options.debug then print(debug.traceback()) end return string.format('%%%%BoundingBox: %d %d %d %d', self.x1, self.y1, self.x2, self.y2) end -- hires boundingboxes --------------------------------------------- HRBb = {} setmetatable(HRBb, {__index=Bb}) function HRBb:from_rect(r) -- also handle the case that r is a 4-element array: if not r.x1 then r.x1 = r[1] end if not r.y1 then r.y1 = r[2] end if not r.x2 then r.x2 = r[3] end if not r.y2 then r.y2 = r[4] end for _,k in ipairs(self.coords) do if not r[k] or type(r[k])~='number' then errror('from_rect called with illegal parameters') end -- sanity check on size if r[k]+.5==r[k] or r[k]-.5==r[k] then errror('HRBb:from_rect: ' .. b[k] ..' greater than maxint') end local b = {} b.x1, b.x2 = math.min(r.x1, r.x2), math.max(r.x1, r.x2) b.y1, b.y2 = math.min(r.y1, r.y2), math.max(r.y1, r.y2) if b.x1==b.x2 or b.y1==b.y2 then errror('from_rect: width or height is zero') end setmetatable(b, {__index=self}) return b end end HRBb.bb_pat = '^%s*%%%%HiResBoundingBox:' HRBb.bb_end = '^%s*%%%%HiResBoundingBox:%s*%(%s*atend%s*%)%s*$' function HRBb:from_comment(s) local p = self.bb_pat..'%s*([-+.%deE]+)'..string.rep('%s+([-+.%deE]+)',3) local b = {} b.x1, b.y1, b.x2, b.y2 = string.match(s, p) if not b.y2 then errror('HRBb.from_comment: illegal boundingbox string ' .. s) end for _,k in ipairs(self.coords) do b[k] = tonumber(b[k]) end return HRBb:from_rect(b) end function HRBb:nonnegative () return self.x1>=0 and self.y1>=0 end function HRBb:comment() return string.format('%%%%HiResBoundingBox: %f %f %f %f', self.x1, self.y1, self.x2, self.y2) end --[[ -- no longer used: gs handles this -- call this one also via pcall function HRBb:wrapper() -- local fn = mktemp('ps') -- local f = io.open(fn, 'wb') -- f.write(string.format('<< /PageSize [%f %f] >> setpagedevice\n', -- self.x2 - self.x1, self.y2 - self.y1)) -- f.write(string.format('gsave\n%f %f translate\n', -self.x1, -self.y1)) -- f:close() -- return fn return string.format( '<< /PageSize [%f %f] >> setpagedevice gsave %f %f translate', self.x2 - self.x1, self.y2 - self.y1, -self.x1, -self.y1) end --]] -- manipulating eps/ps/pdf files ----------------------------------- function identify() local f = io.open(infile, 'rb') if not f then errror('Failure to open '..infile..' for identification') end local filestart= f:read(23) f:close() if not filestart or filestart=='' then return false elseif string.match(filestart,'^\197\208\211\198') then -- c5 d0 d3 c6 return 'epsPreview' elseif string.match(filestart,'^%%!PS%-Adobe%-%d%.%d EPSF%-%d%.%d') then return 'eps' elseif string.match(filestart,'^%%!PS%-Adobe%-%d%.%d') then for _, p in ipairs({'.eps', '.epi', '.epsi', '.epsf'}) do if string.sub(string.lower(infile), -1-string.len(p),-1) == p then return 'eps' else return 'ps' end end return 'ps' elseif string.match(filestart, '^%%PDF') then return 'pdf' else return false end end -- identify function pdf_props(path) local pdfdoc, pgs, maver, miver if pdfe then pdfdoc = pdfe.open(path) if pdfdoc then pgs = pdfe.getnofpages(pdfdoc) maver, miver = pdfe.getversion(pdfdoc) end if not (pdfdoc and pgs and maver and miver) then errror('pdfe failed to get information about '..path) end pdfe.close(pdfdoc) else local cat pdfdoc = epdf.open(path) if pdfdoc then cat = pdfdoc:getCatalog() if cat then pgs = cat:getNumPages() end maver = pdfdoc:getPDFMajorVersion() miver = pdfdoc:getPDFMinorVersion() end if not (pdfdoc and pgs and maver and miver) then errror('epdf failed to get information about '..path) end -- epdf.close(pdfdoc) end -- if os.type=='windows' then waitasec() end if maver > 1 then print(path..' has pdf major version \n'..tostring(maver).. ' which is unsupported;\n'.. 'Continuing with fingers crossed...') end return pgs, miver, maver end -- pdf_props function info() local intype = identify() if not intype then print(infile..' has an unsupported filetype.') elseif intype~='pdf' then print(infile..' has type '..intype..'.') else local pgs, miver, maver = pdf_props(infile) print(infile..' has type pdf, version '..tostring(maver).. '.'..tostring(miver)..' and has '..tostring(pgs)..' pages.') end os.exit() end -- PsPdf object ------------------------------------------------- PsPdf = {} -- creators function PsPdf:new(ext) local psp = {} setmetatable(psp, {__index = self}) -- assign temp file psp.path = mktemp(string.lower(ext)) if string.lower(ext)=='pdf' then psp.type = 'pdf' elseif string.lower(ext)=='eps' then psp.type = 'eps' elseif string.lower(ext)=='ps' then psp.type = 'ps' else psp.type = false end if psp.type=='eps' then psp.pages = 1 end psp.bb = false psp.hrbb = false return psp end -- PsPdf:new function PsPdf:from_path(path) local psp = {} setmetatable(psp, {__index = self}) psp.path = path if lfs.isfile(path) then -- turn existing file into PsPdf object. psp.type = identify(psp.path) if psp.type=='pdf' then psp.pages, psp.miver, psp.maver = pdf_props(psp.path) end else errror('PsPdf:from_path called with non-existant file '..path) end if psp.type=='eps' then psp.pages = 1 end psp.bb = false psp.hrbb = false -- only calculate when needed return psp end -- PsPdf:from_path -- do we need to downgrade the pdf to a lower version? -- consider [e]ps lower than any pdf version function PsPdf:to_downgrade() if self.type~='pdf' then return false elseif options.type~='pdf' then return true elseif settings.pdf_version=='default' then return false elseif settings.pdf_version~='default' and self.maver+0.1*self.miver-0.001 > tonumber(settings.pdf_version) then -- -0.001: exact binary representation of pdf_version not guaranteed return true else return false end end --[[ getting boundingbox property from file itself -------------- get_bb_simple: use only for eps PsPdf objects we generated ourselves, so we can assume that the bbox comments are in the header and the hires bb lies within the lores bb. Of course the file itself is not rewritten. --]] function PsPdf:get_bb_simple() if self.type~='eps' then errror('get_bb_simple called with non-eps file '..self.path) end self.bb = false self.hrbb = false local slurp = false local f = io.open(self.path, 'rb') if f then slurp = f:read(bufsize) f:close() end lines = {} for l in string.gmatch(slurp, '[^\n\r]+') do if string.match(l, Bb.bb_pat) then self.bb = Bb:from_comment(l) elseif string.match(l, HRBb.bb_pat) then self.hrbb = HRBb:from_comment(l) elseif self.bb then break -- stop looking; we expect hrbb next to bb end if self.bb and self.hrbb then break end end if not self.bb then errror('No valid boundingbox for generated file' .. self.path) end return self -- no real need for a return value end function PsPdf:bb_from_gs() if self.type=='ps' then errror('bb_from_gs called with ps file '..self.path) -- not needed for generic PostScript, -- page selection only works with pdf files, so we save ourselves -- the trouble of picking the right bbox from a list end if self.type=='eps' and not self.bb:nonnegative() then errror('bb_from_gs called on ' .. self.path .. ' which has some negative boundingbox coordinates') -- any_to_any should guard against such an invocation end -- Since Ghostscript writes the boundingbox comments to stderr, -- we need a shell to intercept this output: local bb_file = mktemp('dsc') -- a somewhat low resolution parameter may help gs -- deal with eps files with large coordinates -- but this may impact the accuracy of the HRBb local cmdline if self.type=='eps' and (self.bb.x2 > 850 or self.bb.y2 > 850) then cmdline = gs_prog .. ' -r300 ' .. table.concat(gs_options,' ') else cmdline = gs_prog .. ' ' .. table.concat(gs_options,' ') end if self.type=='pdf' then pg = options.page or 1 cmdline = cmdline .. ' -dFirstPage#' .. tostring(pg) .. ' -dLastPage#' .. tostring(pg) end cmdline = cmdline .. ' -sDEVICE#bbox ' .. self.path .. ' 2>'..bb_file -- execute shell command local r, cmd write_log('os.execute: '..cmdline) r = os.execute(cmdline) if not r then errror('Cannot get fixed boundingbox for '..self.path) end -- read new bbox from ghostscript output -- can we really count on the plain bb coming first? -- OTOH, I would rather not introduce unnecessary complexity -- still, it may be better to match each line with [HR]Bb_pat local bb = false local hrbb = false local fin = io.open(bb_file, 'r') if fin then for i=1,10 do -- actually, 2 should suffice local l = fin:read("*line") if not l then break end if string.match(l, Bb.bb_pat) then bb = Bb:from_comment(l) end if string.match(l, HRBb.bb_pat) then hrbb = HRBb:from_comment(l) end end fin:close() end if not bb or not hrbb then errror('Cannot get fixed boundingbox for '..self.path) end return bb, hrbb end -- eps_clean: remove some problem features from eps (new file & object) function PsPdf:eps_clean() -- return a PsPdf object referring to a new file -- without a preview header and with boundingbox(es) in the header. -- return a new file even if no changes were needed. local function bytes2num (s, i) -- convert substring s[i..i+3] to a number. -- by working byte for byte we avoid endian issues local n = string.byte(s, i+3) for j=2,0,-1 do n = 256*n + string.byte(s, i+j) end return n -- somehow the explicit expression below didn't work -- return ((256 * (256 * (256 * string.byte(s,i+3)) + string.byte(s,i+2)) -- + string.byte(s,i+1)) + string.byte(s,i)) end if self.type~='eps' and self.type~='epsPreview' then errror('epsclean called with non-eps file ' .. self.path) end local offset, ps_length = false, false local fin, fout if self.type=='eps' then offset = 0 ps_length = lfs.attributes(self.path, 'size') else -- read TOC; see Adobe EPS specification -- interpret byte for byte, in case the platform is not little-endian fin = io.open(self.path, 'rb') if fin then local toc = fin:read(12) fin:close() if toc and string.len(toc)==12 then offset = bytes2num(toc, 5) ps_length = bytes2num(toc, 9) end end if not offset then errror('Could not read preview header of ' .. self.path) end end -- create the PsPdf object which is to be returned local psp psp = PsPdf:new('eps') -- read an initial and if necessary a final chunk of the file -- to find boundingbox comments. local atend = false local hr_atend = false local slurp -- the read buffer local l -- contains current scanned line; split off from slurp -- pre_lines: scanned header lines; alternately lines and eols local pre_lines = {} -- new_offset: offset plus combined length of scanned header lines local new_offset = offset -- post_lines: scanned trailer lines local post_lines = {} -- middle_length: ps_length minus scanned header- and and maybe trailer parts -- this is the length of file that will be copied wholesale. local middle_length local i, i_bb, i_hrbb local j, j_bb, j_hrbb, j_end -- j_end: index of final scanned trailer line -- no i_end necessary: for header lines we can use #pre_lines. fin = io.open(self.path, 'rb') if not fin then errror('Cannot read '..self.path) end fin:seek('set', offset) -- remaining, unscanned length of input buffer slurp local unscanned = math.min(ps_length,bufsize) slurp = fin:read(unscanned) -- unnecessary: psp.bb = nil psp.hrbb = nil i, i_bb, i_hrbb = 0, false, false while unscanned>0 do i = i+1 if string.find(slurp,'[\n\r]')==1 then l,slurp = string.match(slurp, '^([\n\r]+)(.*)$') else l,slurp = string.match(slurp, '^([^\n\r]+)(.*)$') if string.match(l, Bb.bb_end) then atend = true i_bb = i elseif string.match(l, Bb.bb_pat) then psp.bb = Bb:from_comment(l) -- from_comment errors out on failure; no need to check return value i_bb = i elseif string.match(l, HRBb.bb_end) then hr_atend = true i_hrbb = i elseif string.match(l, HRBb.bb_pat) then psp.hrbb = HRBb:from_comment(l) i_hrbb = i end -- bbox line end -- eol/non-eol pre_lines[i] = l unscanned = unscanned - string.len(l) if (i_bb and (i_hrbb or (i_bb<(i-1)))) or unscanned<=0 then -- condition i_bb<i-1: -- We do not want to find the hrbb of an included eps. -- Therefore we stop looking for hrbb if it is not next to bb -- (with an intervening eol) -- Note that the header comments are not necessarily terminated -- with a %%EndComments line; see Adobe DSC spec 5001 break end -- deciding whether to stop end -- while new_offset = offset + string.len(table.concat(pre_lines)) middle_length = ps_length - string.len(table.concat(pre_lines)) if atend or hr_atend then -- find boundingbox comments, starting from end of postscript if ps_length>bufsize then fin:seek('set',offset+ps_length-bufsize) unscanned = bufsize slurp = fin:read(unscanned) else -- use what is left from old slurp unscanned = string.len(slurp) end j = 1 -- count down from 0 j_bb, j_hrbb, j_end = false, false, false while unscanned>0 do j = j - 1 if string.find(slurp,'[\n\r]', string.len(slurp)) then slurp,l = string.match(slurp, '^(.-)([\n\r]+)$') -- '-': non-greedy matching else slurp,l = string.match(slurp, '^(.-)([^\n\r]+)$') if string.match(l, Bb.bb_pat) then psp.bb = Bb:from_comment(l) j_bb = j elseif string.match(l, HRBb.bb_pat) then psp.hrbb = HRBb:from_comment(l) j_hrbb = j end -- bbox line end -- eol/non-eol post_lines[j] = l unscanned = unscanned - string.len(l) if (psp.bb and (psp.hrbb or not hr_atend or j_bb>(j+1))) or unscanned<=0 then -- stop looking j_end = j break end -- deciding whether to stop end -- while middle_length = middle_length - string.len(table.concat(post_lines, '', j_end, 0)) end --if atend fin:close() -- fix boundingbox lines if atend and j_bb then -- pre_lines[i_bb] = post_lines[j_bb] pre_lines[i_bb] = psp.bb:comment() -- WHY DOESNT THIS WORK ???? post_lines[j_bb] = '' post_lines[j_bb+1] = '' end if hr_atend and j_hrbb then -- pre_lines[i_hrbb] = post_lines[j_hrbb] pre_lines[i_hrbb] = psp.hrbb:comment() post_lines[j_hrbb] = '' post_lines[j_hrbb+1] = '' end -- create cleaned eps file fout = io.open(psp.path, 'wb') if not fout then errror('Cannot create new file '..psp.path) end fout:write(table.concat(pre_lines)) fout:close() slice_file(self.path, psp.path, middle_length, new_offset, 'ab') fout = io.open(psp.path, 'ab') fout:write(table.concat(post_lines, '', j_end, 0)) fout:close() return psp end -- eps_clean -- tight boundingbox (new file & object) function PsPdf:eps_crop() -- conversion is not done by an external program, although -- we invoke Ghostscript with a bbox device for a tight boundingbox. -- We use both the regular and the hires boundingbox from gs. -- The eps should already have been cleaned up by eps_clean, -- and the current boundingbox should not contain negative coordinates, -- otherwise the bbox output device may give incorrect results. -- Only the boundingbox in the eps is rewritten. -- create the PsPdf object which is to be returned local psp = PsPdf:new('eps') -- read new bbox from ghostscript output psp.bb, psp.hrbb = self:bb_from_gs() -- rewrite header with new boundingboxes local slurp -- the read buffer local l -- contains current scanned line; split off from slurp -- pre_lines: scanned header lines; alternately lines and eols local pre_lines = {} -- offset: combined length of scanned header lines local offset = 0 local ps_length = lfs.attributes(self.path, 'size') local i, i_bb, i_hrbb fin = io.open(self.path, 'rb') if not fin then errror('Cannot read '..self.path) end -- remaining, unscanned length of input buffer slurp local unscanned = math.min(ps_length,bufsize) slurp = fin:read(unscanned) i, i_bb, i_hrbb = 0, false, false while unscanned>0 do i = i+1 if string.find(slurp,'[\n\r]')==1 then l,slurp = string.match(slurp, '^([\n\r]+)(.*)$') else l,slurp = string.match(slurp, '^([^\n\r]+)(.*)$') if string.match(l, Bb.bb_pat) then i_bb = i elseif string.match(l, HRBb.bb_pat) then i_hrbb = i end -- bbox line end -- eol/non-eol pre_lines[i] = l unscanned = unscanned - string.len(l) if (i_bb and (i_hrbb or (i_bb<(i-1)))) or unscanned<=0 then break end end -- while fin:close() offset = string.len(table.concat(pre_lines)) if i_hrbb then pre_lines[i_bb] = psp.bb:comment() pre_lines[i_hrbb] = psp.hrbb:comment() else -- jam both bbox comments into one slot, with an intervening eol. -- for the sake of conformity, we copy an existing eol. pre_lines[i_bb] = psp.bb:comment() .. pre_lines[i_bb-1] .. psp.hrbb:comment() end -- write a new eps file fout = io.open(psp.path, 'wb') if not fout then errror('Cannot write new file '.. psp.path) end fout:write(table.concat(pre_lines)) fout:close() slice_file(self.path, psp.path, lfs.attributes(self.path,'size') - offset, offset, 'ab') options.bbox = false return psp end -- eps_crop --[[ most of these conversions involve a single invocation of gs, pdftops or texlua Each conversion fullfills all options that it can: gray, bbox and page. gray when converting to pdf, bbox when converting from eps or from pdf to pdf and page when converting from pdf. It then sets the fullfilled option(s) to false. We make sure to do the tight boundingbox before a file format downgrade: rasterization of the page or graphic frustrates boundingbox calculation. We like to preserve fonts as fonts. gs does this when generating pdf, but may fail for fonts such as cid and large truetype when generating PostScript. In such cases, pdftops may succeed. However, it seems that if the page contains an element that does not cleanly convert, pdftops simply rasterizes the entire page, and that this choice is made per page. --]] -- Converting from pdf to pdf using luatex; no grayscaling here function PsPdf:getpgbox() if options.page and options.page > self.pages then errror('PsPdf:getpgbox called with non-existent page '.. options.page) end local pg = options.page or 1 local bb, hrbb, pgbox, pdfdoc, ppage if pdfe then pdfdoc = pdfe.open(self.path) if pdfdoc then ppage = pdfe.getpage(pdfdoc, pg) if not ppage then errror('did not get page') end if ppage then pgbox = pdfe.getbox(ppage, 'MediaBox') if not pgbox then pgbox = pdfe.getbox(ppage, 'CropBox') if not pgbox then pgbox = pdfe.getbox(ppage, 'TrimBox') if not pgbox then errror('No box acquired') end end end end end pdfe.close(pdfdoc) else local cat pdfdoc = epdf.open(self.path) if pdfdoc then cat = pdfdoc:getCatalog() if cat then ppage = cat:getPage(pg) if ppage then pgbox = ppage:getMediaBox() if not pgbox then pgbox = ppage:getCropBox() if not pgbox then pgbox = ppage:getTrimBox() end end end end end end -- normalization and further checks, including for non-nil, -- by HRBb:from_rect, which errors out on failures if pgbox then pgbox = HRBb:from_rect(pgbox) -- this also converts numeric array indices to x1 ... y2 if necessary else errror('Cannot get page box from '..self.path..' page '..pg) end return pgbox end -- PsPdf:getpgbox function PsPdf:pdf_crop() -- options to be fulfilled: page, boundingbox if possible -- embeds the pdf with boundingbox parameters into a new (lua)tex document if options.page and options.page > self.pages then errror('PsPdf:pdf_crop called with non-existent page '.. options.page) end local bb, hrbb, pgbox pgbox = self:getpgbox() if options.bbox and pgbox:nonnegative() then bb, hrbb = self:bb_from_gs() options.bbox = false else hrbb = pgbox end -- luatex is on searchpath local luatex_prog = 'luatex' -- write TeX file which includes cropped pdf page -- adapted from Heiko Oberdiek's pdfcrop utility. -- the table `pieces' will contain the component strings for the tex source -- first, for texlua <= 0.81 local pieces = {} if status.luatex_version <= 80 then pieces[1] = '\\pdfoutput=1\n' else pieces[1] = [[ \edef\pdfminorversion {\pdfvariable minorversion} \edef\pdfcompresslevel {\pdfvariable compresslevel} \edef\pdfobjcompresslevel {\pdfvariable objcompresslevel} \edef\pdfdecimaldigits {\pdfvariable decimaldigits} \edef\pdfhorigin {\pdfvariable horigin} \edef\pdfvorigin {\pdfvariable vorigin} \let\pdfpagewidth\pagewidth \let\pdfpageheight\pageheight \let\pdfximage\saveimageresource \let\pdfrefximage\useimageresource \let\pdflastximage\lastsavedimageresourceindex \outputmode=1 ]] end if self.maver > 1 then pieces[2] = '\\pdfminorversion=9\n' else pieces[2] = '\\pdfminorversion=' .. self.miver .. '\n' end if self.maver > 1 or self.miver > 4 then pieces[3] = [[ \pdfcompresslevel=9 \pdfobjcompresslevel=2 \pdfdecimaldigits=4 ]] else pieces[3] = [[ \pdfcompresslevel=9 \pdfobjcompresslevel=0 \pdfdecimaldigits=4 ]] end pieces[4] = [[ \def\page #1 [#2 #3 #4 #5]{% \count0=#1\relax \setbox0=\hbox{% \pdfximage page #1 mediabox{]] pieces[5] = self.path pieces[6] = [[}% \pdfrefximage\pdflastximage }% \pdfhorigin=#2bp\relax \pdfvorigin=#3bp\relax \pagewidth=#4bp\relax \pageheight=#5bp\relax \ht0=\pageheight \shipout\box0\relax } ]] pieces[7] = string.format([[ \page %d [%f %f %f %f] \csname @@end\endcsname \end ]], options.page or 1, -hrbb.x1, hrbb.y1, hrbb.x2-hrbb.x1, hrbb.y2-hrbb.y1) local textemp = mktemp('tex') -- this also took care of pdf: local pdftemp = string.gsub(textemp, 'tex$', 'pdf') -- if os.type=='windows' then waitasec() end local f = io.open(textemp, 'w') -- if os.type=='windows' then waitasec() end f:write(table.concat(pieces, '')) f:close() local cmd, res, psp -- if os.type=='unix' then cmd = {luatex_prog, '--safer', '--no-shell-escape', textemp} log_cmd(cmd) res = spawnexec(cmd) if res and res==0 and lfs.attributes(pdftemp, 'size')>0 then psp = PsPdf:from_path(pdftemp) options.bbox = false options.page = false return psp else errror('pdf_crop failed on '..self.path) end end function PsPdf:eps_to_pdf() -- option to be fulfilled: gray -- set target and maybe pdf version if applicable if self.type~='eps' then errror('PsPdf:eps_to_pdf called for non-eps file '.. self.path) end local cmd maybe_add_version_parameter() cmd = tab_combine({{gs_prog}, gs_options, pdf_options}) if options.gray then cmd = tab_combine({cmd, gray_options}) end table.insert(cmd, '-dEPSCrop') -- uses existing hires bb local psp = PsPdf:new('pdf') table.insert(cmd, '-sOutputFile#'..psp.path) cmd = tab_combine({cmd, pdf_tail_options}) table.insert(cmd, self.path) log_cmd(cmd) local res = spawnexec(cmd) if res and res==0 and lfs.attributes(psp.path, 'size')>0 then psp.pages, psp.miver, psp.maver = pdf_props(psp.path) options.gray = false return psp else errror('eps_to_pdf failed on '..self.path) end end -- eps_to_pdf -- Converting from pdf to pdf with grayscaling and/or page selection -- or just eliminating negative boundingbox function PsPdf:pdf_to_pdf() -- option to be fulfilled: gray, optionally page -- side effect: makes bbox non-negative. -- do not call this just for page selection because -- pdf_crop can do this in a less invasive manner if self.type~='pdf' then errror('PsPdf:pdf_to_pdf called for non-pdf file '.. self.path) end local cmd if options.page and options.page > self.pages then errror('PsPdf:pdf_to_pdf called with non-existent page '.. options.page) end cmd = tab_combine({{gs_prog}, gs_options, pdf_options}) if options.gray then cmd = tab_combine({cmd, gray_options}) end if options.page then table.insert(cmd, '-dFirstPage#'..tostring(options.page)) table.insert(cmd, '-dLastPage#'..tostring(options.page)) end maybe_add_version_parameter() local psp = PsPdf:new('pdf') table.insert(cmd, '-sOutputFile#'..psp.path) cmd = tab_combine({cmd, pdf_tail_options}) table.insert(cmd, self.path) log_cmd(cmd) local res = spawnexec(cmd) if res and res==0 and lfs.attributes(psp.path, 'size')>0 then psp.pages, psp.miver, psp.maver = pdf_props(psp.path) options.gray = false options.page = false return psp else errror('pdf_to_pdf failed on '..self.path) end end -- pdf_to_pdf function PsPdf:pdf_to_eps() -- options to be fulfilled: page local psp = PsPdf:new('eps') local cmd, res -- any_to_any already checked the validity and relevance of options.page if pdftops then if options.page then cmd = tab_combine({{pdftops}, ps_options, {'-f', options.page, '-l', options.page, '-eps', self.path, psp.path}}) else cmd = tab_combine({{pdftops}, ps_options, {'-eps', self.path, psp.path}}) end log_cmd(cmd) if os.type=='windows' then -- suppress console output of 'No display font for...' messages, -- which are usually harmless and for which I know no easy fix -- pdftops -q does not do the trick on Windows, -- and redirection to logfile gives access denied under miktex res = os.execute(table.concat(cmd, ' ')..' 2>nul') else res = spawnexec(cmd) end if res and res==0 and lfs.attributes(psp.path, 'size')>0 then psp.pages = 1 options.page = false else errror('pdf_to_eps failed on '..self.path) end -- fix for incorrect DSC header produced by some versions of pdftops: -- if necessary, change line `% Produced by ...' into `%%Produced by ...' -- this is usually the second line. -- otherwise the DSC header would be terminated before the bbox comment. -- this problem exists with pdftops from TL2011/w32. local slurp -- input buffer local fin = io.open(psp.path, 'rb') if not fin then errror('Cannot read '..psp.path) end -- remaining, unscanned length of input buffer slurp local unscanned = math.min(lfs.attributes(psp.path, 'size'),bufsize) slurp = fin:read(unscanned) local i, i_bb = 0, false local needs_fixing = false local pre_lines = {} local offset = 0 while unscanned>0 do i = i+1 if string.find(slurp,'[\n\r]')==1 then l,slurp = string.match(slurp, '^([\n\r]+)(.*)$') else l,slurp = string.match(slurp, '^([^\n\r]+)(.*)$') if string.match(l, Bb.bb_pat) then -- bbox line i_bb = i elseif string.match(l, '^%%%s') then -- `%' is escape char: doubled -- %X with X printable would be ok needs_fixing = true -- fix rightaway l = string.gsub(l, '^%%%s', '%%%%') -- same length end end -- eol/non-eol pre_lines[i] = l unscanned = unscanned - string.len(l) offset = offset + string.len(l) if i_bb then break end end -- while fin:close() if needs_fixing then -- write a new eps file local newfile = mktemp('eps') fout = io.open(newfile, 'wb') if not fout then errror('Cannot write new file '.. newfile) end fout:write(table.concat(pre_lines)) fout:close() slice_file(psp.path, newfile, lfs.attributes(psp.path,'size') - offset, offset, 'ab') psp.path = newfile end -- needs_fixing else -- use ghostscript local epsdev = gs_epsdevice() if not epsdev then errror('Conversion to eps not supported by this ghostscript') end cmd = tab_combine({{gs_prog}, gs_options, {'-sDEVICE#'..epsdev, '-dHaveTrueTypes=true', '-dLanguageLevel#3'}}) if options.gray then cmd = tab_combine({cmd, gray_options}) end if options.page then table.insert(cmd, '-dFirstPage='..options.page) table.insert(cmd, '-dLastPage='..options.page) end table.insert(cmd, '-sOutputFile='..psp.path) table.insert(cmd, self.path) log_cmd(cmd) res = spawnexec(cmd) if res and res==0 and lfs.attributes(psp.path, 'size')>0 then psp.pages = 1 options.page = false options.gray = false else errror('pdf_to_eps failed on '..self.path) end end -- use ghostscript psp:get_bb_simple() return psp end -- pdf_to_eps function PsPdf:ps_to_pdf() -- options to be fulfilled: gray if self.type~='ps' then errror('PsPdf:ps_to_pdf called for non-ps file '.. self.path) end local cmd cmd = tab_combine({{gs_prog}, gs_options, pdf_options}) if options.gray then cmd = tab_combine({cmd, gray_options}) end local psp = PsPdf:new('pdf') table.insert(cmd, '-sOutputFile#'..psp.path) cmd = tab_combine({cmd, pdf_tail_options}) table.insert(cmd, self.path) log_cmd(cmd) local res = spawnexec(cmd) if res and res==0 and lfs.attributes(psp.path, 'size')>0 then psp.pages, psp.miver, psp.maver = pdf_props(psp.path) options.gray = false return psp else errror('ps_to_pdf failed on '..self.path) end end -- PsPdf:ps_to_pdf function PsPdf:pdf_to_ps() -- options to be fulfilled: page and, if not using pdftops, also gray local psp = PsPdf:new('ps') -- options.page checked by any_to_any psp.pages = self.pages local cmd, res if pdftops then cmd = tab_combine({{pdftops}, ps_options}) if options.page then cmd = tab_combine({cmd, {'-f', options.page, '-l', options.page}}) end cmd = tab_combine({cmd, {'-paper', 'match', self.path, psp.path}}) else -- use ghostscript cmd = tab_combine({{gs_prog}, gs_options, {'-sDEVICE#ps2write', '-dHaveTrueTypes=true', '-dLanguageLevel#3'}}) if options.gray then cmd = tab_combine({cmd, gray_options}) end if options.page then cmd = tab_combine({cmd, {'-dFirstPage#'..options.page, '-dLastPage#'..options.page}}) end table.insert(cmd, '-sOutputFile#'..psp.path) table.insert(cmd, self.path) end log_cmd(cmd) if os.type=='windows' and pdftops then -- suppress console output of 'No display font for...' messages, -- which are usually harmless and for which I know no easy fix -- pdftops -q does not do the trick on Windows, -- and redirection to logfile gives access denied under miktex res = os.execute(table.concat(cmd, ' ')..' 2>nul') else res = spawnexec(cmd) end if res and res==0 and lfs.attributes(psp.path, 'size')>0 then options.page = false -- gs will have grayscaled if requested but pdftops will not if not pdftops then options.gray = false end return psp else errror('pdf_to_ps failed on '..self.path) end end -- PsPdf:pdf_to_ps function PsPdf:ps_to_ps() -- we do not accept a page option since we do not know -- which pages are available. -- if no gray option then there is no point in invoking this function. local psp = PsPdf:new('ps') local cmd = tab_combine({{gs_prog}, gs_options, {'-sDEVICE#ps2write', '-dHaveTrueTypes=true', '-dLanguageLevel#3'}}) if options.gray then cmd = tab_combine({cmd, gray_options}) end table.insert(cmd, '-sOutputFile#'..psp.path) table.insert(cmd, self.path) log_cmd(cmd) local res = spawnexec(cmd) if res and res==0 and lfs.attributes(psp.path, 'size')>0 then options.gray = false return psp else errror('ps_to_ps failed on '..self.path) end end -- PsPdf:ps_to_ps function any_to_any() local psp = PsPdf:from_path(infile) -- sanitize some options if options.type=='ps' then options.bbox = false end if (options.bbox or options.type=='eps') and not options.page then options.page = 1 end if psp.type=='pdf' then if options.page then local pgs = pdf_props(infile) if pgs<options.page then errror(infile..' has only '..pgs..' page(s).') elseif pgs==1 then options.page = false end end elseif psp.type=='eps' then options.page = false end -- psp.type=='ps': pages not yet known but maybe not needed local do_something = false if psp.type=='eps' then do_something = true -- do at least cleanup elseif psp.type~=options.type then do_something = true elseif options.page then do_something = true elseif options.bbox then do_something = true elseif options.gray then do_something = true elseif options.type=='pdf' then if psp:to_downgrade() then do_something = true elseif settings.pdf_target and settings.pdf_target~=default then do_something = true end end if not do_something then if infile~=outfile then slice_file(infile, outfile) end return true end -- `distiller' settings -- these depend on whether final output is pdf if options.type=='pdf' then if settings.pdf_target and (settings.pdf_target~='default') then table.insert(pdf_options, '-dPDFSETTINGS#/'..settings.pdf_target) end if not is_miktex then -- options below cause trouble with unpacked cmd table if settings.pdf_target~='screen' and settings.pdf_target~='ebook' then pdf_tail_options = { '-c', '<</NeverEmbed [ ] >> setdistillerparams', '-f'} end end end --[[ Actual conversions each single-step conversion takes care of options it can handle and sets those options to false. Cropping a pdf is best be done before converting to postscript or a low (<1.4) pdf version. all invocations of external programs work on temporary files in the then-current temporary directory, with a simple generated filename. So no need to quote names of input- or output filenames. --]] local newfile if psp.type=='eps' or psp.type=='epsPreview' then -- As a side effect of eps_clean, the modified or unmodified source file -- is copied to our temp subdirectory. -- We always create a new file. psp = psp:eps_clean() if options.bbox and psp.bb:nonnegative() then psp = psp:eps_crop() end if options.type=='eps' then if options.gray or options.bbox then -- bbox: eps_crop was apparently not applicable: pdf roundtrip psp = psp:eps_to_pdf() if options.bbox then psp = psp:pdf_crop() end psp = psp:pdf_to_eps() end elseif options.type=='pdf' then psp = psp:eps_to_pdf() if options.bbox then psp = psp:pdf_crop() end if psp:to_downgrade() then maybe_add_version_parameter() psp = psp:pdf_to_pdf() end elseif options.type=='ps' then -- often, the eps file is fine as a postscript file. -- however, it may lack a showpage operator, or have a weird -- boundingbox. converting back-and-forth to pdf solves both problems. -- eps_to_pdf will take care of grayscaling -- a tight boundingbox option is not supported for ps output. psp = psp:eps_to_pdf():pdf_to_ps() end slice_file(psp.path, outfile) return true elseif psp.type=='ps' then -- preliminary: -- copy infile to a file in the temp directory, needed for gs -dSAFER newfile = mktemp(psp.type) slice_file(psp.path, newfile) psp.path = newfile if options.type=='ps' and not options.page then psp = psp:ps_to_ps() slice_file(psp.path, outfile) return true end -- remaining options require initial conversion to pdf psp = psp:ps_to_pdf() -- AFAIK, all high-level ps constructs are covered by any pdf version -- so this option should not cause unnecessary loss of structure maybe_add_version_parameter() if options.page and options.page>1 then -- could not check page option before local pgs = pdf_props(psp.path) if pgs<options.page then errror(infile..' has only '..pgs..' page(s).') elseif pgs==1 then options.page = false end end -- actual conversion if options.type=='eps' then if options.bbox then psp = psp:pdf_crop() end psp = psp:pdf_to_eps() elseif options.type=='pdf' then if options.bbox or options.page then psp = psp:pdf_crop() -- else no action needed end elseif options.type=='ps' then psp = psp:pdf_to_ps() end -- pdf => ps slice_file(psp.path, outfile) return true elseif psp.type=='pdf' then if options.type=='pdf' and settings.pdf_target=='default' and not options.gray and not options.bbox and not options.page and not psp:to_downgrade() then if infile~=outfile then slice_file(infile, outfile) end return true end -- preliminary: -- copy infile to a file in the temp directory, needed for gs -dSAFER newfile = mktemp(psp.type) slice_file(psp.path, newfile) psp = PsPdf:from_path(newfile) local pgbox -- actual conversion if options.type=='eps' then if options.bbox then pgbox = psp:getpgbox() -- page n. available from options table if not pgbox:nonnegative() or options.gray then -- fix in extra pdf-to-pdf step psp = psp:pdf_to_pdf() end -- we want to calculate a tight boundingbox before conversion to eps, -- because this conversion may cause rasterization and baffle -- gs' boundingbox calculations psp = psp:pdf_crop() elseif options.gray and pdftops then psp = psp:pdf_to_pdf() end psp = psp:pdf_to_eps() elseif options.type=='pdf' then -- pdf_crop can take care of bbox and page, -- but not of gray and not of some pdf options if options.bbox then pgbox = psp:getpgbox() if not pgbox:nonnegative() then -- pdf_to_pdf fixes negative bbox parameters -- and also takes care of page and gray psp = psp:pdf_to_pdf() end psp = psp:pdf_crop() end need_gs = false if psp:to_downgrade() then need_gs = true maybe_add_version_parameter() end if settings.pdf_target~='default' then need_gs = true end if options.gray then need_gs = true end if (not need_gs) and options.page then psp = psp:pdf_crop() -- less invasive than page selection by gs end if need_gs then psp = psp:pdf_to_pdf() -- will handle page selection too end elseif options.type=='ps' then if options.gray and pdftops then psp = psp:pdf_to_pdf():pdf_to_ps() else psp = psp:pdf_to_ps() end end -- pdf => ps slice_file(psp.path, outfile) return true end end -- any_to_any -- system-dependent initialization ----------------------------------- -- current directory, at program start cwd = lfs.currentdir() if os.type == 'windows' then cwd = string.gsub(cwd, '\\', '/') end -- child searchpath initially set to parent searchpath -- childpath = os.getenv('PATH') -- prepend (lua)tex directory to searchpath, if not already there maybe_add_path(os.selfdir, false) -- Windows: miktex, TL or neither. is_miktex, is_tl_w32 -- no support yet for separate ghostscript is_miktex = false is_tl_w32 = false if os.type == 'windows' then if string.find (string.lower(kpse.version()), 'miktex') then is_miktex = true else local rt = string.gsub(os.selfdir,'[\\/][^\\/]+[\\/][^\\/]+$', '') if not rt then errror('Unrecognized TeX directory structure', 0) elseif lfs.isfile(rt..'/release-texlive.txt') then --[[ -- TL version is easy to determine but is not needed local fin = io:open(rt..'release-texlive.txt', 'r') if fin then local l = fin:read('*line') tl_ver = string.match(l, 'version%s+(%d+)$') if tl_ver then tl_ver = tonumber(tl_ver) end end -- if fin --]] is_tl_w32 = true else errror('Not MikTeX and no file ' .. rt .. '/release-texlive.txt; TeX installation not supported.', 0) end -- if isfile end -- if not miktex end -- if windows -- without Ghostscript we are dead in the water. gs_prog = false do local rt='' if os.type == 'unix' then if find_on_path('gs') then gs_prog = 'gs' else error('No ghostscript on searchpath!', 0) end elseif is_miktex then gs_prog = 'mgs.exe' -- neither MiKTeX's nor TL's ghostscript need GS_LIB to be set elseif is_tl_w32 then -- windows/TeX Live -- grandparent of texlua.exe directory .. ... -- rt = string.gsub(os.selfdir,'[\\/][^\\/]+[\\/][^\\/]+$', '') -- ..'/tlpkg/tlgs' -- maybe_add_path(rt..'/bin', false) -- -- gs_prog = 'gswin32c.exe' -- ---[[ problems with (at least) grayscaling gs_prog = 'rungs.exe' --]] else errror('Only TeX Live and MikTeX supported!', 0) end end -- do -- directory for configuration and log epsdir = '' if os.type == 'windows' then epsdir = fw(os.getenv('APPDATA')) .. '/epspdf' else epsdir = os.getenv('HOME')..'/.epspdf' end rcfile = epsdir .. '/config' logfile = epsdir .. '/epspdf.log' -- create epsdir if necessary if lfs.isfile(epsdir) then error('Cannot continue; epspdf directory ' .. epsdir .. ' is a file') elseif not lfs.isdir(epsdir) then if not lfs.mkdir(epsdir) then error('Failed to create epspdf directory ' .. epsdir) end end -- start logging --------------------------------- -- log rotate if logfile too big if lfs.attributes(logfile) and lfs.attributes(logfile).size > 100000 then local oldlog = logfile .. '.old' if lfs.attributes(oldlog) then if os.remove(oldlog) then os.rename(logfile,oldlog) end elseif lfs.attributes(logfile) then do -- separate epsdir runs with empty lines print_log('\n\nNew run') end end -- do elseif end -- if lfs...logfile write_log('epspdf '..table.concat(arg, ' ')) --[[ settings, initial values priority, from low to high: - built-in defaults - settings read from and written to the configuration file - command-line options, defined in the opts table The options- and settings tables are initialized from built-in defaults. We go for false rather than undefined, because this results in an actual settings- or options entry. Command-line options are copied to either options or settings. We ignore illegal settings in the config file. --]] pdf_targets = {'screen', 'ebook', 'printer', 'prepress', 'default'} pdf_versions = {'1.2', '1.3', '1.4', '1.5', '1.6', '1.7', 'default'} -- ghostscript will substitute higher versions with -- the highest-supported version settings = {} descriptions = {} settings.pdf_target = 'default' descriptions.pdf_target = 'One of ' .. join(pdf_targets, ', ', ' or ') settings.pdf_version = 'default' descriptions.pdf_version = 'One of ' .. join(pdf_versions, ', ', ' or ') settings.use_pdftops = true descriptions.use_pdftops = 'Use pdftops if available' -- epspdf stores ps- and pdf viewer settings on behalf of the gui interface -- but does not use them itself. -- They will not be used at all under macos or windows. settings.ps_viewer = false descriptions.ps_viewer = 'Epspdftk: viewer for PostScript files; not used on Windows or Mac OS' settings.pdf_viewer = false descriptions.pdf_viewer = 'Epspdftk: viewer for pdf files; not used on Windows or Mac OS' -- default_dir, which is used on all platforms, is only for the gui. if os.type == 'windows' then settings.default_dir = string.gsub(os.getenv('USERPROFILE'), '\\', '/') else settings.default_dir = os.getenv('HOME') end descriptions.default_dir = 'Epspdftk: initial directory; ignored by epspdf itself' -- options ------------------------------------- -- besides settings, which can be saved, we also use options which are not. -- these are mostly conversion options. options = {} options.page = false options.gray = false options.bbox = false options.debug = false options.type = false -- implied via output filename on command line -- command-line fragments for conversions -------------------- -- We could make these `class attributes' for PsPdf but to what purpose? -- For Windows shell commands, we need to substitute `#' for `=' -- when invoking Ghostscript. For simplicity, we do this across the board. -- -P- : do not look first in current directory gs_options = {'-q', '-dNOPAUSE', '-dBATCH', '-P-', '-dSAFER'} -- may add custom options later pdf_options = {'-sDEVICE#pdfwrite'} -- '-dUseCIEColor' causes serious slowdown -- options for final conversion to pdf; -- will be completed after reading settings and options -- -f ensures that the input filename is not added to a -c string pdf_tail_options = {'-f'} gray_options = {'-dProcessColorModel#/DeviceGray', '-sColorConversionStrategy#Gray'} pdftops = false -- gets a value only if we are going to use pdftops ps_options = {'-level3'} -- `main program' inside scope-creating block ---------------------- do -- main program local in_dir = false -- directory of infile local out_dir = false -- directory of outfile do -- Handle settings and command-line inside nested scope -------------- read_settings(rcfile) local opts = {} opts.page = { type = 'string', val = nil, forms = {'-p', '--page', '--pagenumber'}, placeholder = 'PNUM', negforms = nil, help = 'Page number; must be a positive integer' } opts.gray = { type = 'boolean', val = nil, forms = {'-g', '--grey', '--gray', '-G', '--GREY', '--GRAY'}, negforms = nil, help = 'Convert to grayscale' } opts.bbox = { type = 'boolean', val = nil, forms = {'-b', '--bbox', '--BoundingBox'}, negforms = nil, help = 'Compute tight boundingbox' } ---[[ ignored; included for backward compatibility opts.use_hires_bb = { type = 'boolean', val = nil, forms = {'-r', '--hires'}, negforms = {'-n', '--no-hires'}, } opts.custom = { type = 'string', val = nil, forms = {'-C', '--custom', '-P', '--psoptions'}, negforms = nil } --]] opts.pdf_target = { type = 'string', val = nil, forms = {'-T', '--target'}, placeholder = 'TARGET', negforms = nil, help = descriptions.pdf_target } opts.pdf_version = { type = 'string', val = nil, forms = {'-N', '--pdfversion'}, placeholder = 'VERSION', negforms = nil, help = descriptions.pdf_version } opts.use_pdftops = { type = 'boolean', val = nil, forms = {'-U'}, negforms = {'-I'}, help = descriptions.use_pdftops } opts.info = { type = 'boolean', val = nil, forms = {'-i', '--info'}, negforms = nil, help = 'Info: display detected filetype and exit' } opts.help = { type = 'boolean', val = nil, forms = {'-h', '--help'}, negforms = nil, help = 'Display this help message and exit' } opts.version = { type = 'boolean', val = nil, forms = {'-v', '--version'}, negforms = nil, help = 'Display version info and exit' } opts.save = { type = 'boolean', val = nil, forms = {'-s', '--save'}, negforms = nil, help = 'Save some settings to configuration file' } opts.debug = { type = 'boolean', val = nil, forms = {'-d'}, negforms = nil, help = 'Debug: do not remove temp files' } opts.gui = { type = 'string', val = nil, forms = {'--gui'}, negforms = nil, help = nil -- reserved for use by epspdftk } -- a couple of functions only available during command-line parsing local function show_version () print('Epspdf version 0.6.5.1\nCopyright (c) 2006-2023 Siep Kroonenberg') end local function help (mess) -- requires opts array if mess then print(mess..eol) end show_version() -- below, string.gsub unindents its long-string parameter. -- string.format removes the second return value of string.gsub. print( -- string.format('%s', string.gsub([[ Convert between [e]ps and pdf formats Usage: epspdf[.tlu] [options] infile [outfile] Default for outfile is file.pdf if infile is file.eps or file.ps Default for outfile is file.eps if infile is file.pdf ]], '([\r\n]+) ', '%1')) --) -- need to enforce an ordering, otherwise we could have used pairs(opts) -- omitted below: no-op options -- one line where possible local indent_n = 12 local intent_sp = string.rep(' ', indent_n) local indent_fmt = '%-' .. tostring(indent_n) .. 's' for _, o in ipairs({'page', 'gray', 'bbox', 'pdf_target', 'pdf_version', 'use_pdftops', 'save', 'info', 'debug', 'version', 'help'}) do local v = opts[o] if v and v.help then local synt = join(v.forms, ', ') if v.type ~= 'boolean' then synt = synt .. ' ' .. v.placeholder end if string.len(synt)<indent_n then print(string.format(indent_fmt, synt) .. v.help) else print(synt) print(intent_sp .. v.help) end if v.negforms then local neghelp = 'Reverses the above' synt = join(v.negforms, ', ') if string.len(synt)<indent_n then print(string.format(indent_fmt, synt) .. neghelp) else print(synt) print(intent_sp .. neghelp) end end end end -- for if mess then os.exit(1) else os.exit() end end -- help if #arg < 1 then help('No parameters') end -- command-line parsing -- -r="tata tata" is parsed by [tex]lua as a single argument -- lua/linux retains the quotes, -- lua/windows strips them. -- texlua strips them, both on unix and on windows. local i=1 while i<=#arg and string.sub(arg[i],1,1)=='-' do local parsed = false local kk, vv = string.match(arg[i],'([^=]+)=(.*)$') if kk==nil then kk = arg[i] -- also vv==nil else vv = strip_outer_spaces(vv) end for p, o in pairs(opts) do if in_list(kk, o.forms) or in_list(kk, o.negforms) then parsed = true if o.type == 'boolean' then if vv then help(kk..' should not have a parameter.') end if in_list(kk, o.forms) then o.val = true else o.val = false end elseif vv then o.val = vv else i = i + 1 if i>#arg then help('Missing parameter to '..kk) end o.val = strip_outer_spaces(arg[i]) end -- testing for o.type or vv break -- for end -- if in_list end -- for if not parsed then help('illegal parameter '..kk) end i = i + 1 end -- while -- check and interpret opts. -- Copy to either settings or to options table. -- at syntax error, abort via help function. -- page if opts.page.val then local pnum = tonumber(opts.page.val) if pnum<=0 or math.floor(pnum) ~= pnum then help(opts.page.val..' not a positive integer') else options.page = pnum end end -- grayscaling if opts.gray.val then options.gray = true else options.gray = false end -- boundingbox if opts.bbox.val then options.bbox = true else options.bbox = false end --[[ -- using hires boundingbox if opts.use_hires_bb.val~=nil then settings.use_hires_bb = opts.use_hires_bb.val end --]] -- using pdftops if opts.use_pdftops.val~=nil then settings.use_pdftops = opts.use_pdftops.val end -- pdf target use if opts.pdf_target.val~=nil then if in_list(opts.pdf_target.val, pdf_targets) then settings.pdf_target = opts.pdf_target.val else help('Illegal value '..opts.pdf_target.val..' for pdf_target') end end -- pdf version if opts.pdf_version.val~=nil then if in_list(opts.pdf_version.val, pdf_versions) then settings.pdf_version = opts.pdf_version.val else help('Illegal value '..opts.pdf_version.val..' for pdf_version') end end -- pdftops should be on the path if settings.use_pdftops then if os.type=='windows' then pdftops = find_on_path('pdftops.exe') else pdftops = find_on_path('pdftops') end end -- other options if opts.save.val then write_settings(rcfile) end if opts.debug.val then options.debug = true end if opts.help.val then help() end -- opts.info.val: do later; need to get infile first if opts.version.val then show_version() os.exit() end if opts.gui.val then gui(opts.gui.val) end -- now we need 1 or 2 filenames, unless the user really only -- wanted to save options without further action. if i>#arg then if opts.save.val then os.exit() else help('No filenames') end end infile = arg[i] outfile = false if i<#arg then outfile = arg[i+1] end if (#arg>i and opts.info.val) or (#arg>i+1) then help('Surplus non-option parameters') end if not outfile and not opts.info.val then -- derive outfile from infile: [e]ps => pdf, pdf => eps if intype=='pdf' then outfile = string.gsub(infile,'%.[^%.]*$','eps') else outfile = string.gsub(infile,'%.[^%.]*$','.pdf') end end -- one final quick option if opts.info.val then info() end end -- do (decoding command-line) --[[ Once it becomes clear that real work needs to be done, we shall create a temp directory. because of gs -dSAFER restrictions, infile must be in (a subdirectory of) the directory of the output file, e.g. in the temp directory. So we copy infile to the temp directory. --]] if not lfs.isfile(infile) or lfs.attributes(infile, 'size')==0 then errror(infile..' does not exist or is empty.') end infile, in_dir = absolute_path(infile) outfile, out_dir = absolute_path(outfile) if not out_dir then errror('Invalid output directory for '.. outfile) end -- directory for temporary files -- previously, we used a subdirectory of the target directory. -- however, since under windows cleanup may fail, we now try to use -- a directory under a dedicated temp directory, which has a better chance -- of getting cleaned up by the system. for i, d in pairs({system_tempdir(), out_dir}) do if not lfs.chdir(d) then io.stdout:write('cannot cd into '..d..'\n') goto continue end tempdir = os.tmpdir() if not tempdir then goto continue end break ::continue:: end if not tempdir then errror('Cannot create directory for temporary files') end lfs.chdir(tempdir) -- determine filetype from first few bytes of file intype = identify(infile) -- remaining cases: want a real conversion if not intype then errror(infile..' has an unsupported filetype') end -- valid output filetype? options.type = string.match(outfile, '.*%.([^%.]+)$') if not options.type or (options.type~='ps' and options.type~='eps' and options.type~='pdf') then errror('Output file '..outfile.. ' should have extension .eps, .ps or .pdf') end if outfile==infile then slice_file(infile, infile..'.backup') -- copy, not move, since outfile may be infile if there was nothing to do end result = any_to_any(infile, outfile) if not lfs.isfile(outfile) or lfs.attributes(outfile, 'size')==0 then errror('Failed to generate '..outfile) end if not options.debug then cleantemp() end end