For other information, see the Ghostscriptoverview and the instructions on how to installGhostscript.General overviewThis document describes how to build a Ghostscript executable from sourcecode. There are four major steps to building Ghostscript:Acquire the compressed archive files of source code for Ghostscript andthe required third-party libraries.Unpack the archive files into the Ghostscript directory and correctlynamed subdirectories.Configure the build to match your system and desired configuration options.Invoke "make" to build the software.The remainder of this document describes each of these steps in detail.Note that some of this process is platform-dependent. After buildingGhostscript you must then install it; for that, see theinstallation instructions.How to acquire the source codeBuilding Ghostscript requires the Ghostscript source code itself, and alsothe source code for some third-party libraries that Ghostscript uses.Ghostscript source codeThere are two kinds of Ghostscript distributions available, called "AFPLGhostscript" and "GPL Ghostscript"; the distinction between them isexplained in the conditions for distributingGhostscript. The authoritative distribution site for AFPLGhostscript is "###" is the unpunctuated version number. GPL Ghostscript is available from the same site at source code is packaged in two different formats:gzip-compressed tar files (*.tar.gz) and zip files(*.zip). For all versions there are gzip-compressed tarfiles:ghostscript-#.##.tar.gzghostscript-fonts-std-#.##.tar.gzghostscript-fonts-other-#.##.tar.gzFor recent versions of Ghostscript there are also zip filesgs###src.zipgs###w32.exe("#.##" and "###" are version numbers in punctuated and unpunctuated form.)Software to decompress and extract both formats is available for almostevery platform for which Ghostscript is available -- including Unix, DOS,MS Windows, and VMS -- so you can choose the format most convenient foryou; but it's up to you to locate that software. See the section on unpacking the source code.Third-party library source codeTo build Ghostscript you need the source code for the Independent JPEG Group (IJG) library, thePortable Network Graphics(PNG)library, and the zlibcompression and decompression library. The default build also expects sourcefor the jbig2dec JBIG2 decompressionlibrary.On Windows and MacOS, the .zip and .sit source archives include the appropriate source versions of these libraries, so no additional downloads are necessary.Unix tarballs may also contain appropriate library source; the configure scriptwill tell you if it cannot find the appropriate libraries.Here are authoritative distribution points for these libraries, should you needto obtain the source yourself. As elsewhere, "#" is used for versionnumbers. The JPEG source code is quite stable, so the referencehere includes the latest version number. Versions of the zlib source are not compatible between the 1.1.x and 1.2.x series; if you wish to compile in zlib (as opposed to linking to a separately build dynamic library) you must use a 1.2.x version.Third-party libraries: authoritative sourcesJPEG -#.#.#.tar.gz -#.#.#.tar.gz (latest) -1.2.1.tar.gz See the official website for a list of mirrors.jbig2dec _id=28301On DOS or MS Windows one ordinarily uses the zip file kits, in otherenvironments the compressed tar files, but this is simply a matter ofconvenience, since for the same version of the software the compressed tarfile has the same contents as the zip file. Note that each of theselibraries has its own version number that hasnothing to do with Ghostscript's version number; you shouldget the highest numbered version. (If you encounter difficulties in thebuild process you might have to use a lower-numbered version, but don'tworry about this yet.) If you're running Linux, you might check whetherthese libraries are already available in source form on your system, sincemany Linux distributors include them; but we advise you to get the highestversion from the Net if you can.How to unpack the source codeUnfortunately there are no generally accepted standards for how to packagesource code into archives, so the instructions for unpacking Ghostscript arelonger than they should be. We begin with a brief explanation of how toextract the two kinds of archive files.How to unpack compressed tar files generallyTar (.tar) files are the de facto standard forarchiving files on Unix (every Unix system has the tarprogram), and programs to extract their contents are also widely availablefor DOS, MS Windows, and VMS. To economize on space and downloading time,Ghostscript's tar files are compressed with GNU gzip, whichadds the suffix ".gz" to the file name, giving".tar.gz".To unpack a compressed tar file MyArchive.tar.gz youmust both decompress it and extract the contents. You can do this in twosteps, one to decompress the file and another to unpack it:gzip -d MyArchive.tar.gztar -xf MyArchive.taror in a pipeline:gzip -d -c MyArchive.tar.gz tar -xf -or, if you have a program like GNU tar that can handlecompressed tar files, with a single command:tar -zxf MyArchive.tar.gzThe tar program automatically preserves directory structurein extracting files. The Ghostscript source archive puts all files under adirectory gs#.##, so using tar to unpack acompressed archive should always properly create that directory, which wewill call the "gs directory". Make sure you're positioned in theparent of the gs directory before unpackingthe files. If a subdirectory doesn't already exist, tarcreates it.Some other programs -- under MS Windows, for instance -- can also unpackcompressed tar files, but they may not automatically preserve directorystructure nor even extract files into the current directory. If you useone of these, you mustset the program's options to "Use folder names" or the equivalent, andcheck that it is extracting files into the right place.How to unpack zip files generallyZip files are the de facto standard for archiving files on DOS andMS Windows, and programs to extract their contents are widely available forDOS, MS Windows, Unix, VMS, and other platforms. Zip files are at once anarchive format and a compressed format, so an unzipping programdecompresses and extracts archived files as a single step.One common 16-bit DOS program is pkunzip, which comes inthe pkzip package. If you use this, you should ensure thatyou have at least version 2.04g, because with its -dswitch, that version of pkunzip preserves the directorystructure of archived files when extracting them; see below. Anotherpopular free program to unpack zip archives, available for DOS and MSWindows (16-bit and 32-bit), Unix, VMS, and other platforms, is InfoZIPunzip: -zip.org/pub/infozip/UnZip.htmlUnlike pkunzip, InfoZIP unzip automaticallypreserves the directory structure of extracted files. So if you have a ziparchive MyArchive.zip:Extracting zipped filesCommand Preserves directory structurepkunzip MyArchive.zip Does NOTpkunzip -d MyArchive.zip DOES (note the -d switch)unzip MyArchive.zip DOESAs with the compressed tar files, make sure you're positioned in theparent of the gs directory before unpackingthe files. If a subdirectory doesn't already exist, zip orpkunzip -d creates it.How to unpack Ghostscript itselfAt this point you have acquired all the source codeand are ready to unpack it according to the preceding guidelines for tar files or zip files. Tounpack the Ghostscript source, make the parent of the (new)gs directory the current directory.2-step: gzip -d ghostscript-#.##.tar.gztar -xf ghostscript-#.##.tarPipe: gzip -d -c ghostscript-#.##.tar.gz tar -xf -GNU tar: tar -zxf ghostscript-#.##.tar.gzpkunzip: pkunzip -d gs###sr1.zippkunzip -d gs###sr2.zip...unzip: unzip gs###src.zipAll the Ghostscript source files are now in subdirectories of the gsdirectory.Source subdirectoriesSubdirectory Contentssrc/ C source code and makefileslib/ PostScript files and scripts used when running Ghostscriptdoc/ Documentationman/ Unix man pagesexamples/ Sample PostScript filesHow to unpack the third-party librariesThe Ghostscript makefiles expect to find the JPEG, PNG, and zlib source codein specific subdirectories of the gs directory, and thismeans you must pay careful attention to unpacking the source code for thesepackages. Use the same method for all of them, no matter how they'repackaged:Make the gs directory current.Unpack the archive file, creating a subdirectory (which will include aversion number).Whatever the subdirectory's original name, rename it to the versionlessname shown just below.If you're uncertain how to unpack an archive, review the sections on compressed tar files and zipfiles.3d-party software subdirectoriesPackage Possibleoriginal name Rename toJPEG ./jpeg-6b ./jpegPNG ./libpng-#.## ./libpngzlib ./zlib-#.#.# ./zlibLuratech compressor librariesGhostscript has optional support for the Luratech proprietary JBIG2 and JPEG 2000 implementations. If you have the source code for these and wish the compile them into Ghostscript, the build system expects them to be in directories named ldf_jb2 and lwf_jb2 in the top level gs source directory, alongside the other third-party libraries.How to check for post-release bug fixesBug information and fixes are tracked on Ghostscript Bugzilla.For more information, please visit to prepare the makefilesThe Ghostscript makefiles are very large and complex in order to deal withthe diverse requirements of all the different systems where they may beused.Ghostscript has an automatic configuration script. If you're on unix ora system that supports unix shell scripts, this is the easiest option to use.Simply type:./configurefrom the top level of the ghostscript source directory. It should configureitself based on what's available on your system, warn you of any missingdependencies, and generate a Makefile. At this point you can skip to thesection invoking make below. Also, many common configuration options (like install location) can be set through options to the configure script. Type './configure --help' for a completelisting. Note that the configuration option is only available with the unix .tar distributions of the source.Note that if you're building Ghostscript from development source out ofa repository instead of from a released source package, you should run'./autogen.sh' instead of ./configure. This script takes all the same options that configure does.If your system doesn't support the configure script or you don't wish touse it, you can use the traditional ghostscript makefile system, editingthe options by hand to match your system as described below.Fortunately, the only makefiles you're likely to want to change arerelatively small ones containing platform-specific information.Platform-specific makefilesMakefile Used forMakefile.in Template makefile for the autoconf buildbcwin32.mak MS Windows with Borland/Inprise compilersmsvc32.mak MS Windows with Microsoft Visual C++ version 4 to 7.openvms.mak OpenVMSos2.mak OS/2 with the gcc/emx compilerunix-gcc.mak Unix with gccunixansi.mak Unix with ANSI C compilers other than gccwatcw32.mak MS Windows with Watcom compilers Platform-independent makefilescontrib.mak Contributed device driversdevs.mak Maintained device driversgs.mak Documentation and miscellanyicclib.mak ICC color correction libraryijs.mak IJS raster driver libraryint.mak Main makefile for the PostScript & PDF interpreterjpeg.mak JPEG librarylib.mak Graphics enginelibpng.mak PNG libraryversion.mak Version and release datezlib.mak zlib librarySince these files change from one Ghostscript version to another, sometimessubstantially, and since they all include documentation for the variousoptions, here we don't duplicate most of that documentation: we recommendstrongly that you review the entire makefile specific for your operatingsystem and compiler before building Ghostscript.Building against the Luratech compression librariesTo compile Ghostscript against the proprietary Luratech JBIG2 and JPEG 2000 implementations, edit the JBIG2_* and JPX_* defines in the third-party library section of the toplevel makefile. The autoconfmakefile has a commented-out example of the useful form. Changes for your environmentYou must edit the platform-specific makefile to change any of these:The name of the makefile itself (MAKEFILE macro)The locations to install Ghostscript files (prefix etc.)The default search paths for the initialization and font files(GS_LIB_DEFAULT macro)The debugging options (DEBUG and TDEBUGmacros)Which optional features to include (FEATURE_DEVS)Which device drivers to include (DEVICE_DEVS andDEVICE_DEVS1--20 macros)Default resolution parameters for some printer drivers(devs.mak or contrib.mak, whichever definesthe driver)The platform-specific makefilesinclude comments describing all these except theDEVICE_DEVS options. These are described indevs.mak and contrib.mak, even though thefile that must be edited to select them is the platform-specific makefile. Checkalso the JVERSION and PVERSION macros inthe platform-specific makefile, and adjust them if they don't match theJPEG and PNG library versions you're using: see jpeg.makand libpng.mak for more information.Some platform-specific options are described in the sections for individualplatforms. See the "Options" section near the beginning of the relevantmakefile for more information.Selecting features and devicesYou may build Ghostscript with any of a variety of features and with anysubset of the available device drivers. The complete list of features isin a comment at the beginning of gs.mak, and the completelist of drivers in comments at the beginning of devs.makand contrib.mak. To find what devices a platform-specificmakefile selects to include in the executable, look in it for all lines ofthe formFEATURE_DEVS=list of featuresDEVICE_DEVS*=list of devicesFor example, if the makefile hasFEATURE_DEVS=$(PSD)level2.devindicating that only the PostScript Level 2 facilities should be included,you might make itFEATURE_DEVS=$(PSD)level2.dev $(PSD)pdf.devto add the ability to interpret PDF files. (In fact,FEATURE_DEVS in the current Unix makefiles already includes$(PSD)pdf.dev.) The Unix makefile also definesDEVICE_DEVS=$(DD)x11.devindicating that the X Windows driver should be included, but sinceplatform-specific makefiles as distributed normally include many of thepossible features and drivers, you will probably rather remove from themakefile the features and drivers you don't want. It does no harm toinclude unneeded features and devices, but the resulting executable will belarger than needed.You may edit the FEATURE_DEVS line to select or omit any ofthe features listed near the beginning of gs.mak, and theDEVICE_DEVS* lines to select or omit any of the devicedrivers listed near the beginning of devs.mak andcontrib.mak. The first device listed in the definition ofDEVICE_DEVS becomes the default device for this executable;see the usage documentation for how toselect an output device at run time using the-sDEVICE= switch. Ifyou can't fit all the devices on a single line, you may add lines definingDEVICE_DEVS1=$(DD)dev11.dev ... $(DD)dev1n.devDEVICE_DEVS2=$(DD)dev21.dev ... $(DD)dev2n.devetc., up to DEVICE_DEVS15. Don't use continuation lines --on some platforms they don't work.Note that if you want to include a driver named xxx, you must put$(DD)xxx.dev inDEVICE_DEVS*. Similarly, if you want to include a featurerelated to the PostScript or PDF language interpreters (PostScript level1 .. 3, or other language features such as the ability to read EPSF files orTrueType font files), you must represent it as$(PSD)xxx.dev. If you are linkingonly the graphics library -- not the language interpreter(s) -- with anapplication and want to include optional graphics library features such asCIE color, you represent them as$(GLD)xxx.dev.Precompiled run-time dataGhostscript normally reads a number of external data files at run time:initialization files containing PostScript code, fonts, and other resourcessuch as halftones. By changing options in the top-level makefile for theplatform, you can cause some of these files to be compiled into theexecutable: this simplifies installation, improves security, may reducememory requirements, and may be essential if you are planning on puttingGhostscript into ROM.To compile the initialization files (lib/gs_init.ps, etc.)into the executable, change the 0 to a 1 inthe lineCOMPILE_INITS=0Compiled initialization includes the default font map.It is used only if Ghostscript cannot find or open the default fontmap file at run time. To compile fonts into the executable, see Precompiling fonts. To compile threshold-array halftones into the executable, see the "Compiledhalftone" section of int.mak for a sample makefile fragment,genht.c for the syntax of halftone data files, andlib/ht_ccsto.ps for a sample data file. Note that eventhough the data files use PostScript syntax, compiled halftones do notrequire the PostScript interpreter and may be used with the graphics libraryalone.GNU readlineAFPL Ghostscript does not include an interface to GNU readline. A usercontributed code for this purpose, which we spent significant time debuggingand then updating to track internal architectural changes in Ghostscript.The contributor was willing to assign the copyright to Aladdin Enterprises(the copyright holder of Ghostscript at the time), and to allow the code tobe distributed with the Aladdin Free Public License (AFPL) as well as theGNU License (GPL). However, even though the GPL allows linking GPLed code(such as the GNU readline library package) with non-GPLed code (such as allthe rest of AFPL Ghostscript) if one doesn't distribute the result, the FreeSoftware Foundation, creators of the GPL, have told us that in theiropinion, the GPL forbids distributing non-GPLed code that is merelyintended to be linked with GPLed code. We understand that FSFtakes this position in order to prevent the construction of software that ispartly GPLed and partly not GPLed, even though the text of the GPL does notactually forbid this (it only forbids distribution of suchsoftware). We think that FSF's position is legally questionable and not inthe best interest of users, but we do not have the resources to challengeit, especially since FSF's attorney apparently supports it. Therefore, eventhough we added the user-contributed interface to GNU readline in internalAladdin Ghostscript version 5.71 and had it working in version 5.93 (one ofthe last beta versions before the 6.0 release), we removed it from theAladdin Ghostscript 6.0 distribution.GPL Ghostscript distributions will include support for GNU readline. Aswith other GPL Ghostscript components that are not included in AFPLGhostscript, the maintainers of Ghostscript will not attempt to run, link,or even compile this code, or keep it current across changes in the rest ofGhostscript. We will, however, welcome bug fixes or updates, and distributethem with subsequent releases of GPL Ghostscript.The first Ghostscript distribution to include GPL readlinesupport was GNU Ghostscript 6.0. Support has unfortunatelybeen spotty since then.We put considerable work into making it possible for Ghostscript to use GNUreadline, including the creation and adjustment of internal softwareinterfaces specifically to serve this purpose. In principle, we should haveundone this work in AFPL Ghostscript, lest FSF object to it too asintended to facilitate linking AFPL Ghostscript with GNU readline (as theU.S. government has been said to do for code that merely provides APIs whereencryption may be added). However, we are willing to take this risk ratherthan spend the time to undo the interface changes.If you have comments or questions about this situation, please feel free tocontact the Free Software Foundation, authors of the GPL and copyrightholders of GNU readline, at gnu@gnu.org,and/or artofcode LLC, copyright holder of Ghostscript, at raph@artofcode.com.Setting up "makefile"After going through the steps just described to unpackthesources, configure the build and make any desiredchanges to themakefiles, and unpack or create links to the third party libraries, as the final step inpreparing to build Ghostscript you must usually associate the name"makefile" with the correct makefile for your environment sothe make command can find it. See the section on yourparticular platform for how to do that if necessary.Invoking "make"makeBuilds Ghostscript without debugging options.make debugBuilds Ghostscript with debugging options and additional internal errorchecks. The program will be somewhat larger and slower, but it will behaveno differently unless you actually turn on debugging options at executiontime with the -DDEBUG or-Z command line switchesdescribed in the usage documentation.make pgOn Unix platforms, builds with the -pg compilerswitch, creating an executable for time profiling.make beginOn PC platforms, attempts a quick and dirty compilation of all the.c files in the current directory. See themore detailed explanation.make installAfter building, installs the Ghostscript executables, support files,and documentation, but does not install fonts. See theinstallation documentation.make cleanDeletes all the files created by the build process (relocatables,executables, and miscellaneous temporary files). If you've built anexecutable and want to save it, move it first to another place, because"make clean" deletes it.Note: on most platforms some of these simple instructions don'tquite work in one way or another. Read the section on your specificplatform.Cross-compilingIf you are compiling Ghostscript on machines X1 ... Xn withcross-compilers that generate code for machine Y, you must firstperform several extra steps on some machine Z (not necessarily of thesame type as either Xi or Y). First of all, choose a makefileappropriate for Z and edit it to reflect the run-time options youwish to include (FEATURE_DEVS, DEVICE_DEVS*,and any other relevant options), just as for non-cross-compilation.If Z runs Unix, perform the following steps:On Z,make cleanmake obj/arch.h obj/genconf obj/echogsEdit obj/arch.h to reflect the architecture of Y.On Z,make CC=: CCLD=:Copy the files obj/*.h from Z to the directory oneach Xi that will be used for compilation.Extract from the file obj/ldt.tr (on Z) the listof .o files that will be linked: this gives the list ofsource files that must be compiled.Do the compilations on Xi.If Z runs some version of Microsoft Windows with Microsoft VisualC++, use the following steps. NOTE: We have not actually testedthis.On Z,nmake cleannmake obj\arch.h obj\genconf.exe obj\echogs.exeEdit obj\arch.h to reflect the architecture of Y.On Z,nmake CC=rem LINK=remCopy the files obj\*.h from Z to the directory oneach Xi that will be used for compilation.Extract from the file obj\ldt.tr (on Z) the listof .obj files that will be linked: this gives the list ofsource files that must be compiled.Do the compilations on Xi.How to build Ghostscript from source (PC version)All Ghostscript builds in PC (DOS and MS Windows) environments are 32- or64-bit: 16-bit builds are not supported. The relevant makefiles arePC makefilesMakefile Construction tools For environmentbcwin32.mak Borland/Inprise C++ 4.x 32-bit MS Windows 3.1 + Win32s, 95, 98, NTmsvc32.mak Microsoft Visual C++ 4 to 8 MS Windows 32-bitwatcw32.mak Watcom C/386 or C++ MS Windows 32-bitunix-gcc.mak Cygnus gcc Cygnus gnu-win32To build Ghostscript you need MS-DOS version 3.3 or later andBorland/Inprise C/C++ (4.0 or later); Microsoft Visual C++ (version 4.0 orlater); Watcom C/386 (version 8.5 or later) or C++ (any version); or thefree djgpp + go32 development system. The options in the makefiles arechosen to strike a balance between RAM consumption and likely usefulness.If you run make in directory dir, the defaultconfiguration generates an executable that assumes the Ghostscriptinitialization and font files are in directorydir\lib.Note that the make program supplied with each PC compilerhas a different name. We refer to this program generically asmake everywhere else in this document, but you will find thecorrect name for each compiler in the relevant section below that discussesthat compiler.You must have COMMAND.COM in your path to build Ghostscript.After making the changes needed to choose features and devices to build intothe executable, you must create the directory where the compiler will do itswork (normally the obj subdirectory of the currentdirectory) and the directory where the compiled code will be placed(normally the bin subdirectory). Then to build theGhostscript executable all you need do is give the makecommand.A special make target "begin" attempts to compile all the.c files in the current directory. Some of thesecompilations will fail, but the ones that succeed will go considerablyfaster because they don't individually pay the overhead of starting up thecompiler. So a good strategy for building the executable for the firsttime, or after changing a widely used .h file, is to do thefast compilation of everything possible, then the controlled compilation ofeverything that failed in the first step:make beginmakeNote: if you unpack the Ghostscript sources on a DOS or MS Windowssystem from a Unix tar file, the unpacked files have linefeed alone as theline terminator (the Unix convention) instead of carriage return + linefeed(the Microsoft convention), which may make the C compiler unhappy. Onesimple way to fix this, if you have the InfoZIP zip andunzip programs, iszip -l CVTEMP.zip *.bat *.c *.h *.def *.rc (Letter "l", not the digit "1")unzip -o CVTEMP.zip (Rewrite all the same files correctly)del CVTEMP.zip (Delete the temporary zip file)Borland/Inprise environmentTo compile Ghostscript with the Borland/Inprise environment (hereafterreferred to as just "Borland"), you need Borland C++ (version 4.0 or later);specifically the compiler, make utility, and linker. Youalso need either the Borland assembler (version 1.0 or later) or theMicrosoft assembler (version 4.0 or later).To create "makefile", give the commandecho !include "src\bcwin32.mak" >makefileTo run the make program, give the commmandmakeBesides the source files and the makefiles, you need:*.bat (a variety of batch files used in the build process)Comments in the makefiles describe the configuration parameters. If yourconfiguration is different from the following, you should definitely readthose comments and see if you want or need to change any of this:The compiler files are in C:\BC and its subdirectories.You are using the Borland assembler tasm.You want an executable that will run on any 32-bit PC-compatible,regardless of processor type (80386, 80486, Pentium, or compatible) andregardless of whether a math coprocessor (80x87) is present -- an issue onlywith 80386 processors.NotesA user reports that the Borland C++ 4.00 with patch 1-6 doesn'tproduce a working executable of Ghostscript 5.03. We can't test this,since we no longer have this compiler.Borland C++ 4.5 has a bug or bugs that cause(s) the 32-bit Windowsexecutable to crash if you give any @-files on the command line. Amongother things, this makes the uniprint driver unusable, because it referencesthe .upp configuration files this way. This problem may possibly be fixedby one or more of the patch files on _5/Borland C++ 4.52 has a bug that causes the 32-bit Windows executable tofail during startup. Borland provides a patch for this bug in _5/bc45xp1.zipBorland C++ 5.0 and 5.01 have a code generator bug that generatesincorrect code for the construct !file_is_valid(). Do notattempt to compile Ghostscript with these compilers. If you want to reportthis bug to Borland, send them the result of compilingziodev.c and tell them to look at the code generated forfile_is_valid() and !file_is_valid(). Wedon't know whether Borland C++ 5.02 still has this problem. The problem does not appear to exist in Borland C++Builder 4 or 5.
When building for the MS Windows Win32s environment, the makeprocess will stop after it has created genarch.exe.You should then run "_genarch.bat", wait untilgenarch has finished and then exit MS Windows. Then type"make" again to restart the make process.Borland C++Builder 5 and above require BUILDER_VERSIONto be set explicitly to 5 in the make file because the version of MAKE which shipswith this product (Version 5.2) is the same as that shipped with Version 4.5. Therefore,there is no way to automatically establish the compiler version that is in use. Note thatbecause a 16 bit compile does not ship with Version 5.5, conditionals have been added toprevent attempts to compile 16 bit code when BUILDER_VERSION = 5
Note that under Borland C++Builder 5, MAKEdoes not stop when _genarch.bat should be run as describedabove. It is necessary for the user to Abort the make by pressing Control-C. You shouldthen run "_genarch.bat", wait until genarch hasfinished and then exit MS Windows. Then type "make" again torestart the make process. All targets are built succesfully if this step is ignored. Idon't know if the targets are correct although they seem to run OK.
To prevent the compiler terminating because toomany warning messages have been generated, copy the file file bcc32.cfg tothe top level directory using the following command:
Microsoft Environment NOTE: We have received reports that the Microsoft Visual C++ 5.0 and 6.0 compilers produce incorrect code for Ghostscript version 6.0 and later, from the same source code that compiles and runs correctly with other compilers. In spite of these reports, several members of the Artifex staff use version 6.0 of the MSVC compiler on a regular basis and we have not found any problems. You may also want to try out the Intel C/C++ compiler, which can be integrated into the Microsoft Visual C++ environment.To compile Ghostscript using the Microsoft environment, you need Microsoft Visual C++ 4.0 or later with its associated "nmake" utility and linker. Using Microsoft Developer StudioMicrosoft Developer Studio is the Microsoft Visual C++ integrated development environment. To use it to build Ghostscript: it is first necessary to create a new workspace/project. To create the workspace/project, open Microsoft Developer Studio and select File/New. In the dialog window that is opened, select 'Makefile' as the type of project. Specify a name for the project. (Microsoft does not allow special characters such as ., *, ?, /, or \ as part of project names.) Also specify the location of the master directory for your Ghostscript files. Then select OK. In the next dialog window, specify the build command line as nmake /f src/msvc32.mak DEVSTUDIO= Note the value for DEVSTUDIO is empty. Then select Finish. At this point, it is now possible to build Ghostscript using Developer Studio. To build, press F7 or select the build icon. Note: multiple warnings will also given about things like double to float data conversions. Ignore them. We have not found a way to create a single set of sources that does not create warnings with the different compilers and operating systems supported by Ghostscript. We are working to reduce the number of the warning messages. To run Ghostscript inside of Developer Studio, it is necessary to specify the name of the executable program . Select Project/Settings. Select the Debug tab. Then for Executable for debug session: specify bin/gswin32.exe To use all of the features of Microsoft Developer Studio for debugging, and modifying Ghostscriptt, you need to finish the remaining steps. To add the Ghostscript DLL to the project, select Project/Settings. Select the Debug tab. Change the Category to Additional DLLs. Then specify bin/gsdll32.dll. To specify the Ghostscript program arguments, select Project/Settings. Select the Debug tab. Change the Category to General. Then specify the desired program arguments. For example, specifying: examples/tiger.eps will result in the tiger example file being displayed when Ghostscript is executed. . A final note: it is possible to create a command file (build.bat) to be used for the build command line. If many different workspaces/projects are created, it is simpler to use a build batch command file rather than retyping the build command line for each new project. Here is an example used by one of Artifex's staff members. This file is one line: nmake -f src/msvc32.mak DEVSTUDIO= DEBUG=1 TDEBUG=1 GS_LIB_DEFAULT="./lib/;./font;$(GSROOTDIR)/lib;$(AROOTDIR)/fonts" Please note the double quotes around the value for GS_LIB_DEFAULT and the addition of ./lib;./fonts; to its definition. This uses the local (within the project) copy of the lib and fonts directories. This is convenient if any changes need to be made in these directories. Setting DEBUG=1 includes debugging features in the build: It defines the C preprocessor symbol DEBUG. The latter includes tracing and self-validation code fragments into compilation. Particularly it enables the -Z and -T switches in Ghostscript. It compiles code fragments for the C stack overflow checks. Code produced with this option is somewhat larger and runs somewhat slower.Setting TDEBUG=1 disables code optimization in the C compiler andincludes symbol table information for the debugger.Code becomes substantially slower and larger. An optional setting DEBUGSYM=1 is only useful with TDEBUG=0for advanced developers. It includes symbol table information for the debuggerin an optimized (release) build.NOTE: The debug information generated for the optimized code may besignificantly misleading. For general MSVC users we recommend TDEBUG=1.Using the command lineGhostscript can be made using either the DOS shell or one one of the various command line shells made for Windows.In order for the makefiles to work properly, two items may have to be changed. An attempt is made to select the correct version of Microsoft Visual C++ based on the version of nmake. If this doesn't work it will default to version 6.x. If you are not using version 6.x then before building, in src\msvc32.mak find the line "#MSVC_VERSION=6" and change it to "MSVC_VERSION=4", "MSVC_VERSION=5", "MSVC_VERSION=7" or "MSVC_VERSION=8". . In some cases the location of the Microsoft Developer Studio, needs to be changed. The location of Microsoft Developer Studio is defined by the value of DEVSTUDIO. There are several different definitions of DEVSTUDIO in src\msvc32.mak. There is one for each of the currently supported versions of Microsoft Visual C++ (4, 5, 6, 7, 7.1 and 8). The normal installation process for Microsoft Visual C++ includes setting the location of the Microsoft Visual C++ executables (cl.exe, link.exe, nmake.exe, rc.exe) in your PATH definition and the LIB and INCLUDE environment variables are set to point to the Microsoft Visual C++ directories. If this is true then the value for DEVSTUDIO can be changed to empty. I.e. DEVSTUDIO= If PATH, LIB, and INCLUDE are not correctly set then the value for DEVSTUDIO needs to be defined. For example, for version 6.0, the default definition for the location for the Microsoft Developer Studio is: DEVSTUDIO=C:\Program Files\Microsoft Visual Studio If the path to Microsoft Developer Studio on your system differs from the default then change the appropriate definition of DEVSTUDIO. (Remember that there is a separate definition of DEVSTUDIO for each version of MSVC, so be sure to change the correct definition.) To run the make program, give the command nmake -f src\msvc32.makRather than changing src/msvc32.mak, these values can be specified on the makecommand line, I.e. nmake -f src\msvc32.mak MSVC_VERSION=6 DEVSTUDIO="C:\Program Files\Microsoft Visual Studio" nmake -f src\msvc32.mak MSVC_VERSION=7 DEVSTUDIO="C:\Program Files\Microsoft Visual Studio .NET" Note that double quotes have been added around the path for DEVSTUDIO due to the spaces in the path value.This command line can also be put into a batch file. You may get warning messages during compilation about /QI0f being an undefined switch, or the message "dwmain32.def: EXETYPE not supported for platform; ignored" during linking. Multiple warnings will also given about things like double to float data conversions. Ignore them. We have not found a way to create a single set of sources that does not create warnings with the different compilers and operating systems supported by Ghostscript. The Microsoft VC++ 5.0 compiler locks up when compilinggxi12bit.c with /O2. Compile this filewithout /O2. The Microsoft VC++ 5.0 compiler produces a non-working executable if compiling without stack checking. Don't change the setting TDEBUG=1 in msvc32.mak. Building with the Luratech compression librariesIf you wish to compile Ghostscript with the Luratech JBIG2 and JPEG 2000 implementations, the source should be installed as described above under unpacking third-party libraries. If you have an appropriately licensed source distribution this should alreadyhave been done.To enable the Luratech code, you need to pass JBIG2_LIB=ldf_jb2 and JPX_LIB=lwf_jp2 on the nmake command line, or add these defines to your Visual Studio project.Building Ghostscript for 64-bit Windows (AMD64 processor) requiresMicrosoft Visual Studio .NET 2005 on 64-bit Windows,or Microsoft Visual Studio .NET 2003 and Windows Server 2003 DDKon 32-bit Windows (cross-compile).Compiling for 64-bit is similar to the Microsoft Environment instructions above,but with the addition of a WIN64 define.Cross compile on 32-bit Windows XPMicrosoft Visual Studio .NET 2003 is used for 32-bit compilationof auxiliary programs used by the compile process, while Windows Server 2003 Device Driver Kit (DDK)is used for 64-bit compilation.The DDK cross compilers for the IA64 and AMD64 processors,however only AMD64 is supported by the makefile.The DDK is not installed correctly by the setup program.You need to copy msobj10.dll to the compilerdirectory from a nearby directory.To make ghostscript use nmake -f src/msvc32.mak WIN64=This will fail when it tries to run genconf.exe.Move ./obj/genconf.exe to 64-bit Windows, then run it genconf arch.hMove arch.h back to ./obj/arch.h.(Alternatively, use arch.h created by a 32-bit build and change ARCH_ALIGN_PTR_MOD to 8, ARCH_ALIGN_STRUCT_MOD to 16,and ARCH_SIZEOF_PTR to 8).Then restart the build nmake -f src/msvc32.mak WIN64=You can also use Microsoft Visual Studio .NET 2005 to do a similar cross compile, but you will need to change the DEVSTUDIO path.Compile on 64-bit Windows XPTo make ghostscript use nmake -f src/msvc32.mak WIN64=The makefile currently uses the cross compiler (x86_amd64) rather than the native compiler (amd64).You can install Microsoft Visual Studio .NET 2003 on64-bit Windows, but you can't install Windows Server 2003 DDK.You may be able to copy the DDK directory c:\winddkfrom a 32-bit system to a 64-bit system and compile GS.Making self-extracting executablesYou can build self-extracting Windows executables of Ghostscript. (This isnot needed to use Ghostscript.) Currently this requires both theBorland/Inprise and the Microsoft compilers, and also two pieces ofthird-party software:WinZipSE, available from is not free.zip, available from -zip.org/pub/infozip/Zip.html. This is free.You will have to edit src/winint.mak to defineWINZIPSE_XE and ZIP_XE respectively as thepath names of these programs. See Release.htm forthe detailed procedure.Watcom environmentTo use the Watcom compiler, add to AUTOEXEC.BAT the line"set DOS4G=quiet". Check thatAUTOEXEC.BAT also contains a line of the form"set WATCOM=wcdir" where wcdir isthe directory where you installed the Watcom tools, and that the setting ofPATH includes wcdir\binnt (or%WATCOM%\binnt) before wcdir\binw(or %WATCOM%\binw). Then to create"makefile":For Give the commandMS Windows echo !include src\watcw32.mak >makefileBefore compiling, change the definition of the WCVERSIONmacro in the makefile (watcw32.mak) to the version of the Watcom compiler you areusing. This is necessary to handle some minor incompatibilities betweenversions.To run the make program, give the commmandwmake -uCygwin32 gccA user reports that it is possible to compile Ghostscript for MS Windows NTusing the Cygwin32 gcc compiler, GNU make, and theunix-gcc.mak makefile, with only two small source codechanges:Add "b" to the call to fopen in gp_open_scratchMirror the gp_ntfs logic for gp_pathstring_not_bareInformation about this compiler and environment is at the Cygnus site: note that Cygnus's licensing terms aren't quite as liberal aboutredistribution as either the GNUGeneral Public Licenseor the Aladdin Free Public License, so read theirlicense carefully if you want to redistribute the results of using theircompiler.Intel C/C++ environmentIntel provides a C/C++ compiler that is compatible with the Microsoft Visual C++ environment. The mainadvantage of this compiler over MSVC 5.0 and 6.0 is that it producesworking code even when all optimizations are enabled and when stack checkingis disabled.To build Ghostscript using the Intel C/C++ compiler, you have to make thefollowing small changes in the makefiles:Find and change the second occurrence of"COMPILE_FULL_OPTIMIZED" to "/O2" in filemsvccmd.mak. Override "TDEBUG","COMP", and "COMPAUX" when invokingnmake.More specifically, use "TDEBUG=0" and set both"COMP" and "COMPAUX" to the full path oficl (for example"COMP=C:\intel\compiler45\bin\icl" if the Intel C/C++compiler V4.5 was installed to C:\intel). It is suggestedthat you use a batch file to launch nmake, since the commandline processes the "=" on its own. Also, you may need toexecute vcvars32.bat and iccvars.bat toregister the proper paths for the compiler, its include files and itslibraries.You can buy or download a 30-day evaluation version of the Intel C/C++compiler from Intel's Software Performance Tools web site: to build Ghostscript from source (MacOS version)Traditional MacOSThe Macintosh version of Ghostscript requires the Metrowerks Codewarrior development suite. Download the macgs-7xx-src.sit source archive from the location listedbelow. This includes a Codewarrior .mcp project file than can be used to build both Carbon and CFM versions of the ghostscript shared library component. your system doesn't automatically unpack the source archive, you candownload the free Stuffit Expander to open it.This archive includes appropriate versions of the jpeg, zlib and libpng 3rd partylibrary source for convenience. You must still download the fonts and place them in anappropriate location, along with the contents of the lib directory from the sourcearchive.Note that since this is just a library component, you will need a front-end application, such asMacGSView, to actually view or convert postscript and pdf documents.MacOS XThe unix source distribution (.tar.gz) builds fine on Darwin/MacOS X,albeit without a display device. You can generally just use the Makefilegenerated by ./configure or macosx.makas your top-level makefile and get a reasonable default build. This willallow you to use Ghostscript from the command line as a BSD-layer toolto rasterize postscript and pdf to image files, and convert between the high-level formats supported by Ghostscript. See the instructions for theunix build below for details of how to customize this build.There is also a support for building Ghostscript as a framework. This isa special encapsulated shared library format specific to MacOS X. To buildthe framework, copy macosx.mak to the top-level directory, rename it tomakefile and issue 'make framework' from Terminal.app. This will resultin a Ghostscript.framework in the sobin directory. It must be manually copied to /Library/Frameworks/ before applicationscan use it. You may need to create the Frameworks/ directory on some systems.Finally, there is a macos-mcp.mak makefile that can beused to set up the Codewarrior shared library component build describedin the section on Classic MacOS above. Currentlythis makefile is distributed only with the MacOS-specific .sitsource archive, but with be included generally in future releases.To set up the shlib build, download and uncompress the Ghostscript source.If the archive doesn't contain the 3rd party jpeg, png, and zlib source,you must download them as described at the beginning of this document andunpack them under the macgs-###-src directory under the specific namesjpeg, zlib and libpng. You cannot use symlinks asCodewarrior will not be able to follow them for some of the needed headerfiles.Copy src/macos-mcp.mak to the top-level directory and renameit makefile. Then run 'make' in that directory, either fromwithin Terminal.app or through Project Builder. This will set up thegenerated code required for the build and run a shell script to generateghostscript.mcp.xml. Launch Metrowerks Codewarrior, and select'Import Project...' from the File menu, and open the xml project file.When asked, save the results as ghostscript.mcp in the same directory and you should be ready to build the shared library component.
Vga Dll Version 5.01 Free Download
Download Zip: https://tinurli.com/2vG95s
2ff7e9595c
コメント