forked from NetHack/NetHack
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Cross-compiling
730 lines (573 loc) · 33.3 KB
/
Cross-compiling
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
Cross-compiling NetHack 3.7 Last edit: February 18, 2023
The NetHack 3.7 build process differs from the build process of previous
versions in some important ways. Those differences make it possible to use
a cross-compiler running on one platform (the "host" platform of the build)
to produce a binary NetHack package that can execute on an entirely different
platform.
Part A Contents:
A1. Why cross-compile?
A2. Building NetHack 3.6 (before)
A3. Building NetHack 3.7 (going forward)
A4. How was the build procedure reduced to 5 steps?
A5. How can I help with the cross-compiling initiative?
Part B Contents:
B1. Two sets of compiles and procedures
B2. What needs to be built and executed on the HOST?
B3. What needs to be built for the TARGET?
B4. Case sample: msdos
B5. Case sample: amiga (started but incomplete)
B6. Case sample: Web Assembly, libnh
B7. Case sample: mips
--------------------------------------------------------------------------------
Part A - Cross-compiling NetHack
--------------------------------------------------------------------------------
+--------------------------+
| A1. Why cross-compile? |
+--------------------------+
By using cross-compilers on host platforms with fast processors, plenty of RAM
and storage resources, and an available cross-compiler, it may be possible to
keep or resurrect a working version of NetHack on platforms that are now too
constrained to carry out the build process natively on the platform anymore.
Some of the constraints in carrying out a native build on the desired target
may include, but not necessarily be limited to, any of the following:
o Access: Somebody with a working knowledge of the NetHack build process may
not have the desired target build platform available to them. Conversely,
somebody with a keen knowledge of the target platform, and access to it,
may not be all that familiar with the NetHack build process.
o Resources: Address space limitations, insufficient RAM, low amounts of disk
storage, slow processor performance, may impede the ability to execute the
compile process on the target platform.
o Compilers: Some of the native compilers on historical platforms may only
support the dialect of C that was popular when the platform and compiler
were in their prime.
Another useful potential result of cross-compiling, is that it paves the way
for carrying out test and production builds of NetHack for multiple target
platforms through automated steps carried out on the host platform(s).
+-------------------------------------+
| A2. Building NetHack 3.6 (before) |
+-------------------------------------+
Very generally, the build of NetHack in past versions required the following
steps to be carried out:
1. Compile and link util/makedefs.
2. Run makedefs repeatedly with different command line options to produce
several output files that are required for:
(a) additional build steps to follow, including some header
files: pm.h, onames.h, date.h.
(b) creation of files, containing information required by,
or about the game during its execution, that are stored in a
portable, platform-independent way, that need to be inserted
into the game package.
(c) creation of files containing information required by, or about
the game during its execution, that are stored in an architecture
and/or platform and/or operating system dependent way, that need
to be inserted into the game package (the quest text format is
one example).
3. Compile and link the level compiler. This step needs to execute
work-alike tools to lex and yacc, or needs to build pre-built lex and
yacc output (.c, .h files) that are provided in the sys/share part of
the NetHack source code tree.
4. Execute the level compiler to read dat/*.des files and create
a set of binary output files that are architecture and/or operating
system dependent on the build platform, for use by the game during
its execution.
5. Compile and link the dungeon compiler. Like the level compiler, this
step needs to execute work-alike tools to lex and yacc, or needs to
build pre-built lex and yacc output (.c, .h files) that are provided
in the sys/share part of the NetHack source code tree.
6. Execute the dungeon compiler to read dat/dungeon.def and create
a set of binary output files that are architecture and/or operating
system dependent on the build platform, for use by the game during
its execution.
7. Compile and link several less critical utilities such as uudecode,
tile-generation utilities, and so forth, all of which need to execute
on the build platform during the build process to produce output files
for use during the game, that are reasonably portable (not architecture
and/or operating system dependent; only the output of the utilities
becomes part of the game package, not the executable utilities
themselves.
8. Compile and link the game itself.
9. Package the game and its required files including the output from
previous steps 2b, 2c, 4, 6, 7 and 8 above.
Steps 1, 2a, 2b, 7, and 9 above are not impediments to cross-compiling NetHack.
Steps 2c, 3, 4, 5, 6 and 8 above are impediments to cross-compiling NetHack.
That's because the files that those steps produce are very much tied to the
platform where the build of NetHack is being carried out. Variations between
platforms (such as 32-bit vs 64-bit, integer sizes, pointer sizes, processor
byte order, data alignment requirements, struct padding and the way bitfields
are stored) impact the portability of those data files between different
platforms and operating systems. If all those things happen to match, the files
might, just might, be usable across platforms, but the chances are against it,
and that certainly cannot be counted on.
+------------------------------------------+
| A3. Building NetHack 3.7 (going forward) |
+------------------------------------------+
Again, very generally, the build of NetHack in 3.7 requires the following
steps to be carried out:
1. Compile and link util/makedefs.
2. Run makedefs repeatedly with different command line options to produce
several required output files that contain information required by the
game, or contain information about the game during its execution, that
are stored in a portable, platform-independent way, that need to be
inserted into the game package (makedefs -d, -o, -r, -h, -s).
3. Compile and link several less critical utilities such as uudecode,
tile-generation utilities, and so forth, all of which need to execute
on the build platform during the build process to produce output files
for use during the game, that are reasonably portable (not architecture
and/or operating system dependent; only the output of the utilities
becomes part of the game package, not the executable utilities
themselves.
4. Compile and link the game components for the TARGET; that includes
NetHack itself, Lua, and any optional regular-expression or window port
libraries that you plan to link into the NetHack game executable.
5. Package the game and its required files including the output from
previous steps 2, 3 and 4 above.
Step 4 is now the only impediment to cross-compiling NetHack. That impediment
is resolved by executing step 4 using a cross-compiler that runs on the build (host)
platform to produce a resulting binary for the target platform, instead of
executing the native compiler.
+-----------------------------------------------------+
| A4. How was the build procedure reduced to 5 steps? |
+-----------------------------------------------------+
The following are among several design changes planned in NetHack 3.7,
and these specific changes are what altered the build process to make
cross-compiling possible:
o There is no creation of platform-dependent files, such as the quest
text files, by makedefs during the build process. Instead, the quest
text files have been converted to Lua and are inserted into the game
package for processing by the embedded Lua during execution of NetHack.
o There is no build-time level compiler involved. Instead, the level
descriptions have been converted to Lua and are inserted into the game
package for processing by the embedded Lua during execution of NetHack.
o There is no build-time dungeon compiler involved. Instead, the dungeon
description has been converted to Lua and is inserted into the game
package for processing by the embedded Lua during execution of NetHack.
o Some of the build and option information that was formerly produced
during build time by makedefs, and contained information about the
build-platform specifically, is now produced at runtime within the
game under a cross-compiled build. As such, it now produces information
applicable to the target NetHack environment, not the build environment.
+------------------------------------------------------------+
| A5. How can I help with the cross-compiling initiative? |
+------------------------------------------------------------+
o If you have a favourite target platform (let's call it XX-Platform for
example purposes) that you'd like to see NetHack be able to run on, do
some research to find out if a cross-compiler exists that:
- produces output for XX-Platform.
- executes on a platform that you use and love (Linux, Windows,
macOS are some examples of platforms that have cross-compilers
for other targets available)
o Then, make the community, devteam, and others aware that you're starting
a cross-compile of NetHack for XX-Platform. You might need to ask some
"starting out" questions initially, and as you get deeper into it, you
might need to ask some tougher questions.
o Perhaps consider forking from NetHack on GitHub, and do the
cross-compiler work there in your fork. Strive to get it to a point where
it's ready to play-test on XX-Platform, or perhaps even use an emulator
of XX-Platform if one is available. We live in a time where plenty do.
Doing your work on a GitHub fork has the following advantages:
- It will make it really simple to integrate your work back into
the NetHack source tree if that's one of your goals.
- It will make it possible and straightforward to merge upstream
NetHack changes into your work for the XX-Platform cross-compile
so that it stays current with the game as it evolves.
- You may get help from others in the form of suggestions, or
pull-requests, or offers to join the development. Chances are,
you aren't the only person out there that would like to
establish/resurrect/maintain NetHack on XX-Platform.
Have fun!
-----------------------------------------------------------------------------
Part B - Cross-compiling details
-----------------------------------------------------------------------------
Part B Contents:
B1. Two sets of compiles and procedures
B2. What needs to be built and executed on the HOST?
B3. What needs to be built for the TARGET?
B4. Case sample: msdos
+-----------------------------------------+
| B1. Two sets of compiles and procedures |
+-----------------------------------------+
The HOST is the platform/place that you're running the build procedures using
the native compiler/linker, and the cross-compiler/linker that runs on the HOST
to build the game for a TARGET platform.
You have to:
1. Build mandatory utilities on the HOST.
2. Execute the mandatory utilities to generate components that will be used
during step 4 to build the game itself, or that will generate components
that will become part of the TARGET game package.
3. Build optional or enhancing utilities on the HOST, execute those
optional or enhancing utilities on the HOST to generate components that
will become part of the TARGET game package.
4. Execute a supported cross-compiler to compile the rest of the game
components like NetHack, Lua, and any optional libraries (the word
"supported", in this sense, means a compiler that runs on your HOST
build platform, and generates output executable files for the TARGET
platform).
It should be mentioned that you can execute the cross-compile build approach
to generate binaries for the same platform as the host, where the HOST
compiler and the TARGET compiler are the same.
+------------------------------------------------------+
| B2. What needs to be built and executed on the HOST? |
+------------------------------------------------------+
On the HOST, here are the mandatory things that have to be built.
a) Using the HOST native compiler, build HOST native utility makedefs
Compile and link the following with these compiler switches:
-DCROSSCOMPILE
from sources: util/makedefs.c, src/mdlib.c, src/monst.c, src/objects.c
src/date.c, src/alloc.c
b) Execute HOST native makedefs utility, util/makedefs, as follows:
Required for complete packaging of the game, but not the C source
game compile:
util/makedefs -d
util/makedefs -r
util/makedefs -h
util/makedefs -s
c) Using the HOST native compiler, build these additional utilities if your
target platform requires components that they produce. It is important
to note that all of the required source files need to be compiled to
native obj files for linking into the HOST-side utility. Some of the
source files (src/monst.c, src/objects.c) were likely already compiled
as native HOST-side obj files in order to build the native HOST utility
'makedefs' HOST utility above, and you don't need to compile them again
for use in linking other HOST utilities if the HOST-native obj files
produced from them are still around.
NOTE: There are some source files that need to be compiled for linking
into utilities that are needed on the HOST side, but that are also
needed again later as TARGET obj files for linking into the TARGET
executable, and therefore must be compiled twice.
They include: src/drawing.c, src/objects.c, src/monst.c,
src/alloc.c, util/panic.c. It is important to keep the compiled
HOST-side obj files produced by the HOST native compiler distinct from
the TARGET-side obj files produced by the cross-compiler. That can be
accomplished either by naming the generated object files a little
differently (perhaps with a suffix) between the HOST-side and the
TARGET-side, or by placing the HOST-side obj files and the TARGET-side
obj files into distinct, different directories during the build process.
Use whatever method works best for your cross-compile effort and tools.
util/dlb
from sources: src/dlb.c, src/dlb_main.c, src/alloc.c,
util/panic.c
purpose: For packaging up many files that are
required components of the TARGET game
into a single nhdat or nhdat370 combined
file
util/uudecode
from sources: sys/share/uudecode.c
purpose: convert some binary files, that are
distributed in the NetHack sources in
uuencoded format, back into their
original binary state
util/tilemap
from sources: win/share/tilemap.c
purpose: produce output file src/tile.c that is
required for building TARGET packages with
tile support
util/tile2bmp
from sources: win/share/tile2bmp.c, win/share/tiletext.c,
win/share/tilemap.c, src/drawing.c,
src/monst.c, src/objects.c
purpose: Read win/share/monsters.txt,
win/share/objects.txt and win/share/other.txt
files and produce a .bmp file.
util/gif2txt
from sources: win/share/gifread.c, win/share/tiletext.c,
win/share/tilemap.c, src/drawing.c,
src/monst.c, src/objects.c,
src/alloc.c, util/panic.c
purpose: Read win/share/monsters.txt,
win/share/objects.txt and win/share/other.txt
files and produce a .gif file.
util/ppmwrite
from sources: win/share/ppmwrite.c, win/share/tiletext.c,
win/share/tilemap.c, src/drawing.c,
src/monst.c, src/objects.c,
src/alloc.c, util/panic.c
purpose: Read win/share/monsters.txt,
win/share/objects.txt and win/share/other.txt
files and produce a .ppm file.
+--------------------------------------------+
| B3. What needs to be built for the TARGET? |
+--------------------------------------------+
For the TARGET side, here are the mandatory things that have to be built via
the HOST-executed cross-compiler that generates code for the TARGET platform.
Using the cross-compiler, build the following targets:
a) NetHack sources (core is mandatory)
With the cross-compiler and linker for the TARGET platform,
cross-compile and link with these compiler switches:
-DCROSSCOMPILE and -DCROSSCOMPILE_TARGET
core sources (2019): src/allmain.c, src/alloc.c, src/apply.c,
src/artifact.c, src/attrib.c, src/ball.c,
src/bones.c, src/botl.c, src/cmd.c, src/dbridge.c,
src/decl.c, src/detect.c, src/dig.c, src/display.c,
src/dlb.c, src/do.c, src/do_name.c, src/do_wear.c,
src/dog.c, src/dogmove.c, src/dokick.c,
src/dothrow.c, src/drawing.c, src/dungeon.c,
src/eat.c, src/end.c, src/engrave.c, src/exper.c,
src/explode.c, src/extralev.c, src/files.c,
src/fountain.c, src/hack.c, src/hacklib.c,
src/insight.c, src/invent.c, src/isaac64.c,
src/light.c, src/lock.c, src/mail.c,
src/makemon.c, src/mcastu.c,
src/mdlib.c, src/mhitm.c, src/mhitu.c, src/minion.c,
src/mklev.c, src/mkmap.c, src/mkmaze.c, src/mkobj.c,
src/mkroom.c, src/mon.c, src/mondata.c,
src/monmove.c, src/monst.c, src/mplayer.c,
src/mthrowu.c, src/muse.c, src/music.c,
src/nhlsel.c, src/nhlua.c, src/nhlobj.c,
src/o_init.c, src/objects.c, src/objnam.c,
src/options.c, src/pager.c, src/pickup.c,
src/pline.c, src/polyself.c, src/potion.c,
src/pray.c, src/priest.c, src/quest.c,
src/questpgr.c, src/read.c, src/rect.c,
src/region.c, src/restore.c, src/rip.c, src/rnd.c,
src/role.c, src/rumors.c, src/save.c, src/sfstruct.c,
src/shk.c, src/shknam.c, src/sit.c, src/sounds.c,
src/sp_lev.c, src/spell.c, src/steal.c, src/steed.c,
src/symbols.c, src/sys.c, src/teleport.c,
src/timeout.c, src/topten.c, src/track.c,
src/trap.c, src/u_init.c, src/uhitm.c, src/vault.c,
src/version.c, src/vision.c,
src/weapon.c, src/were.c, src/wield.c, src/windows.c,
src/wizard.c, src/worm.c, src/worn.c, src/write.c,
src/zap.c, sys/share/cppregex.cpp
tty sources: win/tty/getline.c, win/tty/termcap.c,
win/tty/topl.c, win/tty/wintty.c
generated (if req'd):
src/tile.c
plus your platform-specific source files that contain main, typically
*main.c, and unix support in *unix.c, tty support in *tty.c, and other
system support in *sys.c as well as others sources pertaining to your
specific target platform(s).
b) Lua (mandatory in 3.7)
lib/lua-5.4.6/src
from sources: lua.c, lapi.c, lauxlib.c, lbaselib.c, lcode.c,
lcorolib.c, lctype.c, ldblib.c, ldebug.c,
ldo.c, ldump.c, lfunc.c, lgc.c, linit.c,
liolib.c, llex.c, lmathlib.c, lmem.c,
loadlib.c, lobject.c, lopcodes.c,
loslib.c, lparser.c, lstate.c, lstring.c,
lstrlib.c, ltable.c, ltablib.c, ltm.c,
lundump.c, lutf8lib.c, lvm.c, lzio.c,
lbitlib.c
purpose: links into the game executable to interpret
lua level description files, lua dungeon
description files, and a lua quest text file.
d) recover (optional if desired/required; some targets have recover
functionality built into NetHack itself)
c) Additional optional library packages/obj files as required
lib/pdcurses/...
or lib/pdcursesmod/...
from sources: addch.c, addchstr.c, addstr.c, attr.c, beep.c,
bkgd.c, border.c, clear.c, color.c, delch.c,
deleteln.c, getch.c, getstr.c, getyx.c,
inch.c, inchstr.c, initscr.c, inopts.c,
insch.c, insstr.c, instr.c, kernel.c,
keyname.c, mouse.c, move.c, outopts.c,
overlay.c, pad.c, panel.c, printw.c,
refresh.c, scanw.c, scr_dump.c, scroll.c,
slk.c, termattr.c, touch.c, util.c, window.c,
debug.c, pdcclip.c, pdcdisp.c, pdcgetsc.c,
pdckbd.c, pdcutil.c
purpose: underlying curses platform support for some
target platforms where inclusion of the
NetHack curses window port in win/curses is
desired
+-------------------------+
| B4. Case sample: msdos |
+-------------------------+
Cross-compiler used: Andrew Wu's djgpp cross-compiler
Cross-compiler url: https://github.com/andrewwutw/build-djgpp
Cross-compiler pre-built binary downloads:
https://github.com/andrewwutw/build-djgpp/releases
Cross-compiler bits tested:
https://github.com/andrewwutw/build-djgpp
and the pre-built binary for your platform from:
https://github.com/andrewwutw/build-djgpp/releases
and a DOS-extender (for including in msdos packaging) from
http://sandmann.dotster.com/cwsdpmi/csdpmi7b.zip
and pdcurses from:
https://github.com/wmcbrine/PDCurses.git
or pdcursesmod from:
https://github.com/Bill-Gray/PDCursesMod.git
- A shell script to download that djgpp cross-compiler and associated
pieces for either linux or macOS is available:
sh sys/msdos/fetch-cross-compiler.sh
That script won't install anything, it just does file fetches and stores
them in subfolders of lib. The linux.370 and macOS.370 hints files are
configured to find the cross-compiler there if you add
CROSS_TO_MSDOS=1
on your make command line.
Note: Both the fetch-cross-compiler.sh script and the msdos
cross-compile and package procedures require unzip and zip to be available
on your host build system.
On your linux host:
cd sys/unix ; sh setup.sh hints/linux.370 ; cd ../..
make fetch-lua
On your macOS host:
cd sys/unix ; sh setup.sh hints/macOS.370 ; cd ../..
make fetch-lua
The MSDOS cross-compile can then be carried out by specifying
CROSS_TO_MSDOS=1 on the make command line:
make CROSS_TO_MSDOS=1 all
make CROSS_TO_MSDOS=1 package
You can explicitly include tty and curses support if desired. The default
you'll end up with is a tty-only cross-compile build:
make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_MSDOS=1 package
Result: The "make package" target will bundle all of the necessary
components to run NetHack on msdos into a folder:
targets/msdos/pkg
and then it zips the contents of that folder into:
targets/msdos/nh370dos.zip
Also note that building the msdos targets using the make command
above, does not preclude you from building local linux or macOS
targets as well. Just drop the CROSS_TO_MSDOS=1 from the make
command line. That's because the cross-compiler hints additions are
enclosed inside ifdef sections and won't interfere with the
non-cross-compile build in that case.
+-------------------------+
| B5. Case sample: amiga |
+-------------------------+
Disclaimer: This is a minimal recipe, just to help someone else get
started if they have a desire to get a full cross-compile of
NetHack going for the Amiga.
See CAVEATS below.
Cross-compiler used: bebbo's amiga-gcc
Cross-compiler url: https://github.com/bebbo/amiga-gcc
To our knowledge, a pre-built copy of the cross-compiler isn't available,
so you will likely have to obtain the cross-compiler sources via git and
build it on your system.
The build prerequisite packages for building the compiler on Ubuntu can be
easily obtained:
sudo apt install make wget git gcc g++ lhasa libgmp-dev \
libmpfr-dev libmpc-dev flex bison gettext texinfo ncurses-dev \
autoconf rsync
The build prerequisite packages for macOS via homebrew are documented but
not tested by us any of us to date.
brew install bash wget make lhasa gmp mpfr libmpc flex gettext \
texinfo gcc make autoconf
After installing the prerequite packages and the cross-compiler
it was a straightforward build:
git clone https://github.com/bebbo/amiga-gcc.git
cd amiga-gcc
make update
[Note that you may have to take ownership of the files in the bebbo
repo via chown before successfully carrying out the next steps]
make clean
make clean-prefix
date; make all -j3 >&b.log; date
The compiler pieces are installed in /opt/amiga by default. If you prefer,
you can alter the prefix before you build if you want. The instructions
for doing so were spelled out at the time of this writing at:
https://github.com/bebbo/amiga-gcc
On your linux host:
cd sys/unix ; sh setup.sh hints/linux.370 ; cd ../..
make fetch-lua
On your macOS host:
cd sys/unix ; sh setup.sh hints/macOS.370 ; cd ../..
make fetch-lua
The Amiga cross-compile can then be carried out by specifying
CROSS_TO_AMIGA=1 on the make command line:
make CROSS_TO_AMIGA=1 all
make CROSS_TO_AMIGA=1 package
You can explicitly include tty and curses support if desired, otherwise
you'll end up with a tty-only cross-compile build. The SDL1 pdcurses
support has not been tested.
make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_AMIGA=1 all
Result: The "make package" target will bundle the (hopefully) necessary
components to run NetHack on msdos into a folder:
targets/amiga/pkg
and then it zips the contents of that folder into:
targets/amiga/nh370ami.zip
Also note that building the amiga targets using the make command
above, does not preclude you from building local linux or macOS
targets as well. Just drop the CROSS_TO_AMIGA=1 from the make
command line.
The cross-compiler hints additions are enclosed inside ifdef sections
and won't interfere with the non-cross-compile build in that case.
CAVEATS: The original NetHack Amiga build steps included the source for
some utilities that were built and executed on the amiga:
txt2iff and xpm2iff
as part of the NetHack build procedure on amiga.
Those did not compile out-of-the-box on the linux host. They
will either have to be:
- ported to build and run on the linux or macOS cross-compile
host
or
- their functionality will have to be rolled into amiga NetHack
itself and executed on the target Amiga the first time the game
is run, perhaps.
If you make headway, or are successful getting a working copy of
NetHack going on the amiga, drop us a note at [email protected].
+--------------------------------+
| B6. Case sample: Web Assembly |
+--------------------------------+
Credit: The initial Web Assembly cross compile was found in a pull request:
https://github.com/NetHack/NetHack/pull/385
by apowers313. The pull request was merged with some accompanying
NetHack source tree integration changes in early October 2020.
Cross-compiler used: emscripten
Cross-compiler url: https://emscripten.org/docs/getting_started/downloads.html
Here's a brief guide to obtaining the cross-compiler sources via git and
building it on your system.
For Ubuntu, the build prerequisite packages for building the compiler can
be easily obtained:
sudo apt-get install python3 cmake default-jre
For macOS, you will need to install Xcode, git, cmake, Python 3.5 or new
(at time of this writing).
After installing the prerequite packages above, obtain the cross-compiler
via git and build it from the directory of your choice using steps similar
to these:
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
git pull
./emsdk install latest
./emsdk activate latest
source ./emsdk_env.sh
The steps above reflect what was outlined at this url at the time
of writing:
https://emscripten.org/docs/getting_started/downloads.html
That is the definitive source and trumps anything documented here.
On your linux host, prepare to cross-compile NetHack as follows:
cd sys/unix ; sh setup.sh hints/linux.370 ; cd ../..
make fetch-lua
On your macOS host, prepare to cross-compile NetHack as follows:
cd sys/unix ; sh setup.sh hints/macOS.370 ; cd ../..
make fetch-lua
Then, cross-compile to targets/wasm as follows:
make CROSS_TO_WASM=1
You can build src/libnh.a from pull request 385 as follows:
make WANT_LIBNH=1
Do not add any additional windowport interfaces to your build
(such as WANT_WIN_TTY=1 WANT_WIN_CURSES=1 WANT_WIN_X11=1 or
WANT_WIN_QT=1) as those aren't applicable to the Web Assembly
or nethacklib builds. A "shim" pseudo-windowport is included
from pull request 385.
Result: As mentioned, the wasm cross-compile will end up in
targets/wasm and the nethacklib.a will end up in
src.
The cross-compiler hints additions are enclosed inside ifdef sections
and shouldn't interfere with the non-cross-compile builds using
hints/linux.370 or hints/macOS.370.
+--------------------------------+
| B7. Case sample: mips |
+--------------------------------+
Cross-compiler used: gcc-mipsel-linux-gnu, g++-mipsel-linux-gnu
Cross-compiler url:
Here's a brief guide to obtaining the cross-compiler sources on an
Ubuntu system and building NetHack with it.
For Ubuntu, the build prerequisite packages for building the compiler can
be easily obtained:
sudo apt install gcc-mipsel-linux-gnu
sudo apt install g++-mipsel-linux-gnu
On your linux host, prepare to cross-compile NetHack as follows:
cd sys/unix ; sh setup.sh hints/linux.370 ; cd ../..
make fetch-lua
Then, cross-compile to targets/mips as follows:
make CROSS_TO_MIPS=1 fetch-ncurses
make CROSS_TO_MIPS=1 package
Do not add any additional windowport interfaces to your build
(such as WANT_WIN_TTY=1 WANT_WIN_CURSES=1 WANT_WIN_X11=1 or
WANT_WIN_QT=1) as those aren't applicable to the mips cross-compile.
The cross-compiler hints additions are enclosed inside ifdef sections
and shouldn't interfere with the non-cross-compile builds using
hints/linux.370 or hints/macOS.370.
---