Installing the Free Pascal Compiler: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		While the Free Pascal Compiler comes pre-built for several processor architectures and operating systems, there may be occasions where a pre-built compiler won't do, and you need to build it yourself. There are a number of reasons for doing this, including:
2	2
3	3		- Intellectual curiosity - you want to discover the compiler's speed, using a medium sized application like the compiler itself.
4	4		- Cross Compiling - you want to build a compiler that creates binaries for a different CPU architecture, operating environment, or both, than the one you are using right now.
5	5		- New environment - you want to build the compiler for a processor or operating system that either a version of the compiler does not currently exist, or you are porting it to a new operating system or processor.
6	6		- Do it yourself - you prefer to build applications from source where possible.
7	7		- Security - for organizational policy, legal requirements, or operational security, programs from untrusted sources cannot be used, and must be recompiled locally. Or you want to confirm the compiler you have is the same as the one it produces, possibly running a checksum on the new one to confirm it matches the published one.
8	8
9	9		And the most obvious reason of all:
10	10
11	11		- New Version - you are creating a new release of the compiler.
12	12
13	13		This document will try to help you do these things.
14	14
15	15		## Overview
16	16
17	17		There are a number of ways to install the Free Pascal Compiler and its libraries on your system. The current version and trunk, and sometimes beta and release candidates, are available directly from the [FPC website](https://sourceforge.net/projects/freepascal/files/) (tar, exe, rpm, dmg, pkg files). In addition, versions of FPC are provided (including rpm and deb files) from the [Lazarus download site](http://sourceforge.net/projects/lazarus/files/). Linux users can almost certainly find FPC in their distribution's repositories but may find that it is outdated.
18	18
19	19		It is possible to build FPC from source, typically each release needs to be built with the previous release. It is possible to install FPC in the application space (often requiring root or administrator access) or in a your own user space. These things depend on your particular operating system.
20	20
21	21		There is an extensive discussion of how to install and build Free Pascal compilers available here <http://www.stack.nl/~marcov/buildfaq.pdf> - it may be a little too detailed for some users, but it is very comprehensive.
22	22
23	23		## Linux
24	24
25	25		### Downloading FPC binary packages
26	26
27	27		> Note: You have a number of way to install FPC presented here, which one is best for you depends very much on what you are planning to do and if you need a very current version. If you are also planning on installing Lazarus, perhaps a quick look at [[Installing Lazarus]] and [[Installing Lazarus on Linux]] is a very good idea.
28	28
29	29		With the recent release of FPC 3.2.2, only a few distributions will have the new FPC compiler in its repositories. You can do one of -
30	30
31	31		- If you use rpm packages, you can find FPC322 in <https://sourceforge.net/projects/freepascal/files/Linux/3.2.2/> or more generally in <https://www.freepascal.org/download.html> You might install using a command like -
32	32
33	33		// or perhaps rpm -Uvh fpc-3.2.2-1.x86_64.rpm
34	34
35	35		- If you use deb packages try the ones made available by, but not bundled with Lazarus at <https://sourceforge.net/projects/lazarus/files/>. Install using gdebi or, perhaps this command (note the ./ in front of filename, if you don't use an explicit path to filename, apt will search its own official repo, not what you want)-
36	36		``` bash
37	37		apt install ./fpc-laz_3.2.2-1_amd64.deb
38	38		```
39	39
40	40		Note the actual name changes from time to time, use the name you downloaded !
41	41
42	42		If you already have a FPC installed from your distro package manager, you should use that same package manager to remove them before installing under another model. Some quite strange things can happen if your compile uses a mixture of FPC versions !
43	43
44	44		### Downloading FPC tar balls
45	45
46	46		Another option is installing from a tar, an easy and possibly even more useful model. These tars are available for a wide range of Unix like systems. You need to download the appropriate binary tar for your OS and CPU and you may also need the source files, common for all OS/CPU. You install FPC this way in your own space, not as root.
47	47
48	48		Here is a series of commands, not a script, that will install FPC on a 64 bit Linux system. It could be scripted but would would need sanity and error checking. Note that I like to install things like this in my \$HOME/bin directory, if you prefer having it in \$HOME, it is even easier, I am sure you can see the differences.
49	49
50	50		> Note: A tar install does not resolve dependencies, if they are not already present, first install binutils, make, gcc.
51	51
52	52		> Note: A tar ball install will, if you manage paths properly, allow you to have several versions of FPC installed.
53	53
54	54		(if you want something a bit newer, please see <https://www.freepascal.org/develop.html> )
55	55
56	56		``` bash
57	57		cd
58	58		mkdir -p bin/FPC/Tars
59	59		mkdir bin/FPC/SRC
60	60		mkdir bin/FPC/fpc-3.2.2
61	61		cd bin/FPC/Tars
62	62		# download src and compiler tars, change for different CPU (or Mac ?)
63	63
64	64		wget https://sourceforge.net/projects/freepascal/files/Source/3.2.2/fpc-3.2.2.source.tar.gz
65	65		wget https://sourceforge.net/projects/freepascal/files/Linux/3.2.2/fpc-3.2.2.x86_64-linux.tar
66	66
67	67		tar xf fpc-3.2.2.x86_64-linux.tar
68	68		cd fpc-3.2.2.x86_64-linux
69	69		./install.sh
70	70		# when asked where to install, enter $HOME/bin/FPC/fpc-3.2.2, accept all defaults after that.
71	71
72	72		cd ../../SRC
73	73		tar xzf ../Tars/fpc-3.2.2.source.tar.gz
74	74
75	75		# Set a path to where the compiler is, add line at end of .bashrc, if you don't use bash, adjust !
76	76		# (! e.g. Use ~/.profile instead of ~/.bashrc so that the path is available also in Lazarus IDE.)
77	77		echo "PATH=\"\$HOME/bin/FPC/fpc-3.2.2/bin\":\"\$PATH\"" >> ~/.bashrc
78	78		source ~/.bashrc
79	79
80	80		# trivial test
81	81		cd
82	82		fpc -iV
83	83		```
84	84
85	85		> Note: The second wget above assumes you are working with an amd64 (AMD or Intel) type machine, other platforms require a different tar ball. For example, for a Raspberry Pi, you would use -
86	86		>
87	87		> ``` bash
88	88		> wget https://sourceforge.net/projects/freepascal/files/Linux/3.2.2/fpc-3.2.2.arm-linux.tar
89	89		> ```
90	90		>
91	91		> which has the armhf 32bit compiler. Incidentally, the Raspberry Pi may need you to increase swap space to at least a Gig if you plan to later build any large applications with FPC.
92	92
93	93		### Downloading FPC sources from Git or zip
94	94
95	95		If you plan to build your own compiler from source, this is the approach for you.
96	96
97	97		The FPC source files are stored in a git repository (https://gitlab.com/freepascal.org/fpc/source). The repository keeps track of all the changes by developers in the source tree and has multiple branches. Once you have the sources, please see Installing from source under BSD/Linux for instructions on how to install them.
98	98
99	99		Anyone can download (but not upload) the source using either git or, easier if you want a one off snapshot, zip. And possibly even SVN. The default is to get the main (aka trunk) version of the source but you also select any one of the very many branches or tags.
100	100
101	101		Git - is most appropriate if you are going to add or sorrect something in the source and submit your change to the developers. Its a bigger and slower download but once done, easy to keep up to date. Note that its very unlikely contributions to anything other than main will be accepted. Here is an example initial download of main, assuming you already have git installed -
102	102
103		-	~~`git clone `[`https://gitlab.com/freepascal.org/fpc/source`](https://gitlab.com/freepascal.org/fpc/source)~~
	103	+	```text
	104	+	git clone https://gitlab.com/freepascal.org/fpc/source
	105	+	```
104	106
105	107		Once the git download is finished, cd into the new directory and build as documented below. You can now keep your git repository up to date using the normal git commands. Git is well documented online but (https://wiki.freepascal.org/FPC_git) has some fpc specific help.
106	108
107	109		Zip - a possibly easier option is to download a "zip ball' archive of the source, from the web interface you can select which branch or tag you are interested in (combo box that defaults to 'main'). There are quite a lot of branches and tags to choose from, so please choose carefully. The web interface will let you download the zip of the selected branch or tag directly or command line people may do one of (with the last part of command line indicating which branch):
108	110
109		-	~~`wget `[`https://gitlab.com/freepascal.org/fpc/source/-/archive/fixes_3_2/source-fixes_3_2.zip`](https://gitlab.com/freepascal.org/fpc/source/-/archive/fixes_3_2/source-fixes_3_2.zip)\~~
110		-	~~`wget `[`https://gitlab.com/freepascal.org/fpc/source/-/archive/release_3_2_2/source-release_3_2_2.zip`](https://gitlab.com/freepascal.org/fpc/source/-/archive/release_3_2_2/source-release_3_2_2.zip)~~
	111	+	```text
	112	+	wget https://gitlab.com/freepascal.org/fpc/source/-/archive/fixes_3_2/source-fixes_3_2.zip
	113	+	wget https://gitlab.com/freepascal.org/fpc/source/-/archive/release_3_2_2/source-release_3_2_2.zip
	114	+	```
111	115
112	116		You would unzip the zipball and build the source as described below.
113	117
114	118		#### Documentation sources
115	119
116	120		The documentation sources are in a separate repository called fpcdocs, so the command to get them is:
117	121
118	122		``` bash
119	123		cd ~
120	124		git clone https://gitlab.com/freepascal.org/fpc/documentation.git fpcdocs
121	125		```
122	126
123	127		If you want to learn more about subversion, read this excellent [Subversion book](http://svnbook.red-bean.com/) which is also available online in different formats for free.
124	128
125	129		For more information, see the [Free Pascal website](https://www.freepascal.org/develop.html).
126	130
127	131		### Compiling the FPC source, using preinstalled FPC
128	132
129	133		- First install the release FPC from RPM/DEB or tarballs as described above.
130	134		- Get FPC sources (trunk) as described above.
131	135		- Make FPC sources with (execute in the source (trunk) directory):
132	136
133	137		``` bash
134	138		make clean
135	139		make all
136	140		make install INSTALL_PREFIX=install/to/directory
137	141		```
138	142
139	143		Decide about install/to/directory and also add options that you need.
140	144
141	145		- Check your ~/.fpc.cfg or /etc/fpc.cfg. It either has to be valid for the trunk compiler as well or you have to move it to the ../etc directory above your compiler executable. E.g. if your compiler is in ~/software/fpc/3.2.0/lib/fpc/3.2.0 (~/software/fpc/3.2.0/bin), you have to move the fpc.cfg to ~/software/fpc/3.2.0/lib/fpc/etc.
142	146		- If you have no valid global fpc.cfg file, you have to create one in install/to/directory/lib/fpc/etc. For this run the following commands
143	147
144	148		``` bash
145	149		cd install/to/directory/lib/fpc
146	150		mkdir etc
147	151		fpcmkcfg -d basepath="install/to/directory/lib/fpc/\$fpcversion" -o etc/fpc.cfg
148	152		```
149	153
150	154		### Compiling the FPC source, using just downloaded FPC 3.2.2
151	155
152	156		- Download FPC 3.2.2 (latest official release), ie tarball fpc-3.2.2.x86_64-linux.tar.
153	157		- Unpack this tarball to e.g. "~/Downloads/fpc", do CD to the folder containing the file "install.sh", run from Terminal:
154	158
155		-	~~`$ ./install.sh`~~
	159	+	```text
	160	+	$ ./install.sh
	161	+	```
156	162
157	163		It will ask several questions in the Terminal, answer them. You will have installed FPC 3.2.2 to the folder e.g. "/home/user/fpc-3.2.2".
158	164
159	165		- Download the Git snapshot of FPC:
160	166
161		-	~~`$ git clone `[`https://gitlab.com/freepascal.org/fpc/source`](https://gitlab.com/freepascal.org/fpc/source)~~
	167	+	```text
	168	+	$ git clone https://gitlab.com/freepascal.org/fpc/source
	169	+	```
162	170
163	171		- Do CD to new folder "source" and call:
164	172
165		-	~~`$ make clean PP=/home/user/fpc-3.2.2/bin/fpc`\~~
166		-	~~`$ make all PP=/home/user/fpc-3.2.2/bin/fpc`~~
	173	+	```text
	174	+	$ make clean PP=/home/user/fpc-3.2.2/bin/fpc
	175	+	$ make all PP=/home/user/fpc-3.2.2/bin/fpc
	176	+	```
167	177
168	178		Here you must specify the "PP=" key and the full path to the "fpc" file installed from tarball. Command "make clean" is required if you compile again.
169	179
170	180		Final compiled binary will be the file "source/compiler/ppcx64".
171	181
172	182		## FreeBSD
173	183
174	184		> Note: If you wish to also install Lazarus, you can omit installing FPC with the steps below as the Lazarus port will install it for you. See [[Installing Lazarus on FreeBSD]].
175	185
176	186		### Installing from the ports collection
177	187
178	188		The FreeBSD ports collection has FPC v3.2.2 version in `/usr/ports/lang/fpc` and FPC Development v3.3.1 version in `/usr/ports/lang/fpc-devel`. Nowadays all units were merged into only one package of FPC/FPC-devel. The FPC/FPC-devel source is now installed by default; it previously needed to be copied and uncompressed from `/usr/ports/distfiles/freepascal`.
179	189
180	190		This must be done as root.
181	191
182	192		``` bash
183	193		# cd /usr/ports/lang/fpc && make install && make clean
184	194		```
185	195
186	196		If you want use development (aka trunk) version of fpc with all units included do the following:
187	197
188	198		``` bash
189	199		# cd /usr/ports/lang/fpc-devel && make install clean
190	200		```
191	201
192	202		Also, you can install FPC and units from pkg binaries:
193	203
194	204		``` bash
195	205		# pkg install lang/fpc
196	206		```
197	207
198	208		Installing development FPC and units from pkg binaries:
199	209
200	210		``` bash
201	211		# pkg install lang/fpc-devel
202	212		```
203	213
204	214		Once FPC is installed you can check if it's working by simply running as a normal user:
205	215
206	216		``` bash
207	217		$ fpc test
208	218		```
209	219
210	220		which should produce output similar to this:
211	221
212		-	~~` Free Pascal Compiler version 3.2.2 [2021/08/03] for x86_64`\~~
213		-	~~` Copyright (c) 1993-2021 by Florian Klaempfl and others`\~~
214		-	~~` Target OS: FreeBSD for x86-64`\~~
215		-	~~` Compiling test`\~~
216		-	~~` Fatal: Cannot open file "test"`\~~
217		-	~~` Fatal: Compilation aborted`\~~
218		-	~~` Error: /usr/local/bin/ppcx64 returned an error exitcode`~~
	222	+	```text
	223	+	Free Pascal Compiler version 3.2.2 [2021/08/03] for x86_64
	224	+	Copyright (c) 1993-2021 by Florian Klaempfl and others
	225	+	Target OS: FreeBSD for x86-64
	226	+	Compiling test
	227	+	Fatal: Cannot open file "test"
	228	+	Fatal: Compilation aborted
	229	+	Error: /usr/local/bin/ppcx64 returned an error exitcode
	230	+	```
219	231
220	232		### Installing from tar
221	233
222	234		Select the appropriate 32 bit/64 bit tar file based on your system. For x86_64 64-bit FreeBSD, download from [x86_64](https://www.freepascal.org/down/x86_64/freebsd.html). For i386 32-bit FreeBSD, download from [i386](https://www.freepascal.org/down/i386/freebsd.html).
223	235
224	236		To install Free Pascal from a terminal:
225	237
226	238		``` bash
227	239		$ fetch ftp://ftp.freepascal.org/pub/fpc/dist/3.2.2/x86_64-freebsd/fpc-3.2.2.x86_64-freebsd11.tar
228	240		$ tar -xf fpc-3.2.2.x86_64-freebsd11.tar
229	241		$ cd fpc-3.2.2.x86_64-freebsd
230	242		$ bash install.sh
231	243		```
232	244
233	245		Replace the desired Free Pascal version (3.0.4, 3.2.0 or 3.2.2) and architecture (x86_64 or i386) as required.
234	246
235	247		If you want to install the Free Pascal Compiler globally, for example in `/usr/local`, run the install.sh script as root. `install.sh` script uses bash shell syntax. If you get `Bad substitution` error, make sure you run script with bash.
236	248
237	249		If you are on FreeBSD 12 or newer, the default linker is the `lld`. This may cause problems if you have code that uses, for example, the cthreads unit as in the following program:
238	250
239	251		``` pascal
240	252		uses cthreads;
241	253		begin
242	254		writeln('hello');
243	255		end.
244	256		```
245	257
246	258		The executable generated for this program will cause a segmentation fault when run. To fix this issue, you need to install the GNU linker:
247	259
248	260		``` bash
249	261		root# pkg install binutils
250	262		```
251	263
252	264		and add a symbolic-link from `/usr/local/bin/ld.bfd` to `/bin/ld.bfd`.
253	265
254	266		## OpenBSD
255	267
256	268		### Installing from tar
257	269
258	270		Select the appropriate 32 bit/64 bit tar file based on your system. For x86_64 64-bit OpenBSD, download from [x86_64](https://sourceforge.net/projects/freepascal/files/OpenBSD/3.2.2/fpc-3.2.2.x86_64-openbsd.tar). For i386 32-bit OpenBSD, download from [i386](https://sourceforge.net/projects/freepascal/files/OpenBSD/3.2.2/fpc-3.2.2.i386-openbsd.tar).
259	271
260	272		To install Free Pascal from a terminal:
261	273
262	274		``` bash
263	275		$ wget https://sourceforge.net/projects/freepascal/files/OpenBSD/3.2.2/fpc-3.2.2.x86_64-openbsd.tar
264	276		$ tar -xf fpc-3.2.2.x86_64-openbsd.tar
265	277		$ cd fpc-3.2.2.x86_64-openbsd
266	278		$ bash install.sh
267	279		```
268	280
269	281		Replace the desired Free Pascal version (3.0.4, 3.2.0, or 3.2.2) and architecture (x86_64 or i386) as required.
270	282
271	283		If you want to install the Free Pascal Compiler globally, for example in `/usr/local`, run the install.sh script as root. `install.sh` script uses bash shell syntax. If you get `Bad subtitution` error, make sure you run script with bash. OpenBSD uses ksh as default shell. You need to install bash manually.
272	284
273	285		## Installing from source on BSD/Linux
274	286
275	287		Effectively, you need:
276	288
277	289		1\. A file with all FPC sources downloaded from git (https://gitlab.com/freepascal.org/fpc/source) or perhaps (https://sourceforge.net/projects/freepascal/files/Source/3.2.2/fpc-3.2.2.source.tar.gz).
278	290
279	291		2\. A starting (bootstrap) FPC compiler. An FPC release can always be built by the previously released FPC version, and FPC trunk can always be built by the current FPC release. You can download a bootstrap Free Pascal Compiler or use your distribution's package management/software system to install one.
280	292
281	293		FPC build process:
282	294
283	295		- Fetch necessary files (starting compiler), FPC source file or source svn directory
284	296		- If using FPC source files: extract/de-tgz in work directory,
285	297		- Build: enter work/fpc/ and run:
286	298
287	299		``` bash
288	300		# Linux use:
289	301		export MAKE=`which make` ; echo $MAKE
290	302		# FreeBSD use (default csh, or tcsh):
291	303		set MAKE=`which gmake` ; echo $MAKE
292	304		# FreeBSD use (bash):
293	305		export MAKE=`which gmake` ; echo $MAKE
294	306		$MAKE all OPT='-gl' FPC=/path/to/startingcompiler-name-ppcx64
295	307		# $MAKE is make on Linux and gmake on BSD
296	308		# /path/to/ can be omitted when ppc386 (32 bit) or ppcx64 (64 bit) is in the path
297	309		```
298	310
299	311		- Install FPC. Again in work/fpc, run
300	312
301	313		``` bash
302	314		$MAKE install FPC=compiler/ppcx64 PREFIX=$THEPREFIX
303	315		#replace the FPC=compiler/ppcx64 (or ppc386 for 32 bit) with the relevant compiler if not on Intel x86
304	316		#THEPREFIX= usually is /usr/local or just /usr, but eg on NetBSD it is /usr/pkg for ports)
305	317		```
306	318
307	319		- Create a symlink:
308	320
309	321		``` bash
310	322		ln -s $THEPREFIX/lib/fpc/3.2.2/ppcx64 $THEPREFIX/bin/ppcx64
311	323		```
312	324
313	325		- Install sources:
314	326
315	327		``` bash
316	328		$MAKE install sourceinstall PREFIX=$THEPREFIX
317	329		```
318	330
319	331		- Create a symlink for default FPC source path:
320	332
321	333		``` bash
322	334		ln -sf $THEPREFIX/share/src/3.2.2/fpc /usr/share/fpcsrc
323	335		```
324	336
325	337		- Set up fpc.cfg configuration file:
326	338
327	339		``` bash
328	340		$THEPREFIX/lib/fpc/3.2.2/samplecfg $THEPREFIX/lib/fpc/3.2.0 $ETCDIR
329	341		```
330	342
331	343		- Optionally test to see if `ppcx64 -i` (or whatever compiler your architecture uses) gives output, else give a warning that user needs to add \$PREFIX/bin to the current path. Try to compile a program with `ppcx64 -viwn`, and see if that gives errors.
332	344
333	345		Notes:
334	346
335	347		- If you need fpcmake package lists, you need to generate or supply them yourself, (in the port, or in an extra archive) either way, do a dummy install to /tmp/pack and determine the files installed with
336	348		``` bash
337	349		find . >ll
338	350		```
339	351
340	352		- \$THEPREFIX and \$ETCDIR should be user configurable. Otherwise local installs aren't possible.
341	353
342	354		- BSDHIER=1 on all make commands forces BSD hierarchy conventions.
343	355
344	356		## Windows
345	357
346	358		### Installing an FPC release with the Windows installer
347	359
348	360		> Warning: If you are intending to also install Lazarus using the official Windows installer which installs both FPC + Lazarus, please ignore these instructions and instead refer to [[Installing Lazarus on Windows]] to avoid having to resolve any resulting conflicts.
349	361
350	362		By far the easiest way to get a working installation of the Free Pascal Compiler is to download and run the appropriate self-extracting Windows installer from the official [SourceForge repository for FPC 3.2.2](https://sourceforge.net/projects/freepascal/files/Win32/3.2.2/) - this release contains the current release versions of the Free Pascal Compiler and the Free Pascal libraries. The Windows installer packages install very easily, and should work 'out-of-the-box'. You will be taken through a typical Windows installation wizard to install the FPC binaries and Free Pascal libraries:
351	363
352	364		- Choose an installation location for FPC (suggested `C:\FPC\3.2.2`)
353	365		- Choose installation type (recommended Full Installation)
354	366		- Choose file associations, configuration file creation etc
355	367		- Install
356	368		- View README
357	369
358	370		### Installing from source
359	371
360	372		Installing from source with a command line git client is not for novices, since you also need a working bootstrap compiler to be able to compile the Free Pascal Compiler from source. Instructions for obtaining a bootstrap compiler are included below.
361	373
362	374		#### Obtaining the source with a command line git client
363	375
364	376		The easiest way to get the Free Pascal Compiler source is by using a git client. The exact commands may vary between git clients; the commands given below are for the command line git client downloadable from [GitForWindows.org](https://gitforwindows.org/).
365	377
366	378		##### Source for a release version of FPC
367	379
368	380		First create a directory in which you'd like to keep the source. Any normal user can do this. Create a directory for FPC (eg `C:\Source`) by typing the following at a command prompt:
369	381
370	382		```dos
371	383		C:\Users\you> cd \
372	384		C:\> mkdir Source
373	385		C:\> cd Source
374	386		```
375	387
376	388		Now type issue the following command at a command prompt:
377	389
378	390		```dos
379	391		C:\Source> git clone -b release_3_2_2 https://gitlab.com/freepascal.org/fpc/source.git fpc-3.2.2
380	392		```
381	393
382	394		Wait while the git repository is downloaded to the fpc-3.2.2 directory in your newly created Source directory. This can take a while... have a look at the helpful [Free Pascal Forums](https://forum.lazarus.freepascal.org/) while you wait :-) You may also like to read the excellent [[Forum\|How to use the Forum]] Wiki article which explains how to get answers to pesky questions quickly. New Forum users are always welcome.
383	395
384	396		##### Source for a non-release version of FPC
385	397
386	398		There are two current non-release branches of the Free Pascal Compiler: the development (main) branch and the Fixes 3.2 branch which includes additional fixes to the released 3.2.2 version. Developers, and those who like living on the bleeding edge and testing new features and fixes, will choose the development version; more normal users, who wish to use a stable branch with some additional fixes since the latest release version, will choose the Fixes branch. The instructions below cover both these branches.
387	399
388	400		If it does not already exist, create a directory in which you'd like to keep the FPC source (eg `C:\Source`). Any normal user can do this. Now type the following command at a command prompt:
389	401
390	402		For the Fixes branch of FPC 3.2
391	403
392	404		```dos
393	405		C:\Source> git clone -b fixes_3_2 https://gitlab.com/freepascal.org/fpc/source.git fpc-fixes-3.2.0
394	406		```
395	407
396	408		For the Development (main) branch of FPC
397	409
398	410		```dos
399	411		C:\Source> git clone -b main https://gitlab.com/freepascal.org/fpc/source.git fpc-main
400	412		```
401	413
402	414		Hint: To update your local copy of the repository with subsequent changes, you need only do:
403	415
404	416		For the Fixes branch of FPC 3.2
405	417
406	418		```dos
407	419		C:\> cd C:\Source\fpc-fixes-3.2
408	420		C:\Source\fpc-fixes-3.2> git clean -f -d
409	421		C:\Source\fpc-fixes-3.2> git pull
410	422		```
411	423
412	424		For the Development (main) branch of FPC
413	425
414	426		```dos
415	427		C:\> cd C:\Source\fpc-main
416	428		C:\Source\fpc-trunk> git clean -f -d
417	429		C:\Source\fpc-trunk> git pull
418	430		```
419	431
420	432		#### Obtaining a bootstrap compiler
421	433
422	434		To obtain a bootstrap Free Pascal Compiler, download the distribution package [fpc-3.2.2.i386-win32.exe](https://www.freepascal.org/down/i386/win32.html) and run it - it is a self-extracting installer, so just follow the instructions to install it. The installer should set the PATH environment variable as appropriate.
423	435
424	436		Then restart windows.
425	437
426	438		#### Compiling the FPC source
427	439
428	440		Before you start
429	441
430	442		- The installation PREFIX in the instructions that follow is totally dependent on the directory in which you installed FPC. The Windows FPC installer uses a default location of `C:\FPC` and the FPC 3.2.2 release files are placed in `C:\FPC\3.2.2`. Since versions change relatively frequently, it is recommended that you just select and maintain a single PREFIX default location without any regard to FPC version numbers. A reasonable PREFIX to adopt is the one used by the Windows FPC installer (`C:\FPC`) but you must also make sure that the `C:\FPC\bin\i386-win32\` directory is added to your path environment variable.
431	443
432	444		- Check that the `make.exe` which is found first in your path environment variable is the GNU one included with your bootstrap FPC compiler. If you have a recent version of Delphi installed, watch out for its version of `make` being earlier in your path. It does not understand the FPC Makefile and you will receive many errors if you try to use it. You can check this by opening a command prompt and typing `make -v`. The result should be (or very similar):
433	445
434		-	~~` `![`fpc_windows_make.png`](/wiki-images/1/12/Fpc_windows_make.png)~~
	446	+	```text
	447	+	file:fpc_windows_make.png
	448	+	```
435	449
436	450		- If you need to change your path so that the correct `make.exe` is found, you can either do it temporarily or permanently.
437	451		- To change it temporarily (it is in effect only until you close the current command prompt) to find `make.exe` in `C:\FPC\3.2.2\bin\i386-win32`, at a command prompt type:
438	452
439	453		C:\Source\> set PATH=C:\FPC\3.2.2\bin\i386-win32;%PATH%
440	454
441	455		- - To change it permanently, open Control Panel \> System and choose "Advanced system settings" under "Related settings" towards the bottom of the page. Now choose "Environment Variables..." in the System Properties dialog. Here you will probably need to change the Path that appears under "System variables" so that `C:\FPC\3.2.2\bin\i386-win32` occurs first.
442	456
443	457		Instructions
444	458
445	459		- At a command prompt, navigate to your local FPC source directory (eg `C:\Source\fpc-3.2.2`) by typing:
446	460
447	461		```dos
448	462		C:\> cd Source\fpc-3.2.2
449	463		```
450	464
451	465		- Compile the FPC source with:
452	466
453	467		```dos
454	468		C:/Source/fpc-3.2.2> make distclean all
455	469		```
456	470
457	471		- To overwrite an existing FPC installation in, for example, `C:\FPC`) type:
458	472
459	473		```dos
460	474		C:/Source/fpc-3.2.2> make install PREFIX=C:\FPC
461	475		```
462	476
463	477		- If you also need the cross-compiler to x86_64, type the following commands which will compile the cross-compiler and then install it:
464	478
465	479		```dos
466	480		C:/Source/fpc-3.2.2> make all OS_TARGET=win64 CPU_TARGET=x86_64 INSTALL_PREFIX=C:\FPC\3.2.2 PP=C:\FPC\3.2.2\bin\i386-win32\ppc386.exe DATA2INC=C:\FPC\3.2.2\bin\i386-win32\data2inc.exe
467	481
468	482		C:/Source/fpc-3.2.2> make crossinstall OS_TARGET=win64 CPU_TARGET=x86_64 INSTALL_PREFIX=C:\FPC\3.2.2 PP=C:\FPC\3.2.2\bin\i386-win32\ppc386.exe DATA2INC=C:\FPC\3.2.2\bin\i386\win32\data2inc.exe
469	483		```
470	484
471	485		The cross-compiler to compile programs for Windows 64 bit may now be found here: `C:\FPC\3.2.2\bin\i386-win32\ppcrossx64`.
472	486
473	487		Done!
474	488
475	489		## macOS
476	490
477	491		> Warning: If you are intending to also install Lazarus using the official macOS installation packages which install both FPC + Lazarus, please ignore these instructions and instead refer to [[Installing Lazarus on macOS]] to avoid having to resolve any resulting FPC conflicts.
478	492
479	493		### Installing an FPC release from the official macOS packages
480	494
481	495		#### Step 1: Download Xcode (optional)
482	496
483	497		Xcode is a 12GB download which will take up 16GB of disk space. You only need to download and install the full Xcode development environment if you need:
484	498
485	499		- the SDKs for iOS, iPadOS, watchOS and tvOS; or
486	500		- to validate and upload apps to the Mac App Store; or
487	501		- to [[Notarization for macOS 10.14.5+\|notarise]] apps for distribution outside of the Mac App Store.
488	502
489	503		Xcode 11.3.1 for use on macOS 10.14 Mojave must now be installed by downloading it from [Apple Developer Connection](http://developer.apple.com/) (ADC), which requires free registration. Xcode 11.4.x for use on macOS 10.15 Catalina can be installed from the [Mac App store](https://apps.apple.com/us/genre/mac-developer-tools/id12002?mt=12). Note that you must first move any old Xcode versions from the Applications folder into the trash or rename the Xcode app (eg Xcode.app to Xcode_1014.app). You can select which version of Xcode to use with the command line utility `xcode-select`.
490	504
491	505		Older systems:
492	506
493	507		The developer tools can be installed from the original macOS installation disks or a newer copy downloaded from the [Apple Developer Connection](http://developer.apple.com/) (ADC), which requires free registration. Download the Xcode file, it will end up in your Downloads directory as a zip file. Click it. It is unarchived into your Downloads directory. You may be happy with it there but maybe not. Other users will see the path to it but be unable to use it. And it is untidy there. So I moved mine and then told xcode-select where it was moved to (in a terminal) -
494	508
495	509		``` bash
496	510		mv Downloads/Xcode.app /Developer/.
497	511		sudo xcode-select -s /Developer/Xcode.app/Contents/Developer
498	512		```
499	513
500	514		#### Step 2: Xcode Command Line Tools
501	515
502	516		This is shown here as a separate step because it really is a separate step in addition to Step 1. Don't confuse this with the internal Xcode command line tools that the Xcode GUI will tell you are already installed. FPC does not use those Xcode internal command line tools, so do the following (it is quick and easy)-
503	517
504	518		``` bash
505	519		sudo xcode-select --install
506	520		sudo xcodebuild -license accept
507	521		```
508	522
509	523		You only need to enter the first of the two commands above unless you have also installed the full Xcode package. If you have only installed the command line tools, you should omit entering the xcodebuild command.
510	524
511	525		#### Step 3: Download FPC
512	526
513	527		Download the Free Pascal Compiler (FPC) and FPC source from the [Free Pascal website](https://www.freepascal.org/download.html). When you arrive at the download page, select a mirror and then choose the correct version for your operating system.
514	528
515	529		These installation packages are built by the FPC developers and track formal releases. As these installation packages are not code signed nor notarized by Apple, you need to either control-click on the installation package and choose "Open" or right-click on the installation package and choose "Open" in the contextual menu and confirm you want to install from an Unknown Developer.
516	530
517	531		### Other installation options
518	532
519	533		See [[Other macOS installation options\|Other FPC Installation Options]].
520	534
521	535		## Testing the FPC Install
522	536
523	537		You might like to try a simple and quick test of FPC at this stage. From the command line (Mac - Open an Application \> Utilities \> Terminal) start an editor (e.g. pico or nano), paste this very short program and save it as the file `helloworld.pas` (using the WriteOut command in GNU nano):
524	538
525	539		``` pascal
526	540		program helloworld;
527	541		begin
528	542		writeln('hello world !');
529	543		end.
530	544		```
531	545
532	546		Now exit the editor and compile this simple code by typing this command, before pressing `Enter`:
533	547
534	548		``` bash
535	549		fpc helloworld.pas
536	550		```
537	551
538	552		It should very quickly make an executable called, you guessed it, "helloworld". Run this executable by typing this command and then pressing `Enter`:
539	553
540	554		``` bash
541	555		./helloworld
542	556		```
543	557
544	558		If that worked, well done!
545	559
546	560		## Useful command-line switches for compiling from source
547	561
548	562		- Significantly speed up the FPC source tree compilation
549	563		- `FPMAKEOPT="-T x"` (x = the number of CPU cores you have)
550	564
551	565		- Reduce the number of times the compiler itself gets recompiled
552	566		- `NOWPOCYCLE=1`
553	567
554	568		- Add debug information and disable optimizations during compilation of the compiler/RTL
555	569		- `OPT="-gl -O-"`
556	570
557	571		## Installing cross compilers
558	572
559	573		A cross compiler allows you to create binaries (executables) for a platform different from the platform being used for compilation. For example, working under macOS and creating executables for Win64 or Win32 (only up to and including macOS 10.14.6 due to Apple's removal of 32 bit frameworks). For details on how to do this, see [[Cross compiling\|Cross Compiling]].
560	574
561	575		## See also
562	576
563	577		- [[FPC\|FPC Wiki Documentation]].
564	578		- [FPC Official Documentation](https://www.freepascal.org/docs.html).
565	579		- [[FPC New Features 3.2.2\|FPC 3.2.2 New Features]].
566	580		- [[User Changes 3.2.2\|FPC 3.2.2 User Changes]] - may break existing code.
567	581		- [[FPC New Features Trunk\|FPC New Features in development version]].
568	582		- [[User Changes Trunk\|FPC User Changes in development version]] - may break existing code.
569	583
570	584		---
571	585		From the Free Pascal wiki, page "Installing the Free Pascal Compiler", as it stood on 2024-03-04 after a change by Dbannon, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
572	586		Category: FPC
573	587		Category: Install

Back to history