4796 lines
176 KiB
OCaml
4796 lines
176 KiB
OCaml
(* cpdf command line tools *)
|
|
let demo = false
|
|
let agpl = true
|
|
let major_version = 2
|
|
let minor_version = 7
|
|
let minor_minor_version = 1
|
|
let version_date = "(24th July 2024)"
|
|
|
|
open Pdfutil
|
|
open Pdfio
|
|
|
|
let combine_with_spaces strs =
|
|
String.trim
|
|
(fold_left (fun x y -> x ^ (if x <> "" then " " else "") ^ y) "" strs)
|
|
|
|
let tempfiles = ref []
|
|
|
|
let exit n =
|
|
begin try iter Sys.remove !tempfiles with _ -> exit n end;
|
|
exit n
|
|
|
|
let null () = ()
|
|
|
|
let initial_file_size = ref 0
|
|
|
|
let empty = Pdf.empty ()
|
|
|
|
(* Wrap up the file reading functions to exit with code 1 when an encryption
|
|
problem occurs. This happens when object streams are in an encrypted document
|
|
and so it can't be read without the right password... The existing error
|
|
handling only dealt with the case where the document couldn't be decrypted once
|
|
it had been loaded. *)
|
|
let pdfread_pdf_of_input ?revision a b c =
|
|
try Pdfread.pdf_of_input ?revision a b c with
|
|
Pdf.PDFError s when String.length s >=10 && String.sub s 0 10 = "Encryption" ->
|
|
raise (Cpdferror.SoftError "Bad owner or user password when reading document")
|
|
|
|
let pdfread_pdf_of_channel_lazy ?revision ?source b c d =
|
|
try Pdfread.pdf_of_channel_lazy ?revision ?source b c d with
|
|
Pdf.PDFError s when String.length s >=10 && String.sub s 0 10 = "Encryption" ->
|
|
raise (Cpdferror.SoftError "Bad owner or user password when reading document")
|
|
|
|
let pdfread_pdf_of_file ?revision a b c =
|
|
try Pdfread.pdf_of_file ?revision a b c with
|
|
Pdf.PDFError s when String.length s >=10 && String.sub s 0 10 = "Encryption" ->
|
|
raise (Cpdferror.SoftError "Bad owner or user password when reading document")
|
|
|
|
let optstring = function
|
|
| "" -> None
|
|
| x -> Some x
|
|
|
|
let _ =
|
|
set_binary_mode_in stdin true;
|
|
set_binary_mode_out stdout true
|
|
|
|
let stay_on_error = ref false
|
|
|
|
exception StayOnError
|
|
|
|
(* Fatal error reporting. *)
|
|
let error s =
|
|
Pdfe.log (s ^ "\nUse -help for help.\n");
|
|
if not !stay_on_error then exit 2 else raise StayOnError
|
|
|
|
let soft_error s =
|
|
Pdfe.log (Printf.sprintf "%s\n" s);
|
|
if not !stay_on_error then exit 1 else raise StayOnError
|
|
|
|
let parse_pagespec pdf spec =
|
|
try Cpdfpagespec.parse_pagespec pdf spec with
|
|
Failure x -> error x
|
|
|
|
(* We allow an operation such as ScaleToFit on a range such as 'portrait' to be silently null to allow, for example:
|
|
cpdf -scale-to-fit a4portrait in.pdf portrait AND -scale-to-fit a4landscape landscape -o out.pdf
|
|
*)
|
|
let parse_pagespec_allow_empty pdf spec =
|
|
try Cpdfpagespec.parse_pagespec pdf spec with
|
|
Pdf.PDFError ("Page range specifies no pages") -> []
|
|
|
|
(* Operations. *)
|
|
type op =
|
|
| CopyFont of string
|
|
| CountPages
|
|
| Version
|
|
| Encrypt
|
|
| Decrypt
|
|
| StampOn of string
|
|
| StampUnder of string
|
|
| CombinePages of string
|
|
| TwoUp
|
|
| TwoUpStack
|
|
| Impose of bool
|
|
| RemoveBookmarks
|
|
| AddBookmarks of string
|
|
| AddText of string
|
|
| AddRectangle
|
|
| RemoveText
|
|
| Draft
|
|
| PadBefore
|
|
| PadAfter
|
|
| PadEvery of int
|
|
| PadMultiple of int
|
|
| PadMultipleBefore of int
|
|
| Shift
|
|
| ShiftBoxes
|
|
| Scale
|
|
| ScaleToFit
|
|
| Stretch
|
|
| ScaleContents of float
|
|
| AttachFile of string list
|
|
| RemoveAttachedFiles
|
|
| ListAttachedFiles
|
|
| DumpAttachedFiles
|
|
| RemoveAnnotations
|
|
| ListAnnotations
|
|
| CopyAnnotations of string
|
|
| SetAnnotations of string
|
|
| Merge
|
|
| Split
|
|
| SplitOnBookmarks of int
|
|
| SplitMax of int
|
|
| Spray
|
|
| Clean
|
|
| Info
|
|
| PageInfo
|
|
| Metadata
|
|
| SetMetadata of string
|
|
| RemoveMetadata
|
|
| Fonts
|
|
| RemoveFonts
|
|
| Compress
|
|
| Decompress
|
|
| Crop
|
|
| Trim
|
|
| Bleed
|
|
| Art
|
|
| RemoveCrop
|
|
| RemoveArt
|
|
| RemoveTrim
|
|
| RemoveBleed
|
|
| CopyBox
|
|
| MediaBox
|
|
| HardBox of string
|
|
| Rotate of int
|
|
| Rotateby of int
|
|
| RotateContents of float
|
|
| Upright
|
|
| VFlip
|
|
| HFlip
|
|
| ThinLines of float
|
|
| SetAuthor of string
|
|
| SetTitle of string
|
|
| SetSubject of string
|
|
| SetKeywords of string
|
|
| SetCreate of string
|
|
| SetModify of string
|
|
| SetCreator of string
|
|
| SetProducer of string
|
|
| SetTrapped
|
|
| SetUntrapped
|
|
| SetVersion of int
|
|
| ListBookmarks
|
|
| SetPageLayout of string
|
|
| SetPageMode of string
|
|
| SetNonFullScreenPageMode of string
|
|
| HideToolbar of bool
|
|
| HideMenubar of bool
|
|
| HideWindowUI of bool
|
|
| FitWindow of bool
|
|
| CenterWindow of bool
|
|
| DisplayDocTitle of bool
|
|
| Presentation
|
|
| ChangeId
|
|
| RemoveId
|
|
| CopyId of string
|
|
| BlackText
|
|
| BlackLines
|
|
| BlackFills
|
|
| ExtractImages
|
|
| ListImages
|
|
| ImageResolution of float
|
|
| MissingFonts
|
|
| ExtractFontFile of string
|
|
| ExtractText
|
|
| OpenAtPage of string
|
|
| OpenAtPageFit of string
|
|
| OpenAtPageCustom of string
|
|
| AddPageLabels
|
|
| RemovePageLabels
|
|
| PrintPageLabels
|
|
| RemoveDictEntry of string
|
|
| ReplaceDictEntry of string
|
|
| PrintDictEntry of string
|
|
| ListSpotColours
|
|
| RemoveClipping
|
|
| SetMetadataDate of string
|
|
| CreateMetadata
|
|
| EmbedMissingFonts
|
|
| BookmarksOpenToLevel of int
|
|
| CreatePDF
|
|
| RemoveAllText
|
|
| ShowBoxes
|
|
| TrimMarks
|
|
| Prepend of string
|
|
| Postpend of string
|
|
| OutputJSON
|
|
| OCGCoalesce
|
|
| OCGList
|
|
| OCGRename
|
|
| OCGOrderAll
|
|
| StampAsXObject of string
|
|
| PrintFontEncoding of string
|
|
| TableOfContents
|
|
| Typeset of string
|
|
| TextWidth of string
|
|
| Draw
|
|
| Composition of bool
|
|
| Chop of int * int
|
|
| ChopHV of bool * float
|
|
| ProcessImages
|
|
| ExtractStream of string
|
|
| PrintObj of string
|
|
| ReplaceObj of string * string
|
|
| Verify of string
|
|
| MarkAs of Cpdfua.subformat
|
|
| RemoveMark of Cpdfua.subformat
|
|
| PrintStructTree
|
|
| ExtractStructTree
|
|
| ReplaceStructTree of string
|
|
| SetLanguage of string
|
|
| Redact
|
|
|
|
let string_of_op = function
|
|
| PrintFontEncoding _ -> "PrintFontEncoding"
|
|
| PrintDictEntry _ -> "PrintDictEntry"
|
|
| Impose _ -> "Impose"
|
|
| CopyFont _ -> "CopyFont"
|
|
| CountPages -> "CountPages"
|
|
| Version -> "Version"
|
|
| Encrypt -> "Encrypt"
|
|
| Decrypt -> "Decrypt"
|
|
| StampOn _ -> "StampOn"
|
|
| StampUnder _ -> "StampUnder"
|
|
| CombinePages _ -> "CombinePages"
|
|
| TwoUp -> "TwoUp"
|
|
| TwoUpStack -> "TwoUpStack"
|
|
| RemoveBookmarks -> "RemoveBookmarks"
|
|
| AddBookmarks _ -> "AddBookmarks"
|
|
| AddText _ -> "AddText"
|
|
| AddRectangle -> "AddRectangle"
|
|
| RemoveText -> "RemoveText"
|
|
| Draft -> "Draft"
|
|
| PadBefore -> "PadBefore"
|
|
| PadAfter -> "PadAfter"
|
|
| PadEvery _ -> "PadEvery"
|
|
| PadMultiple _ -> "PadMultiple"
|
|
| PadMultipleBefore _ -> "PadMultipleBefore"
|
|
| Shift -> "Shift"
|
|
| ShiftBoxes -> "ShiftBoxes"
|
|
| Scale -> "Scale"
|
|
| ScaleToFit -> "ScaleToFit"
|
|
| Stretch -> "Stretch"
|
|
| ScaleContents _ -> "ScaleContents"
|
|
| AttachFile _ -> "AttachFile"
|
|
| RemoveAttachedFiles -> "RemoveAttachedFiles"
|
|
| ListAttachedFiles -> "ListAttachedFiles"
|
|
| DumpAttachedFiles -> "DumpAttachedFiles"
|
|
| RemoveAnnotations -> "RemoveAnnotations"
|
|
| ListAnnotations -> "ListAnnotations"
|
|
| CopyAnnotations _ -> "CopyAnnotations"
|
|
| SetAnnotations _ -> "SetAnnotations"
|
|
| Merge -> "Merge"
|
|
| Split -> "Split"
|
|
| SplitOnBookmarks _ -> "SplitOnBookmarks"
|
|
| SplitMax _ -> "SplitMax"
|
|
| Spray -> "Spray"
|
|
| Clean -> "Clean"
|
|
| Info -> "Info"
|
|
| PageInfo -> "PageInfo"
|
|
| Metadata -> "Metadata"
|
|
| SetMetadata _ -> "SetMetadata"
|
|
| RemoveMetadata -> "RemoveMetadata"
|
|
| Fonts -> "Fonts"
|
|
| RemoveFonts -> "RemoveFonts"
|
|
| Compress -> "Compress"
|
|
| Decompress -> "Decompress"
|
|
| Crop -> "Crop"
|
|
| RemoveCrop -> "RemoveCrop"
|
|
| CopyBox -> "CopyBox"
|
|
| MediaBox -> "MediaBox"
|
|
| HardBox _ -> "HardBox"
|
|
| Rotate _ -> "Rotate"
|
|
| Rotateby _ -> "Rotateby"
|
|
| RotateContents _ -> "RotateContents"
|
|
| Upright -> "Upright"
|
|
| VFlip -> "VFlip"
|
|
| HFlip -> "HFlip"
|
|
| ThinLines _ -> "ThinLines"
|
|
| SetAuthor _ -> "SetAuthor"
|
|
| SetTitle _ -> "SetTitle"
|
|
| SetSubject _ -> "SetSubject"
|
|
| SetKeywords _ -> "SetKeywords"
|
|
| SetCreate _ -> "SetCreate"
|
|
| SetModify _ -> "SetModify"
|
|
| SetCreator _ -> "SetCreator"
|
|
| SetProducer _ -> "SetProducer"
|
|
| SetTrapped -> "SetTrapped"
|
|
| SetUntrapped -> "SetUntrapped"
|
|
| SetVersion _ -> "SetVersion"
|
|
| ListBookmarks -> "ListBookmarks"
|
|
| SetPageLayout _ -> "SetPageLayout"
|
|
| SetPageMode _ -> "SetPageMode"
|
|
| SetNonFullScreenPageMode _ -> "SetNonFullScreenPageMode"
|
|
| HideToolbar _ -> "HideToolbar"
|
|
| HideMenubar _ -> "HideMenubar"
|
|
| HideWindowUI _ -> "HideWindowUI"
|
|
| FitWindow _ -> "FitWindow"
|
|
| CenterWindow _ -> "CenterWindow"
|
|
| DisplayDocTitle _ -> "DisplayDocTitle"
|
|
| Presentation -> "Presentation"
|
|
| ChangeId -> "ChangeId"
|
|
| RemoveId -> "RemoveId"
|
|
| CopyId _ -> "CopyId"
|
|
| BlackText -> "BlackText"
|
|
| BlackLines -> "BlackLines"
|
|
| BlackFills -> "BlackFills"
|
|
| ExtractImages -> "ExtractImages"
|
|
| ListImages -> "ListImages"
|
|
| ImageResolution _ -> "ImageResolution"
|
|
| MissingFonts -> "MissingFonts"
|
|
| ExtractFontFile _ -> "ExtractFontFile"
|
|
| ExtractText -> "ExtractText"
|
|
| OpenAtPage _ -> "OpenAtPage"
|
|
| OpenAtPageFit _ -> "OpenAtPageFit"
|
|
| OpenAtPageCustom _ -> "OpenAtPageCustom"
|
|
| AddPageLabels -> "AddPageLabels"
|
|
| RemovePageLabels -> "RemovePageLabels"
|
|
| PrintPageLabels -> "PrintPageLabels"
|
|
| RemoveDictEntry _ -> "RemoveDictEntry"
|
|
| ReplaceDictEntry _ -> "ReplaceDictEntry"
|
|
| ListSpotColours -> "ListSpotColours"
|
|
| RemoveClipping -> "RemoveClipping"
|
|
| Trim -> "Trim"
|
|
| Art -> "Art"
|
|
| Bleed -> "Bleed"
|
|
| RemoveArt -> "RemoveArt"
|
|
| RemoveTrim -> "RemoveTrim"
|
|
| RemoveBleed -> "RemoveBleed"
|
|
| SetMetadataDate _ -> "SetMetadataDate"
|
|
| CreateMetadata -> "CreateMetadata"
|
|
| EmbedMissingFonts -> "EmbedMissingFonts"
|
|
| BookmarksOpenToLevel _ -> "BookmarksOpenToLevel"
|
|
| CreatePDF -> "CreatePDF"
|
|
| RemoveAllText -> "RemoveAllText"
|
|
| ShowBoxes -> "ShowBoxes"
|
|
| TrimMarks -> "TrimMarks"
|
|
| Prepend _ -> "Prepend"
|
|
| Postpend _ -> "Postpend"
|
|
| OutputJSON -> "OutputJSON"
|
|
| OCGCoalesce -> "OCGCoalesce"
|
|
| OCGList -> "OCGList"
|
|
| OCGRename -> "OCGRename"
|
|
| OCGOrderAll -> "OCGOrderAll"
|
|
| StampAsXObject _ -> "StampAsXObject"
|
|
| TableOfContents -> "TableOfContents"
|
|
| Typeset _ -> "Typeset"
|
|
| TextWidth _ -> "TextWidth"
|
|
| Draw -> "Draw"
|
|
| Composition _ -> "Composition"
|
|
| Chop _ -> "Chop"
|
|
| ChopHV _ -> "ChopHV"
|
|
| ProcessImages -> "ProcessImages"
|
|
| ExtractStream _ -> "ExtractStream"
|
|
| PrintObj _ -> "PrintObj"
|
|
| ReplaceObj _ -> "ReplaceObj"
|
|
| Verify _ -> "Verify"
|
|
| MarkAs _ -> "MarkAs"
|
|
| RemoveMark _ -> "RemoveMark"
|
|
| PrintStructTree -> "PrintStructTree"
|
|
| ExtractStructTree -> "ExtractStructTree"
|
|
| ReplaceStructTree _ -> "ReplaceStructTree"
|
|
| SetLanguage _ -> "SetLanguage"
|
|
| Redact -> "Redact"
|
|
|
|
(* Inputs: filename, pagespec. *)
|
|
type input_kind =
|
|
| AlreadyInMemory of Pdf.t * string
|
|
| InFile of string
|
|
| StdIn
|
|
|
|
let string_of_input_kind = function
|
|
| AlreadyInMemory (_, s) -> s
|
|
| InFile s -> s
|
|
| StdIn -> "Stdin"
|
|
|
|
type input =
|
|
input_kind * string * string * string * bool ref * int option
|
|
(* input kind, range, user_pw, owner_pw, was_decrypted_with_owner, revision *)
|
|
|
|
type output_method =
|
|
| NoOutputSpecified
|
|
| Stdout
|
|
| File of string
|
|
|
|
(* Outputs are also added here, in case -spray is in use. *)
|
|
let spray_outputs = ref []
|
|
|
|
(* A list of PDFs to be output, if no output method was specified. *)
|
|
let output_pdfs : Pdf.t list ref = ref []
|
|
|
|
let standard_namespace = "http://iso.org/pdf/ssn"
|
|
let pdf2_namespace = "http://iso.org/pdf2/ssn"
|
|
|
|
type font =
|
|
| StandardFont of Pdftext.standard_font
|
|
| EmbeddedFont of string
|
|
| OtherFont of string
|
|
|
|
type args =
|
|
{mutable op : op option;
|
|
mutable preserve_objstm : bool;
|
|
mutable create_objstm : bool;
|
|
mutable out : output_method;
|
|
mutable inputs : input list;
|
|
mutable chunksize : int;
|
|
mutable linearize : bool;
|
|
mutable keeplinearize : bool;
|
|
mutable rectangle : string;
|
|
mutable coord : string;
|
|
mutable duration : float option;
|
|
mutable transition : string option;
|
|
mutable horizontal : bool;
|
|
mutable inward : bool;
|
|
mutable direction : int;
|
|
mutable effect_duration : float;
|
|
mutable font : font;
|
|
mutable fontname : string;
|
|
mutable fontencoding : Pdftext.encoding;
|
|
mutable fontsize : float;
|
|
mutable embedstd14 : string option;
|
|
mutable color : Cpdfaddtext.colour;
|
|
mutable opacity : float;
|
|
mutable position : Cpdfposition.position;
|
|
mutable underneath : bool;
|
|
mutable linespacing : float;
|
|
mutable midline : bool;
|
|
mutable topline : bool;
|
|
mutable justification : Cpdfaddtext.justification;
|
|
mutable bates : int;
|
|
mutable batespad : int option;
|
|
mutable prerotate : bool;
|
|
mutable relative_to_cropbox : bool;
|
|
mutable keepversion : bool;
|
|
mutable bycolumns : bool;
|
|
mutable pagerotation : int;
|
|
mutable crypt_method : string;
|
|
mutable owner : string;
|
|
mutable user : string;
|
|
mutable no_edit : bool;
|
|
mutable no_print : bool;
|
|
mutable no_copy : bool;
|
|
mutable no_annot : bool;
|
|
mutable no_forms : bool;
|
|
mutable no_extract : bool;
|
|
mutable no_assemble : bool;
|
|
mutable no_hq_print : bool;
|
|
mutable debug : bool;
|
|
mutable debugcrypt : bool;
|
|
mutable debugforce : bool;
|
|
mutable boxes : bool;
|
|
mutable encrypt_metadata : bool;
|
|
mutable retain_numbering : bool;
|
|
mutable process_struct_trees : bool;
|
|
mutable remove_duplicate_fonts : bool;
|
|
mutable remove_duplicate_streams : bool;
|
|
mutable encoding : Cpdfmetadata.encoding;
|
|
mutable scale : float;
|
|
mutable copyfontpage : int;
|
|
mutable copyfontname : string option;
|
|
mutable fast : bool;
|
|
mutable dashrange : string;
|
|
mutable outline : bool;
|
|
mutable linewidth : float;
|
|
mutable path_to_ghostscript : string;
|
|
mutable path_to_im : string;
|
|
mutable path_to_p2p : string;
|
|
mutable path_to_jbig2enc : string;
|
|
mutable frombox : string option;
|
|
mutable tobox : string option;
|
|
mutable mediabox_if_missing : bool;
|
|
mutable topage : string option;
|
|
mutable scale_stamp_to_fit : bool;
|
|
mutable labelstyle : Pdfpagelabels.labelstyle;
|
|
mutable labelprefix : string option;
|
|
mutable labelstartval : int;
|
|
mutable labelsprogress : bool;
|
|
mutable squeeze : bool;
|
|
mutable squeeze_recompress : bool;
|
|
mutable squeeze_pagedata: bool;
|
|
mutable original_filename : string;
|
|
mutable was_encrypted : bool;
|
|
mutable cpdflin : string option;
|
|
mutable recrypt : bool;
|
|
mutable was_decrypted_with_owner : bool;
|
|
mutable creator : string option;
|
|
mutable producer : string option;
|
|
mutable extract_text_font_size : float option;
|
|
mutable padwith : string option;
|
|
mutable alsosetxml : bool;
|
|
mutable justsetxml : bool;
|
|
mutable gs_malformed : bool;
|
|
mutable gs_quiet : bool;
|
|
mutable merge_add_bookmarks : bool;
|
|
mutable merge_add_bookmarks_use_titles : bool;
|
|
mutable createpdf_pages : int;
|
|
mutable createpdf_pagesize : Pdfpaper.t;
|
|
mutable removeonly : string option;
|
|
mutable jsonparsecontentstreams : bool;
|
|
mutable jsonnostreamdata : bool;
|
|
mutable jsondecompressstreams : bool;
|
|
mutable jsoncleanstrings : bool;
|
|
mutable ocgrenamefrom : string;
|
|
mutable ocgrenameto : string;
|
|
mutable dedup : bool;
|
|
mutable dedup_per_page : bool;
|
|
mutable collate : bool;
|
|
mutable impose_columns : bool;
|
|
mutable impose_rtl : bool;
|
|
mutable impose_btt : bool;
|
|
mutable impose_center : bool;
|
|
mutable impose_margin : float;
|
|
mutable impose_spacing : float;
|
|
mutable impose_linewidth : float;
|
|
mutable format_json : bool;
|
|
mutable replace_dict_entry_value : Pdf.pdfobject;
|
|
mutable dict_entry_search : Pdf.pdfobject option;
|
|
mutable toc_title : string;
|
|
mutable toc_bookmark : bool;
|
|
mutable idir_only_pdfs : bool;
|
|
mutable no_warn_rotate : bool;
|
|
mutable jpegquality : float;
|
|
mutable jpegqualitylossless : float;
|
|
mutable onebppmethod : string;
|
|
mutable pixel_threshold : int;
|
|
mutable length_threshold : int;
|
|
mutable percentage_threshold : float;
|
|
mutable dpi_threshold : float;
|
|
mutable resample_factor : float;
|
|
mutable resample_interpolate : bool;
|
|
mutable jbig2_lossy_threshold : float;
|
|
mutable extract_stream_decompress : bool;
|
|
mutable verify_single : string option;
|
|
mutable draw_struct_tree : bool;
|
|
mutable image_title : string option;
|
|
mutable subformat : Cpdfua.subformat option;
|
|
mutable indent : float option}
|
|
|
|
let args =
|
|
{op = None;
|
|
preserve_objstm = true;
|
|
create_objstm = false;
|
|
out = NoOutputSpecified;
|
|
inputs = [];
|
|
chunksize = 1;
|
|
linearize = false;
|
|
keeplinearize = false;
|
|
rectangle = "0 0 0 0";
|
|
coord = "0 0";
|
|
duration = None;
|
|
transition = None;
|
|
horizontal = true;
|
|
inward = true;
|
|
direction = 0;
|
|
effect_duration = 1.;
|
|
font = StandardFont Pdftext.TimesRoman;
|
|
fontname = "Times-Roman";
|
|
fontsize = 12.;
|
|
fontencoding = Pdftext.WinAnsiEncoding;
|
|
color = Cpdfaddtext.RGB (0., 0., 0.);
|
|
opacity = 1.;
|
|
position = Cpdfposition.TopLeft (100., 100.);
|
|
underneath = false;
|
|
linespacing = 1.;
|
|
midline = false;
|
|
topline = false;
|
|
justification = Cpdfaddtext.LeftJustify;
|
|
bates = 0;
|
|
batespad = None;
|
|
prerotate = false;
|
|
relative_to_cropbox = false;
|
|
keepversion = false;
|
|
bycolumns = false;
|
|
pagerotation = 0;
|
|
crypt_method = "";
|
|
owner = "";
|
|
user = "";
|
|
no_edit = false;
|
|
no_print = false;
|
|
no_copy = false;
|
|
no_annot = false;
|
|
no_forms = false;
|
|
no_extract = false;
|
|
no_assemble = false;
|
|
no_hq_print = false;
|
|
debug = false;
|
|
debugcrypt = false;
|
|
debugforce = false;
|
|
boxes = false;
|
|
encrypt_metadata = true;
|
|
retain_numbering = false;
|
|
process_struct_trees = false;
|
|
remove_duplicate_fonts = false;
|
|
remove_duplicate_streams = false;
|
|
encoding = Cpdfmetadata.Stripped;
|
|
scale = 1.;
|
|
copyfontpage = 1;
|
|
copyfontname = None;
|
|
fast = false;
|
|
dashrange = "all";
|
|
outline = false;
|
|
linewidth = 1.0;
|
|
path_to_ghostscript = "";
|
|
path_to_im = "";
|
|
path_to_p2p = "";
|
|
path_to_jbig2enc = "";
|
|
frombox = None;
|
|
tobox = None;
|
|
mediabox_if_missing = false;
|
|
topage = None;
|
|
scale_stamp_to_fit = false;
|
|
labelstyle = Pdfpagelabels.DecimalArabic;
|
|
labelprefix = None;
|
|
labelstartval = 1;
|
|
labelsprogress = false;
|
|
squeeze = false;
|
|
squeeze_recompress = true;
|
|
squeeze_pagedata = true;
|
|
original_filename = "";
|
|
was_encrypted = false;
|
|
cpdflin = None;
|
|
recrypt = false;
|
|
was_decrypted_with_owner = false;
|
|
producer = None;
|
|
creator = None;
|
|
embedstd14 = None;
|
|
extract_text_font_size = None;
|
|
padwith = None;
|
|
alsosetxml = false;
|
|
justsetxml = false;
|
|
gs_malformed = false;
|
|
gs_quiet = false;
|
|
merge_add_bookmarks = false;
|
|
merge_add_bookmarks_use_titles = false;
|
|
createpdf_pages = 1;
|
|
createpdf_pagesize = Pdfpaper.a4;
|
|
removeonly = None;
|
|
jsonparsecontentstreams = false;
|
|
jsonnostreamdata = false;
|
|
jsondecompressstreams = false;
|
|
jsoncleanstrings = false;
|
|
ocgrenamefrom = "";
|
|
ocgrenameto = "";
|
|
dedup = false;
|
|
dedup_per_page = false;
|
|
collate = false;
|
|
impose_columns = false;
|
|
impose_rtl = false;
|
|
impose_btt = false;
|
|
impose_center = false;
|
|
impose_margin = 0.;
|
|
impose_spacing = 0.;
|
|
impose_linewidth = 0.;
|
|
format_json = false;
|
|
replace_dict_entry_value = Pdf.Null;
|
|
dict_entry_search = None;
|
|
toc_title = "Table of Contents";
|
|
toc_bookmark = true;
|
|
idir_only_pdfs = false;
|
|
no_warn_rotate = false;
|
|
jpegquality = 100.;
|
|
jpegqualitylossless = 101.;
|
|
onebppmethod = "";
|
|
pixel_threshold = 25;
|
|
length_threshold = 100;
|
|
percentage_threshold = 99.;
|
|
dpi_threshold = 0.;
|
|
resample_factor = 101.;
|
|
resample_interpolate = false;
|
|
jbig2_lossy_threshold = 0.85;
|
|
extract_stream_decompress = false;
|
|
verify_single = None;
|
|
draw_struct_tree = false;
|
|
image_title = None;
|
|
subformat = None;
|
|
indent = None}
|
|
|
|
(* Do not reset original_filename or cpdflin or was_encrypted or
|
|
was_decrypted_with_owner or recrypt or producer or creator or path_to_* or
|
|
gs_malformed or gs_quiet or no-warn-rotate, since we want these to work
|
|
across ANDs. Or squeeze options: a little odd, but we want it to happen on
|
|
eventual output. Or -debug-force (from v2.6). *)
|
|
let reset_arguments () =
|
|
args.op <- None;
|
|
args.preserve_objstm <- true;
|
|
args.create_objstm <- false;
|
|
args.out <- NoOutputSpecified;
|
|
args.inputs <- [];
|
|
args.chunksize <- 1;
|
|
args.linearize <- false;
|
|
args.keeplinearize <- false;
|
|
args.rectangle <- "0 0 0 0";
|
|
args.coord <- "0 0";
|
|
args.duration <- None;
|
|
args.transition <- None;
|
|
args.horizontal <- true;
|
|
args.inward <- true;
|
|
args.direction <- 0;
|
|
args.effect_duration <- 1.;
|
|
args.font <- StandardFont Pdftext.TimesRoman;
|
|
args.fontname <- "Times-Roman";
|
|
args.fontsize <- 12.;
|
|
args.fontencoding <- Pdftext.WinAnsiEncoding;
|
|
args.color <- Cpdfaddtext.RGB (0., 0., 0.);
|
|
args.opacity <- 1.;
|
|
args.position <- Cpdfposition.TopLeft (100., 100.);
|
|
args.underneath <- false;
|
|
args.linespacing <- 1.;
|
|
args.midline <- false;
|
|
args.topline <- false;
|
|
args.justification <- Cpdfaddtext.LeftJustify;
|
|
args.bates <- 0;
|
|
args.batespad <- None;
|
|
args.prerotate <- false;
|
|
args.relative_to_cropbox <- false;
|
|
args.keepversion <- false;
|
|
args.bycolumns <- false;
|
|
args.pagerotation <- 0;
|
|
args.crypt_method <- "";
|
|
args.owner <- "";
|
|
args.user <- "";
|
|
args.no_edit <- false;
|
|
args.no_print <- false;
|
|
args.no_copy <- false;
|
|
args.no_annot <- false;
|
|
args.no_forms <- false;
|
|
args.no_extract <- false;
|
|
args.no_assemble <- false;
|
|
args.no_hq_print <- false;
|
|
args.debug <- false;
|
|
args.debugcrypt <- false;
|
|
args.boxes <- false;
|
|
args.encrypt_metadata <- true;
|
|
args.retain_numbering <- false;
|
|
args.process_struct_trees <- false;
|
|
args.remove_duplicate_fonts <- false;
|
|
args.remove_duplicate_streams <- false;
|
|
args.encoding <- Cpdfmetadata.Stripped;
|
|
args.scale <- 1.;
|
|
args.copyfontpage <- 1;
|
|
args.copyfontname <- None;
|
|
args.fast <- false;
|
|
args.dashrange <- "all";
|
|
args.outline <- false;
|
|
args.linewidth <- 1.0;
|
|
args.frombox <- None;
|
|
args.tobox <- None;
|
|
args.mediabox_if_missing <- false;
|
|
args.topage <- None;
|
|
args.scale_stamp_to_fit <- false;
|
|
args.labelstyle <- Pdfpagelabels.DecimalArabic;
|
|
args.labelprefix <- None;
|
|
args.labelstartval <- 1;
|
|
args.labelsprogress <- false;
|
|
args.embedstd14 <- None;
|
|
args.extract_text_font_size <- None;
|
|
args.padwith <- None;
|
|
args.alsosetxml <- false;
|
|
args.justsetxml <- false;
|
|
args.merge_add_bookmarks <- false;
|
|
args.merge_add_bookmarks_use_titles <- false;
|
|
args.createpdf_pages <- 1;
|
|
args.createpdf_pagesize <- Pdfpaper.a4;
|
|
args.removeonly <- None;
|
|
args.jsonparsecontentstreams <- false;
|
|
args.jsonnostreamdata <- false;
|
|
args.jsondecompressstreams <- false;
|
|
args.jsoncleanstrings <- false;
|
|
args.ocgrenamefrom <- "";
|
|
args.ocgrenameto <- "";
|
|
args.dedup <- false;
|
|
args.dedup_per_page <- false;
|
|
args.collate <- false;
|
|
args.impose_columns <- false;
|
|
args.impose_rtl <- false;
|
|
args.impose_btt <- false;
|
|
args.impose_center <- false;
|
|
args.impose_margin <- 0.;
|
|
args.impose_spacing <- 0.;
|
|
args.impose_linewidth <- 0.;
|
|
args.format_json <- false;
|
|
args.replace_dict_entry_value <- Pdf.Null;
|
|
args.dict_entry_search <- None;
|
|
args.toc_title <- "Table of Contents";
|
|
args.toc_bookmark <- true;
|
|
args.idir_only_pdfs <- false;
|
|
args.jpegquality <- 100.;
|
|
args.jpegqualitylossless <- 101.;
|
|
args.onebppmethod <- "";
|
|
args.pixel_threshold <- 25;
|
|
args.length_threshold <- 100;
|
|
args.percentage_threshold <- 99.;
|
|
args.dpi_threshold <- 0.;
|
|
args.resample_factor <- 101.;
|
|
args.resample_interpolate <- false;
|
|
args.jbig2_lossy_threshold <- 0.85;
|
|
args.extract_stream_decompress <- false;
|
|
clear Cpdfdrawcontrol.fontpack_initialised;
|
|
args.verify_single <- None;
|
|
args.draw_struct_tree <- false;
|
|
args.image_title <- None;
|
|
args.subformat <- None;
|
|
args.indent <- None
|
|
|
|
(* Prefer a) the one given with -cpdflin b) a local cpdflin, c) otherwise assume
|
|
installed at a system place *)
|
|
let find_cpdflin provided =
|
|
match provided with
|
|
Some x -> x
|
|
| None ->
|
|
let dotslash = match Sys.os_type with "Win32" -> "" | _ -> "./" in
|
|
if Sys.file_exists "cpdflin" then (dotslash ^ "cpdflin") else
|
|
if Sys.file_exists "cpdflin.exe" then (dotslash ^ "cpdflin.exe") else
|
|
match Sys.os_type with
|
|
"Win32" -> "cpdflin.exe"
|
|
| _ -> "cpdflin"
|
|
|
|
(* Call cpdflin, given the (temp) input name, the output name, and the location
|
|
of the cpdflin binary. Returns the exit code. *)
|
|
let call_cpdflin cpdflin temp output best_password =
|
|
let command =
|
|
Filename.quote_command cpdflin
|
|
["--linearize"; ("--password=" ^ best_password); temp; output]
|
|
in
|
|
match Sys.os_type with
|
|
"Win32" ->
|
|
(* On windows, don't use LD_LIBRARY_PATH - it will happen automatically *)
|
|
if args.debug then Pdfe.log (command ^ "\n");
|
|
Sys.command command
|
|
| _ ->
|
|
(* On other platforms, if -cpdflin was provided, or cpdflin was in the
|
|
current folder, set up LD_LIBRARY_PATH: *)
|
|
match cpdflin with
|
|
"cpdflin" ->
|
|
if args.debug then Pdfe.log (command ^ "\n");
|
|
Sys.command command
|
|
| _ ->
|
|
let command =
|
|
"DYLD_FALLBACK_LIBRARY_PATH=" ^ Filename.quote (Filename.dirname cpdflin) ^ " " ^
|
|
"LD_LIBRARY_PATH=" ^ Filename.quote (Filename.dirname cpdflin) ^ " " ^
|
|
command
|
|
in
|
|
if args.debug then Pdfe.log (command ^ "\n");
|
|
Sys.command command
|
|
|
|
let get_pagespec () =
|
|
match args.inputs with
|
|
| (_, ps, _, _, _, _)::_ -> ps
|
|
| _ -> error "No range specified for input, or specified too late."
|
|
|
|
let string_of_permission = function
|
|
| Pdfcrypt.NoEdit -> "No edit"
|
|
| Pdfcrypt.NoPrint -> "No print"
|
|
| Pdfcrypt.NoCopy -> "No copy"
|
|
| Pdfcrypt.NoAnnot -> "No annotate"
|
|
| Pdfcrypt.NoForms -> "No edit forms"
|
|
| Pdfcrypt.NoExtract -> "No extract"
|
|
| Pdfcrypt.NoAssemble -> "No assemble"
|
|
| Pdfcrypt.NoHqPrint -> "No high-quality print"
|
|
|
|
let getpermissions pdf =
|
|
fold_left
|
|
(fun x y -> if x = "" then x ^ y else x ^ ", " ^ y)
|
|
""
|
|
(map string_of_permission (Pdfread.permissions pdf))
|
|
|
|
let banlist_of_args () =
|
|
let l = ref [] in
|
|
if args.no_edit then l =| Pdfcrypt.NoEdit;
|
|
if args.no_print then l =| Pdfcrypt.NoPrint;
|
|
if args.no_copy then l =| Pdfcrypt.NoCopy;
|
|
if args.no_annot then l =| Pdfcrypt.NoAnnot;
|
|
if args.no_forms then l =| Pdfcrypt.NoForms;
|
|
if args.no_extract then l =| Pdfcrypt.NoExtract;
|
|
if args.no_assemble then l =| Pdfcrypt.NoAssemble;
|
|
if args.no_hq_print then l =| Pdfcrypt.NoHqPrint;
|
|
!l
|
|
|
|
(* If a file is encrypted, decrypt it using the owner password or, if not
|
|
present, the user password. If the user password is used, the operation to be
|
|
performed is checked to see if it's allowable under the permissions regime. *)
|
|
|
|
(* The bans. Each function has a list of bans. If any of these is present in the
|
|
bans list in the input file, the operation cannot proceed. Other operations
|
|
cannot proceed at all without owner password. *)
|
|
let banned banlist = function
|
|
| Fonts | Info | Metadata | PageInfo | CountPages
|
|
| ListAttachedFiles | ListAnnotations
|
|
| ListBookmarks | ImageResolution _ | ListImages | MissingFonts
|
|
| PrintPageLabels | Clean | Compress | Decompress
|
|
| ChangeId | CopyId _ | ListSpotColours | Version
|
|
| DumpAttachedFiles | RemoveMetadata | EmbedMissingFonts | BookmarksOpenToLevel _ | CreatePDF
|
|
| SetPageMode _ | SetNonFullScreenPageMode _ | HideToolbar _ | HideMenubar _ | HideWindowUI _
|
|
| FitWindow _ | CenterWindow _ | DisplayDocTitle _
|
|
| RemoveId | OpenAtPageFit _ | OpenAtPage _ | OpenAtPageCustom _ | SetPageLayout _
|
|
| ShowBoxes | TrimMarks | CreateMetadata | SetMetadataDate _ | SetVersion _
|
|
| SetAuthor _|SetTitle _|SetSubject _|SetKeywords _|SetCreate _
|
|
| SetModify _|SetCreator _|SetProducer _|RemoveDictEntry _ | ReplaceDictEntry _ | PrintDictEntry _ | SetMetadata _
|
|
| ExtractText | ExtractImages | ExtractFontFile _
|
|
| AddPageLabels | RemovePageLabels | OutputJSON | OCGCoalesce
|
|
| OCGRename | OCGList | OCGOrderAll | PrintFontEncoding _ | TableOfContents | Typeset _ | Composition _
|
|
| TextWidth _ | SetAnnotations _ | CopyAnnotations _ | ExtractStream _ | PrintObj _ | ReplaceObj _
|
|
| Verify _ | MarkAs _ | RemoveMark _ | ExtractStructTree | ReplaceStructTree _ | SetLanguage _
|
|
| PrintStructTree
|
|
-> false (* Always allowed *)
|
|
(* Combine pages is not allowed because we would not know where to get the
|
|
-recrypt from -- the first or second file? *)
|
|
| Decrypt | Encrypt | CombinePages _ -> true (* Never allowed *)
|
|
| AddBookmarks _ | PadBefore | PadAfter | PadEvery _ | PadMultiple _ | PadMultipleBefore _
|
|
| Merge | Split | SplitOnBookmarks _ | SplitMax _ | Spray | RotateContents _ | Rotate _
|
|
| Rotateby _ | Upright | VFlip | HFlip | Impose _ | Chop _ | ChopHV _ | Redact ->
|
|
mem Pdfcrypt.NoAssemble banlist
|
|
| TwoUp | TwoUpStack | RemoveBookmarks | AddRectangle | RemoveText|
|
|
Draft | Shift | ShiftBoxes | Scale | ScaleToFit|Stretch|RemoveAttachedFiles|
|
|
RemoveAnnotations|RemoveFonts|Crop|RemoveCrop|Trim|RemoveTrim|Bleed|RemoveBleed|Art|RemoveArt|
|
|
CopyBox|MediaBox|HardBox _|SetTrapped|SetUntrapped|Presentation|
|
|
BlackText|BlackLines|BlackFills|CopyFont _|StampOn _|StampUnder _|StampAsXObject _|
|
|
AddText _|ScaleContents _|AttachFile _| ThinLines _ | RemoveClipping | RemoveAllText
|
|
| Prepend _ | Postpend _ | Draw | ProcessImages ->
|
|
mem Pdfcrypt.NoEdit banlist
|
|
|
|
let operation_allowed pdf banlist op =
|
|
args.debugforce ||
|
|
match op with
|
|
| None ->
|
|
if args.debugcrypt then Printf.printf "operation is None, so allowed!\n";
|
|
true (* Merge *) (* changed to allow it *)
|
|
| Some op ->
|
|
if args.debugcrypt then Printf.printf "operation_allowed: op = %s\n" (string_of_op op);
|
|
if args.debugcrypt then Printf.printf "Permissions: %s\n" (getpermissions pdf);
|
|
not (banned banlist op)
|
|
|
|
let decrypt_if_necessary (_, _, user_pw, owner_pw, was_dec_with_owner, _) op pdf =
|
|
if args.debugcrypt then
|
|
begin match op with
|
|
None -> flprint "decrypt_if_necessary: op = None\n"
|
|
| Some x -> Printf.printf "decrypt_if_necessary: op = %s\n" (string_of_op x)
|
|
end;
|
|
if not (Pdfcrypt.is_encrypted pdf) then pdf else
|
|
match op with Some (CombinePages _) ->
|
|
(* This is a hack because we don't have support for recryption on combine
|
|
* pages. This is prevented by permissions above, but in the case that the
|
|
* owner password is blank (e.g christmas_tree_lights.pdf), we would end
|
|
* up here. *)
|
|
soft_error "Combine pages: both files must be unencrypted for this operation, or add -decrypt-force"
|
|
| _ ->
|
|
match Pdfcrypt.decrypt_pdf_owner owner_pw pdf with
|
|
| Some pdf ->
|
|
args.was_decrypted_with_owner <- true;
|
|
was_dec_with_owner := true;
|
|
if args.debugcrypt then Printf.printf "Managed to decrypt with owner password\n";
|
|
pdf
|
|
| _ ->
|
|
if args.debugcrypt then Printf.printf "Couldn't decrypt with owner password %s\n" owner_pw;
|
|
match
|
|
if args.debugcrypt then Printf.printf "call decrypt_pdf user\n";
|
|
let r = Pdfcrypt.decrypt_pdf user_pw pdf in
|
|
if args.debugcrypt then Printf.printf "returned from decrypt_pdf\n";
|
|
r
|
|
with
|
|
| Some pdf, permissions ->
|
|
if args.debugcrypt then Printf.printf "Managed to decrypt with user password\n";
|
|
if operation_allowed pdf permissions op
|
|
then pdf
|
|
else soft_error "User password cannot give permission for this operation. Supply owner or add -decrypt-force."
|
|
| _ ->
|
|
if args.debugcrypt then Printf.printf "Failed to decrypt with user password: raising soft_error";
|
|
soft_error "Failed to decrypt file: wrong password?"
|
|
|
|
(* Output Page Count *)
|
|
let output_page_count pdf =
|
|
Printf.printf "%i\n" ((if args.fast then Pdfpage.endpage_fast else Pdfpage.endpage) pdf)
|
|
|
|
let detect_duplicate_op op =
|
|
match args.op with
|
|
None | Some Shift -> ()
|
|
| _ ->
|
|
Pdfe.log (Printf.sprintf "Operation %s already specified, so cannot specify operation %s.\nUse AND from Chapter 1 of the manual to chain commands together.\n"
|
|
(string_of_op (unopt args.op)) (string_of_op op));
|
|
exit 1
|
|
|
|
let setop op () =
|
|
detect_duplicate_op op;
|
|
args.op <- Some op
|
|
|
|
let setout name =
|
|
args.out <- File name;
|
|
spray_outputs := name::!spray_outputs
|
|
|
|
let setchunk c =
|
|
if c > 0
|
|
then args.chunksize <- c
|
|
else error "invalid chunk size"
|
|
|
|
let fixdashes s =
|
|
let bufferdashes chars =
|
|
let buf = ref [] in
|
|
iter
|
|
(function '-' -> buf =@ [' '; '-'; ' '] | x -> buf =| x)
|
|
chars;
|
|
rev !buf
|
|
in
|
|
let chars = explode s in
|
|
implode (bufferdashes chars)
|
|
|
|
let set_input_image f s =
|
|
try
|
|
let fh = open_in_bin s in
|
|
let pdf = Cpdfimage.image_of_input f (Pdfio.input_of_channel fh) in
|
|
begin try close_in fh with _ -> () end;
|
|
args.original_filename <- s;
|
|
args.create_objstm <- true;
|
|
args.inputs <- (AlreadyInMemory (pdf, s), "all", "", "", ref false, None)::args.inputs
|
|
with
|
|
Sys_error _ -> error "Image file not found"
|
|
|
|
let jbig2_global = ref None
|
|
|
|
let set_input_png s = set_input_image (fun () -> Cpdfimage.obj_of_png_data) s
|
|
|
|
let set_input_jpeg s = set_input_image (fun () -> Cpdfimage.obj_of_jpeg_data) s
|
|
|
|
let set_input_jpeg2000 s = set_input_image (fun () -> Cpdfimage.obj_of_jpeg2000_data) s
|
|
|
|
let set_input_jbig2 s =
|
|
set_input_image
|
|
(fun () -> Cpdfimage.obj_of_jbig2_data ?global:!jbig2_global) s;
|
|
args.remove_duplicate_streams <- true
|
|
let encrypt_to_collect = ref 0
|
|
|
|
let setmethod s =
|
|
detect_duplicate_op Encrypt;
|
|
if args.op = None then args.op <- Some Encrypt; (* Could be additional to -split *)
|
|
match s with
|
|
| "40bit" | "128bit" | "AES" | "AES256" | "AES256ISO" -> args.crypt_method <- s
|
|
| _ -> error ("Unsupported encryption method " ^ s)
|
|
|
|
let anon_fun s =
|
|
try
|
|
match !encrypt_to_collect with
|
|
| 3 -> setmethod s; decr encrypt_to_collect
|
|
| 2 -> args.owner <- s; decr encrypt_to_collect
|
|
| 1 -> args.user <- s; decr encrypt_to_collect
|
|
| 0 ->
|
|
let before, after = cleavewhile (neq '=') (explode s) in
|
|
begin match implode before with
|
|
| "user" ->
|
|
begin match args.inputs with
|
|
| [] -> ()
|
|
| (a, b, _, e, f, g)::more ->
|
|
args.inputs <- (a, b, implode (tl after), e, f, g)::more
|
|
end
|
|
| "owner" ->
|
|
begin match args.inputs with
|
|
| [] -> ()
|
|
| (a, b, d, _, f, g)::more ->
|
|
args.inputs <- (a, b, d, implode (tl after), f, g)::more
|
|
end
|
|
| _ -> raise Not_found
|
|
end
|
|
| _ -> assert false
|
|
with
|
|
Not_found ->
|
|
try
|
|
ignore (String.index s '.');
|
|
begin match rev (explode s) with
|
|
| a::b::c::d::e::'.'::r when implode (map Char.uppercase_ascii [e; d; c; b; a]) = "JBIG2" -> set_input_jbig2 s
|
|
| a::b::c::d::'.'::r when implode (map Char.uppercase_ascii [d; c; b; a]) = "JPEG" -> set_input_jpeg s
|
|
| a::b::c::'.'::r when implode (map Char.uppercase_ascii [c; b; a]) = "JPG" -> set_input_jpeg s
|
|
| a::b::c::'.'::r when implode (map Char.uppercase_ascii [c; b; a]) = "JP2" -> set_input_jpeg2000 s
|
|
| a::b::c::'.'::r when implode (map Char.uppercase_ascii [c; b; a]) = "JPX" -> set_input_jpeg2000 s
|
|
| a::b::c::'.'::r when implode (map Char.uppercase_ascii [c; b; a]) = "JPF" -> set_input_jpeg2000 s
|
|
| a::b::c::'.'::r when implode (map Char.uppercase_ascii [c; b; a]) = "PNG" -> set_input_png s
|
|
| _ -> args.inputs <- (InFile s, "all", "", "", ref false, None)::args.inputs
|
|
end;
|
|
args.original_filename <- s
|
|
with
|
|
Not_found ->
|
|
match args.inputs with
|
|
| [] ->
|
|
Pdfe.log (Printf.sprintf "Warning: '%s' ignored\n" s)
|
|
| (a, _, d, e, f, g)::t ->
|
|
args.inputs <- (a, fixdashes s, d, e, f, g)::t
|
|
|
|
(* If a password begins with a dash, we allow -pw=<password> too *)
|
|
let setdashpassword = anon_fun
|
|
|
|
(* Setting operations *)
|
|
let setcrop s =
|
|
setop Crop ();
|
|
args.rectangle <- s
|
|
|
|
let settrim s =
|
|
setop Trim ();
|
|
args.rectangle <- s
|
|
|
|
let setbleed s =
|
|
setop Bleed ();
|
|
args.rectangle <- s
|
|
|
|
let setart s =
|
|
setop Art ();
|
|
args.rectangle <- s
|
|
|
|
let setmediabox s =
|
|
setop MediaBox ();
|
|
args.rectangle <- s
|
|
|
|
let setrectangle s =
|
|
setop AddRectangle ();
|
|
args.coord <- s
|
|
|
|
let setrotate i =
|
|
if i = 0 || i = 90 || i = 180 || i = 270
|
|
then setop (Rotate i) ()
|
|
else error "bad rotation"
|
|
|
|
let setrotateby i =
|
|
if i = 0 || i = 90 || i = 180 || i = 270
|
|
then setop (Rotateby i) ()
|
|
else error "bad rotation"
|
|
|
|
let hidetoolbar b =
|
|
try setop (HideToolbar (bool_of_string b)) () with
|
|
_ -> failwith "HideToolBar: must use true or false"
|
|
|
|
let hidemenubar b =
|
|
try setop (HideMenubar (bool_of_string b)) () with
|
|
_ -> failwith "HideMenuBar: must use true or false"
|
|
|
|
let hidewindowui b =
|
|
try setop (HideWindowUI (bool_of_string b)) () with
|
|
_ -> failwith "HideWindowUI: must use true or false"
|
|
|
|
let fitwindow b =
|
|
try setop (FitWindow (bool_of_string b)) () with
|
|
_ -> failwith "FitWindow: must use true or false"
|
|
|
|
let centerwindow b =
|
|
try setop (CenterWindow (bool_of_string b)) () with
|
|
_ -> failwith "CenterWindow: must use true or false"
|
|
|
|
let displaydoctitle b =
|
|
try setop (DisplayDocTitle (bool_of_string b)) () with
|
|
_ -> failwith "DisplayDocTitle: must use true or false"
|
|
|
|
let read_file_size s =
|
|
let read_int s' =
|
|
try int_of_string (implode (rev s')) with
|
|
_ -> error (Printf.sprintf "Could not read file size specification %s" s)
|
|
in
|
|
match rev (explode (String.uppercase_ascii s)) with
|
|
| 'B'::'I'::'G'::s -> 1024 * 1024 * 1024 * read_int s
|
|
| 'B'::'G'::s -> 1000 * 1000 * 1000 * read_int s
|
|
| 'B'::'I'::'M'::s -> 1024 * 1024 * read_int s
|
|
| 'B'::'M'::s -> 1000 * 1000 * read_int s
|
|
| 'B'::'I'::'K'::s -> 1024 * read_int s
|
|
| 'B'::'K'::s -> 1000 * read_int s
|
|
| s -> read_int s
|
|
|
|
let setsplitmax i = setop (SplitMax (read_file_size i)) ()
|
|
let setstdout () = args.out <- Stdout
|
|
let setstdin () = args.inputs <- [StdIn, "all", "", "", ref false, None]
|
|
let settrans s = args.transition <- Some s
|
|
let setduration f = args.duration <- Some f
|
|
let setvertical () = args.horizontal <- false
|
|
let setoutward () = args.inward <- false
|
|
let setdirection i =
|
|
args.direction <-
|
|
match i with
|
|
| 0 | 90 | 180 | 270 | 315 -> i
|
|
| _ -> error "Bad direction"
|
|
let seteffectduration f = args.effect_duration <- f
|
|
let setcopyid s = setop (CopyId s) ()
|
|
let setthinlines s = setop (ThinLines (Cpdfcoord.parse_single_number empty s)) ()
|
|
|
|
let setcopyannotations s = setop (CopyAnnotations s) ()
|
|
|
|
let setsetannotations s = setop (SetAnnotations s) ()
|
|
|
|
let setshift s =
|
|
setop Shift ();
|
|
args.coord <- s
|
|
|
|
let setshiftboxes s =
|
|
setop ShiftBoxes ();
|
|
args.coord <- s
|
|
|
|
let setscale s =
|
|
setop Scale ();
|
|
args.coord <- s
|
|
|
|
let setscaletofit s =
|
|
setop ScaleToFit ();
|
|
args.coord <- s
|
|
|
|
let setstretch s =
|
|
setop Stretch ();
|
|
args.coord <- s
|
|
|
|
let setattachfile s =
|
|
match args.op with
|
|
| Some (AttachFile t) ->
|
|
args.op <- Some (AttachFile (s::t))
|
|
| None ->
|
|
setop (AttachFile [s]) ()
|
|
| Some _ -> detect_duplicate_op (AttachFile [s])
|
|
|
|
let setextracttextfontsize f =
|
|
args.extract_text_font_size <- Some f
|
|
|
|
let setfontsize f =
|
|
if f > 0. then args.fontsize <- f else error "Negative font size specified"
|
|
|
|
let setaddtext s =
|
|
setop (AddText s) ()
|
|
|
|
let setcolor s =
|
|
args.color <- Cpdfdrawcontrol.parse_colour s
|
|
|
|
let setopacity o =
|
|
args.opacity <- o
|
|
|
|
let setaddbookmarks s =
|
|
setop (AddBookmarks s) ()
|
|
|
|
let setaddbookmarksjson s =
|
|
setop (AddBookmarks s) ();
|
|
args.format_json <- true
|
|
|
|
let setlistfontsjson () =
|
|
setop Fonts ();
|
|
args.format_json <- true
|
|
|
|
let setinfojson () =
|
|
setop Info ();
|
|
args.format_json <- true
|
|
|
|
let setpageinfojson () =
|
|
setop PageInfo ();
|
|
args.format_json <- true
|
|
|
|
let setprintpagelabelsjson () =
|
|
setop PrintPageLabels ();
|
|
args.format_json <- true
|
|
|
|
let setlistbookmarksjson () =
|
|
setop ListBookmarks ();
|
|
args.format_json <- true
|
|
|
|
let setlistannotationsjson () =
|
|
setop ListAnnotations ();
|
|
args.format_json <- true
|
|
|
|
let setstampon f =
|
|
setop (StampOn f) ();
|
|
(* Due to an earlier bad decision (default position), we have this nasty hack *)
|
|
if args.position = Cpdfposition.TopLeft (100., 100.) then args.position <- Cpdfposition.BottomLeft (0., 0.)
|
|
|
|
let setstampunder f =
|
|
setop (StampUnder f) ();
|
|
if args.position = Cpdfposition.TopLeft (100., 100.) then args.position <- Cpdfposition.BottomLeft (0., 0.)
|
|
|
|
let setstampasxobject f =
|
|
setop (StampAsXObject f) ()
|
|
|
|
let setcombinepages f =
|
|
setop (CombinePages f) ()
|
|
|
|
let setposcenter s =
|
|
let x, y = Cpdfcoord.parse_coordinate empty s in
|
|
args.position <- Cpdfposition.PosCentre (x, y)
|
|
|
|
let setposleft s =
|
|
let x, y = Cpdfcoord.parse_coordinate empty s in
|
|
args.position <- Cpdfposition.PosLeft (x, y)
|
|
|
|
let setposright s =
|
|
let x, y = Cpdfcoord.parse_coordinate empty s in
|
|
args.position <- Cpdfposition.PosRight (x, y)
|
|
|
|
let settop n =
|
|
args.position <- Cpdfposition.Top (Cpdfcoord.parse_single_number empty n);
|
|
args.justification <- Cpdfaddtext.CentreJustify
|
|
|
|
let settopleft n =
|
|
let coord =
|
|
match Cpdfcoord.parse_coordinate empty n with
|
|
| (a, b) -> Cpdfposition.TopLeft (a, b)
|
|
| exception _ ->
|
|
let x = Cpdfcoord.parse_single_number empty n in
|
|
Cpdfposition.TopLeft (x, x)
|
|
in
|
|
args.position <- coord;
|
|
args.justification <- Cpdfaddtext.LeftJustify
|
|
|
|
let settopright n =
|
|
let coord =
|
|
match Cpdfcoord.parse_coordinate empty n with
|
|
| (a, b) -> Cpdfposition.TopRight (a, b)
|
|
| exception _ ->
|
|
let x = Cpdfcoord.parse_single_number empty n in
|
|
Cpdfposition.TopRight (x, x)
|
|
in
|
|
args.position <- coord;
|
|
args.justification <- Cpdfaddtext.RightJustify
|
|
|
|
let setleft n =
|
|
args.position <- Cpdfposition.Left (Cpdfcoord.parse_single_number empty n);
|
|
args.justification <- Cpdfaddtext.LeftJustify
|
|
|
|
let setbottomleft n =
|
|
let coord =
|
|
match Cpdfcoord.parse_coordinate empty n with
|
|
| (a, b) -> Cpdfposition.BottomLeft (a, b)
|
|
| exception _ ->
|
|
let x = Cpdfcoord.parse_single_number empty n in
|
|
Cpdfposition.BottomLeft (x, x)
|
|
in
|
|
args.position <- coord;
|
|
args.justification <- Cpdfaddtext.LeftJustify
|
|
|
|
let setbottom n =
|
|
args.position <- Cpdfposition.Bottom (Cpdfcoord.parse_single_number empty n);
|
|
args.justification <- Cpdfaddtext.CentreJustify
|
|
|
|
let setbottomright n =
|
|
let coord =
|
|
match Cpdfcoord.parse_coordinate empty n with
|
|
| (a, b) -> Cpdfposition.BottomRight (a, b)
|
|
| exception _ ->
|
|
let x = Cpdfcoord.parse_single_number empty n in
|
|
Cpdfposition.BottomRight (x, x)
|
|
in
|
|
args.position <- coord;
|
|
args.justification <- Cpdfaddtext.RightJustify
|
|
|
|
let setright n =
|
|
args.position <- Cpdfposition.Right (Cpdfcoord.parse_single_number empty n);
|
|
args.justification <- Cpdfaddtext.RightJustify
|
|
|
|
let setdiagonal n =
|
|
args.position <- Cpdfposition.Diagonal;
|
|
args.justification <- Cpdfaddtext.CentreJustify
|
|
|
|
let setreversediagonal n =
|
|
args.position <- Cpdfposition.ReverseDiagonal;
|
|
args.justification <- Cpdfaddtext.CentreJustify
|
|
|
|
let setcenter n =
|
|
args.position <- Cpdfposition.Centre;
|
|
args.justification <- Cpdfaddtext.CentreJustify
|
|
|
|
(* Calculate -bates automatically so that n is applied to the first page in the range *)
|
|
let setbatesrange n =
|
|
let first_page =
|
|
let range = Cpdfpagespec.parse_pagespec_without_pdf (get_pagespec ()) in
|
|
fold_left min max_int range
|
|
in
|
|
args.bates <- n + 1 - first_page
|
|
|
|
let set_input s =
|
|
args.original_filename <- s;
|
|
args.inputs <- (InFile s, "all", "", "", ref false, None)::args.inputs
|
|
|
|
let set_json_input s =
|
|
args.original_filename <- s;
|
|
args.create_objstm <- true;
|
|
let fh = open_in_bin s in
|
|
let pdf = Cpdfjson.of_input (Pdfio.input_of_channel fh) in
|
|
close_in fh;
|
|
args.inputs <- (AlreadyInMemory (pdf, s), "all", "", "", ref false, None)::args.inputs
|
|
|
|
let set_input_dir s =
|
|
let names = sort compare (leafnames_of_dir s) in
|
|
let names =
|
|
if args.idir_only_pdfs then
|
|
option_map
|
|
(fun x ->
|
|
if String.length x > 4 && String.lowercase_ascii (String.sub x (String.length x - 4) 4) = ".pdf"
|
|
then Some x else None)
|
|
names
|
|
else
|
|
names
|
|
in
|
|
args.inputs <-
|
|
(rev
|
|
(map
|
|
(fun n -> (InFile (s ^ Filename.dir_sep ^ n), "all", "", "", ref false, None)) names))
|
|
@ args.inputs
|
|
|
|
let setdebug () =
|
|
set Pdfread.read_debug;
|
|
set Pdfwrite.write_debug;
|
|
set Pdfcrypt.crypt_debug;
|
|
set Pdfops.debug;
|
|
args.debug <- true
|
|
|
|
let setboxes () =
|
|
args.boxes <- true
|
|
|
|
let set_no_encrypt_metadata () =
|
|
args.encrypt_metadata <- false
|
|
|
|
let set_retain_numbering () =
|
|
args.retain_numbering <- true
|
|
|
|
let set_remove_duplicate_fonts () =
|
|
args.remove_duplicate_fonts <- true
|
|
|
|
let setencoding enc () =
|
|
args.encoding <- enc
|
|
|
|
let setscaletofitscale f =
|
|
args.scale <- f
|
|
|
|
let setscalecontents f =
|
|
detect_duplicate_op (ScaleContents f);
|
|
args.op <- Some (ScaleContents f);
|
|
args.position <- Cpdfposition.Diagonal (* Will be center *)
|
|
|
|
let setsqueeze () =
|
|
args.squeeze <- true;
|
|
args.create_objstm <- true
|
|
|
|
let setcreatoraswego s =
|
|
args.creator <- Some s
|
|
|
|
let setproduceraswego s =
|
|
args.producer <- Some s
|
|
|
|
let setprepend s =
|
|
args.op <- Some (Prepend s)
|
|
|
|
let setpostpend s =
|
|
args.op <- Some (Postpend s)
|
|
|
|
(* Parsing the control file *)
|
|
let rec getuntilendquote prev = function
|
|
| [] -> implode (rev prev), []
|
|
| '"'::t -> implode (rev prev), t
|
|
| '\\'::'"'::t -> getuntilendquote ('"'::prev) t
|
|
| h::t -> getuntilendquote (h::prev) t
|
|
|
|
let rec getarg prev = function
|
|
| [] -> implode (rev prev), []
|
|
| h::t ->
|
|
if Pdf.is_whitespace h
|
|
then implode (rev prev), t
|
|
else getarg (h::prev) t
|
|
|
|
let rec parse_chars args = function
|
|
| [] -> rev args
|
|
| h::more when Pdf.is_whitespace h ->
|
|
parse_chars args more
|
|
| '"'::more ->
|
|
let this, rest = getuntilendquote [] more in
|
|
parse_chars (this::args) rest
|
|
| h::t ->
|
|
let this, rest = getarg [] (h::t) in
|
|
parse_chars (this::args) rest
|
|
|
|
let parse_control_file name =
|
|
(parse_chars []
|
|
(charlist_of_bytes (Pdfio.bytes_of_input_channel (open_in_bin name))))
|
|
|
|
let parse_control_file_json name =
|
|
try
|
|
match Cpdfyojson.Safe.from_file name with
|
|
| `List ls -> map (function `String s -> s | _ -> raise Exit) ls
|
|
| _ -> raise Exit
|
|
with
|
|
Exit -> error "Syntax error in JSON control file."
|
|
|
|
let setencryptcollect () =
|
|
encrypt_to_collect := 3
|
|
|
|
let setcopyfont s =
|
|
detect_duplicate_op (CopyFont s);
|
|
args.op <- Some (CopyFont s)
|
|
|
|
let setfontpage i =
|
|
args.copyfontpage <- i
|
|
|
|
let setcopyfontname s =
|
|
args.copyfontname <- Some s
|
|
|
|
let setpadevery i =
|
|
detect_duplicate_op (PadEvery i);
|
|
if i > 0 then
|
|
args.op <- Some (PadEvery i)
|
|
else
|
|
error "PadEvery: must be > 0"
|
|
|
|
let setpadwith filename =
|
|
args.padwith <- Some filename
|
|
|
|
let setpadmultiple i =
|
|
detect_duplicate_op (PadMultiple i);
|
|
args.op <- Some (PadMultiple i)
|
|
|
|
let setpadmultiplebefore i =
|
|
detect_duplicate_op (PadMultipleBefore i);
|
|
args.op <- Some (PadMultipleBefore i)
|
|
|
|
let setfast () =
|
|
args.fast <- true
|
|
|
|
(* Explicitly add a range. Parse it and replace the top input file with the range. *)
|
|
let setrange spec =
|
|
args.dashrange <- spec;
|
|
match args.inputs with
|
|
(x, _, c, d, e, f)::more ->
|
|
args.inputs <- (x, spec, c, d, e, f) :: more
|
|
| x -> ()
|
|
|
|
let setrevision n =
|
|
match args.inputs with
|
|
(a, b, c, d, e, _)::more ->
|
|
args.inputs <- (a, b, c, d, e, Some n) :: more
|
|
| [] ->
|
|
Pdfe.log "Warning. -revision ignored. Put it after the filename.\n"
|
|
|
|
let setimageresolution f =
|
|
detect_duplicate_op (ImageResolution f);
|
|
args.op <- Some (ImageResolution f)
|
|
|
|
let setimpath p =
|
|
args.path_to_im <- p
|
|
|
|
let setjbig2encpath p =
|
|
args.path_to_jbig2enc <- p
|
|
|
|
let setp2ppath p =
|
|
args.path_to_p2p <- p
|
|
|
|
let setfrombox s =
|
|
detect_duplicate_op CopyBox;
|
|
args.op <- Some CopyBox;
|
|
args.frombox <- Some s
|
|
|
|
let settobox s =
|
|
args.tobox <- Some s
|
|
|
|
let setmediaboxifmissing () =
|
|
args.mediabox_if_missing <- true
|
|
|
|
let settopage s =
|
|
args.topage <- Some s
|
|
|
|
let setstdinuser u =
|
|
match args.inputs with
|
|
| (StdIn, x, _, o, f, g)::t -> args.inputs <- (StdIn, x, u, o, f, g)::t
|
|
| _ -> error "-stdin-user: must follow -stdin"
|
|
|
|
let setstdinowner o =
|
|
match args.inputs with
|
|
| (StdIn, x, u, _, f, g)::t -> args.inputs <- (StdIn, x, u, o, f, g)::t
|
|
| _ -> error "-stdin-owner: must follow -stdin"
|
|
|
|
let setopenatpage n =
|
|
detect_duplicate_op (OpenAtPage n);
|
|
args.op <- Some (OpenAtPage n)
|
|
|
|
let setopenatpagefit n =
|
|
detect_duplicate_op (OpenAtPageFit n);
|
|
args.op <- Some (OpenAtPageFit n)
|
|
|
|
let setopenatpagecustom n =
|
|
detect_duplicate_op (OpenAtPageCustom n);
|
|
args.op <- Some (OpenAtPageCustom n)
|
|
|
|
let setlabelstyle s =
|
|
let style =
|
|
match s with
|
|
| "DecimalArabic" -> Pdfpagelabels.DecimalArabic
|
|
| "UppercaseRoman" -> Pdfpagelabels.UppercaseRoman
|
|
| "LowercaseRoman" -> Pdfpagelabels.LowercaseRoman
|
|
| "UppercaseLetters" -> Pdfpagelabels.UppercaseLetters
|
|
| "LowercaseLetters" -> Pdfpagelabels.LowercaseLetters
|
|
| "NoLabelPrefixOnly" -> Pdfpagelabels.NoLabelPrefixOnly
|
|
| _ -> error "Unknown label style"
|
|
in
|
|
args.labelstyle <- style
|
|
|
|
let setlabelprefix s =
|
|
args.labelprefix <- Some s
|
|
|
|
let setlabelstartval i =
|
|
args.labelstartval <- i
|
|
|
|
let setlabelsprogress () =
|
|
args.labelsprogress <- true
|
|
|
|
let setcpdflin s =
|
|
args.cpdflin <- Some s
|
|
|
|
let setrecrypt () =
|
|
args.recrypt <- true
|
|
|
|
let setremovedictentry s =
|
|
detect_duplicate_op (RemoveDictEntry s);
|
|
args.op <- Some (RemoveDictEntry s)
|
|
|
|
let logto = ref None
|
|
|
|
let setsqueezelogto s =
|
|
logto := Some s
|
|
|
|
let setstayonerror () =
|
|
set stay_on_error
|
|
|
|
let setembedstd14 s =
|
|
args.embedstd14 <- Some s
|
|
|
|
let _ =
|
|
Cpdfdrawcontrol.setembedstd14 := (fun b dir -> if b then args.embedstd14 <- Some dir else args.embedstd14 <- None)
|
|
|
|
let sethardbox box =
|
|
detect_duplicate_op (HardBox box);
|
|
args.op <- Some (HardBox box)
|
|
|
|
let setalsosetxml () =
|
|
args.alsosetxml <- true
|
|
|
|
let setjustsetxml () =
|
|
args.justsetxml <- true
|
|
|
|
let setsetmetadatadate d =
|
|
detect_duplicate_op (SetMetadataDate d);
|
|
args.op <- Some (SetMetadataDate d)
|
|
|
|
let setgsmalformed () =
|
|
args.gs_malformed <- true
|
|
|
|
let setmergeaddbookmarks () =
|
|
args.merge_add_bookmarks <- true
|
|
|
|
let setmergeaddbookmarksusetitles () =
|
|
args.merge_add_bookmarks_use_titles <- true
|
|
|
|
let setbookmarksopentolevel l =
|
|
detect_duplicate_op (BookmarksOpenToLevel l);
|
|
args.op <- Some (BookmarksOpenToLevel l)
|
|
|
|
let setcreatepdfpages i =
|
|
args.createpdf_pages <- i
|
|
|
|
let setcreatepdfpapersize s =
|
|
args.createpdf_pagesize <-
|
|
let w, h = Cpdfcoord.parse_coordinate (Pdf.empty ()) s in
|
|
Pdfpaper.make Pdfunits.PdfPoint w h
|
|
|
|
let setimpose s =
|
|
setop (Impose true) ();
|
|
args.coord <- s
|
|
|
|
let setimposexy s =
|
|
setop (Impose false) ();
|
|
args.coord <- s
|
|
|
|
let setchop s =
|
|
let x, y = Cpdfcoord.parse_coordinate empty s in
|
|
setop (Chop (int_of_float x, int_of_float y)) ()
|
|
|
|
let setchopv x =
|
|
setop (ChopHV (false, Cpdfcoord.parse_single_number (Pdf.empty ()) x)) ()
|
|
|
|
let setchoph y =
|
|
setop (ChopHV (true, Cpdfcoord.parse_single_number (Pdf.empty ()) y)) ()
|
|
|
|
let setreplacedictentry s =
|
|
setop (ReplaceDictEntry s) ()
|
|
|
|
let setprintdictentry s =
|
|
setop (PrintDictEntry s) ()
|
|
|
|
let setreplacedictentryvalue s =
|
|
try
|
|
let pdfobj = Cpdfjson.object_of_json (Cpdfyojson.Safe.from_string s) in
|
|
args.replace_dict_entry_value <- pdfobj
|
|
with
|
|
e -> error (Printf.sprintf "Failed to parse replacement value: %s\n" (Printexc.to_string e))
|
|
|
|
let setdictentrysearch s =
|
|
try
|
|
let pdfobj = Cpdfjson.object_of_json (Cpdfyojson.Safe.from_string s) in
|
|
args.dict_entry_search <- Some pdfobj
|
|
with
|
|
e -> error (Printf.sprintf "Failed to parse search term: %s\n" (Printexc.to_string e))
|
|
|
|
let setprintfontencoding s =
|
|
setop (PrintFontEncoding s) ()
|
|
|
|
let settypeset s =
|
|
setop (Typeset s) ()
|
|
|
|
let settypesetsubformat s =
|
|
args.subformat <- Some (Cpdfua.subformat_of_string s)
|
|
|
|
let settableofcontentstitle s =
|
|
args.toc_title <- s
|
|
|
|
let settocnobookmark () =
|
|
args.toc_bookmark <- false
|
|
|
|
let setidironlypdfs () =
|
|
args.idir_only_pdfs <- true
|
|
|
|
let setnowarnrotate () =
|
|
args.no_warn_rotate <- true
|
|
|
|
let whingemalformed () =
|
|
Pdfe.log "Command line must be of exactly the form\ncpdf <infile> -gs <path> -gs-malformed-force -o <outfile>\n";
|
|
exit 1
|
|
|
|
let addop o =
|
|
begin match o with Cpdfdraw.FontPack _ -> set Cpdfdrawcontrol.fontpack_initialised | _ -> () end;
|
|
begin match args.op with Some Draw -> () | _ -> error "Need to be in drawing mode for this." end;
|
|
Cpdfdrawcontrol.addop o
|
|
|
|
let embed_font_inner font =
|
|
match font with
|
|
| StandardFont f ->
|
|
(* Printf.printf "embed_font: StandardFont\n";*)
|
|
begin match args.embedstd14 with
|
|
| Some dirname ->
|
|
begin try
|
|
let fontfile, fontname = Cpdfembed.load_substitute dirname f in
|
|
Cpdfembed.EmbedInfo {fontfile; fontname; encoding = args.fontencoding}
|
|
with
|
|
e -> error (Printf.sprintf "Can't load font for embedding: %s\n" (Printexc.to_string e))
|
|
end
|
|
| None ->
|
|
PreMadeFontPack (Cpdfembed.fontpack_of_standardfont (Pdftext.StandardFont (f, args.fontencoding)))
|
|
end
|
|
| OtherFont f ->
|
|
ExistingNamedFont
|
|
| EmbeddedFont name ->
|
|
(*Printf.printf "embed_font: TTF\n";*)
|
|
try
|
|
let fontname, font = Hashtbl.find Cpdfdrawcontrol.ttfs name in
|
|
args.fontname <- fontname;
|
|
font
|
|
with
|
|
Not_found -> error (Printf.sprintf "Font %s not found" name)
|
|
|
|
let embed_font () = embed_font_inner args.font
|
|
|
|
let _ = Cpdfdrawcontrol.embed_font := embed_font
|
|
|
|
let _ = Cpdfdrawcontrol.setdrawing := (fun () -> args.op <- Some Draw)
|
|
|
|
let setfont f =
|
|
(*Printf.printf "Cpdfcommand.setfont: |%s|\n%!" f;*)
|
|
try
|
|
let fontname, _ = Hashtbl.find Cpdfdrawcontrol.ttfs f in
|
|
args.font <- EmbeddedFont f;
|
|
args.fontname <- fontname
|
|
with
|
|
Not_found ->
|
|
let convert f = (* convert from written PDF representation to internal PDF string e.g # sequences *)
|
|
match Pdfread.lex_name (Pdfio.input_of_string f) with Pdfgenlex.LexName s -> s | _ -> assert false
|
|
in
|
|
args.font <-
|
|
begin match Pdftext.standard_font_of_name ("/" ^ f) with
|
|
| Some x -> StandardFont x
|
|
| None ->
|
|
if f <> "" && hd (explode f) <> '/' then error "Font not found";
|
|
OtherFont (convert f)
|
|
end;
|
|
args.fontname <-
|
|
begin match Pdftext.standard_font_of_name ("/" ^ f) with
|
|
| Some x -> f
|
|
| None -> convert f
|
|
end;
|
|
(* If drawing, add the font pack as an op. *)
|
|
begin match args.op with Some Draw -> addop (Cpdfdraw.FontPack (f, embed_font (), null_hash ())) | _ -> () end
|
|
|
|
let loadttf n =
|
|
(*Printf.printf "loadttf: %s\n" n;*)
|
|
let name, filename =
|
|
match String.split_on_char '=' n with
|
|
| [name; filename] -> name, filename
|
|
| _ -> error "loadttf: bad file specification. Should be <name>=<filename>"
|
|
in
|
|
try
|
|
let fontfile = Pdfio.bytes_of_string (contents_of_file filename) in
|
|
let fontname = Filename.remove_extension (Filename.basename filename) in
|
|
Hashtbl.replace
|
|
Cpdfdrawcontrol.ttfs
|
|
name
|
|
(fontname, Cpdfembed.EmbedInfo {fontfile; fontname; encoding = args.fontencoding});
|
|
(* If drawing, add the font pack as an op. *)
|
|
begin match args.op with
|
|
Some Draw -> addop (Cpdfdraw.FontPack (fontname, embed_font_inner (EmbeddedFont name), null_hash ())) | _ -> () end
|
|
with
|
|
_ -> error "addtff: could not load TTF"
|
|
|
|
let () = Cpdfdrawcontrol.loadttf := loadttf
|
|
|
|
let setstderrtostdout () =
|
|
Pdfe.logger := (fun s -> print_string s; flush stdout)
|
|
|
|
let settextwidth s =
|
|
args.op <- Some (TextWidth s)
|
|
|
|
let setdraw () =
|
|
args.op <- Some Draw
|
|
|
|
let setdrawstructtree () =
|
|
args.draw_struct_tree <- true
|
|
|
|
let setextractfontfile s =
|
|
args.op <- Some (ExtractFontFile s)
|
|
|
|
let () = Cpdfdrawcontrol.getfontname := fun () -> args.fontname
|
|
let () = Cpdfdrawcontrol.getfontsize := fun () -> args.fontsize
|
|
let () = Cpdfdrawcontrol.setfontname := setfont
|
|
let () = Cpdfdrawcontrol.setfontsize := fun s -> args.fontsize <- s
|
|
let () = Cpdfdrawcontrol.getindent := fun () -> args.indent
|
|
|
|
let setlistimagesjson () =
|
|
setop ListImages ();
|
|
args.format_json <- true
|
|
|
|
let set_jbig2_global f =
|
|
jbig2_global := Some (Pdfio.bytes_of_string (contents_of_file f))
|
|
|
|
let clear_jbig2_global () =
|
|
jbig2_global := None
|
|
|
|
let setjpegquality q =
|
|
args.jpegquality <- q
|
|
|
|
let setjpegqualitylossless q =
|
|
args.jpegqualitylossless <- q
|
|
|
|
let set1bppmethod m =
|
|
args.onebppmethod <- m
|
|
|
|
let setpixelthreshold i =
|
|
args.pixel_threshold <- i
|
|
|
|
let setlengththreshold i =
|
|
args.length_threshold <- i
|
|
|
|
let setpercentagethreshold i =
|
|
args.percentage_threshold <- i
|
|
|
|
let setdpithreshold i =
|
|
args.dpi_threshold <- i
|
|
|
|
let setlosslessresample i =
|
|
args.resample_factor <- i
|
|
|
|
let setlosslessresampledpi i =
|
|
args.resample_factor <- -.i
|
|
|
|
let setresampleinterpolate () =
|
|
args.resample_interpolate <- true
|
|
|
|
let setjbig2_lossy_threshold f =
|
|
args.jbig2_lossy_threshold <- f
|
|
|
|
let setprocessimagesinfo () =
|
|
set Cpdfimage.debug_image_processing
|
|
|
|
let setextractstream s =
|
|
args.op <- Some (ExtractStream s)
|
|
|
|
let setextractstreamdecomp s =
|
|
args.op <- Some (ExtractStream s);
|
|
args.extract_stream_decompress <- true
|
|
|
|
let setprintobj s =
|
|
args.op <- Some (PrintObj s)
|
|
|
|
let setreplaceobj s =
|
|
match String.split_on_char '=' s with
|
|
| [a; b] -> args.op <- Some (ReplaceObj (a, b))
|
|
| _ -> error "replace_obj: bad specification"
|
|
|
|
let expand_namespace = function
|
|
| "PDF" -> standard_namespace
|
|
| "PDF2" -> pdf2_namespace
|
|
| x -> x
|
|
|
|
let setreadableops () =
|
|
Pdfops.whitespace := "\n";
|
|
Pdfops.always_add_whitespace := true;
|
|
Pdfops.write_comments := true
|
|
|
|
let specs =
|
|
[("-version",
|
|
Arg.Unit (setop Version),
|
|
" Print the cpdf version number");
|
|
("-o",
|
|
Arg.String setout,
|
|
" Set the output file, if appropriate");
|
|
("-i",
|
|
Arg.String set_input,
|
|
" Add an input file");
|
|
("-png",
|
|
Arg.String set_input_png,
|
|
" Load from a PNG file, converting to PDF");
|
|
("-jpeg",
|
|
Arg.String set_input_jpeg,
|
|
" Load from a JPEG file, converting to PDF");
|
|
("-jpeg2000",
|
|
Arg.String set_input_jpeg2000,
|
|
" Load from a JPEG2000 file, converting to PDF");
|
|
("-jbig2",
|
|
Arg.String set_input_jbig2,
|
|
" Load from a JBIG2 fragment, converting to PDF");
|
|
("-jbig2-global",
|
|
Arg.String set_jbig2_global,
|
|
" Load a JBIG2 global stream");
|
|
("-jbig2-global-clear",
|
|
Arg.Unit clear_jbig2_global,
|
|
" Forget any JBIG2 global stream");
|
|
("-idir",
|
|
Arg.String set_input_dir,
|
|
" Add a directory of files");
|
|
("-idir-only-pdfs",
|
|
Arg.Unit setidironlypdfs,
|
|
" Have -idir ignore files not ending in .pdf");
|
|
("-pw",
|
|
Arg.String setdashpassword,
|
|
" Supply a password explicitly -pw=<password>");
|
|
("-stdin",
|
|
Arg.Unit setstdin,
|
|
" Read input from standard input");
|
|
("-stdin-owner",
|
|
Arg.String setstdinowner,
|
|
" Owner password for -stdin");
|
|
("-stdin-user",
|
|
Arg.String setstdinuser,
|
|
" User password for -stdin");
|
|
("-stdout",
|
|
Arg.Unit setstdout,
|
|
" Send result to standard output");
|
|
("-error-on-malformed",
|
|
Arg.Set Pdfread.error_on_malformed,
|
|
" Do not try to read malformed files");
|
|
("-range",
|
|
Arg.String setrange,
|
|
" Explicitly add a range");
|
|
("-collate",
|
|
Arg.Unit (fun () -> args.collate <- true),
|
|
" Collate ranges when merging");
|
|
("-revision",
|
|
Arg.Int setrevision,
|
|
"");
|
|
("-change-id",
|
|
Arg.Unit (setop ChangeId),
|
|
" Change the file's /ID tag");
|
|
("-no-preserve-objstm",
|
|
Arg.Unit (fun () -> args.preserve_objstm <- false),
|
|
" Don't preserve object streams");
|
|
("-create-objstm",
|
|
Arg.Unit (fun () -> args.create_objstm <- true),
|
|
" Create object streams anew");
|
|
("-keep-version",
|
|
Arg.Unit (fun () -> args.keepversion <- true),
|
|
" Don't change the version number");
|
|
("-l",
|
|
Arg.Unit (fun () -> args.linearize <- true),
|
|
" Linearize output file");
|
|
("-keep-l",
|
|
Arg.Unit (fun () -> args.keeplinearize <- true),
|
|
" Linearize if the input file was linearized");
|
|
("-cpdflin",
|
|
Arg.String setcpdflin,
|
|
" Set location of 'cpdflin'");
|
|
("-recrypt",
|
|
Arg.Unit setrecrypt,
|
|
" Keep this file's encryption when writing");
|
|
("-raw",
|
|
Arg.Unit (setencoding Cpdfmetadata.Raw),
|
|
" Do not process text");
|
|
("-stripped",
|
|
Arg.Unit (setencoding Cpdfmetadata.Stripped),
|
|
" Process text by simple stripping to ASCII");
|
|
("-utf8",
|
|
Arg.Unit (setencoding Cpdfmetadata.UTF8),
|
|
" Process text by conversion to UTF8 Unicode");
|
|
("-fast",
|
|
Arg.Unit setfast,
|
|
" Speed over correctness with malformed documents");
|
|
("-args",
|
|
Arg.Unit (fun () -> ()),
|
|
" Get arguments from a file.");
|
|
("-args-json",
|
|
Arg.Unit (fun () -> ()),
|
|
" Get arguments from a JSON file.");
|
|
("-merge",
|
|
Arg.Unit (setop Merge),
|
|
" Merge a number of files into one");
|
|
("-retain-numbering",
|
|
Arg.Unit set_retain_numbering,
|
|
" Don't renumber pages when merging");
|
|
("-merge-add-bookmarks",
|
|
Arg.Unit setmergeaddbookmarks,
|
|
" Add bookmarks for each file to merged file");
|
|
("-merge-add-bookmarks-use-titles",
|
|
Arg.Unit setmergeaddbookmarksusetitles,
|
|
" Use title of document rather than filename");
|
|
("-process-struct-trees",
|
|
Arg.Unit (fun () -> args.process_struct_trees <- true),
|
|
" Process structure trees");
|
|
("-remove-duplicate-fonts",
|
|
Arg.Unit set_remove_duplicate_fonts,
|
|
" Remove duplicate fonts when merging");
|
|
("-split",
|
|
Arg.Unit (setop Split),
|
|
" Split a file into individual pages");
|
|
("-chunk",
|
|
Arg.Int setchunk,
|
|
" Set chunk size for -split (default 1)");
|
|
("-split-bookmarks",
|
|
Arg.Int (fun i -> setop (SplitOnBookmarks i) ()),
|
|
" Split a file at bookmarks at a given level");
|
|
("-split-max",
|
|
Arg.String setsplitmax,
|
|
" Split a file to files of a given size");
|
|
("-spray",
|
|
Arg.Unit (setop Spray),
|
|
" Split a file by alternating pages");
|
|
("-scale-page",
|
|
Arg.String setscale,
|
|
" -scale-page \"sx sy\" scales by (sx, sy)");
|
|
("-scale-to-fit",
|
|
Arg.String setscaletofit,
|
|
" -scale-to-fit \"x y\" scales to page size (x, y)");
|
|
("-stretch",
|
|
Arg.String setstretch,
|
|
" -stretch \"x y\" scales without preserving aspect ratio");
|
|
("-scale-contents",
|
|
Arg.Float setscalecontents,
|
|
" Scale contents by the given factor");
|
|
("-scale-to-fit-scale",
|
|
Arg.Float setscaletofitscale,
|
|
" -scale-to-fit-scale (1.0 = 100%)");
|
|
("-shift",
|
|
Arg.String setshift,
|
|
" -shift \"dx dy\" shifts the chosen pages");
|
|
("-shift-boxes",
|
|
Arg.String setshiftboxes,
|
|
" -shift-boxes \"dx dy\" shifts boxes on the chosen pages");
|
|
("-rotate",
|
|
Arg.Int setrotate,
|
|
" Set rotation of pages to 0, 90, 180, 270");
|
|
("-rotateby",
|
|
Arg.Int setrotateby,
|
|
" Rotate pages by 90, 180 or 270 degrees");
|
|
("-rotate-contents",
|
|
Arg.Float (fun f -> setop (RotateContents f) ()),
|
|
" Rotate contents of pages");
|
|
("-upright",
|
|
Arg.Unit (setop Upright),
|
|
" Make pages upright");
|
|
("-prerotate",
|
|
Arg.Unit (fun () -> args.prerotate <- true),
|
|
" Calls -upright on pages before modifying them, if required");
|
|
("-no-warn-rotate",
|
|
Arg.Unit setnowarnrotate,
|
|
" Do not warn on pages of PDFs which are not upright");
|
|
("-hflip",
|
|
Arg.Unit (setop HFlip),
|
|
" Flip pages horizontally");
|
|
("-vflip",
|
|
Arg.Unit (setop VFlip),
|
|
" Flip pages vertically");
|
|
("-crop",
|
|
Arg.String setcrop,
|
|
" Crop specified pages (synonym for -cropbox)");
|
|
("-cropbox",
|
|
Arg.String setcrop,
|
|
" Crop specified pages");
|
|
("-artbox",
|
|
Arg.String setart,
|
|
" Set art box for specified pages");
|
|
("-bleedbox",
|
|
Arg.String setbleed,
|
|
" Set bleed box for specified pages");
|
|
("-trimbox",
|
|
Arg.String settrim,
|
|
" Set trim box for specified pages");
|
|
("-hard-box",
|
|
Arg.String sethardbox,
|
|
" Hard crop specified pages to the given box");
|
|
("-show-boxes",
|
|
Arg.Unit (setop ShowBoxes),
|
|
" Show boxes by adding rectangles to pages");
|
|
("-trim-marks",
|
|
Arg.Unit (setop TrimMarks),
|
|
" Add trim marks");
|
|
("-remove-crop",
|
|
Arg.Unit (setop RemoveCrop),
|
|
" Remove cropping on specified pages");
|
|
("-remove-cropbox",
|
|
Arg.Unit (setop RemoveCrop),
|
|
" Synonym for -remove-crop");
|
|
("-remove-trimbox",
|
|
Arg.Unit (setop RemoveTrim),
|
|
" Remove trim box on specified pages");
|
|
("-remove-bleedbox",
|
|
Arg.Unit (setop RemoveBleed),
|
|
" Remove bleed box on specified pages");
|
|
("-remove-artbox",
|
|
Arg.Unit (setop RemoveArt),
|
|
" Remove art box on specified pages");
|
|
("-frombox", Arg.String setfrombox, " Set box to copy from");
|
|
("-tobox", Arg.String settobox, " Set box to copy to");
|
|
("-mediabox-if-missing",
|
|
Arg.Unit setmediaboxifmissing,
|
|
" If copy from box missing, substitute media box");
|
|
("-mediabox",
|
|
Arg.String setmediabox,
|
|
" Set media box on specified pages");
|
|
("-encrypt",
|
|
Arg.Unit setencryptcollect,
|
|
" Encrypt a document");
|
|
("-decrypt",
|
|
Arg.Unit (setop Decrypt),
|
|
" Decrypt a file");
|
|
("-decrypt-force",
|
|
Arg.Unit (fun () -> args.debugforce <- true),
|
|
" Decrypt a file even without password");
|
|
("-no-edit", Arg.Unit (fun () -> args.no_edit <- true) , " No edits");
|
|
("-no-print", Arg.Unit (fun () -> args.no_print <- true), " No printing");
|
|
("-no-copy", Arg.Unit (fun () -> args.no_copy <- true), " No copying");
|
|
("-no-annot", Arg.Unit (fun () -> args.no_annot <- true), " No annotations");
|
|
("-no-forms", Arg.Unit (fun () -> args.no_forms <- true), " No forms");
|
|
("-no-extract", Arg.Unit (fun () -> args.no_extract <- true), " No extracting");
|
|
("-no-assemble", Arg.Unit (fun () -> args.no_assemble <- true), " No assembling");
|
|
("-no-hq-print", Arg.Unit (fun () -> args.no_hq_print <- true), " No high quality printing");
|
|
("-no-encrypt-metadata",
|
|
Arg.Unit set_no_encrypt_metadata,
|
|
" Don't encrypt metadata (AES only)");
|
|
("-decompress",
|
|
Arg.Unit (setop Decompress),
|
|
" Decompress");
|
|
("-compress",
|
|
Arg.Unit (setop Compress),
|
|
" Compress streams, leaving metadata alone");
|
|
("-remove-duplicate-streams",
|
|
Arg.Unit (fun () -> args.remove_duplicate_streams <- true),
|
|
"");
|
|
("-list-bookmarks",
|
|
Arg.Unit (setop ListBookmarks),
|
|
" List Bookmarks");
|
|
("-list-bookmarks-json",
|
|
Arg.Unit setlistbookmarksjson,
|
|
" List Bookmarks in JSON format");
|
|
("-remove-bookmarks",
|
|
Arg.Unit (setop RemoveBookmarks),
|
|
" Remove bookmarks from a file");
|
|
("-add-bookmarks",
|
|
Arg.String setaddbookmarks,
|
|
" Add bookmarks from the given file");
|
|
("-add-bookmarks-json",
|
|
Arg.String setaddbookmarksjson,
|
|
" Add bookmarks from the given file in JSON format");
|
|
("-bookmarks-open-to-level",
|
|
Arg.Int setbookmarksopentolevel,
|
|
" Open bookmarks to this level (0 = all closed)");
|
|
("-presentation",
|
|
Arg.Unit (setop Presentation),
|
|
" Make a presentation");
|
|
("-trans",
|
|
Arg.String settrans,
|
|
" Set the transition method for -presentation");
|
|
("-duration",
|
|
Arg.Float setduration,
|
|
" Set the display duration for -presentation");
|
|
("-vertical",
|
|
Arg.Unit setvertical,
|
|
" Set dimension for Split and Blinds styles");
|
|
("-outward",
|
|
Arg.Unit setoutward,
|
|
" Set direction for Split and Box styles");
|
|
("-direction",
|
|
Arg.Int setdirection,
|
|
" Set direction for Wipe and Glitter styles");
|
|
("-effect-duration",
|
|
Arg.Float seteffectduration,
|
|
" Set the effect duration in seconds");
|
|
("-stamp-on",
|
|
Arg.String setstampon,
|
|
" Stamp a file on some pages of another");
|
|
("-stamp-under",
|
|
Arg.String setstampunder,
|
|
" Stamp a file under some pages of another");
|
|
("-scale-stamp-to-fit",
|
|
Arg.Unit (fun () -> args.scale_stamp_to_fit <- true),
|
|
" Scale the stamp to fit the page");
|
|
("-combine-pages",
|
|
Arg.String setcombinepages,
|
|
" Combine two files by merging individual pages");
|
|
("-add-text",
|
|
Arg.String setaddtext,
|
|
" Superimpose text on the given range of pages");
|
|
("-remove-text",
|
|
Arg.Unit (setop RemoveText),
|
|
" Remove text previously added by cpdf");
|
|
("-add-rectangle",
|
|
Arg.String setrectangle,
|
|
" Add a rectangle to the page");
|
|
("-bates",
|
|
Arg.Int (fun n -> args.bates <- n),
|
|
" Set the base bates number");
|
|
("-bates-at-range",
|
|
Arg.Int setbatesrange,
|
|
" Set the base bates number at first page in range");
|
|
("-bates-pad-to",
|
|
Arg.Int (fun n -> args.batespad <- Some n),
|
|
" Pad the bates number with leading zeroes to width");
|
|
("-font",
|
|
Arg.String setfont,
|
|
" Set the font");
|
|
("-font-size",
|
|
Arg.Float setfontsize,
|
|
" Set the font size");
|
|
("-load-ttf",
|
|
Arg.String loadttf,
|
|
" Use a TrueType font");
|
|
("-embed-std14",
|
|
Arg.String setembedstd14,
|
|
" Embed standard 14 fonts");
|
|
("-color",
|
|
Arg.String setcolor,
|
|
" Set the color");
|
|
("-opacity",
|
|
Arg.Float setopacity,
|
|
" Set the text opacity");
|
|
("-outline",
|
|
Arg.Unit (fun () -> args.outline <- true),
|
|
" Use outline mode for text");
|
|
("-linewidth",
|
|
Arg.Float (fun f -> args.linewidth <- f),
|
|
" Set line width for outline text");
|
|
("-pos-center",
|
|
Arg.String setposcenter,
|
|
" Set position relative to center of baseline");
|
|
("-pos-left",
|
|
Arg.String setposleft,
|
|
" Set position relative to left of baseline");
|
|
("-pos-right",
|
|
Arg.String setposright,
|
|
" Set position relative to right of baseline");
|
|
("-top",
|
|
Arg.String settop,
|
|
" Set position relative to center top of page");
|
|
("-topleft",
|
|
Arg.String settopleft,
|
|
" Set position relative to top left of page");
|
|
("-topright",
|
|
Arg.String settopright,
|
|
" Set position relative to top right of page");
|
|
("-left",
|
|
Arg.String setleft,
|
|
" Set position relative to center left of page");
|
|
("-bottomleft",
|
|
Arg.String setbottomleft,
|
|
" Set position relative to bottom left of page");
|
|
("-bottom",
|
|
Arg.String setbottom,
|
|
" Set position relative to center bottom of page");
|
|
("-bottomright",
|
|
Arg.String setbottomright,
|
|
" Set position relative to bottom right of page");
|
|
("-right",
|
|
Arg.String setright,
|
|
" Set position relative to center right of page");
|
|
("-diagonal",
|
|
Arg.Unit setdiagonal,
|
|
" Place text diagonally across page");
|
|
("-reverse-diagonal",
|
|
Arg.Unit setreversediagonal,
|
|
" Place text diagonally across page from top left");
|
|
("-center",
|
|
Arg.Unit setcenter,
|
|
" Place text in the center of the page");
|
|
("-justify-left",
|
|
Arg.Unit (fun () -> args.justification <- Cpdfaddtext.LeftJustify),
|
|
" Justify multiline text left");
|
|
("-justify-right",
|
|
Arg.Unit (fun () -> args.justification <- Cpdfaddtext.RightJustify),
|
|
" Justify multiline text right");
|
|
("-justify-center",
|
|
Arg.Unit (fun () -> args.justification <- Cpdfaddtext.CentreJustify),
|
|
" Justify multiline text center");
|
|
("-underneath",
|
|
Arg.Unit (fun () -> args.underneath <- true),
|
|
" Text stamp is underneath content");
|
|
("-line-spacing",
|
|
Arg.Float (fun f -> args.linespacing <- f),
|
|
" Line spacing (1 is normal)");
|
|
("-midline",
|
|
Arg.Unit (fun () -> args.midline <- true),
|
|
" Adjust text to midline rather than baseline");
|
|
("-topline",
|
|
Arg.Unit (fun () -> args.topline <- true),
|
|
" Adjust text to topline rather than baseline");
|
|
("-relative-to-cropbox",
|
|
Arg.Unit (fun () -> args.relative_to_cropbox <- true),
|
|
" Add text relative to Crop Box not Media Box");
|
|
("-embed-missing-fonts",
|
|
Arg.Unit (setop EmbedMissingFonts),
|
|
" Embed missing fonts by calling gs");
|
|
("-twoup",
|
|
Arg.Unit (setop TwoUp),
|
|
" Put 2 pages onto one");
|
|
("-twoup-stack",
|
|
Arg.Unit (setop TwoUpStack),
|
|
" Stack 2 pages onto one twice the size");
|
|
("-impose",
|
|
Arg.String setimpose,
|
|
" Impose onto given page size");
|
|
("-impose-xy",
|
|
Arg.String setimposexy,
|
|
" Impose x by y (zero means unlimited)");
|
|
("-impose-columns",
|
|
Arg.Unit (fun () -> args.impose_columns <- true),
|
|
" Impose in columns rather than rows");
|
|
("-impose-rtl",
|
|
Arg.Unit (fun () -> args.impose_rtl <- true),
|
|
" Impose right-to-left");
|
|
("-impose-btt",
|
|
Arg.Unit (fun () -> args.impose_btt <- true),
|
|
" Impose bottom-to-top");
|
|
("-impose-margin",
|
|
Arg.Float (fun f -> args.impose_margin <- f),
|
|
" Add margin around whole imposed page");
|
|
("-impose-spacing",
|
|
Arg.Float (fun f -> args.impose_spacing <- f),
|
|
" Add spacing around each imposed page");
|
|
("-impose-linewidth",
|
|
Arg.Float (fun f -> args.impose_linewidth <- f),
|
|
" Imposition divider line width (0=none)");
|
|
("-chop",
|
|
Arg.String setchop,
|
|
" Chop x by y");
|
|
("-chop-h",
|
|
Arg.String setchoph,
|
|
" Chop horizontally");
|
|
("-chop-v",
|
|
Arg.String setchopv,
|
|
" Chop horizontally");
|
|
("-chop-columns",
|
|
Arg.Unit (fun () -> args.impose_columns <- true),
|
|
" Chop in columns rather than rows");
|
|
("-chop-rtl",
|
|
Arg.Unit (fun () -> args.impose_rtl <- true),
|
|
" Chop right-to-left");
|
|
("-chop-btt",
|
|
Arg.Unit (fun () -> args.impose_btt <- true),
|
|
" Chop bottom-to-top");
|
|
("-pad-before",
|
|
Arg.Unit (setop PadBefore),
|
|
" Add a blank page before the given pages");
|
|
("-pad-after",
|
|
Arg.Unit (setop PadAfter),
|
|
" Add a blank page after the given pages");
|
|
("-pad-every",
|
|
Arg.Int setpadevery,
|
|
" Add a blank page after every n pages");
|
|
("-pad-with",
|
|
Arg.String setpadwith,
|
|
" Use a given PDF instead of a blank page");
|
|
("-pad-multiple",
|
|
Arg.Int setpadmultiple,
|
|
" Pad the document to a multiple of n pages");
|
|
("-pad-multiple-before",
|
|
Arg.Int setpadmultiplebefore,
|
|
" Pad the document at beginning to a multiple of n pages");
|
|
("-list-annotations",
|
|
Arg.Unit (setop ListAnnotations),
|
|
" List annotations");
|
|
("-list-annotations-json",
|
|
Arg.Unit setlistannotationsjson,
|
|
" List annotations in JSON format");
|
|
("-copy-annotations",
|
|
Arg.String setcopyannotations,
|
|
" Copy annotations from given file");
|
|
("-remove-annotations",
|
|
Arg.Unit (setop RemoveAnnotations),
|
|
" Remove annotations");
|
|
("-set-annotations",
|
|
Arg.String setsetannotations,
|
|
" Set annotations from JSON file");
|
|
("-list-fonts",
|
|
Arg.Unit (setop Fonts),
|
|
" Output font list");
|
|
("-list-fonts-json",
|
|
Arg.Unit setlistfontsjson,
|
|
" Output font list in JSON format");
|
|
("-info",
|
|
Arg.Unit (setop Info),
|
|
" Output file information");
|
|
("-info-json",
|
|
Arg.Unit setinfojson,
|
|
" Output file information in JSON format");
|
|
("-page-info",
|
|
Arg.Unit (setop PageInfo),
|
|
" Output page information");
|
|
("-page-info-json",
|
|
Arg.Unit setpageinfojson,
|
|
" Output page information in JSON format");
|
|
("-set-author",
|
|
Arg.String (fun s -> setop (SetAuthor s) ()),
|
|
" Set Author");
|
|
("-set-title",
|
|
Arg.String (fun s -> setop (SetTitle s) ()),
|
|
" Set Title");
|
|
("-set-subject",
|
|
Arg.String (fun s -> setop (SetSubject s) ()),
|
|
" Set Subject");
|
|
("-set-keywords",
|
|
Arg.String (fun s -> setop (SetKeywords s) ()),
|
|
" Set Keywords");
|
|
("-set-create",
|
|
Arg.String (fun s -> setop (SetCreate s) ()),
|
|
" Set Creation date");
|
|
("-set-modify",
|
|
Arg.String (fun s -> setop (SetModify s) ()),
|
|
" Set Modification date");
|
|
("-set-creator",
|
|
Arg.String (fun s -> setop (SetCreator s) ()),
|
|
" Set Creator");
|
|
("-set-producer",
|
|
Arg.String (fun s -> setop (SetProducer s) ()),
|
|
" Set Producer");
|
|
("-set-trapped",
|
|
Arg.Unit (setop SetTrapped),
|
|
" Mark as trapped");
|
|
("-set-untrapped",
|
|
Arg.Unit (setop SetUntrapped),
|
|
" Mark as not trapped");
|
|
("-also-set-xmp",
|
|
Arg.Unit setalsosetxml,
|
|
" Also set XMP metadata");
|
|
("-just-set-xmp",
|
|
Arg.Unit setjustsetxml,
|
|
" Just set XMP metadata, not old-fashioned metadata");
|
|
("-create-metadata",
|
|
Arg.Unit (setop CreateMetadata),
|
|
" Create XMP metadata from scratch.");
|
|
("-set-page-layout",
|
|
Arg.String (fun s -> setop (SetPageLayout s) ()),
|
|
" Set page layout upon document opening");
|
|
("-set-page-mode",
|
|
Arg.String (fun s -> setop (SetPageMode s) ()),
|
|
" Set page mode upon document opening");
|
|
("-set-non-full-screen-page-mode",
|
|
Arg.String (fun s -> setop (SetNonFullScreenPageMode s) ()),
|
|
" Set non full screen page mode if page mode is FullScreen");
|
|
("-open-at-page",
|
|
Arg.String setopenatpage,
|
|
" Set initial page");
|
|
("-open-at-page-fit",
|
|
Arg.String setopenatpagefit,
|
|
" Set initial page, scaling to fit");
|
|
("-open-at-page-custom",
|
|
Arg.String setopenatpagecustom,
|
|
" Set initial page, with custom scaling");
|
|
("-set-metadata",
|
|
Arg.String (fun s -> setop (SetMetadata s) ()),
|
|
" Set metadata to the contents of a file");
|
|
("-print-metadata",
|
|
Arg.Unit (setop Metadata),
|
|
" Output metadata information");
|
|
("-remove-metadata",
|
|
Arg.Unit (setop RemoveMetadata),
|
|
" Remove document metadata");
|
|
("-set-metadata-date",
|
|
Arg.String setsetmetadatadate,
|
|
" Set the XMP metadata date property");
|
|
("-hide-toolbar",
|
|
Arg.String hidetoolbar,
|
|
" Hide the viewer's toolbar");
|
|
("-hide-menubar",
|
|
Arg.String hidemenubar,
|
|
" Hide the viewer's menubar");
|
|
("-hide-window-ui",
|
|
Arg.String hidewindowui,
|
|
" Hide the viewer's scroll bars etc.");
|
|
("-fit-window",
|
|
Arg.String fitwindow,
|
|
" Resize document's window to fit size of page");
|
|
("-center-window",
|
|
Arg.String centerwindow,
|
|
" Position window in the center of screen");
|
|
("-display-doc-title",
|
|
Arg.String displaydoctitle,
|
|
" Display document's title in the title bar");
|
|
("-set-language",
|
|
Arg.String (fun s -> setop (SetLanguage s) ()),
|
|
" Set the document's language");
|
|
("-pages",
|
|
Arg.Unit (setop CountPages),
|
|
" Count pages");
|
|
("-list-attached-files",
|
|
Arg.Unit (setop ListAttachedFiles),
|
|
" List attached files");
|
|
("-dump-attachments",
|
|
Arg.Unit (setop DumpAttachedFiles),
|
|
" Dump attachments to disk");
|
|
("-attach-file",
|
|
Arg.String setattachfile,
|
|
" Attach a file");
|
|
("-to-page",
|
|
Arg.String settopage,
|
|
" Attach file to given page instead of document");
|
|
("-remove-files",
|
|
Arg.Unit (setop RemoveAttachedFiles),
|
|
" Remove embedded attached document-level files");
|
|
("-list-images",
|
|
Arg.Unit (setop ListImages),
|
|
" List images");
|
|
("-list-images-json",
|
|
Arg.Unit setlistimagesjson,
|
|
" List images in JSON format");
|
|
("-list-images-used",
|
|
Arg.Unit (fun () -> setop (ImageResolution max_float) ()),
|
|
" List images at point of use");
|
|
("-list-images-used-json",
|
|
Arg.Unit (fun () -> args.format_json <- true; setop (ImageResolution max_float) ()),
|
|
" List images at point of use in JSON format");
|
|
("-image-resolution",
|
|
Arg.Float setimageresolution,
|
|
" List images at point of use under a given dpi");
|
|
("-image-resolution-json",
|
|
Arg.Float (fun f -> setimageresolution f; args.format_json <- true),
|
|
" List images at point of use under a given dpi");
|
|
("-copy-font",
|
|
Arg.String setcopyfont,
|
|
" Copy a named font");
|
|
("-copy-font-page",
|
|
Arg.Int setfontpage,
|
|
" Set the page a copied font is drawn from");
|
|
("-copy-font-name",
|
|
Arg.String setcopyfontname,
|
|
" Set the name of the font to copy");
|
|
("-remove-fonts",
|
|
Arg.Unit (setop RemoveFonts),
|
|
" Remove embedded fonts");
|
|
("-missing-fonts",
|
|
Arg.Unit (setop MissingFonts),
|
|
" List missing fonts");
|
|
("-remove-id",
|
|
Arg.Unit (setop RemoveId),
|
|
" Remove the file's /ID tag");
|
|
("-draft",
|
|
Arg.Unit (setop Draft),
|
|
" Remove images from the file");
|
|
("-draft-remove-only",
|
|
Arg.String (fun s -> args.removeonly <- Some s),
|
|
" Only remove named image");
|
|
("-boxes",
|
|
Arg.Unit setboxes,
|
|
" Add crossed boxes to -draft option");
|
|
("-remove-all-text",
|
|
Arg.Unit (setop RemoveAllText),
|
|
" Remove all text");
|
|
("-blacktext",
|
|
Arg.Unit (setop BlackText),
|
|
" Blacken document text");
|
|
("-blacklines",
|
|
Arg.Unit (setop BlackLines),
|
|
" Blacken lines in document");
|
|
("-blackfills",
|
|
Arg.Unit (setop BlackFills),
|
|
" Blacken fills in document");
|
|
("-thinlines",
|
|
Arg.String setthinlines,
|
|
" Set minimum line thickness to the given width");
|
|
("-remove-clipping",
|
|
Arg.Unit (setop RemoveClipping),
|
|
" Remove clipping paths");
|
|
("-clean",
|
|
Arg.Unit (setop Clean),
|
|
" Garbage-collect a file");
|
|
("-set-version",
|
|
Arg.Int (fun i -> setop (SetVersion i) ()),
|
|
" Set PDF version number");
|
|
("-copy-id-from",
|
|
Arg.String setcopyid,
|
|
" Copy one file's ID tag to another");
|
|
("-print-page-labels",
|
|
Arg.Unit (setop PrintPageLabels),
|
|
" Print page labels");
|
|
("-print-page-labels-json",
|
|
Arg.Unit setprintpagelabelsjson,
|
|
" Print page labels in JSON format");
|
|
("-remove-page-labels",
|
|
Arg.Unit (setop RemovePageLabels),
|
|
" Remove page labels");
|
|
("-add-page-labels",
|
|
Arg.Unit (setop AddPageLabels),
|
|
" Add or replace page labels");
|
|
("-label-style",
|
|
Arg.String setlabelstyle,
|
|
" Set label style (default DecimalArabic)");
|
|
("-label-prefix",
|
|
Arg.String setlabelprefix,
|
|
" Set label prefix (default none)");
|
|
("-label-startval",
|
|
Arg.Int setlabelstartval,
|
|
" Set label start value (default 1)");
|
|
("-labels-progress",
|
|
Arg.Unit setlabelsprogress,
|
|
" Label start value progresses with multiple ranges");
|
|
("-remove-dict-entry",
|
|
Arg.String setremovedictentry,
|
|
" Remove an entry from all dictionaries");
|
|
("-replace-dict-entry",
|
|
Arg.String setreplacedictentry,
|
|
" Remove an entry from all dictionaries");
|
|
("-replace-dict-entry-value",
|
|
Arg.String setreplacedictentryvalue,
|
|
" Replacement value for -replace-dict-entry");
|
|
("-dict-entry-search",
|
|
Arg.String setdictentrysearch,
|
|
" Search string for -remove-dict-entry and -replace-dict-entry");
|
|
("-print-dict-entry",
|
|
Arg.String setprintdictentry,
|
|
" Print dictionary values of a given key");
|
|
("-producer",
|
|
Arg.String setproduceraswego,
|
|
" Change the /Producer entry in the /Info dictionary");
|
|
("-creator",
|
|
Arg.String setcreatoraswego,
|
|
" Change the /Creator entry in the /Info dictionary");
|
|
("-list-spot-colors",
|
|
Arg.Unit (setop ListSpotColours),
|
|
" List spot colors");
|
|
("-create-pdf",
|
|
Arg.Unit (setop CreatePDF),
|
|
" Create a new PDF");
|
|
("-create-pdf-ua-1",
|
|
Arg.String (fun _ -> ()), (* Processed elsewhere *)
|
|
" Create a new PDF/UA-1 with the given title");
|
|
("-create-pdf-ua-2",
|
|
Arg.String (fun _ -> ()), (* Processed elsewhere *)
|
|
" Create a new PDF/UA-2 with the given title");
|
|
("-create-pdf-pages",
|
|
Arg.Int setcreatepdfpages,
|
|
" Number of pages for new PDF");
|
|
("-create-pdf-papersize",
|
|
Arg.String setcreatepdfpapersize,
|
|
" Paper size for new PDF");
|
|
("-prepend-content",
|
|
Arg.String setprepend,
|
|
" Prepend content to page");
|
|
("-postpend-content",
|
|
Arg.String setpostpend,
|
|
" Postpend content to page");
|
|
("-gs",
|
|
Arg.String (fun s -> args.path_to_ghostscript <- s),
|
|
" Path to gs executable");
|
|
("-gs-malformed",
|
|
Arg.Unit setgsmalformed,
|
|
" Also try to reconstruct malformed files with gs");
|
|
("-gs-quiet",
|
|
Arg.Unit (fun () -> args.gs_quiet <- true),
|
|
" Make gs go into quiet mode");
|
|
("-gs-malformed-force",
|
|
Arg.Unit whingemalformed,
|
|
" See manual for usage.");
|
|
("-im",
|
|
Arg.String setimpath,
|
|
" Path to magick executable");
|
|
("-p2p",
|
|
Arg.String setp2ppath,
|
|
" Path to pnmtopng executable");
|
|
("-extract-images",
|
|
Arg.Unit (setop ExtractImages),
|
|
" Extract images to file");
|
|
("-dedup",
|
|
Arg.Unit (fun () -> args.dedup <- true),
|
|
" Deduplicate extracted images fully");
|
|
("-dedup-perpage",
|
|
Arg.Unit (fun () -> args.dedup_per_page <- true),
|
|
" Deduplicate extracted images per page only");
|
|
("-process-images",
|
|
Arg.Unit (setop ProcessImages),
|
|
" Process images within PDF");
|
|
("-process-images-info",
|
|
Arg.Unit setprocessimagesinfo,
|
|
" Show info when processing images");
|
|
("-jbig2enc",
|
|
Arg.String setjbig2encpath,
|
|
" Path to jbig2enc executable");
|
|
("-jpeg-to-jpeg",
|
|
Arg.Float setjpegquality,
|
|
" Set JPEG quality for existing JPEGs");
|
|
("-lossless-to-jpeg",
|
|
Arg.Float setjpegqualitylossless,
|
|
" Set JPEG quality for existing lossless images");
|
|
("-1bpp-method",
|
|
Arg.String set1bppmethod,
|
|
" Set 1bpp compression method for existing images");
|
|
("-jbig2-lossy-threshold",
|
|
Arg.Float setjbig2_lossy_threshold,
|
|
" Set jbig2enc lossy threshold");
|
|
("-pixel-threshold",
|
|
Arg.Int setpixelthreshold,
|
|
" Only process images with more pixels than this");
|
|
("-length-threshold",
|
|
Arg.Int setlengththreshold,
|
|
" Only process images with data longer than this");
|
|
("-percentage-threshold",
|
|
Arg.Float setpercentagethreshold,
|
|
" Only substitute lossy image when smaller than this");
|
|
("-dpi-threshold",
|
|
Arg.Float setdpithreshold,
|
|
" Only process image when always higher than this dpi");
|
|
("-lossless-resample",
|
|
Arg.Float setlosslessresample,
|
|
" Resample lossless images to given part of original");
|
|
("-lossless-resample-dpi",
|
|
Arg.Float setlosslessresampledpi,
|
|
" Resample lossless images to given DPI");
|
|
("-resample-interpolate",
|
|
Arg.Unit setresampleinterpolate,
|
|
" Interpolate when resampling");
|
|
("-squeeze",
|
|
Arg.Unit setsqueeze,
|
|
" Squeeze");
|
|
("-squeeze-log-to",
|
|
Arg.String setsqueezelogto,
|
|
" Squeeze log location");
|
|
("-squeeze-no-pagedata",
|
|
Arg.Unit (fun () -> args.squeeze_pagedata <- false),
|
|
" Don't recompress pages");
|
|
("-squeeze-no-recompress",
|
|
Arg.Unit (fun () -> args.squeeze_recompress <- false),
|
|
" Don't recompress streams");
|
|
("-output-json",
|
|
Arg.Unit (setop OutputJSON),
|
|
" Export PDF file as JSON data");
|
|
("-output-json-parse-content-streams",
|
|
Arg.Unit (fun () -> args.jsonparsecontentstreams <- true),
|
|
" Parse content streams");
|
|
("-output-json-no-stream-data",
|
|
Arg.Unit (fun () -> args.jsonnostreamdata <- true),
|
|
" Skip stream data for brevity");
|
|
("-output-json-decompress-streams",
|
|
Arg.Unit (fun () -> args.jsondecompressstreams <- true),
|
|
" Skip stream data for brevity");
|
|
("-output-json-clean-strings",
|
|
Arg.Unit (fun () -> args.jsoncleanstrings <- true),
|
|
" Convert UTF16BE strings to PDFDocEncoding when possible");
|
|
("-j",
|
|
Arg.String set_json_input,
|
|
" Load a PDF JSON file");
|
|
("-ocg-list",
|
|
Arg.Unit (setop OCGList),
|
|
" List optional content groups");
|
|
("-ocg-rename",
|
|
Arg.Unit (setop OCGRename),
|
|
" Rename optional content group");
|
|
("-ocg-rename-from",
|
|
Arg.String (fun s -> args.ocgrenamefrom <- s),
|
|
" Rename from (with -ocg-rename)");
|
|
("-ocg-rename-to",
|
|
Arg.String (fun s -> args.ocgrenameto <- s),
|
|
" Rename to (with -ocg-rename)");
|
|
("-ocg-order-all",
|
|
Arg.Unit (setop OCGOrderAll),
|
|
" Repair /Order so all OCGs listed ");
|
|
("-ocg-coalesce-on-name",
|
|
Arg.Unit (setop OCGCoalesce),
|
|
" Coalesce OCGs with like name");
|
|
("-stamp-as-xobject",
|
|
Arg.String setstampasxobject,
|
|
" Stamp a file as a form xobject in another");
|
|
("-print-font-table",
|
|
Arg.String setprintfontencoding,
|
|
" Print the /ToUnicode table for a given font, if present.");
|
|
("-print-font-table-page",
|
|
Arg.Int setfontpage,
|
|
" Set page for -print-font-table");
|
|
("-extract-font",
|
|
Arg.String setextractfontfile,
|
|
" Extract a font");
|
|
("-table-of-contents",
|
|
Arg.Unit (setop TableOfContents),
|
|
" Typeset a table of contents from bookmarks");
|
|
("-toc-title",
|
|
Arg.String settableofcontentstitle,
|
|
" Set (or clear if empty) the TOC title");
|
|
("-toc-no-bookmark",
|
|
Arg.Unit settocnobookmark,
|
|
" Don't add the table of contents to the bookmarks");
|
|
("-typeset",
|
|
Arg.String settypeset,
|
|
" Typeset a text file as a PDF");
|
|
("-typeset-subformat",
|
|
Arg.String settypesetsubformat,
|
|
" Set subformat for typesetting");
|
|
("-composition",
|
|
Arg.Unit (setop (Composition false)),
|
|
" Show composition of PDF");
|
|
("-composition-json",
|
|
Arg.Unit (setop (Composition true)),
|
|
" Show composition of PDF in JSON format");
|
|
("-text-width",
|
|
Arg.String settextwidth,
|
|
" Find width of a line of text");
|
|
("-draw", Arg.Unit setdraw, " Begin drawing");
|
|
("-draw-struct-tree", Arg.Unit setdrawstructtree, " Build structure trees when drawing.");
|
|
("-tag", Arg.String Cpdfdrawcontrol.addtag, " Begin structure item");
|
|
("-stag", Arg.String Cpdfdrawcontrol.addstag, " Begin struture branch");
|
|
("-end-tag", Arg.Unit Cpdfdrawcontrol.endtag, " End structure item");
|
|
("-end-stag", Arg.Unit Cpdfdrawcontrol.endstag, " End structure branch");
|
|
("-auto-tags", Arg.Unit (fun _ -> Cpdfdrawcontrol.autotags true), " Auto-tag paragraphs and figures");
|
|
("-no-auto-tags", Arg.Unit (fun _ -> Cpdfdrawcontrol.autotags false), " Don't auto-tag paragraphs and figures");
|
|
("-artifact", Arg.Unit (fun _ -> Cpdfdrawcontrol.artifact ()), " Begin an artifact");
|
|
("-end-artifact", Arg.Unit (fun _ -> Cpdfdrawcontrol.endartifact ()), "End an artifact");
|
|
("-no-auto-artifacts", Arg.Unit (fun _ -> Cpdfdrawcontrol.autoartifacts false), " Don't mark untagged content as artifacts");
|
|
("-eltinfo", Arg.String (fun s -> Cpdfdrawcontrol.eltinfo s), " Add element information");
|
|
("-end-eltinfo", Arg.String (fun s -> Cpdfdrawcontrol.endeltinfo s), " Erase element information");
|
|
("-namespace", Arg.String (fun s -> Cpdfdrawcontrol.addnamespace (expand_namespace s)), " Set the structure tree namespace");
|
|
("-rolemap", Arg.String (fun s -> Cpdfdrawcontrol.setrolemap s), " Set a role map");
|
|
("-rect", Arg.String Cpdfdrawcontrol.addrect, " Draw rectangle");
|
|
("-to", Arg.String Cpdfdrawcontrol.addto, " Move to");
|
|
("-line", Arg.String Cpdfdrawcontrol.addline, " Add line to");
|
|
("-bez", Arg.String Cpdfdrawcontrol.addbezier, " Add Bezier curve to path");
|
|
("-bez23", Arg.String Cpdfdrawcontrol.addbezier23, " Add Bezier v-op to path");
|
|
("-bez13", Arg.String Cpdfdrawcontrol.addbezier13, " Add Bezier y-op to path");
|
|
("-circle", Arg.String Cpdfdrawcontrol.addcircle, " Add circle to path");
|
|
("-strokecol", Arg.String Cpdfdrawcontrol.setstroke, " Set stroke colour");
|
|
("-fillcol", Arg.String Cpdfdrawcontrol.setfill, " Set fill colour");
|
|
("-stroke", Arg.Unit Cpdfdrawcontrol.stroke, " Stroke path");
|
|
("-fill", Arg.Unit Cpdfdrawcontrol.fill, " Fill path");
|
|
("-filleo", Arg.Unit Cpdfdrawcontrol.fillevenodd, " Fill path, even odd");
|
|
("-strokefill", Arg.Unit Cpdfdrawcontrol.strokefill, " Stroke and fill path");
|
|
("-strokefilleo", Arg.Unit Cpdfdrawcontrol.strokefillevenodd, " Stroke and fill path, even odd");
|
|
("-clip", Arg.Unit Cpdfdrawcontrol.clip, " Clip");
|
|
("-clipeo", Arg.Unit Cpdfdrawcontrol.clipevenodd, " Clip, even odd");
|
|
("-close", Arg.Unit Cpdfdrawcontrol.closepath, " Close path");
|
|
("-thick", Arg.String Cpdfdrawcontrol.setthickness, " Set stroke thickness");
|
|
("-cap", Arg.String Cpdfdrawcontrol.setcap, " Set cap");
|
|
("-join", Arg.String Cpdfdrawcontrol.setjoin, " Set join");
|
|
("-miter", Arg.String Cpdfdrawcontrol.setmiter, " Set miter limit");
|
|
("-dash", Arg.String Cpdfdrawcontrol.setdash, " Set dash pattern");
|
|
("-push", Arg.Unit Cpdfdrawcontrol.push, " Push graphics stack");
|
|
("-pop", Arg.Unit Cpdfdrawcontrol.pop, " Pop graphics stack");
|
|
("-matrix", Arg.String Cpdfdrawcontrol.setmatrix, " Append to graphics matrix");
|
|
("-mtrans", Arg.String Cpdfdrawcontrol.setmtranslate, " Translate the graphics matrix");
|
|
("-mrot", Arg.String Cpdfdrawcontrol.setmrotate, " Rotate the graphics matrix");
|
|
("-mscale", Arg.String Cpdfdrawcontrol.setmscale, " Scale the graphics matrix");
|
|
("-mshearx", Arg.String Cpdfdrawcontrol.setmshearx, " Shear the graphics matrix in X");
|
|
("-msheary", Arg.String Cpdfdrawcontrol.setmsheary, " Shear the graphics matrix in Y");
|
|
("-xobj-bbox", Arg.String Cpdfdrawcontrol.xobjbbox, " Specify the bounding box for xobjects");
|
|
("-xobj", Arg.String Cpdfdrawcontrol.startxobj, " Begin saving a sequence of graphics operators");
|
|
("-end-xobj", Arg.Unit Cpdfdrawcontrol.endxobj, " End saving a sequence of graphics operators");
|
|
("-use", Arg.String Cpdfdrawcontrol.usexobj, " Use a saved sequence of graphics operators");
|
|
("-draw-jpeg", Arg.String Cpdfdrawcontrol.addjpeg, " Load a JPEG from file and name it");
|
|
("-draw-png", Arg.String Cpdfdrawcontrol.addpng, " Load a PNG from file and name it");
|
|
("-image", Arg.String (fun s -> Cpdfdrawcontrol.addimage ?title:args.image_title s; args.image_title <- None), " Draw an image which has already been loaded");
|
|
("-image-title", Arg.String (fun s -> args.image_title <- Some s), " Give title for the next -image");
|
|
("-fill-opacity", Arg.Float Cpdfdrawcontrol.addopacity, " Set opacity");
|
|
("-stroke-opacity", Arg.Float Cpdfdrawcontrol.addsopacity, " Set stroke opacity");
|
|
("-bt", Arg.Unit Cpdfdrawcontrol.addbt, " Begin text");
|
|
("-et", Arg.Unit Cpdfdrawcontrol.addet, " End text");
|
|
("-text", Arg.String Cpdfdrawcontrol.addtext, " Draw text");
|
|
("-stext", Arg.String Cpdfdrawcontrol.addspecialtext, " Draw text with %specials");
|
|
("-para", Arg.String Cpdfdrawcontrol.addpara, " Add a paragraph of text");
|
|
("-paras", Arg.String Cpdfdrawcontrol.addparas, " Add paragraphs of text, splitting on newlines");
|
|
("-indent", Arg.Float (fun f -> args.indent <- Some f), " Set indent for paragraphs");
|
|
("-leading", Arg.Float (fun f -> Cpdfdrawcontrol.addop (Cpdfdraw.Leading f)), " Set leading");
|
|
("-charspace", Arg.Float (fun f -> Cpdfdrawcontrol.addop (Cpdfdraw.CharSpace f)), " Set character spacing");
|
|
("-wordspace", Arg.Float (fun f -> Cpdfdrawcontrol.addop (Cpdfdraw.WordSpace f)), " Set word space");
|
|
("-textscale", Arg.Float (fun f -> Cpdfdrawcontrol.addop (Cpdfdraw.TextScale f)), " Set text scale");
|
|
("-rendermode", Arg.Int (fun i -> Cpdfdrawcontrol.addop (Cpdfdraw.RenderMode i)), " Set text rendering mode");
|
|
("-rise", Arg.Float (fun f -> Cpdfdrawcontrol.addop (Cpdfdraw.Rise f)), " Set text rise");
|
|
("-nl", Arg.Unit (fun () -> Cpdfdrawcontrol.addop Cpdfdraw.Newline), " New line");
|
|
("-newpage", Arg.Unit Cpdfdrawcontrol.addnewpage, " Move to a fresh page");
|
|
("-extract-stream", Arg.String setextractstream, " Extract a stream");
|
|
("-extract-stream-decompress", Arg.String setextractstreamdecomp, " Extract a stream, decompressing");
|
|
("-obj", Arg.String setprintobj, " Print object");
|
|
("-replace-obj", Arg.String setreplaceobj, "Replace object");
|
|
("-json", Arg.Unit (fun () -> args.format_json <- true), " Format output as JSON");
|
|
("-verify", Arg.String (fun s -> setop (Verify s) ()), " Verify conformance to a standard");
|
|
("-verify-single", Arg.String (fun s -> args.verify_single <- Some s), " Verify a single test");
|
|
("-mark-as", Arg.String (fun s -> setop (MarkAs (Cpdfua.subformat_of_string s)) ()), " Mark as conforming to a standard");
|
|
("-remove-mark", Arg.String (fun s -> setop (RemoveMark (Cpdfua.subformat_of_string s)) ()), " Remove conformance mark");
|
|
("-print-struct-tree", Arg.Unit (fun () -> setop PrintStructTree ()), " Print structure tree");
|
|
("-extract-struct-tree", Arg.Unit (fun () -> setop ExtractStructTree ()), " Extract structure tree in JSON format");
|
|
("-replace-struct-tree", Arg.String (fun s -> setop (ReplaceStructTree s) ()), " Replace structure tree from JSON");
|
|
("-redact", Arg.Unit (fun () -> setop Redact ()), " Redact entire pages");
|
|
(* These items are undocumented *)
|
|
("-debug", Arg.Unit setdebug, "");
|
|
("-debug-crypt", Arg.Unit (fun () -> args.debugcrypt <- true), "");
|
|
("-debug-force", Arg.Unit (fun () -> args.debugforce <- true), "");
|
|
("-debug-malformed", Arg.Set Pdfread.debug_always_treat_malformed, "");
|
|
("-debug-stderr-to-stdout", Arg.Unit setstderrtostdout, "");
|
|
("-debug-readable-ops", Arg.Unit setreadableops, "");
|
|
("-stay-on-error", Arg.Unit setstayonerror, "");
|
|
(* These items are unfinished *)
|
|
("-extract-text", Arg.Unit (setop ExtractText), "");
|
|
("-extract-text-font-size", Arg.Float setextracttextfontsize, "");
|
|
]
|
|
|
|
and usage_msg =
|
|
"Syntax: cpdf [<operation>] <input files> [-o <output file>]\n\n\
|
|
Copyright Coherent Graphics Ltd.\n\n\
|
|
Version " ^ (if agpl then "AGPLv3-licensed " else "") ^ string_of_int major_version ^ "." ^ string_of_int minor_version ^ "." ^ string_of_int minor_minor_version ^ " " ^ version_date ^ "\n\n\
|
|
https://www.coherentpdf.com/\n\n\
|
|
Input names are distinguished by containing a '.' and may be\n\
|
|
followed by a page range specification, for instance \"1,2,3\"\n\
|
|
or \"1-6,9-end\" or \"even\" or \"odd\" or \"reverse\".\n\nOperations (See \
|
|
manual for full details):\n"
|
|
|
|
(* Reading and writing *)
|
|
let filesize name =
|
|
try
|
|
let x = open_in_bin name in
|
|
let r = in_channel_length x in
|
|
close_in x;
|
|
r
|
|
with
|
|
_ -> 0
|
|
|
|
(* Mend PDF file with Ghostscript. We use this if a file is malformed and CPDF
|
|
* cannot mend it. It is copied to a temporary file, fixed, then we return None or Some (pdf). *)
|
|
let mend_pdf_file_with_ghostscript filename =
|
|
match args.path_to_ghostscript with
|
|
| "" ->
|
|
Pdfe.log "Please supply path to gs with -gs\n";
|
|
exit 2
|
|
| _ ->
|
|
Pdfe.log "CPDF could not mend. Attempting to mend file with gs\n";
|
|
let tmpout = Filename.temp_file "cpdf" ".pdf" in
|
|
tempfiles := tmpout::!tempfiles;
|
|
let gscall =
|
|
Filename.quote_command args.path_to_ghostscript
|
|
((if args.gs_quiet then ["-dQUIET"] else []) @
|
|
["-dNOPAUSE"; "-sDEVICE=pdfwrite"; "-sOUTPUTFILE=" ^ tmpout; "-dBATCH"; filename])
|
|
in
|
|
match Sys.command gscall with
|
|
| 0 -> Pdfe.log "Succeeded!\n"; tmpout
|
|
| _ -> Pdfe.log "Could not fix malformed PDF file, even with gs\n"; exit 2
|
|
|
|
exception StdInBytes of bytes
|
|
|
|
let pdf_of_stdin ?revision user_pw owner_pw =
|
|
let rbytes = ref (mkbytes 0) in
|
|
try
|
|
let user_pw = Some user_pw
|
|
and owner_pw = if owner_pw = "" then None else Some owner_pw in
|
|
let o, bytes = Pdfio.input_output_of_bytes 16384 in
|
|
try
|
|
while true do o.Pdfio.output_char (input_char stdin) done;
|
|
Pdf.empty ()
|
|
with
|
|
End_of_file ->
|
|
let thebytes = Pdfio.extract_bytes_from_input_output o bytes in
|
|
rbytes := thebytes;
|
|
let i = Pdfio.input_of_bytes thebytes in
|
|
pdfread_pdf_of_input ?revision user_pw owner_pw i
|
|
with
|
|
_ -> raise (StdInBytes !rbytes)
|
|
|
|
let rec get_single_pdf ?(decrypt=true) ?(fail=false) op read_lazy =
|
|
let failout () =
|
|
if fail then begin
|
|
(* Reconstructed with ghostscript, but then we couldn't read it even then. Do not loop. *)
|
|
Pdfe.log "Failed to read gs-reconstructed PDF even though gs succeeded\n";
|
|
exit 2
|
|
end
|
|
in
|
|
let warn_gs () =
|
|
begin match args.inputs with
|
|
(InFile inname, _, _, _, _, _)::_ ->
|
|
begin try ignore (close_in (open_in_bin inname)) with _ ->
|
|
Pdfe.log (Printf.sprintf "File %s does not exist\n" inname);
|
|
exit 2
|
|
end
|
|
| _ -> ()
|
|
end;
|
|
Pdfe.log "get_single_pdf: failed to read malformed PDF file. Consider using -gs-malformed\n";
|
|
exit 2
|
|
in
|
|
match args.inputs with
|
|
| (InFile inname, x, u, o, y, revision) as input::more ->
|
|
if args.squeeze then
|
|
Printf.printf "Initial file size is %i bytes\n" (filesize inname);
|
|
let pdf =
|
|
try
|
|
if read_lazy then
|
|
pdfread_pdf_of_channel_lazy ?revision (optstring u) (optstring o) (open_in_bin inname)
|
|
else
|
|
pdfread_pdf_of_file ?revision (optstring u) (optstring o) inname
|
|
with
|
|
| Cpdferror.SoftError _ as e -> raise e (* Bad owner or user password *)
|
|
| _ ->
|
|
if args.gs_malformed then
|
|
begin
|
|
failout ();
|
|
let newname = mend_pdf_file_with_ghostscript inname in
|
|
args.inputs <- (InFile newname, x, u, o, y, revision)::more;
|
|
get_single_pdf ~fail:true op read_lazy
|
|
end
|
|
else
|
|
warn_gs ()
|
|
in
|
|
args.was_encrypted <- Pdfcrypt.is_encrypted pdf;
|
|
if decrypt then decrypt_if_necessary input op pdf else pdf
|
|
| (StdIn, x, u, o, y, revision) as input::more ->
|
|
let pdf =
|
|
try pdf_of_stdin ?revision u o with
|
|
StdInBytes b ->
|
|
if args.gs_malformed then
|
|
begin
|
|
failout ();
|
|
let inname = Filename.temp_file "cpdf" ".pdf" in
|
|
tempfiles := inname::!tempfiles;
|
|
let fh = open_out_bin inname in
|
|
Pdfio.bytes_to_output_channel fh b;
|
|
close_out fh;
|
|
let newname = mend_pdf_file_with_ghostscript inname in
|
|
args.inputs <- (InFile newname, x, u, o, y, revision)::more;
|
|
get_single_pdf ~fail:true op read_lazy
|
|
end
|
|
else
|
|
warn_gs ()
|
|
in
|
|
args.was_encrypted <- Pdfcrypt.is_encrypted pdf;
|
|
if decrypt then decrypt_if_necessary input op pdf else pdf
|
|
| (AlreadyInMemory (pdf, s), _, _, _, _, _)::_ -> pdf
|
|
| _ ->
|
|
raise (Arg.Bad "cpdf: No input specified.\n")
|
|
|
|
let filenames = null_hash ()
|
|
|
|
let squeeze_logto filename x =
|
|
let fh = open_out_gen [Open_wronly; Open_creat] 0o666 filename in
|
|
seek_out fh (out_channel_length fh);
|
|
output_string fh x;
|
|
close_out fh
|
|
|
|
(* This now memoizes on the name of the file to make sure we only load each
|
|
file once *)
|
|
let rec get_pdf_from_input_kind ?(read_lazy=false) ?(decrypt=true) ?(fail=false) ((_, x, u, o, y, revision) as input) op ik =
|
|
let failout () =
|
|
if fail then begin
|
|
(* Reconstructed with ghostscript, but then we couldn't read it even then. Do not loop. *)
|
|
Pdfe.log "Failed to read gs-reconstructed PDF even though gs succeeded\n";
|
|
exit 2
|
|
end
|
|
in
|
|
let warn_gs () =
|
|
begin match input with
|
|
(InFile inname, _, _, _, _, _) ->
|
|
begin try ignore (close_in (open_in_bin inname)) with _ ->
|
|
Pdfe.log (Printf.sprintf "File %s does not exist\n" inname);
|
|
exit 2
|
|
end
|
|
| _ -> ()
|
|
end;
|
|
Pdfe.log "get_pdf_from_input_kind: failed to read malformed PDF file. Consider using -gs-malformed\n";
|
|
exit 2
|
|
in
|
|
match ik with
|
|
| AlreadyInMemory (pdf, _) -> pdf
|
|
| InFile s ->
|
|
if args.squeeze then
|
|
begin
|
|
let size = filesize s in
|
|
initial_file_size := size;
|
|
let str = Printf.sprintf "Initial file size is %i bytes\n" size in
|
|
begin match !logto with
|
|
| None -> print_string str
|
|
| Some filename -> squeeze_logto filename str
|
|
end
|
|
end;
|
|
begin try Hashtbl.find filenames s with
|
|
Not_found ->
|
|
let pdf =
|
|
try
|
|
if read_lazy then
|
|
pdfread_pdf_of_channel_lazy ?revision (optstring u) (optstring o) (open_in_bin s)
|
|
else
|
|
pdfread_pdf_of_file ?revision (optstring u) (optstring o) s
|
|
with
|
|
| Cpdferror.SoftError _ as e -> raise e (* Bad owner or user password *)
|
|
| e ->
|
|
Printf.printf "%s\n" (Printexc.to_string e);
|
|
if args.gs_malformed then
|
|
begin
|
|
failout ();
|
|
let newname = mend_pdf_file_with_ghostscript s in
|
|
get_pdf_from_input_kind ~fail:true (InFile newname, x, u, o, y, revision) op (InFile newname);
|
|
end
|
|
else
|
|
warn_gs ()
|
|
in
|
|
args.was_encrypted <- Pdfcrypt.is_encrypted pdf;
|
|
let pdf = if decrypt then decrypt_if_necessary input op pdf else pdf in
|
|
Hashtbl.add filenames s pdf; pdf
|
|
end
|
|
| StdIn ->
|
|
let pdf =
|
|
try pdf_of_stdin ?revision u o with
|
|
StdInBytes b ->
|
|
if args.gs_malformed then
|
|
begin
|
|
failout ();
|
|
let inname = Filename.temp_file "cpdf" ".pdf" in
|
|
tempfiles := inname::!tempfiles;
|
|
let fh = open_out_bin inname in
|
|
Pdfio.bytes_to_output_channel fh b;
|
|
close_out fh;
|
|
let newname = mend_pdf_file_with_ghostscript inname in
|
|
get_pdf_from_input_kind ~fail:true (InFile newname, x, u, o, y, revision) op (InFile newname);
|
|
end
|
|
else
|
|
warn_gs ()
|
|
in
|
|
args.was_encrypted <- Pdfcrypt.is_encrypted pdf;
|
|
if decrypt then decrypt_if_necessary input op pdf else pdf
|
|
|
|
let rec unescape_octals prev = function
|
|
| [] -> rev prev
|
|
| '\\'::('0'..'9' as a)::('0'..'9' as b)::('0'..'9' as c)::t ->
|
|
let chr = char_of_int (int_of_string ("0o" ^ implode [a;b;c])) in
|
|
unescape_octals (chr::prev) t
|
|
| '\\'::'\\'::t -> unescape_octals ('\\'::prev) t
|
|
| h::t -> unescape_octals (h::prev) t
|
|
|
|
let unescape_octals s =
|
|
implode (unescape_octals [] (explode s))
|
|
|
|
let process s =
|
|
if args.encoding <> Cpdfmetadata.Raw
|
|
then Pdftext.pdfdocstring_of_utf8 s
|
|
else unescape_octals s
|
|
|
|
let set_producer s pdf =
|
|
ignore (Cpdfmetadata.set_pdf_info ("/Producer", Pdf.String (process s), 0) pdf)
|
|
|
|
let set_creator s pdf =
|
|
ignore (Cpdfmetadata.set_pdf_info ("/Creator", Pdf.String (process s), 0) pdf)
|
|
|
|
let really_write_pdf ?(encryption = None) ?(is_decompress=false) mk_id pdf outname =
|
|
if args.producer <> None then set_producer (unopt args.producer) pdf;
|
|
if args.creator <> None then set_creator (unopt args.creator) pdf;
|
|
if args.debugcrypt then Printf.printf "really_write_pdf\n";
|
|
let will_linearize =
|
|
args.linearize || args.keeplinearize && pdf.Pdf.was_linearized
|
|
in
|
|
let outname' =
|
|
if will_linearize then Filename.temp_file "cpdflin" ".pdf" else outname
|
|
in
|
|
if args.debugcrypt then
|
|
Printf.printf "args.recrypt = %b, args.was_encrypted = %b\n"
|
|
args.recrypt args.was_encrypted;
|
|
begin
|
|
if args.recrypt && args.was_encrypted then
|
|
begin
|
|
if args.debugcrypt then
|
|
Printf.printf "Recrypting in really_write_pdf\n";
|
|
match args.inputs with
|
|
[] -> raise (Pdf.PDFError "no input in recryption")
|
|
| (_, _, user_pw, owner_pw, _, _)::_ ->
|
|
let best_password =
|
|
if owner_pw <> "" then owner_pw else user_pw
|
|
in
|
|
Pdfwrite.pdf_to_file_options
|
|
~preserve_objstm:args.preserve_objstm
|
|
~generate_objstm:args.create_objstm
|
|
~compress_objstm:(not is_decompress)
|
|
~recrypt:(Some best_password)
|
|
None mk_id pdf outname'
|
|
end
|
|
else
|
|
begin
|
|
if args.debugforce || not args.was_encrypted || args.was_decrypted_with_owner then
|
|
begin
|
|
if args.debugcrypt then
|
|
Printf.printf "Pdf to file in really_write_pdf\n";
|
|
Pdfwrite.pdf_to_file_options
|
|
~preserve_objstm:args.preserve_objstm
|
|
~generate_objstm:args.create_objstm
|
|
~compress_objstm:(not is_decompress)
|
|
encryption mk_id pdf outname'
|
|
end
|
|
else
|
|
soft_error
|
|
"You must supply -recrypt here, or add -decrypt-force, or provide the owner password."
|
|
end
|
|
end;
|
|
begin
|
|
if will_linearize then
|
|
let cpdflin = find_cpdflin args.cpdflin in
|
|
match args.inputs with
|
|
[] -> raise (Pdf.PDFError "no input in recryption")
|
|
| (_, _, user_pw, owner_pw, _, _)::_ ->
|
|
let best_password =
|
|
if owner_pw <> "" then owner_pw else user_pw
|
|
in
|
|
let code =
|
|
call_cpdflin cpdflin outname' outname best_password
|
|
in
|
|
if code > 0 then
|
|
begin
|
|
begin try Sys.remove outname with _ -> () end;
|
|
Sys.rename outname' outname;
|
|
soft_error
|
|
"Linearizer failed with above error. \
|
|
File written without linearization."
|
|
end
|
|
else
|
|
begin try Sys.remove outname' with _ -> () end;
|
|
end;
|
|
if args.squeeze then
|
|
let s = filesize outname in
|
|
begin
|
|
let str =
|
|
Printf.sprintf
|
|
"Final file size is %i bytes, %.2f%% of original.\n"
|
|
s
|
|
((float s /. float !initial_file_size) *. 100.)
|
|
in
|
|
match !logto with
|
|
| None -> print_string str
|
|
| Some filename -> squeeze_logto filename str
|
|
end
|
|
|
|
let write_pdf ?(encryption = None) ?(is_decompress=false) mk_id pdf =
|
|
if args.debugcrypt then Printf.printf "write_pdf\n";
|
|
if args.create_objstm && not (args.keepversion || pdf.Pdf.major > 1)
|
|
then pdf.Pdf.minor <- max pdf.Pdf.minor 5;
|
|
match args.out with
|
|
| NoOutputSpecified ->
|
|
output_pdfs =| pdf
|
|
| File outname ->
|
|
begin match encryption with
|
|
None ->
|
|
if not is_decompress then
|
|
begin
|
|
ignore (Cpdfsqueeze.recompress_pdf pdf);
|
|
if args.squeeze then Cpdfsqueeze.squeeze ~pagedata:args.squeeze_pagedata ?logto:!logto pdf;
|
|
end;
|
|
Pdf.remove_unreferenced pdf;
|
|
really_write_pdf ~is_decompress mk_id pdf outname
|
|
| Some _ ->
|
|
really_write_pdf ~encryption ~is_decompress mk_id pdf outname
|
|
end
|
|
| Stdout ->
|
|
let temp = Filename.temp_file "cpdfstdout" ".pdf" in
|
|
begin match encryption with
|
|
None ->
|
|
if not is_decompress then
|
|
begin
|
|
ignore (Cpdfsqueeze.recompress_pdf pdf);
|
|
if args.squeeze then Cpdfsqueeze.squeeze ~pagedata:args.squeeze_pagedata ?logto:!logto pdf;
|
|
Pdf.remove_unreferenced pdf
|
|
end;
|
|
really_write_pdf ~encryption ~is_decompress mk_id pdf temp;
|
|
| Some _ ->
|
|
really_write_pdf ~encryption ~is_decompress mk_id pdf temp
|
|
end;
|
|
let temp_file = open_in_bin temp in
|
|
try
|
|
while true do output_char stdout (input_char temp_file) done;
|
|
assert false
|
|
with
|
|
End_of_file ->
|
|
begin try close_in temp_file; Sys.remove temp with
|
|
e -> Pdfe.log (Printf.sprintf "Failed to remove temp file %s (%s)\n" temp (Printexc.to_string e))
|
|
end;
|
|
flush stdout (*r For Windows *)
|
|
|
|
(* Find the stem of a filename *)
|
|
let stem s =
|
|
implode
|
|
(rev (tail_no_fail
|
|
(dropwhile
|
|
(neq '.') (rev (explode (Filename.basename s))))))
|
|
|
|
let fast_write_split_pdfs
|
|
?(names=[]) enc splitlevel original_filename sq spec main_pdf pagenums pdf_pages
|
|
=
|
|
let marks = Pdfmarks.read_bookmarks main_pdf in
|
|
iter2
|
|
(fun number pagenums ->
|
|
let pdf = Pdfpage.pdf_of_pages ~retain_numbering:args.retain_numbering ~process_struct_tree:args.process_struct_trees main_pdf pagenums in
|
|
let startpage, endpage = extremes pagenums in
|
|
let name =
|
|
if names <> [] then List.nth names (number - 1) else
|
|
Cpdfbookmarks.name_of_spec
|
|
args.encoding marks main_pdf splitlevel spec number
|
|
(stem original_filename) startpage endpage
|
|
in
|
|
Pdf.remove_unreferenced pdf;
|
|
if sq then Cpdfsqueeze.squeeze ~pagedata:args.squeeze_pagedata ?logto:!logto pdf;
|
|
really_write_pdf ~encryption:enc (not (enc = None)) pdf name)
|
|
(indx pagenums)
|
|
pagenums
|
|
|
|
(* Return list, in order, a *set* of page numbers of bookmarks at a given level *)
|
|
let bookmark_pages level pdf =
|
|
let refnums = Pdf.page_reference_numbers pdf in
|
|
let fastrefnums = hashtable_of_dictionary (combine refnums (indx refnums)) in
|
|
setify_preserving_order
|
|
(option_map
|
|
(function
|
|
l when l.Pdfmarks.level = level ->
|
|
Some (Pdfpage.pagenumber_of_target ~fastrefnums pdf l.Pdfmarks.target)
|
|
| _ -> None)
|
|
(Pdfmarks.read_bookmarks pdf))
|
|
|
|
let split_at_bookmarks
|
|
enc original_filename ~squeeze level spec pdf
|
|
=
|
|
let pdf_pages = Pdfpage.pages_of_pagetree pdf in
|
|
let points = bookmark_pages level pdf in
|
|
let points =
|
|
lose (fun x -> x <= 0 || x > Pdfpage.endpage pdf) (map pred points)
|
|
in
|
|
let pts = splitat points (indx pdf_pages) in
|
|
fast_write_split_pdfs
|
|
enc level original_filename squeeze spec pdf pts pdf_pages
|
|
|
|
let split_pdf
|
|
enc original_filename
|
|
chunksize linearize ~cpdflin ~preserve_objstm ~create_objstm ~squeeze
|
|
spec pdf
|
|
=
|
|
let pdf_pages = Pdfpage.pages_of_pagetree pdf in
|
|
fast_write_split_pdfs
|
|
enc 0 original_filename squeeze spec pdf
|
|
(splitinto chunksize (indx pdf_pages)) pdf_pages
|
|
|
|
(* Given a PDF, write the split as if we had selected pages, and return its filesize. Delete it. *)
|
|
let split_max_fits pdf s p q =
|
|
if q < p then error "split_max_fits" else
|
|
let filename = Filename.temp_file "cpdf" "sm" in
|
|
let range = ilist p q in
|
|
let newpdf = Pdfpage.pdf_of_pages ~process_struct_tree:args.process_struct_trees ~retain_numbering:args.retain_numbering pdf range in
|
|
let r = args.out in
|
|
args.out <- File filename;
|
|
write_pdf false newpdf;
|
|
args.out <- r;
|
|
let fh = open_in_bin filename in
|
|
let size = in_channel_length fh in
|
|
begin try close_in fh; Sys.remove filename with _ -> () end;
|
|
size <= s
|
|
|
|
(* Binary search on q from current value down to p to find max which fits. Returns q. Upon failure, returns -1 *)
|
|
let rec split_max_search pdf s b p q =
|
|
if p = q then
|
|
if split_max_fits pdf s b q then q else -1
|
|
else
|
|
let half = (q + p) / 2 in
|
|
if split_max_fits pdf s b (half + 1)
|
|
then split_max_search pdf s b (half + 1) q
|
|
else split_max_search pdf s b p half
|
|
|
|
let split_max enc original_filename ~squeeze output_spec s pdf =
|
|
let outs = ref [] in
|
|
let p = ref 1 in
|
|
let endpage = Pdfpage.endpage pdf in
|
|
let q = ref endpage in
|
|
while !p < !q || !p = endpage do
|
|
let newq = split_max_search pdf s !p !p !q in
|
|
if newq = -1 then (Printf.eprintf "Failed to make small enough split at page %i. No files written.\n" !p; exit 2) else
|
|
begin
|
|
(*Printf.printf "Pages %i-%i will fit...\n%!" !p newq;*)
|
|
outs := ilist !p newq::!outs;
|
|
p := newq + 1;
|
|
q := endpage
|
|
end
|
|
done;
|
|
fast_write_split_pdfs enc 0 original_filename squeeze output_spec pdf (rev !outs) (Pdfpage.pages_of_pagetree pdf)
|
|
|
|
let getencryption pdf =
|
|
match Pdfread.what_encryption pdf with
|
|
| None | Some Pdfwrite.AlreadyEncrypted -> "Not encrypted"
|
|
| Some Pdfwrite.PDF40bit -> "40bit"
|
|
| Some Pdfwrite.PDF128bit -> "128bit"
|
|
| Some (Pdfwrite.AES128bit true) -> "128bit AES, Metadata encrypted"
|
|
| Some (Pdfwrite.AES128bit false) -> "128bit AES, Metadata not encrypted"
|
|
| Some (Pdfwrite.AES256bit true) -> "256bit AES, Metadata encrypted"
|
|
| Some (Pdfwrite.AES256bit false) -> "256bit AES, Metadata not encrypted"
|
|
| Some (Pdfwrite.AES256bitISO true) -> "256bit AES ISO, Metadata encrypted"
|
|
| Some (Pdfwrite.AES256bitISO false) -> "256bit AES ISO, Metadata not encrypted"
|
|
|
|
let write_json output pdf =
|
|
match output with
|
|
| NoOutputSpecified ->
|
|
error "-output-json: no output name specified"
|
|
| Stdout ->
|
|
Cpdfjson.to_output
|
|
(Pdfio.output_of_channel stdout)
|
|
~utf8:(args.encoding = Cpdfmetadata.UTF8)
|
|
~parse_content:args.jsonparsecontentstreams
|
|
~no_stream_data:args.jsonnostreamdata
|
|
~decompress_streams:args.jsondecompressstreams
|
|
~clean_strings:args.jsoncleanstrings
|
|
pdf
|
|
| File filename ->
|
|
let f = open_out filename in
|
|
Cpdfjson.to_output
|
|
(Pdfio.output_of_channel f)
|
|
~utf8:(args.encoding = Cpdfmetadata.UTF8)
|
|
~parse_content:args.jsonparsecontentstreams
|
|
~no_stream_data:args.jsonnostreamdata
|
|
~decompress_streams:args.jsondecompressstreams
|
|
~clean_strings:args.jsoncleanstrings
|
|
pdf;
|
|
close_out f
|
|
|
|
let json_to_output json = function
|
|
| NoOutputSpecified ->
|
|
error "no output name specified"
|
|
| Stdout ->
|
|
output_string stdout (Cpdfyojson.Safe.pretty_to_string json);
|
|
| File filename ->
|
|
let f = open_out filename in
|
|
output_string f (Cpdfyojson.Safe.pretty_to_string json);
|
|
close_out f
|
|
|
|
let collate (names, pdfs, ranges) =
|
|
let ois = map ref (combine3 names pdfs ranges) in
|
|
let nis = ref [] in
|
|
while flatten (map (fun {contents = (_, _, r)} -> r) ois) <> [] do
|
|
iter
|
|
(fun ({contents = (name, pdf, range)} as r) ->
|
|
match range with
|
|
| [] -> ()
|
|
| h::t ->
|
|
nis := (name, pdf, [h])::!nis;
|
|
r := (name, pdf, t))
|
|
ois
|
|
done;
|
|
split3 (rev !nis)
|
|
|
|
let warn_prerotate range pdf =
|
|
if not args.prerotate && not (Cpdfpage.alluprightonly range pdf) then
|
|
Pdfe.log "Some pages in the range have non-zero rotation. \
|
|
Consider adding -prerotate or pre-processing with -upright. \
|
|
To silence this warning use -no-warn-rotate\n"
|
|
|
|
let prerotate range pdf =
|
|
Cpdfpage.upright ~fast:args.fast range pdf
|
|
|
|
let check_bookmarks_mistake () =
|
|
if args.merge_add_bookmarks_use_titles && not args.merge_add_bookmarks then
|
|
Pdfe.log "Warning: -merge-add-bookmarks-use-titles is for use with -merge-add-bookmarks\n"
|
|
|
|
let check_clashing_output_name () =
|
|
match args.out with
|
|
| File s ->
|
|
if (List.exists (function (InFile s', _, _, _, _, _) when s = s' -> true | _ -> false) args.inputs) then
|
|
Pdfe.log "Warning: output file name clashes with input file name. Malformed file may result.\n"
|
|
| _ -> ()
|
|
|
|
let build_enc () =
|
|
match args.crypt_method with
|
|
| "" -> None
|
|
| _ ->
|
|
Some
|
|
{Pdfwrite.encryption_method =
|
|
(match args.crypt_method with
|
|
| "40bit" -> Pdfwrite.PDF40bit
|
|
| "128bit" -> Pdfwrite.PDF128bit
|
|
| "AES" -> Pdfwrite.AES128bit args.encrypt_metadata
|
|
| "AES256" -> Pdfwrite.AES256bit args.encrypt_metadata
|
|
| "AES256ISO" -> Pdfwrite.AES256bitISO args.encrypt_metadata
|
|
| _ -> assert false (* Pre-checked *));
|
|
Pdfwrite.owner_password = args.owner;
|
|
Pdfwrite.user_password = args.user;
|
|
Pdfwrite.permissions = banlist_of_args ()}
|
|
|
|
let extract_stream pdf decomp objnum =
|
|
let objnum = int_of_string objnum in (* maybe objspec in the future... *)
|
|
let obj = Pdf.lookup_obj pdf objnum in
|
|
Pdf.getstream obj;
|
|
if decomp then Pdfcodec.decode_pdfstream_until_unknown pdf obj;
|
|
let data =
|
|
match obj with
|
|
| Pdf.Stream {contents = (_, Pdf.Got x)} -> x
|
|
| _ -> mkbytes 0
|
|
in
|
|
match args.out with
|
|
| NoOutputSpecified ->
|
|
()
|
|
| File outname ->
|
|
let fh = open_out_bin outname in
|
|
output_string fh (Pdfio.string_of_bytes data);
|
|
close_out fh
|
|
| Stdout ->
|
|
output_string stdout (Pdfio.string_of_bytes data)
|
|
|
|
(* Empty string is trailerdict. Begins with / and it's a chain separated by
|
|
commas. Begins with P and it's a page number then a (possibly empty) chain.
|
|
Otherwise it's an object number (0 = trailerdict). *)
|
|
let split_chain str = map (fun x -> "/" ^ x) (tl (String.split_on_char '/' str))
|
|
|
|
let print_obj pdf objspec =
|
|
let simple_obj obj =
|
|
let obj = if obj = 0 then pdf.Pdf.trailerdict else Pdf.lookup_obj pdf obj in
|
|
Printf.printf "%S\n" (Pdfwrite.string_of_pdf obj)
|
|
in
|
|
let chain_obj objnum chain =
|
|
let obj = if objnum = 0 then pdf.Pdf.trailerdict else Pdf.lookup_obj pdf objnum in
|
|
match Pdf.lookup_chain pdf obj chain with
|
|
| Some x -> Printf.printf "%S\n" (Pdfwrite.string_of_pdf x)
|
|
| None -> ()
|
|
in
|
|
match explode objspec with
|
|
| 'P'::more ->
|
|
let number, chain =
|
|
let digits, rest = cleavewhile isdigit more in
|
|
List.nth (Pdf.page_reference_numbers pdf) (int_of_string (implode digits) - 1),
|
|
begin match split_chain (implode rest) with [""] -> [] | x -> x end
|
|
in
|
|
chain_obj number chain
|
|
| '/'::more -> chain_obj 0 (split_chain (implode ('/'::more)))
|
|
| [] -> simple_obj 0
|
|
| _ -> simple_obj (int_of_string objspec)
|
|
|
|
(* Empty string is trailerdict. Begins with / and it's a chain separated by commas. *)
|
|
let replace_obj pdf objspec obj =
|
|
let rec find_max_existing to_fake chain =
|
|
if chain = [] then (chain, to_fake) else
|
|
match Pdf.lookup_chain pdf pdf.Pdf.trailerdict chain with
|
|
| None -> find_max_existing (hd (rev chain)::to_fake) (rev (tl (rev chain)))
|
|
| _ -> (chain, to_fake)
|
|
in
|
|
let rec wrap_obj obj = function
|
|
| [] -> obj
|
|
| h::t -> Pdf.Dictionary [(h, wrap_obj obj t)]
|
|
in
|
|
let chain, to_fake = find_max_existing [] (split_chain objspec) in
|
|
let chain, key, obj =
|
|
match to_fake with
|
|
| [] -> (rev (tl (rev chain)), hd (rev chain), obj)
|
|
| h::t -> (chain, h, wrap_obj obj t)
|
|
in
|
|
if chain = [] then
|
|
pdf.Pdf.trailerdict <- Pdf.add_dict_entry pdf.Pdf.trailerdict key obj
|
|
else
|
|
Pdf.replace_chain pdf chain (key, obj)
|
|
|
|
(* Main function *)
|
|
let go () =
|
|
check_bookmarks_mistake ();
|
|
check_clashing_output_name ();
|
|
match args.op with
|
|
| Some Version ->
|
|
flprint
|
|
("cpdf " ^ (if agpl then "AGPL " else "") ^ "Version " ^ string_of_int major_version ^ "." ^ string_of_int minor_version ^ "." ^ string_of_int minor_minor_version ^ " " ^ version_date ^ "\n")
|
|
| None | Some Merge ->
|
|
begin match args.out, args.inputs with
|
|
| _, (_::_ as inputs) ->
|
|
let op = match inputs with [_] -> None | _ -> Some Merge in
|
|
let names, ranges, rotations, _, _, _ = split6 inputs in
|
|
let pdfs = map2 (fun i -> get_pdf_from_input_kind i op) inputs names in
|
|
(* If at least one file had object streams and args.preserve_objstm is true, set -objstm-create *)
|
|
if args.preserve_objstm then
|
|
iter
|
|
(fun pdf ->
|
|
if Hashtbl.length pdf.Pdf.objects.Pdf.object_stream_ids > 0
|
|
then args.create_objstm <- true)
|
|
pdfs;
|
|
begin match pdfs with
|
|
| [pdf] ->
|
|
if hd ranges <> "all" then
|
|
let range = parse_pagespec pdf (hd ranges) in
|
|
let newpdf = Pdfpage.pdf_of_pages ~process_struct_tree:args.process_struct_trees ~retain_numbering:args.retain_numbering pdf range in
|
|
write_pdf false newpdf
|
|
else
|
|
write_pdf false pdf
|
|
| _ ->
|
|
(* We check permissions. A merge is allowed if each file
|
|
included was (a) not encrypted (detected by the absence of
|
|
saved encryption information in the PDF, or (b) decrypted using
|
|
the owner password (stored in the input) *)
|
|
if
|
|
(not args.debugforce) &&
|
|
(not
|
|
(fold_left ( && ) true
|
|
(map2
|
|
(fun (_, _, _, _, was_dec_with_owner, _) pdf ->
|
|
!was_dec_with_owner || pdf.Pdf.saved_encryption = None)
|
|
inputs
|
|
pdfs)))
|
|
then
|
|
soft_error "Merge requires the owner password for all encrypted files, or -decrypt-force."
|
|
else
|
|
let pdfs =
|
|
if args.merge_add_bookmarks then
|
|
map2
|
|
(fun filename pdf -> Cpdfbookmarks.add_bookmark_title filename args.merge_add_bookmarks_use_titles pdf)
|
|
(map (function InFile s -> s | StdIn -> "" | AlreadyInMemory _ -> "") names)
|
|
pdfs
|
|
else
|
|
pdfs
|
|
in
|
|
(* If args.keep_this_id is set, change the ID to the one from the kept one *)
|
|
let rangenums = map2 parse_pagespec pdfs ranges in
|
|
(* At this point, we have the information for collation. *)
|
|
let names = map string_of_input_kind names in
|
|
let names, pdfs, rangenums =
|
|
(if args.collate then collate else Fun.id) (names, pdfs, rangenums)
|
|
in
|
|
let outpdf =
|
|
Pdfmerge.merge_pdfs
|
|
args.retain_numbering args.remove_duplicate_fonts ~process_struct_trees:args.process_struct_trees names pdfs rangenums
|
|
in
|
|
if args.remove_duplicate_streams then Pdfmerge.remove_duplicate_fonts outpdf; (* JBIG2 Globals *)
|
|
write_pdf false outpdf
|
|
end
|
|
| _ ->
|
|
match args.op with
|
|
| Some Merge ->
|
|
error "Merge: Must specify one output and at least one input"
|
|
| None ->
|
|
error "Must specify one output and at least one input"
|
|
| _ -> assert false
|
|
end
|
|
| Some (CopyFont fromfile) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, u, o, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some (CopyFont fromfile)) false
|
|
and frompdf = pdfread_pdf_of_file (optstring u) (optstring o) fromfile in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let copyfontname =
|
|
match args.copyfontname with
|
|
| Some x -> x
|
|
| None -> failwith "copy_font: no font name given"
|
|
in
|
|
let outpdf = Cpdffont.copy_font frompdf copyfontname args.copyfontpage range pdf in
|
|
write_pdf true outpdf
|
|
| _ -> error "copyfont: bad command line"
|
|
end
|
|
| Some RemoveFonts ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some RemoveFonts) false in
|
|
write_pdf true (Cpdffont.remove_fonts pdf)
|
|
| _ -> error "remove fonts: bad command line"
|
|
end
|
|
| Some (ExtractFontFile spec) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, u, o, _, _)::_, File filename ->
|
|
let pdf = get_single_pdf (Some (ExtractFontFile spec)) false in
|
|
begin match String.split_on_char ',' spec with
|
|
| [pnum; name] ->
|
|
begin try Cpdffont.extract_fontfile (int_of_string pnum) name filename pdf with
|
|
Failure _ (*"int_of_string"*) -> error "extract font: bad page number"
|
|
end
|
|
| _ -> error "extract font: bad specification"
|
|
end
|
|
| _ -> error "extract fontfile: bad command line"
|
|
end
|
|
| Some CountPages ->
|
|
begin match args.inputs with
|
|
[(ik, _, _, _, _, _) as input] ->
|
|
let pdf = get_pdf_from_input_kind ~read_lazy:true ~decrypt:false input (Some CountPages) ik in
|
|
output_page_count pdf
|
|
| _ -> raise (Arg.Bad "CountPages: must have a single input file only")
|
|
end
|
|
| Some Clean ->
|
|
let pdf' = get_single_pdf (Some Clean) false in
|
|
write_pdf false pdf'
|
|
| Some Info ->
|
|
let pdf, inname, input =
|
|
match args.inputs with
|
|
| (InFile inname, _, u, o, _, _) as input::_ ->
|
|
pdfread_pdf_of_channel_lazy (optstring u) (optstring o) (open_in_bin inname), inname, input
|
|
| (StdIn, _, u, o, _, _) as input::_ -> pdf_of_stdin u o, "", input
|
|
| (AlreadyInMemory (pdf, _), _, _, _, _, _) as input::_ -> pdf, "", input
|
|
| _ -> raise (Arg.Bad "cpdf: No input specified.\n")
|
|
in
|
|
let json = ref [] in
|
|
if args.format_json
|
|
then json =| ("Encryption", `String (getencryption pdf))
|
|
else Printf.printf "Encryption: %s\n" (getencryption pdf);
|
|
if args.format_json
|
|
then json =| ("Permissions", `List (map (fun p -> `String (string_of_permission p)) (Pdfread.permissions pdf)))
|
|
else Printf.printf "Permissions: %s\n" (getpermissions pdf);
|
|
if inname <> "" then
|
|
let lin = Pdfread.is_linearized (Pdfio.input_of_channel (open_in_bin inname)) in
|
|
if args.format_json then
|
|
json =| ("Linearized", `Bool lin) else Printf.printf "Linearized: %b\n" lin;
|
|
let objstm = length (list_of_hashtbl pdf.Pdf.objects.Pdf.object_stream_ids) > 0 in
|
|
if args.format_json
|
|
then json =| ("Object streams", `Bool objstm)
|
|
else Printf.printf "Object streams: %b\n" objstm;
|
|
let ida, idb =
|
|
match Pdf.lookup_direct pdf "/ID" pdf.Pdf.trailerdict with
|
|
| Some (Pdf.Array [Pdf.String s; Pdf.String s']) ->
|
|
(Pdfwrite.make_hex_pdf_string s, Pdfwrite.make_hex_pdf_string s')
|
|
| _ -> "", ""
|
|
in
|
|
let fixid s = implode (rev (tl (rev (tl (explode s))))) in
|
|
if args.format_json
|
|
then json =| ("ID", if ida ^ idb = "" then `Null else `List [`String (fixid ida); `String (fixid idb)])
|
|
else (if ida ^ idb = "" then Printf.printf "ID: None\n" else Printf.printf "ID: %s %s\n" ida idb);
|
|
let pdf = decrypt_if_necessary input (Some Info) pdf in
|
|
if args.format_json then
|
|
begin
|
|
Cpdfmetadata.output_info ~json Cpdfmetadata.UTF8 pdf;
|
|
Cpdfmetadata.output_xmp_info ~json Cpdfmetadata.UTF8 pdf;
|
|
flprint (Cpdfyojson.Safe.pretty_to_string (`Assoc (rev !json)))
|
|
end
|
|
else
|
|
begin
|
|
Cpdfmetadata.output_info args.encoding pdf;
|
|
Cpdfmetadata.output_xmp_info args.encoding pdf
|
|
end
|
|
| Some PageInfo ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
Cpdfpage.output_page_info ~json:args.format_json pdf range
|
|
| _ -> error "list-bookmarks: bad command line"
|
|
end
|
|
| Some Metadata ->
|
|
Cpdfmetadata.print_metadata (get_single_pdf (Some Metadata) true)
|
|
| Some Fonts ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some Fonts) true in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
Cpdffont.print_fonts ~json:args.format_json pdf range
|
|
| _ -> error "-list-fonts: bad command line"
|
|
end
|
|
| Some ListBookmarks ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
Cpdfbookmarks.list_bookmarks ~json:args.format_json args.encoding range pdf (Pdfio.output_of_channel stdout);
|
|
flush stdout
|
|
| _ -> error "list-bookmarks: bad command line"
|
|
end
|
|
| Some Crop ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some Crop) false in
|
|
let xywhlist = Cpdfcoord.parse_rectangles pdf args.rectangle in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.crop_pdf xywhlist pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "crop: bad command line"
|
|
end
|
|
| Some Art ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some Art) false in
|
|
let xywhlist = Cpdfcoord.parse_rectangles pdf args.rectangle in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.crop_pdf ~box:"/ArtBox" xywhlist pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "art: bad command line"
|
|
end
|
|
| Some Bleed ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some Bleed) false in
|
|
let xywhlist = Cpdfcoord.parse_rectangles pdf args.rectangle in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.crop_pdf ~box:"/BleedBox" xywhlist pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "bleed: bad command line"
|
|
end
|
|
| Some Trim ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some Trim) false in
|
|
let xywhlist = Cpdfcoord.parse_rectangles pdf args.rectangle in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.crop_pdf ~box:"/TrimBox" xywhlist pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "trim: bad command line"
|
|
end
|
|
| Some MediaBox ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some MediaBox) false in
|
|
let xywhlist = Cpdfcoord.parse_rectangles pdf args.rectangle in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.set_mediabox xywhlist pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "set media box: bad command line"
|
|
end
|
|
| Some (HardBox box) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some (HardBox box)) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.hard_box pdf range box args.mediabox_if_missing args.fast in
|
|
write_pdf false pdf
|
|
| _ -> error "hard box: bad command line"
|
|
end
|
|
| Some CopyBox ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some CopyBox) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let f, t =
|
|
begin match args.frombox, args.tobox with
|
|
| Some f, Some t -> f, t
|
|
| _ -> error "Copy box: no tobox or no frombox specified"
|
|
end
|
|
in
|
|
let pdf = Cpdfpage.copy_box f t args.mediabox_if_missing pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "Copy Box: bad command line"
|
|
end
|
|
| Some Decompress ->
|
|
let pdf = get_single_pdf (Some Decompress) false in
|
|
Pdf.iter_stream
|
|
(function stream ->
|
|
try Pdfcodec.decode_pdfstream_until_unknown pdf stream with
|
|
e -> Pdfe.log (Printf.sprintf "Decode failure: %s. Carrying on...\n" (Printexc.to_string e)); ())
|
|
pdf;
|
|
write_pdf ~is_decompress:true false pdf
|
|
| Some Compress ->
|
|
let pdf = get_single_pdf (Some Compress) false in
|
|
if args.remove_duplicate_streams then
|
|
Pdfmerge.remove_duplicate_fonts pdf;
|
|
write_pdf false (Cpdfsqueeze.recompress_pdf pdf)
|
|
| Some RemoveCrop ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some RemoveCrop) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.remove_cropping_pdf pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "remove-crop: bad command line"
|
|
end
|
|
| Some RemoveArt ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some RemoveArt) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.remove_art_pdf pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "remove-crop: bad command line"
|
|
end
|
|
| Some RemoveTrim ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some RemoveTrim) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.remove_trim_pdf pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "remove-crop: bad command line"
|
|
end
|
|
| Some RemoveBleed ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf (Some RemoveBleed) false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.remove_bleed_pdf pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "remove-crop: bad command line"
|
|
end
|
|
| Some (Rotate _) | Some (Rotateby _) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let rotate =
|
|
match args.op with
|
|
| Some (Rotate i) -> Cpdfpage.rotate_pdf i
|
|
| Some (Rotateby i) -> Cpdfpage.rotate_pdf_by i
|
|
| _ -> assert false
|
|
in
|
|
let pdf = rotate pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "rotate: bad command line"
|
|
end
|
|
| Some (RotateContents a) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.rotate_contents ~fast:args.fast a pdf range in
|
|
write_pdf false pdf
|
|
| _ -> error "rotate-contents: bad command line"
|
|
end
|
|
| Some Upright ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf = Cpdfpage.upright ~fast:args.fast range pdf in
|
|
write_pdf false pdf
|
|
| _ -> error "rotate-contents: bad command line"
|
|
end
|
|
| Some ((VFlip | HFlip) as flip) ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, _ ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf pagespec in
|
|
let pdf =
|
|
if flip = VFlip
|
|
then Cpdfpage.vflip_pdf ~fast:args.fast pdf range
|
|
else Cpdfpage.hflip_pdf ~fast:args.fast pdf range
|
|
in
|
|
write_pdf false pdf
|
|
| _ -> error "flip: bad command line"
|
|
end
|
|
| Some ((SetAuthor _ | SetTitle _ | SetSubject _ | SetKeywords _
|
|
| SetCreate _ | SetModify _ | SetCreator _ | SetProducer _
|
|
| SetTrapped | SetUntrapped) as op) ->
|
|
let key, value, version =
|
|
let f s = if args.encoding <> Cpdfmetadata.Raw then Pdftext.pdfdocstring_of_utf8 s else unescape_octals s in
|
|
match op with
|
|
| SetAuthor s -> "/Author", Pdf.String (f s), 0
|
|
| SetTitle s -> "/Title", Pdf.String (f s), 1
|
|
| SetSubject s -> "/Subject", Pdf.String (f s), 1
|
|
| SetKeywords s -> "/Keywords", Pdf.String (f s), 1
|
|
| SetCreate s -> "/CreationDate", Pdf.String (Cpdfmetadata.expand_date s), 0
|
|
| SetModify s -> "/ModDate", Pdf.String (Cpdfmetadata.expand_date s), 0
|
|
| SetCreator s -> "/Creator", Pdf.String (f s), 0
|
|
| SetProducer s -> "/Producer", Pdf.String (f s), 0
|
|
| SetTrapped -> "/Trapped", Pdf.Boolean true, 3
|
|
| SetUntrapped -> "/Trapped", Pdf.Boolean false, 3
|
|
| _ -> assert false
|
|
in
|
|
let pdf = get_single_pdf args.op false in
|
|
let version = if args.keepversion || pdf.Pdf.major > 1 then pdf.Pdf.minor else version in
|
|
write_pdf false
|
|
(Cpdfmetadata.set_pdf_info
|
|
~xmp_also:args.alsosetxml
|
|
~xmp_just_set:args.justsetxml
|
|
(key, value, version) pdf)
|
|
| Some (SetMetadataDate date) ->
|
|
write_pdf false (Cpdfmetadata.set_metadata_date (get_single_pdf args.op false) date)
|
|
| Some ((HideToolbar _ | HideMenubar _ | HideWindowUI _
|
|
| FitWindow _ | CenterWindow _ | DisplayDocTitle _) as op) ->
|
|
begin match args.out with
|
|
| _ ->
|
|
let key, value, version =
|
|
match op with
|
|
| HideToolbar s -> "/HideToolbar", Pdf.Boolean s, 0
|
|
| HideMenubar s -> "/HideMenubar", Pdf.Boolean s, 0
|
|
| HideWindowUI s -> "/HideWindowUI", Pdf.Boolean s, 0
|
|
| FitWindow s -> "/FitWindow", Pdf.Boolean s, 0
|
|
| CenterWindow s -> "/CenterWindow", Pdf.Boolean s, 0
|
|
| DisplayDocTitle s -> "/DisplayDocTitle", Pdf.Boolean s, 4
|
|
| _ -> assert false
|
|
in
|
|
let pdf = get_single_pdf args.op false in
|
|
let version = if args.keepversion || pdf.Pdf.major > 1 then pdf.Pdf.minor else version in
|
|
write_pdf false (Cpdfmetadata.set_viewer_preference (key, value, version) pdf)
|
|
end
|
|
| Some (OpenAtPage str) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf str in
|
|
let n = match range with [x] -> x | _ -> error "open_at_page: range does not specify single page" in
|
|
write_pdf false (Cpdfmetadata.set_open_action pdf false n)
|
|
| Some (OpenAtPageFit str) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf str in
|
|
let n = match range with [x] -> x | _ -> error "open_at_page_fit: range does not specify single page" in
|
|
write_pdf false (Cpdfmetadata.set_open_action pdf true n)
|
|
| Some (OpenAtPageCustom dest) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_pdf false (Cpdfmetadata.set_open_action ~dest pdf true 1)
|
|
| Some (SetMetadata metadata_file) ->
|
|
write_pdf false (Cpdfmetadata.set_metadata args.keepversion metadata_file (get_single_pdf args.op false))
|
|
| Some (SetVersion v) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let pdf =
|
|
if v >= 10
|
|
then {pdf with Pdf.major = 2; Pdf.minor = v - 10}
|
|
else {pdf with Pdf.major = 1; Pdf.minor = v}
|
|
in
|
|
write_pdf false pdf
|
|
| Some (SetPageLayout s) ->
|
|
write_pdf false (Cpdfmetadata.set_page_layout (get_single_pdf args.op false) s)
|
|
| Some (SetPageMode s) ->
|
|
write_pdf false (Cpdfmetadata.set_page_mode (get_single_pdf args.op false) s)
|
|
| Some (SetNonFullScreenPageMode s) ->
|
|
write_pdf false (Cpdfmetadata.set_non_full_screen_page_mode (get_single_pdf args.op false) s)
|
|
| Some Split ->
|
|
begin match args.inputs, args.out with
|
|
| [(f, ranges, _, _, _, _)], File output_spec ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let enc = build_enc () in
|
|
args.create_objstm <- args.preserve_objstm;
|
|
split_pdf
|
|
enc args.original_filename args.chunksize args.linearize ~cpdflin:args.cpdflin
|
|
~preserve_objstm:args.preserve_objstm ~create_objstm:args.preserve_objstm (*yes--always create if preserving *)
|
|
~squeeze:args.squeeze output_spec pdf
|
|
| _, Stdout -> error "Can't split to standard output"
|
|
| _, NoOutputSpecified -> error "Split: No output format specified"
|
|
| _ -> error "Split: bad parameters"
|
|
end
|
|
| Some (SplitOnBookmarks level) ->
|
|
begin match args.out with
|
|
| File output_spec ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let enc = build_enc () in
|
|
args.create_objstm <- args.preserve_objstm;
|
|
split_at_bookmarks
|
|
enc args.original_filename ~squeeze:args.squeeze level output_spec pdf
|
|
| Stdout -> error "Can't split to standard output"
|
|
| NoOutputSpecified -> error "Split: No output format specified"
|
|
end
|
|
| Some (SplitMax s) ->
|
|
begin match args.out with
|
|
| File output_spec ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let enc = build_enc () in
|
|
args.create_objstm <- args.preserve_objstm;
|
|
split_max enc args.original_filename ~squeeze:args.squeeze output_spec s pdf
|
|
| Stdout -> error "Can't split to standard output"
|
|
| NoOutputSpecified -> error "Split: No output format specified"
|
|
end
|
|
| Some Spray ->
|
|
begin match args.inputs, args.out with
|
|
| (_, pagespec, _, _, _, _)::_, File output_spec ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = ref (parse_pagespec pdf pagespec) in
|
|
let enc = build_enc () in
|
|
let pagenums = map ref (many [] (length !spray_outputs)) in
|
|
let n = ref 0 in
|
|
while !range <> [] do
|
|
List.nth pagenums (!n mod (length !spray_outputs)) =| hd !range;
|
|
range := tl !range;
|
|
n += 1;
|
|
done;
|
|
let names = rev !spray_outputs in
|
|
iter (fun x -> if !x = [] then error "Spray: must have at least one page for each output") pagenums;
|
|
args.create_objstm <- args.preserve_objstm;
|
|
fast_write_split_pdfs ~names enc 0 args.original_filename args.squeeze output_spec pdf (map rev (map (!) pagenums)) (Pdfpage.pages_of_pagetree pdf)
|
|
| _, Stdout -> error "Can't spray to standard output"
|
|
| _, NoOutputSpecified -> error "Spray: No output format specified"
|
|
| _, _ -> error "Spray: no input"
|
|
end
|
|
| Some Presentation ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let pdf' =
|
|
Cpdfpresent.presentation
|
|
range
|
|
args.transition args.duration args.horizontal
|
|
args.inward args.direction args.effect_duration pdf
|
|
in
|
|
pdf.Pdf.minor <- if args.keepversion || pdf.Pdf.major > 1 then pdf.Pdf.minor else max pdf.Pdf.minor 1;
|
|
write_pdf false pdf'
|
|
| Some ChangeId ->
|
|
if args.recrypt then
|
|
soft_error "Cannot recrypt with change id: an id is part of encryption information";
|
|
begin match args.inputs, args.out with
|
|
| [(k, _, _, _, _, _) as input], File s ->
|
|
let pdf = get_pdf_from_input_kind input args.op k in
|
|
write_pdf true pdf
|
|
| [(k, _, _, _, _, _) as input], Stdout ->
|
|
let pdf = get_pdf_from_input_kind input args.op k in
|
|
write_pdf true pdf
|
|
| _ -> error "ChangeId: exactly one input file and output file required."
|
|
end
|
|
| Some RemoveId ->
|
|
if args.recrypt then
|
|
soft_error "Cannot recrypt with remove id: an id is part of encryption information";
|
|
let pdf = get_single_pdf args.op false in
|
|
pdf.Pdf.trailerdict <- Pdf.remove_dict_entry pdf.Pdf.trailerdict "/ID";
|
|
write_pdf false pdf
|
|
| Some (CopyId getfrom) ->
|
|
if args.recrypt then
|
|
soft_error "Cannot recrypt with copy id: an id is part of encryption information";
|
|
begin match args.inputs with
|
|
| [(k, _, u, o, _, _) as input] ->
|
|
let pdf =
|
|
Cpdfmetadata.copy_id
|
|
args.keepversion
|
|
(pdfread_pdf_of_file (optstring u) (optstring o) getfrom)
|
|
(get_pdf_from_input_kind input args.op k)
|
|
in
|
|
write_pdf false pdf
|
|
| _ -> error "copy-id: No input file specified"
|
|
end
|
|
| Some (ThinLines w) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdftweak.thinlines range w pdf)
|
|
| Some BlackText ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdftweak.blacktext args.color range pdf)
|
|
| Some BlackLines ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdftweak.blacklines args.color range pdf)
|
|
| Some BlackFills ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdftweak.blackfills args.color range pdf)
|
|
| Some RemoveAnnotations ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfannot.remove_annotations range pdf)
|
|
| Some (CopyAnnotations getfrom) ->
|
|
begin match args.inputs with
|
|
| [(k, _, u, o, _, _) as input] ->
|
|
let input_pdf = get_pdf_from_input_kind input args.op k in
|
|
let range = parse_pagespec_allow_empty input_pdf (get_pagespec ()) in
|
|
Cpdfannot.copy_annotations
|
|
range
|
|
(pdfread_pdf_of_file (optstring u) (optstring o) getfrom)
|
|
input_pdf;
|
|
write_pdf false input_pdf
|
|
| _ -> error "copy-annotations: No input file specified"
|
|
end
|
|
| Some (SetAnnotations json) ->
|
|
let data = Pdfio.input_of_channel (open_in_bin json) in
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfannot.set_annotations_json pdf data;
|
|
write_pdf false pdf
|
|
| Some ListAnnotations ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
if args.format_json then
|
|
flprint (Pdfio.string_of_bytes (Cpdfannot.get_annotations_json pdf range))
|
|
else
|
|
Cpdfannot.list_annotations range args.encoding pdf
|
|
| Some Shift ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let dxdylist = Cpdfcoord.parse_coordinates pdf args.coord in
|
|
write_pdf false (Cpdfpage.shift_pdf ~fast:args.fast dxdylist pdf range)
|
|
| Some ShiftBoxes ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let dxdylist = Cpdfcoord.parse_coordinates pdf args.coord in
|
|
write_pdf false (Cpdfpage.shift_boxes dxdylist pdf range)
|
|
| Some Scale ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let sxsylist = Cpdfcoord.parse_coordinates pdf args.coord in
|
|
write_pdf false (Cpdfpage.scale_pdf ~fast:args.fast sxsylist pdf range)
|
|
| Some ScaleToFit ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
warn_prerotate range pdf;
|
|
let pdf = if args.prerotate then prerotate range pdf else pdf in
|
|
let xylist = Cpdfcoord.parse_coordinates pdf args.coord
|
|
and scale = args.scale in
|
|
write_pdf false (Cpdfpage.scale_to_fit_pdf ~fast:args.fast args.position scale xylist args.op pdf range)
|
|
| Some Stretch ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
warn_prerotate range pdf;
|
|
let pdf = if args.prerotate then prerotate range pdf else pdf in
|
|
let xylist = Cpdfcoord.parse_coordinates pdf args.coord in
|
|
write_pdf false (Cpdfpage.stretch ~fast:args.fast xylist pdf range)
|
|
| Some (ScaleContents scale) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfpage.scale_contents ~fast:args.fast args.position scale pdf range)
|
|
| Some ListAttachedFiles ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let attachments = Cpdfattach.list_attached_files pdf in
|
|
iter
|
|
(fun a -> Printf.printf "%i %s\n" a.Cpdfattach.pagenumber a.Cpdfattach.name)
|
|
attachments;
|
|
flprint ""
|
|
| Some DumpAttachedFiles ->
|
|
let pdf = get_single_pdf args.op false in
|
|
begin match args.out with
|
|
| NoOutputSpecified -> Cpdfattach.dump_attached_files pdf ""
|
|
| File n -> Cpdfattach.dump_attached_files pdf n
|
|
| Stdout -> error "Can't dump attachments to stdout"
|
|
end
|
|
| Some RemoveAttachedFiles ->
|
|
write_pdf false (Cpdfattach.remove_attached_files (get_single_pdf args.op false))
|
|
| Some (AttachFile files) ->
|
|
begin match args.inputs with
|
|
| [(k, _, _, _, _, _) as input] ->
|
|
let pdf = get_pdf_from_input_kind input args.op k in
|
|
let topage =
|
|
try
|
|
match args.topage with
|
|
| None -> None
|
|
| Some "end" -> Some (Pdfpage.endpage pdf)
|
|
| Some s -> Some (int_of_string s)
|
|
with _ -> error "Bad -to-page"
|
|
in
|
|
let pdf = fold_left (Cpdfattach.attach_file args.keepversion topage) pdf (rev files) in
|
|
write_pdf false pdf
|
|
| _ -> error "attach file: No input file specified"
|
|
end
|
|
| Some PadBefore ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let padwith =
|
|
match args.padwith with
|
|
None -> None
|
|
| Some filename -> Some (pdfread_pdf_of_file None None filename)
|
|
in
|
|
write_pdf false (Cpdfpad.padbefore ?padwith range pdf)
|
|
| Some PadAfter ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let padwith =
|
|
match args.padwith with
|
|
None -> None
|
|
| Some filename -> Some (pdfread_pdf_of_file None None filename)
|
|
in
|
|
write_pdf false (Cpdfpad.padafter ?padwith range pdf)
|
|
| Some (PadEvery n) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range =
|
|
match keep (function m -> m mod n = 0) (ilist 1 (Pdfpage.endpage pdf)) with
|
|
| [] -> []
|
|
| l -> if last l = Pdfpage.endpage pdf then all_but_last l else l
|
|
in
|
|
let padwith =
|
|
match args.padwith with
|
|
None -> None
|
|
| Some filename -> Some (pdfread_pdf_of_file None None filename)
|
|
in
|
|
write_pdf false (Cpdfpad.padafter ?padwith range pdf)
|
|
| Some (PadMultiple n) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_pdf false (Cpdfpad.padmultiple n pdf)
|
|
| Some (PadMultipleBefore n) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_pdf false (Cpdfpad.padmultiple (-n) pdf)
|
|
| Some Draft ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfdraft.draft args.removeonly args.boxes range pdf)
|
|
| Some (AddText text) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let cpdffont = embed_font () in
|
|
warn_prerotate range pdf;
|
|
let pdf =
|
|
if args.prerotate then prerotate range pdf else pdf
|
|
and filename =
|
|
match args.inputs with
|
|
| (InFile inname, _, _, _, _, _)::_ -> inname
|
|
| _ -> ""
|
|
in
|
|
write_pdf false
|
|
(Cpdfaddtext.addtexts
|
|
args.linewidth args.outline args.fast args.fontname
|
|
cpdffont args.bates args.batespad args.color args.position
|
|
args.linespacing args.fontsize args.underneath text range
|
|
args.relative_to_cropbox args.opacity
|
|
args.justification args.midline args.topline filename
|
|
args.extract_text_font_size args.coord ~raw:(args.encoding = Raw) pdf)
|
|
| Some RemoveText ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfremovetext.removetext range pdf)
|
|
| Some AddRectangle ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false
|
|
(Cpdfaddtext.addrectangle
|
|
args.fast (Cpdfcoord.parse_coordinate pdf args.coord)
|
|
args.color args.outline args.linewidth args.opacity args.position
|
|
args.relative_to_cropbox args.underneath range pdf)
|
|
| Some (AddBookmarks file) ->
|
|
write_pdf false
|
|
(Cpdfbookmarks.add_bookmarks ~json:args.format_json true (Pdfio.input_of_channel (open_in_bin file))
|
|
(get_single_pdf args.op false))
|
|
| Some RemoveBookmarks ->
|
|
write_pdf false (Pdfmarks.remove_bookmarks (get_single_pdf args.op false))
|
|
| Some TwoUp ->
|
|
write_pdf false (Cpdfimpose.twoup args.fast (get_single_pdf args.op false))
|
|
| Some TwoUpStack ->
|
|
write_pdf false (Cpdfimpose.twoup_stack args.fast (get_single_pdf args.op false))
|
|
| Some Impose fit ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let x, y = Cpdfcoord.parse_coordinate pdf args.coord in
|
|
if not fit && (x < 0.0 || y < 0.0) then error "Negative imposition parameters not allowed." else
|
|
write_pdf false
|
|
(Cpdfimpose.impose ~x ~y ~fit ~columns:args.impose_columns ~rtl:args.impose_rtl ~btt:args.impose_btt ~center:args.impose_center
|
|
~margin:args.impose_margin ~spacing:args.impose_spacing ~linewidth:args.impose_linewidth ~fast:args.fast pdf)
|
|
| Some (StampOn over) ->
|
|
let overpdf =
|
|
match over with
|
|
| "stamp_use_stdin" -> pdf_of_stdin "" ""
|
|
| x -> pdfread_pdf_of_file None None x
|
|
in
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let pdf =
|
|
Cpdfpage.stamp
|
|
args.relative_to_cropbox args.position args.topline args.midline args.fast
|
|
args.scale_stamp_to_fit true range overpdf pdf
|
|
in
|
|
write_pdf false pdf
|
|
| Some (StampUnder under) ->
|
|
let underpdf =
|
|
match under with
|
|
| "stamp_use_stdin" -> pdf_of_stdin "" ""
|
|
| x -> pdfread_pdf_of_file None None x
|
|
in
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let pdf =
|
|
Cpdfpage.stamp
|
|
args.relative_to_cropbox args.position args.topline args.midline args.fast
|
|
args.scale_stamp_to_fit false range underpdf pdf
|
|
in
|
|
write_pdf false pdf
|
|
| Some (CombinePages over) ->
|
|
let underpdf = get_single_pdf args.op false in
|
|
let overpdf = pdfread_pdf_of_file None None over in
|
|
warn_prerotate (parse_pagespec underpdf "all") underpdf;
|
|
warn_prerotate (parse_pagespec overpdf "all") overpdf;
|
|
write_pdf false
|
|
(Cpdfpage.combine_pages
|
|
args.fast
|
|
(prerotate (parse_pagespec underpdf "all") underpdf)
|
|
(prerotate (parse_pagespec overpdf "all") overpdf)
|
|
false false true)
|
|
| Some Encrypt ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let pdf = Cpdfsqueeze.recompress_pdf pdf
|
|
and encryption = build_enc () in
|
|
Pdf.remove_unreferenced pdf;
|
|
if not args.keepversion then
|
|
begin
|
|
let newversion =
|
|
match args.crypt_method with
|
|
"40bit" -> 1 | "128bit" -> 4 | "AES" -> 6 | "AES256" | "AES256ISO" -> 7 | _ -> 0
|
|
in
|
|
let newversion = if args.create_objstm then 5 else newversion in
|
|
if pdf.Pdf.major = 1 then pdf.Pdf.minor <- max pdf.Pdf.minor newversion
|
|
end;
|
|
write_pdf ~encryption false pdf
|
|
| Some Decrypt ->
|
|
args.recrypt <- false;
|
|
write_pdf false (get_single_pdf args.op false)
|
|
| Some RemoveMetadata ->
|
|
write_pdf false (Cpdfmetadata.remove_metadata (get_single_pdf args.op false))
|
|
| Some ExtractImages ->
|
|
let output_spec =
|
|
begin match args.out with
|
|
| File output_spec -> output_spec
|
|
| _ -> ""
|
|
end
|
|
in
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
Cpdfimage.extract_images ~raw:(args.encoding = Cpdfmetadata.Raw) ?path_to_p2p:(match args.path_to_p2p with "" -> None | x -> Some x) ?path_to_im:(match args.path_to_im with "" -> None | x -> Some x) args.encoding args.dedup args.dedup_per_page pdf range output_spec
|
|
| Some (ImageResolution f) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
if args.format_json then
|
|
flprint (Pdfio.string_of_bytes (Cpdfimage.image_resolution_json pdf range f))
|
|
else
|
|
let images = Cpdfimage.image_resolution pdf range f in
|
|
iter
|
|
(function (pagenum, xobject, w, h, wdpi, hdpi, objnum) ->
|
|
if wdpi < f || hdpi < f then
|
|
Printf.printf "%i, %s, %i, %i, %f, %f, %i\n" pagenum xobject w h wdpi hdpi objnum)
|
|
images
|
|
| Some ListImages ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let json = Cpdfimage.images pdf range in
|
|
if args.format_json then
|
|
flprint (Cpdfyojson.Safe.pretty_to_string json)
|
|
else
|
|
begin match json with
|
|
| `List l ->
|
|
iter
|
|
(function (`Assoc [(_, `Int i); (_, `List pages); (_, `String name); (_, `Int w); (_, `Int h); (_, `Int size); (_, bpc); (_, cs); (_, `String filter)]) ->
|
|
let pages = combine_with_spaces (map (function `Int i -> string_of_int i | _ -> "") pages) in
|
|
let bpc = match bpc with `Int bpc -> string_of_int bpc | _ -> "none" in
|
|
let cs = match cs with `String cs -> cs | _ -> "none" in
|
|
flprint (Printf.sprintf "%i, %s, %s, %i, %i, %i, %s, %s, %s\n" i pages name w h size bpc cs filter)
|
|
| _ -> ())
|
|
l
|
|
| _ -> ()
|
|
end
|
|
| Some MissingFonts ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
Cpdffont.missing_fonts pdf range
|
|
| Some ExtractText ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let text = Cpdfextracttext.extract_text args.extract_text_font_size pdf range in
|
|
begin match args.out with
|
|
| File filename ->
|
|
let fh = open_out_bin filename in
|
|
output_string fh text;
|
|
close_out fh
|
|
| NoOutputSpecified | Stdout ->
|
|
print_string text;
|
|
print_newline ()
|
|
end
|
|
| Some AddPageLabels ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec pdf (get_pagespec ()) in
|
|
Cpdfpagelabels.add_page_labels
|
|
pdf args.labelsprogress args.labelstyle args.labelprefix args.labelstartval range;
|
|
write_pdf false pdf
|
|
| Some RemovePageLabels ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Pdfpagelabels.remove pdf;
|
|
write_pdf false pdf
|
|
| Some PrintPageLabels ->
|
|
let pdf = get_single_pdf args.op true in
|
|
if args.format_json then
|
|
let json_of_pagelabel l =
|
|
`Assoc
|
|
[("labelstyle", `String (Pdfpagelabels.string_of_labelstyle l.Pdfpagelabels.labelstyle));
|
|
("labelprefix", begin match l.Pdfpagelabels.labelprefix with None -> `Null | Some s -> `String s end);
|
|
("startpage", `Int l.Pdfpagelabels.startpage);
|
|
("startvalue", `Int l.Pdfpagelabels.startvalue)]
|
|
in
|
|
flprint (Cpdfyojson.Safe.pretty_to_string (`List (map json_of_pagelabel (Pdfpagelabels.read pdf))))
|
|
else
|
|
iter
|
|
print_string
|
|
(map Pdfpagelabels.string_of_pagelabel (Pdfpagelabels.read pdf))
|
|
| Some (RemoveDictEntry key) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdftweak.remove_dict_entry pdf key args.dict_entry_search;
|
|
write_pdf false pdf
|
|
| Some (ReplaceDictEntry key) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdftweak.replace_dict_entry pdf key args.replace_dict_entry_value args.dict_entry_search;
|
|
write_pdf false pdf
|
|
| Some (PrintDictEntry key) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdftweak.print_dict_entry ~utf8:(args.encoding = Cpdfmetadata.UTF8) pdf key
|
|
| Some ListSpotColours ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfspot.list_spot_colours pdf
|
|
| Some RemoveClipping ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdftweak.remove_clipping pdf range)
|
|
| Some CreateMetadata ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_pdf false (Cpdfmetadata.create_metadata pdf)
|
|
| Some EmbedMissingFonts ->
|
|
let fi =
|
|
match args.inputs with
|
|
[(InFile fi, _, _, _, _, _)] -> fi
|
|
| _ -> error "Input method not supported for -embed-missing-fonts"
|
|
in
|
|
let fo =
|
|
match args.out with
|
|
File fo -> fo
|
|
| _ -> error "Output method not supported for -embed-missing-fonts"
|
|
in
|
|
Cpdffont.embed_missing_fonts args.path_to_ghostscript args.gs_quiet fi fo
|
|
| Some (BookmarksOpenToLevel n) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_pdf false (Cpdfbookmarks.bookmarks_open_to_level n pdf)
|
|
| Some CreatePDF ->
|
|
let pdf = Cpdfcreate.blank_document_paper args.createpdf_pagesize args.createpdf_pages in
|
|
write_pdf false pdf
|
|
| Some RemoveAllText ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfremovetext.remove_all_text range pdf)
|
|
| Some ShowBoxes ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfpage.show_boxes pdf range)
|
|
| Some TrimMarks ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfpage.trim_marks pdf range)
|
|
| Some (Postpend s | Prepend s as x) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let before = match x with Prepend _ -> true | _ -> false in
|
|
write_pdf false (Cpdftweak.append_page_content s before args.fast range pdf)
|
|
| Some OutputJSON ->
|
|
let pdf = get_single_pdf args.op false in
|
|
write_json args.out pdf
|
|
| Some OCGCoalesce ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfocg.ocg_coalesce pdf;
|
|
write_pdf false pdf
|
|
| Some OCGList ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdfocg.ocg_list pdf
|
|
| Some OCGRename ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfocg.ocg_rename args.ocgrenamefrom args.ocgrenameto pdf;
|
|
write_pdf false pdf
|
|
| Some OCGOrderAll ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfocg.ocg_order_all pdf;
|
|
write_pdf false pdf
|
|
| Some (StampAsXObject stamp) ->
|
|
let stamp_pdf =
|
|
match stamp with
|
|
| "stamp_use_stdin" -> pdf_of_stdin "" ""
|
|
| x -> pdfread_pdf_of_file None None x
|
|
in
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let pdf, xobj_name =
|
|
Cpdfxobject.stamp_as_xobject pdf range stamp_pdf
|
|
in
|
|
Printf.printf "%s\n" xobj_name;
|
|
flush stdout;
|
|
write_pdf false pdf
|
|
| Some (PrintFontEncoding fontname) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdffont.print_font_table pdf fontname args.copyfontpage
|
|
| Some TableOfContents ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let cpdffont = embed_font () in
|
|
let pdf =
|
|
Cpdftoc.typeset_table_of_contents
|
|
~font:cpdffont ~fontsize:args.fontsize ~title:args.toc_title ~bookmark:args.toc_bookmark pdf
|
|
in
|
|
write_pdf false pdf
|
|
| Some (Typeset filename) ->
|
|
let text = Pdfio.bytes_of_input_channel (open_in_bin filename) in
|
|
let cpdffont = embed_font () in
|
|
let pdf = Cpdftexttopdf.typeset ~font:cpdffont ~papersize:args.createpdf_pagesize ~fontsize:args.fontsize text in
|
|
write_pdf false pdf
|
|
| Some (TextWidth s) ->
|
|
let rawwidth =
|
|
match args.font with
|
|
| StandardFont f ->
|
|
Pdfstandard14.textwidth false WinAnsiEncoding f s
|
|
| _ ->
|
|
error "-text-width only works for the standard 14 fonts"
|
|
in
|
|
let w = (float rawwidth *. args.fontsize) /. 1000. in
|
|
Printf.printf "%f\n" w
|
|
| Some Draw ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
let ops = match !Cpdfdrawcontrol.drawops with [("_MAIN", ops)] -> rev ops | _ -> error "not enough -end-xobj or -et" in
|
|
write_pdf
|
|
false
|
|
(Cpdfdraw.draw ~struct_tree:args.draw_struct_tree ~fast:args.fast ~underneath:args.underneath ~filename:args.original_filename ~bates:args.bates ~batespad:args.batespad range pdf ops)
|
|
| Some (Composition json) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let filesize =
|
|
match args.inputs with
|
|
| (InFile inname, _, _, _, _, _)::_ -> filesize inname
|
|
| _ -> 0
|
|
in
|
|
Cpdfcomposition.show_composition filesize json pdf
|
|
| Some (Chop (x, y)) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfchop.chop ~x ~y ~columns:args.impose_columns ~btt:args.impose_btt ~rtl:args.impose_rtl pdf range)
|
|
| Some (ChopHV (is_h, line)) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfchop.chop_hv ~is_h ~line ~columns:args.impose_columns pdf range)
|
|
| Some ProcessImages ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
Cpdfimage.process
|
|
~q:args.jpegquality ~qlossless:args.jpegqualitylossless ~onebppmethod:args.onebppmethod ~jbig2_lossy_threshold:args.jbig2_lossy_threshold
|
|
~length_threshold:args.length_threshold ~percentage_threshold:args.percentage_threshold ~pixel_threshold:args.pixel_threshold
|
|
~dpi_threshold:args.dpi_threshold ~factor:args.resample_factor ~interpolate:args.resample_interpolate
|
|
~path_to_jbig2enc:args.path_to_jbig2enc ~path_to_convert:args.path_to_im range pdf;
|
|
write_pdf false pdf
|
|
| Some (ExtractStream s) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
extract_stream pdf args.extract_stream_decompress s
|
|
| Some (PrintObj s) ->
|
|
let pdf = get_single_pdf args.op true in
|
|
print_obj pdf s
|
|
| Some (ReplaceObj (a, b)) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let pdfobj = Cpdfjson.object_of_json (Cpdfyojson.Safe.from_string b) in
|
|
replace_obj pdf a pdfobj;
|
|
write_pdf false pdf
|
|
| Some (Verify standard) ->
|
|
begin match standard with
|
|
| "PDF/UA-1(matterhorn)" ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let testname = match args.verify_single with None -> "" | Some x -> x in
|
|
if args.format_json
|
|
then flprint (Cpdfyojson.Safe.pretty_to_string (Cpdfua.test_matterhorn_json pdf testname))
|
|
else Cpdfua.test_matterhorn_print pdf testname
|
|
| _ -> error "Unknown verification type."
|
|
end
|
|
| Some (MarkAs standard) ->
|
|
begin match standard with
|
|
| Cpdfua.PDFUA1 ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfua.mark pdf;
|
|
write_pdf false pdf
|
|
| Cpdfua.PDFUA2 ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfua.mark2 2024 pdf;
|
|
write_pdf false pdf
|
|
end
|
|
| Some (RemoveMark standard) ->
|
|
begin match standard with
|
|
| Cpdfua.PDFUA1 | Cpdfua.PDFUA2 ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfua.remove_mark pdf;
|
|
write_pdf false pdf
|
|
end
|
|
| Some PrintStructTree ->
|
|
let pdf = get_single_pdf args.op true in
|
|
Cpdfua.print_struct_tree pdf
|
|
| Some ExtractStructTree ->
|
|
let pdf = get_single_pdf args.op true in
|
|
let json = Cpdfua.extract_struct_tree pdf in
|
|
json_to_output json args.out
|
|
| Some (ReplaceStructTree s) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let json = Cpdfyojson.Safe.from_file s in
|
|
Cpdfua.replace_struct_tree pdf json;
|
|
write_pdf false pdf
|
|
| Some (SetLanguage s) ->
|
|
let pdf = get_single_pdf args.op false in
|
|
Cpdfmetadata.set_language pdf s;
|
|
write_pdf false pdf
|
|
| Some Redact ->
|
|
let pdf = get_single_pdf args.op false in
|
|
let range = parse_pagespec_allow_empty pdf (get_pagespec ()) in
|
|
write_pdf false (Cpdfpage.redact ~process_struct_tree:args.process_struct_trees pdf range)
|
|
|
|
(* Advise the user if a combination of command line flags makes little sense,
|
|
or error out if it make no sense at all. *)
|
|
let check_command_line () =
|
|
if args.gs_malformed && !Pdfread.error_on_malformed then
|
|
error "Setting both -gs-malformed and -error-on-malformed makes no sense"
|
|
|
|
let parse_argv () s specs anon_fun usage_msg =
|
|
if args.debug then
|
|
Array.iter (fun s -> Pdfe.log (Printf.sprintf "arg: %s\n" s)) Sys.argv;
|
|
Arg.parse_argv ~current:(ref 0) s specs anon_fun usage_msg;
|
|
check_command_line ()
|
|
|
|
let align_specs s =
|
|
Arg.align s
|
|
|
|
(* The old -control mechanism clashed with AND, but must be retained for
|
|
backwards compatibility. There is a new mechanism -args file which performs
|
|
direct textual substitution of the file, before any expansion of ANDs *)
|
|
let rec expand_args_inner prev = function
|
|
[] -> rev prev
|
|
| "-args"::filename::r ->
|
|
expand_args_inner (rev (parse_control_file filename) @ prev) r
|
|
| "-args-json"::filename::r ->
|
|
expand_args_inner (rev (parse_control_file_json filename) @ prev) r
|
|
| h::t -> expand_args_inner (h::prev) t
|
|
|
|
let expand_args argv =
|
|
let l = Array.to_list argv in
|
|
Array.of_list (expand_args_inner [] l)
|
|
|
|
let rec expand_recipes = function
|
|
| [] -> []
|
|
| "-create-pdf-ua-1"::title::t -> Cpdfua.cpdfua_args title @ expand_recipes t
|
|
| "-create-pdf-ua-2"::title::t -> Cpdfua.cpdfua2_args title @ expand_recipes t
|
|
| h::t -> h::expand_recipes t
|
|
|
|
let expand_recipes argv =
|
|
Array.of_list (expand_recipes (Array.to_list argv))
|
|
|
|
let gs_malformed_force fi fo =
|
|
if args.path_to_ghostscript = "" then begin
|
|
Pdfe.log "Please supply path to gs with -gs\n";
|
|
exit 2
|
|
end;
|
|
let gscall =
|
|
Filename.quote_command args.path_to_ghostscript
|
|
((if args.gs_quiet then ["-dQUIET"] else []) @
|
|
["-dNOPAUSE"; "-sDEVICE=pdfwrite"; "-sOUTPUTFILE=" ^ fo; "-dBATCH"; fi])
|
|
in
|
|
match Sys.command gscall with
|
|
| 0 -> exit 0
|
|
| _ -> Pdfe.log "Failed to mend file.\n"; exit 2
|
|
|
|
let process_env_vars () =
|
|
match Sys.getenv_opt "CPDF_DEBUG" with
|
|
| Some "true" -> args.debug <- true
|
|
| Some "false" -> args.debug <- false
|
|
| _ -> ()
|
|
|
|
(* Main function. *)
|
|
let go_withargv argv =
|
|
(* Check for the standalone -gs-malformed-force special command line. This
|
|
* has exactly one file input and exactly one output and just -gs <gs>
|
|
* -gs-malformed-force between. *)
|
|
match argv with
|
|
[|_; inputfilename; "-gs"; gslocation; "-gs-malformed-force"; "-o"; outputfilename|] ->
|
|
args.path_to_ghostscript <- gslocation;
|
|
ignore (gs_malformed_force inputfilename outputfilename);
|
|
exit 0
|
|
| [|_; inputfilename; "-gs"; gslocation; "-gs-malformed-force"; "-o"; outputfilename; "-gs-quiet"|] ->
|
|
args.path_to_ghostscript <- gslocation;
|
|
args.gs_quiet <- true;
|
|
ignore (gs_malformed_force inputfilename outputfilename);
|
|
exit 0
|
|
| _ ->
|
|
Hashtbl.clear filenames;
|
|
if demo then
|
|
flprint "This demo functions normally, but is for evaluation only. https://www.coherentpdf.com/\n";
|
|
try
|
|
(* Pre-expands recipes like -create-pdf-ua-1 *)
|
|
let argv = expand_recipes argv in
|
|
(* Pre-expand -args *)
|
|
let argv = expand_args argv in
|
|
(* Split the arguments into sets either side of ANDs *)
|
|
let sets =
|
|
let args =
|
|
(map (fun l -> "cpdf"::l) (split_around (eq "AND") (tl (Array.to_list argv))))
|
|
in
|
|
match args with
|
|
| [] -> []
|
|
| _ -> combine (map Array.of_list args) (map (eq (length args)) (ilist 1 (length args)))
|
|
in
|
|
iter
|
|
(fun (s, islast) ->
|
|
(*Printf.printf "AND:%b, %s\n" islast (Array.fold_left (fun x y -> x ^ " " ^ y) "" s);
|
|
flprint "\n";*)
|
|
reset_arguments ();
|
|
Cpdfdrawcontrol.drawops := [("_MAIN", [])];
|
|
process_env_vars ();
|
|
parse_argv () s (align_specs specs) anon_fun usage_msg;
|
|
let addrange pdf = AlreadyInMemory (pdf, "fromAND"), args.dashrange, "", "", ref false, None in
|
|
args.inputs <- rev (map addrange !output_pdfs) @ rev args.inputs;
|
|
output_pdfs := [];
|
|
go ())
|
|
sets;
|
|
flush stdout; (*r for Windows *)
|
|
exit 0
|
|
with
|
|
| Arg.Bad s ->
|
|
Pdfe.log
|
|
(implode (takewhile (neq '\n') (explode s)) ^ " Use -help for help.\n\n");
|
|
if not !stay_on_error then exit 2 else raise StayOnError
|
|
| Arg.Help _ ->
|
|
Arg.usage (align_specs specs) usage_msg;
|
|
flush stderr (*r for Windows *)
|
|
| Sys_error s as e ->
|
|
Pdfe.log (s ^ "\n\n");
|
|
if not !stay_on_error then
|
|
(if args.debug then raise e else exit 2)
|
|
else raise StayOnError
|
|
| Pdf.PDFError s as e ->
|
|
Pdfe.log
|
|
("cpdf encountered an error. Technical details follow:\n\n" ^ s ^ "\n\n");
|
|
if not !stay_on_error then
|
|
if args.debug then raise e else exit 2
|
|
else
|
|
raise StayOnError
|
|
| Cpdferror.SoftError s -> soft_error s
|
|
| Cpdferror.HardError s -> error s
|
|
| e ->
|
|
Pdfe.log
|
|
("cpdf encountered an unexpected error. Technical Details follow:\n" ^
|
|
Printexc.to_string e ^ "\n\n");
|
|
if not !stay_on_error then
|
|
(if args.debug then raise e else exit 2) else raise StayOnError
|
|
|
|
let go () =
|
|
go_withargv Sys.argv
|