SpecNext Wiki - User contributions [en-gb]

Monitors

2020-06-05T04:07:40Z

Myopian:

== Monitors reported to be working with the next ==

{| class="wikitable"
! Monitor !! vga0 50hz !! Comments
|-
| Acer AL1715 || No || 50hz vga5 works, 60hz modes work
|-
| Acer K242HL || Yes || "seems to work just fine"
|-
| AG neovo F-419 || Yes || no issues on vga mode 0. (accepts 49Hz to about 75Hz)
|-
| Asus VG278 || Yes || All modes work, both vga and hdmi
|-
| Asus VS239 || Yes || All modes work
|-
| BenQ BL2420PT 24" IPS QHD || Yes || The pixel response times are too slow to show the multi colour effects in the Mescaline demo properly.
|-
| Dell 2000FP || Yes || 4:3 resolution. Has DVI, not HDMI.
|-
| Dell 2007FPB || Yes || 4:3 resolution. Some 'feedback' on image via VGA, but overall very pleased.
|-
| Fujitsu-Siemens B19-6 19 || Yes || 50hz vga0 works
|-
| HP Compaq LA2205wg || Yes || vga0 50hz works
|-
| hp 22cwa || Yes || VGA 50Hz all modes, VGA 60Hz all modes, HDMI both 50Hz and 60Hz. Does not have speakers.
|-
| Hp L1910 || Yes || 50hz mode 0 works
|-
| LG Ring 1900R || No || 50hz vga4 works
|-
| Samsung syncmaster 223bw || Yes ||
|-
| Samsung SyncMaster 940Fn || Yes || 60hz all modes, 50hz vga0, vga1, vga2, vga5, vga6
|-
| Samsung SyncMaster E1920 || Yes || 50hz vga0 works
|-
| Samsung Syncmaster 997mb || Yes || Works fine
|-
| Vibrant VL5A9DL || No || 60hz all modes, 50hz vga4, vga5, vga6
|-
|}

Dot:pisend

2020-05-31T23:38:38Z

Myopian: Created page with "= .PISEND dot command = This utility sends data to the NextPi over the UART link. == Usage == <code>.pisend</code> entered at the basic prompt with no arguments will print..."

= .PISEND dot command =

This utility sends data to the NextPi over the UART link.

== Usage ==

<code>.pisend</code> entered at the basic prompt with no arguments will print help.

The help text is reproduced here:
<pre>
use:

.pisend -c {cmd}
sends a command to the pi0, eg:

.pisend -c nextpi-tzx_load rbc.tzx
.pisend -c nextpi-play_sid sing*

.pisend -c nextpi-tzx_load rbc.tzx
.pisend -c nextpi-play_sid sing*

.pisend -q

discovers pi0 and sets baud

You must send this -q first to discover the pi0. Reg f
is set on successful exit

.pisend -r

flush what is in the uart buffer
to / 49152 with 512 bytes

pisend {filename}

pisend will base64 encode and
trasnmit to the pi0

Thanks to kevb, TimG, Big D and all the rest...
</pre>

== Building ==

Source [https://github.com/em00k/pisend-source here].

[[Category:Developer Tools]]

Dot:tapeout

2020-05-31T23:27:37Z

Myopian: Document tapeout command

= .TAPEOUT dot command =

This utility changes tape output to a given <code>.TAP</code> file.

== Usage ==

<code>.tapeout -h</code> entered at the basic prompt will print help.

The help text is reproduced here:
<pre>
TAPEOUT v1.0 by Garry Lancaster
Change tape output to .TAP file

SYNOPSIS:
.TAPEOUT [OPTION]... [FILE]

OPTIONS:
-v, --verbose
Verbose output
-h, --help
Display this help
-c, --close
Close input file
-o, --overwrite
Overwrite instead of append

Use SAVE "t:" before saving
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/blob/master/src/c/DotCommands/DotCommand_TAPEOUT.c here].

[[Category:Developer Tools]]

Dot:tapein

2020-05-31T23:25:57Z

Myopian:

= .TAPEIN dot command =

This utility changes tape input to a given <code>.TAP</code> file.

== Usage ==

<code>.tapein -h</code> entered at the basic prompt will print help.

The help text is reproduced here:
<pre>
TAPEIN v1.0 by Garry Lancaster
Change tape input to .TAP file

SYNOPSIS:
.TAPEIN [OPTION]... [FILE]

OPTIONS:
-v, --verbose
Verbose output
-h, --help
Display this help
-c, --close
Close input file
-r, --rewind
Rewind to start
-s, --setptr <block>
Set tape block pointer
-p, --pause
Toggle screen pause
-l, --simulate
Toggle loading simulation

Use LOAD "t:" before loading
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/blob/master/src/c/DotCommands/DotCommand_TAPEIN.c here].

[[Category:Developer Tools]]

Dot:tapein

2020-05-31T23:24:26Z

Myopian: Document tapein

= .TAPEIN dot command =

This utility Change tape input to <code>.TAP</code> file.

== Usage ==

<code>.tapein -h</code> entered at the basic prompt will print help.

The help text is reproduced here:
<pre>
TAPEIN v1.0 by Garry Lancaster
Change tape input to .TAP file

SYNOPSIS:
.TAPEIN [OPTION]... [FILE]

OPTIONS:
-v, --verbose
Verbose output
-h, --help
Display this help
-c, --close
Close input file
-r, --rewind
Rewind to start
-s, --setptr <block>
Set tape block pointer
-p, --pause
Toggle screen pause
-l, --simulate
Toggle loading simulation

Use LOAD "t:" before loading
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/blob/master/src/c/DotCommands/DotCommand_TAPEIN.c here].

[[Category:Developer Tools]]

Dot:lstap

2020-05-31T23:20:56Z

Myopian: Document lstap

= .LSTAP dot command =

This utility lists the contents of <code>.tap</code> files.

== Usage ==

<code>.lstap -h</code> entered at the basic prompt will print help.

The help text is reproduced here:
<pre>
LSTAP v1.1 by Garry Lancaster
List contents of any .TAP file

SYNOPSIS:
.LSTAP [OPTION]... [FILE]

OPTIONS:
-h, --help
Display this help
-i, --input
Use current input file
-o, --output
Use current output file
-f, --fileoffsets
Show data offsets in TAP
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/blob/master/src/c/DotCommands/DotCommand_LSTAP.c here].

[[Category:Developer Tools]]

Dot:ls

2020-05-31T23:14:37Z

Myopian: Add documentation for ls.

= .LS dot command =
== Usage ==

<code>.ls --help</code> entered at the basic prompt will print help.

This utility provides directory listings.

The help text is reproduced here:

<pre>
ls - list directory contents

ls [OPTION]... [FILE]...

List information about FILEs
(the current dir by default).

Sort entries alphabetically if
-StUX and --sort are not used.

FILTER FILES

-a, --all
do not ignore .*

-A, --almost-all
ignore . and ..

-B, --ignore-backups
do not list *.bak

Wildcards accepted.

LIST STYLE

-C
list entries by columns

-l
use a long listing format

-m
comma separated list

-x
list entries by lines

-1
list one file per line

--format=across : -x
--fromat=commas : -m
--format=horizontal : -x
--format=long : -l
--format=single-column : -1
--format=verbose : -l
--format=vertical : -C

-s, --size
print file size

-w, --width=COLS
set output width to COLS.

--lfn=off
print 8.3 filenames

--lfn=on
print lfn filenames

--lfn=both
print both 8.3 and lfn

SORT METHOD

-S
sort by size largest first

-t
sort by time newest first

-U
do not sort

-X
sort by extension

--sort=none : -U
--sort=size : -S
--sort=time : -t
--sort=extension : -X

-r, --reverse
reverse sort order

--gdf,
--group-directories-first
list directories before files

FILE SIZE FORMAT

-h, --human-readable
sizes in K,M,G (*1024)

--si
sizes in KB,MB,GB (*1000)

--block-size=SIZE
sizes scaled by SIZE

DATE-TIME FORMAT

--time-style=long-iso
2002-03-30 23:45

--time-style=iso
2002-03-30, 03-30 23:45

--time-style=locale
mar 30 2002 23:45

DIRECTORY PROCESSING

-d, --directory
list dirs and do not enter

-R, --recursive
list subdirs recursively

--system
include system files

OTHER

--help
print this help and exit

--version
print version info and exit
</pre>

== Notes ==

The <code>README.TXT</code> from the source is reproduced here.

<pre>
This is a near complete implementation of unix "ls" that
is capable of sorting directories with thousands of entries.

TODO:

* Add different list styles
Currently -l is always generated

* Change listing format depending on column width

* Add filename formatting with flag characters
and filename colouring.

* Parse the LS_COLOR environment variable for
colouring information. Currently this environment
variable and TIME_STYLE are both read but only
TIME_STYLE is processed.

NOTES:

The output format is limited to -l for now and chosen to
fit in 32 columns. The default is to list 8.3 filenames.

Try a variation like this one in 64 column mode:

.ls --gdf -AR --time-style=locale --lfn=on

USE OF MEMORY

A directory queue is maintained in two 8k pages and is
always paged entirely into memory at mmu6 and mmu7 when
accessed. The queue is fifo and exists in a circular
buffer occupying the 16k. In recursive mode, directories
that need to be visited are pushed into this queue. And
as directories are listed, they are popped out of the queue.

An obstack holding file pointer records is held in main
memory from the end of the program (around address 43000)
to the top of memory. Each file pointer record is a three-
byte pointer, the first byte indicating 8k page number and
the remaining two being a pointer into the page when it is
present in mmu7. These file pointer records are fixed size
and grow like an expanding array so are easily sortable with
quicksort. About 6000 records can be stored in main memory
allowing sorting of directories containing up to 6000 files.

Each file pointer record points at an actual file record.
These records are stored in extra 8k pages called LFN_PAGES.
A file record records 8.3 and lfn names, as well as time and
size information. An individual record is variable in size
because the lfn name is variable in size. Each page storing
records is managed by an obstack which will allocate memory
as needed. The number of pages available is statically
compiled into the program and is currently four which means
32k is available to store file records. Realistically this
places a much lower limit on the max number of files that
can be read from a directory at once, ie less than 6000.
If the limit is reached, the directory listing is split into
pieces. If more space is needed, more pages can be allocated
by changing a constant and re-building the program.

Utilities like .ls must co-exist with basic, as in they must
not disturb basic's state. This means .ls must allocate memory
from the operating system to load into and it must deallocate
that memory on exit. All tasks are taken care of automatically
when z88dk builds this type of dot command called "dotn".
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/ls here].

[[Category:Developer Tools]]

Dot:strings

2020-05-31T23:05:22Z

Myopian:

= .STRINGS dot command =

To use, copy "STRINGS" to the sd card's DOT directory.

== Usage ==

<code>.strings</code> entered on its own at the basic prompt will print help.

This utility searches for ascii text strings stored in files. Results can be printed to screen or saved to an output file.

The help text is reproduced here:

<pre>.strings file [-n num]
[-s string] [-t {o,d,x}]
[-w] [-f] [-o file] [-a file]

-n = set min string len (4)
-s = print separator ("\n")
-t = file offset dec/oct/hex
-w = make \r\n part of string

-f = overwrite permitted
-o = output filename
-a = append filename

no -o,-a prints to screen

strings v1.2 zx-next z88dk.org
</pre>
== Examples ==

# Look for strings at least 6 chars long. If found print the file offset in hex along with the string. Output to screen.

<pre>.strings knight.sna -n 6 -t X
</pre>
<ol start="2">
<li>Look for strings and save findings to an output file. Print file offset in decimal and print a separator between findings.</li></ol>

<pre>.strings knight.sna -t d -s ------- -o string.txt
</pre>

== Compiling ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/strings here].

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o strings -pragma-include:zpragma.inc -subtype=dot-n -Cz"--clean" -create-app
</pre>
[[Category:Developer Tools]]

Dot:strings

2020-05-31T23:04:34Z

Myopian: Created page with "= .STRINGS dot command = To use, copy "STRINGS" to the sd card's DOT directory. == Compiling == <pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-n..."

= .STRINGS dot command =

To use, copy "STRINGS" to the sd card's DOT directory.

== Compiling ==

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o strings -pragma-include:zpragma.inc -subtype=dot-n -Cz"--clean" -create-app
</pre>
== Usage ==

<code>.strings</code> entered on its own at the basic prompt will print help.

This utility searches for ascii text strings stored in files. Results can be printed to screen or saved to an output file.

The help text is reproduced here:

<pre>.strings file [-n num]
[-s string] [-t {o,d,x}]
[-w] [-f] [-o file] [-a file]

-n = set min string len (4)
-s = print separator ("\n")
-t = file offset dec/oct/hex
-w = make \r\n part of string

-f = overwrite permitted
-o = output filename
-a = append filename

no -o,-a prints to screen

strings v1.2 zx-next z88dk.org
</pre>
== Examples ==

# Look for strings at least 6 chars long. If found print the file offset in hex along with the string. Output to screen.

<pre>.strings knight.sna -n 6 -t X
</pre>
<ol start="2">
<li>Look for strings and save findings to an output file. Print file offset in decimal and print a separator between findings.</li></ol>

<pre>.strings knight.sna -t d -s ------- -o string.txt
</pre>

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/strings here].

[[Category:Developer Tools]]

Dot:run

2020-05-31T23:00:30Z

Myopian:

= .RUN dot command =

RUN searches a path to locate and execute a program with filename matching the criteria.

The PATH is held in an environment variable stored in file <code>/sys/env.cfg</code>. It has the following form:

<pre>PATH = /demos/*;/games;/games/*;/games/zx81/*
</pre>
Each line in <code>env.cfg</code> can contain a <code>name = value</code> pair. The code that reads this file is robust so there can be errors and strange formatting but it is important that PATH is contained entirely in one line no matter how long it gets.

PATH is a list of directories that should be searched to locate executables. Each directory is separated by a <code>;</code>. Backward slashes are ok and will be changed to forward, leading and trailing spaces are ok. Spaces inside names are ok.

A trailing <code>/*</code> means all the directories contained in that directory will be searched. So <code>/games/*</code> means all directories in <code>/games</code> will be searched; note it does not mean <code>/games</code> itself will be searched and that is why you will see both <code>/games</code> and <code>/games/*</code> in the example above.

RUN will match the filename it is given against the contents of directories in the PATH and automatically launch the program. It will always search the current directory before those listed in PATH. The filename can contain wildcards.

Options allow listing of all filename matches and executing matches other than the first.

Programs having the following extensions are identified as executable:

<pre>bas, dot, nex, o, p, sna, snx, tap, z80
</pre>
== Compiling ==

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o run -pragma-include:zpragma.inc -subtype=dot-n -Cz"--clean" -create-app
</pre>
== Usage ==

The help text is reproduced here:

<pre>.run [OPTIONS] FILE

supported extensions: bas
dot nex o p sna snx tap z80

options:

-p = list dirs in PATH
-? = list FILE matches
-c = cd to FILE location
-r = retain cwd on clean exit
-N = select Nth FILE match

run 1.4 zx-next z88dk.org
</pre>
== Examples ==

# <code>.run</code>

Prints help.

<ol start="2">
<li><code>.run -p</code></li></ol>

Lists each directory in the PATH. Places an X beside directories that don't exist.

<ol start="3">
<li><code>.run -? war*</code></li></ol>

Lists all executables matching <code>war*</code>. The list is numbered so that a particular match can be referred to.

<ol start="4">
<li><code>.run -c warhawk.nex</code></li></ol>

Change to the directory where warhawk.nex is found.

<ol start="5">
<li><code>.run warhawk.nex</code></li></ol>

Run the first warhawk.nex found

<ol start="6">
<li><code>.run -2 warhawk.nex</code></li></ol>

Run the second warhawk.nex found

<ol start="7">
<li><code>.run castle*.tap</code></li></ol>

(Assume "castlevania.tap" exists and is the first match)

Mount castlevania.tap. The directory will be changed to the location of the tap.

Run with:

<code>LOAD "t:": LOAD ""</code>

<ol start="8">
<li><code>.run -r castlevania.tap</code></li></ol>

Mount castlevania.tap. The current working directory will not be changed.

Run with:

<code>LOAD "t:": LOAD ""</code>

<ol start="9">
<li><code>.run -? *batman*</code> <code>.run -5 *batman*</code></li></ol>

List all executables with <code>batman</code> in their names. Run the 5th match from that list.

== Notes ==

# When loading tap files, the computer will load in the current mode. That is, in standard 128k mode if in nextzxos, usr 0 mode if you have entered usr 0 mode and 48k mode if you have entered 48k mode. This is the same as how other zx machines take care of tape loading but it is different from nextzxos's file browser which will come up with a menu allowing you to select which mode to use before mounting the tap file.
# You may have to change some settings prior to running a program for some programs that rely on precise video timing or other factors. For nirvana games, contention must be enabled before running (and besides that your display must be 50Hz VGA to achieve precise timing). At the time of writing the only way to turn on contention is to do it via basic or the nmi menu but look out for a <code>.reset</code> dot command in the future. To do it via the nmi menu, press the M1 button on the left side of the next; it will be the button closest to you and closest to the bottom where the joystick ports are. From the menu choose "debug tools" then "status". With the arrow keys navigate to nextreg 8 and make sure bit 6 is rest in the value there. If it isn't, press caps+1 and enter a new two-digit hex value which is the same but with bit 6 reset. Then return to basic by pressing 'c'. Contention will now be enabled.

== Building ==

Source [https://gitlab.com/thesmog358/tbblue/-/blob/master/src/c/DotCommands/run here].

[[Category:Developer Tools]]

Dot:run

2020-05-31T22:58:49Z

Myopian: Add documentation for .run

Dot:find

2020-05-31T22:53:04Z

Myopian:

= .FIND dot command =

To use, copy “FIND” to the sd card’s DOT directory.

== Usage ==

<code>.find</code> entered on its own at the basic prompt will print help.

This utility searches directories from the start directory for a particlar file matching criteria supplied on the command line.

The help text is reproduced here:

<pre>find - search for files in a
directory hierarchy

.find DIR [OPTION]...

Find files starting at DIR
that match provided criteria.

Example:

.find . -type=f -name *.txt

[[Category:Developer Tools]]

(find all files in the current
directory and below that end
in ".txt")

All word options accept single
or double leading hyphens.

CRITERIA

-exec
file must be an executable
bas dot nex o p sna snx
tap z80

-mindepth N, -mindepth=N
ignore until at least N
directory levels traversed

-maxdepth N, -maxdepth=N
ignore if more than N
directory levels traversed

-mmin N, -mmin=N
(not implemented yet)

-mtime N, -mtime=N
(not implemented yet)

-name S, -name=S
lfn name must match S
S can contain *? wildcards

-prune S, -prune=S
ignore directory S
S can contain *? wildcards
else S is a canonical name

-size N, -size=N
if N>0 file must be at least
N bytes in size
if N<0 file must be less than
N bytes in size
N can have a suffix modifier:
"b" : * 512
"c" : * 1
"w" : * 2
"k" : * 1024
"M" : * 1048576

-type T, -type=f, -type=d
must be a file, directory

DISPLAY

-lfn=on
print matches with lfn names

-lfn=off
print matches with 8.3 names

-lfn=both
print matches w/ both names

ACTION

-cd N, -cd=N
change to the directory of
the Nth match and exit

OTHER

-help
print this help and exit

-version
print version info and exit

find 1.1 zx-next 128k z88dk.org</pre>
== Examples ==

# Locate all exectuables in the current directory and below. Executables are defined as “nex o p sna snx tap z80” types.

<code>.find . -exec</code>

<ol start="2" style="list-style-type: decimal;">
<li>Locate the 20th executable and change directory to that. Use <code>.run</code> to run the program.</li></ol>

<pre>.find . -exec -cd=20
.run castelvania.tap</pre>
<ol start="3" style="list-style-type: decimal;">
<li>Locate all text files between 1k and 10k in size.</li></ol>

<code>.find . -name *.txt -size 1k -size -10k</code>

<ol start="4" style="list-style-type: decimal;">
<li>Find all games with batman in the name.</li></ol>

<code>.find . -exec -name *batman*</code>

Filename matches are only applied against the long filename. The matching uses wildcards <code>*</code> and <code>?</code> which can match any character including <code>.</code>

== Compiling ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/find here].

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o find -pragma-include:zpragma.inc -subtype=dotn -Cz"--clean" -create-app</pre>

Dot:find

2020-05-31T22:52:23Z

Myopian: Add documentation for find command.

= .FIND dot command =

To use, copy “FIND” to the sd card’s DOT directory.

== Usage ==

<code>.find</code> entered on its own at the basic prompt will print help.

This utility searches directories from the start directory for a particlar file matching criteria supplied on the command line.

The help text is reproduced here:

<pre>find - search for files in a
directory hierarchy

.find DIR [OPTION]...

Find files starting at DIR
that match provided criteria.

Example:

.find . -type=f -name *.txt

(find all files in the current
directory and below that end
in ".txt")

All word options accept single
or double leading hyphens.

CRITERIA

-exec
file must be an executable
bas dot nex o p sna snx
tap z80

-mindepth N, -mindepth=N
ignore until at least N
directory levels traversed

-maxdepth N, -maxdepth=N
ignore if more than N
directory levels traversed

-mmin N, -mmin=N
(not implemented yet)

-mtime N, -mtime=N
(not implemented yet)

-name S, -name=S
lfn name must match S
S can contain *? wildcards

-prune S, -prune=S
ignore directory S
S can contain *? wildcards
else S is a canonical name

-size N, -size=N
if N>0 file must be at least
N bytes in size
if N<0 file must be less than
N bytes in size
N can have a suffix modifier:
"b" : * 512
"c" : * 1
"w" : * 2
"k" : * 1024
"M" : * 1048576

-type T, -type=f, -type=d
must be a file, directory

DISPLAY

-lfn=on
print matches with lfn names

-lfn=off
print matches with 8.3 names

-lfn=both
print matches w/ both names

ACTION

-cd N, -cd=N
change to the directory of
the Nth match and exit

OTHER

-help
print this help and exit

-version
print version info and exit

find 1.1 zx-next 128k z88dk.org</pre>
== Examples ==

# Locate all exectuables in the current directory and below. Executables are defined as “nex o p sna snx tap z80” types.

<code>.find . -exec</code>

<ol start="2" style="list-style-type: decimal;">
<li>Locate the 20th executable and change directory to that. Use <code>.run</code> to run the program.</li></ol>

<pre>.find . -exec -cd=20
.run castelvania.tap</pre>
<ol start="3" style="list-style-type: decimal;">
<li>Locate all text files between 1k and 10k in size.</li></ol>

<code>.find . -name *.txt -size 1k -size -10k</code>

<ol start="4" style="list-style-type: decimal;">
<li>Find all games with batman in the name.</li></ol>

<code>.find . -exec -name *batman*</code>

Filename matches are only applied against the long filename. The matching uses wildcards <code>*</code> and <code>?</code> which can match any character including <code>.</code>

== Compiling ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/find here].

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o find -pragma-include:zpragma.inc -subtype=dotn -Cz"--clean" -create-app</pre>

Dot:extract

2020-05-31T22:36:46Z

Myopian: Created page with "= .EXTRACT dot command = To use, copy “EXTRACT” to the sd card’s DOT directory. == Usage == <code>.extract</code> entered on its own at the basic prompt will print he..."

= .EXTRACT dot command =

To use, copy “EXTRACT” to the sd card’s DOT directory.

== Usage ==

<code>.extract</code> entered on its own at the basic prompt will print help.

This utility reads some portion of a file and either:

* saves that portion to another file
* appends that portion to another file
* loads that portion into the zx-next’s memory
* prints that portion in a hexdump

The data can be loaded anywhere in the zx-next’s memory space. The destination address can be specified as a 64k address within the current banking arrangement, as a linear address covering the entire zx-next memory space in [0x000000,0x1BFFFF], as a 16k bank number in [0,111], or as an 8k page number in [0,223].

All numbers can be specified in decimal, hexadecimal (leading 0x) or octal (leading 0).

The help text is reproduced here:

<pre>.extract file [+off][-off][len]
[-f] [-o file] [-a file]
[-m addr] [-ml linaddr]
[-mp pnum] [-mb bnum]

input:
file = input file
+off = byte offset from start
-off = byte offset from end
len = length in bytes

output:
-f = overwrite permitted
-o = write to out file
-a = append to out file
-m = copy to 64k addr
-ml = copy to linear addr
-mp = copy to start of page
-mb = copy to start of bank

no -o,-a,-m* generates hexdump

extract v1.3 zx-next z88dk</pre>
== Examples ==

# Display the screen stored in an sna snapshot file:

<code>.extract knight.sna +27 6912 -m 0x4000</code>

Extract 6912 bytes from file “knight.sna” at offset 27 and write to 64k memory address 0x4000.

<ol start="2" style="list-style-type: decimal;">
<li>Have a look at the sna header as a hexdump:</li></ol>

<code>.extract knight.sna 27</code>

Extract the first 27 bytes from file “knight.sna” and view it as a hexdump printed to screen.

<ol start="3" style="list-style-type: decimal;">
<li>Copy the last 1024 bytes of a file to another file:</li></ol>

<code>.extract knight.sna -1024 -o knight.bin</code>

Extract the last 1024 bytes from file “knight.sna” and save it to file “knight.bin”. If “knight.bin” already exists, an error will be produced (see -f).

<ol start="4" style="list-style-type: decimal;">
<li>Append file to another one.</li></ol>

<code>.extract knight.sna -a foo.bin</code>

Extract the entire file “knight.sna” and append it to the file “foo.bin”.

<ol start="5" style="list-style-type: decimal;">
<li>Load file to page 18</li></ol>

<pre>.extract knight.sna -mp 18
.extract knight.sna -mb 9
.extract knight.sna -ml 0x24000</pre>
Load the entire file “knight.sna” to the zx next’s memory. All variations above load the file contents to the same place in memory. The first command indicates the location using 8k page number. The second command indicates the location using 16k bank number. The last command indicates the location using a linearized memory address.

== Compiling ==

Source [https://gitlab.com/thesmog358/tbblue/-/tree/master/src/c/DotCommands/extract here].

<pre>zcc +zxn -v -startup=30 -clib=sdcc_iy -SO3 --max-allocs-per-node200000 --opt-code-size @zproject.lst -o extract -pragma-include:zpragma.inc -subtype=dot -Cz"--clean" -create-app</pre>

[[Category:Developer Tools]]