Latest revision as of 08:17, 16 July 2018

>]]

>]]

Overview

$SRC_ROOT will denote the directory in which the source code of OpenOffice.org is stored.

You are advised to check the release notes for the release you are building to inform yourself about changes since previous releases.

Requirements

hardware requirements

• 1 or more reasonable fast CPUs, x-way CPU's recommended.

• 1 GB Ram ( 2 GB recommended )

• at least 10 GB free disk space

Software requirements

The most recent information for building on specific Linux distributions can be found at: AOO Building on Linux Historical (outdated but perhaps useful) information on distribution specific packages can be found from the Distribution specific build instructions pages. Included distributions are: Fedora Gentoo OpenSUSE SUSE9.3 Ubuntu

• C/C++ Compiler:
  • gcc >= 3.3
  • gcc 4.2.3 is the current reference compiler

• The X11 development libraries and header files^[1]

• PAM including the development headers^[2]

• bash.

• gtk2 and libtiff including the development headers^[3]

Full Builds

To perform a full build, you need to follow these steps:

autoconf

The first time you have to run autoconf to prepare a valid and up-to-date configure script. And every time you make changes to the configure.in script, the script will remind you to run autoconf again.

autoconf

configure

• Run the configure script to check all requirements. Run the following command to view all possible options.

./configure --help

An example configure command:

./configure --without-junit --disable-odk

See the last information box in the configure script or Category:Distribution-Specific_Build_Instructions for more information for your platform.

Please check for any warnings emitted by the configure-script. The page OpenSolaris Build Instructions/Configure Errors may be helpful in debugging all the dependencies.

bootstrap

When configure finished successfully, run:

./bootstrap

to create the dmake executable required to build OpenOffice.org.

setting the environment

When the configure script has been run successfully a file LinuxX86Env.Set.sh or LinuxX86-64Env.Set.sh was created^[4]. Do this:

source LinuxX86Env.Set.sh

or

source LinuxX86-64Env.Set.sh

to set up the environment for the build^[5].

This step has to be redone in each shell you are going to use for building.

starting the build

Build the software by typing the following in $SRC_ROOT^[6]:

cd instsetoo_native && build --all

The building procedure will take at least an hour (on a 3 GHz Quad-Core with 8GB RAM without CCACHE).

Partial Builds

There are two ways to do partial builds:

• compatible
• incompatible

Only do compatible partial builds if you know exactly what you are doing.

For more information, see Compatible Builds.

rebuilding from a module (incompatible build)

If you decide to change a module in an incompatible way, you will need to rebuild all modules depending on it (directly or indirectly):

cd $SRC_ROOT/instsetoo_native
build --from $INCOMPATIPLEMODULE --prepare
build --from $INCOMPATIBLEMODULE

rebuilding a module (compatible build)

To rebuild a module you can delete all output directories with, rebuild and redeliver into the solver with:

cd $MODULE
build --from $MODULE --prepare
build && deliver

A simple build in $SRC_ROOT/instsetoo_native will recreate the installation sets, provided all other modules have already been build.^[7]

This does not check for incompatible modules. If unsure, use an incompatible build (see above).

Building a Module with Debug Information

To rebuild a module with debug information and additional assertions and checks, run:

cd $MODULE
build --from $MODULE --prepare # removes old output trees and solver
build debug=true --from $MODULE

Drop the newly created binaries into an existing installation. Building an installation set with them will not help, as binaries are stripped on packing by default.

For details, see Debugging.

Finding Installation Sets

The english installation set will be located at $SRC_ROOT/instsetoo_native/unxlngi6.pro/OpenOffice/{deb,rpm,archive}/install/en-US/^[8].

For 64-bit Linux it is unxlngx6.pro instead of unxlngi6.pro.

See also Run parallel versions.

Tips And Tricks

ccache

export CCACHE_DIR="some/place/with/space"
ccache -M 2G -F 100000
export CXX="ccache g++"
export CC="ccache gcc"

dependencies

nodep

If you set the environment variable nodep to TRUE, then dependency information files are not created - the build finishes faster.

But only enable that on a clean build. Once you have built OOo and then made modifications, unset the variable again to be on the safe side.

NO_HIDS

Similar to the nodep variable, this one prevents the generation of HIDs (Help IDs) that are mainly used for automated testing - if you only want to build OOo, you don't need those.

parallel builds

If you have a multiprocessor machine or similar, you can run a parallel build. There are two levels of parallelism - one operating on makefile (directory) level, the other one on the global level. The two levels of parallelism result from the two-step build procedure in the OOo build environment. The build script runs through all the directories it reads from the build.lst files in all modules and calls dmake for every directory.

parallelism on the global level

For parallelism on the global level, you have to run build from $SRC_ROOT>/instsetoo_native with the -P<number> switch, for example:

build -P2

This takes build how many dmake processes it is allowd to start in parallel.

parallelism on the directory level

export MAXPROCESS=<numer or processes> 

This tells dmake how many targets it is allowed to build in parallel. When you don't use build.pl but build a single directory (single makefile), you can achieve the same with

dmake -P2

combining both levels

If you want to have parallelism on both levels, you can call

build -P2 -- -P2

"--" is a special build.pl parameter that passes every further parameters to the dmake processes it starts.

Recommendation

Experience tells that using the doubled number of cores in your machine is a good choice, using more threads does not make a big difference, except if the combined option is chosen. So even on single core machines using two threads will speed up the build considerably.

create prebuilt mozilla

For the mozilla-components you have the choice to either build from mozilla sources, to use precompiled packages or to use system-mozilla (the one installed on your buildsystem, not everything might work, depending on the version you got installed). You can easily create your own version of the prepacked binaries if you wish to do so (either because you cannot use the official ones because of mismatch of compiler version used to build them/other technical reasons or because you want to use stuff you didn't build yourself). To do so:

• build the moz module from the mozilla sources
• use --enable-build-mozilla when running configure and put the mozilla-source tarball to moz/download
• in moz run dmake zip to create the zip files
• you'll find the zips in {platform}.pro/zipped

Copy them to a location of your liking. Now instead of using --enable-build-mozilla, use --disable-build-mozilla and copy the zips you created or downloaded to moz/zipped and these will be used when compiling. This will greatly reduce build-time (you save the time that would otherwise be spent on compiling mozilla).

See Also

• Category:Distribution-Specific Build Instructions
• Prepared Build Images

1. ↑

   Should be in place with most Linux distributions. Note the there are currently some issues with X version 4.3.

2. ↑

   PAM should be installed by default on most linux distributions. You should only need to add the development package.

3. ↑

   The gtk2, jpeg and tiff libraries are not required if you disable the crash-reporter when running ./configure.

4. ↑

   When you want to use tcsh instead of bash, you will need to use the file LinuxX86Env.Set instead: source LinuxX86Env.Set rehash If you do not use tcsh, it is better to delete that file, as it will get in the way for tab-completion sooner or later.

5. ↑ By default, native packages (.deb/.rpm) will be build.
   

   If you want to have something faster and easier to test: export FORCE2ARCHIVE=true This will create a tarball that can easily be unpacked and run anywhere. An alternative is to set export PKGFORMAT=installed which will create a runnable installation in the output directory of instsetoo_native (Dont set LOCALINSTALLDIR on older milestones, see Issue 111450 .

6. ↑

   You can also run: make but GNU make will just start build.pl. For details run: build --help

7. ↑

   build --all would rebuild changed/missing files. However, it does not check for incompatible modules. If unsure, use build --from --prepare.

8. ↑ The en-US in the path names indicates that the localization is American English. This value corresponds to the language tags defined by RFC 1766 (Tags for the Identification of Languages). The German installation set will be located in a de subdirectory. This scheme holds true for all localizations you may have chosen explicitly.

   Running the configure script with the --with-lang option will introduce the build of additional language resources. This switch accepts one or more RFC 1766 language tags as arguments. Check the value of the completelangiso macro in $SRC_ROOT/solenv/inc/postset.mk for all the currently supported language tags. Example: ./configure --with-lang="de fr" This enables the build of the localized German and French version. The environment variable WITH_LANG will then contain the language tags of the additional (en-US will always be built) languages.

   
   

   If you build additional localized languages it is possible to generate Language Packs that contain only the changes needed to add the additional language to an OpenOffice.org of a different language. The following commands will generate language packs languages that were specified with the --with-lang switch during the configure phase. cd $SRC_ROOT/instsetoo_native/util dmake ooolanguagepack

   Note that you can only build the language packs after you have build the complete office with all selected languages.