randogoth/pastfetch
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

init

Browse source
This commit is contained in:
randogoth 2026-08-31 16:01:14 +03:00
commit 19991bee2a
44 changed files with 4799 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

22
.clang-format Normal file
View file

@ -0,0 +1,22 @@
# Style for pastfetch: C89, K&R braces, 4-space indent.
Language: Cpp
BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
UseTab: Never
ColumnLimit: 100
PointerAlignment: Right
DerivePointerAlignment: false
BreakBeforeBraces: Attach
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AllowShortBlocksOnASingleLine: Never
SpaceAfterCStyleCast: false
IndentCaseLabels: true
SortIncludes: false
BreakStringLiterals: false
ReflowComments: false
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: Consecutive
IndentPPDirectives: None

6
.gitignore vendored Normal file
View file

@ -0,0 +1,6 @@
*.o
*.obj
*.exe
/build/
/dist/
/.venv/

32
LICENSE Normal file
View file

@ -0,0 +1,32 @@
====== Source Code & Software =================================================
Copyright © 2026 Tobias Raayoni Last
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
====== Logos & Artwork ========================================================
Copyright © 2026 by Joni Caparas
Attribution-NonCommercial-ShareAlike 4.0 International
This license requires that reusers give credit to the creator. It allows
reusers to distribute, remix, adapt, and build upon the material in any medium
or format, for noncommercial purposes only. If others modify or adapt the
material, they must license the modified material under identical terms.

45
Makefile Normal file
View file

@ -0,0 +1,45 @@
SRC := src/main.c src/util.c src/detect.c src/render.c
BUILD_DIR := build
BIN_NAME := pf.exe
BIN := $(BUILD_DIR)/$(BIN_NAME)
CC := wcl
# wcl glues the output name to -fe=; every other front-end takes "-o name".
# Compilation happens inside $(BUILD_DIR), hence the ../ prefixes.
ifeq ($(CC),wcl)
# -k4096: the default 2 KB stack overflows. SystemInfo is a ~900-byte
# local in main(), and load_logo/wrap_info_lines each add a 512-byte
# buffer beneath it. Small model shares one 64 KB DGROUP between the
# logo string literals, the stack and the near heap, so this is
# doubled rather than raised further.
CFLAGS ?= -q -bt=dos -ms -ox -k4096 -I../include
OUT := -fe=$(BIN_NAME)
else ifeq ($(CC),owcc)
CFLAGS ?= -bcl=dos -ms -O2 -I../include
OUT := -o $(BIN_NAME)
else
CFLAGS ?= -O2 -I../include
OUT := -o $(BIN_NAME)
endif
LDFLAGS ?=
.PHONY: all clean djgpp
all: $(BIN)
$(BUILD_DIR):
@mkdir -p $(BUILD_DIR)
$(BIN): $(SRC) | $(BUILD_DIR)
@cd $(BUILD_DIR) && $(CC) $(CFLAGS) $(addprefix ../,$(SRC)) $(LDFLAGS) $(OUT)
djgpp:
# No CFLAGS override: the fallback branch above already supplies
# -O2 -I../include, and the include path is required because the
# compile runs inside $(BUILD_DIR).
$(MAKE) CC=i586-pc-msdosdjgpp-gcc
clean:
@rm -rf $(BUILD_DIR) src/*.obj *.obj

147
README.md Normal file
View file

@ -0,0 +1,147 @@
```
                       .    ,__          .           _     
 \,___,   ___    ____ _/_   /  `   ___  _/_     ___  /     
 |    \  /   `  (      |    |__  .'   `  |    .'   ` |,---.
 |    | |    |  `--.   |    |    |----'  |    |      |'   `
 |`---' `.__/| \___.'  \__/ |    `.___,  \__/  `._.' /    |
 \                          /                              
```
In the tradition of the widely popular `fastfetch` or `neofetch` tools on Linux, `pastfetch` is a DOS utility that prints a compact block of information about the running system along with a fancy logo.
It is designed for real DOS distributions, FreeDOS, SvarDOS, and popular emulators (DOSBox, DOSBox-X/Staging, DOSEMU, etc.).
ANSI logos are embedded; an ASCII fallback is used when ANSI output is unavailable.
A selection of gorgeous ANSI Logos for a variety of DOS flavors has been specifically designed for and contributed to the project by [JONINSCII](https://www.instagram.com/joninscii).
## Requirements
To see the logos in all their glory you need to have an ANSI driver installed in CONFIG.SYS. A free NANSI.SYS driver is shipped with this repository.
## Features
- DOS flavour detection using `ver`, environment markers, OEM hints, and DR-DOS signature checks (DR-DOS/Novell DOS/SvarDOS/DOSBox variants/Dosemu/Dosbian/PC DOS/MS-DOS/FreeDOS/etc.)
- True DOS version and flags via INT 21h/3306h (ROM/HMA bits noted)
- Active shell derived from `COMSPEC`
- Basic machine identity from INT 15h/C0h (OpenWatcom builds) or a generic label
- CPU class (8086/8088 vs. 286 vs. 386+)
- Conventional and extended memory sizes via BIOS interrupts
- Drive `C:` total and free space (INT 21h/36h)
- Current text mode dimensions and adapter description, VESA presence flag, plus a palette sample read via INT 10h/1015h
- `CONFIG.SYS` `DEVICE`/`DEVICEHIGH`/`INSTALL` entries (summarised) and ANSI driver detection
- 16-colour swatches when ANSI output is active
## Screenshots
| | | |
|:---:|:---:|:---:|
| <a href="screenshots/msdos.png"><img src="screenshots/msdos.png" width="260" alt="MS-DOS 6.22"></a><br>MS-DOS 6.22 | <a href="screenshots/msdos_noansi.png"><img src="screenshots/msdos_noansi.png" width="260" alt="MS-DOS 6.22 - /noansi"></a><br>MS-DOS 6.22 &mdash; `/noansi` | <a href="screenshots/freedos.png"><img src="screenshots/freedos.png" width="260" alt="FreeDOS 1.4"></a><br>FreeDOS 1.4 |
| <a href="screenshots/drdos.png"><img src="screenshots/drdos.png" width="260" alt="Caldera DR-DOS 7.03"></a><br>Caldera DR-DOS 7.03 | <a href="screenshots/novelldos.png"><img src="screenshots/novelldos.png" width="260" alt="Novell DOS 7"></a><br>Novell DOS 7 | <a href="screenshots/ibmpcdos.png"><img src="screenshots/ibmpcdos.png" width="260" alt="IBM PC DOS 7.0"></a><br>IBM PC DOS 7.0 |
| <a href="screenshots/dosbox.png"><img src="screenshots/dosbox.png" width="260" alt="DOSBox 0.74-3"></a><br>DOSBox 0.74-3 | <a href="screenshots/dosbox-x.png"><img src="screenshots/dosbox-x.png" width="260" alt="DOSBox-X 2026.05.02"></a><br>DOSBox-X 2026.05.02 | <a href="screenshots/dosbox-staging.png"><img src="screenshots/dosbox-staging.png" width="260" alt="DOSBox Staging 0.82.2"></a><br>DOSBox Staging 0.82.2 |
| <a href="screenshots/86_dos_logo.png"><img src="screenshots/86_dos_logo.png" width="260" alt="86-DOS logo"></a><br>86-DOS logo | <a href="screenshots/concurrent_logo.png"><img src="screenshots/concurrent_logo.png" width="260" alt="Concurrent DOS logo"></a><br>Concurrent DOS logo | <a href="screenshots/dosbian_logo.png"><img src="screenshots/dosbian_logo.png" width="260" alt="Dosbian logo"></a><br>Dosbian logo |
| <a href="screenshots/dosv.png"><img src="screenshots/dosv.png" width="260" alt="IBM DOS J5.0/V"></a><br>IBM DOS J5.0/V | <a href="screenshots/dosv_noansi.png"><img src="screenshots/dosv_noansi.png" width="260" alt="IBM DOS J5.0/V - /noansi"></a><br>IBM DOS J5.0/V &mdash; `/noansi` | |
## Background
At first, I planned to contribute to Leah Neukirchen's quite rudimentary [DOSfetch](https://github.com/leahneukirchen/dosfetch), but with no Pascal coding experience the task felt a bit too daunting. I briefly looked into porting it to QBASIC before eventually settling on the much more approachable [OpenWatcom C](https://openwatcom.org/).
What had started as a 'simple and fun weekend project' of a nostalgic xennial dweeb quickly turned into an endless rabbit hole of digging through archive.org to find ancient DOS [installation floppy images](https://archive.org/search?tab=all&query=DOS+floppy), investigating the forgotten realms of [interrupts](https://www.ctyme.com/rbrown.htm), and diving into source code of [MS-DOS](https://github.com/microsoft/MS-DOS) and the [DR-DOS kernel](https://github.com/SvarDOS/edrdos).
I came out with the realization that from today's perspective even with a seemingly 'simple' operating system, all the different DOS flavors and variants have their own weird quirks and unique characteristics that made it more difficult to realize this project than anticipated. Eventually I got it to work on several different popular DOS emulators with different DOS 'distros' and on bare-metal DOS installations on my trusty old ThinkPad X220.
This work would have massively exceeded its scope without the assistance of ChatGPT Codex digging through 1980s source code and help debug and refine my sloppy C code.
After months of putting the project off because I was so worn down by spending days wrestling with weird memory hiccups and rendering glitches I was pretty close to giving up on the whole thing. What kept me going were [JONINSCII](https://www.instagram.com/joninscii)'s steady motivational nudges and the patient detective work of Claude Opus, which eventually managed to iron out the quirks.
## Logos
Built-in ANSI logos for:
- `86_dos`
- `concurrentdos`
- `dos`
- `dosbian`
- `dosbox`
- `dosbox_staging`
- `dosbox_x`
- `dr_dos`
- `freedos`
- `ms_dos`
- `novell_dos`
- `pc_dos`.
## Usage
Copy `pf.exe` onto your DOS system or emulator and run:
```dos
pf [options]
```
Options:
- `/?` show the inline help
- `/list` or `--list` show the built-in logo names and exit
- `/logo NAME` or `--logo NAME` force a particular logo (see `/list`)
- `/nologo` disable ANSI art while keeping the info table
- `/noansi` or `--noansi` force ASCII-only output (also skips colour blocks)
- `/r` or `--prompt-fix` emit an extra ANSI reset/newline for shells that keep colours in the prompt
- `/safe` use the normal CRT cleanup/exit path (default is fast exit)
## Building
The `Makefile` targets DOS MZ executables:
```sh
make # builds build/pf.exe using OpenWatcom wcl by default
make clean # removes build/ and any leftover .obj files
```
- Use `make CC=owcc` if you prefer the OpenWatcom `owcc` front-end (source `owsetenv.sh`/`owsetenv.bat` first).
- `make djgpp` builds with `i586-pc-msdosdjgpp-gcc` (DJGPP cross toolchain).
- Override `CC`, `CFLAGS`, and `LDFLAGS` for other DOS-targeting compilers that provide `int86`/`intdos` equivalents.
- Source formatting is described by `.clang-format`; run `clang-format -i src/*.c include/*.h` before sending a patch.
### Devbox
If you use [devbox](https://www.jetify.com/devbox) for the build env, here are some handy scripts:
```sh
devbox run build # build/pf.exe via OpenWatcom wcl
devbox run clean # removes build/ and dist/
devbox run rebuild # clean + build
devbox run logos # regenerate src/logos_data.inc from logos/*.ans
devbox run dist # dist/pastfetch.zip release bundle (pf.exe + NANSI.SYS + docs)
```
`src/logos_data.inc` is generated and must not be hand-edited: change the art in `logos/`
and re-run `devbox run logos`, which drives `tools/generate_logos_data.py`.
## Testing
Thus far I was only able to test pastfetch in the following configurations:
| DOS Flavor | Emulated | Bare Metal |
|---------------------|----------|--------------------|
| Caldera DR-DOS 7.03 | ✅ | untested |
| FreeDOS 1.4 | ✅ | untested |
| IBM PC DOS 7.0 | ✅ | 🪲 no return to prompt|
| IBM DOS J5.0/V | logo ANSI block shown as japanese characters | untested |
| MS-DOS 6.22 | ✅ | ✅
| DOSBox 0.74-3 | ✅ | emulator only |
| DOSBox Staging 0.82.2| ✅ | emulator only
| DOSBox-X 2026.05.02 | ✅ | emulator only |
| Novell DOS 7 | ✅ | untested |
| SvarDOS 20250427 | ✅ | ✅ |
## Known Bugs
- IBM PC-DOS sometimes does not return to the `C:\>` shell. Unresolved, and not reproducible in any of my emulated environments, but present on a bare metal installation.
## Contribution
- I am eagerly looking for contributors to test pastfetch on different hardware with different DOS distros.
- Also folks who know a bit more about DOS and 16 bit computing and have more experience that would help make this a more solid piece of software.
- If you have more feature ideas and know your way around C a bit, give it a shot
## License
- Software and source code © by Tobias Raayoni Last, licensed under [MIT](https://mit-license.org/)
- Logos and artwork © by Joninscii, licensed under [Creative Commons BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)

25
devbox.json Normal file
View file

@ -0,0 +1,25 @@
{
"$schema": "https://raw.githubusercontent.com/jetify-com/devbox/0.16.0/.schema/devbox.schema.json",
"packages": [
"open-watcom-v2@latest",
"gnumake@latest",
"python3@latest",
"zip@latest"
],
"shell": {
"scripts": {
"build": "make",
"clean": "make clean && rm -rf dist",
"rebuild": "make clean && rm -rf dist && make",
"logos": "python3 tools/generate_logos_data.py",
"dist": [
"make",
"rm -rf dist && mkdir -p dist/pastfetch",
"cp build/pf.exe nansi/NANSI.SYS README.md LICENSE dist/pastfetch/",
"cp nansi/license.txt dist/pastfetch/NANSI.TXT",
"(cd dist && zip -qr pastfetch.zip pastfetch)",
"echo 'wrote dist/pastfetch.zip'"
]
}
}
}

254
devbox.lock Normal file
View file

@ -0,0 +1,254 @@
{
"lockfile_version": "1",
"packages": {
"github:NixOS/nixpkgs/nixpkgs-unstable": {
"last_modified": "2025-12-26T02:09:19Z",
"resolved": "github:NixOS/nixpkgs/8970f698c39f490df47e4cbb7beae7869ddf1978?lastModified=1766714959&narHash=sha256-%2B2xdB27fVMEVKWmh7UtpBGgK1FOVdk5ttV3ZPhpdqVY%3D"
},
"gnumake@latest": {
"last_modified": "2025-12-31T03:27:36Z",
"resolved": "github:NixOS/nixpkgs/f665af0cdb70ed27e1bd8f9fdfecaf451260fc55#gnumake",
"source": "devbox-search",
"version": "4.4.1",
"systems": {
"aarch64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/p15ia8pn2wxzdqaf07nrwdspfwsyrzyn-gnumake-4.4.1",
"default": true
},
{
"name": "man",
"path": "/nix/store/b5lxm0lk6x1bix95n07cz810qfli84c5-gnumake-4.4.1-man",
"default": true
},
{
"name": "info",
"path": "/nix/store/mmvr4hwsambcigjihl7lf3aiprhkdcd2-gnumake-4.4.1-info"
}
],
"store_path": "/nix/store/p15ia8pn2wxzdqaf07nrwdspfwsyrzyn-gnumake-4.4.1"
},
"aarch64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/644anc4jyqal79d739mwr5bxznb1i5qx-gnumake-4.4.1",
"default": true
},
{
"name": "man",
"path": "/nix/store/3nailcskmiij9a4hb6dihaf0hqsfy7kg-gnumake-4.4.1-man",
"default": true
},
{
"name": "debug",
"path": "/nix/store/nzgvdhdnqcg0bpcq4k2aa2zd5qmwgg9x-gnumake-4.4.1-debug"
},
{
"name": "info",
"path": "/nix/store/ij1n1xja5ixfhv4fqi5j8xlkbc80n1lc-gnumake-4.4.1-info"
}
],
"store_path": "/nix/store/644anc4jyqal79d739mwr5bxznb1i5qx-gnumake-4.4.1"
},
"x86_64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/w1zxhygdjxaff1rrp6na4qkh9x4aks8p-gnumake-4.4.1",
"default": true
},
{
"name": "man",
"path": "/nix/store/rv8sy3pwwdn90a5vzk47rm5rx8q040dc-gnumake-4.4.1-man",
"default": true
},
{
"name": "info",
"path": "/nix/store/rbyz3pnr7n8wprrhy588siv2csisr5va-gnumake-4.4.1-info"
}
],
"store_path": "/nix/store/w1zxhygdjxaff1rrp6na4qkh9x4aks8p-gnumake-4.4.1"
},
"x86_64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/n5m6p0j4anvf5cyy79nb2qn7smkzs176-gnumake-4.4.1",
"default": true
},
{
"name": "man",
"path": "/nix/store/9l7klscdz1cf1wdhm6ihd0as6dxlxg72-gnumake-4.4.1-man",
"default": true
},
{
"name": "debug",
"path": "/nix/store/sg196gmr26wc93qj8ajzr5nw5hy54hfq-gnumake-4.4.1-debug"
},
{
"name": "info",
"path": "/nix/store/mcbi0v4cy602a08rkaxl3w3r3k1qmds2-gnumake-4.4.1-info"
}
],
"store_path": "/nix/store/n5m6p0j4anvf5cyy79nb2qn7smkzs176-gnumake-4.4.1"
}
}
},
"open-watcom-v2@latest": {
"last_modified": "2025-12-31T03:27:36Z",
"resolved": "github:NixOS/nixpkgs/f665af0cdb70ed27e1bd8f9fdfecaf451260fc55#open-watcom-v2",
"source": "devbox-search",
"version": "0-unstable-2025-11-15",
"systems": {
"aarch64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/v6jmhc6qhcg4d1y3w3mg3gx2vd2adw79-open-watcom-v2-0-unstable-2025-11-15",
"default": true
}
],
"store_path": "/nix/store/v6jmhc6qhcg4d1y3w3mg3gx2vd2adw79-open-watcom-v2-0-unstable-2025-11-15"
},
"aarch64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/sq79m0vjyhql1f7md0p3y1vl98vhzzxp-open-watcom-v2-0-unstable-2025-11-15",
"default": true
}
],
"store_path": "/nix/store/sq79m0vjyhql1f7md0p3y1vl98vhzzxp-open-watcom-v2-0-unstable-2025-11-15"
},
"x86_64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/5czbv0j32xp8bak27smdcp7m75pkkkk4-open-watcom-v2-0-unstable-2025-11-15",
"default": true
}
],
"store_path": "/nix/store/5czbv0j32xp8bak27smdcp7m75pkkkk4-open-watcom-v2-0-unstable-2025-11-15"
},
"x86_64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/gi35fcah6ryr1yjkayl05kp3z99l9wsi-open-watcom-v2-0-unstable-2025-11-15",
"default": true
}
],
"store_path": "/nix/store/gi35fcah6ryr1yjkayl05kp3z99l9wsi-open-watcom-v2-0-unstable-2025-11-15"
}
}
},
"python3@latest": {
"last_modified": "2025-01-06T03:40:18Z",
"plugin_version": "0.0.4",
"resolved": "github:NixOS/nixpkgs/3df3c47c19dc90fec35359e89ffb52b34d2b0e94#python3",
"source": "devbox-search",
"version": "3.12.8",
"systems": {
"aarch64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/8zc3wcplydp8gsxms24scpzdca438dk5-python3-3.12.8",
"default": true
}
],
"store_path": "/nix/store/8zc3wcplydp8gsxms24scpzdca438dk5-python3-3.12.8"
},
"aarch64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/66pn6ysmvx675061xaq2vz93s9vdc5p4-python3-3.12.8",
"default": true
},
{
"name": "debug",
"path": "/nix/store/brcg3a34fi45ffky63g5pqd22sksvq13-python3-3.12.8-debug"
}
],
"store_path": "/nix/store/66pn6ysmvx675061xaq2vz93s9vdc5p4-python3-3.12.8"
},
"x86_64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/fpmkmdzgd1q7kqadc7czcjdhjj7bsc0i-python3-3.12.8",
"default": true
}
],
"store_path": "/nix/store/fpmkmdzgd1q7kqadc7czcjdhjj7bsc0i-python3-3.12.8"
},
"x86_64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/c9m6yd8fg1flz2j5r4bif1ib5j20a0cy-python3-3.12.8",
"default": true
},
{
"name": "debug",
"path": "/nix/store/cicfrcjr8pky8qd0gxw0x84ynyviy6b5-python3-3.12.8-debug"
}
],
"store_path": "/nix/store/c9m6yd8fg1flz2j5r4bif1ib5j20a0cy-python3-3.12.8"
}
}
},
"zip@latest": {
"last_modified": "2026-08-27T07:16:00Z",
"resolved": "github:NixOS/nixpkgs/c27cdad491a991b11ed731760aa2ef8db0cb0410#zip",
"source": "devbox-search",
"version": "3.0",
"systems": {
"aarch64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/hai68kp8x2bdq2scjvdkfwlzyj501bk4-zip-3.0",
"default": true
}
],
"store_path": "/nix/store/hai68kp8x2bdq2scjvdkfwlzyj501bk4-zip-3.0"
},
"aarch64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/mz2c0d431196mrpv3x3zgf95dxxmfa8q-zip-3.0",
"default": true
}
],
"store_path": "/nix/store/mz2c0d431196mrpv3x3zgf95dxxmfa8q-zip-3.0"
},
"x86_64-darwin": {
"outputs": [
{
"name": "out",
"path": "/nix/store/skd0qiryfvd66k6qa9dmign05hvlqqpj-zip-3.0",
"default": true
}
],
"store_path": "/nix/store/skd0qiryfvd66k6qa9dmign05hvlqqpj-zip-3.0"
},
"x86_64-linux": {
"outputs": [
{
"name": "out",
"path": "/nix/store/3ylbf43vhx924rv23rz9g380d33n7c22-zip-3.0",
"default": true
}
],
"store_path": "/nix/store/3ylbf43vhx924rv23rz9g380d33n7c22-zip-3.0"
}
}
}
}
}

71
include/pastfetch.h Normal file
View file

@ -0,0 +1,71 @@
#ifndef pastfetch_H
#define pastfetch_H
#include <stddef.h>
#define MAX_FLAVOR_LEN 32
typedef struct {
char dos_flavor[MAX_FLAVOR_LEN];
unsigned char dos_major;
unsigned char dos_minor;
unsigned char dos_revision;
unsigned char dos_flags;
char shell[64];
char computer_model[64];
char cpu[64];
unsigned int conventional_kb;
unsigned long extended_kb; // 16-bit int caps at 64 MB
unsigned long disk_total_bytes;
unsigned long disk_free_bytes;
char display_mode[64];
char display_adapter[64];
char display_vbe[64];
char palette_info[256];
char ver_string[80];
char logo_hint[32];
int ansi_available;
} SystemInfo;
// Growable array of owned strings; see src/util.
typedef struct {
char **items;
size_t count;
size_t capacity;
} StringList;
typedef struct {
int no_logo;
char logo_override[32];
int list_only;
int prompt_fix;
int force_ascii;
int hard_exit;
} RunOptions;
// util.c -- string helpers (all tolerate NULL)
void str_copy(char *dest, size_t dest_len, const char *src);
int str_equals_ci(const char *a, const char *b);
int str_equals_ci_n(const char *a, const char *b, size_t len);
int str_starts_ci(const char *text, const char *prefix);
int str_ends_ci(const char *text, const char *suffix);
const char *str_find_ci(const char *text, const char *needle);
int str_has_ci(const char *text, const char *needle);
// util.c -- StringList
void strlist_init(StringList *list);
int strlist_add(StringList *list, const char *value);
int strlist_addn(StringList *list, const char *value, size_t len);
int strlist_adopt(StringList *list, char *owned);
void strlist_remove(StringList *list, size_t index);
void strlist_free(StringList *list);
// detect.c
void detect_system(SystemInfo *info, StringList *drivers);
// render.c
void render_system(const SystemInfo *info, const StringList *drivers, const RunOptions *options);
void list_available_logos(void);
int logo_name_exists(const char *name, char *normalized, size_t normalized_len);
#endif // pastfetch_H

22
logos/86.ans Normal file
View file

@ -0,0 +1,22 @@

ﾜﾛﾛﾛﾛﾛﾜ ﾜﾛﾛﾛﾛﾛﾜ
ﾜﾛﾟ ﾟﾛﾛ ﾛﾛﾟ ﾟﾟ
ﾟﾛﾛﾜﾜﾜﾛﾟ ﾜﾛﾛﾜﾜﾜﾜ
ﾛﾛﾟﾟﾟﾟﾛﾛﾜ ﾛﾛﾛﾟﾟﾟﾛﾛﾜ ﾛﾛﾛﾛ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ
ﾛﾛﾜ ﾜﾛﾛﾛ ﾛﾛﾜ ﾜﾛﾟ
ﾟﾛﾛﾛﾛﾛﾛﾟ ﾟﾛﾛﾛﾛﾛﾟ
ﾛﾛﾛﾛﾛﾛﾜ ﾜﾜﾛﾛﾛﾛﾜﾜ ﾜﾛﾛﾛﾛﾛﾛﾜ ｰ
ﾛﾛ ﾟﾛﾛﾜ ﾛﾛﾟ ﾟﾛﾛ ﾛﾛﾛ ﾟﾛﾛ ｰ
ﾛﾛﾟ ﾛﾛ ﾜﾛﾟ ﾛﾛ ﾟﾛﾛﾛﾜﾜ ｰ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ ﾟﾛﾛﾛﾛﾜ
ﾜﾛﾛ ﾛﾛ ﾛﾛ ﾜﾛﾛ ﾜﾜ ﾟﾛﾛ
ﾛﾛ ﾜﾜﾛﾟ ﾟﾛﾛﾜ ﾜﾜﾛﾛ ﾛﾛﾜ ﾜﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾟﾟ ﾟﾟﾛﾛﾛﾛﾟﾟ ﾟﾛﾛﾛﾛﾛﾛﾟ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ
ﾜﾟ ﾜﾜﾜ ﾜ ﾜ ﾟﾜ
ﾛ ﾛ ﾛﾛﾜﾛﾛ ﾛ
ﾛ ﾛ ﾛ ﾛ ﾛ ﾛ
ﾟﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾟ

12
logos/concurrentdos.ans Normal file
View file

@ -0,0 +1,12 @@
 ﾜﾜﾜ ﾜ
ﾛ ﾟ ﾜﾜﾜ ﾜﾜﾜ ﾜﾜﾜ ﾜ ﾜ ﾜﾜ ﾜﾜ ﾜﾜﾜ ﾜﾜﾜ ﾛﾟ
ﾛ ﾜ ﾛ ﾛ ﾛ ﾛ ﾛ ﾛ ﾛ ﾛ ﾛ ﾛﾜﾟ ﾛ ﾛ ﾛ
ﾟﾟﾟ ﾟﾟﾟ ﾟ ﾟ ﾟﾟﾟ ﾟﾟﾟ ﾟ ﾟ ﾟﾟﾟ ﾟ ﾟ ﾟﾟ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜ ﾜﾜﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜ ﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜ ﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜ ﾜﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜ
ﾜ

19
logos/dos.ans Normal file
View file

@ -0,0 +1,19 @@

ﾛﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜ ﾛﾜﾜﾛﾛﾛﾛﾛﾛﾛﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾜﾛﾛﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｲﾛﾛﾛﾛﾟﾟﾟﾟﾟﾛﾛﾛﾛﾛﾟﾟﾟﾟﾛﾛﾛﾛﾜ ﾛ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛｲｲｲ ﾛﾛﾛﾛﾛ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾟﾛﾛｲﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛ ﾛ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛｲｲｲ ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛｲﾜ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾟﾛﾛﾛﾛｲﾛﾛﾛ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛﾛｲﾜﾛﾛﾛﾛ ﾛﾛﾛﾛﾛ ﾛﾟﾛﾛﾛﾛﾛ
ﾛ ﾛﾛﾛﾛ ﾛﾛﾛｲﾛﾛﾛﾛﾛ ﾛﾛﾛﾜｲﾛﾛ ﾛﾛﾛﾛﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜﾜﾜﾛﾛﾛﾛﾛﾜﾜﾜﾜﾛﾛﾛﾛﾟ ﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ ﾟﾟｲﾛﾛﾛﾛﾛﾛﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾟﾛﾛﾛ
ﾛ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛ
ﾛ ﾛﾛﾛﾛ
ﾛ

24
logos/dos.utf8ans Normal file
View file

@ -0,0 +1,24 @@

██
█ ██████████ ███
█ ██████████▄ █▄▄███████▄▄████████▄███
█ █████████▓▓▓████▀▀▀▀▀█████▀▀▀▀████▄ █
█ ████ █████████ ████▓▓▓ █████
█ ████ █████▀██▓█ ████ ████ █
█ ████ ██████▓▓▓ █ ████████▓▄
█ ████ ██████████ ▀▀████▓███
█ ████ █████▓▄████ █████ █▀█████
█ ████ ███▓█████ ███▄▓██ █████
█ ████████████████▄▄▄▄▄█████▄▄▄▄████▀ █
█ ███████████▀ ▀▀▓██████▀▀▀███████▀███
█ ███████████ █
█ ████
█

19
logos/dosbian.ans Normal file
View file

@ -0,0 +1,19 @@

ﾜﾛﾜﾜｲｲﾛﾛﾛﾛｲｲｲｲｲｲﾛﾛﾛﾜﾜﾛ
ﾛﾛﾛﾛｲｲｲｲﾛﾛﾛﾛｲｲｲﾛﾛﾛﾛﾛﾛﾛ
ﾛﾛﾛﾛｲｲｲｲｲﾛﾛﾛﾛｲｲﾛﾛﾛﾛﾛﾛﾛ
ﾛﾛﾛﾛｲｲｲｲｲｲﾛﾛﾛﾛｲｲｲｲｲﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
ﾛｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛ
ﾛｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲﾛ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ
ﾜﾜﾜﾜ ﾛﾛﾛﾜﾜﾛﾛﾛ ﾜﾛﾛﾛﾛ
ﾛ ﾛﾜ ﾜﾜ ﾜﾜﾜ ﾛﾜﾜ ﾜﾜ ﾜﾜﾜ ﾜﾜﾜﾜ
ﾛ ﾛﾛ ﾛ ﾛ ﾟﾛﾜﾜ ﾛ ﾟﾛ ﾟﾛ ﾜﾜﾛ ﾛ ﾛ
ﾜﾛﾜﾜﾟ ﾟﾜﾜﾟ ﾜﾜﾛﾟ ﾛﾜﾜﾟ ﾜﾛ ﾟﾜﾜﾛﾜ ﾛ ﾛ
by Carmelo Maiolino

22
logos/dosbox.ans Normal file
View file

@ -0,0 +1,22 @@

ｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲ
ｱﾛｰｰｰｰｰｰｰｰｰｰｰｰｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛｰｰｰｰｰｰｰｰｰｰｰｰｰｰｰｰｲｱ
ｱﾛｰｰｰｰｰｰｰｱｱｱｱｱｱｱｱﾛﾛｱｱｱｱﾛﾛﾛｱｱｱｱｱｱｱｰｰｰｰｰｰｰｰｲｱ
ｱﾛｰｰｰｰｰｰｰｰｰｱｱｱｱｱｱﾛﾛﾛﾛﾛﾛﾛﾛｱｱｱｱｱｱｰｰｰｰｰｰｰｰｰｰｲｱ
ｱﾛｰｰｱｰｰｰｰｰｰｰｰｱｱｱｱﾛﾛｱｱｱｱﾛﾛﾛｱｱｱｱｰｰｰｰｰｰｰｱｱｰｰｲｱ
ｱﾛｰｰｱｱｱｰｰｰｰｰｰｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｱｱｰｰｰｰｰｰｰｰｱｱｱｱｰｰｲｱ
ｱﾛｰｰｱｱｱｱｱｰｰｰｰｰｰｰｰｱｱｱｱｱｱｱｱｰｰｰｰｰｰｰｰｱｱｱｱｱｱｰｰｲｱ
ｱﾛｰﾛﾛﾛﾛﾛﾛﾛｱｰｰｰｰｰｰｰﾛﾛﾛﾛﾛﾛｰｰｰｰｰｰｰｱﾛﾛﾛﾛﾛﾛﾛｰｰｲｱ
ｱﾛｰｰﾛﾛﾛｱｱﾛﾛﾛｱｰｰｰﾛﾛﾛｰｰｰｰﾛﾛﾛｰｰｰｱｱﾛﾛﾛｱｱｱｱﾛﾛｰｲｱ
ｱﾛｰｰﾛﾛﾛｱｱｱﾛﾛﾛｱｱｰﾛﾛﾛｰｰｰｰﾛﾛﾛｰｱｱｱｱﾛﾛﾛﾛﾛｱｱｱｰｰｲｱ
ｱﾛｰｰﾛﾛﾛｱｱｱﾛﾛﾛｱｱｱﾛﾛﾛｰｰｰｰﾛﾛﾛｱｱｱｱｱｱｱｱﾛﾛﾛﾛﾛｰｰｲｱ
ｱﾛｰｰﾛﾛﾛｱｱﾛﾛﾛｱｱｱｰﾛﾛﾛｰｰｰｰﾛﾛﾛｰｱｱｱｱﾛﾛｱｱｱｱﾛﾛﾛｰｲｱ
ｱﾛｰﾛﾛﾛﾛﾛﾛﾛﾛｱｱｰｰｰｰｰﾛﾛﾛﾛﾛﾛｰｰｰｰｰｱｱｱﾛﾛﾛﾛﾛﾛﾛｰｰｲｱ
ｱﾛｰｰｱｱｱｱｱｱｱｰｰｰｰｰｰｰｰｱｱｱｱｰｰｰｰｰｰｰｰｱｱｱｱｱｱｱｱｰｰｲｱ
ｱﾛｰｰｱｱｱｱｱｰｰｰｰｰｰｰﾛﾛﾛｱｱｱｱﾛﾛﾛｰｰｰｰｰｰｰｱｱｱｱｱｱｰｰｲｱ
ｱﾛｰｰｱｱｱｰｰｰｰｰｰｰｰｱｱﾛﾛﾛｱｱﾛﾛﾛｱｱｰｰｰｰｰｰｰｰｱｱｱｱｰｰｲｱ
ｱﾛｰｰｱｰｰｰｰｰｰｰｰｱｱｱｱｱﾛﾛﾛﾛﾛﾛｱｱｱｱｱｰｰｰｰｰｰｰｰｱｱｰｰｲｱ
ｱﾛｰｰｰｰｰｰｰｰｰｱｱｱｱｱｱｱﾛﾛﾛﾛﾛﾛｱｱｱｱｱｱｱｰｰｰｰｰｰｰｰｰｰｲｱ
ｱﾛｰｰｰｰｰｰｰｱｱｱｱｱｱｱｱﾛﾛﾛｱｱﾛﾛﾛｱｱｱｱｱｱｱｱｰｰｰｰｰｰｰｰｲｱ
ｱﾛｰｰｰｰｰｰｰｰｰｰｰｰｰｰﾛﾛﾛｰｰｰｰﾛﾛﾛｰｰｰｰｰｰｰｰｰｰｰｰｰｰｰｲｱ
ｲｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｱｲ

21
logos/dosbox_staging.ans Normal file
View file

@ -0,0 +1,21 @@
 ﾜﾜﾜﾜﾜﾜﾜ
ﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜﾜﾜ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾜﾜ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾜﾜ ﾛﾟ ﾟﾛﾛﾟﾟﾟﾟﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾜ ﾛ ﾜﾜ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛ ﾛ ﾟﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛ ﾛﾛﾜ ﾟﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛ ﾛﾛﾛﾛﾜ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛ ﾛ ﾛﾛ ﾛ ﾛﾛ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾜﾛﾛ ﾜﾛﾜ ﾜﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾛﾟ ﾜﾜ ﾟﾛ ﾛﾛﾛﾛ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾟ ﾟﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾟ ﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾜﾜﾜ ﾛ ﾛﾛﾛﾛ ﾛﾛﾟﾜﾛ ﾛﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛ ﾛﾛﾛﾛ ﾛﾟﾜﾛﾛﾛ ﾛ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾟﾟ ﾛﾜ ﾟﾟ ﾜﾛﾜﾛﾛﾛﾛﾛﾛ
ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟ
ﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟ
ﾟﾟﾟﾟ

23
logos/dosbox_x.ans Normal file
View file

@ -0,0 +1,23 @@
 ﾜﾜﾜﾜﾜﾜﾜ
ﾜ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲ
ﾜﾛ ﾟﾛﾛﾛ ﾛｲｲｲ
ﾛ ﾛﾛﾛﾛ ｲｲｲｲ
ﾟﾛ ﾛﾛﾛｲ ｲｲｲｲｲ
ﾛﾜ ｲｲｲｲｲｲｲｲｲｲ ﾜﾜﾜ
ﾛ ﾟｲｲｲｲｲﾟﾟﾟ ﾜﾜ ﾛﾛﾛｲ
ﾛ ﾟﾟ ﾜﾜﾜﾜﾜﾜ ﾛﾛﾛﾛﾜ ﾛﾛｲｲ
ﾜﾜﾜﾜﾜﾜ ﾜﾛﾛﾛﾛﾛﾛﾛﾛｲ ﾟﾛﾛﾛﾛﾜﾛｲｲ
ﾜ ﾜﾛﾛﾛﾛﾛﾟﾟﾟﾛｲﾜ ﾜﾛﾛﾛ ﾟｲｲｲ ﾟﾛﾛﾛｲｲｲﾜ
ﾛ ﾛﾛﾜ ﾜｲｲ ﾛﾛﾛ ｲｲｲｲ ｲｲｲﾟｲｲｲｲﾜ
ﾛﾟ ﾟﾛﾛﾜﾜﾛｲｲｲｲｲｲ ﾟﾛﾛｲ ｲｲｲ ｲｲｲｲ ﾟｲｲﾟ
ﾛﾜ ﾛﾛﾛﾟﾟ ﾟｲｲｲ ﾟｲｲｲﾜﾜﾜｲｲｲ ｲｲｲﾟ ﾛ
ﾛ ﾛｲﾜ ﾜｲｲｲ ﾟﾟｲｲｲｲｲﾟ ﾛﾛﾜﾜﾜﾛﾟ
ﾟﾛ ﾟｲｲﾜﾜｲｲｲｲﾟ ﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾛﾟ
ﾛﾜ ｲｲｲｲﾟﾟ ﾜ ﾜﾛﾛﾛﾟﾟｲｲｲ
ﾛ ﾛﾛ ﾜﾜﾜﾛﾟ ﾛﾛﾛ
ﾟﾛ ﾜﾜﾜﾛﾟﾟﾟ ﾟﾛ ﾟﾛﾛｲｲｲｲｲﾜﾜ
ﾟﾟﾟﾟ ﾛ ﾟﾛﾛﾜ ﾟﾟﾟﾟﾟｲｲｲ
ﾛﾛ ﾛﾟ ﾜﾜﾜ ﾜｲｲｲ
ﾛ ｲｲｲｲｲｲｲｲﾟ
ﾛﾜ ﾟﾟﾟﾟﾟ
ﾟﾟﾛﾜﾜﾜﾜﾜﾜﾛﾟﾟ

20
logos/drdos.ans Normal file
View file

@ -0,0 +1,20 @@

ﾜﾜﾜ
ﾛﾛﾛ Digital Research
ﾟﾟﾛﾛﾟﾟﾛﾜﾜ ﾟﾛﾛﾟﾟﾟﾟﾟﾛﾜ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ
ﾛﾛ ﾛﾛ ﾛﾛﾜﾜﾜﾜﾜﾛﾟ
ﾛﾛ ﾛﾛ ﾛﾛ ﾟﾛﾛﾜ
ﾛﾛ ﾜﾛﾟ ﾛﾛ ﾟﾛﾛﾜ
ﾜﾜﾛﾛﾜﾜﾜﾛﾟﾟ ﾜﾛﾛﾜﾜ ﾟﾛﾛﾜﾜ
ﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜ ﾜ
ﾛﾛ ﾟﾟﾛﾜ ﾜﾛﾛﾟ ﾟﾛﾛﾜ ﾜﾛﾛﾟ ﾟﾛﾛ
ﾛﾛ ﾟﾛﾛ ﾛﾛ ﾛﾛ ﾟﾛﾛﾜ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ ﾟﾟﾛﾛﾛﾜﾜ
ﾛﾛ ﾛﾛ ﾛﾛ ﾛﾛ ﾟﾟﾛﾛﾜ
ﾛﾛ ﾜﾛﾛ ﾛﾛ ﾛﾛ ﾜﾜ ﾛﾛ
ﾛﾛ ﾜﾜﾛﾛﾟ ﾟﾛﾛﾜ ﾜﾛﾛﾟ ﾛﾟﾛﾜﾜ ﾜﾛﾟ
ﾟﾟﾟﾟﾟﾟ ﾟﾟﾟﾟﾟﾟﾟﾟ ﾟ ﾟﾟﾟﾟ

20
logos/freedos.ans Normal file
View file

@ -0,0 +1,20 @@

ﾛ
ｱｲｲｲｲｲｲｲｲｲｲｲｱｱｱ
ｱｲｲｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｱｱ
ｱｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｱ
ｱｲｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｱ
ｱｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｱ
ｱｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｱ
ｱｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｱ
ｱｲﾛﾜﾛﾛﾛﾛﾜﾛﾛﾛﾛﾜﾜﾜﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｱ ﾜﾜｲｲﾜ
ｱｲﾛﾛ ﾛﾛﾛﾛﾛﾟﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｱｲｲｲｲﾟ
ｱｲﾛﾛｱ ﾟﾛﾛﾛﾛﾛｱ ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｲｲｲｲｲ
ｱｲﾛﾛﾟﾟﾟﾟﾛﾛﾛﾛﾛﾟﾟﾟﾛﾛﾛﾛｲｲﾛﾛﾛﾛﾛﾛﾛｲｱｲｲ
ﾛｱﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟｱｲﾛﾛﾛﾛﾛｲｱｲｲｲﾜ
ﾛﾛﾛｲﾜ ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾜﾜﾛﾛﾛﾛﾛﾛﾛｲｱﾛﾛｲｲｲﾜ
ﾛﾛﾛｲﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛｱﾛﾛﾛ ﾟﾟﾟ
ﾛﾛ ｰｲｲｲｲｲｲｲｲｲｲｲｲｲｲｲｱｱﾛﾛﾛﾛ ﾛﾛ
ﾛﾛ ｱｰｰﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾟﾛﾛﾛ
ﾛ ｲｱﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛ ﾛﾛ
ﾛ ﾛﾛ

23
logos/ibmdos.ans Normal file
View file

@ -0,0 +1,23 @@
 ﾜ
ﾜﾟ ﾟﾜ
ﾜﾟ ﾟﾜ
ﾜﾟ ﾟﾜ
ﾜﾟ ﾜﾜﾜﾜﾜﾜﾜ ﾟﾜ
ﾜﾟ ﾜﾟﾟﾟ ﾟﾟﾟﾜ ﾟﾜ
ﾜﾟ ﾜﾟ ﾜﾜﾜ ﾟﾜ ﾟﾜ
ﾜﾟ ﾜﾟ ﾛﾟ ﾟﾛ ﾟﾜ ﾟﾜ
ﾜﾟ ﾛ ﾜﾜﾜ ﾟﾛﾜﾜﾜﾜﾜ ﾛ ﾟﾜ
ﾜﾟ ﾜﾟ ﾛﾟ ﾟﾛﾜ ﾟﾟﾟﾟﾟﾛﾜ ﾟﾜ ﾟﾜ
ﾜﾟ ﾛ ﾜﾜﾜ ﾟﾛﾜ ﾟﾛﾜ ﾜﾜ ﾟﾛ ﾛ ﾟﾜ
ﾛ ﾛ ﾜﾛﾟ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾛﾟ ﾛ ﾛ
ﾟﾜ ﾛ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛ ﾛ ﾜﾟ
ﾟﾜ ﾛ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾜﾛﾟ ﾛ ﾜﾟ
ﾟﾜ ﾟﾜ ﾟﾛﾜ ﾟﾛ ﾜﾟ ﾜﾟ
ﾟﾜ ﾟﾜ ﾟﾛﾜﾛﾟ ﾜﾟ ﾜﾟ
ﾟﾜ ﾟﾜ ﾟ ﾜﾟ ﾜﾟ
ﾟﾜ ﾟﾟﾟﾜﾜﾜﾜﾜﾜﾜﾟﾟﾟ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟ

20
logos/msdos.ans Normal file
View file

@ -0,0 +1,20 @@

ﾛﾛﾛﾛﾜ ﾜﾛﾛﾛﾛ ﾜﾜﾛﾛﾛﾛﾛﾛﾜﾜ
ﾛﾛﾛﾛﾛ ﾛﾛﾛﾛﾛ ﾜﾛﾛﾛﾛﾟﾟﾟﾟﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛﾛﾛ ﾛﾛﾛﾛ ﾛﾛﾛﾛ
ﾛﾛﾛﾛﾛﾛﾜ ﾜﾛﾛﾛﾛﾛﾛ ﾟﾛﾛﾛﾛﾜﾜ ﾛ
ﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ ﾟﾟﾛﾛﾛﾛﾛﾛﾜﾜ
ﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ ﾟﾟﾟﾛﾛﾛﾛﾜ
ﾛﾛﾛ ﾛﾛﾛﾜﾛﾛﾛ ﾛﾛﾛ ﾜﾜﾜﾜ ﾛﾛﾛﾛ
ﾛﾛﾛ ﾛﾛﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛﾛﾜ ﾜﾛﾛﾛﾛ
ﾛﾛﾛ ﾟﾛﾛﾛﾟ ﾛﾛﾛ ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ
ﾟﾟﾟ ﾟﾟﾟ ﾟﾟﾟ ﾟﾟﾟﾟﾟﾟ
ﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜﾜﾜ ﾜﾜﾜﾜﾜﾜﾜ
ﾛﾛﾛﾟﾟﾟﾟﾛﾛﾜﾛﾛﾛﾛﾟﾟﾟﾟﾛﾛﾛﾛﾛﾟﾟﾟﾟﾟﾛﾛﾛﾜ
ﾛﾛﾛ ﾜﾛﾛﾟﾛﾜ ﾛﾛﾟﾛﾛﾜ ﾟﾟ
ﾛﾛﾛ ﾛﾛﾛﾟﾛﾛﾛ ﾛﾛﾜﾛﾛﾛ
ﾛﾛﾛ ﾛﾛﾛ ﾛﾛﾛ ﾟﾛﾛﾛﾛﾛﾛﾜﾜ
ﾛﾛﾛ ﾛﾛﾛﾜﾛﾛﾛ ﾛﾛﾛﾟﾟﾛﾛﾛﾛﾜ
ﾛﾛﾛ ﾛﾛﾟﾛﾛﾛﾟ ﾛﾛ ﾛﾛﾛ ﾛﾛﾛ
ﾛﾛﾛ ﾜﾜﾛﾛﾛﾟﾜ ﾜﾟﾛﾛﾜﾜ ﾜﾛﾛﾟ
ﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟﾟﾛﾛﾛﾛﾛﾛﾟﾟ

23
logos/novell.ans Normal file
View file

@ -0,0 +1,23 @@

ﾜﾛﾜ
ﾜﾛﾛﾛﾛﾛﾜ
ﾜﾛﾛﾜ ﾟﾛﾛﾛﾛﾜ
ﾜﾛﾟﾟﾛﾛﾛﾜ ﾟﾛﾛﾛﾛﾜ
ﾜﾛﾟ ﾛﾜ ﾟﾛﾛﾛﾜ ﾟﾛﾟ ﾛﾜ
ﾜﾛﾛﾜ ﾟﾛﾛﾛﾜ ﾟﾛﾛﾛ ﾜﾛﾟ ﾜﾛﾜ
ﾜﾛﾛﾜ ﾟﾛﾜ ﾟ ﾜﾛﾜ ﾟ ﾜﾛﾟ ﾜﾛﾟ ﾟﾛﾜ
ﾜﾛﾛﾜ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾟﾟﾜﾛﾟ ﾜﾛﾟ ﾜﾟ ﾛﾛﾛﾜ
ﾜﾛﾟ ﾜ ﾟﾜ ﾟﾛﾜ ﾟﾛﾜ ﾜﾛﾟ ﾜﾛﾟ ﾜﾟ ﾜﾟ ﾜ ﾛﾛﾜ
ﾜﾛﾟﾛﾜ ﾟﾛﾜ ﾟﾜ ﾟﾟ ﾟﾛﾛﾟ ﾜﾛﾟ ﾜﾟ ﾜﾟ ﾜﾟ ﾜﾟﾟﾟﾛﾜ
ﾜﾛﾛﾛﾜ ﾟﾛﾜ ﾟﾛﾜ ﾟﾛﾛﾜﾛﾟ ﾟﾛﾜﾜﾜﾟ ﾜﾟ ﾜﾛ ﾜﾟ ﾛﾛﾛ
ﾟﾛﾜ ﾟﾟﾛﾜ ﾟﾛﾜ ﾟﾟ ﾛﾛﾟ ﾜ ﾟﾛﾛ ﾟ ﾜﾟﾟﾛ ﾛﾜﾛﾛﾟ
ﾟﾛﾜ ﾜﾜ ﾟﾛﾛﾛﾛﾟ ﾜﾛﾛﾛﾜ ﾟﾛﾛﾛ ﾜﾟ ﾜﾛﾛﾟ
ﾟﾛﾜ ﾟﾛﾛﾜﾜﾛﾟ ﾟﾛﾟ ﾟﾛﾛﾜ ﾟﾛﾜﾜﾜﾛﾛﾟ
ﾟﾛﾜ ﾛﾛﾟ ﾟﾛﾛﾜ ﾟﾛﾛﾟ
ﾟﾛﾟ ﾜﾛﾛﾟ ﾜ
ﾜ ﾟﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾛﾟ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜ ﾜﾟ
ﾟﾜﾟ

BIN
nansi/NANSI.SYS Normal file
View file

Binary file not shown.

291
nansi/license.txt Normal file
View file

@ -0,0 +1,291 @@
GNU GENERAL PUBLIC LICENSE
http://www.gnu.org/copyleft/gpl.html
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your freedom
to share and change it. By contrast, the GNU General Public License is
intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This General
Public License applies to most of the Free Software Foundation's
software and to any other program whose authors commit to using it.
(Some other Free Software Foundation software is covered by the
GNU Library General Public License instead.) You can apply it to your
programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new free
programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid anyone
to deny you these rights or to ask you to surrender the rights. These
restrictions translate to certain responsibilities for you if you distribute
copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis
or for a fee, you must give the recipients all the rights that you have. You
must make sure that they, too, receive or can get the source code. And
you must show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on,
we want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software patents.
We wish to avoid the danger that redistributors of a free program will
individually obtain patent licenses, in effect making the program
proprietary. To prevent this, we have made it clear that any patent must
be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS FOR
COPYING, DISTRIBUTION AND
MODIFICATION
0. This License applies to any program or other work which contains a
notice placed by the copyright holder saying it may be distributed under
the terms of this General Public License. The "Program", below, refers
to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it, either
verbatim or with modifications and/or translated into another language.
(Hereinafter, translation is included without limitation in the term
"modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of running
the Program is not restricted, and the output from the Program is
covered only if its contents constitute a work based on the Program
(independent of having been made by running the Program). Whether
that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the notices
that refer to this License and to the absence of any warranty; and give
any other recipients of the Program a copy of this License along with the
Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide a
warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but does
not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program, and
can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based on
the Program, the distribution of the whole must be on the terms of this
License, whose permissions for other licensees extend to the entire
whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest your
rights to work written entirely by you; rather, the intent is to exercise the
right to control the distribution of derivative or collective works based
on the Program.
In addition, mere aggregation of another work not based on the
Program with the Program (or with a work based on the Program) on a
volume of a storage or distribution medium does not bring the other
work under the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding
machine-readable source code, which must be distributed under
the terms of Sections 1 and 2 above on a medium customarily
used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your cost
of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with
such an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to control
compilation and installation of the executable. However, as a special
exception, the source code distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies the
executable.
If distribution of executable or object code is made by offering access to
copy from a designated place, then offering equivalent access to copy
the source code from the same place counts as distribution of the source
code, even though third parties are not compelled to copy the source
along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt otherwise
to copy, modify, sublicense or distribute the Program is void, and will
automatically terminate your rights under this License. However, parties
who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full
compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and all
its terms and conditions for copying, distributing or modifying the
Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these terms
and conditions. You may not impose any further restrictions on the
recipients' exercise of the rights granted herein. You are not responsible
for enforcing compliance by third parties to this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot distribute
so as to satisfy simultaneously your obligations under this License and
any other pertinent obligations, then as a consequence you may not
distribute the Program at all. For example, if a patent license would not
permit royalty-free redistribution of the Program by all those who
receive copies directly or indirectly through you, then the only way you
could satisfy both it and this License would be to refrain entirely from
distribution of the Program.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any patents
or other property right claims or to contest validity of any such claims;
this section has the sole purpose of protecting the integrity of the free
software distribution system, which is implemented by public license
practices. Many people have made generous contributions to the wide
range of software distributed through that system in reliance on
consistent application of that system; it is up to the author/donor to
decide if he or she is willing to distribute software through any other
system and a licensee cannot impose that choice.
This section is intended to make thoroughly clear what is believed to be
a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in certain
countries either by patents or by copyrighted interfaces, the original
copyright holder who places the Program under this License may add an
explicit geographical distribution limitation excluding those countries, so
that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
9. The Free Software Foundation may publish revised and/or new
versions of the General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may differ in
detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number
of this License, you may choose any version ever published by the Free
Software Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we
sometimes make exceptions for this. Our decision will be guided by the
two goals of preserving the free status of all derivatives of our free
software and of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF
CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM,
TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT
WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE
PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND,
EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD
THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE
COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW
OR AGREED TO IN WRITING WILL ANY COPYRIGHT
HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED
ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR
OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS

988
nansi/readme.txt Normal file
View file

@ -0,0 +1,988 @@
NANSI.SYS
An Enhanced MS-DOS Console Driver
Version 3.4 November 1991
Documentation updated February 1999
http://alumni.caltech.edu/~dank/nansi/
1. Introduction - Who should use NANSI.SYS
NANSI.SYS is a console device driver for MS-DOS computers. It exe-
cutes the same ANSI cursor control sequences as does the standard con-
sole driver ANSI.SYS, but significantly faster. It also offers
several extra features, while still being simple, small, and cheap.
You can benefit from using NANSI.SYS if:
1. you use programs (such as DIR, MORE, or NETHACK) which display text
on the screen via DOS, or
2. you have an EGA or VGA, and want to use the 43- or 50-line mode of
your display, or
3. you run out of space when redefining keys with ANSI.SYS, or
4. you are a programmer who uses ANSI escape sequences, and are frus-
trated with slow display updates, or
5. you are porting display-intensive Unix programs to run under MS-
DOS.
You will not benefit from using NANSI.SYS if:
1. you never wish commands like TYPE or DIR were faster, and
2. you only use programs like Microsoft Word or Word Perfect, which
bypass DOS when displaying text, and
3. you aren't interested in displaying 43 lines of text on your EGA or
VGA, and
4. you have never heard of ANSI.SYS anyway.
The display speed improvement you get by installing NANSI.SYS depends
on the kind of programs you run. Installing NANSI.SYS will bring no
improvement in display speed for programs that bypass DOS (e.g. Micro-
soft Word), a 30% improvement in display speed with most programs that
don't bypass DOS, a 50% improvement with "optimized" programs (see
chapter 9 below), and a 95% improvement with "optimized" programs that
avoid scrolling.
One "optimized" program, COPY /b, comes with DOS. To test the speed
improvement yourself, create a long text file named foo.txt, and
display it with COPY /b foo.txt con: with NANSI.SYS installed- it will
go by very quickly. This speed increase occurs even when running in a
window in Microsoft Windows 3.0.
2. Compatibility
NANSI.SYS has been tested on IBM PC/XT, /AT, and PS/2 systems. It
should run on any CGA, MDA, EGA, or VGA compatible video card. It is
compatible with Microsoft Windows 3.0. Unlike many display speedup
progams, it does not use wierd hardware scrolling tricks, and there-
fore remains completely compatible with programs that write directly
to the screen.
November 29, 1991
- 2 -
3. Copyright status
This program and documentation is Copyright 1986, 1991 Daniel Kegel.
The executable program and its documentation may be freely distri-
buted.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
or look on the web at http://www.gnu.org/copyleft/gpl.html.
Correspondence (in English, German, or French) should be
directed to the author at dank@alumni.caltech.edu
4. Version
The version number can be found with the DOS command TYPE NANSI.SYS.
This documentation is for version 3.3, created November 1991.
5. Installation and System Requirements
NANSI.SYS version 3.3 is distributed as the archive NANSI33.ZIP, with
the following contents:
NANSI.SYS - the device driver
NANSI.DOC - this documentation file
RAW.C - how to set and clear RAW mode for faster screen output
RAW.H - definitions for users of RAW.C
GC.ON - text file which, when TYPEd, turns on the graphics cursor
NANSI.SYS requires MS-DOS version 2.0 or higher, and uses about 3
kilobytes of system RAM.
To install NANSI.SYS on your computer, copy the file NANSI.SYS to your
boot disk (usually C:), and include one of the following statements in
the configuration file CONFIG.SYS on your boot disk:
For IBM VGA and Vega VGA cards, or if you don't know (or care) what
kind of card you have:
DEVICE=NANSI.SYS
November 29, 1991
- 3 -
For Paradise VGA Plus cards:
DEVICE=NANSI.SYS /t54 /t55 /t56 /t57
For VGA cards using the Oak Technology OTI-067:
DEVICE=NANSI.SYS /t4F /t50 /t51
For VGA cards using the Trident Microsystems TVGA 8900:
DEVICE=NANSI.SYS /t50 /t51 /t52 /t53 /t54 /t55 /t56 /t57 /t58 /t59 /t5A
6. COMMAND-LINE OPTIONS
6.1. /K : force Nansi to use extended keyboard BIOS calls which
sense F11 and F12
When IBM introduced the extended keyboard with F11 and F12 keys, and
separated the numeric keypad from the arrow keys, it also introduced
an extended way of reading the keyboard with BIOS. The old way still
works, but doesn't recognize the extended keys.
Normally, Nansi tries to detect whether the extended keyboard BIOS
calls are available, and if so, uses them. However, by giving the /k
option you can force Nansi to use these calls even if Nansi doesn't
think they are there. This option is included for compatibility with
ANSI.SYS.
6.2. /X : tell Nansi to let you redefine the extended keys indepen-
dantly
IBM's extended keyboard BIOS calls added something new: they return
different scan codes for different keys with the same meaning. For
instance, they return 71 for the numeric keypad HOME key, but 224;71
for the gray HOME key. Nansi returns 71 when either of these keys are
pressed. However, the /X option causes these keys to be treated dif-
ferently during keyboard redefinition. For example, if you start
Nansi with the /X option, you can define just the gray HOME key to say
"dir/w" by sending the string ESC [224;71;"dir/w";13p
6.3. /S : tell Nansi to be secure, and disable keyboard redefini-
tion
Although it is nice to be able to redefine the keyboard with escape
sequences, it is a gaping security hole. To prevent trojan horse
attacks from messages in text files, archives, and programs downloaded
from the outside world, disable this feature by invoking Nansi with
the /s option in config.sys. For example,
DEVICE=NANSI.SYS /s /t54 /t55 /t56 /t57
This saves a few bytes of memory, too.
November 29, 1991
- 4 -
6.4. /Tnn : tell Nansi that video mode nn is a text mode
No two VGA cards seem to have the same set of video mode codes. The
same mode number can indicate a graphics mode on one card, and a text
mode on another card. Worse yet, BIOS can't tell you what kind of
mode it's in. This is a problem because Nansi gets its speed by
bypassing BIOS, which it can only do in text modes.
Nansi solves this dilemma by maintaining a 256-entry table, one entry
per possible video mode. By default, the table says that only modes
0, 1, 2, 3, and 7 are text modes. You can add new text modes with the
/t option. For instance, if modes D hex and 50 hex are text modes,
you would invoke Nansi as follows:
DEVICE=NANSI.SYS /t0D /t50
How to tell whether you need /t:
If your board is in a non-IBM text video mode (for instance, mode 50
hex), and you haven't added /t50 after NANSI.SYS in CONFIG.SYS, the
cursor will disappear after a CLS command, and the text output will be
sluggish; furthermore, if you turn on the graphics cursor (by TYPEing
the file GC.ON which came with NANSI), the beginning and end of every
text line will be garbled.
How to tell whether you don't need /t:
If you mistakenly specify a graphics mode with the /t option, the
display will be garbled while in that mode. Get back to normal by
typing MODE CO80 or rebooting, and remove the offending /t option from
config.sys.
November 29, 1991
- 5 -
7. ANSI Control Sequences
While putting text up on the screen, NANSI.SYS keeps a lookout for the
escape character (chr(27), known as ESC); this character signals the
start of a terminal control sequence. Terminal control sequences fol-
low the format
ESC [ param; param; ...; param cmd
where
ESC is the escape character chr$(27).
[ is the left bracket character.
param is an ASCII decimal number, or a string in quotes.
cmd is a case-specific letter identifying the command.
Usually, zero, one, or two parameters are given. If parameters are
omitted, they usually default to 1; however, some commands (KKR) treat
the no-parameter case specially. Spaces are not allowed between
parameters.
For example, both ESC[1;1H and ESC[H send the cursor to the home posi-
tion (1,1), which is the upper left.
In general, if you ask the cursor to go beyond the edge of the screen,
it goes to the appropriate edge. (ANSI.SYS was not always so nice.)
The following C macro illustrates how one could print a string at a
given location on the screen:
#define printXY(x,y,s) printf("%c[%d;%dH%s", 27, y, x, s);
Either single or double quotes may be used to quote a string. Each
character inside a quoted string is equivalent to one numeric parame-
ter. Quoted strings are normally used only for the Keyboard Key Reas-
signment command.
Each ANSI control sequence supported by NANSI.SYS is described below.
The descriptions follow the format
7.0.1. ABBREVIATED_NAME: what_to_send LONG NAME
where ABBREVIATED_NAME is a short name for the sequence, what_to_send
tells you what characters make up the sequence, and LONG NAME is a
long name for the sequence.
November 29, 1991
- 6 -
7.1. Sequences dealing with Cursor Positioning
7.1.1. CUP: ESC[#;#H Cursor Position
Moves the cursor to the position specified by the parameters. The
first parameter, y, specifies the row number; the second parameter, x,
specifies the column number. If no parameters are given, the cursor
is moved to (1,1), the upper left corner of the screen.
7.1.2. HVP: ESC[#;#f Horizontal and Vertical Position
This is identical to Cursor Position. Don't ask me why it exists.
7.1.3. CUU: ESC[#A Cursor Up
Moves the cursor up the given number of rows without changing its hor-
izontal position.
7.1.4. CUD: ESC[#B Cursor Down
Moves the cursor down the given number of rows without changing its
horizontal position.
7.1.5. CUF: ESC[#C Cursor Forward
Moves the cursor right the given number of columns without changing
its vertical position.
7.1.6. CUB: ESC[#D Cursor Backward
Moves the cursor left the given number of columns without changing its
vertical position.
7.1.7. DSR: ESC[#n Device Status, Report!
# must be 6. The sequence ESC[6n causes the console driver to output
a CPR (Cursor Position Report) sequence.
Note: This sequence is not supported by the ANSI.SYS emulator built
into Microsoft Windows 1.x or 2.x.
November 29, 1991
- 7 -
7.1.8. CPR: ESC[#;#R Cursor Position Report
The console driver outputs this sequence upon reciept of a DSR
sequence. The first parameter is the cursor's vertical position; the
second parameter is the cursor's horizontal position.
Note: Contrary to the MS-DOS manual, ANSI.SYS outputs a carriage
return after this sequence. NANSI.SYS faithfully reproduces this
quirk.
The resulting string can have up to eleven characters. For example,
if you have a 100-line display (wow), and the cursor is at
(x=132,y=100), the string will be ESC[132;100R followed by a carriage
return.
This should never be sent to the console driver.
Also note: This sequence is not supported by the ANSI.SYS emulator
built into Microsoft Windows 1.x or 2.x.
Here is an example of how to use DSR/CPR to find the current cursor
position with the C language:
/* Code fragment to get current cursor X and Y from console */
/* Be sure to disable line-buffering on stdin before calling */
int x, y, c;
printf("\033[6n");
fflush(stdout);
if (getchar() != '\033' || getchar() != '[')
abort("Console not responding to DSR?");
for (y=0; isdigit(c=getchar()); y=y*10+(c-'0'));
if (c != ';')
abort("Console CPR faulty?");
for (x=0; isdigit(c=getchar()); x=x*10+(c-'0'));
if (c != 'R')
abort("Console CPR faulty?");
#ifndef VT100
getchar(); /* ignore trailing CR */
#endif
This can also be useful for sensing screen size.
7.1.9. SCP: ESC[s Save Cursor Position
Saves the cursor's X and Y locations in an internal variable. See
RCP.
7.1.10. RCP: ESC[u Restore Cursor Position
Moves cursor to the position it held when the last SCP sequence was
received.
November 29, 1991
- 8 -
7.2. Sequences that Edit the Display
7.2.1. ED: ESC[#J Erase in Display
# must be 2. Clears the entire screen.
Note: Contrary to the MS-DOS manual, ANSI.SYS also moves the cursor to
the upper left corner of the screen. Contrary to the ANSI standard,
ANSI.SYS does not insist on # being 2. NANSI.SYS faithfully repro-
duces these quirks. (Version 2.2 of NANSI.SYS insisted on # being 2,
and it caused compatibility problems with programs that ignored the
MS-DOS manual. Sigh.)
7.2.2. EL: ESC[K Erase in Line
Deletes from the cursor to the end of the line.
7.2.3. IL: ESC[#L Insert Lines
The cursor line and all lines below it move down # lines, leaving
blank space. The cursor position is unchanged. The bottommost #
lines are lost.
Note: This is not supported in ANSI.SYS.
7.2.4. DL: ESC[#M Delete Lines
The block of # lines at and below the cursor are deleted; all lines
below them move up # lines to fill in the gap, leaving # blank lines
at the bottom of the screen. The cursor position is unchanged.
Note: This is not supported in ANSI.SYS.
7.2.5. ICH: ESC[#@ Insert Characters
The cursor character and all characters to the right of it move right
# columns, leaving behind blank space. The cursor position is
unchanged. The rightmost # characters on the line are lost.
Note: This is not supported in ANSI.SYS.
7.2.6. DCH: ESC[#P Delete Characters
The block of # characters at and to the right of the cursor are
deleted; all characters to the right of it move left # columns, leav-
ing behind blank space. The cursor position is unchanged.
Note: This is not supported in ANSI.SYS.
November 29, 1991
- 9 -
7.3. Sequences that Set Modes
7.3.1. KKR: ESC["string"p Keyboard Key Reassignment
The first char (or, for function keys, two chars) of the string gives
the key to redefine; the rest of the string is the key's new value.
To specify unprintable chars, give the ASCII value of the char outside
of quotes, as a normal parameter. IBM function keys are two byte
strings starting with zero. For instance, ESC[0;59;"dir a:";13p rede-
fines function key 1 to have the value "dir a:" followed by the ENTER
key.
There are about 500 bytes available to hold redefinition strings.
Once this space fills up, new strings are ignored.
To clear all definitions, send the string ESC[p. (There was no way to
do this in ANSI.SYS.)
This feature is a security risk, and can be disabled with the /s
option when loading Nansi in config.sys. See Command-line Options
above.
Here's a table of the ASCII values of the common function keys; for
others, see the IBM Basic manual or the "IBM PS/2 and PC BIOS Inter-
face Technical Reference," a steal at $80 from IBM (1-800-IBM-PCTB).
F1 0;59 F2 0;60 F3 0;61 F4 0;62
F5 0;63 F6 0;64 F7 0;65 F8 0;66
F9 0;67 F10 0;68 F11 0;133 F12 0;134
HOME 0;71 END 0;79 PGUP 0;73 PGDN 0;81
INS 0;82 DEL 0;83 LEFT 0;75 RIGHT 0;77
UP 0;72 DOWN 0;80
When /X is given, the gray Insert, Delete, Home, End, PageUp, PageDn,
and arrow keys on an Extended keyboard can be redefined separately by
using 224 rather than 0 as the initial byte.
7.3.2. SGR: ESC[#;#;...#m Set Graphics Rendition
The Set Graphics Rendition command is used to select foreground and
background colors or attributes. When you use multiple parameters,
they are executed in sequence, and the effects are cumulative.
Attrib Value
0 All attributes off (normal white on black)
1 Bold
4 Underline
5 Blink
7 Reverse Video
30-37 foreground black/red/green/yellow/blue/magenta/cyan/white
40-47 background black/red/green/yellow/blue/magenta/cyan/white
November 29, 1991
- 10 -
7.3.3. SM: ESC[=nh Set Video Mode
This sequence selects one of the available video modes. The IBM BIOS
supports several video modes; the codes given in the BIOS documenta-
tion are used as parameters to the Set Mode command. (In bitmap
modes, the cursor is simulated with a small blob (^V).)
Mode Code Value
0 text 40x25 Black & White
1 text 40x25 Color
2 text 80x25 Black & White
3 text 80x25 Color
4 bitmap 320x200 4 bits/pixel
5 bitmap 320x200 1 bit/pixel
6 bitmap 640x200 1 bit/pixel
13 bitmap 320x200 4 bits/pixel
14 bitmap 640x200 4 bits/pixel
15 bitmap 640x350 1 bit/pixel
16 bitmap 640x350 4 bits/pixel
17 bitmap 640x480 1 bit/pixel
18 bitmap 640x480 4 bits/pixel
19 bitmap 320x200 8 bits/pixel
Modes 0, 1, and 4-19 require a CGA, EGA or VGA.
Modes 13-16 require an EGA or VGA.
Modes 17-19 require a VGA.
Other graphics cards may support other video modes.
The EGA and VGA let you use a shorter character cell in text modes in
order to squeeze more lines of text out of the 25-line text modes. To
enter short line mode, set the desired 25-line text mode (0 to 3),
then Set Mode 43. For instance: ESC[=3h ESC[=43h. To exit short line
mode, set the desired 25-line text mode again. On IBM VGA cards, this
sequence gives you a 50 line screen. NANSI.SYS ignores mode 43 unless
there is an EGA or VGA on your computer.
November 29, 1991
- 11 -
7.3.4. SM: ESC[?nh Set Nonvideo Mode
This sequence is used to set non-video modes. The only value sup-
ported is
Mode Code Value when set
7 Cursor wraps at end of line
Setting mode 7 tells the cursor to wrap around to the next line when
it passes the end of a line.
7.3.5. RM: ESC[?nl Reset Nonvideo Mode
This sequence is used to reset non-video modes. The only value sup-
ported is
Mode Code Value when reset
7 Cursor stops at end of line
Resetting mode 7 tells the cursor to 'stick' at the end of the line
instead of wrapping to the next line.
November 29, 1991
- 12 -
8. Background - What does a console driver do, and how?
A console driver consists of subroutines which are called by MS-DOS.
MS-DOS itself is mostly just subroutines which can be called by appli-
cation programs.
Programs that want to display text on the screen can call the "Write"
subroutine provided by MS-DOS. This subroutine in turn calls the
"Write" subroutine of the console driver.
When you, for example, type
C> type foo.txt
COMMAND.COM uses the "Read" subroutine of MS-DOS to read the file
"foo.txt" from the disk; it then uses the "Write" subroutine of MS-DOS
with the file's contents. MS-DOS then calls the console driver's
"Write" subroutine, which finally puts the data up on the screen.
Both ANSI.SYS and NANSI.SYS use IBM Video BIOS to control the screen.
However, NANSI.SYS writes directly to the screen in text modes; this
allows much faster operation.
9. How to Display Text Quickly
Output to the screen via DOS is usually slow because characters are
sent one-at-a-time through several layers of software. Application
programs often call a DOS function for each character or line.
To avoid this overhead, application programs should write as many
characters per DOS call as possible (in C programs, this means using
setbuf(), fflush(), and buffered output).
Another problem is that application programs sometimes send line after
line of text, letting the cursor stay at the bottom of the screen.
This forces the console driver to scroll the entire screen up once for
each line displayed, which is rather expensive.
This can be fixed by having the application program clear the screen
and home the cursor after each page of output.
Finally, the biggest problem is that DOS calls the device driver once
or twice for each character written.
Fortunately, DOS can be told to pass the entire write request directly
to the device driver; this is called "raw" mode. The files RAW.C and
RAW.H, included in this package, provide an easy way to set and clear
"raw" mode, to turn break checking on and off, and to check for keys-
trokes when in raw mode.
Even if you follow all these rules, output with ANSI.SYS will still be
very slow, simply because IBM did a bad job designing BIOS, and
because ANSI.SYS was written with total disregard for performance.
NANSI.SYS, on the other hand, was written by a performance fanatic.
November 29, 1991
- 13 -
10. NANSI and Microsoft Windows
Microsoft Windows 1.x and 2.x allowed you to run command.com in a win-
dow, but did not give you access to NANSI.SYS. Windows 3.0 gives you
full access to NANSI.SYS, even when running command.com in a window
(wow!). However, you can only do this if you have a 386-based com-
puter (boo, hiss); on other computers, Windows runs command.com only
in full screen mode.
Under Microsoft Windows 3.0, if you write text to stdout in RAW mode,
the display is not refreshed until the end of the write; no intermedi-
ate scrolling is shown. I suspect this is because Windows doesn't
refresh the display until display memory hasn't been touched for a few
milliseconds.
11. New in version 3.3 of NANSI.SYS
Fixed bug that caused erratic behavior after ESC[p. Bug was present
in all prior versions of NANSI.
Fixed a few typos in documentation.
12. New in version 3.2 of NANSI.SYS
Can finally read F11 and F12!
New /K command-line option forces Nansi to use Extended Keyboard BIOS
calls if for some reason Nansi doesn't recognize the extended key-
board.
New /X command-line option lets user redefine "new" cursor motion keys
independently of "old" cursor motion keys.
Both of these switches are compatible with the switches of the same
name in ANSI.SYS.
13. New in version 3.1 of NANSI.SYS
A new escape sequence has been added to enable and disable the simu-
lated cursor in graphics mode (see SET MODE 99). The graphics cursor
is disabled by default.
Nansi can now sense options given on the DEVICE=NANSI.SYS line in
config.sys.
/S command-line option has been added to disable the keyboard redefin-
ition escape sequence. This closes up a big security loophole.
/T command-line option has been added to allow the user to tell Nansi
about nonstandard text video modes (see COMMAND-LINE OPTIONS). This
is important if you want to use non-IBM text modes properly, as Nansi
treats nonstandard modes as graphics by default, which results in
slower display.
November 29, 1991
- 14 -
14. New in version 3.0 of NANSI.SYS
Now obeys BIOS's idea of number of screen lines, when supported.
Works properly when on video pages greater than zero, too.
Supports 132-column displays.
Deleted Output Character Translation feature. It took up 260 bytes,
and nobody ever used it.
Fixed bug related to setting background color while in graphics mode.
No longer assumes AH is zero upon entry to driver.
November 29, 1991
- 15 -
15. Limitations in the current version of NANSI.SYS
Video modes are specified in hexadecimal on the command line, and in
decimal in escape sequences. This is a needless inconsistancy, but
since users' manuals usually specify the mode numbers in hex, it
shouldn't be too big a bother. You can convert a hexadecimal number
to decimal in BASIC with the print command. For example, from the DOS
prompt, typing
C:>basic
print &h7f
system
displays "127".
All parameter values must be between 0 and 255.
The maximum number of characters available for keyboard redefinition
is 500. Any single keyboard redefinition escape sequence must be
shorter than (500 - (total keyboard redefinition space already used))
bytes.
Insert and delete character do not work in graphics modes.
Graphics mode writing is slow. If this bothers you, try NNANSI, which
is someone else's modification of NANSI v2.2 to attack just this prob-
lem.
Does not support erase-to-end-of-screen and other useful functions.
Nansi determines whether the BIOS number-of-screen-lines variable is
supported by checking for an EGA card. There might be a better way.
Nansi only checks for an EGA or VGA card at startup time. If you have
two video cards installed, and one shows more text lines per screen
than the other, AND you switch between the cards without rebooting,
Nansi could conceivably become confused about the number of text lines
on the screen.
November 29, 1991

BIN
screenshots/86_dos_logo.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 91 KiB

BIN
screenshots/concurrent_logo.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 84 KiB

BIN
screenshots/dosbian_logo.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 96 KiB

BIN
screenshots/dosbox-staging.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1 MiB

BIN
screenshots/dosbox-x.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 414 KiB

BIN
screenshots/dosbox.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 198 KiB

BIN
screenshots/dosv.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 116 KiB

BIN
screenshots/dosv_noansi.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 92 KiB

BIN
screenshots/drdos.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
screenshots/freedos.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 99 KiB

BIN
screenshots/ibmpcdos.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 92 KiB

BIN
screenshots/msdos.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 80 KiB

BIN
screenshots/msdos_noansi.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
screenshots/novelldos.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 93 KiB

1018
src/detect.c Normal file
View file

File diff suppressed because it is too large Load diff

293
src/logos_data.inc Normal file
View file

@ -0,0 +1,293 @@
/* Auto-generated by tools/generate_logos_data.py. Do not edit. */
static const char *const logo_86_dos[] = {
"\x1b[0m",
" \x1b[1m\xdc\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1m\xdc\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdf\x1b[0m \x1b[1m\xdf\xdf\x1b[0m",
" \x1b[1m\xdf\xdb\xdb\xdc\xdc\xdc\xdb\xdf\x1b[0m \x1b[1m\xdc\xdb\xdb\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\xdc\x1b[0m \x1b[1m\xdb\xdb\xdb\xdf\xdf\xdf\xdb\xdb\xdc\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m",
" \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m",
" \x1b[1m\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdb\xdf\x1b[0m",
" \x1b[1m\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0m",
"",
" \x1b[1m\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdc\xdb\xdb\xdb\xdb\xdc\xdc\x1b[0m \x1b[1m\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[30m\xb0\x1b[37m",
" \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1m\xdb\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdf\xdb\xdb\x1b[0m \x1b[30m\xb0\x1b[37m",
" \x1b[1m\xdb\xdb\xdf\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdb\xdf\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdc\xdc\x1b[0m \x1b[30m\xb0\x1b[37m",
" \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1m\xdc\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdb\xdb\x1b[0m \x1b[1m\xdc\xdc\x1b[0m \x1b[1m\xdf\xdb\xdb\x1b[0m",
" \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdc\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdc\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdc\x1b[0m \x1b[1m\xdc\xdb\xdb\x1b[0m",
" \x1b[1m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\x1b[0m \x1b[1m\xdf\xdf\xdb\xdb\xdb\xdb\xdf\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0m",
"",
" \x1b[1m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdc\xdc\x1b[0m \x1b[1m\xdc\x1b[0m \x1b[1m\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m",
" \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\xdc\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1m\xdf\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdf\x1b[0m",
NULL,
};
static const char *const logo_concurrentdos[] = {
"\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\x1b[0m",
" \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\x1b[0m \x1b[1;34m\xdc\x1b[0m \x1b[1;34m\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdb\xdf\x1b[0m",
" \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdc\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\xdc\xdf\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m",
" \x1b[1;34m\xdf\xdf\xdf\x1b[0m \x1b[1;34m\xdf\xdf\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\xdf\xdf\x1b[0m \x1b[1;34m\xdf\xdf\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\xdf\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\x1b[0m \x1b[1;34m\xdf\xdf\x1b[0m",
" \x1b[1m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[37m \x1b[30m\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[30m\xdc\x1b[37m \x1b[1m\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[1m\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m",
" \x1b[1m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[37m \x1b[1m\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\x1b[0;30m\xdc\x1b[37m \x1b[30m\xdc\x1b[1;37m\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[1m\xdc\xdc\xdc\x1b[0m",
" \x1b[1m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\xdc\xdc\x1b[37m \x1b[30m\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0;30m\xdc\xdc\x1b[37m \x1b[30m\xdc\xdc\xdc\x1b[1;37m\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[30m\xdc\x1b[37m",
NULL,
};
static const char *const logo_dos[] = {
"\x1b[0m",
"",
"",
"\x1b[30m\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[1m \x1b[0;30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[30m\xdb\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[30m\xdb\x1b[1;35m\xdc\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[33m\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0;30m\xdb\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb2\x1b[35m\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdf\x1b[33m\xdb\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[30m\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\xdb\xdb\x1b[1;35m\xdb\xdb\xdb\xdb\x1b[0;31m\xdb\x1b[37m \x1b[1;33m\xdb\xdb\xdb\x1b[0;35m\xdb\x1b[1m\xb2\xb2\xb2\x1b[0m \x1b[1;33m\xdb\xdb\xdb\x1b[0;30m\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\x1b[1;35m\xdb\xdb\xdb\x1b[0;31m\xdf\xdb\xdb\x1b[1m\xb2\x1b[0;30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;33m\xdb\xdb\xdb\x1b[0m \x1b[1;35m\xdb\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\x1b[1;35m\xdb\xdb\xdb\x1b[0;30m\xdb\x1b[1;31m\xb2\xb2\xb2\x1b[0m \x1b[30m\xdb\x1b[37m \x1b[1;33m\xdb\xdb\xdb\xdb\x1b[35m\xdb\xdb\xdb\x1b[0;33m\xdb\x1b[1m\xb2\xdc\x1b[0m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\xdb\x1b[1;35m\xdb\xdb\xdb\x1b[0;30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[1;33m\xdf\xdf\x1b[35m\xdb\xdb\xdb\x1b[0;33m\xdb\x1b[1m\xb2\xdb\xdb\xdb\x1b[0m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\xdb\x1b[1;35m\xdb\xdb\xb2\x1b[31m\xdc\xdb\xdb\xdb\x1b[0;30m\xdb\x1b[37m \x1b[30m\xdb\xdb\x1b[1;35m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\x1b[1;33m\xdf\xdb\xdb\xdb\x1b[0;30m\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\x1b[0m \x1b[30m\xdb\xdb\xdb\x1b[1;35m\xb2\x1b[31m\xdb\xdb\xdb\xdb\x1b[0;30m\xdb\x1b[37m \x1b[1;33m\xdb\xdb\xdb\xdc\x1b[35m\xb2\xdb\xdb\x1b[0m \x1b[1;33m\xdb\xdb\xdb\x1b[0;30m\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0;35m\xdb\xdb\x1b[1m\xdc\xdc\xdc\xdc\xdc\xdb\x1b[33m\xdb\xdb\xdb\xdb\xdc\xdc\xdc\xdc\xdb\xdb\xdb\xdb\xdf\x1b[0m \x1b[30m\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0m \x1b[35m\xdf\xdf\x1b[1m\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\x1b[33m\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0;30m\xdb\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[30m\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m \x1b[30m\xdb\xdb\xdb\xdb\x1b[37m",
"\x1b[30m\xdb\x1b[37m",
"",
NULL,
};
static const char *const logo_dosbian[] = {
"\x1b[0m",
" \x1b[1;30m\xdc\x1b[0;30m\xdb\x1b[1m\xdc\xdc\x1b[0m\xb2\xb2\xdb\xdb\xdb\xdb\xb2\xb2\xb2\xb2\xb2\xb2\xdb\xdb\xdb\x1b[1;30m\xdc\xdc\x1b[0;30m\xdb\x1b[37m",
" \x1b[1;30m\xdb\xdb\xdb\xdb\x1b[0m\xb2\xb2\xb2\xb2\xdb\xdb\xdb\xdb\xb2\xb2\xb2\x1b[1;30m\xdb\xdb\xdb\x1b[0m\xdb\x1b[1;30m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;30m\xdb\xdb\xdb\xdb\x1b[0m\xb2\xb2\xb2\xb2\xb2\xdb\xdb\xdb\xdb\xb2\xb2\x1b[1;30m\xdb\xdb\xdb\x1b[0m\xdb\x1b[1;30m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;30m\xdb\xdb\xdb\xdb\x1b[0m\xb2\xb2\xb2\xb2\xb2\xb2\xdb\xdb\xdb\xdb\xb2\xb2\xb2\xb2\xb2\x1b[1;30m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0m",
" \x1b[1;30m\xdb\x1b[33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[30m\xdb\x1b[0m",
" \x1b[1;30m\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[30m\xdb\x1b[0m",
" \x1b[1;30m\xdb\x1b[37m\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\x1b[30m\xdb\x1b[0m",
" \x1b[1;30m\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[30m\xdb\x1b[0m \x1b[30m\xdb\x1b[37m",
" \x1b[1;30m\xdb\x1b[37m\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\x1b[30m\xdb\x1b[0m \x1b[30m\xdb\x1b[37m",
" \x1b[1;30m\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[30m\xdb\x1b[0m \x1b[30m\xdb\x1b[37m",
" \x1b[30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[30m\xdb\xdb\xdb\x1b[37m \x1b[30m\xdb\x1b[37m",
" \x1b[1;34m\xdc\xdc\xdc\xdc\x1b[0m \x1b[30m\xdb\xdb\xdb\x1b[1;34m\xdc\xdc\x1b[0;30m\xdb\xdb\xdb\x1b[37m \x1b[1;34m\xdc\x1b[0;30m\xdb\xdb\xdb\xdb\x1b[37m",
" \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\xdc\x1b[0m \x1b[1;34m\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdb\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[0m \x1b[1;34m\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdf\xdb\xdc\xdc\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdf\xdb\x1b[0m \x1b[1;34m\xdf\xdb\x1b[0m \x1b[1;34m\xdc\xdc\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m",
" \x1b[1;34m\xdc\xdb\xdc\xdc\xdf\x1b[0m \x1b[1;34m\xdf\xdc\xdc\xdf\x1b[0m \x1b[1;34m\xdc\xdc\xdb\xdf\x1b[0m \x1b[1;34m\xdb\xdc\xdc\xdf\x1b[0m \x1b[1;34m\xdc\xdb\x1b[0m \x1b[1;34m\xdf\xdc\xdc\xdb\xdc\x1b[0m \x1b[1;34m\xdb\x1b[0m \x1b[1;34m\xdb\x1b[0m",
"",
" \x1b[1;30mby Carmelo Maiolino\x1b[0m",
NULL,
};
static const char *const logo_dosbox[] = {
"\x1b[0m",
" \x1b[33m\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\x1b[1m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xdb\xdb\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\x1b[1m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xdb\xdb\xdb\xb1\xb1\xdb\xdb\xdb\xb1\xb0\xb0\xb0\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xb0\xb0\xb0\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xdb\xdb\x1b[0;33m\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xdb\xdb\xdb\xb1\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb0\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xb0\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xdb\xdb\xdb\xb1\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xdb\xdb\xdb\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xb0\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xb0\xb1\xb1\xb1\xb1\xdb\xdb\xb1\xb1\xb1\xb1\xdb\xdb\xdb\x1b[0;33m\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\x1b[1m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\x1b[1m\xb0\xb0\xb0\xb0\xb0\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xdb\xdb\xdb\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb0\xb0\xb0\xb0\xb0\xb0\x1b[0;33m\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb1\xdb\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\x1b[1m\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb0\xb0\x1b[1m\xdb\xdb\xdb\x1b[0;33m\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb2\xb1\x1b[37m",
" \x1b[33m\xb2\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb1\xb2\x1b[37m",
NULL,
};
static const char *const logo_dosbox_staging[] = {
"\x1b[0m \x1b[1;34m\xdc\xdc\xdc\x1b[37m\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1;34m\xdc\xdc\xdc\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1;34m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1;34m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdc\x1b[0m \x1b[1m\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\x1b[0m",
" \x1b[1;34m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdc\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdc\xdc\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1;34m\xdb\xdb\xdb\xdb\x1b[32m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdb\x1b[0m",
" \x1b[1;32m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdc\x1b[0m \x1b[1m\xdf\xdb\xdb\x1b[0m",
" \x1b[1;32m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1;32m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1;32m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdb\xdb\x1b[0m \x1b[1m\xdc\xdb\xdc\x1b[0m \x1b[1m\xdc\xdb\x1b[0m",
" \x1b[1;33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0m",
" \x1b[1;33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdb\xdf\x1b[0m \x1b[1m\xdc\xdc\x1b[0m \x1b[1m\xdf\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1;33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m",
" \x1b[1;33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\xdb\xdb\x1b[33m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdf\x1b[0m \x1b[1m\xdf\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdf\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdc\xdc\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdf\xdc\xdb\x1b[0m \x1b[1m\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\xdf\xdc\xdb\xdb\xdb\x1b[0m \x1b[1m\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdf\xdf\xdf\x1b[0m \x1b[1m\xdb\xdc\x1b[0m \x1b[1m\xdf\xdf\x1b[0m \x1b[1m\xdc\xdb\xdc\xdb\xdb\xdb\xdb\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdf\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\x1b[0m \x1b[1m\xdc\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdf\xdb\xdb\xdb\xdb\x1b[37m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdf\x1b[0m",
" \x1b[1;31m\xdf\x1b[37m\xdf\xdf\xdf\x1b[0m",
NULL,
};
static const char *const logo_dosbox_x[] = {
"\x1b[0m \x1b[1;31m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[1;30m\xdc\x1b[0m \x1b[1;31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\x1b[0m",
" \x1b[1;30m\xdc\xdb\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xb2\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;31m\xdb\xdb\xdb\xdb\x1b[0m \x1b[1;31m\xb2\xb2\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdf\xdb\x1b[0m \x1b[1;31m\xdb\xdb\xdb\xb2\x1b[0m \x1b[1;31m\xb2\xb2\xb2\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdb\xdc\x1b[0m \x1b[1;31m\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xdc\xdc\xdc\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;31m\xdf\xb2\xb2\xb2\xb2\xb2\xdf\xdf\xdf\x1b[0m \x1b[1;32m\xdc\xdc\x1b[0m \x1b[1;32m\xdb\xdb\xdb\xb2\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;31m\xdf\xdf\x1b[0m \x1b[1;35m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;32m\xdb\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;32m\xdb\xdb\xb2\xb2\x1b[0m",
" \x1b[1;34m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;35m\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\x1b[0m \x1b[1;32m\xdf\xdb\xdb\xdb\xdb\xdc\xdb\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdc\x1b[0m \x1b[1;34m\xdc\xdb\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdb\xb2\xdc\x1b[0m \x1b[1;35m\xdc\xdb\xdb\xdb\x1b[0m \x1b[1;35m\xdf\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xdf\xdb\xdb\xdb\xb2\xb2\xb2\xdc\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;34m\xdb\xdb\xdc\x1b[0m \x1b[1;34m\xdc\xb2\xb2\x1b[0m \x1b[1;35m\xdb\xdb\xdb\x1b[0m \x1b[1;35m\xb2\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xb2\xb2\xb2\xdf\xb2\xb2\xb2\xb2\xdc\x1b[0m",
" \x1b[1;30m\xdb\xdf\x1b[0m \x1b[1;34m\xdf\xdb\xdb\xdc\xdc\xdb\xb2\xb2\xb2\xb2\xb2\xb2\x1b[0m \x1b[1;35m\xdf\xdb\xdb\xb2\x1b[0m \x1b[1;35m\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xb2\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xdf\xb2\xb2\xdf\x1b[0m",
" \x1b[1;30m\xdb\xdc\x1b[0m \x1b[1;34m\xdb\xdb\xdb\xdf\xdf\x1b[0m \x1b[1;34m\xdf\xb2\xb2\xb2\x1b[0m \x1b[1;35m\xdf\xb2\xb2\xb2\xdc\xdc\xdc\xb2\xb2\xb2\x1b[0m \x1b[1;32m\xb2\xb2\xb2\xdf\x1b[0m \x1b[1;30m\xdb\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;34m\xdb\xb2\xdc\x1b[0m \x1b[1;34m\xdc\xb2\xb2\xb2\x1b[0m \x1b[1;35m\xdf\xdf\xb2\xb2\xb2\xb2\xb2\xdf\x1b[0m \x1b[1;30m\xdb\xdb\xdc\xdc\xdc\xdb\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdb\x1b[0m \x1b[1;34m\xdf\xb2\xb2\xdc\xdc\xb2\xb2\xb2\xb2\xdf\x1b[0m \x1b[1;33m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;30m\xdc\xdc\xdc\xdb\xdf\x1b[0m",
" \x1b[1;30m\xdb\xdc\x1b[0m \x1b[1;34m\xb2\xb2\xb2\xb2\xdf\xdf\x1b[0m \x1b[1;30m\xdc\x1b[0m \x1b[1;33m\xdc\xdb\xdb\xdb\xdf\xdf\xb2\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[30m\xdb\xdb\x1b[37m \x1b[1;30m\xdc\xdc\xdc\xdb\xdf\x1b[0m \x1b[1;33m\xdb\xdb\xdb\x1b[0m",
" \x1b[1;30m\xdf\xdb\x1b[0m \x1b[1;30m\xdc\xdc\xdc\xdb\xdf\xdf\xdf\x1b[0m \x1b[1;30m\xdf\xdb\x1b[0m \x1b[1;33m\xdf\xdb\xdb\xb2\xb2\xb2\xb2\xb2\xdc\xdc\x1b[0m",
" \x1b[1;30m\xdf\xdf\xdf\xdf\x1b[0m \x1b[30m\xdb\x1b[37m \x1b[1;30m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1;33m\xdf\xdf\xdf\xdf\xdf\xb2\xb2\xb2\x1b[0m",
" \x1b[30m\xdb\xdb\x1b[37m \x1b[1;30m\xdb\xdf\x1b[0m \x1b[1;33m\xdc\xdc\xdc\x1b[0m \x1b[1;33m\xdc\xb2\xb2\xb2\x1b[0m",
" \x1b[1;30m\xdb\x1b[0m \x1b[1;33m\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xdf\x1b[0m",
" \x1b[1;30m\xdb\xdc\x1b[0m \x1b[1;33m\xdf\xdf\xdf\xdf\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdf\xdb\xdc\xdc\xdc\xdc\xdc\xdc\xdb\xdf\xdf\x1b[0m",
NULL,
};
static const char *const logo_dr_dos[] = {
"\x1b[0m",
" \x1b[1;34m\xdc\xdc\xdc\x1b[0m",
" \x1b[1;34m\xdb\xdb\xdb\x1b[0m \x1b[1;30mDigital\x1b[0m \x1b[1;30mResearch\x1b[0m",
"",
" \x1b[1;31m\xdf\xdf\xdb\xdb\xdf\xdf\xdb\xdc\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdf\xdf\xdf\xdf\xdf\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\xdc\xdc\xdc\xdc\xdc\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdc\xdb\xdb\xdc\xdc\xdc\xdb\xdf\xdf\x1b[0m \x1b[1;31m\xdc\xdb\xdb\xdc\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\xdc\x1b[0m",
"",
" \x1b[1;31m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;31m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;31m\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;31m\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdc\xdb\xdb\xdf\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdc\xdb\xdb\xdf\x1b[0m \x1b[1;31m\xdf\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdf\xdb\xdb\xdb\xdc\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdf\xdf\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdc\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdc\xdc\x1b[0m \x1b[1;31m\xdb\xdb\x1b[0m",
" \x1b[1;31m\xdb\xdb\x1b[0m \x1b[1;31m\xdc\xdc\xdb\xdb\xdf\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdc\xdb\xdb\xdf\x1b[0m \x1b[1;31m\xdb\xdf\xdb\xdc\xdc\x1b[0m \x1b[1;31m\xdc\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdf\xdf\xdf\xdf\xdf\x1b[0m \x1b[1;31m\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\x1b[0m \x1b[1;31m\xdf\x1b[0m \x1b[1;31m\xdf\xdf\xdf\xdf\x1b[0m",
NULL,
};
static const char *const logo_freedos[] = {
"\x1b[0m",
" \x1b[30m\xdb\x1b[37m",
" \x1b[36m\xb1\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb1\xb1\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xb2\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb1\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\x1b[1;37;46m\xdc\x1b[40m\xdb\xdb\xdb\xdb\x1b[46m\xdc\x1b[0;36m\xdb\xdb\xdb\xdb\x1b[1;37;46m\xdc\xdc\xdc\x1b[0;36m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb1\x1b[37m \x1b[36m\xdc\xdc\xb2\xb2\xdc\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\x1b[1;37m\xdb\x1b[0m \x1b[1m\xdb\x1b[0;36m\xdb\xdb\xdb\x1b[1;37m\xdb\xdf\xdf\xdf\xdb\x1b[0;36m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\xb2\xb2\xb2\xb2\xdf\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\x1b[1;37m\xdb\x1b[30m\xb1\x1b[0m \x1b[1m\xdf\xdb\x1b[0;36m\xdb\xdb\xdb\x1b[1;37m\xdb\x1b[30m\xb1\x1b[0m \x1b[1m\xdf\xdb\x1b[0;36m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb2\xb2\xb2\xb2\x1b[37m",
" \x1b[36m\xb1\xb2\xdb\xdb\x1b[1;37;46m\xdf\xdf\xdf\xdf\x1b[0;36m\xdb\xdb\xdb\xdb\xdb\x1b[1;37;46m\xdf\xdf\xdf\x1b[0;36m\xdb\xdb\xdb\xdb\xb2\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\xb2\xb2\x1b[37m",
" \x1b[30m\xdb\x1b[36m\xb1\xdf\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\xb1\xb2\xdb\xdb\xdb\xdb\xdb\xb2\xb1\xb2\xb2\xb2\xdc\x1b[37m",
" \x1b[30m\xdb\xdb\xdb\x1b[36m\xb2\xdc\x1b[37m \x1b[30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[36m\xdc\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb2\xb1\x1b[30m\xdb\xdb\x1b[36m\xb2\xb2\xb2\xdc\x1b[37m",
" \x1b[30m\xdb\xdb\xdb\x1b[36m\xb2\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xb1\x1b[30m\xdb\xdb\xdb\x1b[37m \x1b[36m\xdf\xdf\xdf\x1b[37m",
" \x1b[30m\xdb\xdb\x1b[37m \x1b[36m\xb0\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb2\xb1\xb1\xdb\xdb\xdb\xdb\x1b[37m \x1b[30m\xdb\xdb\x1b[37m",
" \x1b[30m\xdb\xdb\x1b[37m \x1b[36m\xb1\xb0\xb0\x1b[30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[36m\xdf\xdb\xdb\xdb\x1b[37m",
" \x1b[30m\xdb\x1b[37m \x1b[36m\xb2\xb1\x1b[30m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[36m\xdb\xdb\x1b[37m",
" \x1b[30m\xdb\x1b[37m \x1b[30m\xdb\xdb\x1b[37m",
NULL,
};
static const char *const logo_ms_dos[] = {
"\x1b[0m",
" \x1b[34m\xdb\xdb\xdb\xdb\xdc\x1b[37m \x1b[34m\xdc\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdc\xdc\xdb\xdb\xdb\xdb\xdb\xdb\xdc\xdc\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdc\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\xdb\xdb\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\xdb\xdb\xdb\xdc\x1b[37m \x1b[34m\xdc\xdb\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdf\xdb\xdb\xdb\xdb\xdc\xdc\x1b[37m \x1b[30m\xdb\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdf\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdc\xdc\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdf\xdf\xdf\xdb\xdb\xdb\xdb\xdc\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdc\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdc\xdc\xdc\xdc\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdb\xdb\xdb\xdb\xdc\x1b[37m \x1b[34m\xdc\xdb\xdb\xdb\xdb\x1b[37m",
" \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdf\xdb\xdb\xdb\xdf\x1b[37m \x1b[34m\xdb\xdb\xdb\x1b[37m \x1b[34m\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[37m",
" \x1b[34m\xdf\xdf\xdf\x1b[37m \x1b[34m\xdf\xdf\xdf\x1b[37m \x1b[34m\xdf\xdf\xdf\x1b[37m \x1b[34m\xdf\xdf\xdf\xdf\xdf\xdf\x1b[37m",
" \x1b[31m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[37m \x1b[35m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[37m \x1b[1;33m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\x1b[35;41m\xdc\x1b[40m\xdb\xdb\xdb\xdb\xdf\xdf\xdf\xdf\xdb\xdb\x1b[1;33m\xdb\xdb\xdb\x1b[45m\xdf\x1b[40m\xdf\xdf\xdf\xdf\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[35m\xdc\xdb\xdb\x1b[41m\xdf\x1b[31;40m\xdb\xdc\x1b[37m \x1b[1;33m\xdb\xdb\xdf\x1b[0;35m\xdb\xdb\xdc\x1b[37m \x1b[1;33m\xdf\xdf\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[35m\xdb\xdb\xdb\x1b[31m\xdf\xdb\xdb\xdb\x1b[37m \x1b[1;33m\xdb\xdb\xdc\x1b[0;35m\xdb\xdb\xdb\x1b[37m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[35m\xdb\xdb\xdb\x1b[37m \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[1;33m\xdf\xdb\x1b[0;35m\xdb\xdb\xdb\x1b[1;33m\xdb\xdb\xdc\xdc\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[35m\xdb\xdb\xdb\x1b[31m\xdc\xdb\xdb\xdb\x1b[37m \x1b[35m\xdb\xdb\xdb\x1b[1;33m\xdf\xdf\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[35m\xdb\xdb\x1b[41m\xdf\x1b[31;40m\xdb\xdb\xdb\xdf\x1b[37m \x1b[1;33m\xdb\xdb\x1b[0m \x1b[35m\xdb\xdb\xdb\x1b[37m \x1b[1;33m\xdb\xdb\xdb\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\x1b[37m \x1b[31m\xdc\xdc\xdb\xdb\xdb\x1b[45m\xdf\x1b[35;40m\xdc\x1b[37m \x1b[35m\xdc\x1b[1;33;45m\xdf\x1b[40m\xdb\xdb\x1b[45m\xdc\xdc\x1b[0m \x1b[1;33m\xdc\xdb\xdb\xdf\x1b[0m",
" \x1b[31m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\x1b[35m\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\x1b[1;33m\xdf\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdf\xdf\x1b[0m",
NULL,
};
static const char *const logo_novell_dos[] = {
"\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdf\xdf\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;31m\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdf\x1b[0m \x1b[1;31m\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\x1b[0m \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\x1b[0m \x1b[1;31m\xdc\xdb\xdc\x1b[0m \x1b[1;31m\xdf\x1b[0m \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdf\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdf\xdf\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdb\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;31m\xdc\x1b[0m \x1b[1;31m\xdf\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\x1b[0m \x1b[1;30m\xdb\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdc\x1b[0m \x1b[1;31m\xdf\xdf\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\xdf\xdf\xdb\xdc\x1b[0m",
" \x1b[1;31m\xdc\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\xdb\xdf\x1b[0m \x1b[1;30m\xdf\xdb\xdc\xdc\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdb\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdb\xdb\xdb\x1b[0m",
"\x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdf\x1b[0m \x1b[1;31m\xdb\xdb\xdf\x1b[0m \x1b[1m\xdc\x1b[0m \x1b[1;30m\xdf\xdb\xdb\x1b[0m \x1b[1;30m\xdf\x1b[0m \x1b[1;30m\xdc\xdf\xdf\xdb\x1b[0m \x1b[1;30m\xdb\xdc\xdb\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdc\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdb\xdb\xdf\x1b[0m \x1b[1m\xdc\xdb\xdb\xdb\xdc\x1b[0m \x1b[1;30m\xdf\xdb\xdb\xdb\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdb\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdf\xdb\xdb\xdc\xdc\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1;30m\xdf\xdb\xdc\xdc\xdc\xdb\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdb\xdc\x1b[0m \x1b[1;31m\xdb\xdb\xdf\x1b[0m \x1b[1m\xdf\xdb\xdb\xdc\x1b[0m \x1b[1;30m\xdf\xdb\xdb\xdf\x1b[0m",
" \x1b[1;31m\xdf\xdb\xdf\x1b[0m \x1b[1m\xdc\xdb\xdb\xdf\x1b[0m \x1b[1;30m\xdc\x1b[0m",
" \x1b[1;30m\xdc\x1b[0m \x1b[1m\xdf\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdb\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\xdf\x1b[0m",
NULL,
};
static const char *const logo_pc_dos[] = {
"\x1b[0m \x1b[1;30m\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdc\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdf\xdf\xdf\x1b[0m \x1b[1m\xdf\xdf\xdf\xdc\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;35m\xdc\xdc\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;35m\xdb\xdf\x1b[0m \x1b[1;35m\xdf\xdb\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;32m\xdc\xdc\xdc\x1b[0m \x1b[1;35m\xdf\xdb\xdc\xdc\xdc\xdc\xdc\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;32m\xdb\xdf\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;35m\xdf\xdf\xdf\xdf\xdf\xdb\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
" \x1b[1;30m\xdc\xdf\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;33m\xdc\xdc\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;35m\xdc\xdc\x1b[0m \x1b[1;35m\xdf\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;30m\xdf\xdc\x1b[0m",
"\x1b[1;30m\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;33m\xdc\xdb\xdf\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;35m\xdf\xdb\xdb\xdf\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;30m\xdb\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;32m\xdf\xdb\xdc\xdb\xdf\x1b[0m \x1b[1m\xdb\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;33m\xdf\xdb\xdc\x1b[0m \x1b[1;33m\xdf\xdb\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;33m\xdf\xdb\xdc\xdb\xdf\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdf\xdc\x1b[0m \x1b[1;33m\xdf\x1b[0m \x1b[1m\xdc\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1m\xdf\xdf\xdf\xdc\xdc\xdc\xdc\xdc\xdc\xdc\xdf\xdf\xdf\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\xdc\x1b[0m \x1b[1;30m\xdc\xdf\x1b[0m",
" \x1b[1;30m\xdf\x1b[0m",
NULL,
};

124
src/main.c Normal file
View file

@ -0,0 +1,124 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <dos.h>
#include <conio.h>
#if defined(__WATCOMC__)
#include <process.h>
#endif
#include "pastfetch.h"
#if defined(__WATCOMC__)
extern unsigned char _nullarea[32];
static void reset_null_sentinel(void) {
// Restore the Watcom null-pointer guard pattern so spurious NULL reports clear
memset(_nullarea, 0x01, sizeof(_nullarea));
}
#endif
static void safe_exit(int code, int hard_exit) {
// Flush output, clear null sentinel, and terminate.
fflush(NULL);
#if defined(__WATCOMC__)
reset_null_sentinel();
#endif
if (hard_exit) {
_exit(code);
} else {
exit(code);
}
}
//Check for a Ctrl+Q keypress in the BIOS buffer to force a fast exit
static int force_quit_requested(void) {
if (!kbhit()) {
return 0;
}
{
int ch = getch();
if (ch == 0 || ch == 0xE0) {
int scan = getch();
return scan == 0x10; // Ctrl+Q scan code
}
return ch == 0x11; // Ctrl+Q ASCII
}
}
// Parse command-line options into RunOptions
static void parse_args(int argc, char **argv, RunOptions *options) {
int i;
memset(options, 0, sizeof(*options));
// Default to fast exit to avoid stuck prompts on IBM PC DOS and Novell
// but only sometimes????
options->hard_exit = 1;
for (i = 1; i < argc; ++i) {
if (str_equals_ci(argv[i], "/nologo") || strcmp(argv[i], "--no-logo") == 0) {
options->no_logo = 1;
} else if (str_equals_ci(argv[i], "/list") || strcmp(argv[i], "--list") == 0) {
options->list_only = 1;
} else if (str_equals_ci(argv[i], "/logo") || strcmp(argv[i], "--logo") == 0) {
if (i + 1 >= argc) {
fputs("Error: /logo requires a logo name.\n", stderr);
safe_exit(1, options->hard_exit);
}
if (!logo_name_exists(argv[i + 1], options->logo_override,
sizeof(options->logo_override))) {
fputs("Error: unknown logo name. Use /list to view available logos.\n", stderr);
safe_exit(1, options->hard_exit);
}
++i;
} else if (str_equals_ci(argv[i], "/noansi") || strcmp(argv[i], "--noansi") == 0) {
options->force_ascii = 1;
} else if (str_equals_ci(argv[i], "/r") || strcmp(argv[i], "--prompt-fix") == 0) {
options->prompt_fix = 1;
} else if (str_equals_ci(argv[i], "/safe") || str_equals_ci(argv[i], "/safeexit")) {
options->hard_exit = 0;
} else if (strcmp(argv[i], "/?") == 0) {
puts("pastfetch - DOS system information fetcher");
puts("");
puts("Usage: pastfetch [options]");
puts("");
puts("Options:");
puts(" /nologo Disable ANSI logo output");
puts(" /list Show available logo names");
puts(" /logo NAME Force a specific logo (NAME from /list)");
puts(" /noansi Force ASCII logo even if ANSI is available");
puts(" /r Emit an extra ANSI reset/newline for stubborn shells");
puts(" /safe Use normal CRT cleanup/exit (default is fast exit)");
puts(" Ctrl+Q Force a fast exit even if /safe was used");
puts(" /? Show this help text");
safe_exit(0, options->hard_exit);
}
}
}
// Entry point: parse args, detect system, and render output.
int main(int argc, char **argv) {
SystemInfo info;
StringList drivers;
RunOptions options;
memset(&info, 0, sizeof(info));
strlist_init(&drivers);
parse_args(argc, argv, &options);
if (options.list_only) {
list_available_logos();
} else {
detect_system(&info, &drivers);
render_system(&info, &drivers, &options);
}
strlist_free(&drivers);
if (force_quit_requested()) {
options.hard_exit = 1;
}
safe_exit(0, options.hard_exit);
return 0; // yes, yes, compiler shut up already
}

941
src/render.c Normal file
View file

@ -0,0 +1,941 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <dos.h>
#if defined(__WATCOMC__)
#include <i86.h>
#endif
#include "pastfetch.h"
#define INFO_LABEL_COL 12
#define DEFAULT_SCREEN_WIDTH 80
#define TEXT_OFFSET 46
#define MAX_INFO_LINES 21
#define MAX_TOTAL_LINES 24
#define MAX_LOGO_CANDIDATES 8
#define MAX_LOGO_VISIBLE (TEXT_OFFSET > 1 ? (TEXT_OFFSET - 1) : 45)
typedef struct {
char label[INFO_LABEL_COL + 1];
char *value;
} InfoEntry;
typedef struct {
InfoEntry *items;
size_t count;
size_t capacity;
} InfoBuffer;
#include "logos_data.inc"
typedef struct {
const char *name;
const char *const *lines;
} LogoEntry;
// fallback ASCII logo
static const char *const ascii_logo_dos[] = {
"88888888ba, ,ad8888ba, ad88888ba",
"88 `\"8b d8\"' `\"8b d8\" \"8b",
"88 `8b d8' `8b Y8,",
"88 88 88 88 `Y8aaaaa,",
"88 88 88 88 `\"\"\"\"\"8b,",
"88 8P Y8, ,8P `8b",
"88 .a8P Y8a. .a8P Y8a a8P",
"88888888Y\"' `\"Y8888Y\"' \"Y88888P\"",
NULL,
};
static size_t ansi_visible_width(const char *text);
static const LogoEntry logo_table[] = {
{"86_dos", logo_86_dos},
{"concurrentdos", logo_concurrentdos},
{"dos", logo_dos},
{"dosbian", logo_dosbian},
{"dosbox", logo_dosbox},
{"dosbox_staging", logo_dosbox_staging},
{"dosbox_x", logo_dosbox_x},
{"dr_dos", logo_dr_dos},
{"freedos", logo_freedos},
{"ms_dos", logo_ms_dos},
{"novell_dos", logo_novell_dos},
{"pc_dos", logo_pc_dos},
{NULL, NULL},
};
// Drop empty edges and cap logo height
static void logo_trim_height(StringList *logo) {
while (logo && logo->count > 0) {
size_t width = ansi_visible_width(logo->items[0]);
if (width == 0) {
strlist_remove(logo, 0);
} else {
break;
}
}
while (logo && logo->count > 0) {
size_t width = ansi_visible_width(logo->items[logo->count - 1]);
if (width == 0) {
strlist_remove(logo, logo->count - 1);
} else {
break;
}
}
while (logo && logo->count > MAX_TOTAL_LINES) {
strlist_remove(logo, logo->count - 1);
}
}
// Load the built-in ASCII fallback logo.
static void load_ascii_logo(StringList *logo) {
size_t i;
if (!logo) {
return;
}
for (i = 0; ascii_logo_dos[i] != NULL; ++i) {
strlist_add(logo, ascii_logo_dos[i]);
}
}
// Check whether a string segment contains any non-space character.
static int has_visible_chars_n(const char *text, size_t len) {
size_t i;
if (!text) {
return 0;
}
for (i = 0; i < len; ++i) {
if (!isspace((unsigned char)text[i])) {
return 1;
}
}
return 0;
}
// Initialize the info buffer structure.
static void info_buffer_init(InfoBuffer *buffer) {
buffer->items = NULL;
buffer->count = 0;
buffer->capacity = 0;
}
// Release storage held by info buffer entries.
static void info_buffer_free(InfoBuffer *buffer) {
size_t i;
if (!buffer) {
return;
}
for (i = 0; i < buffer->count; ++i) {
free(buffer->items[i].value);
buffer->items[i].value = NULL;
}
free(buffer->items);
buffer->items = NULL;
buffer->count = 0;
buffer->capacity = 0;
}
// Append a label/value pair to the info buffer.
static int info_buffer_add(InfoBuffer *buffer, const char *label, const char *value) {
InfoEntry *entry;
InfoEntry *new_items;
const char *safe_label = label ? label : "";
const char *safe_value = value ? value : "";
size_t new_capacity;
char *value_copy;
if (!buffer) {
return 0;
}
if (buffer->count >= MAX_INFO_LINES) {
return 0;
}
if (buffer->count == buffer->capacity) {
new_capacity = buffer->capacity == 0 ? 16 : buffer->capacity * 2;
new_items = (InfoEntry *)realloc(buffer->items, new_capacity * sizeof(InfoEntry));
if (!new_items) {
return 0;
}
buffer->items = new_items;
buffer->capacity = new_capacity;
}
entry = &buffer->items[buffer->count];
strncpy(entry->label, safe_label, INFO_LABEL_COL);
entry->label[INFO_LABEL_COL] = '\0';
value_copy = (char *)malloc(strlen(safe_value) + 1); // yikes
if (!value_copy) {
return 0;
}
strcpy(value_copy, safe_value);
entry->value = value_copy;
buffer->count++;
return 1;
}
// Format a label/value pair into a fixed-width line and append it.
// Lines that would be entirely blank are skipped, not stored.
static int text_block_add(StringList *block, const char *label, const char *value,
size_t value_len) {
size_t total_len;
char *line;
const char *safe_label = label ? label : "";
const char *safe_value = value ? value : "";
if (!block) {
return 0;
}
if (!has_visible_chars_n(safe_label, strlen(safe_label)) &&
!has_visible_chars_n(safe_value, value_len)) {
return 1;
}
total_len = INFO_LABEL_COL + 1 + value_len;
line = (char *)malloc(total_len + 1);
if (!line) {
return 0;
}
snprintf(line, total_len + 1, "%-*s %.*s", INFO_LABEL_COL, safe_label, (int)value_len,
safe_value);
if (!strlist_adopt(block, line)) {
free(line);
return 0;
}
return 1;
}
// Append a feature string into a buffer separated by newlines.
static void append_feature(char *buffer, size_t buffer_len, const char *feature) {
size_t existing;
if (!buffer || buffer_len == 0 || !feature || !*feature) {
return;
}
existing = strlen(buffer);
if (existing > 0) {
if (existing + 1 < buffer_len) {
buffer[existing++] = '\n';
buffer[existing] = '\0';
} else {
return;
}
}
strncat(buffer, feature, buffer_len - strlen(buffer) - 1);
}
// Render a byte count into human-readable units.
static void format_size(unsigned long bytes, char *buffer, size_t buffer_len) {
const unsigned long KB = 1024UL;
const unsigned long MB = 1024UL * KB;
const unsigned long GB = 1024UL * MB;
if (bytes >= GB) {
unsigned long integral = bytes / GB;
unsigned long fractional = (bytes % GB) * 100UL / GB;
snprintf(buffer, buffer_len, "%lu.%02lu GB", integral, fractional);
} else if (bytes >= MB) {
unsigned long integral = bytes / MB;
unsigned long fractional = (bytes % MB) * 100UL / MB;
snprintf(buffer, buffer_len, "%lu.%02lu MB", integral, fractional);
} else if (bytes >= KB) {
unsigned long integral = bytes / KB;
unsigned long fractional = (bytes % KB) * 100UL / KB;
snprintf(buffer, buffer_len, "%lu.%02lu KB", integral, fractional);
} else {
snprintf(buffer, buffer_len, "%lu bytes", bytes);
}
}
// Normalize a flavor string into a filename-friendly form.
static void sanitize_flavor(const char *input, char *output, size_t output_len) {
size_t i;
size_t pos = 0;
if (!input || !*input) {
str_copy(output, output_len, "default");
return;
}
for (i = 0; input[i] != '\0' && pos < output_len - 1; ++i) {
char c = (char)tolower((unsigned char)input[i]);
if (isalnum((unsigned char)c)) {
output[pos++] = c;
} else if (c == ' ' || c == '-' || c == '_' || c == '.') {
if (pos > 0 && output[pos - 1] != '_') {
output[pos++] = '_';
}
}
}
if (pos == 0) {
str_copy(output, output_len, "default");
} else {
output[pos] = '\0';
}
}
void list_available_logos(void) {
size_t i;
puts("Available logos:");
for (i = 0; logo_table[i].name; ++i) {
puts(logo_table[i].name);
}
}
// Validate a logo name and optionally return its normalized form.
int logo_name_exists(const char *name, char *normalized, size_t normalized_len) {
char sanitized[32];
size_t i;
if (!name) {
return 0;
}
sanitize_flavor(name, sanitized, sizeof(sanitized));
if (!sanitized[0]) {
return 0;
}
for (i = 0; logo_table[i].name; ++i) {
if (strcmp(sanitized, logo_table[i].name) == 0) {
str_copy(normalized, normalized_len, sanitized);
return 1;
}
}
return 0;
}
// Compute printable width of a string ignoring ANSI escape sequences
static size_t ansi_visible_width(const char *text) {
size_t width = 0;
const unsigned char *ptr = (const unsigned char *)text;
if (!text) {
return 0;
}
while (*ptr) {
if (*ptr == '\x1b') {
++ptr;
if (*ptr == '[') {
++ptr;
while (*ptr && ((*ptr >= '0' && *ptr <= '9') || *ptr == ';' || *ptr == '?' ||
*ptr == ':' || *ptr == '=')) {
++ptr;
}
if (*ptr) {
++ptr;
}
} else if (*ptr && (*ptr == '(' || *ptr == ')' || *ptr == '*' || *ptr == '+' ||
*ptr == '-' || *ptr == '.' || *ptr == '/')) {
++ptr;
if (*ptr) {
++ptr;
}
} else {
if (*ptr) {
++ptr;
}
}
continue;
}
if (*ptr == '\r' || *ptr == '\n') {
++ptr;
continue;
}
++width;
++ptr;
}
return width;
}
// Append text to a buffer inserting a separator when needed.
static void append_with_separator(char *dest, size_t dest_size, const char *text,
const char *separator) {
if (!dest || !text || !*text || dest_size == 0) {
return;
}
{
size_t current = strlen(dest);
size_t remaining;
if (current >= dest_size - 1) {
return;
}
remaining = dest_size - current - 1;
if (*dest != '\0' && separator && *separator) {
size_t sep_len = strlen(separator);
if (sep_len > remaining) {
sep_len = remaining;
}
strncat(dest, separator, sep_len);
current = strlen(dest);
if (current >= dest_size - 1) {
return;
}
remaining = dest_size - current - 1;
}
strncat(dest, text, remaining);
}
}
// Write unsigned int into a buffer without stdio formatting
static size_t append_uint(char *dest, unsigned int value) {
char tmp[10];
size_t len = 0;
size_t written = 0;
if (!dest) {
return 0;
}
do {
if (len < sizeof(tmp)) {
tmp[len++] = (char)('0' + (value % 10));
}
value /= 10;
} while (value > 0);
while (len > 0) {
*dest++ = tmp[--len];
++written;
}
return written;
}
// Emit ANSI cursor move sequence to 1-based row/col.
static void emit_cursor_move(unsigned int row, unsigned int col) {
char seq[24];
char *ptr = seq;
if (row == 0) {
row = 1;
}
if (col == 0) {
col = 1;
}
*ptr++ = '\x1b';
*ptr++ = '[';
ptr += append_uint(ptr, row);
*ptr++ = ';';
ptr += append_uint(ptr, col);
*ptr++ = 'H';
*ptr = '\0';
fputs(seq, stdout);
}
// Clear the screen using ANSI when available, else BIOS fallback.
static void clear_screen(const SystemInfo *info) {
if (info && info->ansi_available) {
fputs("\x1b[2J\x1b[H", stdout);
return;
}
#if defined(__WATCOMC__)
{
union REGS regs;
regs.h.ah = 0x06;
regs.h.al = 0;
regs.h.bh = 0x07;
regs.x.cx = 0;
regs.x.dx = (24 << 8) | 79;
int86(0x10, &regs, &regs);
regs.h.ah = 0x02;
regs.h.bh = 0;
regs.h.dh = 0;
regs.h.dl = 0;
int86(0x10, &regs, &regs);
}
#else
putchar('\f');
#endif
}
// Copy the first non-empty line from a nl-delimited string.
static char *extract_first_segment(const char *text) {
const char *cursor;
const char *next;
size_t len;
char *result;
if (!text) {
return NULL;
}
cursor = text;
while (*cursor && isspace((unsigned char)*cursor)) {
++cursor;
}
if (*cursor == '\0') {
return NULL;
}
next = strchr(cursor, '\n');
len = next ? (size_t)(next - cursor) : strlen(cursor);
while (len > 0 && isspace((unsigned char)cursor[len - 1])) {
--len;
}
result = (char *)malloc(len + 1);
if (!result) {
return NULL;
}
memcpy(result, cursor, len);
result[len] = '\0';
return result;
}
static void add_candidate(const char **list, size_t *count, const char *value) {
size_t i;
if (!value || !*value || *count >= MAX_LOGO_CANDIDATES) {
return;
}
for (i = 0; i < *count; ++i) {
if (strcmp(list[i], value) == 0) {
return;
}
}
list[(*count)++] = value;
}
/* Choose and load the best matching logo for the detected DOS flavor.
Successively looser spellings of the name are tried against logo_table,
each derived from the previous non-empty one:
"MS-DOS 6.22 compat." -> ms_dos_6_22_compat (sanitized)
-> ms-dos-6-22-compat (hyphenated)
-> ms-dos-6-22 (compat suffix dropped)
-> ms (first word only)
with "ms_dos" and then "dos" appended as final fallbacks. */
static void load_logo(const char *dos_flavor, StringList *logo) {
char sanitized[32];
char trimmed[32];
char hyphenated[32];
char compat_fix[32];
char base[32];
const char *candidates[MAX_LOGO_CANDIDATES];
size_t candidate_count = 0;
const char *current;
const char *const *lines = NULL;
size_t i, j, len;
if (!logo) {
return;
}
sanitize_flavor(dos_flavor, sanitized, sizeof(sanitized));
add_candidate(candidates, &candidate_count, sanitized);
current = sanitized;
/* Drop trailing underscores left by sanitize_flavor. */
str_copy(trimmed, sizeof(trimmed), current);
while ((len = strlen(trimmed)) > 0 && trimmed[len - 1] == '_') {
trimmed[len - 1] = '\0';
}
if (trimmed[0]) {
add_candidate(candidates, &candidate_count, trimmed);
current = trimmed;
}
/* Logo names in logo_table use underscores, but accept hyphens too. */
str_copy(hyphenated, sizeof(hyphenated), current);
for (i = 0; hyphenated[i] != '\0'; ++i) {
if (hyphenated[i] == '_') {
hyphenated[i] = '-';
}
}
if (hyphenated[0]) {
add_candidate(candidates, &candidate_count, hyphenated);
current = hyphenated;
}
/* "MS-DOS compat." is a fallback label, not a distinct flavour. */
str_copy(compat_fix, sizeof(compat_fix), current);
if (str_ends_ci(compat_fix, "-compat") || str_ends_ci(compat_fix, "_compat")) {
compat_fix[strlen(compat_fix) - 7] = '\0';
}
if (compat_fix[0]) {
add_candidate(candidates, &candidate_count, compat_fix);
current = compat_fix;
}
/* Last resort before the generic fallbacks: the leading word alone. */
str_copy(base, sizeof(base), current);
for (i = 0; base[i] != '\0'; ++i) {
if (base[i] == '_' || base[i] == '-') {
base[i] = '\0';
break;
}
}
add_candidate(candidates, &candidate_count, base);
if (strncmp(sanitized, "ms_dos", 6) == 0) {
add_candidate(candidates, &candidate_count, "ms_dos");
}
add_candidate(candidates, &candidate_count, "dos");
for (i = 0; i < candidate_count && !lines; ++i) {
for (j = 0; logo_table[j].name; ++j) {
if (strcmp(candidates[i], logo_table[j].name) == 0) {
lines = logo_table[j].lines;
break;
}
}
}
if (!lines) {
lines = logo_dos;
}
/* Copy each line, truncating at MAX_LOGO_VISIBLE printable characters so
the art cannot run into the info column. Escape sequences are copied
through without counting toward the visible width. */
for (i = 0; lines[i] != NULL; ++i) {
const char *src = lines[i];
char buffer[512];
char *dst = buffer;
char *limit = buffer + sizeof(buffer) - 1;
size_t visible = 0;
while (*src && visible < MAX_LOGO_VISIBLE && dst < limit) {
if (*src == '\x1b') {
*dst++ = *src++;
while (*src && dst < limit) {
*dst++ = *src;
if (isalpha((unsigned char)*src)) {
src++;
break;
}
src++;
}
continue;
}
*dst++ = *src++;
visible++;
}
*dst = '\0';
strlist_add(logo, buffer);
}
logo_trim_height(logo);
}
// Build the list of system information lines to render.
static void collect_info_lines(const SystemInfo *info, const StringList *drivers,
InfoBuffer *lines) {
char version[32];
char total_space[32];
char free_space[32];
char version_flags[32];
char buffer[64];
if (!info || !drivers || !lines) {
return;
}
version_flags[0] = '\0';
if (info->dos_flags & 0x08) {
append_feature(version_flags, sizeof(version_flags), "ROM");
}
if (info->dos_flags & 0x10) {
append_feature(version_flags, sizeof(version_flags), "HMA");
}
if (info->dos_major || info->dos_minor) {
if (info->dos_revision > 0) {
snprintf(version, sizeof(version), "%u.%u.%u", (unsigned int)info->dos_major,
(unsigned int)info->dos_minor, (unsigned int)info->dos_revision);
} else {
snprintf(version, sizeof(version), "%u.%u", (unsigned int)info->dos_major,
(unsigned int)info->dos_minor);
}
} else {
str_copy(version, sizeof(version), "Unknown");
}
if (version_flags[0]) {
strncat(version, " (", sizeof(version) - strlen(version) - 1);
strncat(version, version_flags, sizeof(version) - strlen(version) - 1);
strncat(version, ")", sizeof(version) - strlen(version) - 1);
}
format_size(info->disk_total_bytes, total_space, sizeof(total_space));
format_size(info->disk_free_bytes, free_space, sizeof(free_space));
info_buffer_add(lines, "DOS", info->dos_flavor);
info_buffer_add(lines, "Kernel", version);
if (info->ver_string[0]) {
info_buffer_add(lines, "VER cmd", info->ver_string);
}
info_buffer_add(lines, "Shell", info->shell);
info_buffer_add(lines, "Model", info->computer_model);
info_buffer_add(lines, "CPU", info->cpu);
if (info->display_mode[0]) {
info_buffer_add(lines, "Display", info->display_mode);
if (lines->count < MAX_INFO_LINES) {
char graphics[256];
graphics[0] = '\0';
if (info->display_adapter[0]) {
append_with_separator(graphics, sizeof(graphics), info->display_adapter, " | ");
}
if (info->display_vbe[0]) {
append_with_separator(graphics, sizeof(graphics), info->display_vbe, " | ");
}
if (info->palette_info[0]) {
char *palette_summary = extract_first_segment(info->palette_info);
if (palette_summary) {
append_with_separator(graphics, sizeof(graphics), palette_summary, " | ");
free(palette_summary);
}
}
if (graphics[0]) {
info_buffer_add(lines, "Graphics", graphics);
}
}
}
snprintf(buffer, sizeof(buffer), "%u KB", info->conventional_kb);
info_buffer_add(lines, "RAM", buffer);
snprintf(buffer, sizeof(buffer), "%lu KB", info->extended_kb);
info_buffer_add(lines, "Ext. RAM", buffer);
snprintf(buffer, sizeof(buffer), "%s total", total_space);
info_buffer_add(lines, "Drive C:", buffer);
snprintf(buffer, sizeof(buffer), "%s free", free_space);
info_buffer_add(lines, "", buffer);
if (lines->count < MAX_INFO_LINES) {
if (drivers->count == 0) {
info_buffer_add(lines, "Config", "No DEVICE/INSTALL entries found");
} else {
char summary[256];
if (drivers->count == 1) {
str_copy(summary, sizeof(summary), drivers->items[0]);
} else {
snprintf(summary, sizeof(summary), "%u entries (first: %s)",
(unsigned)drivers->count, drivers->items[0]);
}
info_buffer_add(lines, "Config", summary);
}
}
}
// Wrap long info values into multiple display lines.
static void wrap_info_lines(const InfoBuffer *info, size_t total_width, StringList *output) {
size_t prefix_width = INFO_LABEL_COL + 1;
size_t max_value_width = (total_width > prefix_width) ? (total_width - prefix_width) : 0;
size_t i;
if (!output || !info) {
return;
}
for (i = 0; i < info->count && i < MAX_INFO_LINES; ++i) {
const char *label = info->items[i].label;
const char *value = info->items[i].value ? info->items[i].value : "";
const char *cursor = value;
int first_line = 1;
while (*cursor && output->count < MAX_INFO_LINES) {
size_t remaining = max_value_width ? max_value_width : strlen(cursor);
size_t take = strlen(cursor);
char linebuf[512];
if (remaining == 0) {
break;
}
if (remaining > sizeof(linebuf) - 1) {
remaining = sizeof(linebuf) - 1;
}
if (take > remaining) {
take = remaining;
if (max_value_width) {
size_t back = take;
while (back > 0 && !isspace((unsigned char)cursor[back - 1])) {
--back;
}
if (back > 0) {
take = back;
}
}
}
strncpy(linebuf, cursor, take);
linebuf[take] = '\0';
cursor += take;
while (*cursor && isspace((unsigned char)*cursor)) {
++cursor;
}
text_block_add(output, first_line ? label : "", linebuf, strlen(linebuf));
first_line = 0;
}
if (output->count >= MAX_INFO_LINES) {
break;
}
}
}
// Draw the logo and formatted info, with optional palette swatches
static void render_canvas(const StringList *logo, const InfoBuffer *info, int show_palette,
int ansi_available) {
/* Reserve the final column. A line that exactly fills the screen makes the
display wrap the cursor by itself, and the newline that follows then
lands as a blank row -- the black lines through the ASCII logo under
/noansi. 46 (logo) + 13 (label) + 21 (value) was exactly 80. */
size_t usable_width = DEFAULT_SCREEN_WIDTH - 1;
size_t info_width = (usable_width > TEXT_OFFSET) ? (usable_width - TEXT_OFFSET) : 0;
StringList rendered;
size_t rows;
size_t i;
strlist_init(&rendered);
wrap_info_lines(info, info_width, &rendered);
if (show_palette && ansi_available) {
static const int colors[] = {30, 31, 32, 33, 34, 35, 36, 37};
char line[256];
size_t idx;
line[0] = '\0';
for (idx = 0; idx < sizeof(colors) / sizeof(colors[0]); ++idx) {
char segment[16];
snprintf(segment, sizeof(segment), "\x1b[%dm\xDB\xDB\x1b[0m ", colors[idx]);
append_with_separator(line, sizeof(line), segment, "");
}
strlist_add(&rendered, line);
if (rendered.count < MAX_TOTAL_LINES) {
line[0] = '\0';
for (idx = 0; idx < sizeof(colors) / sizeof(colors[0]); ++idx) {
char segment[16];
snprintf(segment, sizeof(segment), "\x1b[1;%dm\xDB\xDB\x1b[0m ", colors[idx]);
append_with_separator(line, sizeof(line), segment, "");
}
strlist_add(&rendered, line);
}
}
rows = rendered.count;
if (logo && logo->count > rows) {
rows = logo->count;
}
if (rows > MAX_TOTAL_LINES) {
rows = MAX_TOTAL_LINES;
}
for (i = 0; i < rows; ++i) {
const char *logo_line = (logo && i < logo->count) ? logo->items[i] : "";
const char *info_line = (i < rendered.count) ? rendered.items[i] : NULL;
size_t visible = ansi_visible_width(logo_line);
size_t padding = (visible < TEXT_OFFSET) ? (TEXT_OFFSET - visible) : 1;
if (ansi_available) {
if (info_line) {
emit_cursor_move((unsigned int)(i + 1U), (unsigned int)(TEXT_OFFSET + 1));
fputs(info_line, stdout);
}
emit_cursor_move((unsigned int)(i + 1U), 1);
fputs(logo_line, stdout);
while (padding--) {
putchar(' ');
}
putchar('\n');
} else {
const char *right = info_line ? info_line : "";
int logo_has_text = logo_line && *logo_line;
int info_has_text = has_visible_chars_n(right, strlen(right));
if (!logo_has_text && !info_has_text) {
continue;
}
if (logo_has_text) {
fputs(logo_line, stdout);
}
if (info_has_text) {
size_t left_len = logo_has_text ? strlen(logo_line) : 0;
size_t space_count = (left_len < TEXT_OFFSET) ? (TEXT_OFFSET - left_len) : 1;
while (space_count--) {
putchar(' ');
}
fputs(right, stdout);
}
putchar('\n');
}
}
strlist_free(&rendered);
fflush(stdout);
}
// Public entry to render detected system info and logo
void render_system(const SystemInfo *info, const StringList *drivers, const RunOptions *options) {
StringList logo;
InfoBuffer info_lines;
int show_logo = 1;
int show_palette = 0;
int ansi_active;
if (!info || !drivers) {
return;
}
ansi_active = info->ansi_available;
if (options) {
show_logo = !options->no_logo;
if (options->force_ascii) {
ansi_active = 0;
}
show_palette = ansi_active;
} else {
show_logo = 1;
show_palette = ansi_active;
}
clear_screen(info);
info_buffer_init(&info_lines);
collect_info_lines(info, drivers, &info_lines);
strlist_init(&logo);
if (show_logo) {
if (ansi_active) {
const char *logo_source;
if (options && options->logo_override[0]) {
logo_source = options->logo_override;
} else {
logo_source = info->logo_hint[0] ? info->logo_hint : info->dos_flavor;
}
load_logo(logo_source, &logo);
} else {
load_ascii_logo(&logo);
}
}
render_canvas(show_logo ? &logo : NULL, &info_lines, show_palette, ansi_active);
strlist_free(&logo);
info_buffer_free(&info_lines);
if (options && options->prompt_fix) {
if (ansi_active) {
fputs("\x1b[0m\r\n", stdout);
} else {
fputs("\r\n", stdout);
}
fflush(stdout);
}
}

175
src/util.c Normal file
View file

@ -0,0 +1,175 @@
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "pastfetch.h"
// Case-insensitive string helpers
static int lower(unsigned char c) {
return tolower(c);
}
void str_copy(char *dest, size_t dest_len, const char *src) {
if (!dest || dest_len == 0 || !src) {
return;
}
strncpy(dest, src, dest_len - 1);
dest[dest_len - 1] = '\0';
}
int str_equals_ci_n(const char *a, const char *b, size_t len) {
size_t i;
if (!a || !b) {
return 0;
}
for (i = 0; i < len; ++i) {
if (lower((unsigned char)a[i]) != lower((unsigned char)b[i])) {
return 0;
}
}
return 1;
}
int str_equals_ci(const char *a, const char *b) {
if (!a || !b) {
return 0;
}
while (*a && *b) {
if (lower((unsigned char)*a) != lower((unsigned char)*b)) {
return 0;
}
++a;
++b;
}
return *a == '\0' && *b == '\0';
}
int str_starts_ci(const char *text, const char *prefix) {
size_t i;
if (!text || !prefix) {
return 0;
}
for (i = 0; prefix[i] != '\0'; ++i) {
if (text[i] == '\0' || lower((unsigned char)text[i]) != lower((unsigned char)prefix[i])) {
return 0;
}
}
return 1;
}
int str_ends_ci(const char *text, const char *suffix) {
size_t text_len;
size_t suffix_len;
if (!text || !suffix) {
return 0;
}
text_len = strlen(text);
suffix_len = strlen(suffix);
if (suffix_len == 0 || text_len < suffix_len) {
return 0;
}
return str_equals_ci_n(text + text_len - suffix_len, suffix, suffix_len);
}
const char *str_find_ci(const char *text, const char *needle) {
size_t text_len;
size_t needle_len;
size_t i;
if (!text || !needle || !*needle) {
return NULL;
}
text_len = strlen(text);
needle_len = strlen(needle);
if (needle_len > text_len) {
return NULL;
}
for (i = 0; i <= text_len - needle_len; ++i) {
if (str_equals_ci_n(text + i, needle, needle_len)) {
return text + i;
}
}
return NULL;
}
int str_has_ci(const char *text, const char *needle) {
return str_find_ci(text, needle) != NULL;
}
// StringList: a growable array of owned strings
void strlist_init(StringList *list) {
if (!list) {
return;
}
list->items = NULL;
list->count = 0;
list->capacity = 0;
}
int strlist_adopt(StringList *list, char *owned) {
if (!list || !owned) {
return 0;
}
if (list->count == list->capacity) {
size_t new_capacity = list->capacity == 0 ? 16 : list->capacity * 2;
char **items = (char **)realloc(list->items, new_capacity * sizeof(char *));
if (!items) {
return 0;
}
list->items = items;
list->capacity = new_capacity;
}
list->items[list->count++] = owned;
return 1;
}
int strlist_addn(StringList *list, const char *value, size_t len) {
char *copy;
if (!list || !value) {
return 0;
}
copy = (char *)malloc(len + 1);
if (!copy) {
return 0;
}
memcpy(copy, value, len);
copy[len] = '\0';
if (!strlist_adopt(list, copy)) {
free(copy);
return 0;
}
return 1;
}
int strlist_add(StringList *list, const char *value) {
if (!value) {
return 0;
}
return strlist_addn(list, value, strlen(value));
}
void strlist_remove(StringList *list, size_t index) {
size_t i;
if (!list || index >= list->count) {
return;
}
free(list->items[index]);
for (i = index; i + 1 < list->count; ++i) {
list->items[i] = list->items[i + 1];
}
list->count--;
}
void strlist_free(StringList *list) {
size_t i;
if (!list) {
return;
}
for (i = 0; i < list->count; ++i) {
free(list->items[i]);
}
free(list->items);
strlist_init(list);
}

99
tools/generate_logos_data.py Normal file
View file

@ -0,0 +1,99 @@
#!/usr/bin/env python3
"""
Generate src/logos_data.inc from the ANSI art files under logos/.
Each ANSI logo is converted into a NULL-terminated array of C string literals
so render.c can embed them directly without needing to parse files at runtime.
"""
from __future__ import annotations
import argparse
from pathlib import Path
LOGO_SOURCES = [
("logo_86_dos", "logos/86.ans"),
("logo_concurrentdos", "logos/concurrentdos.ans"),
("logo_dos", "logos/dos.ans"),
("logo_dosbian", "logos/dosbian.ans"),
("logo_dosbox", "logos/dosbox.ans"),
("logo_dosbox_staging", "logos/dosbox_staging.ans"),
("logo_dosbox_x", "logos/dosbox_x.ans"),
("logo_dr_dos", "logos/drdos.ans"),
("logo_freedos", "logos/freedos.ans"),
("logo_ms_dos", "logos/msdos.ans"),
("logo_novell_dos", "logos/novell.ans"),
("logo_pc_dos", "logos/ibmdos.ans"),
]
def split_lines(path: Path) -> list[bytes]:
"""Return the ANSI file as a list of raw lines without line endings."""
data = path.read_bytes()
# splitlines() handles CRLF/CR/LF and preserves empty lines.
return data.splitlines()
def to_c_literal(line: bytes) -> str:
"""Convert a raw line to a C string literal with escaped bytes."""
pieces = ['"']
for byte in line:
if byte == 0x5C: # backslash
pieces.append("\\\\")
elif byte == 0x22: # double quote
pieces.append('\\"')
elif byte == 0x07:
pieces.append("\\a")
elif byte == 0x08:
pieces.append("\\b")
elif byte == 0x09:
pieces.append("\\t")
elif byte == 0x0C:
pieces.append("\\f")
elif byte == 0x0B:
pieces.append("\\v")
elif 0x20 <= byte <= 0x7E:
pieces.append(chr(byte))
else:
pieces.append(f"\\x{byte:02x}")
pieces.append('"')
return "".join(pieces)
def generate(output: Path) -> None:
root = Path(__file__).resolve().parents[1]
lines = [
"/* Auto-generated by tools/generate_logos_data.py. Do not edit. */",
"",
]
for symbol, rel_path in LOGO_SOURCES:
logo_path = root / rel_path
if not logo_path.exists():
raise FileNotFoundError(f"Missing logo file: {logo_path}")
lines.append(f"static const char *const {symbol}[] = {{")
for raw_line in split_lines(logo_path):
lines.append(f" {to_c_literal(raw_line)},")
lines.append(" NULL,")
lines.append("};")
lines.append("")
output_path = root / output
output_path.write_text("\n".join(lines), encoding="utf-8")
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
"-o",
"--output",
default="src/logos_data.inc",
type=Path,
help="Path to write the generated include (default: %(default)s)",
)
args = parser.parse_args()
generate(args.output)
if __name__ == "__main__":
main()