Support wide Curses on MS-DOS

Also, fix IBMGraphics on Curses

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "submodules/pdcurses"]
 	path = submodules/pdcurses
 	url = https://github.com/wmcbrine/PDCurses.git
+[submodule "submodules/pdcursesmod"]
+	path = submodules/pdcursesmod
+	url = https://github.com/Bill-Gray/PDCursesMod.git

Cross-compiling

@@ -428,6 +428,7 @@ Using the cross-compiler, build the following targets:
     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,
@@ -461,6 +462,8 @@ Cross-compiler pre-built binary downloads:
            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:

include/extern.h

@@ -3032,9 +3032,9 @@ extern boolean glyphid_cache_status(void);
 extern int glyphrep_to_custom_map_entries(const char *op, int *glyph);
 void free_all_glyphmap_u(void);
 int add_custom_urep_entry(const char *symset_name, int glyphidx,
-                          const uint8 *utf8str, long ucolor,
+                          uint32 utf32ch, const uint8 *utf8str, long ucolor,
                           enum graphics_sets which_set);
-int set_map_u(glyph_map *gm, const uint8 *utf8str, long ucolor);
+int set_map_u(glyph_map *gm, uint32 utf32ch, const uint8 *utf8str, long ucolor);
 #endif /* ENHANCED_SYMBOLS */
 
 /* ### vault.c ### */

include/wintype.h

@@ -80,6 +80,7 @@ struct classic_representation {
 struct unicode_representation {
     uint32 ucolor;
     uint16 u256coloridx;
+    uint32 utf32ch;
     uint8 *utf8str;
 };
 

src/symbols.c

@@ -1065,7 +1065,9 @@ apply_customizations_to_symset(enum graphics_sets which_set)
         details = g.sym_customizations[UNICODESET].details;
         while (details) {
             gm = &glyphmap[details->content.urep.glyphidx];
-            (void) set_map_u(gm, details->content.urep.u.utf8str,
+            (void) set_map_u(gm,
+                             details->content.urep.u.utf32ch,
+                             details->content.urep.u.utf8str,
                              details->content.urep.u.ucolor);
             details = details->next;
         }

src/utf8map.c

@@ -60,11 +60,11 @@ to_custom_symset_entry_callback(int glyph, struct find_struct *findwhat)
     uval = unicode_val(findwhat->unicode_val);
     if (unicodeval_to_utf8str(uval, utf8str, sizeof utf8str)) {
 #ifdef NO_PARSING_SYMSET
-        set_map_u(gm, utf8str,
+        set_map_u(gm, uval, utf8str,
                   (findwhat->color != 0L) ? findwhat->color : 0L);
 #endif
         add_custom_urep_entry(known_handling[H_UTF8], glyph,
-                              utf8str, findwhat->color, UNICODESET);
+                              uval, utf8str, findwhat->color, UNICODESET);
     }
 }
 
@@ -217,7 +217,7 @@ unicode_val(const char *cp)
 }
 
 int
-set_map_u(glyph_map *gm, const uint8 *utf8str, long ucolor)
+set_map_u(glyph_map *gm, uint32 utf32ch, const uint8 *utf8str, long ucolor)
 {
     static uint32_t closecolor = 0;
     static int clridx = 0;
@@ -237,6 +237,7 @@ set_map_u(glyph_map *gm, const uint8 *utf8str, long ucolor)
             gm->u->u256coloridx = clridx;
         else
             gm->u->u256coloridx = 0;
+        gm->u->utf32ch = utf32ch;
         return 1;
     }
     return 0;
@@ -475,7 +476,7 @@ glyphrep(const char *op)
 
 int
 add_custom_urep_entry(const char *customization_name, int glyphidx,
-                      const uint8 *utf8str, long ucolor,
+                      uint32 utf32ch, const uint8 *utf8str, long ucolor,
                       enum graphics_sets which_set)
 {
     static uint32_t closecolor = 0;
@@ -505,6 +506,7 @@ add_custom_urep_entry(const char *customization_name, int glyphidx,
                     details->content.urep.u.u256coloridx = clridx;
                 else
                     details->content.urep.u.u256coloridx = 0;
+                details->content.urep.u.utf32ch = utf32ch;
                 return 1;
             }
             prev = details;
@@ -522,6 +524,7 @@ add_custom_urep_entry(const char *customization_name, int glyphidx,
         newdetails->content.urep.u.u256coloridx = clridx;
     else
         newdetails->content.urep.u.u256coloridx = 0;
+    newdetails->content.urep.u.utf32ch = utf32ch;
     newdetails->next = (struct customization_detail *) 0;
     if (!details && prev) {
         prev->next = newdetails;
@@ -1071,7 +1074,7 @@ to_unicode_callback(int glyph UNUSED, struct find_struct *findwhat)
     uval = unicode_val(findwhat->unicode_val);
     if (unicodeval_to_utf8str(uval, utf8str, sizeof utf8str)) {
 #ifdef NO_PARSING_SYMSET
-        set_map_u(gm, utf8str,
+        set_map_u(gm, uval, utf8str,
                   (findwhat->color != 0L) ? findwhat->color : 0L);
 #else
 

sys/msdos/Install.dos

@@ -43,6 +43,8 @@ II. There once was a time when people built NetHack right on their DOS machine.
         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
     and Lua from:
         http://www.lua.org/ftp/lua-5.4.4.tar.gz
 
@@ -82,6 +84,12 @@ II. There once was a time when people built NetHack right on their DOS machine.
         make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_MSDOS=1 all
         make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_MSDOS=1 package
 
+    Add WANT_DOSVGA for a curses build that supports higher resolutions and
+    external fonts:
+
+        make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_MSDOS=1 WANT_DOSVGA=1 all
+        make WANT_WIN_TTY=1 WANT_WIN_CURSES=1 CROSS_TO_MSDOS=1 WANT_DOSVGA=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

sys/msdos/fetch-cross-compiler.sh

@@ -91,6 +91,12 @@ if [ ! -d "pdcurses" ]; then
 	git clone --depth 1 https://github.com/wmcbrine/PDCurses.git pdcurses
 fi
 
+#  PDCursesMod
+if [ ! -d "pdcursesmod" ]; then
+	echo "Getting ../pdcursesmod from https://github.com/Bill-Gray/PDCursesMod.git" ; \
+	git clone --depth 1 https://github.com/Bill-Gray/PDCursesMod.git pdcursesmod
+fi
+
 if [ ! -d djgpp/djgpp-patch ]; then
     echo "Getting djlsr205.zip" ;
     cd djgpp

sys/msdos/fonts/OFL.TXT

@@ -0,0 +1,94 @@
+Copyright (C) 2020 Dimitar Toshkov Zhekov,
+with Reserved Font Name "Terminus Font".
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

sys/msdos/fonts/README-fonts

@@ -0,0 +1,24 @@
+The following files are copied verbatim from the Terminus font package,
+version 4.49, available at https://sourceforge.net/projects/terminus-font/ .
+They are distributed under the SIL Open Font License, Version 1.1.
+
+* ter-u16b.bdf
+* ter-u16v.bdf
+* ter-u20b.bdf
+* ter-u24b.bdf
+* ter-u28b.bdf
+* ter-u32b.bdf
+
+The program makefont.rb is distributed under the NetHack license, and can be
+used to generate the binary font files. Because no port of Ruby is available
+for MS-DOS, the binary font files are provided precompiled. They are also
+distributed under the SIL Open Font License.
+
+* ter-u16b.psf
+* ter-u16v.psf
+* ter-u20b.psf
+* ter-u24b.psf
+* ter-u28b.psf
+* ter-u32b.psf
+
+OFL.TXT contains the text of the SIL Open Font License.

sys/msdos/fonts/makefont.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+#   Copyright (c) 2016 Ray Chason
+#   NetHack may be freely redistributed.  See license for details.
+
+# Information about a single glyph in the font
+class Glyph
+
+    attr :width
+    attr :height
+    attr_accessor :bytes
+    attr_accessor :code
+
+    def initialize(width, height)
+        @width = width
+        @height = height
+        @bytes = ""
+        @code = []
+        bwidth = (width + 7) / 8
+    end
+
+end
+
+# This converts an unsigned integer to four little endian bytes
+def write_u32(x)
+    ([ x, (x >> 8), (x >> 16), (x >> 24) ].map {|x|
+        (x & 0xFF).chr(Encoding::ASCII_8BIT)
+    }).join('')
+end
+
+# IBM437 order as NetHack expects
+ibm437 = [
+    0x0000, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
+    0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C,
+    0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8,
+    0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC,
+    0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+    0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
+    0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+    0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
+    0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
+    0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+    0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
+    0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+    0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
+    0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+    0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x2302,
+    0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
+    0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
+    0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
+    0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
+    0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
+    0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
+    0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+    0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
+    0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
+    0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
+    0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
+    0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
+    0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
+    0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
+    0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
+    0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
+]
+
+# As ibm437, but mapping Unicode back to the IBM437 position
+ibm437_rev = {}
+ibm437.size.times {|i| ibm437_rev[ibm437[i]] = i}
+
+# Variables to be used in the main loop
+font = [ nil ] * ibm437.size # Font position to glyph
+font_by_bytes = {}           # Bitmap string to font position
+font_by_code = {}            # Unicode code point to glyph
+width = nil
+height = nil
+bwidth = nil
+glyph = nil
+bitmap = false
+row = 0
+
+if ARGV.size != 2 then
+  	STDERR.puts "Usage: #{$0} <input-bdf> <output-psf>"
+    exit 1
+end
+
+File.foreach(ARGV[0]) do |line|
+    line.chomp!
+    if line.start_with?('FONTBOUNDINGBOX ') then
+        # Width and height of a glyph
+        rec = line.split
+        width = rec[1].to_i
+        height = rec[2].to_i
+        bwidth = (width + 7) / 8
+    elsif line.start_with?('STARTCHAR ') then
+        # A glyph begins here
+        glyph = Glyph.new(width, height)
+    elsif line.start_with?('ENCODING ') then
+        # This line provides the Unicode code point
+        rec = line.split
+        glyph.code << rec[1].to_i
+    elsif line.start_with?('BITMAP') then
+        # Bitmap data appears on following lines
+        bitmap = true
+        row = 0
+    elsif line.start_with?('ENDCHAR') then
+        # End of bitmap data
+        # Position will be according to IBM437 if the code point is in IBM437,
+        # else matching any prior occurrence if the same glyph has appeared
+        # before, else as a new glyph
+        pos = ibm437_rev[glyph.code[0]] || font_by_bytes[glyph.bytes] || font.size
+        if font[pos].nil? then
+            font[pos] = glyph
+            font_by_bytes[glyph.bytes] = pos
+        else
+            font[pos].code.concat(glyph.code)
+        end
+        font_by_code[glyph.code[0]] = pos
+        glyph = nil
+        bitmap = false
+    elsif bitmap then
+        # Hex data after BITMAP and before ENDCHAR
+        bwidth.times do |col|
+            byte = line[col*2..col*2+1].to_i(16).chr(Encoding::ASCII_8BIT)
+            glyph.bytes << byte
+        end
+        row += 1
+    end
+end
+
+# The provided BDFs code positions 16 and 17 differently from what NetHack
+# expects
+if font[ibm437_rev[0x25BA]].nil? and not font_by_code[0x25B6].nil? then
+    pos1 = font_by_code[0x25B6]
+    pos2 = ibm437_rev[0x25BA]
+    font[pos2] = font[pos1]
+    font[pos2].code << 0x25BA
+    font[pos1] = nil
+end
+if font[ibm437_rev[0x25C4]].nil? and not font_by_code[0x25C0].nil? then
+    pos1 = font_by_code[0x25C0]
+    pos2 = ibm437_rev[0x25C4]
+    font[pos2] = font[pos1]
+    font[pos2].code << 0x25C4
+    font[pos1] = nil
+end
+
+# Fill any empty slots; warn if within first 256
+i = 0
+while i < font.size do
+    if font[i].nil? then
+        puts "Position #{i} is empty" if i < ibm437.size
+        font[i] = font.pop
+    end
+    i += 1
+end
+
+File.open(ARGV[1], "wb") do |outfile|
+
+    # Write the PSF header
+    outfile.write("\x72\xB5\x4A\x86")           # magic
+    outfile.write(write_u32(0))                 # version
+    outfile.write(write_u32(32))                # headersize
+    outfile.write(write_u32(0x01))              # flags (Unicode table present)
+    outfile.write(write_u32(font.size))         # length
+    outfile.write(write_u32(bwidth * height))   # charsize
+    outfile.write(write_u32(height))            # height
+    outfile.write(write_u32(width))             # width
+
+    # Write the glyphs
+    font.each {|glyph| outfile.write(glyph.bytes)}
+
+    # Write the Unicode mappings
+    font.each do |glyph|
+        outfile.write((glyph.code.map {|x| x.chr(Encoding::UTF_8)}).join(''))
+        outfile.write(0xFF.chr(Encoding::ASCII_8BIT))
+    end
+end

sys/unix/hints/include/cross-post.370

@@ -38,6 +38,16 @@ dospkg: $(GAMEBIN) $(TARGETPFX)recover.exe ../dat/nhtiles.bmp
 	cp ../sys/share/NetHack.cnf $(TARGETPFX)pkg/NETHACK.CNF
 	cp ../sys/msdos/sysconf $(TARGETPFX)pkg/SYSCONF
 	cp ../doc/nethack.txt $(TARGETPFX)pkg/NETHACK.TXT
+ifdef WANT_DOSVGA
+	cp ../sys/msdos/fonts/ter-u16b.psf $(TARGETPFX)pkg/TER-U16B.PSF
+	cp ../sys/msdos/fonts/ter-u16v.psf $(TARGETPFX)pkg/TER-U16V.PSF
+	cp ../sys/msdos/fonts/ter-u18b.psf $(TARGETPFX)pkg/TER-U18B.PSF
+	cp ../sys/msdos/fonts/ter-u20b.psf $(TARGETPFX)pkg/TER-U20B.PSF
+	cp ../sys/msdos/fonts/ter-u22b.psf $(TARGETPFX)pkg/TER-U22B.PSF
+	cp ../sys/msdos/fonts/ter-u24b.psf $(TARGETPFX)pkg/TER-U24B.PSF
+	cp ../sys/msdos/fonts/ter-u28b.psf $(TARGETPFX)pkg/TER-U28B.PSF
+	cp ../sys/msdos/fonts/ter-u32b.psf $(TARGETPFX)pkg/TER-U32B.PSF
+endif
 	cp  ../lib/djgpp/cwsdpmi/bin/CWSDPMI.EXE $(TARGETPFX)pkg/CWSDPMI.EXE
 	-touch $(TARGETPFX)pkg/RECORD
 	cd $(TARGETPFX)pkg ; zip -9 ../NH370DOS.ZIP * ; cd ../../..
@@ -180,13 +190,13 @@ $(TARGETPFX)touch.o : $(PDCTOP)/pdcurses/touch.c
 $(TARGETPFX)util.o : $(PDCTOP)/pdcurses/util.c
 $(TARGETPFX)window.o : $(PDCTOP)/pdcurses/window.c
 $(TARGETPFX)debug.o : $(PDCTOP)/pdcurses/debug.c
-$(TARGETPFX)pdcclip.o : $(PDCTOP)/dos/pdcclip.c
+$(TARGETPFX)pdcclip.o : $(PDCPORT)/pdcclip.c
-$(TARGETPFX)pdcdisp.o : $(PDCTOP)/dos/pdcdisp.c
+$(TARGETPFX)pdcdisp.o : $(PDCPORT)/pdcdisp.c
-$(TARGETPFX)pdcgetsc.o : $(PDCTOP)/dos/pdcgetsc.c
+$(TARGETPFX)pdcgetsc.o : $(PDCPORT)/pdcgetsc.c
-$(TARGETPFX)pdckbd.o : $(PDCTOP)/dos/pdckbd.c
+$(TARGETPFX)pdckbd.o : $(PDCPORT)/pdckbd.c
-$(TARGETPFX)pdcscrn.o : $(PDCTOP)/dos/pdcscrn.c
+$(TARGETPFX)pdcscrn.o : $(PDCPORT)/pdcscrn.c
-$(TARGETPFX)pdcsetsc.o : $(PDCTOP)/dos/pdcsetsc.c
+$(TARGETPFX)pdcsetsc.o : $(PDCPORT)/pdcsetsc.c
-$(TARGETPFX)pdcutil.o : $(PDCTOP)/dos/pdcutil.c
+$(TARGETPFX)pdcutil.o : $(PDCPORT)/pdcutil.c
 endif  # BUILD_PDCURSES
 #
 # End of cross-compiling -POST section

sys/unix/hints/include/cross-pre.370

@@ -74,9 +74,18 @@ ifdef BUILD_PDCURSES
 # PD Curses library
 #===============-=================================================
 ifdef WANT_WIN_CURSES
+ifdef WANT_DOSVGA
+PDCTOP = ../lib/pdcursesmod
+PDCPORT = $(PDCTOP)/dosvga
+PDCURSESDEF= -I$(PDCTOP) -I$(PDCPORT) \
+		-D"CURSES_GRAPHICS" -D"CURSES_BRIEF_INCLUDE" \
+		-D"PDC_WIDE" -D"CURSES_UNICODE"
+else
 PDCTOP = ../lib/pdcurses
-PDCURSESDEF= -I../lib/pdcurses -I../lib/pdcurses/dos \
+PDCPORT = $(PDCTOP)/dos
+PDCURSESDEF= -I$(PDCTOP) -I$(PDCPORT) \
 		-D"CURSES_GRAPHICS" -D"CURSES_BRIEF_INCLUDE"
+endif # WANT_DOSVGA
 PDCLIBOBJ1= $(TARGETPFX)addch.o $(TARGETPFX)addchstr.o \
 		$(TARGETPFX)addstr.o $(TARGETPFX)attr.o \
 		$(TARGETPFX)beep.o $(TARGETPFX)bkgd.o \
@@ -152,7 +161,7 @@ MSDOS_TARGET_CFLAGS = -c -O -I../include -I../sys/msdos -I../win/share \
 	-Wimplicit -Wimplicit-function-declaration -Wimplicit-int \
 	-Wmissing-parameter-type -Wold-style-definition -Wstrict-prototypes \
 	-DGCC_WARN
-PDCINCL += -I$(PDCTOP)/dos
+PDCINCL += -I$(PDCPORT)
 PDC_TARGET_CFLAGS = $(MSDOS_TARGET_CFLAGS) -Wno-unused-parameter \
 			-Wno-missing-prototypes
 LUA_TARGET_CFLAGS = $(MSDOS_TARGET_CFLAGS)
@@ -189,7 +198,7 @@ VARDATND += nhtiles.bmp
 #
 ifdef WANT_WIN_CURSES
 # rules for pdcurses dos-specific files
-$(TARGETPFX)%.o : $(PDCTOP)/dos/%.c
+$(TARGETPFX)%.o : $(PDCPORT)/%.c
 	$(TARGET_CC) $(PDCINCL) $(PDC_TARGET_CFLAGS) -o$@  $<
 endif  # WANT_WIN_CURSES
 #

win/curses/cursmain.c

@@ -154,11 +154,30 @@ curses_init_nhwindows(int *argcp UNUSED,
                       char **argv UNUSED)
 {
 #ifdef PDCURSES
+    static char pdc_font[BUFSZ] = "";
     char window_title[BUFSZ];
 #endif
 
 #ifdef CURSES_UNICODE
     setlocale(LC_CTYPE, "");
+#ifdef PDCURSES
+    /* Assume the DOSVGA port of PDCursesMod, or the SDL1 or SDL2 port of
+       either PDCurses or PDCursesMod. Honor the font_map option to set
+       a font.
+       On MS-DOS, if no font_map is set, use ter-u16v.psf if it is present.
+       PDC_FONT has no effect on other PDCurses or PDCursesMod ports. */
+    if (iflags.wc_font_map && iflags.wc_font_map[0]) {
+        Snprintf(pdc_font, sizeof(pdc_font), "PDC_FONT=%s",
+                 iflags.wc_font_map);
+#ifdef MSDOS
+    } else if (access("ter-u16v.psf", R_OK) >= 0) {
+        Snprintf(pdc_font, sizeof(pdc_font), "PDC_FONT=ter-u16v.psf");
+#endif
+    }
+    if (pdc_font[0] != '\0') {
+        putenv(pdc_font);
+    }
+#endif
 #endif
 
 #ifdef XCURSES

win/curses/curswins.c

@@ -3,6 +3,9 @@
 /* Copyright (c) Karl Garrison, 2010. */
 /* NetHack may be freely redistributed.  See license for details. */
 
+#if defined(CURSES_UNICODE) && !defined(_XOPEN_SOURCE_EXTENDED)
+#define _XOPEN_SOURCE_EXTENDED 1
+#endif
 #include "curses.h"
 #include "hack.h"
 #include "wincurs.h"
@@ -596,12 +599,75 @@ static void
 write_char(WINDOW * win, int x, int y, nethack_char nch)
 {
     curses_toggle_color_attr(win, nch.color, nch.attr, ON);
+#if defined(CURSES_UNICODE) && defined(ENHANCED_SYMBOLS)
+    if ((nch.unicode_representation && nch.unicode_representation->utf8str)
+        || SYMHANDLING(H_IBM)) {
+        /* CP437 to Unicode mapping according to the Unicode Consortium */
+        static const uint16 cp437[256] = {
+            0x0020, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022,
+            0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C,
+            0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8,
+            0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC,
+            0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+            0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+            0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+            0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+            0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+            0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+            0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+            0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
+            0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+            0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+            0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+            0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302,
+            0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7,
+            0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
+            0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
+            0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192,
+            0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba,
+            0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
+            0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
+            0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
+            0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
+            0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
+            0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
+            0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
+            0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4,
+            0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
+            0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
+            0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0
+        };
+        attr_t attr;
+        short pair;
+        wchar_t wch[3];
+        uint32 utf32ch;
+        cchar_t cch;
+
+        if (SYMHANDLING(H_UTF8)) {
+            utf32ch = nch.unicode_representation->utf32ch;
+        } else if (SYMHANDLING(H_IBM)) {
+            utf32ch = cp437[(uint8)nch.ch];
+        } else {
+            utf32ch = (uint8)nch.ch;
+        }
+        if (sizeof(wchar_t) == 2 && utf32ch >= 0x10000) {
+            /* UTF-16 surrogate pair */
+            wch[0] = (wchar_t)((utf32ch >> 10) + 0xD7C0);
+            wch[1] = (wchar_t)((utf32ch & 0x3FF) + 0xDC00);
+            wch[2] = L'\0';
+        } else {
+            wch[0] = (wchar_t)utf32ch;
+            wch[1] = L'\0';
+        }
+        wmove(win, y, x);
+        wattr_get(win, &attr, &pair, NULL);
+        setcchar(&cch, wch, attr, pair, NULL);
+        mvwadd_wch(win, y, x, &cch);
+    } else
+#endif
 #ifdef PDCURSES
-    mvwaddrawch(win, y, x, nch.ch);
+        mvwaddrawch(win, y, x, nch.ch);
 #else
-    if (nch.unicode_representation && nch.unicode_representation->utf8str)
-        mvwprintw(win, y, x, "%s", nch.unicode_representation->utf8str);
-    else
         mvwaddch(win, y, x, nch.ch);
 #endif
     curses_toggle_color_attr(win, nch.color, nch.attr, OFF);