Initial revision

diff --git a/StraySrc/!DLLs/!Boot,feb b/StraySrc/!DLLs/!Boot,feb
new file mode 100644 (file)
index 0000000..68c2aac
--- /dev/null
+++ b/StraySrc/!DLLs/!Boot,feb
@@ -0,0 +1,9 @@
+|
+| DLL repository !Boot file
+|
+| © 1994 Straylight
+|  Distribute as required
+|
+
+IconSprites <Obey$Dir>.!Sprites
+If "<DLL$Dir>"="" Then Run <Obey$Dir>.!Run
\ No newline at end of file

diff --git a/StraySrc/!DLLs/!Run,feb b/StraySrc/!DLLs/!Run,feb
new file mode 100644 (file)
index 0000000..7aa2c6a
--- /dev/null
+++ b/StraySrc/!DLLs/!Run,feb
@@ -0,0 +1,23 @@
+|
+| DLL repository !Run file
+|
+| © 1994 Straylight
+|  Distribute as required
+|
+
+| --- Allow slightly nicer access to our utilities ---
+
+Set DLL$Dir <Obey$Dir>
+Set Alias$_util /<DLL$Dir>.%%0 %%*1
+
+| --- Add the directories to our path ---
+
+_util hour -on
+IconSprites <DLL$Dir>.!Sprites
+Unset DLL$Path
+_util enumerate -nofiles <DLL$Dir> "_util pathUtil -create DLL$Path %%0."
+_util hour -off
+
+| --- Clear alias now we've finished ---
+
+Unset Alias$_util

diff --git a/StraySrc/!DLLs/!Sprites,ff9 b/StraySrc/!DLLs/!Sprites,ff9
new file mode 100644 (file)
index 0000000..e3cb75b
Binary files /dev/null and b/StraySrc/!DLLs/!Sprites,ff9 differ

diff --git a/StraySrc/!DLLs/!Sprites22,ff9 b/StraySrc/!DLLs/!Sprites22,ff9
new file mode 100644 (file)
index 0000000..8ff2ea0
Binary files /dev/null and b/StraySrc/!DLLs/!Sprites22,ff9 differ

diff --git a/StraySrc/Announce b/StraySrc/Announce
new file mode 100644 (file)
index 0000000..fe3c4a2
--- /dev/null
+++ b/StraySrc/Announce
@@ -0,0 +1,152 @@
+The Straylight Source Distribution
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+For a long while now, I've been pontificating in comp.sys.acorn.programmer
+about how clever I am, and how I know how to do things properly.  Most
+of the regular readers should now be thinking something along the lines
+of `This [mdw] chap seems to know what he's doing, although I've never
+seen any of his work.  He's been going on about these libraries and
+things but we've never seen them or seen any software which uses them.
+It all seems a bit fishy.'  Well, now's my time to put my money where my
+mouth is.  Straylight is releasing all of its source code.  Well, the
+interesting bits.
+
+The next question ought to be `why?'  Why am I doing this?  Well, there
+are two reasons, although they're both associated with Linux.  The first
+reason is that I've `seen the light' of Free software, and want to do
+something about my heretical past as a Software Hoarder.  I want to give
+my small contribution to the world, as Freely as the GNU and Linux teams
+are doing.  And I want to show off a bit, too.  The second reason is
+that I'm not doing much Acorn work at all any more.  Akasha (my RiscPC)
+spends most of her time turned off now, in favour of Excessus (my Linux
+PC), and I don't have the time or the inclination to maintain this
+rather large chunk of source code any more, so I'm giving it all to the
+community which inspired it.  It feels slightly like a sort of a swan
+song as I leave the Acorn world.
+
+I'll be releasing the code in dribs and drabs over the coming weeks,
+hopefully in a sensible order, so that all the software can be built
+with the parts already available.  Unfortunately, most of it was never
+designed to be source distributed, so there's no guarantees against
+mutual dependencies.  We'll work it out as we go along, hopefully.  The
+main components are:
+
+  * Some simple header files and libraries for assembling the code, and
+    some trivial utilities used in the build processes.
+
+  * BAS -- the Basic Assembler Supplement, which allows Basic programs
+    to generate AOF object code.  This is required for some of the other
+    build tools.
+
+  * SDLS -- the Straylight Dynamic Linking System.  This is already well
+    known, but not well used, I think.  Maybe the sources will be
+    interesting to someone.
+
+  * Dynamite -- our dynamic-area heap manager module.  Again, well known
+    software, so maybe the sources will provide some interest.
+
+  * Sculptrix -- Straylight's 3D border rendering module.  I'm very
+    proud of this code.  Provided also is the source to version 1, which
+    was a horrible hack made worse by poor modifications.  Version 2
+    does more, at the same speed, in less space, and more maintainably.
+
+  * STEEL -- the Straylight Extensive Event-driven Library.  This is a
+    grandiose name for a RISC_OSLib more-or-less rewrite.  There are
+    Issues involved here, which I'll try to resolve -- some of the
+    source files aren't `pure' Straylight code, which could cause
+    problems.  I recommend against anyone using STEEL -- it's just
+    needed by Glass, which is a jolly good piece of software.
+
+  * Glass -- Straylight's template editor.  It's actually the second
+    template editor I've written, although I'm thoroughly ashamed of the
+    first one.  It's been around for ages, quietly circulating around a
+    slowly increasing coterie of friends.  I suspect many readers
+    already have copies of Glass they shouldn't have.  Well, as of this
+    announcement, those copies become legal.  I'd be interested in
+    hearing how far this informal distribution had reached.
+
+  * A pile of silly utilities.  There's a mouse speed changer which
+    tries to read the current speed using underhand methods (i.e.,
+    peeking around OS workspace).  There's a rudimentary debugger Tim
+    wrote which might be the start of something useful.
+
+  * Sprinkle -- a little module exactly 256 bytes long which supports
+    linked lists of sprite areas.
+
+  * Constrain -- constrain the mouse pointer to a circle.  This is used
+    in one of Sapphire's custom controls.
+
+  * Sapphire -- not an acronym, but a weak pun on STEEL.  This is
+    STEEL's successor.  It's a comprehensive (I think) run-time support
+    system and RISC OS library for applications written in assembler.
+
+    There are a number of bits of Sapphire which are incomplete:
+
+      -- There's a scripting language, SAIL, which is based on the work
+         Straylight did on the Termite language.  There may be
+         complications on this code.
+
+      -- There's an interface for C programs, but it's very messy.  Many
+         bits of Sapphire require more expressive syntax for declaring
+         data structures than C provides.
+
+      -- There was going to be a wonderful colour selector, but it never
+         really got finished.  The good bits in the current version are
+         the RGB selector window (which is fully functional -- the
+         RGB colour square custom control is my favourite bit) and the
+         HSV colour circle, with its circular mouse constraint.
+
+      -- The threading code needs to be rewritten, and the rest of the
+         library ought to be properly multithreaded or locked.
+
+    My favourite innovations are:
+
+      -- The way filters work in the event manager.  We never needed to
+         change the way events got dispatched, because we got it right
+         the first time.
+
+      -- Custom controls in the dialogue box system.  This one was my
+         idea.
+
+      -- The menu system.  I like the way the same menu blocks can be
+         used for normal and tearoff menus.  (We designed the system
+         together over a pub lunch, but Tim did all the implementation
+         so lots of kudos for him.)
+
+      -- The viewer code, and the background-redrawing gallery stuff.
+         This was mine, although Tim had already done the listbox code
+         on which it was based.
+
+    There are a lot of good ideas in here (in my expert opinion) and
+    some clever tricks too.  I think that anyone maintaining a RISC OS
+    library should look in here.  It is, I hope, like Glass: an example
+    of the benefits of the Second System Effect.
+
+  * Sapphire example programs.  There's a small number of these, to show
+    how we expected people to write Sapphire programs.  They're all
+    lovingly crafted and perfectly formed.  Oh, yes.
+
+Documentation for all of these is going to be patchy at best.  The
+libraries are sort-of documented by their header files, and by the
+examples provided.
+
+That's all there'll be.
+
+On the matter of licensing: I'll apply the GNU Library General Public
+License to as much as I can, and the full General Public License to
+everything else.  Software which is already OFFICIALLY available under a
+different licence may continue to be licenced under those terms;
+however, the existing licences only cover unmodified binaries, so if you
+make modifications to the software, you're bound by all the restrictions
+of the GPL.
+
+Well, thanks for taking the time to read all of this.  It's been great
+working with RISC OS, but I think I've been doing it for too long.  I'll
+still hang around Acorn newsgroups and flame people whom I think are
+being stupid.  I will keep porting to RISC OS in mind as I continue to
+write, but as far as developing specifically for Acorn is concerned,
+that's all you get.
+
+It's 10:30 at night, I'm cold, and I've been typing this for too long.
+Goodbye.  It's been great.

diff --git a/StraySrc/BuildTools b/StraySrc/BuildTools
new file mode 100644 (file)
index 0000000..43c09eb
--- /dev/null
+++ b/StraySrc/BuildTools
@@ -0,0 +1,49 @@
+Build tools
+~~~~~~~~~~~
+
+Apart from the tools provided, you'll need the following programs to
+build the Straylight Source Release:
+
+cc             Acorn's C compiler
+objasm         Acorn's ARM assembler
+link           Acorn's linker
+libfile                Acorn's archiver
+squeeze                Acorn's executable compresser
+amu            Acorn's rather nasty make utility
+ccrunch                A BASIC cruncher
+sed            GNU's stream editor
+
+I recommend using the C5 versions of these tools; some of the source
+files may require C5 versions, but I'm not sure.
+
+A few pieces of code were deliberately built using the C4 versions of
+various tools, to ensure compatibility with people developing for RISC
+OS 2.  For this reason, some of the Makefiles assume the presence of
+programs `o-cc', `o-objasm', `o-link' and `o-libfile'; these are assumed
+to be the earlier versions.  If you only have one version of the
+compiler, assembler and tools, you can set aliases to make the
+`o-'-prefixed versions run the non-prefixed ones.
+
+The STEEL library may require bits of RISC_OSLib.  You won't be able to
+build STEEL or the programs which use it without RISC_OSLib.
+
+Everything else ought to be provided in the package.  There are a
+collection of strange tools we've created to help build our programs,
+and a few more written specially for this source release:
+
+buildstub      Builds Sapphire extension stubs
+enumerate      Run a *command for each file in a directory
+fixlink                Patches partially linked AOF files because link 4.00 is
+                       buggy
+hour           Hourglass control from Obey files
+inst           Install programs once they've been built
+msgaof         Compile a message file to linkable AOF
+pathutil       Manipulate path variables properly
+resgen         Tool for building DLLs containing shared resources
+setdate                Stamp the current date into an AOF file
+setslot                A replacement for *WimpSlot which understands flex
+ssrclean       Delete a lot of files at once
+submake                Tool for making recursive makes work
+templaof       Convert a template file into an embedded templates
+test           Test conditions in Obey files
+

diff --git a/StraySrc/COPYING b/StraySrc/COPYING
new file mode 100644 (file)
index 0000000..916d1f0
--- /dev/null
+++ b/StraySrc/COPYING
@@ -0,0 +1,339 @@
+                   GNU GENERAL PUBLIC LICENSE
+                      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.
+\f
+                   GNU GENERAL PUBLIC LICENSE
+   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.)
+\f
+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.
+\f
+  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.
+\f
+  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
+\f
+       Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    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
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

diff --git a/StraySrc/Dynamite/Makefile,fe1 b/StraySrc/Dynamite/Makefile,fe1
new file mode 100644 (file)
index 0000000..e362d22
--- /dev/null
+++ b/StraySrc/Dynamite/Makefile,fe1
@@ -0,0 +1,100 @@
+#
+# Makefile
+#
+# © 1998 Straylight/Edgeware
+#
+
+#----- Licensing note -------------------------------------------------------
+#
+# This makefile 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, or (at your option)
+# any later version.
+#
+# This makefile 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 makefile.  If not, write to the Free Software Foundation,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#----- Compilation flags ----------------------------------------------------
+
+# --- Uncomment to use the C4 tools ---
+
+# OLD = o-
+
+# --- C compilation ---
+
+CC = $(OLD)cc -c -o $@
+CFLAGS = -depend !Depend -throwback -ffah -Ilibs: -IC:
+COMPILE = $(CC) $(CFLAGS)
+
+# --- Assembling ---
+
+AS = $(OLD)objasm -quit -to $@
+ASFLAGS = -stamp -depend !Depend -throwback
+ASSEMBLE = $(AS) $(ASFLAGS) -from
+
+BAS = basasm
+
+# --- Linking ---
+
+LD = $(OLD)link -o $@
+LD_APP = $(LD) -aif
+LD_UTIL = $(LD) -bin -base 0
+LD_MOD = $(LD) -bin -base 0
+LD_BIN = $(LD) -bin -base 0
+LD_DLL = $(LD) -rmf
+LD_AOF = $(LD) -aof
+
+# --- Making libraries ---
+
+AR = $(OLD)libfile -o
+
+CDLL = cdll
+
+# --- Setting file types ---
+
+SET_APP = SetType $@ FF8
+SET_MOD = SetType $@ FFA
+SET_UTIL = SetType $@ FFC
+SET_DLL = SetType $@ FFD
+
+# --- Other maintenance things ---
+
+RM = ssrclean
+INSTALL = inst
+SETDATE = setdate
+SQUEEZE = squeeze $@
+DATE = %zdy %mo %ce%yr
+MODDATE = %dy %m3 %ce%yr
+CRIGHT = © %ce%yr Straylight
+FIXLINK = fixlink $@
+
+#----- Default rules --------------------------------------------------------
+
+.SUFFIXES: .o .c .s .bs
+.c.o:
+       $(COMPILE) $<
+.s.o:
+       $(ASSEMBLE) $<
+.bs.o:
+       $(BAS) $< $@
+
+#----- Compiling things -----------------------------------------------------
+
+all:
+       submake *.Makefile
+
+install:
+       submake *.Makefile -- install
+
+clean:
+       submake *.Makefile -- clean
+
+#----- Dynamic dependencies -------------------------------------------------
+
+# Dynamic dependencies:

diff --git a/StraySrc/Dynamite/apcs/Makefile,fe1 b/StraySrc/Dynamite/apcs/Makefile,fe1
new file mode 100644 (file)
index 0000000..d557229
--- /dev/null
+++ b/StraySrc/Dynamite/apcs/Makefile,fe1
@@ -0,0 +1,105 @@
+#
+# Makefile
+#
+# © 1998 Straylight/Edgeware
+#
+
+#----- Licensing note -------------------------------------------------------
+#
+# This makefile 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, or (at your option)
+# any later version.
+#
+# This makefile 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 makefile.  If not, write to the Free Software Foundation,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#----- Compilation flags ----------------------------------------------------
+
+# --- Uncomment to use the C4 tools ---
+
+# OLD = o-
+
+# --- C compilation ---
+
+CC = $(OLD)cc -c -o $@
+CFLAGS = -depend !Depend -throwback -ffah -Ilibs: -IC:
+COMPILE = $(CC) $(CFLAGS)
+
+# --- Assembling ---
+
+AS = $(OLD)objasm -quit -to $@
+ASFLAGS = -stamp -depend !Depend -throwback
+ASSEMBLE = $(AS) $(ASFLAGS) -from
+
+BAS = basasm
+
+# --- Linking ---
+
+LD = $(OLD)link -o $@
+LD_APP = $(LD) -aif
+LD_UTIL = $(LD) -bin -base 0
+LD_MOD = $(LD) -bin -base 0
+LD_BIN = $(LD) -bin -base 0
+LD_DLL = $(LD) -rmf
+LD_AOF = $(LD) -aof
+
+# --- Making libraries ---
+
+AR = $(OLD)libfile -o
+
+CDLL = cdll
+
+# --- Setting file types ---
+
+SET_APP = SetType $@ FF8
+SET_MOD = SetType $@ FFA
+SET_UTIL = SetType $@ FFC
+SET_DLL = SetType $@ FFD
+
+# --- Other maintenance things ---
+
+RM = ssrclean
+INSTALL = inst
+SETDATE = setdate
+SQUEEZE = squeeze $@
+DATE = %zdy %mo %ce%yr
+MODDATE = %dy %m3 %ce%yr
+CRIGHT = © %ce%yr Straylight
+FIXLINK = fixlink $@
+
+#----- Default rules --------------------------------------------------------
+
+.SUFFIXES: .o .c .s .bs
+.c.o:
+       $(COMPILE) $<
+.s.o:
+       $(ASSEMBLE) $<
+.bs.o:
+       $(BAS) $< $@
+
+#----- Compiling things -----------------------------------------------------
+
+all: o.dynamite
+
+o.dynamite: o.dyn_apcs
+       $(AR) -c o.dynamite o.dyn_apcs
+
+install: o.dynamite
+
+clean:
+       -$(RM) o.*
+
+#----- Dynamic dependencies -------------------------------------------------
+
+# Dynamic dependencies:
+o.dyn_apcs: s.dyn_apcs
+o.dyn_apcs: libs:header
+o.dyn_apcs: libs:swis
+o.dyn_apcs: libs:stream

diff --git a/StraySrc/Dynamite/apcs/h/dynamite b/StraySrc/Dynamite/apcs/h/dynamite
new file mode 100644 (file)
index 0000000..7eb8c1a
--- /dev/null
+++ b/StraySrc/Dynamite/apcs/h/dynamite
@@ -0,0 +1,377 @@
+/*
+ * dynamite.h
+ *
+ * Interface to Dynamite SWIs
+ *
+ * © 1997 Straylight
+ */
+
+/*----- Licensing note ----------------------------------------------------*
+ *
+ * This file is part of Straylight's Dynamite
+ *
+ * Dynamite 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, or (at your option)
+ * any later version.
+ *
+ * Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __dynamite_h
+#define __dynamite_h
+
+/*----- Notes -------------------------------------------------------------*
+ *
+ * The interfaces to Dynamite have been written in assembler.  This has the
+ * benefit of making them very small and minimising procedure call overhead.
+ * It also has the disadvantage of not setting _kernel_last_oserror()
+ * properly.  If this is important, you should use _kernel_swi() directly.
+ *
+ * The SWI interface routines are safe to call from SVC mode (e.g. in a
+ * C module).
+ */
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+/*------ Important types --------------------------------------------------*/
+
+/* --- dynamite_anchor --- *
+ *
+ * This is the type of a Dynamite anchor.  It should only be used within
+ * these declarations, since it exists to keep the compiler happy and make
+ * the declarations look neat.  Your actual anchors will have various types
+ * depending on what you want to store in your Dynamite blocks.
+ *
+ * To avoid casts, we cheat horridly, and in the knowledge that we will only
+ * be dealing with the *address* of an anchor we macro dynamite_anchor to
+ * void, so that its address is a void *.
+ */
+
+#define dynamite_anchor void
+
+/* --- dynamite_error --- *
+ *
+ * This is the type of error which Dynamite SWIs return.  Depending on
+ * whether you're using RISC_OSLib or not, you may want these to return
+ * os_errors or _kernel_oserrors, or its own special type.  All these error
+ * structures have the same format and member names -- it's just a matter of
+ * naming the structure.
+ *
+ * The way we sort all this out is by allowing the client to set up a macro
+ * to tell us what to do.
+ */
+
+#if defined(dynamite_USE_OS_ERROR)
+
+  #ifndef __os_h
+    #include "os.h"
+  #endif
+
+  typedef os_error dynamite_error;
+
+#elif defined(dynamite_USE_KERNEL_OSERROR)
+
+  #ifndef __kernel_h
+    #include "kernel.h"
+  #endif
+
+  typedef _kernel_oserror dynamite_error;
+
+#elif !defined(dynamite_error)
+
+  typedef struct dynamite_error
+  {
+    int errnum;                         /* Error number */
+    char errmess[252];                  /* Error message text */
+  }
+  dynamite_error;
+
+#endif
+
+/* --- dynstr_blockInfo --- *
+ *
+ * This structure contains the information dynamite_blockInfo() returns.
+ */
+
+typedef struct dynstr_blockInfo
+{
+  int size;                             /* Block size in bytes */
+  int blockID;                          /* Block's ID number */
+}
+dynstr_blockInfo;
+
+/* --- dynstr_describe --- *
+ *
+ * This structure contains the information dynamite_describe() returns.
+ */
+
+typedef struct dynstr_describe
+{
+  int area;                             /* Dynamic area handle, or -1 */
+  int size;                             /* Total size of Dynamite area */
+  int unused;                           /* Space unused in Dynamite area */
+}
+dynstr_describe;
+
+/*----- Interface functions -----------------------------------------------*
+ *
+ * Most of these return a pointer to a dynamite_error structure.  If the
+ * call was successful, this pointer will be null.
+ *
+ * However, where errors are unlikely and a value return is more natural,
+ * this is not the case.
+ *
+ * To check for the existance of Dynamite you should check the return value
+ * of dynamite_describe() for an error.
+ */
+
+/* --- dynamite_alloc --- *
+ *
+ * Arguments:   anchor == address of the anchor to use
+ *              size == the size to allocate, in bytes
+ *              id == the id value to give to the block
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Allocates memory from the Dynamite heap.  If successful,
+ *              *anchor on exit contains the address of the block allocated.
+ *              Note that the anchor must *not* be in application space --
+ *              use dynamite_claimAnchor to get one from the RMA if you
+ *              don't have other RMA data.
+ */
+
+extern dynamite_error *dynamite_alloc(dynamite_anchor */*anchor*/,
+                                      int /*size*/,
+                                      int /*id*/);
+
+/* --- dynamite_free --- *
+ *
+ * Arguments:   anchor == the address of block's anchor
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Frees memory in the Dynamite heap.  The memory is marked
+ *              as being free, but no blocks are moved -- this makes freeing
+ *              lots of blocks very fast.
+ */
+
+extern dynamite_error *dynamite_free(dynamite_anchor */*anchor*/);
+
+/* --- dynamite_freeWithID --- *
+ *
+ * Arguments:   id == the ID of the blocks to free
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Frees all blocks with the given ID value.  This allows
+ *              applications and modules to free all their allocated blocks
+ *              when they close down.
+ */
+
+extern dynamite_error *dynamite_freeWithID(int /*id*/);
+
+/* --- dynamite_blockInfo --- *
+ *
+ * Arguments:   anchor == address of block's anchor
+ *              info == address of structure to fill in
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Returns information about a Dynamite block.
+ */
+
+extern dynamite_error *dynamite_blockInfo(dynamite_anchor */*anchor*/,
+                                          dynstr_blockInfo */*info*/);
+
+/* --- dynamite_changeID --- *
+ *
+ * Arguments:   anchor == address of block's anchor, or 0 for all blocks
+ *              newID == new ID to set for block or blocks
+ *              oldID == optional old ID of blocks to change, if anchor == 0
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Changes the ID of a block or blocks.  If you specify a single
+ *              block by passing a nonzero anchor, you don't have to specify
+ *              an oldID value.
+ */
+
+extern dynamite_error *dynamite_changeID(dynamite_anchor */*anchor*/,
+                                         int /*newID*/,...
+                                      /* int oldID */);
+
+/* --- dynamite_resize --- *
+ *
+ * Arguments:   anchor == address of block's anchor
+ *              size == new size to make block
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Changes a block's size.  If you make the block larger, the
+ *              data will be unchanged.  If you reduce the size, data at the
+ *              end will be deleted.  The block will usually move as a
+ *              result of this operation.
+ */
+
+extern dynamite_error *dynamite_resize(dynamite_anchor */*anchor*/,
+                                       int /*size*/);
+
+/* --- dynamite_midExtend --- *
+ *
+ * Arguments:   anchor == address of block's anchor
+ *              at == offset within block at which to insert or remove bytes
+ *              by == (signed) number of bytes to insert
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Inserts or removes bytes in a block at a given offset.
+ *              See the manual for a complete description of this call.
+ */
+
+extern dynamite_error *dynamite_midExtend(dynamite_anchor */*anchor*/,
+                                          int /*at*/,
+                                          int /*by*/);
+
+/* --- dynamite_save --- *
+ *
+ * Arguments:   value == value to save on the relocation stack
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Saves a value on the Dynamite relocation stack.  You can
+ *              only save one value at a time through this interface.
+ */
+
+extern dynamite_error *dynamite_save(void */*value*/);
+
+/* --- dynamite_load --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     The value from the top of the relocation stack.
+ *
+ * Use:         Loads a value from Dynamite's relocation stack and returns
+ *              it.  You can only restore one value at a time through this
+ *              interface.
+ */
+
+extern void *dynamite_load(void);
+
+/* --- dynamite_reduce --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     0 if heap couldn't be compacted, non-0 if it could
+ *
+ * Use:         Performs a partial compaction of the Dynamite heap.
+ */
+
+extern int dynamite_reduce(void);
+
+/* --- dynamite_compact --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     Pointer to possible error.
+ *
+ * Use:         Fully compacts the Dynamite heap.  This is equivalent to
+ *
+ *                while (dynamite_reduce())
+ *                  ;
+ */
+
+extern dynamite_error *dynamite_compact(void);
+
+/* --- dynamite_lock --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     Pointer to a possible error
+ *
+ * Use:         Locks the heap, stopping any blocks not explicitly resized
+ *              from being moved -- this basically just disables compaction.
+ *              You *must* lock the heap while it is being used within a
+ *              callback or SWI handler.
+ */
+
+extern dynamite_error *dynamite_lock(void);
+
+/* --- dynamite_unlock --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     Pointer to a possible error
+ *
+ * Use:         Unlocks the heap, allowing compaction to take place again.
+ */
+
+extern dynamite_error *dynamite_unlock(void);
+
+/* --- dynamite_claimAnchor --- *
+ *
+ * Arguments:   ancptr == where to store the address of the anchor
+ *
+ * Returns:     Pointer to a possible error
+ *
+ * Use:         Allocates an anchor from the RMA and returns its address.
+ */
+
+extern dynamite_error *dynamite_claimAnchor(dynamite_anchor **/*ancptr*/);
+
+/* --- dynamite_releaseAnchor --- *
+ *
+ * Arguments:   anchor == address of anchor to release
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         Frees an anchor allocated by dynamite_claimAnchor.
+ */
+
+extern dynamite_error *dynamite_releaseAnchor(dynamite_anchor */*anchor*/);
+
+/* --- dynamite_readSpriteSize --- *
+ *
+ * Arguments:   --
+ *
+ * Returns:     Actual size of sprite area in bytes
+ *
+ * Use:         Returns the real size of the sprite area -- before RISC OS
+ *              3.5, Dynamite has to fake the return value from
+ *              OS_ReadDynamicArea so that you can no longer work out how
+ *              much memory is free in the system.  This call allows you
+ *              to find the real sprite area size.
+ */
+
+extern int dynamite_readSpriteSize(void);
+
+/* --- dynamite_describe --- *
+ *
+ * Arguments:   desc == address of structure to fill in, or 0
+ *
+ * Returns:     Pointer to possible error
+ *
+ * Use:         If desc is nonzero, this call will read some useful
+ *              information about the Dynamite heap.  If desc is 0, it will
+ *              return an error if Dynamite is not loaded -- you can
+ *              therefore test for Dynamite's presence.
+ */
+
+extern dynamite_error *dynamite_describe(dynstr_describe */*desc*/);
+
+/*----- That's all, folks -------------------------------------------------*/
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif

diff --git a/StraySrc/Dynamite/apcs/s/dyn_apcs b/StraySrc/Dynamite/apcs/s/dyn_apcs
new file mode 100644 (file)
index 0000000..02021d5
--- /dev/null
+++ b/StraySrc/Dynamite/apcs/s/dyn_apcs
@@ -0,0 +1,282 @@
+;
+; dyn_apcs.s
+;
+; APCS interface to Dynamite SWIs
+;
+; © 1994-1998 Straylight
+;
+
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+               GET     libs:stream
+
+;----- Main code ------------------------------------------------------------
+
+               AREA    |C$$Code|,CODE,READONLY
+
+; --- dynamite_alloc ---
+;
+; On entry:    a1 == address of anchor
+;              a2 == size of block, in bytes
+;              a3 == block ID
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_alloc
+dynamite_alloc
+               MOV     ip,lr
+               SWI     XDynamite_Alloc
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_free ---
+;
+; On entry:    a1 == address of anchor
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_free
+dynamite_free
+               MOV     ip,lr
+               SWI     XDynamite_Free
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_freeWithID ---
+;
+; On entry:    a1 == block ID (must be non-zero)
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_freeWithID
+dynamite_freeWithID
+               MOV     ip,lr
+               SWI     XDynamite_FreeWithID
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_blockInfo ---
+;
+; On entry:    a1 == address of block anchor
+;              a2 == address of structure to fill in
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_blockInfo
+dynamite_blockInfo
+               STMFD   sp!,{lr}
+               MOV     ip,a2
+               SWI     XDynamite_BlockInfo
+               STMVCIA ip,{a3,a4}
+               MOVVC   a1,#0
+               LDMFD   sp!,{pc}^
+
+; --- dynamite_changeID ---
+;
+; On entry:    a1 == address of anchor, or 0
+;              a2 == new ID
+;              a3 == (optional) old ID
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_changeID
+dynamite_changeID
+               MOV     ip,lr
+               SWI     XDynamite_ChangeID
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_resize ---
+;
+; On entry:    a1 == address of anchor
+;              a2 == new size, in bytes
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_resize
+dynamite_resize
+               MOV     ip,lr
+               SWI     XDynamite_Resize
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_midExtend ---
+;
+; On entry:    a1 == address of anchor
+;              a2 == offset at which to extend
+;              a3 == number of bytes to add
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_midExtend
+dynamite_midExtend
+               MOV     ip,lr
+               SWI     XDynamite_MidExtend
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_save ---
+;
+; On entry:    a1 == value to save
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_save
+dynamite_save
+               MOV     ip,lr
+               MOV     a2,a1
+               MOV     a1,#2
+               SWI     XDynamite_Save
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_load ---
+;
+; On entry:    --
+;
+; On exit:     a1 == value loaded from relocation stack
+
+               EXPORT  dynamite_load
+dynamite_load
+               MOV     ip,lr
+               MOV     a1,#1
+               SWI     XDynamite_Load
+               MOVS    pc,ip
+
+; --- dynamite_reduce ---
+;
+; On entry:    --
+;
+; On exit:     a1 == 0 if compaction not performed, nonzero otherwise
+
+               EXPORT  dynamite_reduce
+dynamite_reduce
+               MOV     ip,lr
+               SWI     XDynamite_Reduce
+               MOVCC   a1,#1
+               MOVCS   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_compact ---
+;
+; On entry:    --
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_compact
+dynamite_compact
+               MOV     ip,lr
+               SWI     XDynamite_Compact
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_lock ---
+;
+; On entry:    --
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_lock
+dynamite_lock
+               MOV     ip,lr
+               SWI     XDynamite_Lock
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_unlock ---
+;
+; On entry:    --
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_unlock
+dynamite_unlock
+               MOV     ip,lr
+               SWI     XDynamite_Unlock
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_claimAnchor ---
+;
+; On entry:    a1 == address of where to store anchor
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_claimAnchor
+dynamite_claimAnchor
+               MOV     ip,lr
+               MOV     a2,a1
+               SWI     XDynamite_ClaimAnchor
+               STRVC   a1,[a2,#0]
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_releaseAnchor ---
+;
+; On entry:    a1 == address of anchor
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_releaseAnchor
+dynamite_releaseAnchor
+               MOV     ip,lr
+               SWI     XDynamite_ReleaseAnchor
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_readSpriteSize ---
+;
+; On entry:    a1 == where to store the sprite size
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_readSpriteSize
+dynamite_readSpriteSize
+               MOV     ip,lr
+               MOV     a2,a1
+               SWI     XDynamite_ReadSpriteSize
+               STRVC   a1,[a2,#0]
+               MOVVC   a1,#0
+               MOVS    pc,ip
+
+; --- dynamite_describe ---
+;
+; On entry:    a1 == address of a structure to fill in
+;
+; On exit:     a1 == 0 or pointer to error
+
+               EXPORT  dynamite_describe
+dynamite_describe
+               MOV     ip,lr
+               MOV     a4,a1
+               SWI     XDynamite_Describe
+               MOVVS   pc,ip
+               CMP     a4,#0
+               STMNEIA a4,{a1-a3}
+               MOV     a1,#0
+               MOVS    pc,ip
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/Makefile,fe1 b/StraySrc/Dynamite/dynamite/Makefile,fe1
new file mode 100644 (file)
index 0000000..7f5d72d
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/Makefile,fe1
@@ -0,0 +1,183 @@
+#
+# Makefile
+#
+# © 1998 Straylight/Edgeware
+#
+
+#----- Licensing note -------------------------------------------------------
+#
+# This makefile 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, or (at your option)
+# any later version.
+#
+# This makefile 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 makefile.  If not, write to the Free Software Foundation,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#----- Compilation flags ----------------------------------------------------
+
+# --- Uncomment to use the C4 tools ---
+
+# OLD = o-
+
+# --- C compilation ---
+
+CC = $(OLD)cc -c -o $@
+CFLAGS = -depend !Depend -throwback -ffah -Ilibs: -IC:
+COMPILE = $(CC) $(CFLAGS)
+
+# --- Assembling ---
+
+AS = $(OLD)objasm -quit -to $@
+ASFLAGS = -stamp -depend !Depend -throwback
+ASSEMBLE = $(AS) $(ASFLAGS) -from
+
+BAS = basasm
+
+# --- Linking ---
+
+LD = $(OLD)link -o $@
+LD_APP = $(LD) -aif
+LD_UTIL = $(LD) -bin -base 0
+LD_MOD = $(LD) -bin -base 0
+LD_BIN = $(LD) -bin -base 0
+LD_DLL = $(LD) -rmf
+LD_AOF = $(LD) -aof
+
+# --- Making libraries ---
+
+AR = $(OLD)libfile -o
+
+CDLL = cdll
+
+# --- Setting file types ---
+
+SET_APP = SetType $@ FF8
+SET_MOD = SetType $@ FFA
+SET_UTIL = SetType $@ FFC
+SET_DLL = SetType $@ FFD
+
+# --- Other maintenance things ---
+
+RM = ssrclean
+INSTALL = inst
+SETDATE = setdate
+SQUEEZE = squeeze $@
+DATE = %zdy %mo %ce%yr
+MODDATE = %dy %m3 %ce%yr
+CRIGHT = © %ce%yr Straylight
+FIXLINK = fixlink $@
+
+#----- Default rules --------------------------------------------------------
+
+.SUFFIXES: .o .c .s .bs
+.c.o:
+       $(COMPILE) $<
+.s.o:
+       $(ASSEMBLE) $<
+.bs.o:
+       $(BAS) $< $@
+
+#----- Object files ---------------------------------------------------------
+
+OBJS = \
+       o.dynamite \
+       o.dynAnchor o.dynArea o.dynHeap o.dynTask o.fastMove \
+       o.messages
+
+#----- Compiling things -----------------------------------------------------
+
+all: Dynamite
+
+Dynamite: $(OBJS)
+       $(SETDATE) o.version version="Dynamite\t1.21 ($(MODDATE)) $(CRIGHT)"
+       $(LD_MOD) $(OBJS) o.version
+       $(SET_MOD)
+
+o.messages: rsc.messages
+       msgaof rsc.messages o.messages sh.messages
+
+install: Dynamite
+       $(INSTALL) Dynamite <SSR$ModDir>
+
+clean:
+       -$(RM) o.* Dynamite
+
+#----- Dynamic dependencies -------------------------------------------------
+
+# Dynamic dependencies:
+o.dynamite: s.dynamite
+o.dynamite: libs:header
+o.dynamite: libs:swis
+o.dynamite: libs:stream
+o.dynamite: sh.dynAnchor
+o.dynamite: sh.dynArea
+o.dynamite: sh.dynHeap
+o.dynamite: sh.dynTask
+o.dynamite: sh.wSpace
+o.dynamite: sh.messages
+o.dynamite: s.dynamite
+o.dynamite: libs:header
+o.dynamite: libs:swis
+o.dynamite: libs:stream
+o.dynamite: sh.dynAnchor
+o.dynamite: sh.dynArea
+o.dynamite: sh.dynHeap
+o.dynamite: sh.dynTask
+o.dynamite: sh.wSpace
+o.dynamite: sh.messages
+o.dynamite: s.dynamite
+o.dynamite: libs:header
+o.dynamite: libs:swis
+o.dynamite: libs:stream
+o.dynamite: sh.dynAnchor
+o.dynamite: sh.dynArea
+o.dynamite: sh.dynHeap
+o.dynamite: sh.dynTask
+o.dynamite: sh.wSpace
+o.dynamite: sh.messages
+o.dynamite: s.dynamite
+o.dynamite: libs:header
+o.dynamite: libs:swis
+o.dynamite: libs:stream
+o.dynamite: sh.dynAnchor
+o.dynamite: sh.dynArea
+o.dynamite: sh.dynHeap
+o.dynamite: sh.dynTask
+o.dynamite: sh.wSpace
+o.dynamite: sh.messages
+o.dynAnchor: s.dynAnchor
+o.dynAnchor: libs:header
+o.dynAnchor: libs:swis
+o.dynAnchor: sh.wSpace
+o.dynArea: s.dynArea
+o.dynArea: libs:header
+o.dynArea: libs:swis
+o.dynArea: libs:stream
+o.dynArea: sh.wSpace
+o.dynHeap: s.dynHeap
+o.dynHeap: libs:header
+o.dynHeap: libs:swis
+o.dynHeap: libs:stream
+o.dynHeap: libs:sh.fastMove
+o.dynHeap: sh.dynArea
+o.dynHeap: sh.dynTask
+o.dynHeap: sh.wSpace
+o.dynHeap: sh.messages
+o.dynTask: s.dynTask
+o.dynTask: libs:header
+o.dynTask: libs:swis
+o.dynTask: libs:stream
+o.dynTask: sh.dynHeap
+o.dynTask: sh.wSpace
+o.dynTask: sh.messages
+o.fastMove: s.fastMove
+o.fastMove: libs:s.fastMove
+o.fastMove: libs:header
+o.fastMove: libs:swis

diff --git a/StraySrc/Dynamite/dynamite/rsc/messages b/StraySrc/Dynamite/dynamite/rsc/messages
new file mode 100644 (file)
index 0000000..3bfa575
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/rsc/messages
@@ -0,0 +1,82 @@
+;
+; Dynamite messages
+;
+; © 1995 Straylight
+;
+
+;----- Miscellaneous messages -----------------------------------------------
+
+; --- Heap dump messages ---
+
+dumpHpBase: Heap base: &
+dumpHpSize: Heap size: &
+dumpHpArSz: Area size: &
+
+dumpBlkAddr:Block address: &
+dumpBlkSize:Block size   : &
+dumpBlkId:  Block ID     : &
+dumpBlkAnch:Block anchor : &
+dumpBlkFree:Block is free<&0D><&0A>
+
+;----- Error messages -------------------------------------------------------
+
+; --- Finalisation errors ---
+
+errInUse:[1]Dynamite is in use and cannot close down
+errRelease:[1]Dynamite cannot close down (couldn't release vector)
+
+; --- ChangeDynamicArea patch errors ---
+
+errTooBig:[&1C1]Unable to move memory
+
+; --- SWI handling errors ---
+
+errBadSWI:[&1E6]Unknown Dynamite operation
+
+; --- Page manager errors ---
+
+errNoPages:[1]No pages left
+
+; --- Heap manager errors ---
+
+errBadFreeAll:[&80D310]Can't free all blocks with ID 0
+errBadAnchor:[&80D301]Bad anchor passed to Dynamite
+errNoMem:[&80D300]Couldn't allocate memory
+errBadMid:[&80D302]Bad arguments passed to Dynamite_(Mid)Extend
+
+; --- Heap integrity errors ---
+
+errBadHeap1:[&80D312]Dynamite area corrupt: anchor or anchor address corrupted
+errBadHeap2:[&80D312]Dynamite area corrupt: block length corrupted
+errBadHeap3:[&80D312]Dynamite area corrupt: anchor address corrupted
+
+; --- Compactor task errors ---
+
+errDesk:[1]Use *Desktop to start the Dynamite compactor
+
+;----- Command help and syntax strings --------------------------------------
+
+clear:{
+  *Dynamite_Clear will empty the Dynamite heap, releasing all the \
+  memory it was using.
+  Warning: No confirmation is requested; if applications are using \
+  Dynaite, they will almost certainly crash.
+  |
+  Syntax: *Dynamite_Clear\
+}
+
+compactor:{
+  The DynamiteCompactor task performs background compaction on the \
+  Dynamite heap, reducing the amount of memory the area uses.
+  Do not use *Desktop_DynamiteCompactor; use *Desktop instead.
+  |
+  Syntax: *Desktop_DynamiteCompactor\
+}
+
+heapDump:{
+  *Dynamite_HeapDump displays diagnostic information about the state of \
+  Dynamite's memory area.  This information may be of use to programmers \
+  debugging applications which use Dynamite.
+  |
+  Syntax: *Dynamite_HeapDump\
+}

diff --git a/StraySrc/Dynamite/dynamite/s/dynAnchor b/StraySrc/Dynamite/dynamite/s/dynAnchor
new file mode 100644 (file)
index 0000000..e429dbe
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/dynAnchor
@@ -0,0 +1,146 @@
+;
+; dynAnchor.s
+;
+; Useful handle RMA allocation for dynamite
+;
+; © 1994-1998 Straylight
+;
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+;----- External dependencies ------------------------------------------------
+
+               GET     sh.wSpace
+
+;----- Constants ------------------------------------------------------------
+
+danc__chunk    EQU     16                      ;Number of handles to get
+
+;----- Main code ------------------------------------------------------------
+
+               AREA    |Dynamite$$Code|,CODE,READONLY
+
+; --- danc_alloc ---
+;
+; On entry:    --
+;
+; On exit:     R0 == pointer to block allocated, or V set and pointer to
+;                    error
+;
+; Use:         Allocates an anchor to use with dynamite from the RMA,
+;              in a very quick way indeed.
+
+               EXPORT  danc_alloc
+danc_alloc     ROUT
+
+               STMFD   R13!,{R1-R3,R14}
+
+               ; --- Are there any free blocks? ---
+
+               LDR     R2,dyn_ancTable         ;Get the free list offset
+               CMP     R2,#0                   ;Are there any free blocks?
+               BEQ     %01danc_alloc           ;No -- better allocate some
+
+               ; --- Mess about with the free list and return ---
+
+00danc_alloc   LDR     R3,[R2]                 ;Get next pointer from block
+               STR     R3,dyn_ancTable         ;This is now first free block
+               MOV     R0,R2                   ;Point to the block
+               LDMFD   R13!,{R1-R3,PC}^        ;Restore registers and return
+
+               ; --- Create a big block ---
+
+01danc_alloc   MOV     R0,#6                   ;Allocate memory please
+               MOV     R3,#danc__chunk*4+4     ;Get the chunk size
+               SWI     XOS_Module              ;Allocate the big block then
+               LDMVSFD R13!,{R1-R3,PC}         ;If it failed, return error
+
+               LDR     R14,dyn_ancList         ;Load current list head
+               STR     R2,dyn_ancList          ;Save this as new list head
+               STR     R14,[R2],#4             ;And save old list head
+
+               ; --- Now set up the links for the free list ---
+
+               MOV     R0,#0                   ;Next free pointer start at 0
+               SUB     R3,R3,#8                ;Offset to next field of sub
+02danc_alloc   STR     R0,[R2,R3]              ;Store in next field
+               ADD     R0,R2,R3                ;Point to that block
+               SUBS    R3,R3,#4                ;Point to previous block
+               BGE     %02danc_alloc           ;If more to do, continue...
+
+               ; --- The links are set up -- now take off a block ---
+
+               B       %00danc_alloc           ;Then allocate as normal
+
+               LTORG
+
+; --- danc_free ---
+;
+; On entry:    R0 == pointer to block
+;
+; On exit:     Registers preserved
+;
+; Use:         Frees an anchor allocated using danc_alloc.
+
+               EXPORT  danc_free
+danc_free      ROUT
+
+               STMFD   R13!,{R0,R1,R14}        ;Preserve registers
+
+               ; --- Mess about with the list ---
+
+               LDR     R1,dyn_ancTable         ;Get current first block
+               STR     R1,[R0]                 ;Store in newly freed block
+               STR     R0,dyn_ancTable         ;And insert new block in list
+               LDMFD   R13!,{R0,R1,PC}^        ;Oh, and return to caller
+
+               LTORG
+
+; --- danc_quit ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Frees everyone's anchors nicely when the module quits.
+
+               EXPORT  danc_quit
+danc_quit      ROUT
+
+               STMFD   R13!,{R0-R2,R14}        ;Save some registers
+               LDR     R2,dyn_ancList          ;Load the list head
+               CMP     R2,#0                   ;Is there anything to do?
+               LDMEQFD R13!,{R0-R2,PC}^        ;No -- return then
+               MOV     R0,#7                   ;Free RMA block
+00danc_quit    LDR     R1,[R2,#0]              ;Load the next pointer
+               SWI     XOS_Module              ;Free the block
+               MOVS    R2,R1                   ;Point to next one
+               BNE     %00danc_quit            ;And loop round for more
+               LDMFD   R13!,{R0-R2,PC}^        ;Return when all done
+
+               LTORG
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/s/dynArea b/StraySrc/Dynamite/dynamite/s/dynArea
new file mode 100644 (file)
index 0000000..3eaf733
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/dynArea
@@ -0,0 +1,325 @@
+;
+; dynArea.s
+;
+; The handling of the dynamic area itself
+;
+; © 1994-1998 Straylight
+;
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+               GET     libs:stream
+
+;----- External dependencies ------------------------------------------------
+
+               GET     sh.wSpace
+
+;----- Main code ------------------------------------------------------------
+
+               AREA    |Dynamite$$Code|,CODE,READONLY
+
+; --- da_findPage ---
+;
+; On entry:    R2 == address of the page
+;
+; On exit:     R0 == page number
+;
+; Use:         Finds the page number of the page with the address given.
+
+               EXPORT  da_findPage
+da_findPage    ROUT
+
+               STMFD   R13!,{R1,R7-R9,R14}     ;Stack the link
+               LDR     R14,dyn_machine         ;Load the machine type
+               CMP     R14,#&A3                ;RISC OS 3?
+               BCS     %10da_findPage          ;Yes -- jump ahead then
+
+               LDR     R9,dyn_pageCount        ;Load number of pages-1
+               MOV     R14,#&164               ;Find CAM map (RO 2 and 3!)
+               ADD     R9,R14,R9,LSL #2        ;Last valid entry
+               MOV     R8,R2,LSL #4            ;The address of interest << 4
+               SUB     R7,R14,#4               ;We're pre-indexing
+00da_findPage  CMP     R7,R9                   ;Have we finished?
+               LDRNE   R1,[R7,#4]!             ;Load out the entry
+               TEQNE   R8,R1,LSL #4            ;Is this a match?
+               BNE     %00da_findPage          ;No -- keep on looking
+               TEQ     R8,R1,LSL #4            ;Was that a match?
+               SUBEQ   R7,R7,R14               ;Yes -- get offset from base
+               MOVEQ   R0,R7,LSR #2            ;And turn into page number
+               MOVNE   R0,#-1                  ;Otherwise return -1
+               LDMFD   R13!,{R1,R7-R9,PC}^     ;Return to caller
+
+               ; --- We are on RISC OS 3 ---
+
+10da_findPage  MOV     R1,#0                   ;Start at this page
+               MOV     R14,#-1                 ;Get a terminator
+               STMDB   R13!,{R1,R2,R3,R14}     ;Store that in block
+               MOV     R0,R13                  ;Point to the block
+               SWI     OS_FindMemMapEntries    ;Find the page number
+               LDR     R0,[R13],#16            ;Load the page number
+               LDMFD   R13!,{R1,R7-R9,PC}^     ;Return to caller
+
+               LTORG
+
+; --- da_addPages ---
+;
+; On entry:    R0 == number of pages to add
+;              R12 == workspace address
+;
+; On exit:     Possible error returned
+;
+; Use:         Increases the size of the dynamic area by the number of
+;              pages given in R0
+
+               EXPORT  da_addPages
+da_addPages    ROUT
+
+               STMFD   R13!,{R0-R9,R14}        ;Save some registers
+
+               LDR     R9,dyn_machine          ;What machine are we on?
+               CMP     R9,#&A5                 ;Is it a RISC PC?
+               BGE     %50da_addPages          ;Yes -- do things differently
+
+               MOVS    R9,R0                   ;Remember this value
+               BEQ     %10da_addPages          ;Nothing to do -- return
+               LDR     R14,dyn_sprSize         ;Get address of spr area size
+               LDR     R14,[R14]               ;Get the size out
+               LDR     R1,dyn_areaSize         ;Find our area size
+               SUB     R4,R14,R1               ;Find top of system sprites
+               ADD     R2,R4,#&01400000        ;Top of sprite area
+
+               LDR     R3,dyn_log2PageSize     ;Find page size of machine
+               MOV     R5,R9,LSL R3            ;Find size in bytes
+               LDR     R3,dyn_pageSize         ;Find real page size
+               MOV     R1,R5                   ;We want this in R1 too
+               MOV     R0,#3                   ;Change sprite area size
+               SWI     XOS_ChangeDynamicArea   ;Yes... do it now!
+               BVS     %99da_addPages          ;Error -- return
+
+               ; --- Make sure system sprite size remains the same ---
+
+               MOV     R14,#&01400000          ;Get address of sprite area
+               STR     R4,[R14,#0]             ;Get system sprite size
+
+               ; --- Work out how big dynamite area is now ---
+
+               LDR     R14,dyn_areaSize        ;Get the previous size
+               RSB     R8,R14,#&01800000       ;Put new blocks here
+               ADD     R14,R14,R5              ;The new size
+               STR     R14,dyn_areaSize        ;Save this size back
+
+               ; --- Now we need to map up the area ---
+
+               SUB     R13,R13,#16             ;Get me a mem map block
+               MOV     R14,#0                  ;A nice 0 thing
+               STR     R14,[R13,#8]            ;Protection level
+               MOV     R14,#-1                 ;The terminator
+               STR     R14,[R13,#12]           ;Put that in the block
+00da_addPages  SUB     R8,R8,R3                ;Next page goes here
+               BL      da_findPage             ;Find page number of R2
+               STR     R0,[R13,#0]             ;Store the page number
+               STR     R8,[R13,#4]             ;Put that page here please
+               MOV     R0,R13                  ;Point to the block
+               SWI     XOS_SetMemMapEntries    ;Set mem map entries
+               SUBS    R9,R9,#1                ;Reduce page count
+               ADD     R2,R2,R3                ;Now move next page
+               BGT     %00da_addPages          ;Keep doing that then
+               ADD     R13,R13,#16             ;Get the block back
+
+               ; --- Phew! -- almost there ---
+
+               CMP     R4,#0                   ;Is there a sprite area?
+               MOVNE   R4,#&01400000           ;Yes -- get its address
+               MOV     R14,#&1000              ;VDU driver workspace
+               STR     R4,[R14,#1364]          ;And store as sprite area ptr
+
+10da_addPages  LDMFD   R13!,{R0-R9,PC}^        ;Return to caller
+
+               ; --- We are on a RISC PC ---
+
+50da_addPages  LDR     R1,dyn_log2PageSize     ;Get the log 2 page size
+               MOV     R1,R0,LSL R1            ;Work out increment
+               LDR     R0,dyn_areaHandle       ;Load the area handle
+               SWI     XOS_ChangeDynamicArea   ;And increase appropriately
+               LDRVC   R14,dyn_areaSize        ;Load the old area size
+               ADDVC   R14,R14,R1              ;Apply our increment to it
+               STRVC   R14,dyn_areaSize        ;And save it back again
+               LDMVCFD R13!,{R0-R9,PC}^        ;Return to caller
+
+99da_addPages  LDMFD   R13!,{R0-R9,R14}        ;Load back registers
+               ADR     R0,da__noMem            ;Point to error
+               ORRS    PC,R14,#V_flag          ;Return with error
+
+da__noMem      DCD     1
+               DCB     "No pages left",0
+
+; --- da_removePages ---
+;
+; On entry:    R0 == number of pages to remove
+;
+; On exit:     --
+;
+; Use:         Removes the given number of pages from the dynamite
+;              area. If the number of pages to remove is greater than
+;              the actual number of pages allocated, as many as possible
+;              are removed
+
+               EXPORT  da_removePages
+da_removePages ROUT
+
+               STMFD   R13!,{R0-R10,R14}       ;Stack some registers
+
+               LDR     R9,dyn_machine          ;What machine are we on?
+               CMP     R9,#&A5                 ;Is it a RISC PC?
+               BGE     %50da_removePages       ;Yes -- do things differently
+
+               MOV     R9,R0                   ;Remember this value
+               LDR     R8,dyn_areaSize         ;Get my area size
+               RSB     R2,R8,#&01800000        ;The lowest page
+
+               LDR     R5,dyn_log2PageSize     ;Get the page size
+               MOV     R7,R8,LSR R5            ;Number of dynamite pages
+               CMP     R9,R7                   ;Are we in range?
+               MOVGT   R9,R7                   ;No -- we are now
+               CMP     R9,#0                   ;Are we removing 0 pages?
+               BEQ     %99da_removePages       ;Yes -- return now
+
+               LDR     R14,dyn_sprSize         ;Get address of spr area size
+               LDR     R14,[R14]               ;Get the size out
+               LDR     R1,dyn_areaSize         ;Find our area size
+               SUB     R10,R14,R1              ;Find top of system sprites
+               ADD     R6,R10,#&01400000       ;Top of sprite area
+
+               SUB     R14,R8,R9,LSL R5        ;The new dynamite size
+               STR     R14,dyn_areaSize        ;Store this away nicely
+
+               ; --- Now we need to map down the area ---
+
+               LDR     R3,dyn_pageSize         ;Get the page size
+               MOV     R4,R9                   ;Look after the page count
+               SUB     R13,R13,#16             ;Get me a mem map block
+               MOV     R14,#0                  ;A nice 0 thing
+               STR     R14,[R13,#8]            ;Protection level
+               MOV     R14,#-1                 ;The terminator
+               STR     R14,[R13,#12]           ;Put that in the block
+00             BL      da_findPage             ;Find page number of R2
+               STR     R0,[R13,#0]             ;Store the page number
+               STR     R6,[R13,#4]             ;Put that page here please
+               MOV     R0,R13                  ;Point to the block
+               SWI     XOS_SetMemMapEntries    ;Set mem map entries
+               ADD     R2,R2,R3                ;Now move next page
+               ADD     R6,R6,R3                ;Put the next one here
+               SUBS    R9,R9,#1                ;Reduce page count
+               BGT     %00da_removePages       ;Keep doing that then
+               ADD     R13,R13,#16             ;Get the block back
+
+               CMP     R10,#0                  ;Was there an area before
+               BNE     %10da_removePages       ;Yes -- all ok then
+               LDR     R6,dyn_sprSize          ;Get address of spr area size
+               LDR     R6,[R6]                 ;Get the size out
+               MOV     R7,#0                   ;Sprite area header
+               MOV     R8,#16
+               MOV     R9,#16
+               MOV     R2,#&1400000            ;Point to sprite area
+               STMIA   R2,{R6-R9}              ;Store the header
+
+10             MOV     R1,R4,LSL R5            ;We reduce by this amount
+               RSB     R1,R1,#0                ;Make it negative
+               MOV     R0,#3                   ;Change sprite area size
+               SWI     XOS_ChangeDynamicArea   ;Remove those damn pages
+               B       %99da_removePages       ;Return to caller
+
+               ; --- We're on a RISC PC ---
+
+50             LDR     R1,dyn_log2PageSize     ;Get the log 2 page size
+               MOV     R1,R0,LSL R1            ;Work out increment
+               RSB     R1,R1,#0                ;Negate it nicely
+               LDR     R0,dyn_areaHandle       ;Load the area handle
+               SWI     XOS_ChangeDynamicArea   ;And increase appropriately
+               LDR     R14,dyn_areaSize        ;Load the current size
+               SUB     R14,R14,R1              ;How much was it altered by?
+               STR     R14,dyn_areaSize        ;And save that back
+
+99             LDMFD   R13!,{R0-R10,PC}^       ;Return to caller
+
+               LTORG
+
+
+; --- da_readSize ---
+;
+; On entry:    --
+;
+; On exit:     R0 == size of area
+;
+; Use:         Returns the size of the sprite area (including the
+;              dynamite area).
+
+               EXPORT  da_readSize
+da_readSize    ROUT
+
+               LDR     R0,dyn_machine          ;What machine are we on?
+               CMP     R0,#&A5                 ;Is it a RISC PC?
+               BGE     %50da_readSize          ;Yes -- do other things
+
+               LDR     R0,dyn_sprSize          ;Get spr area size pointer
+               LDR     R0,[R0,#0]              ;Load out the size
+               MOVS    PC,R14                  ;And return to caller
+
+               ; --- We're on a RISC PC ---
+
+50da_readSize  STMFD   R13!,{R1,R14}           ;Stack some registers
+               MOV     R0,#3                   ;Read size of sprite area
+               SWI     XOS_ReadDynamicArea     ;Read things out then
+               MOV     R0,R1                   ;Put size in R0
+               LDMFD   R13!,{R1,PC}^           ;Return to caller
+
+               LTORG
+
+; --- da_describe ---
+;
+; On entry:    --
+;
+; On exit:     R0 == dynamic area number (3 == sprite area)
+;              R1 == size of area
+;              R2 == total free in area
+;
+; Use:         Gives back som information on the dynamite area.
+
+               EXPORT  da_describe
+da_describe    ROUT
+
+               LDR     R0,dyn_machine          ;Load out the machine type
+               CMP     R0,#&A5                 ;Is it a RISC PC?
+               LDRGE   R0,dyn_areaHandle       ;Yes -- load dynamic area hnd
+               MOVLT   R0,#-1                  ;No -- return a silly value
+               LDR     R1,dyn_areaSize         ;Put area size in R1
+               LDR     R2,dyn_heapSize         ;And heap size in R2
+               SUB     R2,R1,R2                ;Get size of unused area
+               MOVS    PC,R14                  ;Return to caller
+
+               LTORG
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/s/dynHeap b/StraySrc/Dynamite/dynamite/s/dynHeap
new file mode 100644 (file)
index 0000000..50e6e5f
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/dynHeap
@@ -0,0 +1,1198 @@
+;
+; dynHeap.s
+;
+; New heap management for Dynamite
+;
+; © 1994-1998 Straylight
+;
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+               GET     libs:stream
+
+;----- External dependencies ------------------------------------------------
+
+               GET     libs:sh.fastMove
+
+               GET     sh.dynArea
+               GET     sh.dynTask
+               GET     sh.wSpace
+
+               GET     sh.messages
+
+;----- Macros ---------------------------------------------------------------
+
+               MACRO
+$label         DIR     $reg
+$label         LDR     $reg,dyn_machine        ;Get the machine type
+               CMP     $reg,#&A5               ;Is it a RISC PC?
+               MEND
+
+;----- Main code ------------------------------------------------------------
+
+               AREA    |Dynamite$$Code|,CODE,READONLY
+
+; --- dh_alloc ---
+;
+; On entry:    R0 == pointer to anchor
+;              R1 == size to allocate in bytes
+;              R2 == ID value to store
+;
+; On exit:     R0 and R1 preserved
+;              R2 == address of block allocated
+;
+; Use:         Allocates a block from the Dynamite heap.
+
+               EXPORT  dh_alloc
+dh_alloc       ROUT
+
+               STMFD   R13!,{R0,R1,R3,R14}     ;Save some registers
+               MOV     R3,R0                   ;Keep anchor pointer
+               ADD     R0,R1,#blk__oHead+15    ;Put size in R0...
+               BIC     R0,R0,#15               ;...after mangling suitably
+               BL      dh__ensure              ;Ensure the memory's there
+               BVS     %90dh_alloc             ;If not there, return error
+               STR     R1,[R0,#blk__size]      ;Save the size in there
+               STR     R3,[R0,#blk__anchor]    ;And the anchor address
+               STR     R2,[R0,#blk__id]        ;Oh, and the ID value
+               ADD     R2,R0,#blk__oHead       ;Return correct address
+               STR     R2,[R3,#0]              ;And save address in anchor
+               LDMFD   R13!,{R0,R1,R3,PC}^     ;And return to caller
+
+90dh_alloc     ADD     R13,R13,#4              ;Don't restore R0 on exit
+               LDMFD   R13!,{R1,R3,R14}        ;Unstack some registers
+               ORRS    PC,R14,#V_flag          ;And return the error
+
+               LTORG
+
+; --- dh_free ---
+;
+; On entry:    R0 == pointer to anchor of block to free
+;
+; On exit:     --
+;
+; Use:         Frees a Dynamite block.
+
+               EXPORT  dh_free
+dh_free                ROUT
+
+               STMFD   R13!,{R1,R14}           ;Save some registers
+               BL      dh__checkAnchor         ;Make sure the anchor's OK
+               MOVVC   R14,#0                  ;If so, clear block's anchor
+               STRVC   R14,[R1,#blk__anchor]   ;Zero the anchor (R14==0 !!)
+               BLVC    dh__unCompact           ;Say the heap is uncompact
+               LDMFD   R13!,{R1,PC}            ;Return to caller
+
+               LTORG
+
+; --- dh_freeWithID ---
+;
+; On entry:    R0 == ID of all blocks to free
+;
+; On exit:     --
+;
+; Use:         Frees all allocated blocks with a given ID number.
+
+               EXPORT  dh_freeWithID
+dh_freeWithID  ROUT
+
+               CMP     R0,#0                   ;Is he trying to free ID 0?
+               ADREQL  R0,msg_errBadFreeAll    ;Yes -- that's an error
+               ORREQS  PC,R14,#V_flag          ;So return it to him
+
+               ; --- Do the freeing job ---
+               ;
+               ; We just tonk a 0 anchor over all blocks with a matching ID.
+
+               STMFD   R13!,{R0-R4,R14}        ;Save some registers
+               LDR     R2,dyn_heapSize         ;Load the current heap size
+               DIR     R14                     ;Is it RISC PC?
+               LDRGE   R1,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R1,R2,#&01800000        ;No -- find the base anyway
+               ADD     R2,R2,R1                ;Find the heap end address
+               MOV     R3,#0                   ;Haven't freed anything yet
+
+00dh_freeWithID        CMP     R1,R2                   ;Have we reached the end?
+               BGE     %10dh_freeWithID        ;Yes -- return then
+               LDR     R14,[R1,#blk__id]       ;Get the block's ID
+               SUBS    R14,R14,R0              ;Is it a match? (=> R14==0)
+               STREQ   R14,[R1,#blk__anchor]   ;Yes -- blank out the anchor
+               MOVEQ   R3,#1                   ;And remember we done this
+               LDR     R14,[R1,#blk__size]     ;Load this block's size
+               ADD     R14,R14,#blk__oHead+15  ;Add on the overhead size
+               BIC     R14,R14,#15             ;And align to granularity
+               ADD     R1,R1,R14               ;Move on to next block
+               B       %00dh_freeWithID        ;And go round again
+
+               ; --- We finished -- tidy up and return ---
+
+10dh_freeWithID        CMP     R3,#0                   ;Did we free anything?
+               BLNE    dh__unCompact           ;Yes -- then heap isn't tidy
+               LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
+
+               LTORG
+
+; --- dh_blockInfo ---
+;
+; On entry:    R0 == address of block anchor
+;
+; On exit:     R0 preserved
+;              R1 == address of block
+;              R2 == size of block
+;              R3 == block ID
+;
+; Use:         Returns information about a Dynamite block
+
+               EXPORT  dh_blockInfo
+dh_blockInfo   ROUT
+
+               STMFD   R13!,{R14}              ;Save the link register
+               BL      dh__checkAnchor         ;Make sure anchor is kosher
+               LDMVCIB R1,{R2,R3}              ;Yes -- load size and ID
+               ADDVC   R1,R1,#blk__oHead       ;Point to the block
+               LDMFD   R13!,{PC}               ;And return to caller
+
+               LTORG
+
+; --- dh_changeID ---
+;
+; On entry:    R0 == address of anchor block, or 0 for all
+;              R1 == new ID
+;              R2 == old ID (if R0 == 0)
+;
+; On exit:     --
+;
+; Use:         This call is use to change the ID of either an individual
+;              block (R0 == address of anchor), or the ID of all the
+;              blocks with the ID passed in R2 (if R0 == 0).
+
+               EXPORT  dh_changeID
+dh_changeID    ROUT
+
+               STMFD   R13!,{R0-R3,R14}        ;Stack some registers
+               CMP     R0,#0                   ;Just one block to change?
+               BEQ     %50dh_changeID          ;No -- jump ahead
+
+               ; --- Change the ID of a specific block ---
+
+               MOV     R2,R1                   ;Preserve the new ID
+               BL      dh__checkAnchor         ;Check the anchor
+               BVS     %99dh_changeID          ;It's garbish -- return error
+               STR     R2,[R1,#blk__id]        ;Store the new id
+               B       %98dh_changeID          ;And return to caller
+
+               ; --- Change the ID of all blocks with ID R2 ---
+
+50dh_changeID  LDR     R3,dyn_heapSize         ;Load the current heap size
+               DIR     R14                     ;Is it RISC PC?
+               LDRGE   R0,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R0,R3,#&01800000        ;No -- find the base anyway
+               ADD     R3,R3,R0                ;Find the heap end address
+
+60dh_changeID  CMP     R0,R3                   ;Have we reached the end?
+               BGE     %98dh_changeID          ;Yes -- return then
+               LDR     R14,[R0,#blk__id]       ;Get the id of this block
+               CMP     R14,R2                  ;Do we want to change it?
+               STREQ   R1,[R0,#blk__id]        ;Yes -- make it so then
+               LDR     R14,[R0,#blk__size]     ;Get the block size
+               ADD     R14,R14,#blk__oHead+15  ;Add on the block size
+               BIC     R14,R14,#15             ;And word align
+               ADD     R0,R0,R14               ;Point to the next block
+               B       %60dh_changeID          ;Keep on looking for blocks
+
+98dh_changeID  LDMFD   R13!,{R0-R3,PC}^        ;Return to caller
+
+99dh_changeID  ADD     R13,R13,#4              ;Don't unstack R0
+               LDMFD   R13!,{R1-R3,R14}        ;Get back registers
+               ORRS    PC,R14,#V_flag          ;Return with error
+
+               LTORG
+
+; --- dh__checkAnchor ---
+;
+; On entry:    R0 == address of anchor to check
+;
+; On exit:     R1 == address of block descriptor
+;
+; Use:         Ensures that a given anchor is valid.
+
+dh__checkAnchor        ROUT
+
+               STMFD   R13!,{R14}              ;Save some registers
+               LDR     R1,[R0,#0]              ;Load the block address
+               SUB     R1,R1,#blk__oHead       ;Point to our information
+               LDR     R14,[R1,#blk__anchor]   ;Load the block's anchor
+               CMP     R0,R14                  ;Do they match up?
+               ADRNEL  R0,msg_errBadAnchor     ;No -- point to error message
+               LDMFD   R13!,{R14}              ;Restore registers
+               BICEQS  PC,R14,#V_flag          ;Anchor OK -- clear V on exit
+               ORRNES  PC,R14,#V_flag          ;Anchor duff -- return error
+
+               LTORG
+
+; --- dh__ensure ---
+;
+; On entry:    R0 == number of bytes required (multiple of 16)
+;
+; On exit:     R0 == pointer to base of area allocated
+;
+; Use:         Ensures that there are R0 bytes available in the heap.  If
+;              there aren't R0 bytes available, it goes out of its way to
+;              ensure that there *are* by getting more.  If there still
+;              isn't enough, it compacts the heap and tries some more.
+
+dh__ensure     ROUT
+
+               STMFD   R13!,{R1-R5,R14}        ;Save some registers
+               MOV     R1,R0                   ;Keep the size I want
+
+               ; --- Try to find some space among the free blocks ---
+
+               LDR     R3,dyn_heapSize         ;Load the current heap size
+               DIR     R14                     ;Is it RISC PC?
+               LDRGE   R2,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R2,R3,#&01800000        ;No -- find the base anyway
+               ADD     R3,R3,R2                ;Find the heap end address
+               MOV     R5,#0                   ;No bytes found yet
+
+00dh__ensure   CMP     R2,R3                   ;Is there more to go?
+               BGE     %05dh__ensure           ;No -- then extend the heap
+
+               LDR     R0,[R2,#blk__size]      ;Load this block's size
+               ADD     R0,R0,#blk__oHead+15    ;Add on the overhead size
+               BIC     R0,R0,#15               ;And align to granularity
+               LDR     R14,[R2,#blk__anchor]   ;Is the block free?
+               ADD     R2,R2,R0                ;Bump on block pointer
+               CMP     R14,#0                  ;If so, anchor==0
+               MOVNE   R5,#0                   ;If not, clear free size
+               BNE     %00dh__ensure           ;And loop round again
+
+               ; --- Found a free block ---
+
+               CMP     R5,#0                   ;Is there a free block size?
+               SUBEQ   R4,R2,R0                ;No -- this is the start then
+               ADD     R5,R5,R0                ;Add on the size of this blk
+               SUBS    R14,R5,R1               ;Is this big enough?
+               BLT     %00dh__ensure           ;No -- keep on round
+
+               ; --- Found a big enough space ---
+
+               BEQ     %03dh__ensure           ;If no leftover, skip on
+               ADD     R3,R4,R1                ;Point to bit left over
+               MOV     R0,#0                   ;This block is free
+               SUB     R2,R14,#blk__oHead      ;Subtract info overhead
+               STMIA   R3,{R0,R2}              ;Save this in the block
+
+               ; --- Return address of this memory ---
+
+03dh__ensure   MOV     R0,R4                   ;Point to the free block
+               LDMFD   R13!,{R1-R5,R14}        ;Unstack registers
+               BICS    PC,R14,#V_flag          ;And clear error indicator
+
+               ; --- Main size ensuring loop ---
+
+05dh__ensure   LDR     R14,dyn_areaSize        ;Get the dynamic area size
+               LDR     R2,dyn_heapSize         ;And the size we're using
+               SUB     R3,R14,R2               ;How much do we have?
+               SUBS    R3,R1,R3                ;And is it enough?
+               BLE     %10dh__ensure           ;Yes -- skip onwards
+
+               ; --- Try to get some more pages ---
+
+               LDR     R14,dyn_pageSize        ;Load machine page size
+               SUB     R14,R14,#1              ;Subtract one -- round up
+               ADD     R3,R3,R14               ;Add it on for rounding
+               LDR     R4,dyn_log2PageSize     ;Load the page size log
+               MOV     R0,R3,LSR R4            ;How many do I need?
+               BL      da_addPages             ;Get some more
+               BVC     %10dh__ensure           ;It worked -- skip onwards
+
+               ; --- Hmm... -- try compacting the heap ---
+
+               BL      dh_compact              ;Try to compact the heap
+               BCC     %05dh__ensure           ;If it did, try again
+
+               ADRL    R0,msg_errNoMem         ;Point to the error
+               LDMFD   R13!,{R1-R5,R14}        ;Restore the registers
+               ORRS    PC,R14,#V_flag          ;And return to caller
+
+               ; --- Extend the heap and return the base address ---
+
+10dh__ensure   ADD     R14,R2,R1               ;Work out the new heap size
+               STR     R14,dyn_heapSize        ;Save this away for later
+               DIR     R0                      ;Get the heap's direcection
+               LDRGE   R0,dyn_areaBase         ;Yes -- load the area base
+               ADDGE   R0,R0,R2                ;And add the old heap size
+               RSBLT   R0,R14,#&01800000       ;Otherwise find the heap base
+               LDMFD   R13!,{R1-R5,R14}        ;Unstack registers
+               BICS    PC,R14,#V_flag          ;And clear error indicator
+
+               LTORG
+
+; --- dh_reduce ---
+;
+; On entry:    --
+;
+; On exit:     CS if there was nothing we could do
+;
+; Use:         Tries to shunt the free space in the heap off the end and
+;              back into the operating system's free pool.  It does it a
+;              little bit and then stops, rather like those workmen on the
+;              M40.
+
+               EXPORT  dh_reduce
+dh_reduce      ROUT
+
+               STMFD   R13!,{R14}              ;Save some registers
+               LDR     R14,dyn_hpFlags         ;Load the heap's flags
+               TST     R14,#hpFlag_tidy        ;Is the heap tidy?
+               LDREQ   R14,dyn_lockCount       ;No -- then load lock count
+               CMPEQ   R14,#0                  ;Is the heap locked?
+               BNE     %91dh_reduce            ;Yes -- then return CS now
+
+               ; --- Do search for free blocks ---
+
+               STMFD   R13!,{R0-R9}            ;Save some more registers
+               LDR     R1,dyn_heapSize         ;Load the current heap size
+               DIR     R14                     ;Is it RISC PC?
+               LDRGE   R5,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R5,R1,#&01800000        ;No -- find the base anyway
+               ADD     R1,R1,R5                ;Find the heap end address
+               MOV     R9,R5                   ;Remember heap base address
+
+               ; --- Find a free block ---
+
+               MOV     R7,#0                   ;No previous block
+00dh_reduce    CMP     R5,R1                   ;Are we at the end yet?
+               BGE     %04dh_reduce            ;Yes -- jump ahead a little
+
+               LDR     R2,[R5,#blk__anchor]    ;Get the block's anchor addr
+               CMP     R2,#0                   ;Is the block free?
+               LDR     R2,[R5,#blk__size]      ;Get the block size
+               ADD     R2,R2,#blk__oHead+15    ;Add on the overhead bytes
+               BIC     R2,R2,#15               ;And word align the size
+               MOVNE   R7,R5                   ;No -- remember where it is
+               ADDNE   R5,R5,R2                ;...move on to next one
+               BNE     %00dh_reduce            ;...go round for another one
+
+               ; --- We've found a free block ---
+
+01dh_reduce    ADD     R6,R5,R2                ;Point to the next block
+               CMP     R6,R1                   ;Is that the end of the heap?
+               MOVGE   R8,R7                   ;Yes -- set up prev pointer
+               SUBGE   R2,R2,#blk__oHead       ;...take off overhead
+               STRGE   R2,[R5,#blk__size]      ;...store overall block size
+               BGE     %04dh_reduce            ;...and jump ahead a little
+
+               ; --- Check for two free blocks together ---
+
+               LDR     R0,[R6,#blk__anchor]    ;Does this have an anchor?
+               CMP     R0,#0                   ;Check if it's free
+               SUBNE   R2,R2,#blk__oHead       ;Not -- take off overhead
+               STRNE   R2,[R5,#blk__size]      ;...store overall block size
+               BNE     %02dh_reduce            ;...jump ahead a little
+
+               ; --- Join two adjacent free blocks together ---
+
+               LDR     R0,[R6,#blk__size]      ;Yes -- get its size
+               ADD     R2,R0,R2                ;Concatenate the two blocks
+               ADD     R2,R2,#blk__oHead+15    ;Add on the overhead bytes
+               BIC     R2,R2,#15               ;And word align the size
+               B       %01dh_reduce            ;And check again...
+
+               ; --- We may be searching for the last block ---
+
+02dh_reduce
+               DIR     R14                     ;Get the heap direction
+               MOVLT   R5,R6                   ;Down -- point to next block
+               MOVLT   R8,R7                   ;...remember last block pos.
+               BLT     %00dh_reduce            ;...and keep on searching
+
+               ; --- There's a block to bring down ---
+
+               LDR     R4,[R6,#blk__size]      ;Get size of block to move
+               ADD     R4,R4,#blk__oHead+15    ;Add the flex overhead
+               BIC     R4,R4,#15               ;And word align the size
+               MOVS    R2,R4                   ;This is the size to move
+               MOV     R0,R5                   ;Where to move it to
+               MOV     R1,R6                   ;Where it is right now
+               BLNE    dh__move                ;Copy it down PDQ
+               ADD     R0,R5,R4                ;Point after block we moved
+               MOV     R1,#0                   ;Block doesn't have an anchor
+               STR     R1,[R0,#blk__anchor]    ;Store that away for later
+               SUB     R1,R6,R5                ;Find the difference here
+               SUB     R1,R1,#blk__oHead       ;Don't count this size here
+               STR     R1,[R0,#blk__size]      ;Store the old size in free
+
+               ; --- We need to fix up the block we moved ---
+
+               LDR     R0,[R5,#blk__anchor]    ;Get the anchor pointer
+               ADD     R1,R5,#blk__oHead       ;Point to the real data
+               STR     R1,[R0]                 ;Store client's new anchor
+
+               ; --- That's it -- return to caller ---
+
+               B       %10dh_reduce    ;Return to caller
+
+               ; --- We've reached the end of the heap ---
+               ;
+               ; Now things get a little more complicated:
+               ;
+               ; If the heap goes upwards, then there may be a free block
+               ; on the end that we can free (R5 < R1), otherwise the heap
+               ; is compacted.
+               ;
+               ; If the heap goes downwards, then R8 points to the block
+               ; immediately before the last free one. If R8 is 0, then
+               ; either the heap is compacted (the first block is not free)
+               ; or there is only on free block, and it's at the lower
+               ; end of the heap.
+
+04dh_reduce
+               DIR     R14                     ;Get the heap direction
+               BGE     %05dh_reduce            ;Upwards --  jump ahead
+
+               CMP     R8,#0                   ;Was there a previous block?
+               BNE     %07dh_reduce            ;Yes -- compact heap then
+
+               LDR     R14,[R9,#blk__anchor]   ;Get previous block anchor
+               CMP     R14,#0                  ;Is the first block free?
+               BNE     %90dh_reduce            ;No -- the heap is compacted
+
+               LDR     R14,[R9,#blk__size]     ;Get the size of the free blk
+               ADD     R14,R14,#blk__oHead+15  ;Add on the overhead
+               BIC     R14,R14,#15             ;And correctly align
+               ADD     R7,R9,R14               ;Point past the free block
+
+               LDR     R0,dyn_areaSize         ;Get the area size
+               RSB     R14,R0,#&01800000       ;Find the base address
+               SUB     R5,R7,R14               ;Get size of unsused area
+               SUB     R14,R0,R5               ;Get the area size left
+               STR     R14,dyn_heapSize        ;Store it away nicely
+               LDR     R14,dyn_log2PageSize    ;Get the log page size
+               MOVS    R0,R5,LSR R14           ;How many pages can we free?
+               BLNE    da_removePages          ;More than 0 -- free them
+               B       %20dh_reduce            ;Return to caller
+
+               ; --- Merge the last block with the free area ---
+
+05dh_reduce    CMP     R5,R1                   ;Had we reached the end?
+               BGE     %90dh_reduce            ;Yes -- heaps compact then
+
+               SUB     R14,R5,R9               ;Get the used area size
+               STR     R14,dyn_heapSize        ;And store it away
+               LDR     R0,dyn_pageSize         ;Get the machine page size
+               SUB     R0,R0,#1                ;Turn into a bitmask
+               ADD     R5,R5,R0                ;Align this to page boundary
+               BIC     R0,R5,R0                ;And finish off the align
+               LDR     R1,dyn_areaSize         ;Get the dyn area size
+               ADD     R1,R1,R9                ;Point to end of area
+               SUBS    R0,R1,R0                ;Are these different?
+               BEQ     %10dh_reduce            ;No -- return
+               LDR     R14,dyn_log2PageSize    ;Get the log page size
+               MOVS    R0,R0,LSR R14           ;How many pages can we free?
+               BLNE    da_removePages          ;More than 0 -- free them
+               B       %20dh_reduce            ;Return to caller
+
+               ; --- Move a block in a downwards heap ---
+
+07dh_reduce    LDR     R2,[R8,#blk__size]      ;Get size of block to move
+               ADD     R2,R2,#blk__oHead+15    ;Add the flex overhead
+               BIC     R2,R2,#15               ;And word align the size
+               ADD     R0,R8,R2                ;Point to the free block
+               LDR     R4,[R0,#blk__size]      ;Load out it's size
+               ADD     R14,R4,#blk__oHead+15   ;Add the flex overhead
+               BIC     R14,R14,#15             ;And word align the size
+               ADD     R0,R0,R14               ;Point to the end of the blk
+               SUB     R0,R0,R2                ;Copy the block to here
+               MOV     R1,R8                   ;Where it is right now
+               BLNE    dh__move                ;Copy it down PDQ
+               MOV     R1,#0                   ;Block doesn't have an anchor
+               STR     R1,[R8,#blk__anchor]    ;Store that away for later
+               STR     R4,[R8,#blk__size]      ;Store the old size in free
+
+               ; --- We need to fix up the block we moved ---
+
+               LDR     R14,[R0,#blk__anchor]   ;Get the anchor pointer
+               ADD     R0,R0,#blk__oHead       ;Point to the real data
+               STR     R0,[R14]                ;Store client's new anchor
+
+               ; --- That's it -- return ---
+
+10dh_reduce    LDMFD   R13!,{R0-R9,R14}        ;Load back registers
+               BICS    PC,R14,#C_flag          ;Return with C clear
+
+               ; --- There wasn't anything to do -- we're compacted ---
+
+20dh_reduce    LDR     R0,dyn_hpFlags          ;Load my flags
+               ORR     R0,R0,#hpFlag_tidy      ;We're compacted
+               STR     R0,dyn_hpFlags          ;Store back the flags
+               LDMFD   R13!,{R0-R9,R14}        ;Load back registers
+               BICS    PC,R14,#C_flag          ;Return with C clear
+
+               ; --- Nothing could be done ---
+
+90dh_reduce    LDMFD   R13!,{R0-R9}            ;Load back registers
+91dh_reduce    LDMFD   R13!,{R14}              ;And the link too
+               ORRS    PC,R14,#C_flag          ;Return with C set
+
+               LTORG
+
+; --- dh_compact ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Does a full compaction of the heap.
+
+               EXPORT  dh_compact
+dh_compact     ROUT
+
+               STMFD   R13!,{R14}              ;Stack the link register
+               BL      dh_reduce               ;Try to reduce the heap
+               LDMCSFD R13!,{PC}               ;If it couldn't, return CS
+00dh_compact   BL      dh_reduce               ;Try to reduce the heap
+               BCC     %00dh_compact           ;Did something -- try again
+               LDMFD   R13!,{R14}              ;Return to caller...
+               BICS    PC,R14,#C_flag          ;... saying we did something
+
+               LTORG
+
+; --- dh__unCompact ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Marks the heap as being uncompact.
+
+dh__unCompact  ROUT
+
+               STMFD   R13!,{R14}              ;Stack the link register
+               LDR     R14,dyn_hpFlags         ;Load the flags word
+               TST     R14,#hpFlag_tidy        ;Is the tidy bit on?
+               BICNE   R14,R14,#hpFlag_tidy    ;Clear the 'is tidy' bit
+               STRNE   R14,dyn_hpFlags         ;Store back the flags
+               BLNE    dt_message              ;Yes -- prod compactor
+               LDMFD   R13!,{PC}^              ;Return to caller
+
+               LTORG
+
+; --- dh_lock ---
+;
+; On entry:    --
+;
+; On exit:     R10 corrupted (SWIs don't care about this)
+;
+; Use:         Locks the heap, so that compaction entirely fails to happen.
+
+               EXPORT  dh_lock
+dh_lock                ROUT
+
+               LDR     R10,dyn_lockCount       ;Load the old lock count
+               ADD     R10,R10,#1              ;Bump the counter a little
+               STR     R10,dyn_lockCount       ;Store the counter back
+               MOVS    PC,R14                  ;And return to caller
+
+               LTORG
+
+; --- dh_unlock ---
+;
+; On entry:    --
+;
+; On exit:     R10 corrupted (SWIs don't care about this)
+;
+; Use:         Unlocks the heap, so that compaction can happen again, maybe.
+
+               EXPORT  dh_unlock
+dh_unlock      ROUT
+
+               LDR     R10,dyn_lockCount       ;Load the old lock count
+               SUBS    R10,R10,#1              ;Knock the counter down
+               STRGE   R10,dyn_lockCount       ;Store the counter back
+               BEQ     dt_message              ;If now enabled, signal task
+               MOVS    PC,R14                  ;And return to caller
+
+               LTORG
+
+; --- dh_save ---
+;
+; On entry:    R0 == mask of registers to save
+;
+; On exit:     R10, R11 corrupted
+;
+; Use:         Saves a load of registers on the Dynamite relocation stack.
+;              The mask in R0 contains a bit set for each register to save:
+;              bit 3 set means save R3 etc.  Since this is a SWI, only
+;              R1-R9 can be saved on the stack.
+
+               EXPORT  dh_save
+dh_save                ROUT
+
+               ; --- StrongARM friendly version 1st October 1996 [mdw] ---
+
+               LDR     R10,dyn_stackPtr        ;Load the stack pointer
+
+               TST     R0,#&03F
+               BEQ     %f05
+               MOVS    R11,R0,LSL #31
+               STRCS   R1,[R10],#4
+               TST     R0,#&3FC
+               BEQ     %f00
+               MOVS    R11,R0,LSL #29
+               STRMI   R2,[R10],#4
+               STRCS   R3,[R10],#4
+               TST     R0,#&3F0
+               BEQ     %f00
+               MOVS    R11,R0,LSL #27
+               STRMI   R4,[R10],#4
+               STRCS   R5,[R10],#4
+               TST     R0,#&3C0
+               BEQ     %f00
+05             MOVS    R11,R0,LSL #25
+               STRMI   R6,[R10],#4
+               STRCS   R7,[R10],#4
+               MOVS    R11,R0,LSL #23
+               STRMI   R8,[R10],#4
+               STRCS   R9,[R10],#4
+00
+               STR     R10,dyn_stackPtr        ;Save stack pointer back
+               MOVS    PC,R14                  ;And return to caller
+
+               LTORG
+
+; --- dh_load ---
+;
+; On entry:    R0 == mask of registers to load
+;
+; On exit:     R10, R11 corrupted
+;
+; Use:         Loads a load of registers on the Dynamite relocation stack.
+;              The mask in R0 contains a bit set for each register to load:
+;              bit 3 set means load R3 etc.  Since this is a SWI, only
+;              R1-R9 can be read from the stack.
+
+               EXPORT  dh_load
+dh_load                ROUT
+
+               ; --- StrongARM friendly version 1st October 1996 [mdw] ---
+
+               LDR     R10,dyn_stackPtr        ;Load the stack pointer
+
+               TST     R0,#&3F0
+               BEQ     %f05
+               MOVS    R11,R0,LSL #23
+               LDRCS   R9,[R10,#-4]!
+               LDRMI   R8,[R10,#-4]!
+               TST     R0,#&0FF
+               BEQ     %f00
+               MOVS    R11,R0,LSL #25
+               LDRCS   R7,[R10,#-4]!
+               LDRMI   R6,[R10,#-4]!
+               TST     R0,#&03F
+               BEQ     %f00
+               MOVS    R11,R0,LSL #27
+               LDRCS   R5,[R10,#-4]!
+               LDRMI   R4,[R10,#-4]!
+               TST     R0,#&00F
+               BEQ     %f00
+05             MOVS    R11,R0,LSL #29
+               LDRCS   R3,[R10,#-4]!
+               LDRMI   R2,[R10,#-4]!
+               MOVS    R11,R0,LSL #31
+               LDRCS   R1,[R10,#4]!
+00
+               STR     R10,dyn_stackPtr        ;Save stack pointer back
+               MOVS    PC,R14                  ;And return to caller
+
+               LTORG
+
+; --- dh_extend ---
+;
+; On entry:    R0 == address of block anchor
+;              R1 == new size for block
+;
+; On exit:     R0 preserved
+;              R1 == address of block, may have moved
+;
+; Use:         Changes the size of a block.
+
+               EXPORT  dh_extend
+dh_extend      ROUT
+
+               STMFD   R13!,{R2,R14}           ;Save some registers
+               MOV     R2,R1                   ;Keep the size safe a while
+               BL      dh__checkAnchor         ;Make sure anchor's kosher
+               LDRVC   R1,[R1,#blk__size]      ;Load the size word nicely
+               SUBVC   R2,R2,R1                ;Get the `by' value I need
+               BLVC    dh_midExtend            ;Do the messing about
+               LDMFD   R13!,{R2,PC}            ;Return to caller
+
+               LTORG
+
+; --- dh_midExtend ---
+;
+; On entry:    R0 == address of block anchor
+;              R1 == byte offset from block start
+;              R2 == number of bytes to insert
+;
+; On exit:     R0 preserved
+;              R1 == address of block, may have moved
+;
+; Use:         Inserts or removes bytes at a given offset into a Dynamite
+;              heap block.
+
+               EXPORT  dh_midExtend
+dh_midExtend   ROUT
+
+               STMFD   R13!,{R0,R2-R9,R14}     ;Save some registers
+               MOV     R5,R0                   ;Keep the anchor address
+               MOV     R6,R1                   ;And the byte offset
+               MOV     R7,R2                   ;And the size to insert
+
+               ; --- To start with, some sanity checks ---
+
+               BL      dh__checkAnchor         ;Make sure anchor is OK
+               BVS     %90dh_midExtend         ;If not, return error
+               CMP     R7,#0                   ;Are we growing the block?
+               ADDLT   R14,R6,R7               ;No -- get lowest byte access
+               MOVGE   R14,R6                  ;Yes -- similarly
+               CMP     R14,#0                  ;Is this off the end?
+               ADRLTL  R0,msg_errBadMid        ;Yes -- point to error
+               BLT     %90dh_midExtend         ;And return to caller
+               LDR     R4,[R1,#blk__size]      ;Get the block's size
+               CMP     R6,R4                   ;Are we going too far here?
+               ADRGTL  R0,msg_errBadMid        ;Yes -- point to error
+               BGT     %90dh_midExtend         ;And return to caller
+
+               ; --- Now do the correct extend job ---
+
+               CMP     R7,#0                   ;Are we growing the block?
+               BEQ     %85dh_midExtend         ;Not changing -- return
+               BLT     %50dh_midExtend         ;Shrinking -- skip to do that
+
+               ; --- Make a block bigger ---
+               ;
+               ; We do this in 3 stages:
+               ;
+               ; * Get the amount of dead space at the end of the block, and
+               ;   see if this is enough.
+               ;
+               ; * If not, gather together the free blocks immediately
+               ;   following the block and add this to the dead space.
+               ;
+               ; * If we still don't have enough, we ensure a block of the
+               ;   required size (plus block descriptor) and copy the data
+               ;   into there.
+               ;
+               ; Registers will be used as follows:
+               ;
+               ; R5-R7 are original arguments
+               ; R4 == current size of block
+               ; R3 == size of area we have found
+               ; R2 == base address of extension area
+               ; R1 == base address of block
+
+               ADD     R2,R1,R4                ;Find the end of the block
+               ADD     R3,R4,#blk__oHead+15    ;Align block size to gran.
+               BIC     R0,R3,#15               ;To get dead space too
+               SUB     R3,R0,#blk__oHead       ;But don't have the overhead
+               SUB     R3,R3,R4                ;Get size of the dead space
+               CMP     R3,R7                   ;Is there enough for us?
+               BGE     %30dh_midExtend         ;Yes -- use it then
+
+               ; --- Now we must gather free blocks together nicely ---
+
+               STMFD   R13!,{R8-R10}           ;Save some more registers
+               ADD     R8,R1,R0                ;Find start of next block
+               DIR     R14                     ;Which way is the heap going?
+               LDRGE   R14,dyn_areaBase        ;Upwards -- get base address
+               LDRGE   R10,dyn_heapSize        ;And the heap's size
+               ADDGE   R10,R14,R10             ;To get the top of the heap
+               MOVLT   R10,#&01800000          ;Downwards -- get heap top
+
+05dh_midExtend CMP     R8,R10                  ;Are we there yet?
+               BGE     %10dh_midExtend         ;Yes -- stop there then
+               LDR     R14,[R8,#blk__anchor]   ;Get the block's anchor
+               CMP     R14,#0                  ;Is it a free block?
+               BNE     %10dh_midExtend         ;No -- stop here then
+               LDR     R9,[R8,#blk__size]      ;Get the block's size
+               ADD     R9,R9,#blk__oHead+15    ;Add information overhead
+               BIC     R9,R9,#15               ;And align size nicely
+               ADD     R8,R8,R9                ;Move on to next block
+               ADD     R3,R3,R9                ;And increase available space
+               CMP     R3,R7                   ;Do we have enough yet?
+               BLT     %05dh_midExtend         ;No -- go round again
+
+               LDMFD   R13!,{R8-R10}           ;Restore the stack pointer
+               B       %30dh_midExtend         ;And do the extend op
+
+               ; --- Not enough space in free blocks ---
+               ;
+               ; We dh__ensure enough space in the heap, and copy the whole
+               ; lot.
+
+10dh_midExtend LDMFD   R13!,{R8-R10}           ;Restore the stack pointer
+               ADD     R0,R4,R7                ;Get the required size
+               ADD     R0,R0,#blk__oHead+15    ;Add information overhead
+               BIC     R0,R0,#15               ;And align size nicely
+               BL      dh__ensure              ;Make the space available
+               BVS     %90dh_midExtend         ;If it failed, return error
+               LDR     R1,[R5,#0]              ;Reload anchor -- may move
+               SUB     R1,R1,#blk__oHead       ;And find real block base
+               ADD     R2,R4,#blk__oHead       ;Add on the info overhead
+               BL      dh__move                ;Copy the data over
+               ADD     R14,R0,#blk__oHead      ;Point to the usable area
+               STR     R14,[R5,#0]             ;Save client's new anchor
+               MOV     R14,#0                  ;Get a zero word
+               STR     R14,[R1,#blk__anchor]   ;To mark old block as free
+               BL      dh__unCompact           ;The heap is not compact now
+
+               ; --- Set up registers for the resize op ---
+
+               MOV     R1,R0                   ;Point at the new block base
+               ADD     R2,R1,R4                ;Find area to extend from
+               MOV     R3,R7                   ;And the size we have found
+
+               ; --- Perform the block resize ---
+
+30dh_midExtend ADD     R14,R4,R7               ;Get the new block size
+               STR     R14,[R1,#blk__size]     ;And save it away
+               ADD     R3,R3,R4                ;Get the total area size
+               ADD     R14,R14,#blk__oHead+15  ;Add overhead to new size
+               BIC     R14,R14,#15             ;And align nicely
+
+               ; --- Increase the heap size if we need to ---
+
+               ADD     R0,R1,R14               ;Find the end of the area
+               LDR     R9,dyn_heapSize         ;Load the current heap size
+               DIR     R8                      ;Is it RISC PC?
+               LDRGE   R8,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R8,R9,#&01800000        ;No -- find the base anyway
+               ADD     R9,R9,R8                ;Find the heap end address
+               CMP     R0,R9                   ;Is end too high?
+               SUBGT   R0,R0,R8                ;Yes -- get the heap size
+               STRGT   R0,dyn_heapSize         ;...and store it back again
+
+               ADD     R3,R3,#blk__oHead+15    ;Do the same for the whole...
+               BIC     R3,R3,#15               ;... area size
+               SUBS    R3,R3,R14               ;Get the space left at end
+               BLE     %35dh_midExtend         ;Perfect fit -- skip on
+
+               ; --- Insert a free block here ---
+
+               ADD     R0,R1,R14               ;Find the end of the area
+               MOV     R2,#0                   ;No anchor -- it's free
+               SUB     R3,R3,#blk__oHead       ;Subtract overhead size
+               STMIA   R0,{R2,R3}              ;Save in descriptor block
+
+               ; --- Now split the block as required ---
+
+35dh_midExtend ADD     R1,R1,#blk__oHead       ;Point at usable part of blk
+               ADD     R1,R1,R6                ;Find the split offset
+               ADD     R0,R1,R7                ;Find where to move to
+               SUBS    R2,R4,R6                ;How much we have to move
+               BLNE    dh__move                ;Do the split op
+               B       %85dh_midExtend         ;And return happily to caller
+
+               ; --- We have to reduce a block ---
+
+50dh_midExtend ADD     R14,R4,R7               ;Get the new size
+               STR     R14,[R1,#blk__size]     ;This is the new size
+               ADD     R1,R1,#blk__oHead       ;Point at usable part of blk
+               ADD     R1,R1,R6                ;Find the split offset
+               ADD     R0,R1,R7                ;Find where to move to
+               SUBS    R2,R4,R6                ;How much we have to move
+               BLNE    dh__move                ;Do the split op
+
+               ; --- Now update the size and insert free block ---
+
+               ADD     R3,R4,R7                ;Find the new size
+               ADD     R4,R4,#blk__oHead+15    ;Add overhead to new size
+               BIC     R4,R4,#15               ;And align nicely
+               ADD     R3,R3,#blk__oHead+15    ;Do the same for the whole...
+               BIC     R3,R3,#15               ;... area size
+               SUBS    R14,R4,R3               ;Get the space left at end
+               BEQ     %85dh_midExtend         ;Perfect fit -- skip onwards
+
+               ; --- Insert a free block here ---
+
+               LDR     R1,[R5,#0]              ;Load the block address
+               SUB     R1,R1,#blk__oHead       ;Point to the block descr.
+               ADD     R0,R1,R3                ;Find the end of the area
+               MOV     R2,#0                   ;No anchor -- it's free
+               SUB     R3,R14,#blk__oHead      ;Subtract overhead size
+               STMIA   R0,{R2,R3}              ;Save in descriptor block
+               BL      dh__unCompact           ;The heap is not compact now
+
+               ; --- Now everything is great ---
+
+85dh_midExtend LDR     R1,[R5,#0]              ;Load the block address
+               LDMFD   R13!,{R0,R2-R9,R14}     ;Unstack registers
+               BICS    PC,R14,#V_flag          ;And return to caller
+
+               ; --- We failed miserably ---
+
+90dh_midExtend ADD     R13,R13,#4              ;Don't restore R0 on exit
+               LDMFD   R13!,{R2-R9,R14}        ;Unstack registers
+               ORRS    PC,R14,#V_flag          ;And return to caller
+
+               LTORG
+
+; --- dh__move ---
+;
+; On entry:    R0 == destination of movement
+;              R1 == base of block to move
+;              R2 == size of block to move
+;
+; On exit:     --
+;
+; Use:         Shunts memory around in the heap, relocating everything that
+;              needs relocation.
+
+dh__move       ROUT
+
+               STMFD   R13!,{R3,R4,R14}        ;Save some registers
+               BL      fastMove                ;Do the memory movement
+
+               ; --- Now relocate entries on the stack ---
+
+10dh__move     LDR     R4,dyn_stackPtr         ;Find the stack pointer now
+               ADR     R3,dyn_stack            ;Point to the stack base
+15dh__move     CMP     R3,R4                   ;Have we finished yet?
+               BGE     %20dh__move             ;Yes -- return then
+               LDR     R14,[R3],#4             ;Load next entry from stack
+               SUB     R14,R14,R1              ;Subtract source address
+               CMP     R14,R2                  ;Is it in the block?
+               ADDLO   R14,R14,R0              ;Yes -- relocate
+               STRLO   R14,[R3,#-4]            ;And store back in stack
+               B       %15dh__move             ;And carry on relocating
+
+20dh__move     LDMFD   R13!,{R3,R4,PC}^        ;Return to caller
+
+               LTORG
+
+; --- dh_checkHeap ---
+;
+; On entry:    --
+;
+; On exit:     May return an error
+;
+; Use:         Checks the current internal format of the heap to make
+;              sure that it hasn't been corrupted in any way.
+;              If the integrity check fails then an error is returned.
+
+               EXPORT  dh_checkHeap
+dh_checkHeap   ROUT
+
+               STMFD   R13!,{R0-R7,R14}        ;Save some registers
+
+               ; --- Start going throught the blocks ---
+
+               LDR     R6,dyn_heapSize         ;Load the current heap size
+               DIR     R14                     ;Is it RISC PC?
+               LDRGE   R5,dyn_areaBase         ;Yes -- load the area base
+               RSBLT   R5,R6,#&01800000        ;No -- find the base anyway
+               ADD     R6,R6,R5                ;Find the heap end address
+               MOV     R9,R5                   ;Remember heap base address
+
+               ; --- Find a block ---
+
+               MOV     R7,R5                   ;Previous block
+00dh_checkHeap CMP     R5,R6                   ;Are we at the end yet?
+               ADRGTL  R0,msg_errBadHeap2      ;Oops -- must have a bad len
+               BGT     %90dh_checkHeap         ;Gone past -- oops
+               BEQ     %50dh_checkHeap         ;Yes -- jump ahead a little
+
+               MOV     R0,R5                   ;Get the base of area to chk
+               ADD     R1,R0,#blk__oHead       ;Get the overhead size
+               SWI     OS_ValidateAddress      ;Make sure this is kosher
+               ADRCSL  R0,msg_errBadHeap2      ;No -- must have a bad len
+               BCS     %90dh_checkHeap         ;If not, moan at client
+               LDR     R2,[R5,#blk__anchor]    ;Get the block's anchor addr
+               CMP     R2,#0                   ;Is the block free?
+               BEQ     %10dh_checkHeap         ;Yes -- jump ahead
+
+               ; --- Make sure the anchor checks OK ---
+
+               MOV     R7,R5                   ;This block could be wrong
+               MOV     R0,R2                   ;Get the base of area to chk
+               ADD     R1,R0,#4                ;Just check one word
+               SWI     OS_ValidateAddress      ;Make sure this is kosher
+               ADRCSL  R0,msg_errBadHeap3      ;Address must be dead then
+               BCS     %90dh_checkHeap         ;If not, moan at client
+
+               LDR     R0,[R2,#0]              ;Load the anchors value
+               ADD     R14,R5,#blk__oHead      ;This is what R0 should be
+               CMP     R0,R14                  ;Do they match?
+               ADRNEL  R0,msg_errBadHeap1      ;No -- point to the error
+               BNE     %90dh_checkHeap         ;And return it joyfully
+
+               ; --- Go round for more then ---
+
+10dh_checkHeap LDR     R3,[R5,#blk__size]      ;Get the block size
+               ADD     R3,R3,#blk__oHead+15    ;Add on the overhead bytes
+               BIC     R3,R3,#15               ;And word align the size
+               ADD     R5,R5,R3                ;Yes -- move on to next one
+               B       %00dh_checkHeap         ;...go round for another one
+
+50dh_checkHeap LDMFD   R13!,{R0-R7,R14}        ;Load registers back
+               BICS    PC,R14,#V_flag          ;Return without error
+
+90dh_checkHeap ADD     R13,R13,#4
+               STR     R7,[R0,#0]              ;Store as the error number!
+               LDMFD   R13!,{R1-R7,R14}        ;Load registers back
+               ORRS    PC,R14,#V_flag          ;Return with error
+
+               LTORG
+
+; --- dh_changeAnchor ---
+;
+; On entry:    R0 == pointer to anchor for block
+;              R1 == address of new anchor
+;
+; On exit:     --
+;
+; Use:         Adjusts a block's anchor, in case it moves.
+
+               EXPORT  dh_changeAnchor
+dh_changeAnchor        ROUT
+
+               STMFD   R13!,{R2,R14}           ;Save a register
+               MOV     R2,R1                   ;Remember this value
+               BL      dh__checkAnchor         ;Make sure the anchor's OK
+               STRVC   R2,[R1,#blk__anchor]    ;Save the new anchor pointer
+               ADDVC   R14,R1,#blk__oHead      ;Skip onto the actual data
+               STRVC   R14,[R2,#0]             ;And set the new anchor up
+               LDMFD   R13!,{R2,PC}            ;Return to caller
+
+               LTORG
+
+; --- dh_dump ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Outputs a textual description of the dynamite heap, giving
+;              details of each block within it.
+
+dh__preDump    LDR     R12,[R12]
+
+               EXPORT  dh_dump
+dh_dump                ROUT
+
+               STMFD   R13!,{R0-R4,R14}        ;Stack some registers
+
+               LDR     R4,dyn_heapSize         ;Get the current heap size
+               DIR     R14                     ;Which direction does it go?
+               LDRGE   R2,dyn_areaBase         ;Up -- find the base then
+               RSBLT   R2,R4,#&1800000         ;Down -- start below the RMA
+               ADD     R3,R2,R4                ;Find the heap limit address
+
+               ; --- Display information about the heap in general ---
+
+               ADRL    R0,msg_dumpHpBase       ;Find the message
+               MOV     R1,R2                   ;Get the heap base address
+               BL      dh__writeHex            ;And display it
+
+               MOV     R1,R4                   ;Get the heap size
+               ADRL    R0,msg_dumpHpSize       ;Find the message
+               BL      dh__writeHex            ;And display it
+
+               LDR     R1,dyn_areaSize         ;Get the dynamic area size
+               ADRL    R0,msg_dumpHpArSz       ;Find the message
+               BL      dh__writeHex            ;And display it
+
+               ; --- Now start on the loop ---
+
+00             CMP     R2,R3                   ;Have we finished yet?
+               LDMCSFD R13!,{R0-R4,PC}^        ;Yes -- then return
+
+               SWI     OS_NewLine              ;Start a new line here
+
+               ADRL    R0,msg_dumpBlkAddr      ;Point to the message
+               ADD     R1,R2,#blk__oHead       ;Point to the current block
+               BL      dh__writeHex            ;Display it
+
+               ADRL    R0,msg_dumpBlkSize      ;Point at the message
+               MOV     R0,R0                   ;No-op to prevent objasm bug!
+               LDR     R1,[R2,#blk__size]      ;Get the block's size
+               BL      dh__writeHex            ;Display it
+
+               LDR     R1,[R2,#blk__id]        ;Load the magic ID
+               ADRL    R0,msg_dumpBlkId        ;Point at the message
+               BL      dh__writeHex            ;Display it nicely
+
+               LDR     R1,[R2,#blk__anchor]    ;Find the anchor address
+               CMP     R1,#0                   ;Is the block free?
+               ADREQL  R0,msg_dumpBlkFree      ;Yes -- point to the message
+               SWIEQ   XOS_Write0              ;And display it on screen
+               ADRNEL  R0,msg_dumpBlkAnch      ;Otherwise show anchor addr
+               BLNE    dh__writeHex            ;And move on to next block
+
+               LDR     R14,[R2,#blk__size]     ;Load the block size again
+               ADD     R14,R14,#blk__oHead+15  ;Add overhead and align
+               BIC     R14,R14,#15             ;To find the next block
+               ADD     R2,R2,R14               ;Move onto the next block
+               B       %b00                    ;And skip back into the loop
+
+dh__writeHex   STMFD   R13!,{R2,R14}           ;Save some registers
+               SWI     XOS_Write0              ;Display the string
+               SUB     R13,R13,#12             ;Make a small buffer
+               MOV     R0,R1                   ;Get the number to display
+               MOV     R1,R13                  ;Point to the buffer
+               MOV     R2,#12                  ;The buffer size, sir
+               SWI     XOS_ConvertHex8         ;Convert it into ASCII
+               SWI     XOS_Write0              ;Display that too
+               SWI     XOS_NewLine             ;Move on to a new line
+               ADD     R13,R13,#12             ;Restore the stack pointer
+               LDMFD   R13!,{R2,PC}^           ;And return to caller
+
+               LTORG
+
+;----- * Commands -----------------------------------------------------------
+
+               AREA    |Dynamite$$Commands|,CODE,READONLY
+
+               DCB     "Dynamite_HeapDump",0
+               DCD     dh__preDump
+               DCD     0
+               DCD     synt_heapDump
+               DCD     help_heapDump
+
+;----- Data structures ------------------------------------------------------
+
+; --- Block descriptors ---
+
+               ^       0
+blk__anchor    #       4                       ;Address of block's anchor
+blk__size      #       4                       ;Block's size, as allocated
+blk__id                #       4                       ;Client's magic ID number
+blk__oHead     #       0                       ;Overhead on allocated blocks
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/s/dynTask b/StraySrc/Dynamite/dynamite/s/dynTask
new file mode 100644 (file)
index 0000000..6d3e5e3
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/dynTask
@@ -0,0 +1,305 @@
+;
+; dynTask.s
+;
+; The background compacting WIMP task
+;
+; © 1994-1998 Straylight
+;
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+               GET     libs:stream
+
+;----- External dependencies ------------------------------------------------
+
+               GET     sh.dynHeap
+               GET     sh.wSpace
+
+               GET     sh.messages
+
+               IMPORT  dyn_base
+
+;----- Main code ------------------------------------------------------------
+
+               AREA    |Dynamite$$Code|,CODE,READONLY
+
+; --- dt_service ---
+;
+; On entry:    R1 == service call number
+;              Other registers depend on R1
+;
+; On exit:     Depends on service call
+;
+; Use:         Handles service calls for Dynamite
+
+               EXPORT  dt_service
+dt_service     ROUT
+
+               ; --- Get rid of unwanted services quickly ---
+
+               CMP     R1,#&4A
+               CMPNE   R1,#&27
+               CMPNE   R1,#&49
+               MOVNES  PC,R14
+
+               ; --- Now dispatch wanted services ---
+
+               LDR     R12,[R12,#0]            ;Get my workspace pointer
+               STMFD   R13!,{R14}              ;Save some useful registers
+
+               CMP     R1,#&27                 ;Service_Reset...
+               BEQ     %20dt_service
+
+               CMP     R1,#&4A                 ;Service_StartedWimp
+               BEQ     %10dt_service
+
+               ; --- Service_StartWimp ---
+
+               LDR     R14,dyn_taskHandle      ;Get my task handle
+               CMP     R14,#0                  ;Am I already running?
+               MOVEQ   R14,#-1                 ;I'm trying to start up
+               STREQ   R14,dyn_taskHandle      ;Store as my task handle
+               ADREQL  R0,dt__commands         ;Point to the command string
+               MOVEQ   R1,#0                   ;Claim the service call
+               LDMFD   R13!,{PC}^              ;Return to RISC OS
+
+               ; --- Service_StartedWimp ---
+
+10dt_service   LDR     R14,dyn_taskHandle      ;Get my task handle
+               CMP     R14,#-1                 ;Am I already running?
+               MOVEQ   R14,#0                  ;No -- blank out task handle
+               STREQ   R14,dyn_taskHandle      ;Store it over the old one
+               LDMFD   R13!,{PC}^              ;Return happily
+
+               ; --- Service_Reset ---
+
+20dt_service   MOV     R14,#0                  ;Blank out my task handle
+               STR     R14,dyn_taskHandle      ;Store it over the old one
+               LDMFD   R13!,{PC}^              ;Return to RISC OS now
+
+               LTORG
+
+; --- dt__startTask ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Starts up the Dynamite application from a *Command.
+
+dt__startTask  ROUT
+
+               LDR     R12,[R12]               ;Load my workspace address
+               LDR     R0,dyn_taskHandle       ;Get my task handle variable
+               CMP     R0,#-1                  ;Am I waiting to start?
+               ADRNEL  R0,msg_errDesk          ;No -- moan at stupid user
+               ORRNES  PC,R14,#V_flag          ;And return the error
+               MOV     R0,#1                   ;We're launching the app
+               STR     R0,dyn_launch           ;So set the launch flag
+               STMFD   R13!,{R14}              ;Save a register nicely
+               MOV     R0,#2                   ;Start my module up
+               ADR     R1,dt__myName           ;Point to the module name
+               SWI     XOS_Module              ;Start up the task proper
+               LDMFD   R13!,{PC}               ;And return to caller
+
+dt__myName     DCB     "Dynamite",0
+
+               LTORG
+
+; --- dt_quit ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Closes down Dynamite's WIMP task (used for background
+;              compaction of the heap).
+
+               EXPORT  dt_quit
+dt_quit                ROUT
+
+               STMFD   R13!,{R0,R1,R14}        ;Save some registers
+               LDR     R0,dyn_taskHandle       ;Find my task handle
+               LDR     R1,=&4B534154           ;The magic number thing
+               SWI     XWimp_CloseDown         ;Close down the application
+               MOV     R14,#0                  ;Now we don't have a task
+               STR     R14,dyn_taskHandle      ;So zap my task handle
+               LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
+
+               LTORG
+
+; --- dt_run ---
+;
+; On entry:    R12 == address of module private word
+;
+; On exit:     Via OS_Exit
+;
+; Use:         Runs the Dynamite WIMP task.
+
+               EXPORT  dt_run
+dt_run         ROUT
+
+               LDR     R12,[R12]               ;Find my workspace address
+               ADR     R13,dyn_pollBlk+256     ;Make a microstack
+
+               ; --- Is it worth doing anything? ---
+
+               MOV     R0,#0                   ;How many Wimp tasks?
+               SWI     Wimp_ReadSysInfo        ;Read the number back
+               CMP     R0,#0                   ;Are there any running?
+               SWIEQ   OS_Exit                 ;Nope: then don't bother
+
+               ; --- Handle the ultra-weird launch sequence ---
+
+               LDR     R14,dyn_launch          ;Load the launch flag
+               CMP     R14,#0                  ;Are we launching?
+               BEQ     %50dt_run               ;No -- launch then
+
+               ; --- Start up the WIMP thing ---
+
+               MOV     R0,#200                 ;Make it run under RISC OS 2
+               LDR     R1,=&4B534154           ;Get the magic number thing
+               ADR     R2,dt__taskName         ;Point to the task name
+               SWI     Wimp_Initialise         ;Start up the WindowManager
+               STR     R1,dyn_taskHandle       ;Save the task handle
+
+               ; --- Remove my name from the Switcher's list ---
+
+               ADR     R1,dyn_pollBlk          ;Point to the poll block
+               MOV     R0,#20                  ;Minimum message size
+               STR     R0,[R1,#0]              ;Save in position 0
+               MOV     R2,#0                   ;This is not a reply
+               MOV     R3,#&40000              ;The TaskCloseDown message
+               ORR     R3,R3,#&000C3           ;It comes in two episodes
+               ADD     R0,R1,#12               ;Point to bit of message blk
+               STMIA   R0,{R2,R3}              ;Build the message in there
+               MOV     R0,#17                  ;Don't get a reply
+               MOV     R2,#0                   ;Give everyone a shot at it
+               SWI     XWimp_SendMessage       ;Send it the message
+
+               ; --- Now do the main loop ---
+
+00dt_run       LDR     R14,dyn_hpFlags         ;Load the heap's flags
+               TST     R14,#hpFlag_tidy        ;Is the heap tidy?
+               LDREQ   R14,dyn_lockCount       ;No -- then load lock count
+               CMPEQ   R14,#0                  ;Is the heap locked?
+               MOVNE   R0,#1                   ;Tidy or locked, so be nice
+               MOVEQ   R0,#0                   ;Otherwise use idles
+               ADR     R1,dyn_pollBlk          ;Point to my pollblock
+               ADD     R13,R1,#256             ;Make a bogus stack
+               SWI     Wimp_Poll               ;Do the poll thing
+               CMP     R0,#0                   ;Is it an idle event?
+               SWIEQ   Dynamite_Reduce         ;Yes -- then reduce the heap
+               CMP     R0,#17                  ;Is it a message
+               CMPNE   R0,#18                  ;Of either type
+               LDREQ   R0,[R1,#16]             ;Get the message type
+               CMPEQ   R0,#0                   ;Is it a Message_Quit
+               LDRNE   R14,dyn_hpFlags         ;No -- load the flags
+               BICNE   R14,R14,#hpFlag_mSent   ;...clear the message sent
+               STRNE   R14,dyn_hpFlags         ;...save the flags back
+               BNE     %00dt_run               ;...loop round again
+
+               ; --- I've been told to quit ---
+               ;
+               ; Seeing as I've viciously and nastily removed myself from
+               ; the TaskManager's task table, I know this must have been
+               ; a broadcast quit, so I hari-kiri with wanton abandon.
+
+               SWI     Wimp_CloseDown          ;Close down the task
+               MOV     R0,#0                   ;No task handle any more
+               STR     R0,dyn_taskHandle       ;So zero it then
+               SWI     OS_Exit                 ;Farewell, cruel world
+
+dt__taskName   DCB     "DynamiteCompactor",0
+
+               ; --- Launch the Compactor task ---
+
+50dt_run       MOV     R0,#200                 ;Make it run under RISC OS 2
+               LDR     R1,=&4B534154           ;Get the magic number thing
+               ADR     R2,dt__launchName       ;Point to the task name
+               SWI     Wimp_Initialise         ;Start up the WindowManager
+
+               MOV     R0,#-1                  ;Fake a startup sequence
+               STR     R0,dyn_taskHandle       ;Save this as my task handle
+               LDR     R0,=dt__commands        ;Point to my main command
+               BL      dyn_base                ;Find the module base
+               ADD     R0,R14,R0               ;Relocate the address
+               SWI     Wimp_StartTask          ;Start it up nicely
+
+               SWI     Wimp_CloseDown          ;Tell WIMP to get knotted
+               SWI     OS_Exit                 ;And kill self evilly
+
+dt__launchName DCB     "DynamiteLauncher",0
+
+               LTORG
+
+; --- dt_message ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Sends a silly message to the Compactor task so that it gets
+;              control again if it disabled idle events.
+
+               EXPORT  dt_message
+dt_message     ROUT
+
+               STMFD   R13!,{R0-R3,R14}        ;Save some registers
+               LDR     R14,dyn_taskHandle      ;Load my task handle
+               CMP     R14,#0                  ;Is it vaguely sensible?
+               LDMLEFD R13!,{R0-R3,PC}^        ;No -- don't bother then
+               LDR     R14,dyn_hpFlags         ;Load the flags
+               TST     R14,#hpFlag_mSent       ;Has a message been sent?
+               LDMNEFD R13!,{R0-R3,PC}^        ;Yes -- then return
+               ORR     R14,R14,#hpFlag_mSent   ;Set the flag
+               STR     R14,dyn_hpFlags         ;And save the flags back
+               ADR     R1,dyn_pollBlk          ;Point to the poll block
+               MOV     R0,#20                  ;Minimum message size
+               STR     R0,[R1,#0]              ;Save in position 0
+               MOV     R2,#0                   ;This is not a reply
+               MOV     R3,#&4A000              ;A bogus message number
+               ORR     R3,R3,#&003C0           ;(My SWI chunk base)
+               ADD     R0,R1,#12               ;Point to bit of message blk
+               STMIA   R0,{R2,R3}              ;Build the message in there
+               MOV     R0,#17                  ;Don't get a reply
+               MOV     R2,R14                  ;Get my task handle
+               SWI     XWimp_SendMessage       ;Send it the message
+               LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
+
+               LTORG
+
+               ; --- *Commands ---
+
+               AREA    |Dynamite$$Commands|,CODE,READONLY
+
+dt__commands   DCB     "Desktop_DynamiteCompactor",0
+               DCD     dt__startTask
+               DCD     0
+               DCD     synt_compactor
+               DCD     help_compactor
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/s/dynamite b/StraySrc/Dynamite/dynamite/s/dynamite
new file mode 100644 (file)
index 0000000..2024e17
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/dynamite
@@ -0,0 +1,608 @@
+;
+; dynamite.s
+;
+; Memory management in a dynamic area
+;
+; © 1994-1998 Straylight
+
+;----- Licensing note -------------------------------------------------------
+;
+; This file is part of Straylight's Dynamite
+;
+; Dynamite 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, or (at your option)
+; any later version.
+;
+; Dynamite 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 Dynamite.  If not, write to the Free Software Foundation,
+; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+;----- Standard header ------------------------------------------------------
+
+               GET     libs:header
+               GET     libs:swis
+
+               GET     libs:stream
+
+;----- External dependencies ------------------------------------------------
+
+               GET     sh.dynAnchor
+               GET     sh.dynArea
+               GET     sh.dynHeap
+               GET     sh.dynTask
+               GET     sh.wSpace
+
+               GET     sh.messages
+
+               IMPORT  version
+               IMPORT  |Dynamite$$Commands$$Base|
+
+;----- Module header --------------------------------------------------------
+
+               AREA    |!!!Module$$Header|,CODE,READONLY
+
+dyn__base      DCD     dt_run                  ;Application code
+               DCD     dyn__init               ;Initialisation
+               DCD     dyn__quit               ;Finalisation
+               DCD     dt_service              ;Service call handling
+               DCD     dyn__name               ;Module title string
+               DCD     version                 ;Module help string
+               DCD     |Dynamite$$Commands$$Base| ;Command table
+               DCD     &4A3C0                  ;SWI chunk number
+               DCD     dyn__swis               ;SWI handler code
+               DCD     dyn__swiNames           ;SWI name table
+               DCD     0                       ;SWI name-number code
+
+dyn__name      DCB     "Dynamite",0
+
+;----- Main module code -----------------------------------------------------
+
+               AREA    |Dynamite$$Code|,CODE,READONLY
+
+; --- dyn_base ---
+;
+; On entry:    --
+;
+; On exit:     R14 == base address of module
+;
+; Use:         Finds the base address of the module.
+
+               EXPORT  dyn_base
+dyn_base       ROUT
+
+               STMFD   R13!,{R14}
+               ADR     R14,dyn__base
+               LDMFD   R13!,{PC}^
+
+               LTORG
+
+; --- dyn__init ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Claims some memory, and intercepts OS_ChangeDynamicArea.
+
+dyn__init      ROUT
+
+               STMFD   R13!,{R7,R8,R14}        ;Save some registers
+
+               ; --- Allocate module workspace ---
+
+               MOV     R0,#6                   ;Claim RMA workspace
+               LDR     R3,=dyn_wSize           ;Get my workspace size
+               SWI     XOS_Module              ;Allocate the workspace
+               LDMVSFD R13!,{R7,R8,PC}         ;If it failed, return error
+               STR     R2,[R12,#0]             ;Save workspace address
+               MOV     R12,R2                  ;Point to workspace nicely
+               STR     R12,dyn__wsAddr         ;Store for my patch code
+
+               MOV     R0,#0                   ;Initialise some workspace
+               STR     R0,dyn_areaSize         ;Dynamic area not created yet
+               STR     R0,dyn_heapSize         ;No data in the heap
+               STR     R0,dyn_lockCount        ;And clear the lock counter
+               STR     R0,dyn_launch           ;Make RMRun do clever stuff
+               STR     R0,dyn_taskHandle       ;And make the task handle 0
+               STR     R0,dyn_ancTable         ;Clear the free anchor table
+               STR     R0,dyn_ancList          ;And the anchor block list
+               MOV     R0,#hpFlag_tidy         ;We are compacted now
+               STR     R0,dyn_hpFlags          ;So make a note of this
+
+               ADR     R14,dyn_stack           ;Point to reloc stack base
+               STR     R14,dyn_stackPtr        ;Save as the stack pointer
+
+               ; --- Claim OS_ChangeDynamicArea ---
+               ;
+               ; We trap this in the kernel branch table, rather than at
+               ; the SWI vector, because it's so much easier.
+
+               SWI     XOS_ReadMemMapInfo      ;Read nice things
+               STR     R0,dyn_pageSize         ;Save the page size
+               SUB     R1,R1,#1                ;Chop one off for da_findPage
+               STR     R1,dyn_pageCount        ;And the number of them
+               MOV     R14,#0                  ;Log 2 of page size
+00dyn__init    TST     R0,#1                   ;Is bottom bit set yet?
+               MOVEQ   R0,R0,LSR#1             ;No -- shift along a bit
+               ADDEQ   R14,R14,#1              ;Add to the log
+               BEQ     %00dyn__init            ;And keep on going
+               STR     R14,dyn_log2PageSize    ;And store this away
+
+               MOV     R0,#129                 ;The OS_Byte number
+               MOV     R1,#0                   ;Lovely...
+               MOV     R2,#255                 ;...jubbly!
+               SWI     XOS_Byte                ;Get OS Version number
+               STR     R1,dyn_machine          ;Store this away
+               CMP     R1,#&A5                 ;Is this a RISC PC?
+               BGE     %50dyn__init            ;Yes -- jump ahead then
+               CMP     R1,#&A3                 ;Is it RISC OS 2?
+               LDRLT   R0,=&ABC                ;Yes --- this is sprarea size
+               LDRGE   R0,=&ACC                ;No -- this is then
+               STR     R0,dyn_sprSize          ;Save in the workspace
+
+               MOV     R6,PC                   ;Get the current status
+               TST     R6,#IRQ_disable         ;Are IRQs enabled?
+               TEQEQP  R6,#IRQ_disable         ;Yes -- disable them then
+
+               LDR     R0,=&01F033FC           ;Find the kernel dispatcher
+               LDR     R14,[R0,#OS_ChangeDynamicArea*4]
+               STR     R14,dyn_oldChnArea      ;Save this in my workspace
+               ADR     R14,dyn__patch          ;Point to my patch routine
+               STR     R14,[R0,#OS_ChangeDynamicArea*4]
+
+               LDR     R14,[R0,#OS_ReadDynamicArea*4]
+               STR     R14,dyn_oldReadArea     ;Save this in my workspace
+               ADR     R14,dyn__readPatch      ;Point to my patch routine
+               STR     R14,[R0,#OS_ReadDynamicArea*4]
+
+               LDR     R14,[R0,#OS_ValidateAddress*4]
+               STR     R14,dyn_oldValidate     ;Save this in my workspace
+               ADR     R14,dyn__valPatch       ;Point to my patch routine
+               STR     R14,[R0,#OS_ValidateAddress*4]
+               TEQP    R6,#0                   ;Restore interrupt status
+               MOV     R0,R0                   ;Shut the assembler up
+
+               ; --- Find the TaskManager and WindowManager addresses ---
+
+               ADR     R6,dyn_switchBase       ;Point to bit of workspace
+               MOV     R0,#18                  ;Look up modules by name
+               ADR     R1,dyn__switcher        ;Point to the Switcher's name
+               SWI     XOS_Module              ;Try and find its address
+               MOVVS   R3,#0                   ;If not there, dummy address
+               MOVVS   R4,#0                   ;For that and the end
+               LDRVC   R4,[R3,#-4]             ;Otherwise load module length
+               STMIA   R6!,{R3,R4}             ;Save them in workspace
+
+               ADR     R1,dyn__wimp            ;Point to the Wimp's name
+               SWI     XOS_Module              ;Try and find its address
+               MOVVS   R3,#0                   ;If not there, dummy address
+               MOVVS   R4,#0                   ;For that and the end
+               LDRVC   R4,[R3,#-4]             ;Otherwise load module length
+               STMIA   R6!,{R3,R4}             ;Save them in workspace
+               LDMFD   R13!,{R7,R8,PC}^        ;Return to caller
+
+               ; --- The machine is a RISC PC -- lucky sod! ---
+
+50dyn__init    MOV     R0,#0                   ;Create dynamic area
+               MOV     R1,#-1                  ;No particular number
+               MOV     R2,#0                   ;Initial size of area
+               MOV     R3,#-1                  ;No particular base address
+               MOV     R4,#&80                 ;The area flags
+               MOV     R5,#-1                  ;No maximum size please
+               MOV     R6,#0                   ;No handler needed
+               MOV     R7,#0                   ;Workspace to pass to handler
+               ADR     R8,dyn__areaName        ;Dynamic area name
+               SWI     XOS_DynamicArea         ;Create the area
+               STRVC   R1,dyn_areaHandle       ;Store the handle
+               STRVC   R3,dyn_areaBase         ;And the base address
+
+               LDMFD   R13!,{R7,R8,PC}         ;Return to caller
+
+dyn__switcher  DCB     "TaskManager",0
+dyn__wimp      DCB     "WindowManager",0
+dyn__areaName  DCB     "Dynamite",0
+
+               LTORG
+
+dyn__wsAddr    DCD     0                       ;Yuk -- address of workspace
+
+; --- dyn__quit ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Tries to close Dynamite down.
+
+dyn__quit      ROUT
+
+               STMFD   R13!,{R12,R14}          ;Save a register
+               LDR     R12,[R12]               ;Find my workspace address
+
+               ; --- Make sure we're not needed ---
+
+               BL      dh_compact              ;Compact the heap first
+               LDR     R14,dyn_areaSize        ;How much space are we using?
+               CMP     R14,#0                  ;Is it 0?
+               BNE     %45dyn__quit            ;No -- people might want them
+               LDR     R14,dyn_stackPtr        ;Load the stack pointer
+               ADR     R0,dyn_stack            ;Point to the stack base
+               CMP     R14,R0                  ;Are these equal?
+               BNE     %45dyn__quit            ;No -- we're still used then
+
+               ; --- Close down the compactor ---
+
+               LDR     R14,dyn_taskHandle      ;Get the task handle
+               CMP     R14,#0                  ;Is it a sensible one?
+               BLGT    dt_quit                 ;Yes -- kill the task then
+               BL      danc_quit               ;Free all anchor blocks
+
+               ; --- Get rid of all used pages ---
+
+               LDR     R0,dyn_areaSize         ;Get the area size
+               LDR     R1,dyn_log2PageSize     ;And log 2 of page size
+               MOV     R0,R0,LSR R1            ;Number of pages in area
+               BL      da_removePages          ;Remove pages
+
+               LDR     R0,dyn_machine          ;Get the machine type
+               CMP     R0,#&A5                 ;Is it a RISC PC?
+               BGE     %60dyn__quit            ;Yes -- jump ahead
+
+               ; --- First, try to release OS_ChangeDynamicArea ---
+
+               LDR     R0,=&01F033FC           ;Find the kernel dispatcher
+               LDR     R1,[R0,#OS_ChangeDynamicArea*4]
+               ADR     R14,dyn__patch          ;Point to my patch routine
+               CMP     R1,R14                  ;Can I release it safely?
+               BNE     %50dyn__quit            ;No -- report an error
+
+               LDR     R1,[R0,#OS_ReadDynamicArea*4]
+               ADR     R14,dyn__readPatch      ;Point to my patch routine
+               CMP     R1,R14                  ;Can I release it safely?
+               BNE     %50dyn__quit            ;No -- report an error
+
+               LDR     R1,[R0,#OS_ValidateAddress*4]
+               ADR     R14,dyn__valPatch       ;Point to my patch routine
+               CMP     R1,R14                  ;Can I release it safely?
+               BNE     %50dyn__quit            ;No -- report an error
+
+               LDR     R14,dyn_oldChnArea      ;Load the previous value
+               STR     R14,[R0,#OS_ChangeDynamicArea*4]
+               LDR     R14,dyn_oldReadArea     ;Load the previous value
+               STR     R14,[R0,#OS_ReadDynamicArea*4]
+               LDR     R14,dyn_oldValidate     ;Load the previous value
+               STR     R14,[R0,#OS_ValidateAddress*4]
+
+               ; --- Free the workspace I claimed ---
+
+40dyn__quit    MOV     R0,#7                   ;Free RMA workspace
+               MOV     R2,R12                  ;Point to my workspace
+               SWI     XOS_Module              ;Try to free it nicely
+               LDR     R0,[R13],#4             ;Load private word address
+               MOV     R14,#0                  ;Clear private word value
+               STR     R14,[R0,#0]             ;To stop OS doing this too...
+               LDMFD   R13!,{PC}^              ;Return to caller
+
+               ; --- We have handles or relocation entries ---
+
+45dyn__quit    ADRL    R0,msg_errInUse         ;Point to error message
+               LDMFD   R13!,{R12,R14}          ;Unstack some registers
+               ORRS    PC,R14,#V_flag          ;Return to caller with error
+
+               ; --- We couldn't release OS_ChangeDynamicArea ---
+
+50dyn__quit    ADRL    R0,msg_errRelease       ;Point to error message
+               LDMFD   R13!,{R12,R14}          ;Unstack some registers
+               ORRS    PC,R14,#V_flag          ;Return to caller with error
+
+               ; --- We're on a RISC PC ---
+
+60dyn__quit    MOV     R0,#1                   ;Remove dynamic area
+               LDR     R1,dyn_areaHandle       ;Get the area handle
+               SWI     XOS_DynamicArea         ;Remove it then
+               B       %40dyn__quit            ;Now free workspace etc.
+
+               LTORG
+
+; --- dyn__patch ---
+;
+; On entry:    As for ChangeDynamicArea
+;
+; On exit:     Ditto
+;
+; Use:         Mangles ChangeDynamicArea when being used on the system
+;              sprite area.
+
+dyn__patch     ROUT
+
+               LDR     R12,dyn__wsAddr         ;Find my workspace address
+               CMP     R0,#3                   ;Is it the sprite area?
+               LDRNE   PC,dyn_oldChnArea       ;No -- continue as normal
+
+               ; --- Mangle the `remembered' size of the sprite area ---
+
+               STMFD   R13!,{R14}              ;Save another register
+               LDR     R11,dyn_sprSize         ;Find the size word
+               LDR     R14,[R11,#0]            ;Load total sprite area size
+               ADD     R10,R14,R1              ;How much does he want?
+               CMP     R10,#4*1024*1024        ;More than 4 megs?
+               BGT     %90dyn__patch           ;Yes -- that's an error
+               LDR     R10,dyn_areaSize        ;Load my area's size
+               SUB     R14,R14,R10             ;Get the size of the sprites
+               STR     R14,[R11,#0]            ;Save that for the duration
+
+               ; --- This is nasty and complicated ---
+               ;
+               ; Post processing on kernel SWIs is not something normally
+               ; to be enjoyed.  The way things will have to be done is as
+               ; follows:
+               ;
+               ; * We save R14 and the value &2002A (XOS_ChangeDynamicArea)
+               ;   on the stack.  The SWI value is so that we regain control
+               ;   if something went sadly amiss.
+               ;
+               ; * We call the previous OS_ChangeDynamicArea routine, having
+               ;   set a suitably bogus return address.
+               ;
+               ; * We mangle the system sprite area in a manner in keeping
+               ;   with the aim of the program.
+               ;
+               ; * Then we examine the status returned to us, and if V was
+               ;   set AND the X bit of the R11 saved on the stack before
+               ;   we were entered at the top was clear we call
+               ;   OS_GenerateError.
+
+               MOV     R11,#OS_ChangeDynamicArea ;Get the SWI number
+               ORR     R11,R11,#&20000         ;Set the X bit nicely
+               STMFD   R13!,{R10-R12}          ;Save other registers here
+               STMFD   R13!,{R11}              ;And the obviously bogus R11
+               MOV     R14,PC                  ;Set up a return address
+               LDR     PC,dyn_oldChnArea       ;And let it rip...
+
+               ; --- We have now done a ChangeDynamicArea ---
+                ;
+                ; R14 saved above is on the stack, along with the caller's
+                ; R10-R12 from the OS SWI dispatcher.
+
+               LDR     R11,dyn_sprSize         ;Find the size word
+               LDR     R14,[R11,#0]            ;Load the new area size
+               ADD     R14,R14,R10             ;Add the old difference
+               STR     R14,[R11,#0]            ;And save it back again
+
+50dyn__patch   LDMFD   R13!,{R14}              ;Get his return address
+               LDMFD   R13!,{R11}              ;Get the SWI number too
+               LDMVCFD R13!,{R10-R12}          ;Restore his registers
+               BICVCS  PC,R14,#V_flag          ;And return control to him
+
+               TST     R11,#&20000             ;Was the X bit set?
+               SWIEQ   OS_GenerateError        ;No -- do error like things
+
+               LDMFD   R13!,{R10-R12}          ;Restore his registers
+               ORRS    PC,R14,#V_flag          ;And return the error
+
+               ; --- He wanted too much memory ---
+
+90dyn__patch   ADRL    R0,msg_errTooBig        ;Point to the error
+               CMP     R0,#&80000000           ;Create an overflow
+               B       %50dyn__patch           ;Make it look like it came
+                                               ;from ChangeDynamicArea
+               LTORG
+
+; --- dyn__readPatch ---
+;
+; On entry:    R0 == dynamic area to read, and flags etc.
+;
+; On exit:     R1 == size of dynamic area, R2 == optional maximum size
+;
+; Use:         Reads the size of a dynamic area.  If the caller is
+;              interested in the sprite area AND they're not either the
+;              TaskManager or the WindowManager, we mangle the result so
+;              they think that the sprite area doesn't contain our clever
+;              heap.
+
+dyn__readPatch ROUT
+
+               LDR     R12,dyn__wsAddr         ;Find my workspace address
+               BIC     R10,R0,#&80             ;Clear the clever flag bit
+               CMP     R10,#3                  ;Is it the sprite area?
+               LDRNE   PC,dyn_oldReadArea      ;No -- continue as normal
+
+               ; --- Do all the work then ---
+               ;
+               ; Seeing as we know all there is to know about the sprite
+               ; area, we can do all this here without the yukkiness of
+               ; postprocessing.
+
+               STMFD   R13!,{R2,R14}           ;Save the link register
+               ADR     R11,dyn_switchBase      ;Find module addresses
+               BIC     R10,R14,#&FC000003      ;Find caller's address
+               LDMIA   R11!,{R1,R2}            ;Load switcher base/size
+               SUB     R14,R10,R1              ;Subtract switcher base
+               CMP     R14,R2                  ;Is it within switcher?
+               LDMHSIA R11!,{R1,R2}            ;No -- load wimp base/size
+               SUBHS   R14,R10,R1              ;Subtract wimp base
+               CMPHS   R14,R2                  ;Is it within wimp?
+               LDMFD   R13!,{R2,R14}           ;Unstack registers again
+
+               LDR     R1,dyn_sprSize          ;Find sprite area size word
+               LDR     R1,[R1,#0]              ;Load current sprite size
+               LDRHS   R10,dyn_areaSize        ;If caller is pleb, mangle it
+               SUBHS   R1,R1,R10               ;By subtracting our heap size
+               TST     R0,#&80                 ;Does he want max size?
+               MOVNE   R2,#4*1024*1024         ;Yes -- that's 4MB
+               MOV     R0,#&01400000           ;Point to sprite area start
+
+               ADD     R13,R13,#4              ;Skip past stacked R11
+               LDMFD   R13!,{R10-R12}          ;Unstack caller's registers
+               BICS    PC,R14,#V_flag          ;And return to caller
+
+               LTORG
+
+; --- dyn__valPatch ---
+;
+; On entry:    As for OS_ValidateAddress
+;
+; On exit:     As for OS_ValidateAddress
+;
+; Use:         Mangles OS_ValidateAddress so that it gets our somewhat
+;              rearranged sprite area correct.  This is necessary due to
+;              braindead implementation of OS_ValidateAddress.  I'd like to
+;              be able to do the job properly by hacking the CAM map, but
+;              the Mysterious Background Address Validator assumes that the
+;              SWI works in the way Acorn wrote it, so that's put the
+;              kybosh on that plan.
+
+dyn__valPatch  ROUT
+
+               LDR     R12,dyn__wsAddr         ;Find my workspace address
+
+               STMFD   R13!,{R14}              ;Save the link register
+               MOV     R10,#&01400000          ;Get base of the sprite area
+               MOV     R11,#&01800000          ;Get limit too
+               CMP     R0,R10                  ;Is it in there?
+               CMPCS   R11,R0
+               CMPCS   R1,R10
+               CMPCS   R11,R1
+               LDMCCFD R13!,{R14}              ;No -- restore link
+               LDRCC   PC,dyn_oldValidate      ;And let OS_VA do it then
+
+               ; --- Check for weird sprite area thing and Dynamite area ---
+
+               LDR     R11,dyn_sprSize         ;Get address of sprite size
+               LDR     R11,[R11,#0]            ;Load size of sprite area
+               LDR     R14,dyn_areaSize        ;Load our area size
+               ADD     R11,R10,R11             ;Find end of sprite area
+               SUB     R10,R11,R14             ;Taking our area into account
+               MOV     R11,#&01800000          ;Find top of sprite slot
+               SUB     R11,R11,R14             ;Find bottom of our area
+               CMP     R11,R0                  ;This is deep -- think about
+               CMPHI   R1,R10                  ;it for a while.
+               LDMFD   R13!,{R14}              ;If it isn't invalid...
+               ADD     R13,R13,#4
+               LDMFD   R13!,{R10-R12}
+               ORRHIS  PC,R14,#C_flag
+               BICLSS  PC,R14,#C_flag
+
+               LTORG
+
+; --- dyn__swis ---
+;
+; On entry:    R11 == SWI index
+;
+; On exit:     Depends on the SWI
+;
+; Use:         Dispatches SWIs to other routines
+
+dyn__swis      ROUT
+
+               LDR     R12,[R12]               ;Find my module workspace
+
+               CMP     R11,#&3F
+               BEQ     dh_dump
+
+               CMP     R11,#(%10-%00)/4        ;Is the SWI in range?
+               ADDLO   PC,PC,R11,LSL #2        ;Yes -- dispatch it then
+               B       %10dyn__swis            ;Otherwise report the error
+
+00dyn__swis    B       dh_alloc                ;Dynamite_Claim
+               B       dh_free                 ;Dynamite_Free
+               B       dh_freeWithID           ;Dynamite_FreeWithID
+               B       dh_blockInfo            ;Dynamite_BlockInfo
+               B       dh_changeID             ;Dynamite_ChangeID
+               B       dh_extend               ;Dynamite_Resize
+               B       dh_midExtend            ;Dynamite_MidExtend
+               B       dh_save                 ;Dynamite_Save
+               B       dh_load                 ;Dynamite_Load
+               B       dh_reduce               ;Dynamite_Reduce
+               B       dh_compact              ;Dynamite_Compact
+               B       dh_lock                 ;Dynamite_Lock
+               B       dh_unlock               ;Dynamite_Unlock
+               B       danc_alloc              ;Dynamite_ClaimAnchor
+               B       danc_free               ;Dynamite_ReleaseAnchor
+               B       da_readSize             ;Dynamite_ReadSpriteSize
+               B       da_describe             ;Dynamite_Describe
+               B       dh_checkHeap            ;Dynamite_IntegrityCheck
+               B       dh_changeAnchor         ;Dynamite_ChangeAnchor
+
+10dyn__swis    ADRL    R0,msg_errBadSWI        ;Point at the error
+               ORRS    PC,R14,#V_flag          ;And return it back
+
+dyn__swiNames  DCB     "Dynamite",0
+               DCB     "Alloc",0
+               DCB     "Free",0
+               DCB     "FreeWithID",0
+               DCB     "BlockInfo",0
+               DCB     "ChangeID",0
+               DCB     "Resize",0
+               DCB     "MidExtend",0
+               DCB     "Save",0
+               DCB     "Load",0
+               DCB     "Reduce",0
+               DCB     "Compact",0
+               DCB     "Lock",0
+               DCB     "Unlock",0
+               DCB     "ClaimAnchor",0
+               DCB     "ReleaseAnchor",0
+               DCB     "ReadSpriteSize",0
+               DCB     "Describe",0
+               DCB     "IntegrityCheck",0
+               DCB     "ChangeAnchor",0
+               DCB     0
+
+               LTORG
+
+; --- *Dynamite_Clear ---
+
+dyn__clear     ROUT
+
+               STMFD   R13!,{R14}              ;Save a register
+               LDR     R12,[R12]               ;Load the workspace address
+
+               ; --- Empty the heap ---
+
+               LDR     R0,dyn_areaSize         ;Get the area size
+               LDR     R1,dyn_log2PageSize     ;And log 2 of page size
+               MOV     R0,R0,LSR R1            ;Number of pages in area
+               BL      da_removePages          ;Remove pages
+
+               ; --- Free all the anchors ---
+
+               BL      danc_quit               ;Free all allocated anchors
+
+               ; --- Reset the heap variables ---
+
+               MOV     R0,#0                   ;Initialise some workspace
+               STR     R0,dyn_areaSize         ;Dynamic area not created yet
+               STR     R0,dyn_heapSize         ;No data in the heap
+               STR     R0,dyn_lockCount        ;And clear the lock counter
+               STR     R0,dyn_ancTable         ;Clear the free anchor table
+               STR     R0,dyn_ancList          ;And the anchor block list
+               MOV     R0,#hpFlag_tidy         ;We are compacted now
+               STR     R0,dyn_hpFlags          ;So make a note of this
+
+               LDMFD   R13!,{PC}^              ;And return to caller
+
+               LTORG
+
+               ; --- *Commands ---
+
+               AREA    |Dynamite$$Commands|,CODE,READONLY
+
+               DCB     "Dynamite_Clear",0
+               DCD     dyn__clear
+               DCD     0
+               DCD     synt_clear
+               DCD     help_clear
+
+               AREA    |Dynamite$$Commands_End|,CODE,READONLY
+               DCD     0
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/s/fastMove b/StraySrc/Dynamite/dynamite/s/fastMove
new file mode 100644 (file)
index 0000000..6e9b1f0
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/s/fastMove
@@ -0,0 +1 @@
+               LNK     libs:s.fastMove

diff --git a/StraySrc/Dynamite/dynamite/sh/dynAnchor b/StraySrc/Dynamite/dynamite/sh/dynAnchor
new file mode 100644 (file)
index 0000000..49f1439
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/sh/dynAnchor
@@ -0,0 +1,51 @@
+;
+; dynAnchor.sh
+;
+; Useful handle RMA allocation for dynamite
+;
+; © 1994 Straylight
+;
+
+;----- Overview -------------------------------------------------------------
+;
+; Functions provided:
+;
+;   danc_alloc
+;   danc_free
+;   danc_quit
+
+; --- danc_alloc ---
+;
+; On entry:    --
+;
+; On exit:     R0 == pointer to block allocated, or V set and pointer to
+;                    error
+;
+; Use:         Allocates an anchor to use with dynamite from the RMA,
+;              in a very quick way indeed.
+
+               IMPORT  danc_alloc
+
+; --- danc_free ---
+;
+; On entry:    R0 == pointer to block
+;
+; On exit:     Registers preserved
+;
+; Use:         Frees an anchor allocated using danc_alloc.
+
+               IMPORT  danc_free
+
+; --- danc_quit ---
+;
+; On entry:    --
+;
+; On exit:     --
+;
+; Use:         Frees everyone's anchors nicely when the module quits.
+
+               IMPORT  danc_quit
+
+;----- That's all, folks ----------------------------------------------------
+
+               END

diff --git a/StraySrc/Dynamite/dynamite/sh/dynArea b/StraySrc/Dynamite/dynamite/sh/dynArea
new file mode 100644 (file)
index 0000000..3edf5a9
--- /dev/null
+++ b/StraySrc/Dynamite/dynamite/sh/dynArea
@@ -0,0 +1,79 @@
+;
+; dynArea.sh
+;
+; The handling of the dynamic area itself
+;
+; © 1994 Straylight
+;
+
+;----- Overview -------------------------------------------------------------
+;
+; Functions provided:
+;
+;   da_findPage
+;   da_addPages
+;   da_removePages
+;   da_readSize
+;   da_describe
+
+; --- da_findPage ---
+;
+; On entry:    R2 == address of the page
+;
+; On exit:     R0 == page number
+;
+; Use:         Finds the page number of the page with the address given.
+
+               IMPORT  da_findPage
+
+; --- da_addPages ---
+;
+; On entry:    R0 == number of pages to add
+;              R12 == workspace address
+;
+; On exit:     Possible error returned
+;
+; Use:         Increases the size of the dynamic area by the number of
+;              pages given in R0
+
+               IMPORT  da_addPages
+
+; --- da_removePages ---
+;
+; On entry:    R0 == number of pages to remove
+;
+; On exit:     --
+;
+; Use:         Removes the given number of pages from the dynamite
+;              area. If the number of pages to remove is greater than
+;              the actual number of pages allocated, as many as possible
+;              are removed
+
+               IMPORT  da_removePages
+
+; --- da_readSize ---
+;
+; On entry:    --
+;
+; On exit:     R0 == size of area
+;
+; Use:         Returns the&