Installing the Free Pascal Compiler: what changed

Revision 1 to 2. 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		-	~~</syntaxhighlight>~~
36		-
37	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)-
38	36		``` bash
39	37		apt install ./fpc-laz_3.2.2-1_amd64.deb
40	38		```
41	39
42	40		Note the actual name changes from time to time, use the name you downloaded !
43	41
44	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 !
45	43
46	44		### Downloading FPC tar balls
47	45
48	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.
49	47
50	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.
51	49
52	50		> Note: A tar install does not resolve dependencies, if they are not already present, first install binutils, make, gcc.
53	51
54	52		> Note: A tar ball install will, if you manage paths properly, allow you to have several versions of FPC installed.
55	53
56	54		(if you want something a bit newer, please see <https://www.freepascal.org/develop.html> )
57	55
58	56		``` bash
59	57		cd
60	58		mkdir -p bin/FPC/Tars
61	59		mkdir bin/FPC/SRC
62	60		mkdir bin/FPC/fpc-3.2.2
63	61		cd bin/FPC/Tars
64	62		# download src and compiler tars, change for different CPU (or Mac ?)
65	63
66	64		wget https://sourceforge.net/projects/freepascal/files/Source/3.2.2/fpc-3.2.2.source.tar.gz
67	65		wget https://sourceforge.net/projects/freepascal/files/Linux/3.2.2/fpc-3.2.2.x86_64-linux.tar
68	66
69	67		tar xf fpc-3.2.2.x86_64-linux.tar
70	68		cd fpc-3.2.2.x86_64-linux
71	69		./install.sh
72	70		# when asked where to install, enter $HOME/bin/FPC/fpc-3.2.2, accept all defaults after that.
73	71
74	72		cd ../../SRC
75	73		tar xzf ../Tars/fpc-3.2.2.source.tar.gz
76	74
77	75		# Set a path to where the compiler is, add line at end of .bashrc, if you don't use bash, adjust !
78	76		# (! e.g. Use ~/.profile instead of ~/.bashrc so that the path is available also in Lazarus IDE.)
79	77		echo "PATH=\"\$HOME/bin/FPC/fpc-3.2.2/bin\":\"\$PATH\"" >> ~/.bashrc
80	78		source ~/.bashrc
81	79
82	80		# trivial test
83	81		cd
84	82		fpc -iV
85	83		```
86	84
87	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 -
88	86		>
89	87		> ``` bash
90	88		> wget https://sourceforge.net/projects/freepascal/files/Linux/3.2.2/fpc-3.2.2.arm-linux.tar
91	89		> ```
92	90		>
93	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.
94	92
95	93		### Downloading FPC sources from Git or zip
96	94
97	95		If you plan to build your own compiler from source, this is the approach for you.
98	96
99	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.
100	98
101	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.
102	100
103	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 -
104	102
105	103		`git clone `[`https://gitlab.com/freepascal.org/fpc/source`](https://gitlab.com/freepascal.org/fpc/source)
106	104
107	105		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.
108	106
109	107		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):
110	108
111	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)\
112	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)
113	111
114	112		You would unzip the zipball and build the source as described below.
115	113
116	114		#### Documentation sources
117	115
118	116		The documentation sources are in a separate repository called fpcdocs, so the command to get them is:
119	117
120	118		``` bash
121	119		cd ~
122	120		git clone https://gitlab.com/freepascal.org/fpc/documentation.git fpcdocs
123	121		```
124	122
125	123		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.
126	124
127	125		For more information, see the [Free Pascal website](https://www.freepascal.org/develop.html).
128	126
129	127		### Compiling the FPC source, using preinstalled FPC
130	128
131	129		- First install the release FPC from RPM/DEB or tarballs as described above.
132	130		- Get FPC sources (trunk) as described above.
133	131		- Make FPC sources with (execute in the source (trunk) directory):
134	132
135	133		``` bash
136	134		make clean
137	135		make all
138	136		make install INSTALL_PREFIX=install/to/directory
139	137		```
140	138
141	139		Decide about install/to/directory and also add options that you need.
142	140
143	141		- 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.
144	142		- 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
145	143
146	144		``` bash
147	145		cd install/to/directory/lib/fpc
148	146		mkdir etc
149	147		fpcmkcfg -d basepath="install/to/directory/lib/fpc/\$fpcversion" -o etc/fpc.cfg
150	148		```
151	149
152	150		### Compiling the FPC source, using just downloaded FPC 3.2.2
153	151
154	152		- Download FPC 3.2.2 (latest official release), ie tarball fpc-3.2.2.x86_64-linux.tar.
155	153		- Unpack this tarball to e.g. "~/Downloads/fpc", do CD to the folder containing the file "install.sh", run from Terminal:
156	154
157	155		`$ ./install.sh`
158	156
159	157		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".
160	158
161	159		- Download the Git snapshot of FPC:
162	160
163	161		`$ git clone `[`https://gitlab.com/freepascal.org/fpc/source`](https://gitlab.com/freepascal.org/fpc/source)
164	162
165	163		- Do CD to new folder "source" and call:
166	164
167	165		`$ make clean PP=/home/user/fpc-3.2.2/bin/fpc`\
168	166		`$ make all PP=/home/user/fpc-3.2.2/bin/fpc`
169	167
170	168		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.
171	169
172	170		Final compiled binary will be the file "source/compiler/ppcx64".
173	171
174	172		## FreeBSD
175	173
176	174		> 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]].
177	175
178	176		### Installing from the ports collection
179	177
180	178		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`.
181	179
182	180		This must be done as root.
183	181
184	182		``` bash
185	183		# cd /usr/ports/lang/fpc && make install && make clean
186	184		```
187	185
188	186		If you want use development (aka trunk) version of fpc with all units included do the following:
189	187
190	188		``` bash
191	189		# cd /usr/ports/lang/fpc-devel && make install clean
192	190		```
193	191
194	192		Also, you can install FPC and units from pkg binaries:
195	193
196	194		``` bash
197	195		# pkg install lang/fpc
198	196		```
199	197
200	198		Installing development FPC and units from pkg binaries:
201	199
202	200		``` bash
203	201		# pkg install lang/fpc-devel
204	202		```
205	203
206	204		Once FPC is installed you can check if it's working by simply running as a normal user:
207	205
208	206		``` bash
209	207		$ fpc test
210	208		```
211	209
212	210		which should produce output similar to this:
213	211
214	212		` Free Pascal Compiler version 3.2.2 [2021/08/03] for x86_64`\
215	213		` Copyright (c) 1993-2021 by Florian Klaempfl and others`\
216	214		` Target OS: FreeBSD for x86-64`\
217	215		` Compiling test`\
218	216		` Fatal: Cannot open file "test"`\
219	217		` Fatal: Compilation aborted`\
220	218		` Error: /usr/local/bin/ppcx64 returned an error exitcode`
221	219
222	220		### Installing from tar
223	221
224	222		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).
225	223
226	224		To install Free Pascal from a terminal:
227	225
228	226		``` bash
229	227		$ fetch ftp://ftp.freepascal.org/pub/fpc/dist/3.2.2/x86_64-freebsd/fpc-3.2.2.x86_64-freebsd11.tar
230	228		$ tar -xf fpc-3.2.2.x86_64-freebsd11.tar
231	229		$ cd fpc-3.2.2.x86_64-freebsd
232	230		$ bash install.sh
233	231		```
234	232
235	233		Replace the desired Free Pascal version (3.0.4, 3.2.0 or 3.2.2) and architecture (x86_64 or i386) as required.
236	234
237	235		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.
238	236
239	237		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:
240	238
241	239		``` pascal
242	240		uses cthreads;
243	241		begin
244	242		writeln('hello');
245	243		end.
246	244		```
247	245
248	246		The executable generated for this program will cause a segmentation fault when run. To fix this issue, you need to install the GNU linker:
249	247
250	248		``` bash
251	249		root# pkg install binutils
252	250		```
253	251
254	252		and add a symbolic-link from `/usr/local/bin/ld.bfd` to `/bin/ld.bfd`.
255	253
256	254		## OpenBSD
257	255
258	256		### Installing from tar
259	257
260	258		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).
261	259
262	260		To install Free Pascal from a terminal:
263	261
264	262		``` bash
265	263		$ wget https://sourceforge.net/projects/freepascal/files/OpenBSD/3.2.2/fpc-3.2.2.x86_64-openbsd.tar
266	264		$ tar -xf fpc-3.2.2.x86_64-openbsd.tar
267	265		$ cd fpc-3.2.2.x86_64-openbsd
268	266		$ bash install.sh
269	267		```
270	268
271	269		Replace the desired Free Pascal version (3.0.4, 3.2.0, or 3.2.2) and architecture (x86_64 or i386) as required.
272	270
273	271		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.
274	272
275	273		## Installing from source on BSD/Linux
276	274
277	275		Effectively, you need:
278	276
279	277		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).
280	278
281	279		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.
282	280
283	281		FPC build process:
284	282
285	283		- Fetch necessary files (starting compiler), FPC source file or source svn directory
286	284		- If using FPC source files: extract/de-tgz in work directory,
287	285		- Build: enter work/fpc/ and run:
288	286
289	287		``` bash
290	288		# Linux use:
291	289		export MAKE=`which make` ; echo $MAKE
292	290		# FreeBSD use (default csh, or tcsh):
293	291		set MAKE=`which gmake` ; echo $MAKE
294	292		# FreeBSD use (bash):
295	293		export MAKE=`which gmake` ; echo $MAKE
296	294		$MAKE all OPT='-gl' FPC=/path/to/startingcompiler-name-ppcx64
297	295		# $MAKE is make on Linux and gmake on BSD
298	296		# /path/to/ can be omitted when ppc386 (32 bit) or ppcx64 (64 bit) is in the path
299	297		```
300	298
301	299		- Install FPC. Again in work/fpc, run
302	300
303	301		``` bash
304	302		$MAKE install FPC=compiler/ppcx64 PREFIX=$THEPREFIX
305	303		#replace the FPC=compiler/ppcx64 (or ppc386 for 32 bit) with the relevant compiler if not on Intel x86
306	304		#THEPREFIX= usually is /usr/local or just /usr, but eg on NetBSD it is /usr/pkg for ports)
307	305		```
308	306
309	307		- Create a symlink:
310	308
311	309		``` bash
312	310		ln -s $THEPREFIX/lib/fpc/3.2.2/ppcx64 $THEPREFIX/bin/ppcx64
313	311		```
314	312
315	313		- Install sources:
316	314
317	315		``` bash
318	316		$MAKE install sourceinstall PREFIX=$THEPREFIX
319	317		```
320	318
321	319		- Create a symlink for default FPC source path:
322	320
323	321		``` bash
324	322		ln -sf $THEPREFIX/share/src/3.2.2/fpc /usr/share/fpcsrc
325	323		```
326	324
327	325		- Set up fpc.cfg configuration file:
328	326
329	327		``` bash
330	328		$THEPREFIX/lib/fpc/3.2.2/samplecfg $THEPREFIX/lib/fpc/3.2.0 $ETCDIR
331	329		```
332	330
333	331		- 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.
334	332
335	333		Notes:
336	334
337	335		- 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
338	336		``` bash
339	337		find . >ll
340	338		```
341	339
342	340		- \$THEPREFIX and \$ETCDIR should be user configurable. Otherwise local installs aren't possible.
343	341
344	342		- BSDHIER=1 on all make commands forces BSD hierarchy conventions.
345	343
346	344		## Windows
347	345
348	346		### Installing an FPC release with the Windows installer
349	347
350	348		> 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.
351	349
352	350		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:
353	351
354	352		- Choose an installation location for FPC (suggested `C:\FPC\3.2.2`)
355	353		- Choose installation type (recommended Full Installation)
356	354		- Choose file associations, configuration file creation etc
357	355		- Install
358	356		- View README
359	357
360	358		### Installing from source
361	359
362	360		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.
363	361
364	362		#### Obtaining the source with a command line git client
365	363
366	364		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/).
367	365
368	366		##### Source for a release version of FPC
369	367
370	368		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:
371	369
372	370		```dos
373	371		C:\Users\you> cd \
374	372		C:\> mkdir Source
375	373		C:\> cd Source
376	374		```
377	375
378	376		Now type issue the following command at a command prompt:
379	377
380	378		```dos
381	379		C:\Source> git clone -b release_3_2_2 https://gitlab.com/freepascal.org/fpc/source.git fpc-3.2.2
382	380		```
383	381
384	382		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.
385	383
386	384		##### Source for a non-release version of FPC
387	385
388	386		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.
389	387
390	388		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:
391	389
392	390		For the Fixes branch of FPC 3.2
393	391
394	392		```dos
395	393		C:\Source> git clone -b fixes_3_2 https://gitlab.com/freepascal.org/fpc/source.git fpc-fixes-3.2.0
396	394		```
397	395
398	396		For the Development (main) branch of FPC
399	397
400	398		```dos
401	399		C:\Source> git clone -b main https://gitlab.com/freepascal.org/fpc/source.git fpc-main
402	400		```
403	401
404	402		Hint: To update your local copy of the repository with subsequent changes, you need only do:
405	403
406	404		For the Fixes branch of FPC 3.2
407	405
408	406		```dos
409	407		C:\> cd C:\Source\fpc-fixes-3.2
410	408		C:\Source\fpc-fixes-3.2> git clean -f -d
411	409		C:\Source\fpc-fixes-3.2> git pull
412	410		```
413	411
414	412		For the Development (main) branch of FPC
415	413
416	414		```dos
417	415		C:\> cd C:\Source\fpc-main
418	416		C:\Source\fpc-trunk> git clean -f -d
419	417		C:\Source\fpc-trunk> git pull
420	418		```
421	419
422	420		#### Obtaining a bootstrap compiler
423	421
424	422		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.
425	423
426	424		Then restart windows.
427	425
428	426		#### Compiling the FPC source
429	427
430	428		Before you start
431	429
432	430		- 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.
433	431
434	432		- 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):
435	433
436	434		` `![`fpc_windows_make.png`](/wiki-images/1/12/Fpc_windows_make.png)
437	435
438	436		- If you need to change your path so that the correct `make.exe` is found, you can either do it temporarily or permanently.
439	437		- 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:
440	438
441	439		C:\Source\> set PATH=C:\FPC\3.2.2\bin\i386-win32;%PATH%
442	440
443		-	~~</syntaxhighlight>~~
444		-
445	441		- - 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.
446	442
447	443		Instructions
448	444
449	445		- At a command prompt, navigate to your local FPC source directory (eg `C:\Source\fpc-3.2.2`) by typing:
450	446
451	447		```dos
452	448		C:\> cd Source\fpc-3.2.2
453	449		```
454	450
455	451		- Compile the FPC source with:
456	452
457	453		```dos
458	454		C:/Source/fpc-3.2.2> make distclean all
459	455		```
460	456
461	457		- To overwrite an existing FPC installation in, for example, `C:\FPC`) type:
462	458
463	459		```dos
464	460		C:/Source/fpc-3.2.2> make install PREFIX=C:\FPC
465	461		```
466	462
467	463		- If you also need the cross-compiler to x86_64, type the following commands which will compile the cross-compiler and then install it:
468	464
469	465		```dos
470	466		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
471	467
472	468		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
473	469		```
474	470
475	471		The cross-compiler to compile programs for Windows 64 bit may now be found here: `C:\FPC\3.2.2\bin\i386-win32\ppcrossx64`.
476	472
477	473		Done!
478	474
479	475		## macOS
480	476
481	477		> 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.
482	478
483	479		### Installing an FPC release from the official macOS packages
484	480
485	481		#### Step 1: Download Xcode (optional)
486	482
487	483		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:
488	484
489	485		- the SDKs for iOS, iPadOS, watchOS and tvOS; or
490	486		- to validate and upload apps to the Mac App Store; or
491	487		- to [[Notarization for macOS 10.14.5+\|notarise]] apps for distribution outside of the Mac App Store.
492	488
493	489		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`.
494	490
495	491		Older systems:
496	492
497	493		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) -
498	494
499	495		``` bash
500	496		mv Downloads/Xcode.app /Developer/.
501	497		sudo xcode-select -s /Developer/Xcode.app/Contents/Developer
502	498		```
503	499
504	500		#### Step 2: Xcode Command Line Tools
505	501
506	502		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)-
507	503
508	504		``` bash
509	505		sudo xcode-select --install
510	506		sudo xcodebuild -license accept
511	507		```
512	508
513	509		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.
514	510
515	511		#### Step 3: Download FPC
516	512
517	513		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.
518	514
519	515		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.
520	516
521	517		### Other installation options
522	518
523	519		See [[Other macOS installation options\|Other FPC Installation Options]].
524	520
525	521		## Testing the FPC Install
526	522
527	523		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):
528	524
529	525		``` pascal
530	526		program helloworld;
531	527		begin
532	528		writeln('hello world !');
533	529		end.
534	530		```
535	531
536		-	~~Now exit the editor and compile this simple code by typing this command, before pressing <span class="kbd">Enter</span>:~~
	532	+	Now exit the editor and compile this simple code by typing this command, before pressing `Enter`:
537	533
538	534		``` bash
539	535		fpc helloworld.pas
540	536		```
541	537
542		-	~~It should very quickly make an executable called, you guessed it, "helloworld". Run this executable by typing this command and then pressing <span class="kbd">Enter</span>:~~
	538	+	It should very quickly make an executable called, you guessed it, "helloworld". Run this executable by typing this command and then pressing `Enter`:
543	539
544	540		``` bash
545	541		./helloworld
546	542		```
547	543
548	544		If that worked, well done!
549	545
550	546		## Useful command-line switches for compiling from source
551	547
552	548		- Significantly speed up the FPC source tree compilation
553	549		- `FPMAKEOPT="-T x"` (x = the number of CPU cores you have)
554	550
555	551		- Reduce the number of times the compiler itself gets recompiled
556	552		- `NOWPOCYCLE=1`
557	553
558	554		- Add debug information and disable optimizations during compilation of the compiler/RTL
559	555		- `OPT="-gl -O-"`
560	556
561	557		## Installing cross compilers
562	558
563	559		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]].
564	560
565	561		## See also
566	562
567	563		- [[FPC\|FPC Wiki Documentation]].
568	564		- [FPC Official Documentation](https://www.freepascal.org/docs.html).
569	565		- [[FPC New Features 3.2.2\|FPC 3.2.2 New Features]].
570	566		- [[User Changes 3.2.2\|FPC 3.2.2 User Changes]] - may break existing code.
571	567		- [[FPC New Features Trunk\|FPC New Features in development version]].
572	568		- [[User Changes Trunk\|FPC User Changes in development version]] - may break existing code.
573	569
574	570		---
575	571		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).
576	572		Category: FPC
577	573		Category: Install

Back to history