Update docs for Alpha 1

utility

LICENSE.md

@@ -0,0 +1,157 @@
+### GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+#### 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+#### 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+#### 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+-   a) under this License, provided that you make a good faith effort
+    to ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+-   b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+
+#### 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+-   a) Give prominent notice with each copy of the object code that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the object code with a copy of the GNU GPL and this
+    license document.
+
+#### 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+-   a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the Combined Work with a copy of the GNU GPL and this
+    license document.
+-   c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+-   d) Do one of the following:
+    -   0) Convey the Minimal Corresponding Source under the terms of
+        this License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+    -   1) Use a suitable shared library mechanism for linking with
+        the Library. A suitable mechanism is one that (a) uses at run
+        time a copy of the Library already present on the user's
+        computer system, and (b) will operate properly with a modified
+        version of the Library that is interface-compatible with the
+        Linked Version.
+-   e) Provide Installation Information, but only if you would
+    otherwise be required to provide such information under section 6
+    of the GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the Application
+    with a modified version of the Linked Version. (If you use option
+    4d0, the Installation Information must accompany the Minimal
+    Corresponding Source and Corresponding Application Code. If you
+    use option 4d1, you must provide the Installation Information in
+    the manner specified by section 6 of the GNU GPL for conveying
+    Corresponding Source.)
+
+#### 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+-   a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities, conveyed under the terms of this License.
+-   b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+
+#### 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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 Library
+as you received it specifies that a certain numbered version of the
+GNU Lesser General Public License "or any later version" applies to
+it, you have the option of following the terms and conditions either
+of that published version or of any later version published by the
+Free Software Foundation. If the Library as you received it does not
+specify a version number of the GNU Lesser General Public License, you
+may choose any version of the GNU Lesser General Public License ever
+published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

LICENSE.txt

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  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
-them 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 prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  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.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey 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;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If 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 convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU 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 that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  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.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-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.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            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
-state 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) <year>  <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 3 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, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program 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, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU 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 Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,12 +1,17 @@
-# 3/13/2018 PLASMA 1.1 Available!
-[Download and read the Release Notes](https://github.com/dschmenk/PLASMA/blob/master/doc/Version%201.1.md)
+# 7/4/2020 PLASMA 2.0 Alpha 1 Available!
+[Download and read the Release Notes](https://github.com/dschmenk/PLASMA/releases)
+
+[Change List](https://github.com/dschmenk/PLASMA/blob/master/doc/Version%202.0.md#changes-in-plasma-for-20-alpha-1)
+
+# 4/29/2018 PLASMA 1.2 Available!
+[Download and read the Release Notes](https://github.com/dschmenk/PLASMA/blob/master/doc/Version%201.2.md)
 
 # The PLASMA Programming Language
 
 ![Luc Viatour](https://upload.wikimedia.org/wikipedia/commons/thumb/2/26/Plasma-lamp_2.jpg/1200px-Plasma-lamp_2.jpg)
 image credit: Luc Viatour / www.Lucnix.be
 
-PLASMA: **P**roto **L**anguage **A**s**S**e**M**bler for **A**pple
+PLASMA: **P**roto **L**anguage **A**s**S**e**M**bler for **A**ll
 
 PLASMA is a medium level programming language targeting the 8-bit 6502 processor. Historically, there were simple languages developed in the early years of computers that improved on the tedium of assembly language programming while still being low level enough for system coding. Languages like B, FORTH, and PLASMA fall into this category.
 
@@ -94,7 +99,7 @@ Different projects have led to the architecture of PLASMA, most notably Apple Pa
             - [Call Stack](#call-stack)
             - [Local Frame Stack](#local-frame-stack)
             - [Local String Pool](#local-string-pool)
-        - [The Bytecodes](#the-bytecodes)
+        - [The Bytecodes](https://github.com/dschmenk/PLASMA/wiki/PLASMA-Byte-Codes)
     - [Apple 1 PLASMA](#apple-1-plasma)
     - [Apple II PLASMA](#apple-ii-plasma)
     - [Apple /// PLASMA](#apple--plasma)
@@ -106,7 +111,7 @@ Different projects have led to the architecture of PLASMA, most notably Apple Pa
 
 ## PLASMA Cross-Compiler
 
-The first step in writing PLASMA code is to get a build environment working. If you have Unix-like environment, then this is a fairly easy exercise. Windows users may want to install the [Cygwin](https://www.cygwin.com/) environment to replicate a Unix-like environment under Windows. When installing Cygwin, make sure **gcc-core**, **make**, and **git** are installed under the **Devel** packages. Mac OS X users may have to install the **Xcode** from the App Store.
+The first step in writing PLASMA code is to get a build environment working. If you have Unix-like environment, then this is a fairly easy exercise. Windows users may want to install the [Linux Subsystem for Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10) or the [Cygwin](https://www.cygwin.com/) environment to replicate a Unix-like environment under Windows. When installing Cygwin, make sure **gcc-core**, **make**, and **git** are installed under the **Devel** packages. Mac OS X users may have to install the **Xcode** from the App Store. Linux users should make sure the development packages are installed.
 
 Launch the command-line/terminal application for your environment to download and build PLASMA. Create a source code directory and change the working directory to it, something like:
 
@@ -518,7 +523,7 @@ else
 fin
 ```
 
-The `when`/`is`/`otherwise`/`wend` statement is similar to the `if`/`elsif`/`else`/`fin` construct except that it is more efficient.  It selects one path based on the evaluated expressions, then merges the code path back together at the end.  Only the `when` value is compared against a list of expressions.  The expressions do not need to be constants, they can be any valid expression.  The list of expressions is evaluated in order, so for efficiency sake, place the most common cases earlier in the list. Just as in C programs, a `break` statement is required to keep one clause from falling through to the next. Falling through from one clause to the next can have its uses, so this behavior has been added to PLASMA.
+The `when`/`is`/`otherwise`/`wend` statement is similar to the `if`/`elsif`/`else`/`fin` construct except that it is more efficient.  It selects one path based on the evaluated expressions, then merges the code path back together at the end.  Only the `when` value is compared against a list of constant.  Just as in C programs, a `break` statement is required to keep one clause from falling through to the next. Falling through from one clause to the next can have its uses, so this behavior has been added to PLASMA.
 
 ```
 when keypressed
@@ -1139,7 +1144,7 @@ The common `if` test can have optional `elsif` and/or `else` clauses. Any expres
 
 #### WHEN/IS/[OTHERWISE]/WEND
 
-The complex test case is handled with `when`. Basically an `if`, `elsif`, `else` list of comparisons, it is generally more efficient. The `is` value can be any expression. It is evaluated and tested for equality to the `when` value.
+The complex test case is handled with `when`. Basically an `if`, `elsif`, `else` list of comparisons, it is generally more efficient. The `is` value must be a constant.
 
 ```
 when key
@@ -1162,26 +1167,6 @@ when key
 wend
 ```
 
-With a little "Yoda-Speak", some fairly complex test can be made:
-
-```
-const FALSE = 0
-const TRUE  = NOT FALSE
-
-byte a
-
-when TRUE
-    is (a <= 10)
-        // 10 or less
-        break
-    is (a > 10) AND (a < 20)
-        // between 10 and 20
-        break
-    is (a >= 20)
-        // 20 or greater
-wend
-```
-
 A `when` clause can fall-through to the following clause, just like C `switch` statements by leaving out the `break`.
 
 #### FOR \<TO,DOWNTO\> [STEP]/NEXT
@@ -1313,80 +1298,6 @@ One of the biggest problems to overcome with the 6502 is its very small hardware
 
 Any function that uses in-line strings may have those strings copied to the local string pool for usage. This allows string literals to exist in the same memory as the bytecode and only copied to main memory when used. The string pool is deallocated along with the local frame stack when the function exits.
 
-### The Opcodes
-
-The compact code representation comes through the use of opcodes closely matched to the PLASMA compiler. They are:
-
-| OPCODE |  Name  |                  Description
-|:------:|:------:|-----------------------------------
-| $00    | ZERO   | push zero on the stack
-| $02    | ADD    | add top two values, leave result on top
-| $04    | SUB    | subtract next from top from top, leave result on top
-| $06    | MUL    | multiply two topmost stack values, leave result on top
-| $08    | DIV    | divide next from top by top, leave result on top
-| $0A    | MOD    | divide next from top by top, leave remainder on top
-| $0C    | INCR   | increment top of stack
-| $0E    | DECR   | decrement top of stack
-| $10    | NEG    | negate top of stack
-| $12    | COMP   | compliment top of stack
-| $14    | AND    | bit wise AND top two values, leave result on top
-| $16    | IOR    | bit wise inclusive OR top two values, leave result on top
-| $18    | XOR    | bit wise exclusive OR top two values, leave result on top
-| $1A    | SHL    | shift left next from top by top, leave result on top
-| $1C    | SHR    | shift right next from top by top, leave result on top
-| $02    | IDXB   | add top of stack to next from top, leave result on top (ADD)
-| $1E    | IDXW   | add 2X top of stack to next from top, leave result on top
-| $20    | NOT    | logical NOT of top of stack
-| $22    | LOR    | logical OR top two values, leave result on top
-| $24    | LAND   | logical AND top two values, leave result on top
-| $26    | LA     | load address
-| $28    | LLA    | load local address from frame offset
-| $2A    | CB     | constant byte
-| $2C    | CW     | constant word
-| $2E    | CS     | constant string
-| $30    | DROP   | drop top stack value
-| $32    | DUP    | duplicate top stack value
-| $34    | NOP    |
-| $36    | DIVMOD | divide next from to by top, leave result and remainder on stack
-| $38    | BRGT   | branch next from top greater than top
-| $3A    | BRLT   | branch next from top less than top
-| $3C    | BREQ   | branch next from top equal to top
-| $3E    | BRNE   | branch next from top not equal to top
-| $40    | ISEQ   | if next from top is equal to top, set top true
-| $42    | ISNE   | if next from top is not equal to top, set top true
-| $44    | ISGT   | if next from top is greater than top, set top true
-| $46    | ISLT   | if next from top is less than top, set top true
-| $48    | ISGE   | if next from top is greater than or equal to top, set top true
-| $4A    | ISLE   | if next from top is less than or equal to top, set top true
-| $4C    | BRFLS  | branch if top of stack is zero
-| $4E    | BRTRU  | branch if top of stack is non-zero
-| $50    | BRNCH  | branch to address
-| $52    | IBRNCH | branch to address on stack top
-| $54    | CALL   | sub routine call with stack parameters
-| $56    | ICAL   | sub routine call to address on stack top with stack parameters
-| $58    | ENTER  | allocate frame size and copy stack parameters to local frame
-| $5A    | LEAVE  | deallocate frame and return from sub routine call
-| $5C    | RET    | return from sub routine call
-| $5E    | CFFB   | constant with $FF MSB
-| $60    | LB     | load byte from top of stack address
-| $62    | LW     | load word from top of stack address
-| $64    | LLB    | load byte from frame offset
-| $66    | LLW    | load word from frame offset
-| $68    | LAB    | load byte from absolute address
-| $6A    | LAW    | load word from absolute address
-| $6C    | DLB    | duplicate top of stack into local byte at frame offset
-| $6E    | DLW    | duplicate top of stack into local word at frame offset
-| $70    | SB     | store next from top of stack byte into top address
-| $72    | SW     | store next from top of stack word into top address
-| $74    | SLB    | store top of stack into local byte at frame offset
-| $76    | SLW    | store top of stack into local word at frame offset
-| $78    | SAB    | store top of stack into byte at absolute address
-| $7A    | SAW    | store top of stack into word at absolute address
-| $7C    | DAB    | duplicate top of stack into byte at absolute address
-| $7E    | DAW    | duplicate top of stack into word at absolute address
-
-The opcodes were developed over time by starting with a very basic set of operations and slowly adding opcodes when the PLASMA compiler could improve code density or performance.
-
 ## Apple 1 PLASMA
 
 Obviously the Apple 1 is a little more constrained than most machines PLASMA is targeting. But, with the required addition of the CFFA1 (http://dreher.net/?s=projects/CFforApple1&c=projects/CFforApple1/main.php), the Apple 1 gets 32K of RAM and a mass storage device. Enough to run PLASMA and load/execute modules.

doc/Editor.md

@@ -2,8 +2,8 @@ WELCOME TO THE PLASMA EDITOR!
 =============================
 
 FIRST THINGS FIRST:
-TO NAVIGATE, USE THE ARROW KEYS.  ON THE
-APPLE ][:
+TO NAVIGATE, USE THE ARROW KEYS. ON
+THE APPLE ][:
 
     CTRL-K = UP
     CTRL-J = DOWN.
@@ -18,22 +18,23 @@ TO JUMP AROUND THE TEXT FILE USE:
     CTRL-Q = JUMP BEGINNING
     CTRL-E = JUMP END
 
-THE 'ESCAPE' KEY WILL PUT YOU IN COMMAND
-MODE.  FROM THERE YOU CAN EXIT BY
-ENTERING 'Q' AND 'RETURN'. YOU CAN ALSO
-RETURN TO THE EDITOR BY JUST PRESSING
-'RETURN'.
+THE 'ESCAPE' KEY WILL PUT YOU IN
+COMMAND MODE.  FROM THERE YOU CAN
+EXIT BY ENTERING 'Q' AND 'RETURN'.
+YOU CAN ALSO RETURN TO THE EDITOR BY
+JUST PRESSING 'RETURN'.
 
 -------
 
 THE PLASMA EDITOR IS A SIMPLE TEXT
 EDITOR FOR ENTERING AND MANIPULATING
-TEXT AND SOURCE CODE FILES.  THE EDITOR
-ONLY SUPPORTS 40 COLUMN TEXT ALTHOUGH
-LINES CAN BE UP TO 79 CHARACTERS LONG.
-THE  SCREEN WILL SCROLL HORIZONTALLY
-AS THE CURSOR MOVES. THERE IS 16K OF
-MEMORY FOR THE TEXT BUFFER.
+TEXT AND SOURCE CODE FILES. THE
+EDITOR ONLY SUPPORTS 40 COLUMN TEXT
+ALTHOUGH LINES CAN BE UP TO 79
+CHARACTERS LONG. THE SCREEN WILL
+SCROLL HORIZONTALLY AS THE CURSOR
+MOVES. THERE IS 16K OF MEMORY FOR
+THE TEXT BUFFER.
 
 IT HAS TWO MODES, COMMAND AND EDIT.
 
@@ -52,13 +53,17 @@ EDIT COMMANDS:
     CTRL-Q       = JUMP BEGIN
     CTRL-E       = JUMP END
     CTRL-D       = DELETE CHAR
-    CTRL-X       = DELETE/CUT LINE
-    CTRL-V       = COPY DELETED LINE
+    CTRL-B       = BEGIN SELECTION
+    CTRL-C       = COPY SELECTION INTO CLIPBOARD
+    CTRL-X       = CUT SELECTION INTO CLIPBOARD
+    CTRL-V       = PASTE CLIPBOARD
     CTRL-O       = OPEN NEW LINE
     CTRL-F       = OPEN A FOLLOWING NEW LINE
     CTRL-T       = JOIN LINES
-    CTRL-B       = TOGGLE INSERT/OVERWRITE
+    CTRL-Y       = TOGGLE INSERT/OVERWRITE
     TAB/CTRL-I   = INSERT SPACES TO NEXT TAB
+                 = INDENT SELECTION IF INSERT MODE
+                 = UNDENT SELECTION IF OVERWITE MODE
     ESCAPE       = SWITCH TO COMMAND MODE
     DELETE       = DELETE CHAR LEFT
 
@@ -78,7 +83,7 @@ EDIT COMMANDS:
   APPLE ][, UPPER AND LOWER CASE
   ENTRY WORKS AS EXPECTED.
 
-    CTRL-C       = FORCE LOWER-CASE CHARS
+    ESC T C      = FORCE LOWER-CASE CHARS
 
   If you have a lower-case character
   generator installed, you can force
@@ -93,11 +98,12 @@ EDIT COMMANDS:
   The 'SOLID-APPLE' key will modify
   theese keys:
 
-    SA-RETURN      = OPEN LINE
+    SA-RETURN      = OPEN FOLLOWING LINE
     SA-LEFT ARROW  = JUMP LEFT
     SA-RIGHT ARROW = JUMP RIGHT
     SA-UP ARROR    = JUMP UP
     SA-DOWN ARROW  = JUMP DOWN
+    SA-TAB         = DETAB
 
   Apple /// FEATURES:
   -------------------
@@ -106,11 +112,12 @@ EDIT COMMANDS:
   these keys:
 
     OA-\           = DELETE CHAR LEFT
-    OA-RETURN      = OPEN LINE
+    OA-RETURN      = OPEN FOLLOWING LINE
     OA-LEFT ARROW  = JUMP LEFT
     OA-RIGHT ARROW = JUMP RIGHT
     OA-UP ARROR    = JUMP UP
     OA-DOWN ARROW  = JUMP DOWN
+    OA-TAB         = DETAB
 
   On the keypad, 'OPEN-APPLE' allows
   the keys for navigation and misc:
@@ -124,9 +131,9 @@ EDIT COMMANDS:
     OA-7           = JUMP BEGIN
     OA-1           = JUMP END
     OA-5           = DELETE CHAR
-    OA--           = DELETE/CUT LINE
-    OA-0           = COPY DELETED LINE
-    OA-ENTER       = OPEN NEW LINE
+    OA--           = CUT SELECTION INTO CLIPBOARD 
+    OA-0           = PASTE CLIPBOARD
+    OA-ENTER       = OPEN FOLLOWING LINE
     OA-.           = TOGGLE INSERT/OVERWRITE
 
 COMMAND MODE:
@@ -142,5 +149,9 @@ COMMAND MODE:
     P <PREFIX>   = SET PREFIX
     H [SLOT]     = HARDCOPY TO DEVICE IN SLOT (DEFAULT 1)
     N            = CLEAR TEXT IN MEMORY
+    T G          = TOGGLE GUTTER VIEW
+    T C          = TOGGLE LOWER-CASE SUPPORT (APPLE ][)
+    G <LINE>     = GO TO LINE #
+    F [STRING]   = FIND STRING
     E            = EDIT MODE
     'RETURN'     = EDIT MODE

doc/Version 1.2.md

@@ -1,16 +1,16 @@
-# PLASMA Version 1.1
+# PLASMA Version 1.2
 
 Welcome to PLASMA: the Grand Unifying Platform for the Apple 1, ][, and ///.
 
 Download the four disk images (three if you don't plan to boot an Apple ///):
 
-[PLASMA 1.1 System and ProDOS Boot](https://github.com/dschmenk/PLASMA/blob/master/PLASMA-SYS1.PO?raw=true)
+[PLASMA 1.2 System and ProDOS Boot](https://github.com/dschmenk/PLASMA/blob/ver-1/PLASMA-SYS1.PO?raw=true)
 
-[PLASMA 1.1 Build Tools](https://github.com/dschmenk/PLASMA/blob/master/PLASMA-BLD1.PO?raw=true)
+[PLASMA 1.2 Build Tools](https://github.com/dschmenk/PLASMA/blob/ver-1/PLASMA-BLD1.PO?raw=true)
 
-[PLASMA 1.1 Demos](https://github.com/dschmenk/PLASMA/blob/master/PLASMA-DEM1.PO?raw=true)
+[PLASMA 1.2 Demos](https://github.com/dschmenk/PLASMA/blob/ver-1/PLASMA-DEM1.PO?raw=true)
 
-[PLASMA 1.1 Apple /// SOS Boot ](https://github.com/dschmenk/PLASMA/blob/master/PLASMA-SOS1.PO?raw=true)
+[PLASMA 1.2 Apple /// SOS Boot ](https://github.com/dschmenk/PLASMA/blob/ver-1/PLASMA-SOS1.PO?raw=true)
 
 PLASMA can be run from floppies, System in Drive 1, and Build or Demos in Drive 2. Mass storage is the recommended installation that looks like (replacing HARDISK with your volume name of choice):
 
@@ -98,6 +98,16 @@ There is a [YouTube playlist](https://www.youtube.com/playlist?list=PLlPKgUMQbJ7
 
 - The documentation is sparse and incomplete. Yep, could use your help...
 
+# Changes in PLASMA for 1.2
+
+1. Add TFTPD TFTP server
+
+2. Fix Uthernet 1 driver
+
+3. Add mouse module
+
+4. Fix IRQ issues for interrupt driven mouse driver
+
 # Changes in PLASMA for 1.1
 
 1. All known bugs are fixed

doc/Version 2.0.md

@@ -0,0 +1,276 @@
+# PLASMA Version 2.0 Alpha 1
+
+Welcome to PLASMA: the Grand Unifying Platform for the Apple 1, ][, and ///.
+
+Download the five disk images:
+
+[PLASMA 2.0 Alpha1 800K Full System](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2.2mg?raw=true)
+
+[PLASMA 2.0 Alpha1 System and ProDOS Boot](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2-SYS.PO?raw=true)
+
+[PLASMA 2.0 Alpha1 Build Tools](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2-BLD.PO?raw=true)
+
+[PLASMA 2.0 Alpha1 Demos](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2-DEM.PO?raw=true)
+
+[PLASMA 2.0 Alpha1 TCP/IP network modules](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2-INET.PO?raw=true)
+
+[PLASMA 2.0 Alpha1 Apple /// SOS Mame Boot and SANE floating point modules](https://github.com/dschmenk/PLASMA/blob/master/images/apple/PLASMA2-FPSOS.PO?raw=true)
+
+[PLASMA 2.0 Alpha1 Apple /// Mame hard disk image](https://github.com/dschmenk/PLASMA/blob/master/images/apple/apple3.hd?raw=true)
+
+PLASMA can be run from floppies, System in Drive 1, and Build or Demos in Drive 2. Mass storage is the recommended installation that looks like (replacing HARDISK with your volume name of choice):
+
+System Files => /HARDISK/PLASMA/
+
+Build Files => /HARDISK/PLASMA/BLD/
+
+Demo Files => /HARDISK/PLASMA/DEMOS/
+
+SANE files => /HARDISK/PLASMA/SYS
+
+INET files => /HARDDISK/PLASMA/SYS
+
+Use the System Utilities to copy the floppy images into the above mentioned directories.
+
+## Apple 1
+
+The Apple 1 is a very constrained system compared to the ][ and ///. It is required to have the CFFA1 disk adapter installed to provide file storage and a full 32K od RAM. To get the files onto the CF card required the use of [CiderPress](http://a2ciderpress.com) and they must be placed in one directory. Most PLASMA programs won't work on the Apple 1 due to limited filesystem support, video/graphics capabilities, and lack of audio output. It does, however, make a good place to start when porting PLASMA to a new platform.
+
+## Apple ][
+
+To boot directly into PLASMA, you will need to put the system files in the root prefix of the boot device and make sure PLASMA.SYSTEM is the first SYSTEM file in the directory. Otherwise, start PLASMA.SYSTEM from your program launcher of choice. All Apple ][ models with 64K and two floppy drives are supported up to a maxed out IIGS with accelerator and hard drive.
+
+#### 65802/65816 Support
+
+PLASMA can utilize the 16 bit features of the 65802 and 65816 processors to improve performance of the PLASMA VM operation. This is transparent to the programmer/user and doesn't make any additional memory or capabilities available to PLASMA. PLASMA will automatically run the most optimal VM for your configuration.
+
+## Apple ///
+
+The Apple /// gets the environment it always wanted: The ability to navigate the filesystem with a command line interface. The Apple /// always boots from the floppy drive, even if a hard disk is installed. The PLASMA.SOS floppy should be updated with the SOS.DRIVER configured for your machine. It contains the SOS.DRIVER configured for the Apple 3 Ready-To-Run Mame environment. Once booted, type `S /HARDISK/PLASMA` (or your install directory of choice) to change to, and set, the system directory. This can be automated by creating an `AUTORUN` file on the boot floppy with the above command in it.
+
+## PLASMA Command Line Shell
+
+PLASMA incorporates a very basic command line shell to facilitate navigating the filesystem and executing both SYSTEM/SOS programs and PLASMA modules. It has a few built-in commands:
+
+|       Command       |      Operation        |
+|:----------------------------:|-------------------------|
+| C [PREFIX]                   | Catalog prefix
+| P \<PREFIX\>                 | change to Prefix
+| /                            | change to parent prefix
+| V                            | show online Volumes
+| S \<PREFIX\>                 | set System prefix*
+| +SOS \<SOS.INTERP\> [PREFIX] | launch SOS interpreter*
+| -\<SYSTEM PROGRAM\> [PARAMS] | launch SYSTEM program**
+| +\<PLASMA MODULE\> [PARAMS]  | exec PLASMA module
+```
+[Optional parameters]
+<Required parameters>
+* Apple /// only
+** Apple ][ only
+```
+
+The shell is very brief with error messages. It is meant solely as a way to run programs that accept command line parameters and take up as little memory as possible. It does, however, provide a rich runtime for PLASMA modules.
+
+## Included Modules
+
+PLASMA comes with many library modules used by the tools, demos and sample code. The PLASMA system volume must remain in place for the duration of PLASMAs run otherwise it won't be able to find CMD or the system libraries. Probably the most useful included module is the editor. It is used for editing PLASMA source file, assembly source files, or any text file. Execute it with:
+```
++ED [TEXT FILE]
+```
+The file manipulation utilities to copy, delete, rename, create directories, and change file type and aux type remove the need for external programs to do the same. PLASMA can now be installed with the tools included on the PLASMA2-SYS boot floppy. They are:
+```
++COPY [-R] <SRCPATH>+ <DSTPATH>
++DEL [-R] <FILEPATH>
++REN <FILENAME> <NEWNAME>
++NEWDIR <NEWDIRECTORY>
++TYPE <FILENAME> [NEWTYPE [NEWAUX]]
++CAT [-R] <FILEPATH]
+```
+The ```-R``` option will operate on the directories recursively. Wildcard filenames can be specified with ```'*'``` matching zero or more characters, and ```'?'``` matching any character.
+
+## Compiler Modules
+
+The build disk includes sample source, include files for the system modules, and the PLASMA compiler+optimizer modules. The compiler is invoked with:
+```
++PLASM [-[W][O[2]] <SOURCE FILE> [OUTPUT FILE]
+```
+Compiler warnings are enabled with `-W`. The optional optimizer is enabled with `-O` and extra optimizations are enabled with `-O2`. The source code for a few sample programs are included. The big one, `RPNCALC.PLA`, is the sample RPN calculator that uses many of PLASMA's advanced features. The self-hosted compiler is the same compiler as the cross-compiler, just transcribed from C to PLASMA (yes, the self-hosted PLASMA compiler is written in PLASMA). It requires patience when compiling: it is a fairly large and extensive program.
+
+## Demos
+
+There are some demo programs included for your perusal. Check out `ROGUE` for some diversion. You can find the documentation here: https://github.com/dschmenk/PLASMA/blob/master/doc/Rogue%20Instructions.md. A music sequencer to play through a MockingBoard if it is detected, or the built-in speaker if not. A minimal Web server if you have an Uthernet2 card (required). Try `SPIDERS`for some hires shoot'em-up action. Bug reports appreciated.
+
+## Source Code
+
+Most sample source code is included from the project. They build without alteration and should be a good starting point for further explorations. The header files for the included library modules are in the INC directory.
+
+## Video Playlist
+
+There is a [YouTube playlist](https://www.youtube.com/playlist?list=PLlPKgUMQbJ79VJvZRfv1CJQf4SP2Gw3yU) created for learning PLASMA. It is a WIP, with updates every week or so
+
+## Issues
+
+- All the modules and runtime are written mostly in PLASMA; the compiler and editor as well. This means that there may be some startup delay as the PLASMA module loader reads in the module dependencies and performs dynamic linking. But a 1 MHz, 8 bit CPU interpreting bytecodes is never going to match a modern computer. As noted earlier, an accelerator and mass storage are your (and PLASMA's) friend.
+
+- All the project modules are included. They have been lightly tested.
+
+- The Apple /// may not always report errors properly or at all.
+
+- The documentation is sparse and incomplete. Yep, could use your help...
+
+# Changes in PLASMA for 2.0 Alpha 1
+
+1. Improved entry/exit for 128K Apple IIe //c
+
+2. Improved entry for Apple ///
+
+3. Improved entry and function calls for 16 bit VM
+
+# Changes in PLASMA for 2.0 DP 4
+
+1. Improved editor auto-indenting
+
+2. Compiler fix for terneray operator precedence
+
+3. Machine check for HGR library
+
+# Changes in PLASMA for 2.0 DP 3
+
+1. File manipulation utilities fixed for Apple /// SOS vs ProDOS differences
+
+2. More optimizations for HiRes graphics libraries
+
+3. Spiders From Mars hires demo game
+
+# Changes in PLASMA for 2.0 DP 2
+
+1. Many file manipulaition utilities (COPY, REName, NEWDIRectory, DELete, CATalog, TYPE)
+
+2. New and updated libraries for lo-res. double lo-res and hi-res graphics w/ sprites
+
+3. 32 bit integer library for those times when 16 bits just isn't enough
+
+4. Apple /// improvements to other SOS.INTERP launching with SOS utility
+
+5. Apple /// JIT VM for speed and non JIT version to free up global memory
+
+6. Editor improvements
+
+7. A couple small compiler optimizations
+
+8. Needed to break out TCP/IP modules into seperate floppy image
+
+9. Library changes require full install
+
+# Changes in PLASMA for 2.0 DP 1z
+
+1. Many fixes for the value zero - especially in 65802/65816 divide routine
+
+# Changes in PLASMA for 2.0 DP 1 E+C
+
+1. Greatly improved code editor and additional compiler stats
+
+# Changes in PLASMA for 2.0 DP 1a
+
+1. Fix interaction with JIT compiler and module load/unload
+
+# Changes in PLASMA for 2.0 DP 1
+
+1. Expanded bytecode for more efficient size/performance of programs
+
+2. Just-In-Time Compiler for native code performance (6502 and 65816) for frequently called routines
+
+3. Automatically identify and run most optimal VM for configuration
+
+# Changes in PLASMA for 1.2
+
+1. Add TFTPD TFTP server
+
+2. Fix Uthernet 1 driver
+
+3. Add mouse module
+
+4. Fix IRQ issues for interrupt driven mouse driver
+
+# Changes in PLASMA for 1.1
+
+1. All known bugs are fixed
+
+2. PLASM compiler received a little performance boost with an assembly language helper for ID/keyword lexical scanner
+
+# Changes in PLASMA for 1.0
+
+If you have been programming in PLASMA before, the 1.0 version has some major and minor changes that you should be aware of:
+
+1. Case is no longer significant. Imported symbols were always upper case. Now, all symbols are treated as if they were upper case. You may find that some symbols clash with previously defined symbols of different case. Hey, we didn't need lower case in 1977 and we don't need it now. You kids, get off my lawn!
+
+2. Modules are now first class citizens. Translation: importing a module adds a symbol with the module name. You can simply refer to a module's address with it's name. This is how a module's API table is accessed (instead of adding a variable of the same name in the IMPORT section).
+
+3. Bytecode changes means previously compiled modules will crash. Rebuild.
+
+4. `BYTE` and `WORD` have aliases that may improve readability of the code. `CHAR` (character) and `RES` (reserve) are synonyms for `BYTE`. `VAR` (variable) is a synonym for `WORD`. These aliases add no functionality. They are simply syntactic sugar to add context to the source code, but may cause problems if you've previously used the same names for identifiers.
+
+5. When declaring variables, a base size can come after the type, and an array size can folllow the identifier. For instance:
+```
+res[10] a, b, c
+```
+will reserve three variables of 10 bytes each. Additionally:
+```
+res[10] v[5], w[3]
+```
+will reserve a total of 80 bytes (10 * 5 + 10 * 3). This would be useful when combined with a structure definition. One could:
+```
+res[t_record] patients[20]
+```
+to reserve an array of 20 patient records.
+
+6. Ternary operator. Just like C and descendants, `??` and `::` allow for an if-then-else inside an expression:
+```
+puts(truth == TRUE ?? "TRUE" :: "FALSE")
+```
+
+7. Multiple value assignements. Multiple values can be returned from functions and listed on variable assignments:
+```
+def func#3 // Return 3 values
+  return 10, 20, 30
+end
+
+a, b, c = 1, 2, 3
+c, d, f = func()
+x, y = y, x // Swap x and y
+```
+
+8. `DROP` allows for explicit dropping of values. In the above `func()` example, if the middle value was the only one desired, the others can be ignored with:
+```
+drop, h, drop = func()
+```
+
+9. The compiler tracks parameter and return counts for functions. If the above `func()` were used without assigning all the return values, they would be dropped:
+```
+a = func() // Two values silently dropped
+```
+To generate compiler warning for this issue, and a few others, use the `-W` option when compiling.
+
+10. Lambda (Anonymous) Functions. The ability to code a quick function in-line can be very powerful when used properly. Look here, https://en.wikipedia.org/wiki/Anonymous_function, for more information.
+
+11. SANE (Standard Apple Numerics Environment) Floating Point Library. An extensive library (two, actually) of extended floating point (80 bit IEEE precision) functionality is suported. A wrapper library has been written to greatly simplify the interface to SANE. Look at the `RPNCALC.PLA` source code as an example.
+
+12. Library Documentation. Preliminary documentation is available on the Wiki: https://github.com/dschmenk/PLASMA/wiki
+
+13. Significant effort has gone into VM tuning and speeding up module loading/dynamic linking.
+
+14. The VM zero page usage has changed. If you write assembly language routines, you will need to rebuild.
+
+# Thanks
+
+I wish to thank the people who have contributed the the PLASMA project. They have greatly improved the development of the language and documentation:
+
+- Martin Haye: PLASMA programmer extraordinaire. Mr. Lawless Legends has requested many of the crucial features that set PLASMA apart.
+- Steve F (ZornsLemma): Has taken the optimizer to new levels and his work on porting PLASMA to the Beeb are amazing: http://stardot.org.uk/forums/viewtopic.php?f=55&t=12306&sid=5a503c593f0698ebc31e590ac61b09fc
+- Peter Ferrie: Assembly optimizer extraordinaire. He has made significant improvements into the code footprint in PLASMA so all the functionality can exist in just a few bytes.
+- David Schmidt (DaveX): His help in documentation have made it much more accessible and professional. Of course any errors are all his. Just kidding, they're mine ;-)
+- Andy Werner (6502.org): Catching the grammatical errors that I ain't no good at.
+- John Brooks: Apple II Guru par excellence. His insights got 10% performance increase out of the VM.
+
+Dave Schmenk
+http://schmenk.is-a-geek.com

src/inc/cmdsys.plh

@@ -2,7 +2,7 @@ import cmdsys
     //
     // Useful values for everyone
     //
-    const _SYSVER_ = $0100 // Version built against
+    const _SYSVER_ = $0200 // Version built against
     const FALSE    = 0
     const TRUE     = not FALSE
     const NULL     = 0
@@ -33,6 +33,7 @@ import cmdsys
     const reshgr2     = $0020
     const resxhgr1    = $0040
     const resxhgr2    = $0080
+    const nojitc      = $0100
     //
     // Module don't free memory
     //
@@ -46,8 +47,15 @@ import cmdsys
         word syspath
         word cmdline
         word modexec
-        byte refcons
-        byte devcons
+        word sysopen
+        word sysclose
+        word sysread
+        word syswrite
+        byte syserr
+        byte jitcount
+        byte jitsize
+        byte refcons    // Apple /// specific
+        byte devcons    // Apple /// specific
     end
     //
     // CMD exported functions

src/inc/dgr.plh

@@ -1,16 +0,0 @@
-import dgr
-    word[] dgrbuff
-    predef dgrPlot(buff, x, y)#0
-    predef dgrHLin(buff, x1, x2, y)#0
-    predef dgrVLin(buff, x, y1, y2)#0
-    predef dgrBLT(buff, x, y, width, height, src)#0
-    predef dgrTile(buff, x, y, src)#0
-    predef dgrTileStr(buff, x, y, tilestr, strlen, tilebuff)#0
-    predef dgrFill(buff, x, y, tile)#0
-    predef dgrMode#1
-    predef txtMode#0
-    predef dgrShow(page)#1
-    predef dgrColor(clr)#0
-    predef dgrLine(buff, x1, y1, x2, y2)#0
-    predef dgrClear(buff, clr)#0
-end

src/inc/dgrlib.plh

@@ -0,0 +1,15 @@
+import dgrlib
+    predef dgrPlot(x, y)#0
+    predef dgrHLin(x1, x2, y)#0
+    predef dgrVLin(y1, y2, x)#0
+    predef dgrBLT(x, y, width, height, src)#0
+    predef dgrTile(x, y, src)#0
+    predef dgrTileStr(x, y, tilestr, strlen, tilebuff)#0
+    predef dgrFill(x, y, tile)#0
+    predef dgrClear(clr)#0
+    predef dgrMode(mode)#1
+    predef dgrShow(page)#1
+    predef dgrSwap#0
+    predef dgrDrawBuf(page)#0
+    predef dgrColor(clr)#0
+end

src/inc/fileio.plh

@@ -18,7 +18,27 @@ import fileio
     const FILE_ERR_INT_TBL_FULL  = $25
     const FILE_ERR_IO            = $27
     //
+    // File entry struc
+    //
+    struc t_fileentry
+        byte store_namelen
+        byte entry_name[15]
+        byte entry_type
+        word entry_keyptr
+        word entry_blocks
+        word entry_EOFL
+        byte entry_EOFH
+        word entry_create[2]
+        byte entry_version
+        byte entry_minver
+        byte entry_access
+        word entry_aux
+        word entry_mod[2]
+        word entry_headptr
+    end
+    //
     // File info struc
+    //
     struc t_fileinfo
         byte file_access
         byte file_type
@@ -37,7 +57,9 @@ import fileio
         word getpfx
         word setpfx
         word getfileinfo
+        word setfileinfo
         word geteof
+        word seteof
         word iobufalloc
         word open
         word close
@@ -45,7 +67,9 @@ import fileio
         word write
         word create
         word destroy
+        word rename
         word newline
+        word online
         word readblock
         word writeblock
     end

src/inc/grlib.plh

@@ -0,0 +1,15 @@
+import grlib
+    predef grPlot(x, y)#0
+    predef grHLin(x1, x2, y)#0
+    predef grVLin(y1, y2, x)#0
+    predef grBLT(x, y, width, height, src)#0
+    predef grTile(x, y, src)#0
+    predef grTileStr(x, y, tilestr, strlen, tilebuff)#0
+    predef grFill(x, y, tile)#0
+    predef grClear(clr)#0
+    predef grMode(mode)#1
+    predef grShow(page)#1
+    predef grSwap#0
+    predef grDrawBuf(page)#0
+    predef grColor(clr)#0
+end

src/inc/hgrfont.plh

@@ -0,0 +1,3 @@
+import hgrfont
+    predef hgrPutStr(x, y, strptr)#0
+end

src/inc/hgrlib.plh

@@ -0,0 +1,24 @@
+import hgrlib
+    predef divmod7(x)#2
+    predef hgrPlot(x, y)#0
+    predef hgrOrPlot(x, y)#0
+    predef hgrXorPlot(x, y)#0
+    predef hgrHLin(x1, x2, y)#0
+    predef hgrVLin(y1, y2, x)#0
+    predef hgrXorHLin(x1, x2, y)#0
+    predef hgrXorVLin(y1, y2, x)#0
+    predef hgrRect(x1, y1, x2, y2)#0
+    predef hgrXorRect(x1, y1, x2, y2)#0
+    predef hgrBLT(x, y, width, height, srcptr)#0
+    predef hgrCopySrc(ofst, y, w, h, srcptr)#0
+    predef hgrAndSrc(ofst, y, w, h, srcptr)#0
+    predef hgrXorSrc(ofst, y, w, h, srcptr)#0
+    predef hgrOrSrc(ofst, y, w, h, srcptr)#0
+    predef hgrCopyDst(ofst, y, w, h, dstptr)#0
+    predef hgrMode(mode)#1
+    predef hgrClear#0
+    predef hgrShow(page)#1
+    predef hgrSwap#1
+    predef hgrDrawBuf(page)#1
+    predef hgrColor(clr)#0
+end

src/inc/hgrsprite.plh

@@ -0,0 +1,19 @@
+import hgrsprite
+    predef spriteCompile(w, h, xcenter, ycenter, srcptr)#1
+    predef spriteDup(sprtsrc)#1
+    predef spriteRead(filestr)#1
+    predef spriteSave(filestr, sprtptr)#1
+    predef spriteDraw(sprtptr)#0
+    predef spriteDrawXor(sprtptr)#0
+    predef spriteUnDraw(sprtptr)#0
+    predef spriteUnDrawXor(sprtptr)#0
+    predef spritePos(x, y, sprtptr)#0
+    predef spritePosIndex(x, y, i)#0
+    predef spriteUnDrawList#0
+    predef spriteUnDrawXorList#0
+    predef spriteDrawList#0
+    predef spriteDrawXorList#0
+    predef spriteAdd(i, sprtptr)#1
+    predef spriteDel(i)#1
+    predef spriteDrawBuf(page)#1
+end

src/inc/hgrtile.plh

@@ -0,0 +1,13 @@
+import hgrtile
+    predef tileDraw(x, y, tileptr)#0
+    predef tileXorDraw(x, y, tileptr)#0
+    predef tileOrDraw(x, y, tileptr)#0
+    predef tileAndDraw(x, y, tileptr)#0
+    predef tileDrawStr(x, y, strptr, strlen, tileset)#0
+    predef tileFromText(txtpage, tileset)#0
+    predef tileMode(mode)#1
+    predef tileClear#0
+    predef tileShow(page)#1
+    predef tileSwap#1
+    predef tileDrawBuf(page)#1
+end

src/inc/int32.plh

@@ -0,0 +1,32 @@
+import int32
+    const t_i32 = 4
+    
+    predef zero32#0
+    predef zext16to32#0
+    predef neg32#0
+    predef load32(i32ptr)#0
+    predef loadi16(imm16)#0
+    predef store32(i32ptr)#0
+    predef add32(i32ptr)#0
+    predef addi16(imm16)#0
+    predef sub32(i32ptr)#0
+    predef subi16(imm16)#0
+    predef shl32(imm8)#0
+    predef shr32(imm8)#0
+    predef mul32(i32ptr)#0
+    predef muli16(imm16)#0
+    predef div32(i32ptr)#2
+    predef divi16(imm16)#2
+    predef iseq32(i32ptr)#1
+    predef iseqi16(imm16)#1
+    predef isge32(i32ptr)#1
+    predef isgei16(imm16)#1
+    predef isle32(i32ptr)#1
+    predef islei16(imm16)#1
+    predef isgt32(i32ptr)#1
+    predef isgti16(imm16)#1
+    predef islt32(i32ptr)#1
+    predef islti16(imm16)#1
+    predef i32tos(i32ptr, strptr)#1
+    predef puti32(i32ptr)#0
+end

src/inc/lines.plh

@@ -0,0 +1,6 @@
+import lines
+    predef setlinespans(h, v)#0 
+    predef linespans(x1, y1, x2, y2)#0
+    predef setlineplot(p)#0
+    predef line(x1, y1, x2, y2)#0
+end

src/inc/lz4.plh

@@ -0,0 +1,3 @@
+import lz4
+    predef lz4Unpack(seq, seqend, buff, buffend)
+end

src/inc/matchfiles.plh

@@ -0,0 +1,5 @@
+import matchfiles
+    predef matchName(src, exp)#1
+    predef matchList(pathptr, exp)#2
+    predef isWildName(exp)#1
+end

src/inc/mouse.plh

@@ -0,0 +1,32 @@
+import mouse
+    //
+    // Status bits
+    //
+    const BUTTON_DOWN      = $80
+    const BUTTON_LAST_DOWN = $40
+    const MOUSE_MOVED      = $20
+    const VBL_INT          = $08
+    const BUTTON_INT       = $04
+    const MOVE_INT         = $02
+    //
+    // Mode bits
+    //
+    const VBL_INT_ENABLE   = $08
+    const BUTTON_INT_ENABLE= $04
+    const MOVE_INT_ENABLE  = $02
+    const MOUSE_ENABLE     = $01
+    //
+    // Mouse API
+    //
+    struc t_mouse
+        word chkVBL
+        word chkMouse
+        word readMouse  // readMouse()#3
+        word setMouse   // setMouse(mode)
+        word clearMouse
+        word posMouse   // posMouse(x, y)
+        word clampMouse // clampMouse(xMin, xMax, yMin, yMax)
+        word homeMouse
+        word detachMouse
+    end
+end

src/libsrc/apple/conio.pla

@@ -1,4 +1,5 @@
 include "inc/cmdsys.plh"
+sysflags nojitc // Keep tone() from compiling and sounding different
 //
 // Handy constants.
 //

src/libsrc/apple/dgrlib.pla

@@ -1,5 +1,4 @@
 include "inc/cmdsys.plh"
-sysflags restxt1|restxt2|resxtxt1|resxtxt2    // Reserve all text pages
 //
 // Apple II hardware constants.
 //
@@ -24,13 +23,15 @@ const page2        = 1
 //
 // Screen row address arrays.
 //
-word[] dgr1rows     = $0400,$0480,$0500,$0580,$0600,$0680,$0700,$0780
-word                = $0428,$04A8,$0528,$05A8,$0628,$06A8,$0728,$07A8
-word                = $0450,$04D0,$0550,$05D0,$0650,$06D0,$0750,$07D0
-word[] dgr2rows     = $0800,$0880,$0900,$0980,$0A00,$0A80,$0B00,$0B80
-word                = $0828,$08A8,$0928,$09A8,$0A28,$0AA8,$0B28,$0BA8
-word                = $0850,$08D0,$0950,$09D0,$0A50,$0AD0,$0B50,$0BD0
-export word[] dgrbuff      = @dgr1rows, @dgr2rows
+word[] dgr1row = $0400,$0480,$0500,$0580,$0600,$0680,$0700,$0780
+word           = $0428,$04A8,$0528,$05A8,$0628,$06A8,$0728,$07A8
+word           = $0450,$04D0,$0550,$05D0,$0650,$06D0,$0750,$07D0
+word[] dgr2row = $0800,$0880,$0900,$0980,$0A00,$0A80,$0B00,$0B80
+word           = $0828,$08A8,$0928,$09A8,$0A28,$0AA8,$0B28,$0BA8
+word           = $0850,$08D0,$0950,$09D0,$0A50,$0AD0,$0B50,$0BD0
+word[] dgrbuff = @dgr1row, @dgr2row
+word drawbuff
+byte drawpage
 //
 // Color mapping.
 //
@@ -49,13 +50,13 @@ end
 //
 // Plot pixel
 //
-export asm dgrPlot(buff, x, y)#0
-        ; GET BUFFER ADDRESS
-        STX     ESP
-        LDA     ESTKL+2,X
+export asm dgrPlot(x, y)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
         STA     SRCL
-        LDA     ESTKH+2,X
-        STA     SRCH
+        LDA     $3001
+		STA		SRCH
+        STX     ESP
         LDA     ESTKL,X     ; Y COORD
         AND     #$FE
         TAY
@@ -76,22 +77,21 @@ asm _dgrPlotPix
         LDX     ESP
         INX
         INX
-        INX
         RTS
 end
 //
 // Plot horizontal row of pixels
 //
-export asm dgrHLin(buff, x1, x2, y)#0
-        ; GET BUFFER ADDRESS
-        STX     ESP
-        LDA     ESTKL+3,X
+export asm dgrHLin(x1, x2, y)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
         STA     SRCL
-        LDA     ESTKH+3,X
-        STA     SRCH
+        LDA     $3001
+		STA		SRCH
+        STX     ESP
         LDA     ESTKL+1,X    ; X2 COORD
         STA     TMPH
-        LDA     ESTKL,X      ; Y COORD
+        LDA     ESTKL+0,X    ; Y COORD
         AND     #$FE
         TAY
         LDA     (SRC),Y
@@ -102,7 +102,7 @@ export asm dgrHLin(buff, x1, x2, y)#0
         LDY     ESTKL+2,X   ; X1 COORD
         PHP
         SEI
--       LDA     ESTKL,X
+-       LDA     ESTKL+0,X   ; Y COORD
         LSR
         TYA
         LDX     GCLR        ; COLOR
@@ -119,20 +119,19 @@ asm _dgrHLinPix
         INX
         INX
         INX
-        INX
         RTS
 end
 //
 // Plot horizontal row of pixels
 //
-export asm dgrVLin(buff, x, y1, y2)#0
-    ; GET BUFFER ADDRESS
-        STX     ESP
-        LDA     ESTKL+3,X
+export asm dgrVLin(y1, y2, x)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
         STA     SRCL
-        LDA     ESTKH+3,X
-        STA     SRCH
-        LDA     ESTKL+1,X   ; Y1 COORD
+        LDA     $3001
+		STA		SRCH
+        STX     ESP
+        LDA     ESTKL+2,X   ; Y1 COORD
         PHP
         SEI
 -       AND     #$FE
@@ -142,38 +141,38 @@ export asm dgrVLin(buff, x, y1, y2)#0
         INY
         LDA     (SRC),Y
         STA     GBASH
-        LDA     ESTKL+1,X
+        LDA     ESTKL+2,X
         LSR
-        LDA     ESTKL+2,X   ; X COORD
+        LDA     ESTKL+0,X   ; X COORD
         LDX     GCLR        ; COLOR
 end
 asm _dgrVLinPix
         JSR     $3000       ; _dgrSetPix
         LDX     ESP
-        INC     ESTKL+1,X   ; Y1 COORD
-        LDA     ESTKL+1,X
-        CMP     ESTKL,X     ; Y2 COORD
+        INC     ESTKL+2,X   ; Y1 COORD
+        LDA     ESTKL+2,X
+        CMP     ESTKL+1,X   ; Y2 COORD
         BCC     -
         BEQ     -
         PLP
         INX
         INX
         INX
-        INX
         RTS
 end
 //
 // Draw sprite
 //
-export asm dgrBLT(buff, x, y, width, height, src)#0
+export asm dgrBLT(x, y, width, height, src)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     DSTL
+        LDA     $3001
+		STA		DSTH
         LDA     ESTKL,X     ; SPRITE
         STA     SRCL
         LDA     ESTKH,X
         STA     SRCH
-        LDA     ESTKL+5,X
-        STA     DSTL
-        LDA     ESTKH+5,X
-        STA     DSTH
         LDA     ESTKL+4,X   ; X1 COORD
         CMP     #80
         BPL     ++++
@@ -197,9 +196,8 @@ export asm dgrBLT(buff, x, y, width, height, src)#0
         CLC
         ADC     ESTKL+2,X   ; WIDTH
         STA     SRCL
-        LDA     SRCH
-        ADC     #$00
-        STA     SRCH
+        BCC     +++
+        INC     SRCH
         BNE     +++
 +       AND     #$FE
         TAY
@@ -245,7 +243,6 @@ asm _dgrBLTPix
         INX
         INX
         INX
-        INX
         RTS
 end
 //
@@ -326,16 +323,17 @@ end
 //
 // Draw 8x8 tile (forced to 2x2 block address)
 //
-export asm dgrTile(buff, x, y, src)#0
+export asm dgrTile(x, y, src)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     DSTL
+        LDA     $3001
+		STA		DSTH
         STX     ESP
         LDA     ESTKL,X       ; TILE
         STA     SRCL
         LDA     ESTKH,X
         STA     SRCH
-        LDA     ESTKL+3,X
-        STA     DSTL
-        LDA     ESTKH+3,X
-        STA     DSTH
         LDA     ESTKL+2,X   ; X1 COORD
         CMP     #80
         BPL     ++++
@@ -357,9 +355,8 @@ export asm dgrTile(buff, x, y, src)#0
         LDA     SRCL        ; SKIP TO NEXT ROW
         ADC     #$07        ; CARRY = 1
         STA     SRCL
-        LDA     SRCH
-        ADC     #$00
-        STA     SRCH
+        BCC     +++
+        INC     SRCH
         BNE     +++
 +       AND     #$FE
         TAY
@@ -392,9 +389,9 @@ export asm dgrTile(buff, x, y, src)#0
         STA     (GBASE),Y
 ++      INC     TMPH        ; X COORD
         INC     TMPH        ; X COORD
-        LDX     ESP
         LDA     TMPH
         BMI     --
+        LDX     ESP
         CMP     ESTKH+2,X   ; X2 COORD
         BCC     --
         PLP
@@ -405,7 +402,6 @@ export asm dgrTile(buff, x, y, src)#0
         CMP     ESTKH+1,X   ; Y2 COORD
         BCC     -
 ++++    INX
-        INX
         INX
         INX
         RTS
@@ -413,22 +409,17 @@ end
 //
 // Draw a string of tiles
 //
-export asm dgrTileStr(buff, x, y, tilestr, strlen, tilebuff)#0
+export asm dgrTileStr(x, y, tilestr, strlen, tilebuff)#0
 -       DEX
         DEX
         DEX
-        DEX
-        LDA     ESTKL+9,X   ; BUFF
-        STA     ESTKL+3,X
-        LDA     ESTKH+9,X
-        STA     ESTKH+3,X
-        LDA     ESTKL+8,X   ; X COORD
+        LDA     ESTKL+7,X   ; X COORD
         STA     ESTKL+2,X
-        LDA     ESTKL+7,X   ; Y COORD
+        LDA     ESTKL+6,X   ; Y COORD
         STA     ESTKL+1,X
-        LDA     ESTKL+4,X   ; TILE
+        LDA     ESTKL+3,X   ; TILE
         STA     ESTKL,X
-        LDA     ESTKH+4,X   ; TILE
+        LDA     ESTKH+3,X   ; TILE
         STA     ESTKH,X
 end
 asm _dgrTileTile
@@ -441,16 +432,17 @@ asm _dgrTileTile
         STA     ESTKL+4,X
         DEC     ESTKL+1,X   ; DEC STRLEN
         BNE     -
-+       TXA
-        CLC
-        ADC     #6
-        TAX
++       INX
+        INX
+        INX
+        INX
+        INX
         RTS
 end
 //
 // Fill a buffer with tiles
 //
-export asm dgrFill(buff, x, y, tile)#0
+export asm dgrFill(x, y, tile)#0
         LDA     ESTKL+2,X
         AND     #$0F
         STA     ESTKL+2,X
@@ -469,18 +461,13 @@ export asm dgrFill(buff, x, y, tile)#0
 -       DEX
         DEX
         DEX
-        DEX
-        LDA     ESTKL+7,X   ; BUFF
-        STA     ESTKL+3,X
-        LDA     ESTKH+7,X
-        STA     ESTKH+3,X
-        LDA     ESTKL+6,X   ; X COORD
+        LDA     ESTKL+5,X   ; X COORD
         STA     ESTKL+2,X
-        LDA     ESTKL+5,X   ; Y COORD
+        LDA     ESTKL+4,X   ; Y COORD
         STA     ESTKL+1,X
-        LDA     ESTKL+4,X   ; TILE
+        LDA     ESTKL+3,X   ; TILE
         STA     ESTKL,X
-        LDA     ESTKH+4,X   ; TILE
+        LDA     ESTKH+3,X   ; TILE
         STA     ESTKH,X
 end
 asm _dgrFillTile
@@ -502,11 +489,10 @@ asm _dgrFillTile
         INX
         INX
         INX
-        INX
         RTS
 end
 //
-// Wait for VLB - Shouldn't work on //c, but seems to.
+// Wait for VLB - Only IIe/IIGS.
 //
 asm vlbWait#0
 -       LDA     $C019
@@ -515,23 +501,59 @@ asm vlbWait#0
         BPL     -
         RTS
 end
+// Wait for VBL on IIc is entirely different from others.
+// Setup, one-time *only* if polling will be used exclusively.
+// Otherwise requires restoring the mode on exit,
+// and setting up per-use instead.
+//   [php]
+//   sei         ; otherwise interrupt is still raised
+//   sta   $C07F ; enable access to VBL register
+//   sta   $C05B ; enable VBL polling
+//   sta   $C07E ; disable access to VBL register
 //
-// Set double lores graphics, return draw buffer
+// wait for VBL:
+// - bit   $C019
+//   bpl   -
+//   lda   $C070 ; $c019 bit 7 is sticky, reset it
 //
-export def dgrMode#1
-    ^showlores
-    ^showfull
-    ^showgraphics
-    ^showpage1
-    ^ena80  = 0
-    ^show80 = 0
-    ^an3on
-    return 1
+// To allow other methods of VBL, restore access:
+// - bit   $C019
+//   bpl   -
+//   lda   $C070 ; $c019 bit 7 is sticky, reset it
+//   sta   $C07F ; enable access to VBL register
+//   sta   $C05A ; disable VBL polling
+//   sta   $C07E ; disable access to VBL register
+//   [plp]
+
+//
+// Clear the buffer
+//
+export def dgrClear(clr)#0
+    byte[32] clrtile
+
+    clr = evnclr[clr&$0F] | (oddclr[clr&$0F] << 8)
+    memset(@clrtile, clr, 32)
+    dgrFill(0, 0, @clrtile)
 end
-//
-// Set text mode
-//
-export def txtMode#0
+export def dgrMode(mode)#1
+    if mode
+        //
+        // Set double lores graphics, return draw buffer
+        //
+        ^showlores
+        ^showfull
+        ^showgraphics
+        ^showpage1
+        ^ena80  = 0
+        ^show80 = 0
+        ^an3on
+        drawpage = 1
+        drawbuff = dgrbuff[1]
+        return 1
+    fin
+    //
+    // Set text mode
+    //
     ^showtext
     ^showpage1
     ^ena80   = 0
@@ -539,6 +561,7 @@ export def txtMode#0
     ^mapmain = 0
     ^an3off
     call($FC58, 0, 0, 0, 0) // home()
+    return 0
 end
 //
 // Set display page, return other page
@@ -548,6 +571,15 @@ export def dgrShow(page)#1
     ^(showpage1 + page)
     return page ^ 1
 end
+export def dgrSwap#0
+    ^(showpage1 + drawpage)
+    drawpage   = drawpage ^ 1
+    drawbuff = dgrbuff[drawpage]
+end
+export def dgrDrawBuf(page)#0
+    drawpage   = page
+    drawbuff = dgrbuff[drawpage]
+end
 //
 // Set color for clear & plot routines
 //
@@ -555,91 +587,6 @@ export def dgrColor(clr)#0
     ^$30 = clr & $0F
 end
 //
-// Draw line
-//
-export def dgrLine(buff, x1, y1, x2, y2)#0
-    byte dx, dy, dx2, dy2, pp
-    word sx, sy, err, dd2
-
-    if x1 < x2
-        sx = 1
-        dx = x2 - x1
-    else
-        sx = -1
-        dx = x1 - x2
-    fin
-    if y1 < y2
-        sy = 1
-        dy = y2 - y1
-    else
-        sy = -1
-        dy = y1 - y2
-    fin
-    dx2 = dx << 1
-    dy2 = dy << 1
-    if dx >= dy // Horizontal line
-        if sx < 0
-            x1, x2 = x2, x1
-            y1, y2 = y2, y1
-            sy     = -sy
-        fin
-        dd2 = dx2 - dy2
-        err = dx - dy2
-        sx = 1
-        while dy
-            if err < 0
-                dgrHLin(buff, x1, x1 + sx - 1, y1)
-                x1 = x1 + sx
-                y1 = y1 + sy
-                sx = 1
-                dy--
-                err = err + dd2
-            else
-                sx++
-                err = err - dy2
-            fin
-        loop
-        if y2 == y1
-            dgrHLin(buff, x1, x2, y1)
-        fin
-    else // Vertical line
-        if sy < 0
-            x1, x2 = x2, x1
-            y1, y2 = y2, y1
-            sx     = -sx
-        fin
-        dd2 = dy2 - dx2
-        err = dy - dx2
-        sy = 1
-        while dx
-            if err < 0
-                dgrVLin(buff, x1, y1, y1 + sy - 1)
-                x1 = x1 + sx
-                y1 = y1 + sy
-                sy = 1
-                dx--
-                err = err + dd2
-            else
-                sy++
-                err = err - dx2
-            fin
-        loop
-        if x2 == x1
-            dgrVLin(buff, x1, y1, y2)
-        fin
-    fin
-end
-//
-// Clear the buffer
-//
-export def dgrClear(buff, clr)#0
-    byte[32] clrtile
-
-    clr = evnclr[clr&$0F] | (oddclr[clr&$0F] << 8)
-    memset(@clrtile, clr, 32)
-    dgrFill(buff, 0, 0, @clrtile)
-end
-//
 // Make sure we are a 128K //e or //c
 //
 if MACHID & $F0 <> $B0
@@ -661,6 +608,19 @@ _dgrSetEvnEvn:1 = @evnclr
 _dgrSetEvnOdd:1 = @oddclr
 _dgrSetOddEvn:1 = @evnclr
 _dgrSetOddOdd:1 = @oddclr
+//
+// Fixups for drawbuff
+//
+dgrPlot:1       = @drawbuff
+dgrPlot:6       = @drawbuff+1
+dgrHLin:1       = @drawbuff
+dgrHLin:6       = @drawbuff+1
+dgrVLin:1       = @drawbuff
+dgrVLin:6       = @drawbuff+1
+dgrBLT:1        = @drawbuff
+dgrBLT:6        = @drawbuff+1
+dgrTile:1       = @drawbuff
+dgrTile:6       = @drawbuff+1
 // Put read AUX mem routine in scary location
 memcpy($0100, @auxRead, 9)
 done

src/libsrc/apple/fileio.pla

@@ -26,7 +26,9 @@ struc t_fileio
     word getpfx
     word setpfx
     word getfileinfo
+    word setfileinfo
     word geteof
+    word seteof
     word iobufalloc
     word open
     word close
@@ -34,20 +36,22 @@ struc t_fileio
     word write
     word create
     word destroy
+    word rename
     word newline
+    word online
     word readblock
     word writeblock
 end
-predef a2getpfx(path), a23setpfx(path), a2getfileinfo(path, fileinfo), a23geteof(refnum), a2iobufs(iobufs), a2open(path), a2close(refnum)
-predef a23read(refnum, buf, len), a2write(refnum, buf, len), a2create(path, type, aux), a23destroy(path)
-predef a2newline(refnum, emask, nlchar), a2readblock(unit, buf, block), a2writeblock(unit, buf, block)
+predef a2getpfx(path), a23setpfx(path), a2getfileinfo(path, fileinfo), a2setfileinfo(path, fileinfo), a23geteof(refnum)#2, a23seteof(refnum, eofl, eofh), a2iobufs(iobufs), a2open(path), a2close(refnum)
+predef a23read(refnum, buf, len), a2write(refnum, buf, len), a2create(path, type, aux), a23destroy(path), a23rename(path, newpath)
+predef a2newline(refnum, emask, nlchar), a2online(unit, buf), a2readblock(unit, buf, block), a2writeblock(unit, buf, block)
 //
 // Exported function table.
 //
 word fileio[]
-word = @a2getpfx, @a23setpfx, @a2getfileinfo, @a23geteof, @a2iobufs, @a2open, @a2close
-word = @a23read, @a2write, @a2create, @a23destroy
-word = @a2newline, @a2readblock, @a2writeblock
+word = @a2getpfx, @a23setpfx, @a2getfileinfo, @a2setfileinfo, @a23geteof, @a23seteof, @a2iobufs, @a2open, @a2close
+word = @a23read, @a2write, @a2create, @a23destroy, @a23rename
+word = @a2newline, @a2online, @a2readblock, @a2writeblock
 //
 // SOS/ProDOS error code
 //
@@ -117,17 +121,53 @@ def a3getfileinfo(path, fileinfo)
     perr     = syscall($C4, @params)
     return perr
 end
-def a1geteof(refnum)
-    return 0
+def a1setfileinfo(path, fileinfo)
+    perr = $01
+    return perr
 end
-def a23geteof(refnum)
+def a2setfileinfo(path, fileinfo)
+    byte params[14]
+
+    params.0 = 7
+    params:1 = path
+    memcpy(@params + 3, fileinfo, 11)
+    perr     = syscall($C3, @params)
+    return perr
+end
+def a3setfileinfo(path, fileinfo)
     byte params[6]
 
+    params.0 = 3
+    params:1 = path
+    params:3 = fileinfo
+    params.5 = 15
+    perr     = syscall($C3, @params)
+    return perr
+end
+def a1geteof(refnum)#2
+    return 0, 0
+end
+def a23geteof(refnum)#2
+    byte params[5]
+
     params.0 = 2
     params.1 = refnum
     params:2 = 0
-    params:4 = 0
+    params.4 = 0
     syscall($D1, @params)
+    return params:2, params.4
+end
+def a1seteof(refnum, eofl, eofh)
+    return 0
+end
+def a23seteof(refnum, eofl, eofh)
+    byte params[5]
+
+    params.0 = 2
+    params.1 = refnum
+    params:2 = eofl
+    params.4 = eofh
+    syscall($D0, @params)
     return params:2
 end
 def a1open(path)
@@ -258,7 +298,7 @@ def a3write(refnum, buff, len)
     params:2 = buff
     params:4 = len
     perr     = syscall($CB, @params)
-    return perr
+    return perr ?? 0 :: len
 end
 def a1create(path, type, aux)
     return perr
@@ -271,7 +311,7 @@ def a2create(path, type, aux)
     params.3  = $C3
     params.4  = type
     params:5  = aux
-    params.7  = $1
+    params.7  = type == $0F ?? $0D :: $01
     params:8  = 0
     params:10 = 0
     perr      = syscall($C0, @params)
@@ -284,13 +324,15 @@ def a3create(path, type, aux)
     params.0  = 3
     params:1  = path
     params:3  = @options
-    params.5  = 3
+    params.5  = 4
     options.0 = type
     options:1 = aux
+    options.3 = type == $0F ?? $0D :: $01
     perr      = syscall($C0, @params)
     return perr
 end
 def a1destroy(path)
+    perr = $01
     return perr
 end
 def a23destroy(path)
@@ -301,6 +343,19 @@ def a23destroy(path)
     perr     = syscall($C1, @params)
     return perr
 end
+def a1rename(oldpath, newpath)
+    perr = $01
+    return perr
+end
+def a23rename(path, newpath)
+    byte params[5]
+
+    params.0 = 2
+    params:1 = path
+    params:3 = newpath
+    perr     = syscall($C2, @params)
+    return perr
+end
 def a1newline(refnum, emask, nlchar)
     return perr
 end
@@ -324,6 +379,57 @@ def a3newline(refnum, emask, nlchar)
     perr     = syscall($C9, @params)
     return perr
 end
+def a1online(unit, buf)
+    perr = $27 // IOERR
+    return perr
+end
+def a2online(unit, buf)
+    byte params[4]
+
+    params.0 = 2
+    params.1 = unit
+    params:2 = buf
+    perr     = syscall($C5, @params)
+    return perr
+end
+def a3volume(unit, volname)
+    byte devname[17]
+    byte info[11]
+    byte params[9]
+    
+    ^volname = 0
+    params.0 = 4
+    params.1 = unit
+    params:2 = @devname
+    params:4 = @info
+    params.6 = 11
+    if syscall($85, @params) == 0
+        params.0 = 4
+        params:1 = @devname
+        params:3 = volname
+        params:5 = 0
+        params:7 = 0
+        return syscall($C5, @params)
+    fin
+    return -1
+end
+def a3online(unit, buf)
+    byte info[11]
+    byte volname[17]
+    byte i
+
+    if unit == 0
+        for i = $01 to $0F
+            if a3volume(i, buf) == 0
+                ^buf = ^buf | (i << 4)
+            fin
+            buf = buf + 16
+        next
+    else
+        return a3volume(unit, buf)
+    fin
+    return 0
+end
 def a13readblock(unit, buf, block)
     perr = $27  // IOERR
     return perr
@@ -359,12 +465,14 @@ when MACHID & MACHID_MODEL
     is MACHID_III
         fileio:getpfx      = @a3getpfx
         fileio:getfileinfo = @a3getfileinfo
+        fileio:setfileinfo = @a3setfileinfo
         fileio:iobufalloc  = @a13iobufs
         fileio:open        = @a3open
         fileio:close       = @a3close
         fileio:write       = @a3write
         fileio:create      = @a3create
         fileio:newline     = @a3newline
+        fileio:online      = @a3online
         fileio:readblock   = @a13readblock
         fileio:writeblock  = @a13writeblock
         break
@@ -372,7 +480,9 @@ when MACHID & MACHID_MODEL
         fileio:getpfx      = @a1getpfx
         fileio:setpfx      = @a1setpfx
         fileio:getfileinfo = @a1getfileinfo
+        fileio:setfileinfo = @a1setfileinfo
         fileio:geteof      = @a1geteof
+        fileio:seteof      = @a1seteof
         fileio:iobufalloc  = @a13iobufs
         fileio:open        = @a1open
         fileio:close       = @a1close
@@ -380,7 +490,9 @@ when MACHID & MACHID_MODEL
         fileio:write       = @a1write
         fileio:create      = @a1create
         fileio:destroy     = @a1destroy
+        fileio:rename      = @a1rename
         fileio:newline     = @a1newline
+        fileio:online      = @a1online
         fileio:readblock   = @a13readblock
         fileio:writeblock  = @a13writeblock
         break

src/libsrc/apple/grlib.pla

@@ -0,0 +1,493 @@
+include "inc/cmdsys.plh"
+//
+// Apple II hardware constants.
+//
+const showgraphics = $C050
+const showtext     = $C051
+const showfull     = $C052
+const showmix      = $C053
+const showpage1    = $C054
+const showpage2    = $C055
+const showlores    = $C056
+const showhires    = $C057
+const show40       = $C00C
+const show80       = $C00D
+const mapmain      = $C000
+const mapaux       = $C001
+const an3on        = $C05E
+const an3off       = $C05F
+const ena80        = $C07E
+const dis80        = $C07F
+const page1        = 0
+const page2        = 1
+//
+// Screen row address arrays.
+//
+word[] gr1row = $0400,$0480,$0500,$0580,$0600,$0680,$0700,$0780
+word          = $0428,$04A8,$0528,$05A8,$0628,$06A8,$0728,$07A8
+word          = $0450,$04D0,$0550,$05D0,$0650,$06D0,$0750,$07D0
+word[] gr2row = $0800,$0880,$0900,$0980,$0A00,$0A80,$0B00,$0B80
+word          = $0828,$08A8,$0928,$09A8,$0A28,$0AA8,$0B28,$0BA8
+word          = $0850,$08D0,$0950,$09D0,$0A50,$0AD0,$0B50,$0BD0
+word[] grbuff = @gr1row, @gr2row
+word drawbuff
+byte drawpage
+
+asm grInc(buff)
+!SOURCE    "vmsrc/plvmzp.inc"
+GBASL    =    $26
+GBASH    =    $27
+GBASE    =    GBASL
+GCLR     =    $30
+end
+//
+// Plot pixel
+//
+export asm grPlot(x, y)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     SRCL
+        LDA     $3001
+		STA		SRCH
+        LDA     ESTKL,X     ; Y COORD
+        AND     #$FE
+        TAY
+        LDA     (SRC),Y
+        STA     GBASL
+        INY
+        LDA     (SRC),Y
+        STA     GBASH
+        LDY     ESTKL+1,X   ; X COORD
+        LSR     ESTKL,X
+        LDA     GCLR        ; COLOR
+        EOR     (GBASE),Y
+        BCS     +
+        ; EVEN ROW
+        AND     #$0F
+        BCC     ++
+        ; ODD ROW
++       AND     #$F0
+++      EOR     (GBASE),Y
+        STA     (GBASE),Y
+        INX
+        INX
+        RTS
+end
+//
+// Plot horizontal row of pixels
+//
+export asm grHLin(x1, x2, y)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     SRCL
+        LDA     $3001
+		STA		SRCH
+        LDA     ESTKL+1,X    ; X2 COORD
+        STA     TMPH
+        LDA     ESTKL+0,X    ; Y COORD
+        AND     #$FE
+        TAY
+        LDA     (SRC),Y
+        STA     GBASL
+        INY
+        LDA     (SRC),Y
+        STA     GBASH
+        LDY     ESTKL+2,X   ; X1 COORD
+-       LDA     ESTKL+0,X   ; Y COORD
+        LSR
+        LDA     GCLR        ; COLOR
+        ; EVEN ROW
+        EOR     (GBASE),Y
+        BCS     +
+        AND     #$0F
+        BCC     ++
+        ; ODD ROW
++       AND     #$F0
+++      EOR     (GBASE),Y
+        STA     (GBASE),Y
+        INC     ESTKL+2,X   ; X1 COORD
+        LDY     ESTKL+2,X
+        CPY     TMPH        ; X2 COORD
+        BCC     -
+        BEQ     -
+        INX
+        INX
+        INX
+        RTS
+end
+//
+// Plot horizontal row of pixels
+//
+export asm grVLin(y1, y2, x)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     SRCL
+        LDA     $3001
+		STA		SRCH
+        LDA     ESTKL+2,X   ; Y1 COORD
+-       AND     #$FE
+        TAY
+        LDA     (SRC),Y
+        STA     GBASL
+        INY
+        LDA     (SRC),Y
+        STA     GBASH
+        LDA     ESTKL+2,X
+        LSR
+        LDY     ESTKL+0,X   ; X COORD
+        LDA     GCLR        ; COLOR
+        ; EVEN ROW
+        EOR     (GBASE),Y
+        BCS     +
+        AND     #$0F
+        BCC     ++
+        ; ODD ROW
++       AND     #$F0
+++      EOR     (GBASE),Y
+        STA     (GBASE),Y
+        INC     ESTKL+2,X   ; Y1 COORD
+        LDA     ESTKL+2,X
+        CMP     ESTKL+1,X   ; Y2 COORD
+        BCC     -
+        BEQ     -
+        INX
+        INX
+        INX
+        RTS
+end
+//
+// Draw sprite
+//
+export asm grBLT(x, y, width, height, src)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     DSTL
+        LDA     $3001
+		STA		DSTH
+        LDA     ESTKL,X     ; SPRITE
+        STA     SRCL
+        LDA     ESTKH,X
+        STA     SRCH
+        LDA     ESTKL+4,X   ; X1 COORD
+        CMP     #40
+        BPL     ++++
+        CLC
+        ADC     ESTKL+2,X
+        BMI     ++++
+        STA     ESTKH+2,X   ; X2 COORD
+        LDA     ESTKL+3,X   ; Y1 COORD
+        CMP     #48
+        BPL     ++++
+        STA     ESTKH+3,X   ; Y COORD
+        CLC
+        ADC     ESTKL+1,X
+        BMI     ++++
+        STA     ESTKH+1,X   ; Y2 COORD
+        STX     ESP
+        LDA     ESTKH+3,X
+-       CMP     #48
+        BCC     +
+        LDA     SRCL        ; SKIP TO NEXT ROW
+        CLC
+        ADC     ESTKL+2,X   ; WIDTH
+        STA     SRCL
+        LDA     SRCH
+        ADC     #$00
+        STA     SRCH
+        BNE     +++
++       AND     #$FE
+        TAY
+        LDA     (DST),Y
+        STA     GBASL
+        INY
+        LDA     (DST),Y
+        STA     GBASH
+        LDA     ESTKL+4,X   ; X1 COORD
+        STA     ESTKH+4,X   ; X COORD
+--      CMP     #40
+        BCS     ++
+        STA     TMP
+        LDA     ESTKH+3,X   ; Y COORD
+        LSR
+        LDY     #$00
+        LDA     (SRC),Y
+        BMI     ++
+        LDY     TMP
+        BCS     oddBLT
+        ; EVEN ROW
+        EOR     (GBASE),Y
+        AND     #$0F
+        BCC     evnBLT
+       ; ODD ROW
+oddBLT  ASL
+        ASL
+        ASL
+        ASL
+        EOR     (GBASE),Y
+        AND     #$F0
+evnBLT  EOR     (GBASE),Y
+        STA     (GBASE),Y
+++      INC     SRCL
+        BNE     +
+        INC     SRCH
++       INC     ESTKH+4,X   ; X COORD
+        LDA     ESTKH+4,X
+        BMI     --
+        CMP     ESTKH+2,X   ; X2 COORD
+        BCC     --
++++     INC     ESTKH+3,X   ; Y COORD
+        LDA     ESTKH+3,X
+        BMI     -
+        CMP     ESTKH+1,X   ; Y2 COORD
+        BCC     -
+++++    INX
+        INX
+        INX
+        INX
+        INX
+        RTS
+end
+//
+// Draw 8x8 tile (forced to 1x2 block address)
+//
+export asm grTile(x, y, src)#0
+        ; GET ROW BUFFER ADDRESSES
+		LDA     $3000
+        STA     DSTL
+        LDA     $3001
+		STA		DSTH
+        STX     ESP
+        LDA     ESTKL,X     ; TILE
+        STA     SRCL
+        LDA     ESTKH,X
+        STA     SRCH
+        LDA     ESTKL+2,X   ; X1 COORD
+        CMP     #40
+        BPL     ++++
+        CLC
+        ADC     #$08
+        BMI     ++++
+        STA     ESTKH+2,X   ; X2 COORD
+        LDA     ESTKL+1,X   ; Y1 COORD
+        CMP     #48
+        BPL     ++++
+        STA     TMPL        ; Y COORD
+        CLC
+        ADC     #$08
+        BMI     ++++
+        STA     ESTKH+1,X   ; Y2 COORD
+        LDA     TMPL        ; Y COORD
+-       CMP     #48
+        BCC     +
+        LDA     SRCL        ; SKIP TO NEXT ROW
+        ADC     #$07        ; CARRY = 1
+        STA     SRCL
+        LDA     SRCH
+        ADC     #$00
+        STA     SRCH
+        BNE     +++
++       AND     #$FE
+        TAY
+        LDA     (DST),Y
+        STA     GBASL
+        INY
+        LDA     (DST),Y
+        STA     GBASH
+        LDA     ESTKL+2,X   ; X1 COORD
+        STA     TMPH        ; X COORD
+--      TAY
+        CMP     #40
+        LDX     #$00
+        LDA     (SRC,X)
+        INC     SRCL
+        BNE     +
+        INC     SRCH
++       BCS     ++
+        STA     (GBASE),Y
+++      INC     TMPH        ; X COORD
+        LDA     TMPH
+        BMI     --
+        LDX     ESP
+        CMP     ESTKH+2,X   ; X2 COORD
+        BCC     --
++++     INC     TMPL        ; Y COORD
+        INC     TMPL        ; Y COORD
+        LDA     TMPL
+        BMI     -
+        CMP     ESTKH+1,X   ; Y2 COORD
+        BCC     -
+++++    INX
+        INX
+        INX
+        RTS
+end
+//
+// Draw a string of tiles
+//
+export asm grTileStr(x, y, tilestr, strlen, tilebuff)#0
+-       DEX
+        DEX
+        DEX
+        LDA     ESTKL+7,X   ; X COORD
+        STA     ESTKL+2,X
+        LDA     ESTKL+6,X   ; Y COORD
+        STA     ESTKL+1,X
+        LDA     ESTKL+3,X   ; TILE
+        STA     ESTKL,X
+        LDA     ESTKH+3,X   ; TILE
+        STA     ESTKH,X
+end
+asm _grTileTile
+        JSR     $5000
+        LDA     ESTKL+4,X   ; UPDATE X COORD
+        CLC
+        ADC     #$08
+        CMP     #40         ; OFF RIGHT SIDE
+        BPL     +
+        STA     ESTKL+4,X
+        DEC     ESTKL+1,X   ; DEC STRLEN
+        BNE     -
++       INX
+        INX
+        INX
+        INX
+        INX
+        RTS
+end
+//
+// Fill a buffer with tiles
+//
+export asm grFill(x, y, tile)#0
+        LDA     ESTKL+2,X
+        AND     #$0F
+        STA     ESTKL+2,X
+        LDA     ESTKL+1,X
+        AND     #$0F
+        STA     ESTKL+1,X
+        LDA     #$00
+        SEC
+        SBC     ESTKL+2,X   ; ORIGINAL X
+        STA     ESTKL+2,X
+        STA     ESTKH+2,X
+        LDA     #$00
+        SEC
+        SBC     ESTKL+1,X
+        STA     ESTKL+1,X
+-       DEX
+        DEX
+        DEX
+        LDA     ESTKL+5,X   ; X COORD
+        STA     ESTKL+2,X
+        LDA     ESTKL+4,X   ; Y COORD
+        STA     ESTKL+1,X
+        LDA     ESTKL+3,X   ; TILE
+        STA     ESTKL,X
+        LDA     ESTKH+3,X   ; TILE
+        STA     ESTKH,X
+end
+asm _grFillTile
+        JSR     $5000
+        LDA     ESTKL+2,X   ; UPDATE X COORD
+        CLC
+        ADC     #$08
+        STA     ESTKL+2,X
+        CMP     #40         ; OFF RIGHT SIDE?
+        BMI     -
+        LDA     ESTKH+2,X   ; RESTORE X COORD
+        STA     ESTKL+2,X
+        LDA     ESTKL+1,X   ; UPDATE Y COORD
+        CLC
+        ADC     #$08
+        STA     ESTKL+1,X
+        CMP     #48         ; OFF BOTTOM?
+        BMI     -
+        INX
+        INX
+        INX
+        RTS
+end
+//
+// Clear the buffer
+//
+export def grClear(clr)#0
+    byte[32] clrtile
+
+    clr = (clr & $0F) | (clr << 4)
+    clr = (clr & $FF) | (clr << 8)
+    memset(@clrtile, clr, 32)
+    grFill(0, 0, @clrtile)
+end
+//
+// Set lores graphics, return draw buffer
+//
+export def grMode(mode)#1
+    if mode
+        //
+        // Set GR mode
+        //
+        ^showlores
+        ^showfull
+        ^showgraphics
+        ^showpage1
+        ^ena80   = 0
+        ^show40  = 0
+        ^mapmain = 0
+        ^an3off
+        drawpage = 1
+        drawbuff = grbuff[1]
+        return 1
+    fin
+    //
+    // Set text mode
+    //
+    ^showtext
+    ^showpage1
+    ^ena80   = 0
+    ^show40  = 0
+    ^mapmain = 0
+    ^an3off
+    call($FC58, 0, 0, 0, 0) // home()
+    return 0
+end
+//
+// Set display page, return other page
+//
+export def grShow(page)#1
+    page = page & 1
+    ^(showpage1 + page)
+    return page ^ 1
+end
+export def grSwap#0
+    ^(showpage1 + drawpage)
+    drawpage   = drawpage ^ 1
+    drawbuff = grbuff[drawpage]
+end
+export def grDrawBuf(page)#0
+    drawpage   = page
+    drawbuff = grbuff[drawpage]
+end
+//
+// Set color for clear & plot routines
+//
+export def grColor(clr)#0
+    ^$30 = (clr & $0F) | (clr << 4)
+end
+//
+// Assembly fixups
+//
+_grTileTile:1  = @grTile
+_grFillTile:1  = @grTile
+//
+// Fixups for drawbuff
+//
+grPlot:1       = @drawbuff
+grPlot:6       = @drawbuff+1
+grHLin:1       = @drawbuff
+grHLin:6       = @drawbuff+1
+grVLin:1       = @drawbuff
+grVLin:6       = @drawbuff+1
+grBLT:1        = @drawbuff
+grBLT:6        = @drawbuff+1
+grTile:1       = @drawbuff
+grTile:6       = @drawbuff+1
+done

src/libsrc/apple/hgrfont.pla

@@ -0,0 +1,140 @@
+include "inc/hgrtile.plh"
+//
+// Apple //e hires character font
+//
+byte hgrFont[]
+byte = $1C,$22,$2A,$3A,$1A,$02,$3C,$00,$08,$14,$22,$22,$3E,$22,$22,$00
+byte = $1E,$22,$22,$1E,$22,$22,$1E,$00,$1C,$22,$02,$02,$02,$22,$1C,$00
+byte = $1E,$22,$22,$22,$22,$22,$1E,$00,$3E,$02,$02,$1E,$02,$02,$3E,$00
+byte = $3E,$02,$02,$1E,$02,$02,$02,$00,$3C,$02,$02,$02,$32,$22,$3C,$00
+byte = $22,$22,$22,$3E,$22,$22,$22,$00,$1C,$08,$08,$08,$08,$08,$1C,$00
+byte = $20,$20,$20,$20,$20,$22,$1C,$00,$22,$12,$0A,$06,$0A,$12,$22,$00
+byte = $02,$02,$02,$02,$02,$02,$3E,$00,$22,$36,$2A,$2A,$22,$22,$22,$00
+byte = $22,$22,$26,$2A,$32,$22,$22,$00,$1C,$22,$22,$22,$22,$22,$1C,$00
+byte = $1E,$22,$22,$1E,$02,$02,$02,$00,$1C,$22,$22,$22,$2A,$12,$2C,$00
+byte = $1E,$22,$22,$1E,$0A,$12,$22,$00,$1C,$22,$02,$1C,$20,$22,$1C,$00
+byte = $3E,$08,$08,$08,$08,$08,$08,$00,$22,$22,$22,$22,$22,$22,$1C,$00
+byte = $22,$22,$22,$22,$22,$14,$08,$00,$22,$22,$22,$2A,$2A,$36,$22,$00
+byte = $22,$22,$14,$08,$14,$22,$22,$00,$22,$22,$14,$08,$08,$08,$08,$00
+byte = $3E,$20,$10,$08,$04,$02,$3E,$00,$3E,$06,$06,$06,$06,$06,$3E,$00
+byte = $00,$02,$04,$08,$10,$20,$00,$00,$3E,$30,$30,$30,$30,$30,$3E,$00
+byte = $00,$00,$08,$14,$22,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7F
+byte = $00,$00,$00,$00,$00,$00,$00,$00,$08,$08,$08,$08,$08,$00,$08,$00
+byte = $14,$14,$14,$00,$00,$00,$00,$00,$14,$14,$3E,$14,$3E,$14,$14,$00
+byte = $08,$3C,$0A,$1C,$28,$1E,$08,$00,$06,$26,$10,$08,$04,$32,$30,$00
+byte = $04,$0A,$0A,$04,$2A,$12,$2C,$00,$08,$08,$08,$00,$00,$00,$00,$00
+byte = $08,$04,$02,$02,$02,$04,$08,$00,$08,$10,$20,$20,$20,$10,$08,$00
+byte = $08,$2A,$1C,$08,$1C,$2A,$08,$00,$00,$08,$08,$3E,$08,$08,$00,$00
+byte = $00,$00,$00,$00,$08,$08,$04,$00,$00,$00,$00,$3E,$00,$00,$00,$00
+byte = $00,$00,$00,$00,$00,$00,$08,$00,$00,$20,$10,$08,$04,$02,$00,$00
+byte = $1C,$22,$32,$2A,$26,$22,$1C,$00,$08,$0C,$08,$08,$08,$08,$1C,$00
+byte = $1C,$22,$20,$18,$04,$02,$3E,$00,$3E,$20,$10,$18,$20,$22,$1C,$00
+byte = $10,$18,$14,$12,$3E,$10,$10,$00,$3E,$02,$1E,$20,$20,$22,$1C,$00
+byte = $38,$04,$02,$1E,$22,$22,$1C,$00,$3E,$20,$10,$08,$04,$04,$04,$00
+byte = $1C,$22,$22,$1C,$22,$22,$1C,$00,$1C,$22,$22,$3C,$20,$10,$0E,$00
+byte = $00,$00,$08,$00,$08,$00,$00,$00,$00,$00,$08,$00,$08,$08,$04,$00
+byte = $10,$08,$04,$02,$04,$08,$10,$00,$00,$00,$3E,$00,$3E,$00,$00,$00
+byte = $04,$08,$10,$20,$10,$08,$04,$00,$1C,$22,$10,$08,$08,$00,$08,$00
+byte = $1C,$22,$2A,$3A,$1A,$02,$3C,$00,$08,$14,$22,$22,$3E,$22,$22,$00
+byte = $1E,$22,$22,$1E,$22,$22,$1E,$00,$1C,$22,$02,$02,$02,$22,$1C,$00
+byte = $1E,$22,$22,$22,$22,$22,$1E,$00,$3E,$02,$02,$1E,$02,$02,$3E,$00
+byte = $3E,$02,$02,$1E,$02,$02,$02,$00,$3C,$02,$02,$02,$32,$22,$3C,$00
+byte = $22,$22,$22,$3E,$22,$22,$22,$00,$1C,$08,$08,$08,$08,$08,$1C,$00
+byte = $20,$20,$20,$20,$20,$22,$1C,$00,$22,$12,$0A,$06,$0A,$12,$22,$00
+byte = $02,$02,$02,$02,$02,$02,$3E,$00,$22,$36,$2A,$2A,$22,$22,$22,$00
+byte = $22,$22,$26,$2A,$32,$22,$22,$00,$1C,$22,$22,$22,$22,$22,$1C,$00
+byte = $1E,$22,$22,$1E,$02,$02,$02,$00,$1C,$22,$22,$22,$2A,$12,$2C,$00
+byte = $1E,$22,$22,$1E,$0A,$12,$22,$00,$1C,$22,$02,$1C,$20,$22,$1C,$00
+byte = $3E,$08,$08,$08,$08,$08,$08,$00,$22,$22,$22,$22,$22,$22,$1C,$00
+byte = $22,$22,$22,$22,$22,$14,$08,$00,$22,$22,$22,$2A,$2A,$36,$22,$00
+byte = $22,$22,$14,$08,$14,$22,$22,$00,$22,$22,$14,$08,$08,$08,$08,$00
+byte = $3E,$20,$10,$08,$04,$02,$3E,$00,$3E,$06,$06,$06,$06,$06,$3E,$00
+byte = $00,$02,$04,$08,$10,$20,$00,$00,$3E,$30,$30,$30,$30,$30,$3E,$00
+byte = $00,$00,$08,$14,$22,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7F
+byte = $00,$00,$00,$00,$00,$00,$00,$00,$08,$08,$08,$08,$08,$00,$08,$00
+byte = $14,$14,$14,$00,$00,$00,$00,$00,$14,$14,$3E,$14,$3E,$14,$14,$00
+byte = $08,$3C,$0A,$1C,$28,$1E,$08,$00,$06,$26,$10,$08,$04,$32,$30,$00
+byte = $04,$0A,$0A,$04,$2A,$12,$2C,$00,$08,$08,$08,$00,$00,$00,$00,$00
+byte = $08,$04,$02,$02,$02,$04,$08,$00,$08,$10,$20,$20,$20,$10,$08,$00
+byte = $08,$2A,$1C,$08,$1C,$2A,$08,$00,$00,$08,$08,$3E,$08,$08,$00,$00
+byte = $00,$00,$00,$00,$08,$08,$04,$00,$00,$00,$00,$3E,$00,$00,$00,$00
+byte = $00,$00,$00,$00,$00,$00,$08,$00,$00,$20,$10,$08,$04,$02,$00,$00
+byte = $1C,$22,$32,$2A,$26,$22,$1C,$00,$08,$0C,$08,$08,$08,$08,$1C,$00
+byte = $1C,$22,$20,$18,$04,$02,$3E,$00,$3E,$20,$10,$18,$20,$22,$1C,$00
+byte = $10,$18,$14,$12,$3E,$10,$10,$00,$3E,$02,$1E,$20,$20,$22,$1C,$00
+byte = $38,$04,$02,$1E,$22,$22,$1C,$00,$3E,$20,$10,$08,$04,$04,$04,$00
+byte = $1C,$22,$22,$1C,$22,$22,$1C,$00,$1C,$22,$22,$3C,$20,$10,$0E,$00
+byte = $00,$00,$08,$00,$08,$00,$00,$00,$00,$00,$08,$00,$08,$08,$04,$00
+byte = $10,$08,$04,$02,$04,$08,$10,$00,$00,$00,$3E,$00,$3E,$00,$00,$00
+byte = $04,$08,$10,$20,$10,$08,$04,$00,$1C,$22,$10,$08,$08,$00,$08,$00
+byte = $1C,$22,$2A,$3A,$1A,$02,$3C,$00,$08,$14,$22,$22,$3E,$22,$22,$00
+byte = $1E,$22,$22,$1E,$22,$22,$1E,$00,$1C,$22,$02,$02,$02,$22,$1C,$00
+byte = $1E,$22,$22,$22,$22,$22,$1E,$00,$3E,$02,$02,$1E,$02,$02,$3E,$00
+byte = $3E,$02,$02,$1E,$02,$02,$02,$00,$3C,$02,$02,$02,$32,$22,$3C,$00
+byte = $22,$22,$22,$3E,$22,$22,$22,$00,$1C,$08,$08,$08,$08,$08,$1C,$00
+byte = $20,$20,$20,$20,$20,$22,$1C,$00,$22,$12,$0A,$06,$0A,$12,$22,$00
+byte = $02,$02,$02,$02,$02,$02,$3E,$00,$22,$36,$2A,$2A,$22,$22,$22,$00
+byte = $22,$22,$26,$2A,$32,$22,$22,$00,$1C,$22,$22,$22,$22,$22,$1C,$00
+byte = $1E,$22,$22,$1E,$02,$02,$02,$00,$1C,$22,$22,$22,$2A,$12,$2C,$00
+byte = $1E,$22,$22,$1E,$0A,$12,$22,$00,$1C,$22,$02,$1C,$20,$22,$1C,$00
+byte = $3E,$08,$08,$08,$08,$08,$08,$00,$22,$22,$22,$22,$22,$22,$1C,$00
+byte = $22,$22,$22,$22,$22,$14,$08,$00,$22,$22,$22,$2A,$2A,$36,$22,$00
+byte = $22,$22,$14,$08,$14,$22,$22,$00,$22,$22,$14,$08,$08,$08,$08,$00
+byte = $3E,$20,$10,$08,$04,$02,$3E,$00,$3E,$06,$06,$06,$06,$06,$3E,$00
+byte = $00,$02,$04,$08,$10,$20,$00,$00,$3E,$30,$30,$30,$30,$30,$3E,$00
+byte = $00,$00,$08,$14,$22,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7F
+byte = $00,$00,$00,$00,$00,$00,$00,$00,$08,$08,$08,$08,$08,$00,$08,$00
+byte = $14,$14,$14,$00,$00,$00,$00,$00,$14,$14,$3E,$14,$3E,$14,$14,$00
+byte = $08,$3C,$0A,$1C,$28,$1E,$08,$00,$06,$26,$10,$08,$04,$32,$30,$00
+byte = $04,$0A,$0A,$04,$2A,$12,$2C,$00,$08,$08,$08,$00,$00,$00,$00,$00
+byte = $08,$04,$02,$02,$02,$04,$08,$00,$08,$10,$20,$20,$20,$10,$08,$00
+byte = $08,$2A,$1C,$08,$1C,$2A,$08,$00,$00,$08,$08,$3E,$08,$08,$00,$00
+byte = $00,$00,$00,$00,$08,$08,$04,$00,$00,$00,$00,$3E,$00,$00,$00,$00
+byte = $00,$00,$00,$00,$00,$00,$08,$00,$00,$20,$10,$08,$04,$02,$00,$00
+byte = $1C,$22,$32,$2A,$26,$22,$1C,$00,$08,$0C,$08,$08,$08,$08,$1C,$00
+byte = $1C,$22,$20,$18,$04,$02,$3E,$00,$3E,$20,$10,$18,$20,$22,$1C,$00
+byte = $10,$18,$14,$12,$3E,$10,$10,$00,$3E,$02,$1E,$20,$20,$22,$1C,$00
+byte = $38,$04,$02,$1E,$22,$22,$1C,$00,$3E,$20,$10,$08,$04,$04,$04,$00
+byte = $1C,$22,$22,$1C,$22,$22,$1C,$00,$1C,$22,$22,$3C,$20,$10,$0E,$00
+byte = $00,$00,$08,$00,$08,$00,$00,$00,$00,$00,$08,$00,$08,$08,$04,$00
+byte = $10,$08,$04,$02,$04,$08,$10,$00,$00,$00,$3E,$00,$3E,$00,$00,$00
+byte = $04,$08,$10,$20,$10,$08,$04,$00,$1C,$22,$10,$08,$08,$00,$08,$00
+byte = $1C,$22,$2A,$3A,$1A,$02,$3C,$00,$08,$14,$22,$22,$3E,$22,$22,$00
+byte = $1E,$22,$22,$1E,$22,$22,$1E,$00,$1C,$22,$02,$02,$02,$22,$1C,$00
+byte = $1E,$22,$22,$22,$22,$22,$1E,$00,$3E,$02,$02,$1E,$02,$02,$3E,$00
+byte = $3E,$02,$02,$1E,$02,$02,$02,$00,$3C,$02,$02,$02,$32,$22,$3C,$00
+byte = $22,$22,$22,$3E,$22,$22,$22,$00,$1C,$08,$08,$08,$08,$08,$1C,$00
+byte = $20,$20,$20,$20,$20,$22,$1C,$00,$22,$12,$0A,$06,$0A,$12,$22,$00
+byte = $02,$02,$02,$02,$02,$02,$3E,$00,$22,$36,$2A,$2A,$22,$22,$22,$00
+byte = $22,$22,$26,$2A,$32,$22,$22,$00,$1C,$22,$22,$22,$22,$22,$1C,$00
+byte = $1E,$22,$22,$1E,$02,$02,$02,$00,$1C,$22,$22,$22,$2A,$12,$2C,$00
+byte = $1E,$22,$22,$1E,$0A,$12,$22,$00,$1C,$22,$02,$1C,$20,$22,$1C,$00
+byte = $3E,$08,$08,$08,$08,$08,$08,$00,$22,$22,$22,$22,$22,$22,$1C,$00
+byte = $22,$22,$22,$22,$22,$14,$08,$00,$22,$22,$22,$2A,$2A,$36,$22,$00
+byte = $22,$22,$14,$08,$14,$22,$22,$00,$22,$22,$14,$08,$08,$08,$08,$00
+byte = $3E,$20,$10,$08,$04,$02,$3E,$00,$3E,$06,$06,$06,$06,$06,$3E,$00
+byte = $00,$02,$04,$08,$10,$20,$00,$00,$3E,$30,$30,$30,$30,$30,$3E,$00
+byte = $00,$00,$08,$14,$22,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7F
+byte = $04,$08,$10,$00,$00,$00,$00,$00,$00,$00,$1C,$20,$3C,$22,$3C,$00
+byte = $02,$02,$1E,$22,$22,$22,$1E,$00,$00,$00,$3C,$02,$02,$02,$3C,$00
+byte = $20,$20,$3C,$22,$22,$22,$3C,$00,$00,$00,$1C,$22,$3E,$02,$3C,$00
+byte = $18,$24,$04,$1E,$04,$04,$04,$00,$00,$00,$1C,$22,$22,$3C,$20,$1C
+byte = $02,$02,$1E,$22,$22,$22,$22,$00,$08,$00,$0C,$08,$08,$08,$1C,$00
+byte = $10,$00,$18,$10,$10,$10,$12,$0C,$02,$02,$22,$12,$0E,$12,$22,$00
+byte = $0C,$08,$08,$08,$08,$08,$1C,$00,$00,$00,$36,$2A,$2A,$22,$22,$00
+byte = $00,$00,$1E,$22,$22,$22,$22,$00,$00,$00,$1C,$22,$22,$22,$1C,$00
+byte = $00,$00,$1E,$22,$22,$1E,$02,$02,$00,$00,$3C,$22,$22,$3C,$20,$20
+byte = $00,$00,$3A,$06,$02,$02,$02,$00,$00,$00,$3C,$02,$1C,$20,$1E,$00
+byte = $04,$04,$1E,$04,$04,$24,$18,$00,$00,$00,$22,$22,$22,$32,$2C,$00
+byte = $00,$00,$22,$22,$22,$14,$08,$00,$00,$00,$22,$22,$2A,$2A,$36,$00
+byte = $00,$00,$22,$14,$08,$14,$22,$00,$00,$00,$22,$22,$22,$3C,$20,$1C
+byte = $00,$00,$3E,$10,$08,$04,$3E,$00,$38,$0C,$0C,$06,$0C,$0C,$38,$00
+byte = $08,$08,$08,$08,$08,$08,$08,$08,$0E,$18,$18,$30,$18,$18,$0E,$00
+byte = $00,$2C,$1A,$00,$00,$00,$00,$00,$00,$2A,$14,$2A,$14,$2A,$00,$00
+//
+// Print string with HGR tile library
+//
+export def hgrPutStr(x, y, strptr)#0
+   tileDrawStr(x, y, strptr + 1, ^strptr, @hgrFont + 1024) // Offset into regular char
+end
+done

src/libsrc/apple/hgrsprite.pla

@@ -0,0 +1,365 @@
+include "inc/cmdsys.plh"
+include "inc/hgrlib.plh"
+include "inc/fileio.plh"
+
+struc t_sprite
+    var  s_xpos
+    var  s_ypos
+    var  s_undery[2]
+    var  s_underofst[2]
+    byte s_undermap[2]
+    byte s_xcenter
+    byte s_ycenter
+    byte s_pitch
+    byte s_height
+    var  s_size
+    var  s_mask[14]
+    var  s_map[14]
+    var  s_under[14]
+end
+
+var drawList[16]
+var undrawList0[16]
+var undrawList1[16]
+var undrawList[2] = @undrawList0, @undrawList1
+byte drawpage
+//
+// Sprite routines
+//
+asm scanMask(x, y, w, srcptr)#0
+!SOURCE    "vmsrc/plvmzp.inc"
+        LDA     ESTKL+0,X   ; SRC PTR
+        STA     SRCL
+        LDA     ESTKH+0,X
+        STA     SRCH
+        LDA     #$00
+-       PHA
+        LSR
+        TAY
+        LDA     (SRC),Y
+        AND     #$80
+        BEQ     +
+        LDA     #$03
++       DEX
+        STA     ESTKL+0,X
+end
+asm     _scanMaskA
+        JSR     $C000       ; HCOLOR
+        DEX
+        DEX
+        LDA     ESTKL+5,X   ; X COORDL
+        STA     ESTKL+1,X     
+        LDA     ESTKH+5,X   ; X COORDH
+        STA     ESTKH+1,X     
+        LDA     ESTKL+4,X   ; Y COORDL
+        STA     ESTKL+0,X     
+        LDA     ESTKH+4,X   ; Y COORDH
+        STA     ESTKH+0,X     
+end
+asm     _scanMaskB
+        JSR     $D000       ; HPLOT
+        INC     ESTKL+3,X   ; X COORDL
+        BNE     +
+        INC     ESTKH+3,X   ; X COORDH
++       PLA
+        CLC
+        ADC     #$01
+        CMP     ESTKL+1,X   ; WIDTH
+        BEQ     BLTDONE
+        PHA
+        LSR
+        TAY
+        LDA     (SRC),Y
+        AND     #$08
+        BEQ     +
+        LDA     #$03
++       DEX
+        STA     ESTKL+0,X
+end
+asm     _scanMaskC
+        JSR     $C000       ; HCOLOR
+        DEX
+        DEX
+        LDA     ESTKL+5,X   ; X COORDL
+        STA     ESTKL+1,X     
+        LDA     ESTKH+5,X   ; X COORDH
+        STA     ESTKH+1,X     
+        LDA     ESTKL+4,X   ; Y COORDL
+        STA     ESTKL+0,X     
+        LDA     ESTKH+4,X   ; Y COORDH
+        STA     ESTKH+0,X     
+end
+asm     _scanMaskD
+        JSR     $D000       ; HPLOT
+        INC     ESTKL+3,X   ; X COORDL
+        BNE     +
+        INC     ESTKH+3,X   ; X COORDH
++       PLA
+        CLC
+        ADC     #$01
+        CMP     ESTKL+1,X   ; WIDTH
+        BNE     -
+BLTDONE INX
+        INX
+        INX
+        INX
+        RTS
+end
+def spriteBLTMask(x, y, w, h, srcptr)#0
+    word i, j
+    byte pitch
+    byte c
+    
+    pitch = (w + 1) / 2
+    for j = y to y + h - 1
+        scanMask(x, j, w, srcptr)
+//        for i = 0 to w - 1
+//            c = srcptr->[i >> 1]
+//            if i & 1
+//                hgrColor(c & $08 ?? 3 :: 0)
+//            else
+//                hgrColor(c & $80 ?? 3 :: 0)
+//            fin
+//            hgrPlot(x + i, j)
+//        next
+        srcptr = srcptr + pitch
+    next
+end
+export def spriteCompile(w, h, xcenter, ycenter, srcptr)#1
+    var sprtptr, bytewidth, spritesize, i
+    
+    sprtptr             = heapalloc(t_sprite)
+    if not sprtptr; return 0; fin
+    bytewidth           = (w + 13) / 7
+    sprtptr->s_pitch    = bytewidth
+    spritesize          = bytewidth * h
+    sprtptr=>s_size     = spritesize
+    sprtptr->s_height   = h
+    sprtptr->s_xcenter  = xcenter
+    sprtptr->s_ycenter  = ycenter
+    sprtptr=>s_under[0] = 0
+    sprtptr=>s_under[1] = 0
+    for i = 0 to 13
+        sprtptr=>s_map[i]  = heapalloc(spritesize)
+        sprtptr=>s_mask[i] = heapalloc(spritesize)
+        if not sprtptr=>s_map[i] or not sprtptr=>s_mask[i]
+            heaprelease(sprtptr)
+            return 0
+        fin
+        hgrColor(7)
+        hgrRect(0, 0, w + 21, h - 1)
+        spriteBLTMask(i, 0, w, h, srcptr)
+        hgrCopyDst(i > 6 ?? 1 :: 0, 0, bytewidth, h, sprtptr=>s_mask[i])
+        hgrColor(0)
+        hgrRect(0, h, w + 21, h * 2 - 1)
+        hgrBLT(i, h, w, h, srcptr)
+        hgrCopyDst(i > 6 ?? 1 :: 0, h, bytewidth, h, sprtptr=>s_map[i])
+    next
+    return sprtptr
+end
+export def spriteDup(sprtsrc)#1
+    var sprtdup
+    byte i
+    
+    sprtdup = heapalloc(t_sprite)
+    if not sprtdup; return 0; fin
+    memcpy(sprtdup, sprtsrc, t_sprite)
+    sprtdup=>s_under[0] = 0
+    sprtdup=>s_under[1] = 0
+    return sprtdup
+end
+export def spriteRead(filestr)#1
+    var sprtptr, spritesize
+    byte refnum, i
+    
+    sprtptr = heapalloc(t_sprite)
+    if not sprtptr; return 0; fin
+    refnum  = fileio:open(filestr)
+    if refnum
+        if fileio:read(refnum, sprtptr, t_sprite) == t_sprite
+            spritesize          = sprtptr=>s_size
+            sprtptr=>s_under[0] = 0
+            sprtptr=>s_under[1] = 0
+            for i = 0 to 13
+                sprtptr=>s_map[i]  = heapalloc(spritesize)
+                sprtptr=>s_mask[i] = heapalloc(spritesize)
+                if not sprtptr=>s_map[i] or not sprtptr=>s_mask[i]
+                    heaprelease(sprtptr)
+                    fileio:close(refnum)
+                    return 0
+                fin
+                fileio:read(refnum, sprtptr=>s_map[i], spritesize)
+                fileio:read(refnum, sprtptr=>s_mask[i], spritesize)
+            next
+        else
+            heaprelease(sprtptr)
+            sprtptr = 0
+        fin
+        fileio:close(refnum)
+    else
+        heaprelease(sprtptr)
+        sprtptr = 0
+    fin
+    return sprtptr
+end
+export def spriteSave(filestr, sprtptr)#1
+    var spritesize
+    byte refnum, i
+
+    fileio:destroy(filestr)
+    if fileio:create(filestr, $06, $0000) == FILE_ERR_OK
+        refnum = fileio:open(filestr)
+        if refnum
+            if fileio:write(refnum, sprtptr, t_sprite) == t_sprite
+                spritesize = sprtptr=>s_size
+                for i = 0 to 13
+                    fileio:write(refnum, sprtptr=>s_map[i], spritesize)
+                    fileio:write(refnum, sprtptr=>s_mask[i], spritesize)
+                next
+            fin
+            fileio:close(refnum)
+            return 0
+        fin
+    fin
+    return -1
+end
+export def spriteDraw(sprtptr)#0
+    byte map, pitch, height
+    var ofst, y
+    
+    y = sprtptr=>s_ypos
+    ofst, map = divmod7(sprtptr=>s_xpos)
+    if ofst & 1
+        map = map + 7
+    fin
+    sprtptr=>s_underofst[drawpage] = ofst
+    sprtptr=>s_undery[drawpage]    = y
+    pitch  = sprtptr->s_pitch
+    height = sprtptr->s_height
+    if not sprtptr=>s_under[drawpage]
+        sprtptr=>s_under[drawpage] = heapalloc(sprtptr=>s_size)
+        if not sprtptr=>s_under[drawpage]; return; fin
+    fin
+    hgrCopyDst(ofst, y, pitch, height, sprtptr=>s_under[drawpage])
+    hgrAndSrc( ofst, y, pitch, height, sprtptr=>s_mask[map])
+    hgrXorSrc( ofst, y, pitch, height, sprtptr=>s_map[map])
+end
+export def spriteUnDraw(sprtptr)#0
+    if sprtptr=>s_under[drawpage]
+        hgrCopySrc(sprtptr=>s_underofst[drawpage], sprtptr=>s_undery[drawpage], sprtptr->s_pitch, sprtptr->s_height, sprtptr=>s_under[drawpage])
+    fin
+end
+export def spriteDrawXor(sprtptr)#0
+    byte map, pitch, height
+    var ofst, y
+    
+    y = sprtptr=>s_ypos
+    ofst, map = divmod7(sprtptr=>s_xpos)
+    if ofst & 1
+        map = map + 7
+    fin
+    sprtptr->s_undermap[drawpage]  = map
+    sprtptr=>s_underofst[drawpage] = ofst
+    sprtptr=>s_undery[drawpage]    = y
+    pitch  = sprtptr->s_pitch
+    height = sprtptr->s_height
+    hgrXorSrc( ofst, y, pitch, height, sprtptr=>s_map[map])
+end
+export def spriteUnDrawXor(sprtptr)#0
+    hgrXorSrc(sprtptr=>s_underofst[drawpage], sprtptr=>s_undery[drawpage], sprtptr->s_pitch, sprtptr->s_height, sprtptr=>s_map[sprtptr->s_undermap[drawpage]])
+end
+export def spritePos(x, y, sprtptr)#0
+    sprtptr=>s_ypos = y - sprtptr->s_ycenter
+    sprtptr=>s_xpos = x - sprtptr->s_xcenter
+end
+export def spritePosIndex(x, y, i)#0
+    i = i & 15
+    if drawList[i]
+        drawList[i]=>s_ypos = y - drawList[i]->s_ycenter
+        drawList[i]=>s_xpos = x - drawList[i]->s_xcenter
+    fin
+end
+export def spriteUnDrawList#0
+    byte i
+    var undrawptr
+    
+    undrawptr = undrawList[drawpage]
+    for i = 15 downto 0
+        if undrawptr=>[i]
+            spriteUnDraw(undrawptr=>[i])
+            undrawptr=>[i] = 0
+        fin
+    next
+end
+export def spriteDrawList#0
+    byte i
+    var undrawptr
+    
+    undrawptr = undrawList[drawpage]
+    for i = 15 downto 0
+        if undrawptr=>[i]
+            spriteUnDraw(undrawptr=>[i])
+        fin
+    next
+    for i = 0 to 15
+        if drawList[i]
+            spriteDraw(drawList[i])
+        fin
+    next
+    memcpy(undrawptr, @drawList, 16*2)
+end
+export def spriteUnDrawXorList#0
+    byte i
+    var undrawptr
+    
+    undrawptr = undrawList[drawpage]
+    for i = 0 to 15
+        if undrawptr=>[i]
+            spriteUnDrawXor(undrawptr=>[i])
+            undrawptr=>[i] = 0
+        fin
+    next
+end
+export def spriteDrawXorList#0
+    byte i
+    var undrawptr
+    
+    undrawptr = undrawList[drawpage]
+    for i = 0 to 15
+        if undrawptr=>[i]
+            spriteUnDrawXor(undrawptr=>[i])
+        fin
+        if drawList[i]
+            spriteDrawXor(drawList[i])
+        fin
+    next
+    memcpy(undrawptr, @drawList, 16*2)
+end
+export def spriteAdd(i, sprtptr)#1
+    var sprtprev
+    
+    i = i & 15
+    sprtprev = drawList[i]
+    drawList[i] = sprtptr
+    return sprtprev
+end
+export def spriteDel(i)#1
+    var sprtprev
+    
+    i = i & 15
+    sprtprev = drawList[i]
+    drawList[i] = 0
+    return sprtprev
+end
+export def spriteDrawBuf(page)#1
+    drawpage = page & 1
+    return drawpage
+end
+//
+// Assembly fixups
+//
+_scanMaskA:1    = @hgrColor
+_scanMaskB:1    = @hgrPlot
+_scanMaskC:1    = @hgrColor
+_scanMaskD:1    = @hgrPlot
+done

src/libsrc/apple/hgrtile.pla

@@ -0,0 +1,435 @@
+include "inc/cmdsys.plh"
+//
+// Hardware addresses
+//
+const showgraphics = $C050
+const showtext     = $C051
+const showfull     = $C052
+const showmix      = $C053
+const showpage1    = $C054
+const showpage2    = $C055
+const showlores    = $C056
+const showhires    = $C057
+const keyboard     = $C000
+const keystrobe    = $C010
+const txt1         = $0400
+const txt2         = $0800
+const hgr1         = $2000
+const hgr2         = $4000
+const page1        = 0
+const page2        = 1
+
+word txtbuff[] = txt1, txt2
+word hgrbuff[] = hgr1, hgr2
+//
+// Screen tile scanline addresses.
+//
+word[] rowaddr   = $0000,$0080,$0100,$0180,$0200,$0280,$0300,$0380
+word             = $0028,$00A8,$0128,$01A8,$0228,$02A8,$0328,$03A8
+word             = $0050,$00D0,$0150,$01D0,$0250,$02D0,$0350,$03D0
+byte[] scanbttml = $00,$80,$00,$80,$00,$80,$00,$80
+byte             = $28,$A8,$28,$A8,$28,$A8,$28,$A8
+byte             = $50,$D0,$50,$D0,$50,$D0,$50,$D0
+byte[] scanbttmh = $1C,$1C,$1D,$1D,$1E,$1E,$1F,$1F
+byte             = $1C,$1C,$1D,$1D,$1E,$1E,$1F,$1F
+byte             = $1C,$1C,$1D,$1D,$1E,$1E,$1F,$1F
+
+byte hbmask    = $81,$82,$84,$88,$90,$A0,$C0
+word hcolor[]  = $0000,$552A,$2A55,$7F7F,$8080,$D5AA,$AAD5,$FFFF
+byte drawpage  = 0
+word drawbuff  = hgr1
+
+asm tileInc#0
+!SOURCE    "vmsrc/plvmzp.inc"
+CURSH   =   $24
+CURSV   =   $25
+GBASL   =   $26
+GBASH   =   $27
+GBASE   =   GBASL
+TBASL   =   $28
+TBASH   =   $29
+TBASE   =   TBASL
+TBAS2L  =   $2A
+TBAS2H  =   $2B
+TBAS2E  =   TBAS2L
+end
+//export def tileDraw(x, y, tileptr)#0
+//    var scrnptr
+//    
+//    scrnptr = (scanaddr[y] | drawbuff) + x
+//    scrnptr->[$1C00] = tileptr->[7]
+//    scrnptr->[$1800] = tileptr->[6]
+//    scrnptr->[$1400] = tileptr->[5]
+//    scrnptr->[$1000] = tileptr->[4]
+//    scrnptr->[$0C00] = tileptr->[3]
+//    scrnptr->[$0800] = tileptr->[2]
+//    scrnptr->[$0400] = tileptr->[1]
+//    scrnptr->[$0000] = tileptr->[0]
+//end
+export asm tileDraw(x, y, tileptr)#0
+        LDA     ESTKL+0,X   ; TILEPTRL
+        STA     SRCL
+        LDA     ESTKH+0,X   ; TILEPTRH
+        STA     SRCH
+        LDY     ESTKL+1,X   ; Y COORD
+        LDA     ESTKL+2,X   ; X COORD
+        CLC
+end
+asm     _tileDraw
+        ADC     $1000,Y     ; SCANBTTML
+        STA     ESTKL+0,X   ; USE ESTK AS POINTER
+        LDA     $3001       ; DRAWBUFFH
+        ADC     $2000,Y     ; SCANBTTMH
+        STA     ESTKL+1,X
+        LDY     #$07        ; DRAW BOTTOM UP
+        SEC
+-       LDA     (SRC),Y
+        STA     (ESTKL,X)
+        LDA     ESTKL+1,X
+        SBC     #$04
+        STA     ESTKL+1,X
+        DEY
+        BNE     -
+        LDA     (SRC),Y
+        STA     (ESTKL,X)
+        INX
+        INX
+        INX
+        RTS
+end
+//export def tileXorDraw(x, y, tileptr)#0
+//    var scrnptr
+//    
+//    scrnptr = (scanaddr[y] | drawbuff) + x
+//    scrnptr->[$1C00] = tileptr->[7]
+//    scrnptr->[$1800] = tileptr->[6]
+//    scrnptr->[$1400] = tileptr->[5]
+//    scrnptr->[$1000] = tileptr->[4]
+//    scrnptr->[$0C00] = tileptr->[3]
+//    scrnptr->[$0800] = tileptr->[2]
+//    scrnptr->[$0400] = tileptr->[1]
+//    scrnptr->[$0000] = tileptr->[0]
+//end
+export asm tileXorDraw(x, y, tileptr)#0
+        LDA     ESTKL+0,X   ; TILEPTRL
+        STA     SRCL
+        LDA     ESTKH+0,X   ; TILEPTRH
+        STA     SRCH
+        LDY     ESTKL+1,X   ; Y COORD
+        LDA     ESTKL+2,X   ; X COORD
+        CLC
+end
+asm     _tileXDraw
+        ADC     $1000,Y     ; SCANBTTML
+        STA     ESTKL+0,X   ; USE ESTK AS POINTER
+        LDA     $3001       ; DRAWBUFFH
+        ADC     $2000,Y     ; SCANBTTMH
+        STA     ESTKL+1,X
+        LDY     #$07        ; DRAW BOTTOM UP
+        SEC
+-       LDA     (SRC),Y
+        EOR     (ESTKL,X)
+        STA     (ESTKL,X)
+        LDA     ESTKL+1,X
+        SBC     #$04
+        STA     ESTKL+1,X
+        DEY
+        BNE     -
+        LDA     (SRC),Y
+        EOR     (ESTKL,X)
+        STA     (ESTKL,X)
+        INX
+        INX
+        INX
+        RTS
+end
+//export def tileOrDraw(x, y, tileptr)#0
+//    var scrnptr
+//    
+//    scrnptr = (scanaddr[y] | drawbuff) + x
+//    scrnptr->[$1C00] = tileptr->[7]
+//    scrnptr->[$1800] = tileptr->[6]
+//    scrnptr->[$1400] = tileptr->[5]
+//    scrnptr->[$1000] = tileptr->[4]
+//    scrnptr->[$0C00] = tileptr->[3]
+//    scrnptr->[$0800] = tileptr->[2]
+//    scrnptr->[$0400] = tileptr->[1]
+//    scrnptr->[$0000] = tileptr->[0]
+//end
+export asm tileOrDraw(x, y, tileptr)#0
+        LDA     ESTKL+0,X   ; TILEPTRL
+        STA     SRCL
+        LDA     ESTKH+0,X   ; TILEPTRH
+        STA     SRCH
+        LDY     ESTKL+1,X   ; Y COORD
+        LDA     ESTKL+2,X   ; X COORD
+        CLC
+end
+asm     _tileODraw
+        ADC     $1000,Y     ; SCANBTTML
+        STA     ESTKL+0,X   ; USE ESTK AS POINTER
+        LDA     $3001       ; DRAWBUFFH
+        ADC     $2000,Y     ; SCANBTTMH
+        STA     ESTKL+1,X
+        LDY     #$07        ; DRAW BOTTOM UP
+        SEC
+-       LDA     (SRC),Y
+        ORA     (ESTKL,X)
+        STA     (ESTKL,X)
+        LDA     ESTKL+1,X
+        SBC     #$04
+        STA     ESTKL+1,X
+        DEY
+        BNE     -
+        LDA     (SRC),Y
+        ORA     (ESTKL,X)
+        STA     (ESTKL,X)
+        INX
+        INX
+        INX
+        RTS
+end
+//export def tileAndDraw(x, y, tileptr)#0
+//    var scrnptr
+//    
+//    scrnptr = (scanaddr[y] | drawbuff) + x
+//    scrnptr->[$1C00] = tileptr->[7]
+//    scrnptr->[$1800] = tileptr->[6]
+//    scrnptr->[$1400] = tileptr->[5]
+//    scrnptr->[$1000] = tileptr->[4]
+//    scrnptr->[$0C00] = tileptr->[3]
+//    scrnptr->[$0800] = tileptr->[2]
+//    scrnptr->[$0400] = tileptr->[1]
+//    scrnptr->[$0000] = tileptr->[0]
+//end
+export asm tileAndDraw(x, y, tileptr)#0
+        LDA     ESTKL+0,X   ; TILEPTRL
+        STA     SRCL
+        LDA     ESTKH+0,X   ; TILEPTRH
+        STA     SRCH
+        LDY     ESTKL+1,X   ; Y COORD
+        LDA     ESTKL+2,X   ; X COORD
+        CLC
+end
+asm     _tileADraw
+        ADC     $1000,Y     ; SCANBTTML
+        STA     ESTKL+0,X   ; USE ESTK AS POINTER
+        LDA     $3001       ; DRAWBUFFH
+        ADC     $2000,Y     ; SCANBTTMH
+        STA     ESTKL+1,X
+        LDY     #$07        ; DRAW BOTTOM UP
+        SEC
+-       LDA     (SRC),Y
+        AND     (ESTKL,X)
+        STA     (ESTKL,X)
+        LDA     ESTKL+1,X
+        SBC     #$04
+        STA     ESTKL+1,X
+        DEY
+        BNE     -
+        LDA     (SRC),Y
+        AND     (ESTKL,X)
+        STA     (ESTKL,X)
+        INX
+        INX
+        INX
+        RTS
+end
+//export def tileDrawStr(x, y, strptr, strlen, tileset)#0
+//    while strlen
+//        tileDraw(x, y, tileset + ^strptr * 8)
+//        x++
+//        strptr++
+//        strlen--
+//    loop
+//end
+export asm tileDrawStr(x, y, strptr, strlen, tileset)#0
+        LDA     ESTKL+0,X   ; TILESETPTRL
+        STA     DSTL
+        LDA     ESTKH+0,X   ; TILESETPTRH
+        STA     DSTH
+        LDA     ESTKL+2,X   ; STRPTRL
+        STA     TMPL
+        LDA     ESTKH+2,X   ; STRPTRH
+        STA     TMPH
+        LDY     ESTKL+3,X   ; Y COORD
+        LDA     ESTKL+4,X   ; X COORD
+        CLC
+end
+asm     _tileDSa
+        ADC     $1000,Y     ; SCANBTTML
+        STA     $D000       ; SELF MODIFY LOOP
+        STA     $D001
+        STA     $D002
+        STA     $D003
+        STA     $D004
+        STA     $D005
+        STA     $D006
+        STA     $D007
+end
+asm     _tileDSb
+        LDA     $3001       ; DRAWBUFFH
+        ADC     $2000,Y     ; SCANBTTMH
+        STA     $D008       ; SELF MODIFY LOOP
+        SEC
+        SBC     #$04
+        STA     $D009
+        SBC     #$04
+        STA     $D00A
+        SBC     #$04
+        STA     $D00B
+        SBC     #$04
+        STA     $D00C
+        SBC     #$04
+        STA     $D00D
+        SBC     #$04
+        STA     $D00E
+        SBC     #$04
+        STA     $D00F
+        LDA     ESTKL+1,X   ; STRLEN
+        STX     IPY
+        TAX                 ; DRAW RIGHT TO LEFT
+        BEQ     +
+        DEX
+        LDY     #$00
+-       STY     SRCH
+        TXA
+        TAY
+        LDA     (TMP),Y     ; TILE INDEX * 8
+        ASL
+        ROL     SRCH
+        ASL
+        ROL     SRCH
+        ASL
+        ROL     SRCH
+;        CLC                ; CARRY IS CLEAR FROM ABOVE
+        ADC     DSTL        ; ADD TO TILESETPTR
+        STA     SRCL
+        LDA     SRCH
+        ADC     DSTH
+        STA     SRCH
+        LDY     #$07        ; DRAW BOTTOM UP
+end
+asm     _tileDSc
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEY
+        LDA     (SRC),Y
+        STA     $4000,X
+        DEX
+        BPL     -
+        LDX     IPY
++       INX
+        INX
+        INX
+        INX
+        INX
+        RTS
+end
+export def tileFromText(txtpage, tileset)#0
+    byte y
+    word txtptr
+    
+    txtptr = txtbuff[txtpage & 1]
+    for y = 0 to 23
+        tileDrawStr(0, y, rowaddr[y] | txtptr, 40, tileset)
+    next        
+end
+export def tileMode(mode)#1
+    if mode
+        //
+        // Set HGR mode
+        //
+        memset(hgr1, 0, $2000) // Clear HGR page 1
+        ^showpage1
+        ^showfull
+        ^showhires
+        ^showgraphics
+        drawpage = 0
+        drawbuff = hgr1
+        return 0
+    fin
+    //
+    // Show text mode
+    //
+    ^showpage1
+    ^showtext
+    return 0
+end
+export def tileClear#0
+    memset(drawbuff, $0000, drawbuff) // Clear current HGR page
+end
+//
+// Set display page, return other page
+//
+export def tileShow(page)#1
+    page = page & 1
+    ^(showpage1 + page)
+    return page ^ 1
+end
+export def tileSwap#1
+    ^(showpage1 + drawpage)
+    drawpage = drawpage ^ 1
+    drawbuff = hgrbuff[drawpage]
+    return drawpage
+end
+export def tileDrawBuf(page)#1
+    drawpage = page & 1
+    drawbuff = hgrbuff[drawpage]
+    return drawpage
+end
+//
+// Assembly fixups
+//
+_tileDraw:1  = @scanbttml
+_tileDraw:6  = @drawbuff.1
+_tileDraw:9  = @scanbttmh
+_tileXDraw:1 = @scanbttml
+_tileXDraw:6 = @drawbuff.1
+_tileXDraw:9 = @scanbttmh
+_tileODraw:1 = @scanbttml
+_tileODraw:6 = @drawbuff.1
+_tileODraw:9 = @scanbttmh
+_tileADraw:1 = @scanbttml
+_tileADraw:6 = @drawbuff.1
+_tileADraw:9 = @scanbttmh
+_tileDSa:1   = @scanbttml
+_tileDSa:4   = @_tileDSc.3
+_tileDSa:7   = @_tileDSc.9
+_tileDSa:10  = @_tileDSc.15
+_tileDSa:13  = @_tileDSc.21
+_tileDSa:16  = @_tileDSc.27
+_tileDSa:19  = @_tileDSc.33
+_tileDSa:22  = @_tileDSc.39
+_tileDSa:25  = @_tileDSc.45
+_tileDSa:28  = @_tileDSc.51
+_tileDSb:1   = @drawbuff.1
+_tileDSb:4   = @scanbttmh
+_tileDSb:7   = @_tileDSc.4
+_tileDSb:13  = @_tileDSc.10
+_tileDSb:18  = @_tileDSc.16
+_tileDSb:23  = @_tileDSc.22
+_tileDSb:28  = @_tileDSc.28
+_tileDSb:33  = @_tileDSc.34
+_tileDSb:38  = @_tileDSc.40
+_tileDSb:43  = @_tileDSc.46
+done
+

src/libsrc/apple/jit.pla

@@ -0,0 +1,56 @@
+//
+// PLASMA JIT bytecode compiler
+//
+include "inc/cmdsys.plh"
+//
+// Indirect interpreter DEFinition entrypoint
+//
+struc t_defentry
+    byte interpjsr
+    word interpaddr
+    word bytecodeaddr
+    byte callcount
+    byte bytecodesize
+end
+//
+// JIT compiler constants
+//
+const jitcomp     = $03E2
+const jitcodeptr  = $03E4
+const codemax     = $BEE0
+const estkh8      = $C000
+const estkh       = $00C0
+const estkl8      = $D000
+const estkl       = $00D0
+const ifpl8       = $E000
+const ifph8       = $E100
+const jmptmp      = $00E6
+const tmpl8       = $E700
+const tmph8       = $E800
+//
+// Bytecode interpreter entrypoints
+//
+const indirectentry = $03DC
+const directentry   = $03D0
+//
+// Copy bytecode DEF to main memory
+//
+def defcpy(dst, defptr)#0
+    *$003C   = defptr=>bytecodeaddr
+    *$003E   = *$003C + defptr->bytecodesize
+    *$0042   = dst
+    call($C311, 0, 0, 0, $04) // CALL XMOVE with carry clear (AUX->MAIN) and ints disabled
+end
+include "libsrc/jitcore.pla"
+//
+// Install JIT compiler
+//
+if *jitcomp
+    return 0
+fin
+*jitcomp        = @compiler
+cmdsys.jitcount = 36
+cmdsys.jitsize  = 96
+puts("JITC enabled\n")
+return modkeep
+done

src/libsrc/apple/jit16.pla

@@ -0,0 +1,67 @@
+//
+// PLASMA JIT bytecode compiler
+//
+include "inc/cmdsys.plh"
+//
+// Indirect interpreter DEFinition entrypoint
+//
+struc t_defentry
+    byte interpjsr
+    word interpaddr
+    word bytecodeaddr
+    byte callcount
+    byte bytecodesize
+end
+//
+// JIT compiler constants
+//
+const jitcomp     = $03E2
+const jitcodeptr  = $03E4
+const codemax     = $BEE0
+const estkh8      = $C000
+const estkh       = $00C0
+const estkl8      = $D000
+const estkl       = $00D0
+const ifp8        = $E000
+const ifpl8       = $E000
+const ifph8       = $E100
+const jmptmp      = $00E6
+const tmp8        = $E700
+const tmpl8       = $E700
+const tmph8       = $E800
+const fetchop     = $00F1
+const ip8         = $F200
+const ip          = $00F2
+//
+// Bytecode interpreter entrypoints
+//
+const indirectentry = $03DC
+const directentry   = $03D0
+//
+// Copy bytecode DEF to main memory
+//
+def defcpy(dst, defptr)#0
+    *$003C   = defptr=>bytecodeaddr
+    *$003E   = *$003C + defptr->bytecodesize
+    *$0042   = dst
+    call($C311, 0, 0, 0, $04) // CALL XMOVE with carry clear (AUX->MAIN) and ints disabled
+end
+//
+// Identify hardware addresses for certain byte sized access operations
+//
+def is_hwaddr(addr)
+    return isuge(addr, $C000) and isult(addr, $C100)
+end
+include "libsrc/jit16core.pla"
+//
+// Install JIT compiler
+//
+if *jitcomp
+    return 0
+fin
+*jitcomp        = @compiler
+cmdsys.jitcount = 32
+cmdsys.jitsize  = 96
+puts("16-bit VM/JITC enabled\n")
+return modkeep
+done

src/libsrc/apple/matchfiles.pla

@@ -0,0 +1,117 @@
+include "inc/cmdsys.plh"
+include "inc/fileio.plh"
+
+var dirbuf
+//
+// Match next section of source and expression
+//
+def matchNext(src, srcofst, exp, expofst)
+    if ^exp >= expofst
+        when exp->[expofst]
+            is '*' // Multi-char wildcard
+                if matchNext(src, srcofst, exp, expofst + 1) // Match zero wild chars
+                    return TRUE
+                elsif ^src >= srcofst and matchNext(src, srcofst + 1, exp, expofst) // Match more wild chars
+                    return TRUE
+                fin
+            is '?' // Single char wildcard
+                if ^src >= srcofst 
+                    return matchNext(src, srcofst + 1, exp, expofst + 1)
+                fin
+                return FALSE
+            otherwise // verbatim match
+                if ^src >= srcofst and src->[srcofst] == exp->[expofst]
+                    return matchNext(src, srcofst + 1, exp, expofst + 1)
+                fin
+                return FALSE
+        wend
+    fin
+    return ^src < srcofst and ^exp < expofst // Return TRUE if at the end of both
+end
+//
+// Start off matching process
+//
+export def matchName(src, exp)#1
+    //
+    // Match on empty wildcard name (same as '*')
+    //
+    if not ^exp
+        return TRUE
+    fin
+    return matchNext(src, 1, exp, 1)
+end
+export def matchList(pathstr, exp)#2
+    byte refnum
+    char[64] curpath
+    var firstblk, entrylen, entriesblk, i, entry, entrylist, entryptr, entrycnt
+
+    if not dirbuf
+        dirbuf = heapallocalign(512, 8, 0)
+    fin
+    if not ^pathstr
+        fileio:getpfx(@curpath)
+        pathstr = @curpath
+    fin
+    if pathstr->[^pathstr] <> '/' // Make sure path ends with a '/'
+        ^pathstr++
+        pathstr->[^pathstr] = '/'
+    fin
+    entrylist = 0
+    entrycnt  = 0
+    firstblk  = 1
+    refnum    = fileio:open(pathstr)
+    while fileio:read(refnum, dirbuf, 512) == 512
+        //
+        // Skip block pointers
+        //
+        entry = dirbuf + 4
+        if firstblk
+            //
+            // Pull out revelant details from the first block
+            //
+            entrylen   = dirbuf->$23
+            entriesblk = dirbuf->$24 - 1
+            entry      = entry + entrylen
+        fin
+        for i = firstblk to entriesblk
+            //
+            // Copy directory entry details
+            //
+            ^entry = ^entry & $0F
+            if ^entry
+                //
+                // Match wildcard filename
+                //
+                if matchName(entry, exp)
+                    entryptr = heapalloc(t_fileentry)
+                    memcpy(entryptr, entry, t_fileentry)
+                    entrycnt++
+                    if not entrylist
+                        entrylist = entryptr
+                    fin
+                fin
+            fin
+            entry = entry + entrylen
+        next
+        firstblk = 0
+    loop
+    fileio:close(refnum)
+    return entrylist, entrycnt
+end
+//
+// Is this a wildcard name?
+//
+export def isWildName(exp)#1
+    byte i
+    
+    if ^exp
+        for i = 1 to ^exp
+            if exp->[i] == '*' or exp->[i] == '?'
+                return TRUE
+            fin
+        next
+    fin
+    return FALSE
+end
+done
+                

src/libsrc/apple/mouse.pla

@@ -0,0 +1,582 @@
+include "inc/cmdsys.plh"
+//
+// Mouse driver interface
+//
+predef chkVbl, chkMouse, readMouse#3, setMouse(mode), clearMouse, posMouse(x, y), clampMouse(xMin, xMax, yMin, yMax), homeMouse, detachMouse
+word = @chkVbl, @chkMouse, @readMouse, @setMouse, @clearMouse, @posMouse, @clampMouse, @homeMouse, @detachMouse
+word rom
+byte params[]
+byte slot, index, page
+word setMouseFW
+byte vblDiv, vblInt, mouInt, bttnPrev
+asm equates
+    !SOURCE "vmsrc/plvmzp.inc"
+end
+//
+// Serve Mouse/VBL IRQ
+//
+asm serviceMouse#0
+VBLINT  =       $400            ; DUMMY VALUES TO BE FIXED-UP
+MOUINT  =       $401
+LASTBTTN=       $402
+        CLD
+        JSR     $C400
+        BCC     +
+        RTS                     ; NOT MOUSE INT
++       LDY     $0778+4         ; CHECK MOUSE INT CAUSE
+        TYA                     ; WAS IT VBL?
+        AND     #$08
+        BEQ     +               ; NOPE, MOVE OR BUTTON
+end
+asm vblEvent
+        INC     VBLINT          ; INC VBL EVENT
++       TYA                     ; MOUSE MOVE OR BUTTON ACTIVE
+        AND     #$82
+end
+asm bttnEvent
+        EOR     LASTBTTN
+        BEQ     +
+end
+asm mouseEvent
+        INC     MOUINT          ; INC MOUSE EVENT
++       TYA
+        AND     #$80
+end
+asm updateBttn
+        STA     LASTBTTN
+end
+asm updateMouse
+        LDX     #$C4
+        LDY     #$40
+        JMP     $C400           ; IIGS REQUIRES THIS HAPPEN IN IRQ
+end
+asm serviceCYA#0
+        CLC
+        RTS
+end
+//
+// Check for VBL (timer) and Mouse events (atomic read and reset)
+//
+asm chkEvt(addr)
+        LDA     ESTKL,X
+        STA     ESTKH-1,X
+        SEI
+        LDA     (ESTKH-1,X)     ; READ INT COUNT
+        TAY
+        LDA     #$00
+        STA     (ESTKH-1,X)     ; CLEAR INT COUNT
+        CLI
+        STY     ESTKL,X         ; RETURN INT COUNT
+        STA     ESTKH,X
+        RTS
+end
+asm readMouse#3
+        LDY     #$04
+        DEX
+        DEX
+        DEX
+        PHP
+        SEI
+        LDA     $0478,Y
+        STA     ESTKL+2,X
+        LDA     $0578,Y
+        STA     ESTKH+2,X
+        LDA     $04F8,Y
+        STA     ESTKL+1,X
+        LDA     $05F8,Y
+        STA     ESTKH+1,X
+        LDA     $0778,Y
+        STA     ESTKL,X
+        LDA     #$00
+        STA     ESTKH,X
+        PLP
+        RTS
+end
+//
+// Convert VBL interrupts into millisecond timer increment
+//
+def chkVblTimer
+    byte count
+    word msec
+
+    msec  = 0
+    count = chkEvt(@vblInt)
+    while count
+        if vblDiv & 2
+            msec   = msec + 16
+            vblDiv = 0
+        else
+            msec = msec + 17
+            vblDiv++
+        fin
+        count--
+    loop
+    return msec
+end
+//
+// Check for VBL/Mouse interrupt events
+//
+def chkVbl
+    return chkEvt(@vblInt)
+end
+def chkMouse
+    return chkEvt(@mouInt)
+end
+//
+// Mouse routines
+//
+def setMouse(mode)
+    return call(setMouseFW, mode, slot, page, $04)
+end
+def clearMouse
+    return call(rom + rom->$15, $00, slot, page, $04) // clearMouseFW
+end
+def posMouse(x, y)
+    //
+    // Fill screen holes
+    //
+    ^($0478 + index) = x
+    ^($0578 + index) = x >> 8
+    ^($04F8 + index) = y
+    ^($05F8 + index) = y >> 8
+    return call(rom + rom->$16, $00, slot, page, $04) // posMouseFW
+end
+def clampMouse(xMin, xMax, yMin, yMax)
+    ^$0478 = xMin
+    ^$0578 = xMin >> 8
+    ^$04F8 = xMax
+    ^$05F8 = xMax >> 8
+    call(rom + rom->$17, $00, slot, page, $04) // clampMouseFW
+    ^$0478 = yMin
+    ^$0578 = yMin >> 8
+    ^$04F8 = yMax
+    ^$05F8 = yMax >> 8
+    return call(rom + rom->$17, $01, slot, page, $04)) // clampMouseFW
+end
+def homeMouse
+    return call(rom + rom->$18, $00, slot, page, $04) // homeMouseFW
+end
+//
+// Detach mouse from interrupts
+//
+def detachMouse
+    setMouse(0)
+    params.0 = 1
+    params.1 = 0
+    return syscall($41, @params)
+end
+//
+// Identify Mouse card/slot and initialize
+//
+for rom = $C100 to $C700 step $0100
+    if rom->5 == $38 and rom->7 == $18 and rom->11 == $01 and rom->12 == $20
+        puts("Found Mouse in slot #"); putc('0' + ((rom >> 8) & $07)); putln
+        //
+        // Hook mouse IRQ handler into ProDOS IRQ chain
+        //
+        params.0 = 2
+        params.1 = 0
+        params:2 = @serviceMouse
+        syscall($40, @params)
+        //
+        // Hook CYA IRQ handler into ProDOS IRQ chain
+        //
+        params.0 = 2
+        params.1 = 3
+        params:2 = @serviceCYA
+        syscall($40, @params)
+        //
+        // Set values
+        //
+        slot           = rom >> 8
+        index          = slot & $07
+        page           = index << 4
+        setMouseFW     = rom + rom->$12
+        //
+        // Fix-up IRQ routine
+        //
+        serviceMouse:2 = rom + rom->$13 // serveMouseFW
+        serviceMouse:8 = $0778+index
+        vblEvent:1     = @vblInt
+        bttnEvent:1    = @bttnPrev
+        mouseEvent:1   = @mouInt
+        updateBttn:1   = @bttnPrev
+        updateMouse.1  = slot
+        updateMouse.3  = page
+        updateMouse:5  = rom + rom->$14 // readMouseFW
+        readMouse.1    = index
+        call(rom + rom->$19, $00, slot, page, $04) // initMouseFW
+        return modkeep
+    fin
+next
+//
+// Not found
+//
+return -1
+done
+
+What follows is the relevant parts to the mouse driver for VM02
+
+CHKMOUSE:   LDX #$20        ; LOOK FOR MOUSE
+    LDA #$01
+    JSR SCAN_SLOTS
+    BCS NOMOUSE
+    PHA         ; SAVE SLOT
+    LDY #$13
+    LDA (TMPTR),Y
+    STA SERVEMOUSE+1        ; FIXUP IRQ HANDLER
+    STX SERVEMOUSE+2
+    LDY #$14
+    LDA (TMPTR),Y
+    STA READMOUSE+1     ; FIXUP IRQ HANDLER
+    STX READMOUSE+2
+    TXA
+    AND #$07
+    STA MOUSE_SLOT
+    TAY
+    JSR MOUSE_INIT      ; MAKE SURE MOUSE IS OFF, INTS OFF
+    LDA WARM_INIT
+    BNE :+
+    JSR PUTS
+    .ASCIIZ "Mouse in slot #"
+    LDA MOUSE_SLOT
+    JSR PRBYTE
+    JSR CROUT
+:   PLA
+    TAY
+    LDA #<MOUSE_DRIVER      ; LOAD MOUSE DRIVER
+    LDX #>MOUSE_DRIVER
+    JSR LOAD_DRIVER
+;
+; SCAN SLOTS FOR MATCHING CARD ID
+; ENTRY: A = START SLOT SCAN
+;        X = CARD ID
+; EXIT:  A = SLOT # :: C = 0
+;        X = SLOT PAGE
+;
+SCAN_SLOTS: ORA #$C0
+    STA TMPTR+1
+    LDA #$00
+    STA TMPTR
+CHKSIG: LDY #$05
+    LDA (TMPTR),Y
+    CMP #$38        ; LOOK FOR PASCAL COMPAT SIG
+    BNE :+
+    LDY #$07
+    LDA (TMPTR),Y
+    CMP #$18
+    BNE :+
+    LDY #$0B
+    LDA (TMPTR),Y
+    CMP #$01
+    BNE :+
+    INY
+    TXA         ; LOOK FOR MATCHING ID
+    CMP (TMPTR),Y
+    BNE :+
+    LDA TMPTR+1
+    TAX
+    AND #$07
+    CLC
+    RTS
+:   INC TMPTR+1
+    LDA TMPTR+1
+    CMP #$C8
+    BCC CHKSIG
+    RTS
+
+;*
+;* TURN VBL INTS ON AFTER INIT
+;*
+VBL_INIT:   LDA MOUSE_SLOT
+    BEQ NOVBL
+    ASL
+    TAX
+    LSR
+    ORA #MOUSECTL_CALLFW
+    TAY
+    SEI         ; TURN OFF INTERRUPTS
+    LDA LINK_DEVCTRL,X
+    STA CALLVBLPROC+1
+    LDA LINK_DEVCTRL+1,X
+    STA CALLVBLPROC+2
+    LDA #$08        ; TURN MOUSE OFF, LEAVE VBL ON
+    LDX #$12
+CALLVBLPROC:    JSR $0000
+    CLI         ; BACK ON
+    LDA WARM_INIT
+    BNE NOVBL
+    JSR PUTSLN
+    .ASCIIZ "VBlank timer active"
+NOVBL:  RTS
+
+    JSR PRODOS
+    .BYTE   $40     ; ALLOC INTERRUPT
+    .ADDR   ALLOCINTPARMS
+.IFDEF  DEBUG
+    BCC :+
+    JSR PUTSLN
+    .ASCIIZ "FAILED TO ALLOCATE INTERRUPT"
+:
+.ENDIF
+    RTS
+ALLOCINTPARMS:  .BYTE   $02
+    .BYTE   $00     ; INT NUM
+    .ADDR   IO_INTERRUPT        ; INT CODE
+
+;*
+;* I/O INTERRUPT ROUTINE
+;*
+IO_INTERRUPT:   CLD
+    LDY #$02        ; SLOT #1 * 2
+FNDIRQPROC: LDA LINK_DEVIRQ+1,Y
+    BEQ NXTIRQPROC
+    STA CALLIRQPROC+2
+    LDA LINK_DEVIRQ,Y
+    STA CALLIRQPROC+1
+    TYA
+    LSR
+    PHA
+CALLIRQPROC:    JSR $0000
+    BCS :+
+    PLA
+    TAY
+    PHA
+    JSR THREAD_NOTIFYIO
+:   PLA
+    ASL
+    TAY
+NXTIRQPROC: INY
+    INY
+    CPY #$10
+    BCC FNDIRQPROC
+    CLC
+    RTS
+
+;*
+;* MOUSE DEVICE DRIVER
+;*
+MOUSE_INIT: ORA #$C0
+    STA XREGMOUSE1+1
+    STA XREGMOUSE2+1
+    ASL
+    ASL
+    ASL
+    ASL
+    STA YREGMOUSE1+1
+    STA YREGMOUSE2+1
+    LDA #$00
+    PHA         ; DISABLE ALL MOUSE INTS
+    LDX #$12        ; FW INDEX FOR SETMOUSE
+    BNE CALLMOUSEFW
+MOUSE_DRIVER:
+MOUSE_DRVR_SZ:  .WORD   MOUSE_DRVR_END - MOUSE_DRVR_START
+MOUSE_READ_OFS: .WORD   MOUSE_READ     - MOUSE_DRVR_START
+MOUSE_WRITE_OFS: .WORD  MOUSE_WRITE    - MOUSE_DRVR_START
+MOUSE_CTRL_OFS: .WORD   MOUSE_CTRL     - MOUSE_DRVR_START
+MOUSE_IRQ_OFS:  .WORD   MOUSE_IRQ      - MOUSE_DRVR_START
+MOUSE_DRVR_START:
+MOUSE_READ:
+MOUSE_WRITE:    SEC
+    RTS
+MOUSE_X:    .WORD   $0000
+MOUSE_Y:    .WORD   $0000
+MOUSE_STATUS:   .BYTE   $00
+MOUSE_CTRL: PHA
+    TYA
+    AND #$F8        ; MASK OFF SLOT #
+    CMP #MOUSECTL_CALLFW
+    BNE :+
+CALLMOUSEFW:    STX OPADDR
+XREGMOUSE2: LDX #$C4
+    STX OPADDR+1
+    LDY #$00
+    LDA (OPADDR),Y      ; GET ENTRYPOINT OFFSET
+    STA OPADDR
+YREGMOUSE2: LDY #$40
+    PLA
+    SEI
+    JMP (OPADDR)        ; CALL FIXED UP FUNCTION POINTER
+:   CMP #MOUSECTL_READMOUSE ; COPY MOUSE STATUS/POSITION INTO EASILY ACCESSIBLE MEMORY
+    BNE :+
+    PLA
+    TYA
+    AND #$07
+    TAX         ; SAVE MOUSE PARAMETERS
+    ASL
+    TAY
+    LDA LINK_DEVREAD,Y
+    STA TMPTR
+    LDA LINK_DEVREAD+1,Y
+    STA TMPTR+1
+    SEI
+    LDY #$02
+    LDA $0478,X
+    STA (TMPTR),Y
+    PHA
+    INY
+    LDA $0578,X
+    STA (TMPTR),Y
+    INY
+    LDA $04F8,X
+    STA (TMPTR),Y
+    PHA
+    INY
+    LDA $05F8,X
+    STA (TMPTR),Y
+    INY
+    LDA $0778,X
+    STA (TMPTR),Y
+    STA TMP
+    PLA
+    TAY
+    PLA
+    TAX
+    LDA TMP
+    RTS
+:   CMP #MOUSECTL_CLAMPX
+    BEQ :+
+    CMP #MOUSECTL_CLAMPY
+    BNE :++
+:   PLA
+    STA $04F8
+    STX $05F8
+    LDA #$00
+    STA $0478
+    STA $0578
+    TYA
+    LSR
+    LSR
+    LSR
+    AND #$01
+    PHA
+    LDX #$17        ; FW INDEX FOR CLAMPMOUSE
+    BNE CALLMOUSEFW
+SETMOUSE:   PHA
+    LDX #$12        ; FW INDEX FOR SETMOUSE
+    BNE CALLMOUSEFW
+:   PLA
+    TYA
+    AND #$F8        ; MASK OFF SLOT #
+    CMP #IOCTL_OPEN
+    BNE :+
+    LDA #<THREAD_YIELD      ; REMOVE SOFTWARE TIMER
+    STA LINK_YIELD
+    LDA #>THREAD_YIELD
+    STA LINK_YIELD+1
+    LDA #$0F        ; TURN MOUSE INTS ON
+    BNE SETMOUSE
+:   CMP #IOCTL_CLOSE
+    BNE :+
+    LDA #$08        ; TURN MOUSE OFF
+    BNE SETMOUSE
+:   CMP #IOCTL_DEACTIVATE
+    BNE :+
+    LDA #MOUSECTL_NOIRQ
+:   CMP #MOUSECTL_NOIRQ     ; UNINSTALL IRQ HANDLER
+    BNE :+
+    SEI
+    LDA #<SW_TIMER      ; RE-INSTALL SW TIMER
+    STA LINK_YIELD
+    LDA #>SW_TIMER
+    STA LINK_YIELD+1
+    BNE SETMOUSE
+:   CMP #IOCTL_ID
+    BEQ :+
+    SEC
+    RTS
+:   LDA #$20        ; MOUSE ID
+    CLC
+    RTS
+;
+; VBLANK TIMER AND MOUSE IRQ
+;
+MOUSE_IRQ:  STA TMP
+SERVEMOUSE: JSR $C400
+    BCS VBLEXIT     ; NOT MOUSE INT
+    LDY TMP     ; CHECK MOUSE INT CAUSE
+    LDA $0778,Y
+    PHA
+    AND #$08        ; WAS IT VLB?
+    BEQ MOUSEEXIT       ; NOPE, MOVE OR BUTTON
+VBLTIC: LDX #$00
+    LDA #$11        ; 17 MSEC (2/3 OF THE TIME)
+    DEC TIMERADJUST
+    BNE :+
+    LDA #$02
+    STA TIMERADJUST
+    LDA #$10        ; 16 MSEC (1/3 OF THE TIME)
+:   JSR SYSTEM_TIC
+MOUSEEXIT:  PLA
+    AND #$86        ; MOUSE MOVE OR BUTTON ACTIVE
+    BEQ VBLEXIT
+XREGMOUSE1: LDX #$C4
+YREGMOUSE1: LDY #$40
+READMOUSE:  JSR $C400       ; IIGS REQUIRES THIS HAPPEN IN IRQ
+    CLC
+    RTS
+VBLEXIT:    SEC
+    RTS
+MOUSE_DRVR_END  EQU *
+
+package apple2;
+/*
+ * This class interfaces directly with the mouse device driver.
+ */
+public class Mouse
+{
+    static private int slot, mouseSlot, mouseCtrl, ctrlRead, addrXPos, addrYPos;
+    static public  int xPos, yPos, status;
+
+    public static boolean enable()
+    {
+        //
+        // Search for mouse card and disable VBL interrupts
+        //
+        for (slot = 1; slot < 8; slot++)
+        {
+            int mouse = vm02.call((1 << 19), 0x90 + (slot << 1)); // ID device
+            if ((mouse & 0x010000FF) == 0x20) // CARRY clear == valid device IOCTL, 0x20 == mouse card ID
+            {
+                mouseCtrl  = 0x90 + (slot << 1);
+                mouseSlot  = slot << 16;
+                ctrlRead   = mouseSlot | 0x801400;
+                addrXPos   = vm02.peekWord(0x0370 + (slot << 1)) + 2;
+                addrYPos   = addrXPos + 2;
+                return (vm02.call(mouseSlot | (3 << 19), mouseCtrl) & 0x01000000) == 0; // open port
+            }
+        }
+        slot = 0;
+        return false;
+    }
+    public static void disable()
+    {
+        vm02.call(mouseSlot | (4<<19), mouseCtrl); // close port
+    }
+    public static void disableIRQ()
+    {
+        int vblSlot, vbl;
+        //
+        // Search for mouse card and disable/remove interrupts
+        //
+        for (vblSlot = 1; vblSlot < 8; vblSlot++)
+        {
+            vbl = vm02.call((1 << 19), 0x90 + (vblSlot << 1)); // ID device
+            if ((vbl & 0x010000FF) == 0x20) // CARRY clear == valid device IOCTL, 0x20 == mouse card ID
+            {
+                vm02.call((vblSlot << 16) | (17 << 19), 0x90 + (vblSlot << 1)); // MOUSECTL_UNVBL
+                break;
+            }
+        }
+    }
+    public static int slotMask()
+    {
+        return (1 << slot);
+    }
+    public static void update()
+    {
+        status = vm02.call(ctrlRead, mouseCtrl) & 0xFF; // CALL_FW ReadMouse
+        xPos   = vm02.peekWord(addrXPos);
+        yPos   = vm02.peekWord(addrYPos);
+    }
+}

src/libsrc/apple/shrlib.pla

@@ -0,0 +1,181 @@
+include "inc/cmdsys.plh"
+//
+// Apple II hardware constants.
+//
+const store80dis    = $C000
+const store80en     = $C001
+const vidctl        = $C029
+const showgraphics  = $C050
+const showtext      = $C051
+const showfull      = $C052
+const showmix       = $C053
+const showpage1     = $C054
+const showpage2     = $C055
+const showlores     = $C056
+const showhires     = $C057
+const show40        = $C00C
+const show80        = $C00D
+const mapmain       = $C000
+const mapaux        = $C001
+const an3on         = $C05E
+const an3off        = $C05F
+const ena80         = $C07E
+const dis80         = $C07F
+const pixbuf        = $2000
+const scbbuf        = $9D00
+const palbuf        = $9E00
+const scb640        = $80       // 640 PIXEL SUPER-HIRES
+const scb320        = $00       // 320 PIXEL SUPER-HIRES
+
+word palette = $0000, $0007, $0070, $0077, $0700, $0707, $0770, $0
+word         = $0CCC, $000F, $00F0, $00FF, $0F00, $0F0F, $0FF0, $0FFF
+
+
+asm shrInc(buff)
+!SOURCE    "vmsrc/plvmzp.inc"
+GBASL    =      $26
+GBASH    =      $27
+GBASE    =      GBASL
+GCLR     =      $30
+STORE80DIS =    $C000
+STORE80EN =	    $C001
+MAINWRT =       $C004
+AUXWRT  =       $C005
+VIDCTL  =       $C029
+SHADOW  =       $C035
+end
+//
+// This gets copied to $0100!!!
+//
+asm auxRead
+        STA     $C003       ; READ AUX MEM
+        LDA     (GBASE),Y
+        STA     $C002       ; READ MAIN MEM
+        RTS
+end
+//
+// Peek byte from SHR memory
+//
+asm shrPeek(addr)
+        LDA     ESTKL,X
+        STA     GBASL
+        LDA     ESTKH,X
+        STA     GBASH
+        LDY     #$00
+        STY     ESTKH,X
+        PHP
+        SEI
+        LDA     SHADOW
+        AND     #$F7
+        STA     SHADOW
+        JSR     $0100
+        STA     ESTKL,X
+        LDA     SHADOW
+        ORA     #$08
+        STA     SHADOW
+        PLP
+        RTS
+end
+//
+// Poke byte into SHR memory
+//
+asm shrPoke(addr, data)#0
+        LDA     ESTKL+1,X
+        STA     GBASL
+        LDA     ESTKH+1,X
+        STA     GBASH
+        LDY     #$00
+        PHP
+        SEI
+        LDA     SHADOW
+        AND     #$F7
+        STA     SHADOW
+        LDA     ESTKL+0,X
+        STA     AUXWRT
+        STA     (GBASE),Y
+        STA     MAINWRT
+        LDA     SHADOW
+        ORA     #$08
+        STA     SHADOW
+        PLP
+        INX
+        INX
+        RTS
+end
+//
+// Fill byte into SHR memory
+//
+asm shrFill(addr, data, len)#0
+        LDA     ESTKL+2,X
+        STA     GBASL
+        LDA     ESTKH+2,X
+        STA     GBASH
+        LDY     #$00
+        PHP
+        SEI
+        LDA     SHADOW
+        AND     #$F7
+        STA     SHADOW
+        LDA     ESTKL+1,X
+        STA     AUXWRT
+-       STA     (GBASE),Y
+        INY
+        BNE     +
+        INC     GBASH
++       DEC     ESTKL+0,X
+        BNE     -
+        DEC     ESTKH+0,X
+        BNE     -
+        STA     MAINWRT
+        LDA     SHADOW
+        ORA     #$08
+        STA     SHADOW
+        PLP
+        INX
+        INX
+        RTS
+end
+export def shrPalette(pal, rgbptr)#0
+    word palptr
+    byte i
+    
+    palptr = palbuf + pal * 32
+    for i = 0 to 31
+        shrPoke(palptr + i, ^(rgbptr + i))
+    next
+end
+export def shrMode(mode)#0
+    byte row, scb
+    if mode
+        //
+        // Set super hires graphics
+        //
+        if mode == 640
+            scb = scb640
+        else
+            scb = scb320
+        fin
+        for row = 0 to 199
+            shrPoke(scbbuf + row, scb)
+            shrRowPalette(row, palette)
+        next
+        ^store80dis = 0 // Turn off 80 column mode
+        ^vidctl = ^vidctl | $80 // Turn on SHR mode
+        return
+    fin
+    //
+    // Set text mode
+    //
+    ^vidctl = ^vidctl & $7F
+    ^showtext
+    ^showpage1
+    ^ena80   = 0
+    ^show40  = 0
+    ^mapmain = 0
+    ^an3off
+    call($FC58, 0, 0, 0, 0) // home()
+end
+
+// Put read AUX mem routine in scary location
+memcpy($0100, @auxRead, 9)
+done

src/libsrc/apple/sndseq.pla

@@ -305,7 +305,7 @@ TONELP  SBC     #$01        ; 2
                             ;+4 = 11 (from BNE above)
 
 +++     BIT     $C000       ; 4
-        BMI     TONEXIT     ; 2
+        NOP                 ; 2
         BPL     TONELP      ; 3
                             ;---
                             ;+9 = 20

src/libsrc/apple/uthernet.pla

@@ -11,10 +11,10 @@ end
 //
 // Uthernet register offsets
 //
-const TX_DATA     = $00
-const RX_DATA     = $00
-const TX_CMD      = $04
-const TX_LEN      = $06
+const TX_DATA    = $00
+const RX_DATA    = $00
+const TX_CMD     = $04
+const TX_LEN     = $06
 const INT_STATUS = $08
 const PREG_INDEX = $0A
 const PREG_DATA  = $0C
@@ -22,13 +22,14 @@ const AUTO_INC   = $8000
 //
 // Uthernet register addresses
 //
-byte[] slot // Init time only
 byte rxdata_lo, rxdata_hi
 byte txcmd
 byte txlen
 byte isq
+word rom[]
 byte pregidx
 byte pregdata
+byte[] slot // Init time only
 //
 // Uthernet MAC address
 //
@@ -37,156 +38,155 @@ byte[6] utherMAC = $00,$0A,$99,$1E,$02,$A0
 // Defines for ASM routines
 //
 asm equates
-    !SOURCE    "vmsrc/plvmzp.inc"
+        !SOURCE "vmsrc/plvmzp.inc"
 end
 //
 // Uthernet I/O functions
 //
-asm _pokeiow(val)
-    LDA    ESTKL,X
+asm _pokeiow(val)#0
+        LDA     ESTKL,X
 end
 asm _pokeiowl
-    STA    $C000
-    LDA    ESTKH,X
+        STA     $C000
+        LDA     ESTKH,X
 end
 asm _pokeiowh
-    STA    $C000
-    RTS
+        STA     $C000
+        INX
+        RTS
 end
 //
 // PEEK BYTE FROM I/O SPACE
 // _peekio()
 //
-asm _peekio
-    DEX
+asm _peekio#1
+        DEX
 end
 asm _peekiol
-    LDA    $C000
-    STA    ESTKL,X
-    LDA    #$00
-    STA    ESTKH,X
-    RTS
+        LDA     $C000
+        STA     ESTKL,X
+        LDA     #$00
+        STA     ESTKH,X
+        RTS
 end
 //
 // PEEK WORD FROM I/O SPACE
 // _peekiow()
 //
-asm _peekiow
-    DEX
+asm _peekiow#1
+        DEX
 end
 asm _peekiowl
-    LDA    $C000
-    STA    ESTKL,X
+        LDA     $C000
+        STA     ESTKL,X
 end
 asm _peekiowh
-    LDA    $C000
-    STA    ESTKH,X
-    RTS
+        LDA     $C000
+        STA     ESTKH,X
+        RTS
 end
 //
 // WRITE FRAME DATA INTO I/O SPACE
 // pokefrm(BUF, LEN)
 //
-asm pokefrm(buf, len)
-    LDY    #$00
-    LDA    ESTKL+1,X
-    STA    SRCL
-    LDA    ESTKH+1,X
-    STA    SRCH
-    LSR    ESTKH,X    ; CONVERT BYTE LEN TO WORD LEN
-    LDA    ESTKL,X
-    ROR
-    ADC    #$00
-    STA    ESTKL,X
-    BEQ     +
-    !BYTE   $A9
--   CLC
-    INC     ESTKH,X
-+   BCS    -
-POKELP    LDA    (SRC),Y
+asm pokefrm(buf, len)#1
+        LDY     #$00
+        LDA     ESTKL+1,X
+        STA     SRCL
+        LDA     ESTKH+1,X
+        STA     SRCH
+        LSR     ESTKH,X     ; CONVERT BYTE LEN TO WORD LEN
+        LDA     ESTKL,X
+        ROR
+        ADC     #$00
+        STA     ESTKL,X
+        BEQ     +
+        INC     ESTKH,X
++       BCC     POKELP
+        INC     ESTKH,X
+POKELP  LDA     (SRC),Y
 end
 asm _pokefrml
-    STA    $C000
-    INY
-    LDA    (SRC),Y
+        STA     $C000
+        INY
+        LDA     (SRC),Y
 end
 asm _pokefrmh
-    STA    $C000
-    INY
-    BNE    +
-    INC    SRCH
-+   DEC    ESTKL,X
-    BNE    POKELP
-    DEC    ESTKH,X
-    BNE    POKELP
-    INX
-    RTS
+        STA     $C000
+        INY
+        BNE     +
+        INC     SRCH
++       DEC     ESTKL,X
+        BNE     POKELP
+        DEC     ESTKH,X
+        BNE     POKELP
+        INX
+        RTS
 end
 //
 // READ FRAME DATA FROM I/O SPACE
 // peekfrm(BUF, LEN)
 //
-asm peekfrm(buf, len)
-    LDY    #$00
-    LDA    ESTKL+1,X
-    STA    DSTL
-    LDA    ESTKH+1,X
-    STA    DSTH
-    LSR    ESTKH,X    ; CONVERT BYTE LEN TO WORD LEN
-    LDA    ESTKL,X
-    ROR
-    ADC    #$00
-    STA    ESTKL,X
-    BEQ    +
-    !BYTE  $A9
--   CLC
-    INC    ESTKH,X
-+   BCS    -
+asm peekfrm(buf, len)#1
+        LDY     #$00
+        LDA     ESTKL+1,X
+        STA     DSTL
+        LDA     ESTKH+1,X
+        STA     DSTH
+        LSR     ESTKH,X     ; CONVERT BYTE LEN TO WORD LEN
+        LDA     ESTKL,X
+        ROR
+        ADC     #$00
+        STA     ESTKL,X
+        BEQ     +
+        INC     ESTKH,X
++       BCC     PEEKLP
+        INC     ESTKH,X
 end
 asm _peekfrml
-PEEKLP     LDA    $C000
-    STA    (DST),Y
-    INY
+PEEKLP  LDA     $C000
+        STA     (DST),Y
+        INY
 end
 asm _peekfrmh
-+    LDA    $C000
-    STA    (DST),Y
-    INY
-    BNE    +
-    INC    DSTH
-+   DEC    ESTKL,X
-    BNE    PEEKLP
-    DEC    ESTKH,X
-    BNE    PEEKLP
-EXPSW    INX
-    RTS
+        LDA     $C000
+        STA     (DST),Y
+        INY
+        BNE     +
+        INC     DSTH
++       DEC     ESTKL,X
+        BNE     PEEKLP
+        DEC     ESTKH,X
+        BNE     PEEKLP
+EXPSW   INX
+        RTS
 end
-def pokeiow(io, data)
+def pokeiow(io, data)#0
     _pokeiowl.1 = io
     _pokeiowh.1 = io+1
-    return _pokeiow(data)
+    _pokeiow(data)
 end
-def peekio(io)
+def peekio(io)#1
     _peekiol.1 = io
     return _peekio()
 end
-def peekiow(io)
+def peekiow(io)#1
     _peekiowl.1 = io
     _peekiowh.1 = io+1
     return _peekiow()
 end
-def pokepreg(reg, data)
+def pokepreg(reg, data)#0
     pokeiow(pregidx, reg)
-    return pokeiow(pregdata, data)
+    pokeiow(pregdata, data)
 end
-def peekpreg(reg)
+def peekpreg(reg)#1
     pokeiow(pregidx, reg)
     return peekiow(pregdata)
 end
 //
 // Set the length of the next packet to send and wait for data space availability
 //
-def pokefrmlen(len)
+def pokefrmlen(len)#1
     pokeiow(txcmd, $C0)
     pokeiow(txlen, len)
     repeat; until peekpreg($0138) & $0100
@@ -195,7 +195,7 @@ end
 //
 // Return the length of awaiting packet, 0 otherwise
 //
-def peekfrmlen
+def peekfrmlen#1
     word len
     len = 0
     if peekiow(isq) & $3F == $04
@@ -214,35 +214,37 @@ end
 // Identify Uthernet card and initialize
 //
 for slot = $90 to $F0 step $10
-    if (peekiow(slot+TX_CMD) & $CC3F) == $09
-        pokeiow(slot+PREG_INDEX, 0)
-        if peekiow(slot+PREG_DATA) == $630E
-            pokepreg($0114, $40)   // RESET
-            rxdata_hi   = slot + 1
-            txcmd       = slot + TX_CMD
-            txlen       = slot + TX_LEN
-            isq         = slot + INT_STATUS
-            pregidx     = slot + PREG_INDEX
-            pregdata    = slot + PREG_DATA
-            _pokefrml.1 = slot
-            _pokefrmh.1 = slot+1
-            _peekfrml.1 = slot
-            _peekfrmh.1 = slot+1
-            pokepreg($0158, utherMAC:0) // MAC addr
-            pokepreg($015A, utherMAC:2) // MAC addr
-            pokepreg($015C, utherMAC:4) // MAC addr
-            pokepreg($0102, $0100) // Recv cfg
-            pokepreg($0104, $0D00) // Recv ctrl
-            pokepreg($0106, $8200) // Xmit cfg
-            pokepreg($0112, $00C0) // Line ctrl
-            //
-            // Install etherip driver
-            //
-            puts("Found Uthernet I in slot #")
-            putc('0' + ((slot - $80) >> 4))
-            putln
-            setEtherDriver(@utherMAC, @peekfrmlen, @peekfrm, @pokefrmlen, @pokefrm)
-            return modkeep
+    rom = ((slot & $70) << 4) | $C000
+    if rom=>$06 <> $3C86 or (slot == $0B or (rom->$05 <> $38 and rom->$07 <> $18)) // Skip slots with signature
+        if (peekiow(slot+TX_CMD) & $CC3F) == $0009
+            pokeiow(slot+PREG_INDEX, 0)
+            if peekiow(slot+PREG_DATA) == $630E
+                pregidx     = slot + PREG_INDEX
+                pregdata    = slot + PREG_DATA
+                pokepreg($0114, $40)        // RESET
+                rxdata_lo   = slot + RX_DATA
+                rxdata_hi   = slot + RX_DATA + 1
+                txcmd       = slot + TX_CMD
+                txlen       = slot + TX_LEN
+                isq         = slot + INT_STATUS
+                _pokefrml.1 = slot + TX_DATA
+                _pokefrmh.1 = slot + TX_DATA + 1
+                _peekfrml.1 = slot + RX_DATA
+                _peekfrmh.1 = slot + RX_DATA + 1
+                pokepreg($0158, utherMAC:0) // MAC addr
+                pokepreg($015A, utherMAC:2) // MAC addr
+                pokepreg($015C, utherMAC:4) // MAC addr
+                pokepreg($0102, $0100)      // Recv cfg
+                pokepreg($0104, $0D00)      // Recv ctrl
+                pokepreg($0106, $8200)      // Xmit cfg
+                pokepreg($0112, $00C0)      // Line ctrl
+                //
+                // Install etherip driver
+                //
+                puts("Found Uthernet I in slot #"); putc('0' + ((slot - $80) >> 4)); putln
+                setEtherDriver(@utherMAC, @peekfrmlen, @peekfrm, @pokefrmlen, @pokefrm)
+                return modkeep
+            fin
         fin
     fin
 next

src/libsrc/apple/uthernet2.pla

@@ -71,10 +71,11 @@ const WIZ_RXMEM3 = $7800
 //
 // Wiznet indirect registers
 //
-byte slot
-word saveidx
-byte regidx
-byte regdata
+word[] rom
+word   saveidx
+byte   regidx
+byte   regdata
+byte   slot
 //
 // Wiznet MAC address
 //
@@ -137,16 +138,15 @@ word bcast = IP_BROADCAST, IP_BROADCAST
 //
 // ICMP type/codes
 //
-const IP_PROTO_ICMP   = 1
 const ICMP_ECHO_REQST = 8
 const ICMP_ECHO_REPLY = 0
 //
 // ICMP message format
 //
 struc t_icmp
-    byte icmp_type
-    byte icmp_code
-    word icmp_chksm
+    byte    icmp_type
+    byte    icmp_code
+    word    icmp_chksm
     word[2] icmp_header
 end
 //
@@ -155,9 +155,9 @@ end
 struc t_piphdr
     byte[IP4ADR_SIZE] pip_src
     byte[IP4ADR_SIZE] pip_dst
-    byte             pip_zero
-    byte             pip_proto
-    word             pip_len
+    byte              pip_zero
+    byte              pip_proto
+    word              pip_len
 end
 //
 // UDP header
@@ -184,11 +184,11 @@ const MAX_WIZ_CHANNELS  = 4
 //
 // Channel protocols
 //
-const WIZ_PROTO_CLOSED     = 0
-const WIZ_PROTO_TCP        = 1
-const WIZ_PROTO_UDP    = 2
-const WIZ_PROTO_IP     = 3
-const WIZ_PROTO_RAW    = 4
+const WIZ_PROTO_CLOSED  = 0
+const WIZ_PROTO_TCP     = 1
+const WIZ_PROTO_UDP     = 2
+const WIZ_PROTO_IP      = 3
+const WIZ_PROTO_RAW     = 4
 //
 // State transistions
 //
@@ -212,7 +212,7 @@ struc t_channel
     word    channel_recv_func
     word    channel_recv_parm
 end
-byte[t_channel * MAX_WIZ_CHANNELS] wizChannel
+byte[t_channel] wizChannel[MAX_WIZ_CHANNELS]
 //
 // Service ICMP hook
 //
@@ -221,17 +221,17 @@ export word hookICMP
 // Defines for ASM routines
 //
 asm equates
-    !SOURCE "vmsrc/plvmzp.inc"
+        !SOURCE "vmsrc/plvmzp.inc"
 end
 //
 // Swap bytes in word
 //
 asm swab(val)
-    LDA ESTKL,X
-    LDY ESTKH,X
-    STA ESTKH,X
-    STY ESTKL,X
-    RTS
+        LDA     ESTKL,X
+        LDY     ESTKH,X
+        STA     ESTKH,X
+        STY     ESTKL,X
+        RTS
 end
 //
 // Wiznet I/O functions
@@ -239,118 +239,122 @@ end
 // POKE WORD TO I/O SPACE
 // Note: Big Endian format
 //
-asm _pokeiow(val)
-    LDA ESTKH,X
+asm _pokeiow(val)#0
+        LDA     ESTKH,X
 end
 asm _pokeiowl
-    STA $C000
-    LDA ESTKL,X
+        STA     $C000
+        LDA     ESTKL,X
 end
 asm _pokeiowh
-    STA $C000
-    RTS
+        STA     $C000
+        INX
+        RTS
 end
 //
 // POKE BYTE TO I/O SPACE
 //
-asm _pokeio(val)
-    LDA ESTKL,X
+asm _pokeio(val)#0
+        LDA     ESTKL,X
 end
 asm _pokeiol
-    STA $C000
-    RTS
+        STA     $C000
+        INX
+        RTS
 end
 //
 // PEEK BYTE FROM I/O SPACE
 //
 asm _peekio
-    DEX
+        DEX
 end
 asm _peekiol
-    LDA $C000
-    STA ESTKL,X
-    LDA #$00
-    STA ESTKH,X
-    RTS
+        LDA     $C000
+        STA     ESTKL,X
+        LDA     #$00
+        STA     ESTKH,X
+        RTS
 end
 //
 // PEEK WORD FROM I/O SPACE
 // Note: Big Endian format
 //
 asm _peekiow
-    DEX
+        DEX
 end
 asm _peekiowl
-    LDA $C000
-    STA ESTKH,X
+        LDA     $C000
+        STA     ESTKH,X
 end
 asm _peekiowh
-    LDA $C000
-    STA ESTKL,X
-    RTS
+        LDA     $C000
+        STA     ESTKL,X
+        RTS
 end
 //
 // WRITE DATA INTO I/O SPACE
 // pokedata(BUF, LEN)
 //
-asm pokedata(buf, len)
-    LDA ESTKL+1,X
-    STA SRCL
-    LDA ESTKH+1,X
-    STA SRCH
-    LDY     ESTKL,X
-    BEQ POKELP
-    LDY #$00
-    INC     ESTKH,X
-POKELP  LDA (SRC),Y
+asm pokedata(buf, len)#0
+        LDA     ESTKL+1,X
+        STA     SRCL
+        LDA     ESTKH+1,X
+        STA     SRCH
+        LDY     ESTKL,X
+        BEQ     POKELP
+        LDY     #$00
+        INC     ESTKH,X
+POKELP  LDA     (SRC),Y
 end
 asm _pokedata
-    STA $C000
-    INY
-    BNE +
-        INC SRCH
-+   DEC ESTKL,X
-    BNE POKELP
-    DEC ESTKH,X
-    BNE POKELP
-    INX
-    RTS
+        STA     $C000
+        INY
+        BNE     +
+        INC     SRCH
++       DEC     ESTKL,X
+        BNE     POKELP
+        DEC     ESTKH,X
+        BNE     POKELP
+        INX
+        INX
+        RTS
 end
 //
 // READ DATA FROM I/O SPACE
 // peekdata(BUF, LEN)
 //
-asm peekdata(buf, len)
-    LDA ESTKL+1,X
-    STA DSTL
-    LDA ESTKH+1,X
-    STA DSTH
-    LDY ESTKL,X
-    BEQ PEEKLP
-    LDY #$00
-    INC     ESTKH,X
+asm peekdata(buf, len)#0
+        LDA     ESTKL+1,X
+        STA     DSTL
+        LDA     ESTKH+1,X
+        STA     DSTH
+        LDY     ESTKL,X
+        BEQ     PEEKLP
+        LDY     #$00
+        INC     ESTKH,X
 end
 asm _peekdata
-PEEKLP  LDA $C000
-    STA (DST),Y
-    INY
-    BNE +
-        INC DSTH
-+   DEC ESTKL,X
-    BNE PEEKLP
-    DEC ESTKH,X
-    BNE PEEKLP
-    INX
-    RTS
+PEEKLP  LDA     $C000
+        STA     (DST),Y
+        INY
+        BNE     +
+        INC     DSTH
++       DEC     ESTKL,X
+        BNE     PEEKLP
+        DEC     ESTKH,X
+        BNE     PEEKLP
+        INX
+        INX
+        RTS
 end
-def pokeiow(io, data)
+def pokeiow(io, data)#0
     _pokeiowl.1 = io
     _pokeiowh.1 = io+1
-    return _pokeiow(data)
+    _pokeiow(data)
 end
-def pokeio(io, data)
+def pokeio(io, data)#0
     _pokeiol.1 = io
-    return _pokeio(data)
+    _pokeio(data)
 end
 def peekio(io)
     _peekiol.1 = io
@@ -361,26 +365,26 @@ def peekiow(io)
     _peekiowh.1 = io+1
     return _peekiow()
 end
-def pokereg(reg, data)
+def pokereg(reg, data)#0
     _pokeiow(reg)
-    return _pokeio(data)
+    _pokeio(data)
 end
 def peekreg(reg)
     _pokeiow(reg)
     return _peekio()
 end
-def pokeregs(reg, buf, len)
+def pokeregs(reg, buf, len)#0
     _pokeiow(reg)
-    return pokedata(buf, len)
+    pokedata(buf, len)
 end
-def peekregs(reg, buf, len)
+def peekregs(reg, buf, len)#0
     _pokeiow(reg)
-    return peekdata(buf, len)
+    peekdata(buf, len)
 end
-def pokeregw(reg, dataw)
+def pokeregw(reg, dataw)#0
     _pokeiow(reg)
     _pokeio(dataw.1)
-    return _pokeio(dataw.0)
+    _pokeio(dataw.0)
 end
 def peekregw(reg)
     word dataw
@@ -415,7 +419,7 @@ def wizSendUDP(wiz, ipdst, portdst, data, len)
         splitlen = WIZ_TXSIZE - txrr
         pokeregs(wizdata + txrr, data,            splitlen)
         pokeregs(wizdata,        data + splitlen, len - splitlen)
-     else
+    else
         pokeregs(wizdata + txrr, data, len)
     fin
     //
@@ -470,9 +474,9 @@ def wizOpenUDP(localport, callback, param)
     wiz=>channel_lclport   = localport
     wiz=>channel_recv_func = callback
     wiz=>channel_recv_parm = param
+    pokereg(wiz=>channel_regs  + WIZ_SnMR,   $02) // UDP protocol
     pokeregw(wiz=>channel_regs + WIZ_SnPORT, localport)
-    pokereg(wiz=>channel_regs + WIZ_SnMR, $02) // UDP protocol
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
+    pokereg(wiz=>channel_regs  + WIZ_SnCR,   $01) // OPEN
     return wiz
 end
 //
@@ -480,14 +484,14 @@ end
 //
 def wizCloseUDP(wiz)
     if isuge(wiz, @wizChannel) and isult(wiz, @wizChannel + MAX_WIZ_CHANNELS * t_channel)
-    //
-    // Clear notiications on this port
-    //
+        //
+        // Clear notiications on this port
+        //
         if wiz->channel_proto == WIZ_PROTO_UDP
             wiz->channel_proto = WIZ_PROTO_CLOSED
             pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-        return 0
-    fin
+            return 0
+        fin
     fin
     //
     // Invalid port
@@ -508,8 +512,8 @@ def wizListenTCP(lclport, callback, param)
     for i = 1 to MAX_WIZ_CHANNELS
         if wiz->channel_proto == WIZ_PROTO_TCP and wiz->channel_state == TCP_STATE_LISTEN and wiz=>channel_lclport == lclport
             break
-    fin
-    wiz = wiz + t_channel
+        fin
+        wiz = wiz + t_channel
     next
     if i > MAX_WIZ_CHANNELS
         //
@@ -519,8 +523,8 @@ def wizListenTCP(lclport, callback, param)
         for i = 1 to MAX_WIZ_CHANNELS
             if !wiz->channel_proto
                 break
-        fin
-        wiz = wiz + t_channel
+            fin
+            wiz = wiz + t_channel
         next
         if i > MAX_WIZ_CHANNELS
             return 0
@@ -537,9 +541,9 @@ def wizListenTCP(lclport, callback, param)
     wiz=>channel_lclport   = lclport
     wiz=>channel_recv_func = callback
     wiz=>channel_recv_parm = param
-    pokereg(wiz=>channel_regs + WIZ_SnMR, $01) // TCP protocol
+    pokereg(wiz=>channel_regs  + WIZ_SnMR,   $01) // TCP protocol
     pokeregw(wiz=>channel_regs + WIZ_SnPORT, lclport)
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
+    pokereg(wiz=>channel_regs  + WIZ_SnCR,   $01) // OPEN
     while peekreg(wiz=>channel_regs + WIZ_SnSR) <> $13; loop // Wait for init
     pokereg(wiz=>channel_regs + WIZ_SnCR, $02) // LISTEN
     return wiz
@@ -619,7 +623,7 @@ def wizSendTCP(wiz, data, len)
         pokeregs(wizdata + txrr, data,            splitlen)
         pokeregs(wizdata,        data + splitlen, len - splitlen)
         //putc('(');puti(splitlen);putc(',');puti(len-splitlen);putc(')')
-     else
+    else
         pokeregs(wizdata + txrr, data, len)
     fin
     //
@@ -634,9 +638,9 @@ end
 //
 def wizCloseTCP(wiz)
     if isuge(wiz, @wizChannel) and isult(wiz, @wizChannel + MAX_WIZ_CHANNELS * t_channel)
-    //
-    // Clear notiications on this port
-    //
+        //
+        // Clear notiications on this port
+        //
         if wiz->channel_proto == WIZ_PROTO_TCP
             pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
             wiz->channel_proto = WIZ_PROTO_CLOSED
@@ -670,10 +674,10 @@ end
 def wizSetParam(wiz, param)
     if wiz->channel_proto == WIZ_PROTO_UDP or wiz->channel_proto == WIZ_PROTO_TCP
         //
-    // Update param on this port
-    //
-    wiz=>channel_recv_parm = param
-    return 0
+        // Update param on this port
+        //
+        wiz=>channel_recv_parm = param
+        return 0
     fin
     //
     // Invalid port
@@ -698,7 +702,7 @@ def wizServiceIP
                 wizregs = wiz=>channel_regs
                 wizdata = wiz=>channel_rxmem
                 sir = peekreg(wizregs + WIZ_SnIR)
-                pokereg(wiz=>channel_regs + WIZ_SnIR, sir) // Clear SnIR
+                pokereg(wizregs + WIZ_SnIR, sir) // Clear SnIR
                 when wiz->channel_proto
                     is WIZ_PROTO_UDP
                         if sir & $04
@@ -735,63 +739,63 @@ def wizServiceIP
                                     wiz->channel_state = TCP_STATE_OPEN
                             wend
                         fin
-                    if sir & $04
-                        //
-                        // Receive TCP packet
-                        //
-                        if wiz->channel_state == TCP_STATE_OPEN
-                            rxlen = peekregw(wizregs + WIZ_SnRSR)
-                            rxrr  = peekregw(wizregs + WIZ_SnRXRD)
-                            rxwr  = rxrr & WIZ_RXMASK
-                            rxpkt = heapalloc(rxlen)
-                            if rxwr + rxlen > WIZ_RXSIZE
-                                splitlen = WIZ_RXSIZE - rxwr
-                                peekregs(wizdata + rxwr, rxpkt,            splitlen)
-                                peekregs(wizdata,        rxpkt + splitlen, rxlen - splitlen)
-                            else
-                                peekregs(wizdata + rxwr, rxpkt, rxlen)
+                        if sir & $04
+                            //
+                            // Receive TCP packet
+                            //
+                            if wiz->channel_state == TCP_STATE_OPEN
+                                rxlen = peekregw(wizregs + WIZ_SnRSR)
+                                rxrr  = peekregw(wizregs + WIZ_SnRXRD)
+                                rxwr  = rxrr & WIZ_RXMASK
+                                rxpkt = heapalloc(rxlen)
+                                if rxwr + rxlen > WIZ_RXSIZE
+                                    splitlen = WIZ_RXSIZE - rxwr
+                                    peekregs(wizdata + rxwr, rxpkt,            splitlen)
+                                    peekregs(wizdata,        rxpkt + splitlen, rxlen - splitlen)
+                                else
+                                    peekregs(wizdata + rxwr, rxpkt, rxlen)
+                                fin
+                                pokeregw(wizregs + WIZ_SnRXRD, rxrr + rxlen)
+                                pokereg(wizregs + WIZ_SnCR, $40) // RECV
+                                wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,rxpkt,rxlen,wiz=>channel_recv_parm)
+                                heaprelease(rxpkt)
                             fin
-                            pokeregw(wizregs + WIZ_SnRXRD, rxrr + rxlen)
-                            pokereg(wizregs + WIZ_SnCR, $40) // RECV
-                            wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,rxpkt,rxlen,wiz=>channel_recv_parm)
-                            heaprelease(rxpkt)
                         fin
-                    fin
-                    if sir & $02
-                        //
-                        // Close TCP socket
-                        //
-                        if wiz->channel_state == TCP_STATE_OPEN // Notify callback w/ len = 0
-                            wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,0,wiz=>channel_lclport,0,wiz=>channel_recv_parm)
+                        if sir & $02
+                            //
+                            // Close TCP socket
+                            //
+                            if wiz->channel_state == TCP_STATE_OPEN // Notify callback w/ len = 0
+                                wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,0,wiz=>channel_lclport,0,wiz=>channel_recv_parm)
+                            fin
+                            wiz->channel_state = TCP_STATE_CLOSED
+                            pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
+                        fin
+                        if sir & $08
+                            //
+                            // Timeout on TCP socket
+                            //
+                            when wiz->channel_state
+                                is TCP_STATE_OPEN
+                                    wiz->channel_state = TCP_STATE_CLOSING
+                                    wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
+                                    break
+                                is TCP_STATE_CONNECT
+                                    wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
+                                is TCP_STATE_CLOSING
+                                    wiz->channel_state = TCP_STATE_CLOSED
+                                    pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
+                            wend
                         fin
-                        wiz->channel_state = TCP_STATE_CLOSED
-                        pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-                    fin
-                    if sir & $08
-                        //
-                        // Timeout on TCP socket
-                        //
-                        when wiz->channel_state
-                            is TCP_STATE_OPEN
-                                wiz->channel_state = TCP_STATE_CLOSING
-                                wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
-                                break
-                            is TCP_STATE_CONNECT
-                                wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
-                            is TCP_STATE_CLOSING
-                                wiz->channel_state = TCP_STATE_CLOSED
-                                pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-                        wend
-                    fin
                 wend
             fin
             wiz = wiz + t_channel
         next
-    if ir & $80
+        if ir & $80
             //
-        // IP conflict
-        //
-        pokereg(WIZ_IR, $80)
+            // IP conflict
+            //
+            pokereg(WIZ_IR, $80)
         fin
         if ir & $40
             //
@@ -839,71 +843,77 @@ end
 // Identify Uthernet II card and initialize
 //
 for slot = $90 to $F0 step $10
-    regdata = peekio(slot)
-    if (regdata & $E4) == $00
-        pokeio(slot, $03) // Try setting auto-increment indirect I/F
-        if peekio(slot) == $03
-            saveidx = peekiow(slot + 1)
-            peekio(slot + 3) // Dummy read to data register should increment index
-            if peekiow(slot + 1) == saveidx + 1
-                //
-                // Good chance this is it
-                //
-                pokeio(slot, $80) // RESET
-                regidx      = slot + 1
-                regdata     = slot + 3
-                _pokedata.1 = regdata
-                _peekdata.1 = regdata
-                pokeio(slot, $03) // Auto-increment indirect I/F + enable ping
-                //
-                // The following looks redundant, but it sets up the peek/poke locations
-                // for peekreg(s)/pokereg(s)
-                //
-                pokeiow(regidx, WIZ_MR)
-                pokeio(regdata, $03) // Auto-increment indirect I/F + enable ping
-                peekio(regdata)
-                //
-                // Initialize common registers
-                //
-                pokeregs(WIZ_SHAR, @wizMAC, 6) // MAC addr
-                pokeregw(WIZ_RTR, 5000)        // Timeout period to 500ms
-                pokereg(WIZ_RMSR, $55)         // 2K Rx memory/channel
-                pokereg(WIZ_TMSR, $55)         // 2K Tx memory/channel
-                //
-                // Print settings
-                //
-                puts("Found Uthernet II in slot #")
-                putc('0' + ((slot - $80) >> 4))
-                putln
-                //
-                // Fill channel structure
-                //
-                saveidx = @wizChannel
-                for slot = 0 to 3
-                    saveidx=>channel_regs  = WIZ_SREGS + (WIZ_SSIZE  * slot)
-                    saveidx=>channel_txmem = WIZ_TXMEM + (WIZ_TXSIZE * slot)
-                    saveidx=>channel_rxmem = WIZ_RXMEM + (WIZ_RXSIZE * slot)
-                    saveidx = saveidx + t_channel
-                next
-                //
-                // Fill in Net class
-                //
-                iNet:serviceIP      = @wizServiceIP
-                iNet:openUDP        = @wizOpenUDP
-                iNet:sendUDP        = @wizSendUDP
-                iNet:closeUDP       = @wizCloseUDP
-                iNet:listenTCP      = @wizListenTCP
-                iNet:connectTCP     = @wizConnectTCP
-                iNet:sendTCP        = @wizSendTCP
-                iNet:closeTCP       = @wizCloseTCP
-                iNet:setInterfaceIP = @setWizIP
-                iNet:getInterfaceHA = @getWizHA
-                iNet:setCallback    = @wizSetCallback
-                iNet:setParam       = @wizSetParam
-                return modkeep
+    rom = ((slot & $70) << 4) | $C000
+    if rom=>$06 <> $3C86 or (slot == $0B or (rom->$05 <> $38 and rom->$07 <> $18)) // Skip slots with signature
+        regdata = peekio(slot)
+        if (regdata & $E4) == $00
+            pokeio(slot, $03) // Try setting auto-increment indirect I/F
+            if peekio(slot) == $03
+                saveidx = peekiow(slot + 1)
+                peekio(slot + 3) // Dummy read to data register should increment index
+                if peekiow(slot + 1) == saveidx + 1
+                    //
+                    // Good chance this is it
+                    //
+                    pokeio(slot, $80) // RESET
+                    regidx      = slot + 1
+                    regdata     = slot + 3
+                    _pokedata.1 = regdata
+                    _peekdata.1 = regdata
+                    repeat
+                        pokeio(slot, $03) // Auto-increment indirect I/F + enable ping
+                    until peekio(slot) == $03
+                    //
+                    // The following looks redundant, but it sets up the peek/poke locations
+                    // for peekreg(s)/pokereg(s)
+                    //
+                    pokeiow(regidx, WIZ_MR)
+                    pokeio(regdata, $03) // Auto-increment indirect I/F + enable ping
+                    peekio(regdata)
+                    //
+                    // Initialize common registers
+                    //
+                    wizMAC[5] = slot >> 4          // Slighty unique MAC address
+                    pokeregs(WIZ_SHAR, @wizMAC, 6) // MAC addr
+                    pokeregw(WIZ_RTR, 5000)        // Timeout period to 500ms
+                    pokereg(WIZ_RMSR, $55)         // 2K Rx memory/channel
+                    pokereg(WIZ_TMSR, $55)         // 2K Tx memory/channel
+                    //
+                    // Print settings
+                    //
+                    puts("Found Uthernet II in slot #")
+                    putc('0' + ((slot - $80) >> 4))
+                    putln
+                    //
+                    // Fill channel structure
+                    //
+                    saveidx = @wizChannel
+                    for slot = 0 to 3
+                        saveidx=>channel_regs  = WIZ_SREGS + (WIZ_SSIZE  * slot)
+                        saveidx=>channel_txmem = WIZ_TXMEM + (WIZ_TXSIZE * slot)
+                        saveidx=>channel_rxmem = WIZ_RXMEM + (WIZ_RXSIZE * slot)
+                        saveidx = saveidx + t_channel
+                    next
+                    //
+                    // Fill in Net class
+                    //
+                    iNet:serviceIP      = @wizServiceIP
+                    iNet:openUDP        = @wizOpenUDP
+                    iNet:sendUDP        = @wizSendUDP
+                    iNet:closeUDP       = @wizCloseUDP
+                    iNet:listenTCP      = @wizListenTCP
+                    iNet:connectTCP     = @wizConnectTCP
+                    iNet:sendTCP        = @wizSendTCP
+                    iNet:closeTCP       = @wizCloseTCP
+                    iNet:setInterfaceIP = @setWizIP
+                    iNet:getInterfaceHA = @getWizHA
+                    iNet:setCallback    = @wizSetCallback
+                    iNet:setParam       = @wizSetParam
+                    return modkeep
+                fin
             fin
+            pokeio(slot, regdata) // Restore register
         fin
-        pokeio(slot, regdata) // Restore register
     fin
 next
 //

src/libsrc/args.pla

@@ -1,4 +1,5 @@
 include "inc/cmdsys.plh"
+sysflags nojitc // No need to speed this up
 
 def argDelim(str)
     byte n

src/libsrc/dhcp.pla

@@ -3,6 +3,7 @@
 //
 include "inc/cmdsys.plh"
 include "inc/inet.plh"
+sysflags nojitc // No need to JITC this temp loaded module
 //
 // Needed to init subnet
 //
@@ -137,7 +138,7 @@ end
 def recvDHCP(remip, remport, pkt, len, param)
     word servopts, maskopts, gwopts, dnsopts
 
-    //putip(remip);putc(':');puti(remport);putln
+    //puts("recvDHCP: ");putip(remip);putc(':');puti(remport);putln
     //dumpdhcp(pkt)
     if pkt=>dhcp_xid:0 == $0201 and pkt=>dhcp_xid:2 == $0403
         when pkt->dhcp_opts.[parseopts(@pkt->dhcp_opts, 53) + 2]
@@ -155,10 +156,10 @@ def recvDHCP(remip, remport, pkt, len, param)
                 iNet:sendUDP(portDHCP, 0, DHCP_SERVER_PORT, @DHCP, @endDHCP - @DHCP)
                 break
             is DHCP_ACK
-                optsOP.2 = DHCP_ACK
                 //
                 // Copy parameters to working copy
                 //
+                optsOP.2 = DHCP_ACK
                 memcpy(@localip, @pkt->dhcp_yourip, IP4ADR_SIZE)
                 maskopts = parseopts(@pkt->dhcp_opts, 1) + 2
                 if maskopts >= 0
@@ -187,7 +188,7 @@ iNet:getInterfaceHA(@optsCID.3)
 //
 // Clear our local IP address
 //
-iNet:setInterfaceIP(@zeros,@ones, @zeros)
+iNet:setInterfaceIP(@zeros, @ones, @zeros)
 //
 // Prepare to receive DHCP packets from a server
 //
@@ -206,17 +207,17 @@ repeat
     optsSRV          = 255
     DHCP.dhcp_secs.1 = retry
     iNet:sendUDP(portDHCP, 0, DHCP_SERVER_PORT, @DHCP, @optsSRV - @DHCP + 1)
-    for timeout = 0 to 1000
+    for timeout = 0 to 4000
         iNet:serviceIP()
         if optsOP.2 == DHCP_ACK
             break
         fin
     next
-    retry = retry + 1
+    retry++
 until retry > 4 or optsOP.2 == DHCP_ACK
 iNet:closeUDP(portDHCP)
 iNet:setInterfaceIP(@localip, @localnet, @localgw)
 puts("Apple II bound to:\n");putip(@localip);putc('/');putip(@localnet);putln
 iNet:setDNS(@localdns)
-//puts("DNS: ");putip(@localdns);putln
+puts("DNS:");putip(@localdns);putln
 done

src/libsrc/etherip.pla

@@ -52,7 +52,6 @@ const IP_PROTO_TCP  = $06
 //
 // ICMP type/codes
 //
-const IP_PROTO_ICMP   = 1
 const ICMP_ECHO_REQST = 8
 const ICMP_ECHO_REPLY = 0
 //
@@ -101,7 +100,7 @@ const ARP_REQST = $0100 // BE format
 const ARP_REPLY = $0200 // BE format
 struc t_arp
     word arp_hw
-    word arp_proto
+    word arp_prot
     byte arp_hlen
     byte arp_plen
     word arp_op
@@ -155,8 +154,8 @@ struc t_notify
     word notify_func
     word notify_parm
 end
-byte[t_notify * MAX_UDP_NOTIFIES] portsUDP
-byte[t_notify * MAX_TCP_NOTIFIES] portsTCP
+byte[t_notify] portsUDP[MAX_UDP_NOTIFIES]
+byte[t_notify] portsTCP[MAX_TCP_NOTIFIES]
 //
 // Service ICMP hook
 //
@@ -379,12 +378,14 @@ end
 // Open TCP socket in SERVER mode
 //
 def etherListenTCP(lclport, callback, param)
+    puts("TCP/IP not yet implented for this hardware.\n")
     return 0
 end
 //
 // Open TCP socket in CLIENT mode
 //
 def etherConnectTCP(remip, remport, lclport, callback, param)
+    puts("TCP/IP not yet implented for this hardware.\n")
     return 0
 end
 //
@@ -500,7 +501,7 @@ def etherServiceIP
                             lclport = swab(rxptr=>udp_dst)
                             for i = 1 to MAX_UDP_NOTIFIES
                                 if port=>notify_port == lclport
-                                port=>notify_func(@iphdr=>ip_src,swab(rxptr=>udp_src),rxptr+t_udphdr,swab(rxptr=>udp_len),port=>notify_parm)
+                                port=>notify_func(@iphdr=>ip_src,swab(rxptr=>udp_src),rxptr+t_udphdr,swab(rxptr=>udp_len)-t_udphdr,port=>notify_parm)
                                 break
                             fin
                             port = port + t_notify
@@ -586,7 +587,6 @@ def getEtherHA(ha)
     if ha; memcpy(ha, @myMAC, MAC_SIZE); fin
     return MAC_SIZE
 end
-
 //
 // Fill in iNet class
 //

src/libsrc/inet.pla

@@ -33,7 +33,7 @@ end
 //
 // External interface to net class. Must be first.
 //
-export byte[t_inet] iNet
+res[t_inet] iNet
 //
 // List of loadable network device drivers
 //
@@ -54,12 +54,6 @@ def iNetSetDNS(ipptr)
     return 0
 end
 
-//def putb(hexb)
-//    return call($FDDA, hexb, 0, 0, 0)
-//end
-//def puth(hex)
-//    return call($F941, hex >> 8, hex, 0, 0)
-//end
 //def dumpbytes(buf, len)
 //    word i
 //
@@ -87,14 +81,14 @@ def parseIP(ipstr, ipaddr)
 
     endstr = ipstr + ^ipstr
     for i = 0 to 3
-    ipstr = ipstr + 1
-        while ^ipstr >= '0' and ^ipstr <= '9' and ipstr <= endstr
-        ipaddr->[i] = ipaddr->[i] * 10 + ^ipstr - '0'
         ipstr = ipstr + 1
-    loop
-    if ^ipstr <> '.' and ipstr < endstr
-        return 0
-    fin
+            while ^ipstr >= '0' and ^ipstr <= '9' and ipstr <= endstr
+            ipaddr->[i] = ipaddr->[i] * 10 + ^ipstr - '0'
+            ipstr = ipstr + 1
+        loop
+        if ^ipstr <> '.' and ipstr < endstr
+            return 0
+        fin
     next
     return i == 3
 end
@@ -105,11 +99,11 @@ def parseDomain(domstr, msgptr)
     l = 0
     for i = 1 to ^domstr
         if domstr->[i] == '.'
-        msgptr->[l] = i - l - 1
-        l = i
-    else
-        msgptr->[i] = domstr->[i]
-    fin
+            msgptr->[l] = i - l - 1
+            l = i
+        else
+            msgptr->[i] = domstr->[i]
+        fin
     next
     msgptr->[l] = i - l - 1
     msgptr  = msgptr + i
@@ -154,7 +148,7 @@ def recvDNS(remip, remport, pkt, len, ipaddr)
             resptr = resptr + 8
             //dumpbytes(resptr + 2, ^(resptr + 1))
             resptr = resptr + 2 + ^(resptr + 1); putln
-            r = r - 1
+            r--
         loop
     fin
     stateDNS = DNS_ANSWER
@@ -171,7 +165,7 @@ def iNetResolve(namestr, ipaddr)
         //
         // Query Domain Name Server for address
         //
-        dnspkt             = heapmark // Use heap as working DNS query packet
+        dnspkt             = heapalloc(^namestr + t_dnshdr + 8) // Use heap as working DNS query packet
         msgptr             = dnspkt
         msgptr=>dnsID      = $BEEF
         msgptr=>dnsCode    = $0001 // RD (Recursion Desired)
@@ -181,9 +175,8 @@ def iNetResolve(namestr, ipaddr)
         msgptr=>dnsArCount = 0
         msgptr             = parseDomain(namestr, msgptr + t_dnshdr)
         msgptr=>0          = $0100 // BE TYPE  = Address
-        msgptr=>2          = $0100 // BE CLASS = INternet
+        msgptr=>2          = $0100 // BE CLASS = Internet
         msglen             = msgptr - dnspkt + 4
-        heapalloc(msglen)
         //
         // Prepare to receive DNS answer from server
         //
@@ -204,29 +197,27 @@ def iNetResolve(namestr, ipaddr)
     fin
     return ipaddr=>0 <> 0 or ipaddr=>2 <> 0
 end
-
+//
+// Initialze network stack
+//
 def iNetInit
     //
     // Look for net hardware
     //
     while ^driver
-        //puts(driver);putln
         if cmdsys:modexec(driver) >= 0
-                break
+            //
+            // Get an IP address
+            //
+            cmdsys:modexec("DHCP")
+            iNet:resolveIP = @iNetResolve
+            return @iNet
         fin
         driver = driver + ^driver + 1
     loop
-    if !^driver
-        return 0
-    fin
-    //
-    // Get an IP address
-    //
-    cmdsys:modexec("DHCP")
-    iNet:resolveIP = @iNetResolve
-    return @iNet
+    puts("No network adapters found.\n")
+    return NULL
 end
-
 //
 // Fill iNet class
 //

src/libsrc/int32.pla

@@ -0,0 +1,682 @@
+//
+// 32 bit integer math routines
+//
+include "inc/cmdsys.plh"
+const t_i32 = 4
+//
+// Include zero page definitions
+//
+asm int32Inc
+    !SOURCE "vmsrc/plvmzp.inc"
+ACCUM32 =       DSTH+1
+DVSIGN  =       TMP+3
+end
+export asm zero32#0
+        LDA     #$00
+        STA     ACCUM32+0
+        STA     ACCUM32+1
+        STA     ACCUM32+2
+        STA     ACCUM32+3
+        RTS
+end
+export asm zext16to32#0
+        LDA     #$00
+        STA     ACCUM32+2
+        STA     ACCUM32+3
+        RTS
+end
+export asm neg32#0
+        LDA     #$00
+        SEC
+        SBC     ACCUM32+0
+        STA     ACCUM32+0
+        LDA     #$00
+        SBC     ACCUM32+1
+        STA     ACCUM32+1
+        LDA     #$00
+        SBC     ACCUM32+2
+        STA     ACCUM32+2
+        LDA     #$00
+        SBC     ACCUM32+3
+        STA     ACCUM32+3
+        RTS
+end
+export asm load32(i32ptr)#0
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$00
+        LDA     (TMP),Y
+        STA     ACCUM32+0
+        INY
+        LDA     (TMP),Y
+        STA     ACCUM32+1
+        INY
+        LDA     (TMP),Y
+        STA     ACCUM32+2
+        INY
+        LDA     (TMP),Y
+        STA     ACCUM32+3
+        INX
+        RTS
+end
+export asm loadi16(imm16)#0
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     ACCUM32+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     ACCUM32+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     ACCUM32+2
+        STY     ACCUM32+3
+        INX
+        RTS
+end
+export asm store32(i32ptr)#0
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$00
+        LDA     ACCUM32+0
+        STA     (TMP),Y
+        INY
+        LDA     ACCUM32+1
+        STA     (TMP),Y
+        INY
+        LDA     ACCUM32+2
+        STA     (TMP),Y
+        INY
+        LDA     ACCUM32+3
+        STA     (TMP),Y
+        INX
+        RTS
+end
+export asm add32(i32ptr)#0
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$00
+        LDA     (TMP),Y
+        CLC
+        ADC     ACCUM32+0
+        STA     ACCUM32+0
+        INY
+        LDA     (TMP),Y
+        ADC     ACCUM32+1
+        STA     ACCUM32+1
+        INY
+        LDA     (TMP),Y
+        ADC     ACCUM32+2
+        STA     ACCUM32+2
+        INY
+        LDA     (TMP),Y
+        ADC     ACCUM32+3
+        STA     ACCUM32+3
+        INX
+        RTS
+end
+export asm addi16(imm16)#0
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        CLC
+        ADC     ACCUM32+0
+        STA     ACCUM32+0
+        LDA     ESTKH+0,X       ; IMM16H
+        BPL     +
+        DEY
++       ADC     ACCUM32+1
+        STA     ACCUM32+1
+        TYA
+        ADC     ACCUM32+2
+        STA     ACCUM32+2
+        TYA
+        ADC     ACCUM32+3
+        STA     ACCUM32+3
+        INX
+        RTS
+end
+export asm sub32(i32ptr)#0
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        BMI     _SUB
+end
+export asm subi16(imm16)#0
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+_SUB    LDA     ACCUM32+0
+        SEC
+        SBC     SRC+0
+        STA     ACCUM32+0
+        LDA     ACCUM32+1
+        SBC     SRC+1
+        STA     ACCUM32+1
+        LDA     ACCUM32+2
+        SBC     SRC+2
+        STA     ACCUM32+2
+        LDA     ACCUM32+3
+        SBC     SRC+3
+        STA     ACCUM32+3
+        INX
+        RTS
+end
+export asm shl32(imm8)#0
+        LDA     ESTKL+0,X       ; IMM8
+        AND     #$1F
+        CMP     #16
+        BCC     +
+        LDY     ACCUM32+1
+        STY     ACCUM32+3
+        LDY     ACCUM32+0
+        STY     ACCUM32+2
+        LDY     #$00
+        STY     ACCUM32+1
+        STY     ACCUM32+0
+        SBC     #16
++       CMP     #8
+        BCC     +
+        LDY     ACCUM32+2
+        STY     ACCUM32+3
+        LDY     ACCUM32+1
+        STY     ACCUM32+2
+        LDY     ACCUM32+0
+        STY     ACCUM32+1
+        LDY     #$00
+        STY     ACCUM32+0
+        SBC     #8
++       TAY
+        BEQ     ++
+-       ASL     ACCUM32+0
+        ROL     ACCUM32+1
+        ROL     ACCUM32+2
+        ROL     ACCUM32+3
+        DEY
+        BNE     -
+++      INX
+        RTS
+end
+export asm shr32(imm8)#0
+        LDA     ESTKL+0,X       ; IMM8
+        AND     #$1F
+        BEQ     +
+        TAY
+        LDA     #$80
+-       CMP     ACCUM32
+        ROR     ACCUM32+3
+        ROR     ACCUM32+2
+        ROR     ACCUM32+1
+        ROR     ACCUM32+0
+        DEY
+        BNE     -
++       INX
+        RTS
+end
+export asm mul32(i32ptr)#0
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _MUL
+end
+export asm muli16(imm16)#0
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_MUL    LDA     ACCUM32+0
+        STA     ESTKL-1,X
+        LDA     ACCUM32+1
+        STA     ESTKH-1,X
+        LDA     ACCUM32+2
+        STA     ESTKL+0,X
+        LDA     ACCUM32+3
+        STA     ESTKH+0,X
+        STY     ACCUM32+0
+        STY     ACCUM32+1
+        STY     ACCUM32+2
+        STY     ACCUM32+3
+        LDY     #$03
+        LDA     #$80
+        STA     TMPL
+-       AND     SRC,Y
+        BEQ     +
+        CLC
+        LDA     ESTKL-1,X
+        ADC     ACCUM32+0
+        STA     ACCUM32+0
+        LDA     ESTKH-1,X
+        ADC     ACCUM32+1
+        STA     ACCUM32+1
+        LDA     ESTKL+0,X
+        ADC     ACCUM32+2
+        STA     ACCUM32+2
+        LDA     ESTKH+0,X
+        ADC     ACCUM32+3
+        STA     ACCUM32+3
++       LSR     TMPL
+        BCC     +
+        DEY
+        BMI     ++
+        ROR     TMPL
++       ASL     ACCUM32+0
+        ROL     ACCUM32+1
+        ROL     ACCUM32+2
+        ROL     ACCUM32+3
+        LDA     TMPL
+        BNE     -
+++      INX
+        RTS
+end
+export asm div32(i32ptr)#2
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03            ; DVSR = SRC..SRC+3
+        LDA     (TMP),Y
+        BMI     +
+        STA     SRC+3
+        DEY
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _DIV
++       SEC
+-       LDA     #$00
+        SBC     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        LDY     #$01
+        BNE     _DIV
+end
+export asm divi16(imm16)#2
+        LDY     #$00            ; DVSR = SRC..SRC+3
+        STY     SRC+2
+        STY     SRC+3
+        LDA     ESTKH+0,X       ; IMM16H
+        BPL     +
+        TYA                     ; DVSR IS NEG
+        SEC
+        SBC     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        TYA
+        SBC     ESTKH+0,X       ; IMM16L
+        STA     SRC+1
+        INY
+        BNE     _DIV
++       STA     SRC+1
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+_DIV    STY     DVSIGN          ; LSB = SIGN OF DVSR
+        DEX                     ; REMNDR = ESTK..ESTK+1
+        LDY     #$00
+        STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        STY     ESTKL+1,X
+        STY     ESTKH+1,X
+        LDA     SRC+0           ; DIVIDE BY 0?
+        ORA     SRC+1
+        ORA     SRC+2
+        ORA     SRC+3
+        BNE     +
+        STA     ACCUM32+0       ; SET TO 0 AND EXIT
+        STA     ACCUM32+1
+        STA     ACCUM32+2
+        STA     ACCUM32+3
+-       RTS
++       LDA     ACCUM32+0       ; DIVIDE 0?
+        ORA     ACCUM32+1
+        ORA     ACCUM32+2
+        ORA     ACCUM32+3
+        BEQ     -        
+        LDA     ACCUM32+3       ; DVDND = ACCUM32
+        BPL     +
+        LDA     #$81            ; DVDND IS NEG
+        CLC
+        ADC     DVSIGN
+        STA     DVSIGN
+        TYA
+        SEC
+        SBC     ACCUM32+0
+        STA     ACCUM32+0
+        TYA
+        SBC     ACCUM32+1
+        STA     ACCUM32+1
+        TYA
+        SBC     ACCUM32+2
+        STA     ACCUM32+2
+        TYA
+        SBC     ACCUM32+3
+        STA     ACCUM32+3
++       LDY     #$21            ; #BITS+1
+-       ASL     ACCUM32+0       ; SKIP DVDND LEADING 0 BITS
+        ROL     ACCUM32+1
+        ROL     ACCUM32+2
+        ROL     ACCUM32+3
+        DEY
+        BCC     -
+-       ROL     ESTKL+0,X       ; REMNDR
+        ROL     ESTKH+0,X
+        ROL     ESTKL+1,X
+        ROL     ESTKH+1,X
+        LDA     ESTKL+0,X       ; REMNDR
+        CMP     SRC+0           ; DVSR
+        LDA     ESTKH+0,X       ; COMPARE
+        SBC     SRC+1
+        LDA     ESTKL+1,X
+        SBC     SRC+2
+        LDA     ESTKH+1,X
+        SBC     SRC+3
+        BCC     +               ; IS LESS THAN?
+        STA     ESTKH+1,X
+        LDA     ESTKL+0,X       ; REMNDR
+        SBC     SRC+0           ; DVSR
+        STA     ESTKL+0,X       ; SUBTRACT
+        LDA     ESTKH+0,X
+        SBC     SRC+1
+        STA     ESTKH+0,X
+        LDA     ESTKL+1,X
+        SBC     SRC+2
+        STA     ESTKL+1,X
+        SEC
++       ROL     ACCUM32+0       ; DVDND
+        ROL     ACCUM32+1       ; ROTATE IN RESULT
+        ROL     ACCUM32+2
+        ROL     ACCUM32+3
+        DEY
+        BNE     -
+        LDA     DVSIGN          ; SET SIGNS OF RESULTS
+        BPL     +
+        TYA
+        SEC
+        SBC     ESTKL+0,X
+        STA     ESTKL+0,X
+        TYA
+        SBC     ESTKH+0,X
+        STA     ESTKH+0,X
+        TYA
+        SBC     ESTKL+1,X
+        STA     ESTKL+1,X
+        TYA
+        SBC     ESTKH+1,X
+        STA     ESTKH+1,X
+        LDA     DVSIGN
++       LSR
+        BCC     +
+        TYA
+        SBC     ACCUM32+0
+        STA     ACCUM32+0
+        TYA
+        SBC     ACCUM32+1
+        STA     ACCUM32+1
+        TYA
+        SBC     ACCUM32+2
+        STA     ACCUM32+2
+        TYA
+        SBC     ACCUM32+3
+        STA     ACCUM32+3
++       RTS
+end
+export asm iseq32(i32ptr)#1
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _ISEQ
+end
+export asm iseqi16(imm16)#1
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_ISEQ   LDA     ACCUM32+0
+        CMP     SRC+0
+        BNE     +
+        LDA     ACCUM32+1
+        CMP     SRC+1
+        BNE     +
+        LDA     ACCUM32+2
+        CMP     SRC+2
+        BNE     +
+        LDA     ACCUM32+3
+        CMP     SRC+3
+        BNE     +
+        DEY
++       STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        RTS
+end
+export asm isge32(i32ptr)#1
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _ISGE
+end
+export asm isgei16(imm16)#1
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_ISGE   LDA     ACCUM32+0
+        CMP     SRC+0
+        LDA     ACCUM32+1
+        SBC     SRC+1
+        LDA     ACCUM32+2
+        SBC     SRC+2
+        LDA     ACCUM32+3
+        SBC     SRC+3
+        BVC     +
+        EOR     #$80
++       BMI     +
+        DEY
++       STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        RTS
+end
+export asm isle32(i32ptr)#1
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _ISLE
+end
+export asm islei16(imm16)#1
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_ISLE   LDA     SRC+0
+        CMP     ACCUM32+0
+        LDA     SRC+1
+        SBC     ACCUM32+1
+        LDA     SRC+2
+        SBC     ACCUM32+2
+        LDA     SRC+3
+        SBC     ACCUM32+3
+        BVC     +
+        EOR     #$80
++       BMI     +
+        DEY
++       STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        RTS
+end
+export asm isgt32(i32ptr)#1
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _ISGT
+end
+export asm isgti16(imm16)#1
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_ISGT   LDA     SRC+0
+        CMP     ACCUM32+0
+        LDA     SRC+1
+        SBC     ACCUM32+1
+        LDA     SRC+2
+        SBC     ACCUM32+2
+        LDA     SRC+3
+        SBC     ACCUM32+3
+        BVC     +
+        EOR     #$80
++       BPL     +
+        DEY
++       STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        RTS
+end
+export asm islt32(i32ptr)#1
+        LDA     ESTKL+0,X       ; I32PTR
+        STA     TMPL
+        LDA     ESTKH+0,X       ; I32PTR
+        STA     TMPH
+        LDY     #$03
+-       LDA     (TMP),Y
+        STA     SRC,Y
+        DEY
+        BPL     -
+        INY
+        BEQ     _ISLT
+end
+export asm islti16(imm16)#1
+        LDY     #$00
+        LDA     ESTKL+0,X       ; IMM16L
+        STA     SRC+0
+        LDA     ESTKH+0,X       ; IMM16H
+        STA     SRC+1
+        BPL     +               ; SIGN EXTEND
+        DEY
++       STY     SRC+2
+        STY     SRC+3
+        LDY     #$00
+_ISLT   LDA     ACCUM32+0
+        CMP     SRC+0
+        LDA     ACCUM32+1
+        SBC     SRC+1
+        LDA     ACCUM32+2
+        SBC     SRC+2
+        LDA     ACCUM32+3
+        SBC     SRC+3
+        BVC     +
+        EOR     #$80
++       BPL     +
+        DEY
++       STY     ESTKL+0,X
+        STY     ESTKH+0,X
+        RTS
+end
+export def i32tos(i32ptr, strptr)#1
+    res[t_i32] save
+    word iptr, rem
+    char[12] istr
+    
+    iptr = @istr.11
+    store32(@save)
+    load32(i32ptr)
+    if i32ptr->3 & $80
+        neg32()
+        putc('-')
+    fin
+    repeat
+        drop, rem = divi16(10) // Only care about LSW of remainder
+        ^iptr = rem + '0'
+        iptr--
+    until iseqi16(0)
+    ^iptr = @istr.11 - iptr
+    strcpy(strptr, iptr)
+    load32(@save)
+    return strptr
+end
+export def puti32(i32ptr)#0
+    char[12] i32str
+        
+    puts(i32tos(i32ptr, @i32str))
+end
+
+done
+

src/libsrc/lines.pla

@@ -0,0 +1,506 @@
+include "inc/cmdsys.plh"
+predef nopLin(a, b, c)#0
+predef nopPix(a, b)#0
+
+byte jmpplot = $4C // Sneaky!
+var plot     = @nopPix
+var hspan    = @nopLin
+var vspan    = @nopLin
+var err, shorterr, shortlen, longerr, longlen
+
+//def nopLin(a, b, c)#0
+//end
+//def majorspans(majorstart, major, majorend, minor, dir, majorspan)#0
+//    //
+//    // Initial half-span step
+//    //
+//    err = err + shorterr
+//    repeat
+//        majorspan(majorstart, major, minor)#0
+//        minor      = minor + dir     // Move to next span
+//        majorstart = major + 1       // Start of next span = end of previous + 1
+//        if err >= 0             // Short span
+//            err   = err   + shorterr
+//            major = major + shortlen
+//        else                    // Long span
+//            err   = err   + longerr
+//            major = major + longlen
+//        fin
+//    until major >= majorend
+//    //
+//    // Final half-span step
+//    //
+//    majorspan(majorstart, majorend, minor)#0
+//end
+asm majorspans(majorstart, major, majorend, minor, dir, majorspan)#0
+!SOURCE    "vmsrc/plvmzp.inc"
+        LDA     $1000       ; ERRL
+        CLC
+        ADC     $2000       ; SHORTERRL
+        STA     $1000       ; ERRL
+        LDA     $1001       ; ERRH
+        ADC     $2001       ; SHORTERRH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+0,X   ; MAJORSPANL
+        STA     $A000
+        STA     $B000
+        LDA     ESTKH+0,X   ; MAJORSPANH
+        STA     $A001
+        STA     $B001
+end
+asm     _majorspansA
+-       DEX
+        DEX
+        DEX
+        LDA     ESTKL+8,X   ; MAJORSTARTL
+        STA     ESTKL+2,X
+        LDA     ESTKH+8,X   ; MAJORSTARTH
+        STA     ESTKH+2,X
+        LDA     ESTKL+7,X   ; MAJORL
+        STA     ESTKL+1,X
+        LDA     ESTKH+7,X   ; MAJORH
+        STA     ESTKH+1,X
+        LDA     ESTKL+5,X   ; MINORL
+        STA     ESTKL+0,X
+        LDA     ESTKH+5,X   ; MINORH
+        STA     ESTKH+0,X
+        JSR     $A000
+
+        LDA     ESTKL+2,X   ; MINORL
+        CLC
+        ADC     ESTKL+1,X   ; DIRL
+        STA     ESTKL+2,X
+        LDA     ESTKH+2,X   ; MINORH
+        ADC     ESTKH+1,X   ; DIRH
+        STA     ESTKH+2,X
+
+        LDA     ESTKL+4,X   ; MAJORL
+        CLC
+        ADC     #$01
+        STA     ESTKL+5,X   ; MAJORSTARTL
+        LDA     ESTKH+4,X   ; MAJORH
+        ADC     #$00
+        STA     ESTKH+5,X   ; MAJORSTARTH
+end
+asm     _majorspansB
+        LDY     $1001       ; ERRH
+        BMI     +
+end
+asm     _majorspansC
+        LDA     $1000       ; ERRL
+        CLC
+        ADC     $2000       ; SHORTERRL
+        STA     $1000       ; ERRL
+        TYA                 ; ERRH
+        ADC     $2001       ; SHORTERRH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+4,X   ; MAJORL
+        CLC
+        ADC     $3000       ; SHORTLENL
+        STA     ESTKL+4,X
+        LDA     ESTKH+4,X   ; MAJORH
+        ADC     $3001       ; SHORTLENH
+        STA     ESTKH+4,X
+        LDA     ESTKL+4,X   ; MAJORL
+        CMP     ESTKL+3,X   ; MAJORENDL
+        LDA     ESTKH+4,X   ; MAJORH
+        SBC     ESTKH+3,X   ; MAJORENDH
+        BCC     -
+        BCS     ++
+end
+asm     _majorspansD
++       LDA     $1000       ; ERRL
+        CLC
+        ADC     $4000       ; LONGERRL
+        STA     $1000       ; ERRL
+        TYA                 ; ERRH
+        ADC     $4001       ; LONGERRL
+        STA     $1001       ; ERRH
+        LDA     ESTKL+4,X   ; MAJORL
+        CLC
+        ADC     $5000       ; LONGLENL
+        STA     ESTKL+4,X
+        LDA     ESTKH+4,X   ; MAJORH
+        ADC     $5001       ; LONGLENH
+        STA     ESTKH+4,X
+        LDA     ESTKL+4,X   ; MAJORL
+        CMP     ESTKL+3,X   ; MAJORENDL
+        LDA     ESTKH+4,X   ; MAJORH
+        SBC     ESTKH+3,X   ; MAJORENDH
+        BCS     ++
+end
+asm     _majorspansE
+        JMP     $6000
+++      DEX
+        DEX
+        DEX
+        LDA     ESTKL+8,X   ; MAJORSTARTL
+        STA     ESTKL+2,X
+        LDA     ESTKH+8,X   ; MAJORSTARTH
+        STA     ESTKH+2,X
+        LDA     ESTKL+6,X   ; MAJORENDL
+        STA     ESTKL+1,X
+        LDA     ESTKH+6,X   ; MAJORENDH
+        STA     ESTKH+1,X
+        LDA     ESTKL+5,X   ; MINORL
+        STA     ESTKL+0,X
+        LDA     ESTKH+5,X   ; MINORH
+        STA     ESTKH+0,X
+        JSR     $B000
+        TXA
+        CLC
+        ADC     #$06
+        TAX
+        RTS
+end
+asm nopLin(a, b, c)#0
+        INX
+end
+asm nopPix(a, b)#0
+        INX
+        INX
+        RTS
+end
+//def hline(x1, x2, dx2, y, dy2, sy)#0
+//    var dyx2, x
+//
+//    err  = dy2 - dx2 / 2
+//    dyx2 = dy2 - dx2
+//    for x = x1 to x2
+//        plot(x, y)#0
+//        if err >= 0
+//            y   = y + sy
+//            err = err + dyx2
+//        else
+//            err = err + dy2
+//        fin
+//    next
+//end
+asm hline(x1, x2, dx2, y, dy2, sy)#0
+        LDA     ESTKH+3,X   ; DX2H
+        LSR
+        STA     TMPH
+        LDA     ESTKL+3,X   ; DX2L
+        ROR
+        STA     TMPL
+        LDA     ESTKL+1,X   ; DY2L
+        SEC
+        SBC     TMPL
+        STA     $1000       ; ERRL
+        LDA     ESTKH+1,X   ; DY2H
+        SBC     TMPH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+1,X   ; DY2L
+        SEC
+        SBC     ESTKL+3,X   ; DX2L
+        STA     ESTKL+3,X   ; DYX2L
+        LDA     ESTKH+1,X   ; DY2H
+        SBC     ESTKH+3,X   ; DX2H
+        STA     ESTKH+3,X   ; DYX2H
+-       DEX
+        DEX
+        LDA     ESTKL+7,X   ; XL
+        STA     ESTKL+1,X
+        LDA     ESTKH+7,X   ; XH
+        STA     ESTKH+1,X
+        LDA     ESTKL+4,X   ; YL
+        STA     ESTKL+0,X
+        LDA     ESTKH+4,X   ; YH
+        STA     ESTKH+0,X
+end
+asm     _hlineA
+        JSR     $2000       ; PLOT
+        LDA     $1001       ; ERRH
+        BMI     +
+        LDA     ESTKL+2,X   ; YL
+        CLC
+        ADC     ESTKL+0,X   ; SYL
+        STA     ESTKL+2,X
+        LDA     ESTKH+2,X   ; YH
+        ADC     ESTKH+0,X   ; SYH
+        STA     ESTKH+2,X
+        LDA     ESTKL+3,X   ; DYX2L
+        LDY     ESTKH+3,X   ; DYX2H
+        BEQ     ++
+        BNE     ++
+end
+asm     _hlineB
++       LDA     ESTKL+1,X   ; DY2L
+        LDY     ESTKH+1,X   ; DY2H
+++      CLC
+        ADC     $1000       ; ERRL
+        STA     $1000       ; ERRL
+        TYA
+        ADC     $1001       ; ERRH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+5,X   ; X1L
+        CMP     ESTKL+4,X   ; X2L
+        LDA     ESTKH+5,X
+        SBC     ESTKH+4,X
+        BCS     +
+        INC     ESTKL+5,X   ; XL
+        BNE     -
+        INC     ESTKH+5,X   ; XH
+        BCC     -
++       TXA
+        ADC     #$05
+        TAX
+        RTS
+end
+//def vline(y1, y2, dy2, x, dx2, sx)#0
+//    var dxy2, y
+//    
+//    err  = dx2 - dy2 / 2
+//    dxy2 = dx2 - dy2
+//    for y = y1 to y2
+//        plot(x, y)#0
+//        if err >= 0
+//            x   = x + sx
+//            err = err + dxy2
+//        else
+//            err = err + dx2
+//        fin
+//    next
+//end
+asm vline(y1, y2, dy2, x, dx2, sx)#0
+        LDA     ESTKH+3,X   ; DY2H
+        LSR
+        STA     TMPH
+        LDA     ESTKL+3,X   ; DY2L
+        ROR
+        STA     TMPL
+        LDA     ESTKL+1,X   ; DX2L
+        SEC
+        SBC     TMPL
+        STA     $1000       ; ERRL
+        LDA     ESTKH+1,X   ; DX2H
+        SBC     TMPH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+1,X   ; DX2L
+        SEC
+        SBC     ESTKL+3,X   ; DX2L
+        STA     ESTKL+3,X   ; DXY2L
+        LDA     ESTKH+1,X   ; DX2H
+        SBC     ESTKH+3,X   ; DY2H
+        STA     ESTKH+3,X   ; DXY2H
+-       DEX
+        DEX
+        LDA     ESTKL+4,X   ; XL
+        STA     ESTKL+1,X
+        LDA     ESTKH+4,X   ; XH
+        STA     ESTKH+1,X
+        LDA     ESTKL+7,X   ; YL
+        STA     ESTKL+0,X
+        LDA     ESTKH+7,X   ; YH
+        STA     ESTKH+0,X
+end
+asm     _vlineA
+        JSR     $2000       ; PLOT
+        LDA     $1001       ; ERRH
+        BMI     +
+        LDA     ESTKL+2,X   ; XL
+        CLC
+        ADC     ESTKL+0,X   ; SXL
+        STA     ESTKL+2,X
+        LDA     ESTKH+2,X   ; XH
+        ADC     ESTKH+0,X   ; SXH
+        STA     ESTKH+2,X
+        LDA     ESTKL+3,X   ; DXY2L
+        LDY     ESTKH+3,X   ; DXY2H
+        BEQ     ++
+        BNE     ++
+end
+asm     _vlineB
++       LDA     ESTKL+1,X   ; DX2L
+        LDY     ESTKH+1,X   ; DX2H
+++      CLC
+        ADC     $1000       ; ERRL
+        STA     $1000       ; ERRL
+        TYA
+        ADC     $1001       ; ERRH
+        STA     $1001       ; ERRH
+        LDA     ESTKL+5,X   ; Y1L
+        CMP     ESTKL+4,X   ; Y2L
+        LDA     ESTKH+5,X
+        SBC     ESTKH+4,X
+        BCS     +
+        INC     ESTKL+5,X   ; YL
+        BNE     -
+        INC     ESTKH+5,X   ; YH
+        BCC     -
++       TXA
+        ADC     #$05
+        TAX
+        RTS
+end
+
+export def setlinespans(h, v)#0
+    hspan = h
+    vspan = v
+end
+def hmajorspans(x1, y1, x2, y2, dx, dy, sy)#0
+    var dy2, halflen, rem
+    //
+    // Half-span length and error
+    //
+    dy2          = dy * 2
+    halflen, rem = divmod(dx, dy2)
+    err          = dy2 - rem
+    //
+    // Long-span length = half-span length * 2
+    //
+    longlen = (halflen + 1) * 2
+    longerr = err * 2
+    if longerr >= dy2
+        longerr = longerr - dy2
+        longlen--
+    fin
+    //
+    // Short-span length = long-span length - 1
+    //
+    shortlen = longlen - 1
+    shorterr = longerr - dy2
+    majorspans(x1, x1 + halflen, x2, y1, sy, hspan)
+end
+def vmajorspans(x1, y1, x2, y2, dx, dy, sx)#0
+    var dx2, halflen, rem
+
+    //
+    // Half-span length and error
+    //
+    dx2          = dx * 2
+    halflen, rem = divmod(dy, dx2)
+    err          = dx2 - rem
+    //
+    // Long-span length = half-span length * 2
+    //
+    longlen = (halflen + 1) * 2
+    longerr = err * 2
+    if longerr >= dx2
+        longerr = longerr - dx2
+        longlen--
+    fin
+    shortlen = longlen - 1
+    shorterr = longerr - dx2
+    majorspans(y1, y1 + halflen, y2, x1, sx, vspan)
+end
+export def linespans(x1, y1, x2, y2)#0
+    var dx, dy, dx2, dy2, halflen, rem, sx, sy
+    
+    sx = 1
+    sy = 1
+    dx = x2 - x1
+    if dx < 0
+        sx  = -1; dx = -dx
+    fin
+    dy = y2 - y1
+    if dy < 0
+        sy  = -1; dy = -dy
+    fin
+    if dx >= dy
+        if sx < 0
+            y1, y2 = y2, y1
+            x1, x2 = x2, x1
+            sy = -sy
+        fin
+        if dy == 0
+            hspan(x1, x2, y1)#0; return
+        fin
+        //
+        // JIT optimize setup
+        //
+        hmajorspans(x1, y1, x2, y2, dx, dy, sy)
+    else
+        if sy < 0
+            x1, x2 = x2, x1
+            y1, y2 = y2, y1
+            sx = -sx
+        fin
+        if dx == 0
+            vspan(y1, y2, x1)#0; return
+        fin
+        //
+        // JIT optimize inner setup
+        //
+        vmajorspans(x1, y1, x2, y2, dx, dy, sx)
+    fin
+end
+export def setlineplot(p)#0
+    plot = p
+end
+export def line(x1, y1, x2, y2)#0
+    var sx, sy, dx2, dy2
+    
+    sx = 1
+    sy = 1
+    dx2 = (x2 - x1) * 2
+    if dx2 < 0
+        sx = -1; dx2 = -dx2
+    fin
+    dy2 = (y2 - y1) * 2
+    if dy2 < 0
+        sy = -1; dy2 = -dy2
+    fin
+    if dx2 >= dy2
+        if sx < 0
+            x1, x2 = x2, x1
+            y1, y2 = y2, y1
+            sy = -sy
+        fin
+        hline(x1, x2, dx2, y1, dy2, sy)
+    else
+        if sy < 0
+            y1, y2 = y2, y1
+            x1, x2 = x2, x1
+            sx = -sx
+        fin
+        vline(y1, y2, dy2, x1, dx2, sx)
+    fin
+ end
+
+//
+// Assembly fixups
+//
+majorspans:1    = @err
+majorspans:5    = @shorterr
+majorspans:8    = @err
+majorspans:11   = @err.1
+majorspans:14   = @shorterr.1
+majorspans:17   = @err.1
+majorspans:22   = @_majorspansA.28
+majorspans:25   = @_majorspansE.31
+majorspans:30   = @_majorspansA.29
+majorspans:33   = @_majorspansE.32
+_majorspansB:1  = @err.1
+_majorspansC:1  = @err
+_majorspansC:5  = @shorterr
+_majorspansC:8  = @err
+_majorspansC:12 = @shorterr.1
+_majorspansC:15 = @err.1
+_majorspansC:21 = @shortlen
+_majorspansC:28 = @shortlen.1
+_majorspansD:1  = @err
+_majorspansD:5  = @longerr
+_majorspansD:8  = @err
+_majorspansD:12 = @longerr.1
+_majorspansD:15 = @err.1
+_majorspansD:21 = @longlen
+_majorspansD:28 = @longlen.1
+_majorspansE:1  = @_majorspansA
+hline:16        = @err
+hline:23        = @err.1
+_hlineA:1       = @jmpplot
+_hlineA:4       = @err.1
+_hlineB:6       = @err
+_hlineB:9       = @err
+_hlineB:13      = @err.1
+_hlineB:16      = @err.1
+vline:16        = @err
+vline:23        = @err.1
+_vlineA:1       = @jmpplot
+_vlineA:4       = @err.1
+_vlineB:6       = @err
+_vlineB:9       = @err
+_vlineB:13      = @err.1
+_vlineB:16      = @err.1
+done

src/libsrc/lz4.pla

@@ -0,0 +1,91 @@
+include "inc/cmdsys.plh"
+asm incs
+        !SOURCE    "vmsrc/plvmzp.inc"
+end
+//
+// Always forward copy memory - important for overlapping match sequences
+//
+asm bcpy(dst, src, len)#0
+        INX
+        INX
+        INX
+        LDA     ESTKL-3,X
+        ORA     ESTKH-3,X
+        BEQ     CPYEX
+        LDA     ESTKL-1,X
+        STA     DSTL
+        LDA     ESTKH-1,X
+        STA     DSTH
+        LDA     ESTKL-2,X
+        STA     SRCL
+        LDA     ESTKH-2,X
+        STA     SRCH
+        LDY     ESTKL-3,X
+        BEQ     CPYLP
+        INC     ESTKH-3,X
+        LDY     #$00
+CPYLP   LDA     (SRC),Y
+        STA     (DST),Y
+        INY
+        BNE     +
+        INC     DSTH
+        INC     SRCH
++       DEC     ESTKL-3,X
+        BNE     CPYLP
+        DEC     ESTKH-3,X
+        BNE     CPYLP
+CPYEX   RTS
+end
+//
+// Unpack LZ4 sequence into buffer, return unpacked length
+//
+export def lz4Unpack(seq, seqend, buff, buffend)
+    word data, len, match, i
+    byte token
+
+    data = buff
+    while isult(seq, seqend)
+        token = ^seq
+        seq++
+        len = token >> 4
+        if len
+            //
+            // Literal sequence
+            //
+            if len == 15
+                while ^seq == 255
+                    len = len + 255
+                    seq++
+                loop
+                len = len + ^seq
+                seq++
+            fin
+            if isuge(data + len, buffend); return 0; fin
+            bcpy(data, seq, len)
+            data = data + len
+            seq  = seq  + len
+        fin
+        len = token & $0F
+        if len or isult(seq, seqend)
+            //
+            // Match sequence
+            //
+            match =  data - *seq
+            seq   = seq + 2
+            len   = len + 4
+            if len == 19 // $0F + 4
+                while ^seq == 255
+                    len = len + 255
+                    seq++
+                loop
+                len = len + ^seq
+                seq++
+            fin
+            if isuge(data + len, buffend); return 0; fin
+            bcpy(data, match, len)
+            data = data + len
+        fin
+    loop
+    return data - buff
+end
+done

src/libsrc/memmgr.pla

@@ -544,7 +544,7 @@ export def hmemNew(size)
                 //
                 // Allocate 3/4 of available heap on 128K machine, 1/2 on 64K machine
                 //
-                poolsize = ((@page - heapmark) >> 1) & $7FFF
+                poolsize = (heapavail >> 1) & $7FFF
                 if MACHID & $30 == $30
                         poolsize = poolsize + (poolsize >> 1)
                 fin
@@ -666,7 +666,7 @@ end
 // !!! Does this work on Apple ///???
 //
 sysbuf = $0800 // heapallocalign(1024, 8, 0)
-initdata = heapmark // Use data at top of heap for initialization
+initdata = heapalloc(t_initdata) // Use data on heap for initialization
 initdata=>volparms.0 = 2
 initdata=>volparms.1 = 0
 initdata=>volparms:2 = sysbuf
@@ -733,5 +733,6 @@ repeat
     fin
 until !initdata->filecnt
 fileio:close(initdata->catref)
+heaprelease(initdata)
 //puts(@swapvol); putln
 done

src/libsrc/sane.pla

@@ -734,19 +734,21 @@ def loadcode(codefile)
     ref   = fileio:open(strcat(strcpy(@filepath, cmdsys:syspath), codefile))
     //puts("ref = "); prbyte(ref); puts(" perr = "); prbyte(perr); putln
     if ref
-        pcode = heapmark
+        pcode = heapalloc(512)
         fileio:read(ref, pcode, 512)
         //puts("Read header bytes: "); puti(seglen)
         //if seglen == 0; puts(" perr = "); prbyte(perr); fin
         //getc; putln
         //dumpheader(pcode)
         //putname(pcode + segname + 8); putc('='); prword(pcode); putln
+        heaprelease(pcode + (pcode + t_diskinfo)=>codeaddr) // REserve heap to end of buffer
         seglen = fileio:read(ref, pcode, (pcode + t_diskinfo)=>codeaddr)
         //puts("Read segment bytes: "); puti(seglen); putln
         fileio:close(ref)
         if !fp6502 and (MACHID & $F0 == $B0) // 128K Apple //e or //c
             seglen = fixup(AUXADDR, pcode + seglen - 2) - pcode
             auxmove(AUXADDR, pcode, seglen)
+            heaprelease(pcode)
             pcode = AUXADDR
         else
             heaprelease(fixup(pcode, pcode + seglen - 2)) // Set heap to beginning of relocation list

src/libsrc/wiznet.pla

@@ -1,993 +0,0 @@
-//
-// Wiznet 5100 based ethernet card
-//
-// TCP/IP is built into hardware, so no dependencies on the software
-// layers, like the Uthernet
-//
-include "inc/cmdsys.plh"
-//
-// Net object
-//
-import inet
-   word iNet
-end
-struc t_inet
-    word initIP
-    word serviceIP
-    word openUDP
-    word sendUDP
-    word closeUDP
-    word listenTCP
-    word connectTCP
-    word sendTCP
-    word closeTCP
-    word setInterfaceIP
-    word getInterfaceHA
-    word setCallback
-    word setParam
-end
-//
-// Module don't free memory
-//
-const modkeep     = $2000
-const modinitkeep = $4000
-//
-// Wiznet registers
-//
-const WIZ_MR     = $00
-const WIZ_GWR    = $01
-const WIZ_SUBR   = $05
-const WIZ_SHAR   = $09
-const WIZ_SIPR   = $0F
-const WIZ_IR     = $15
-const WIZ_IMR    = $16
-const WIZ_RTR    = $17
-const WIZ_RCR    = $19
-const WIZ_RMSR   = $1A
-const WIZ_TMSR   = $1B
-const WIZ_PATR   = $1C
-const WIZ_PTMR   = $28
-const WIZ_PMGC   = $29
-const WIZ_UIPR   = $2A
-const WIZ_UPRT   = $2E
-//
-// Wiznet socket registers
-//
-const WIZ_SREGS   = $0400
-const WIZ_SSIZE   = $0100
-const WIZ_SOCK0   = $0400
-const WIZ_SOCK1   = $0500
-const WIZ_SOCK2   = $0600
-const WIZ_SOCK3   = $0700
-const WIZ_SnMR    = $00
-const WIZ_SnCR    = $01
-const WIZ_SnIR    = $02
-const WIZ_SnSR    = $03
-const WIZ_SnPORT  = $04
-const WIZ_SnDHAR  = $06
-const WIZ_SnDIPR  = $0C
-const WIZ_SnDPORT = $10
-const WIZ_SnMSSR  = $12
-const WIZ_SnPROTO = $14
-const WIZ_SnTOS   = $15
-const WIZ_SnTTL   = $16
-const WIZ_SnFSR   = $20
-const WIZ_SnTXRD  = $22
-const WIZ_SnTXWR  = $24
-const WIZ_SnRSR   = $26
-const WIZ_SnRXRD  = $28
-//
-// Wiznet socket data
-//
-const WIZ_TXMEM  = $4000
-const WIZ_TXSIZE = $0800
-const WIZ_TXMASK = WIZ_TXSIZE-1
-const WIZ_TXMEM0 = $4000
-const WIZ_TXMEM1 = $4800
-const WIZ_TXMEM2 = $5000
-const WIZ_TXMEM3 = $5800
-const WIZ_RXMEM  = $6000
-const WIZ_RXSIZE = $0800
-const WIZ_RXMASK = WIZ_RXSIZE-1
-const WIZ_RXMEM0 = $6000
-const WIZ_RXMEM1 = $6800
-const WIZ_RXMEM2 = $7000
-const WIZ_RXMEM3 = $7800
-//
-// Wiznet indirect registers
-//
-byte regidx, regdata
-word slot, saveidx
-//
-// Wiznet MAC address
-//
-byte[6] wizMAC = $00,$0A,$99,$1E,$02,$B0
-//
-// Wiznet IP addresses
-//
-byte[4] localip
-byte[4] subnet
-byte[4] gateway
-//
-// Predefine service routine
-//
-predef wizServiceIP
-//
-// Segment list element
-//
-struc t_segment
-    word seg_buf
-    word seg_len
-end
-//
-// Max Ethernet frame size
-//
-const MAX_FRAME_SIZE = 1518
-const MAC_BROADCAST  = $FFFF
-const MAC_SIZE       = 6
-//
-// Ethernet header
-//
-struc t_ethrhdr
-    byte[MAC_SIZE] ethr_dst
-    byte[MAC_SIZE] ethr_src
-    word           ethr_payload
-end
-const PAYLOAD_IP  = $0008 // BE format
-const PAYLOAD_ARP = $0608 // BE format
-//
-// IP datagram header
-//
-const IP4ADR_SIZE = 4
-struc t_iphdr
-    byte ip_vers_hlen
-    byte ip_service
-    word ip_length
-    word ip_id
-    word ip_flags_fragofst
-    byte ip_ttl
-    byte ip_proto
-    word ip_chksm
-    byte[IP4ADR_SIZE] ip_src
-    byte[IP4ADR_SIZE] ip_dst
-    byte[] ip_options
-end
-const IP_BROADCAST  = $FFFF
-const IP_PROTO_ICMP = $01
-const IP_PROTO_UDP  = $11
-const IP_PROTO_TCP  = $06
-word bcast = IP_BROADCAST, IP_BROADCAST
-//
-// ICMP type/codes
-//
-const IP_PROTO_ICMP   = 1
-const ICMP_ECHO_REQST = 8
-const ICMP_ECHO_REPLY = 0
-//
-// ICMP message format
-//
-struc t_icmp
-    byte icmp_type
-    byte icmp_code
-    word icmp_chksm
-    word[2] icmp_header
-end
-//
-// UDP IPv4 psuedo header
-//
-struc t_piphdr
-    byte[IP4ADR_SIZE] pip_src
-    byte[IP4ADR_SIZE] pip_dst
-    byte             pip_zero
-    byte             pip_proto
-    word             pip_len
-end
-//
-// UDP header
-//
-struc t_udphdr
-    word udp_src
-    word udp_dst
-    word udp_len
-    word udp_chksm
-end
-//
-// TCP header
-//
-struc t_tcphdr
-    word tcp_src
-    word tcp_dst
-    word tcp_len
-    word tcp_chksm
-end
-//
-// Local network parameters
-//
-const MAX_WIZ_CHANNELS	= 4
-//
-// Channel protocols
-//
-const WIZ_PROTO_CLOSED     = 0
-const WIZ_PROTO_TCP        = 1
-const WIZ_PROTO_UDP	   = 2
-const WIZ_PROTO_IP	   = 3
-const WIZ_PROTO_RAW	   = 4
-//
-// State transistions
-//
-const TCP_STATE_CLOSED	= 0
-const TCP_STATE_CLOSING = 1
-const TCP_STATE_LISTEN  = 2
-const TCP_STATE_CONNECT = 3
-const TCP_STATE_OPEN    = 4
-//
-// HW channels
-//
-struc t_channel
-    byte    channel_proto
-    byte    channel_state
-    word    channel_regs
-    word    channel_txmem
-    word    channel_rxmem
-    word    channel_lclport
-    word    channel_remport
-    byte[4] channel_remip
-    word    channel_recv_func
-    word    channel_recv_parm
-end
-byte[t_channel * MAX_WIZ_CHANNELS] wizChannel
-//
-// Service ICMP hook
-//
-export word hookICMP
-//
-// Defines for ASM routines
-//
-asm equates
-	!SOURCE	"vmsrc/plvmzp.inc"
-end
-//
-// Swap bytes in word
-//
-asm swab
-	LDA	ESTKL,X
-	LDY	ESTKH,X
-	STA	ESTKH,X
-	STY	ESTKL,X
-	RTS
-end
-//
-// Wiznet I/O functions
-//
-// POKE WORD TO I/O SPACE
-// Note: Big Endian format
-//
-asm _pokeiow
-	LDA	ESTKH,X
-end
-asm _pokeiowl
-	STA	$C000
-	LDA	ESTKL,X
-end
-asm _pokeiowh
-	STA	$C000
-	RTS
-end
-//
-// POKE BYTE TO I/O SPACE
-//
-asm _pokeio
-	LDA	ESTKL,X
-end
-asm _pokeiol
-	STA	$C000
-	RTS
-end
-//
-// PEEK BYTE FROM I/O SPACE
-//
-asm _peekio
-	DEX
-end
-asm _peekiol
-	LDA	$C000
-	STA	ESTKL,X
-	LDA	#$00
-	STA	ESTKH,X
-	RTS
-end
-//
-// PEEK WORD FROM I/O SPACE
-// Note: Big Endian format
-//
-asm _peekiow
-	DEX
-end
-asm _peekiowl
-	LDA	$C000
-	STA	ESTKH,X
-end
-asm _peekiowh
-	LDA	$C000
-	STA	ESTKL,X
-	RTS
-end
-//
-// WRITE DATA INTO I/O SPACE
-// pokedata(BUF, LEN)
-//
-asm pokedata
-	LDA	ESTKL+1,X
-	STA	SRCL
-	LDA	ESTKH+1,X
-	STA	SRCH
-	LDY     ESTKL,X
-	BEQ	POKELP
-	LDY	#$00
-	INC     ESTKH,X
-POKELP	LDA	(SRC),Y
-end
-asm _pokedata
-	STA	$C000
-	INY
-	BNE	+
-    	INC	SRCH
-+	DEC	ESTKL,X
-	BNE	POKELP
-	DEC	ESTKH,X
-	BNE	POKELP
-	INX
-	RTS
-end
-//
-// READ DATA FROM I/O SPACE
-// peekdata(BUF, LEN)
-//
-asm peekdata
-	LDA	ESTKL+1,X
-	STA	DSTL
-	LDA	ESTKH+1,X
-	STA	DSTH
-	LDY	ESTKL,X
-	BEQ	PEEKLP
-	LDY	#$00
-	INC     ESTKH,X
-end
-asm _peekdata
-PEEKLP	LDA	$C000
-	STA	(DST),Y
-	INY
-	BNE	+
-    	INC	DSTH
-+	DEC	ESTKL,X
-	BNE	PEEKLP
-	DEC	ESTKH,X
-	BNE	PEEKLP
-	INX
-	RTS
-end
-def pokeiow(io, data)
-    _pokeiowl.1 = io
-    _pokeiowh.1 = io+1
-    return _pokeiow(data)
-end
-def pokeio(io, data)
-    _pokeiol.1 = io
-    return _pokeio(data)
-end
-def peekio(io)
-    _peekiol.1 = io
-    return _peekio()
-end
-def peekiow(io)
-    _peekiowl.1 = io
-    _peekiowh.1 = io+1
-    return _peekiow()
-end
-def pokereg(reg, data)
-    _pokeiow(reg)
-    return _pokeio(data)
-end
-def peekreg(reg)
-    _pokeiow(reg)
-    return _peekio()
-end
-def pokeregs(reg, buf, len)
-//    _pokeiow(reg)
-//    return pokedata(buf, len)
-    word i
-    len = len - 1
-    for i = 0 to len
-        _pokeiow(reg + i)
-	_pokeio(buf->[i])
-    next
-end
-def peekregs(reg, buf, len)
-//    _pokeiow(reg)
-//    return peekdata(buf, len)
-// There is an issue missing data on back-to-back reads
-    word i
-    len = len - 1
-    for i = 0 to len
-        _pokeiow(reg + i)
-	buf->[i] = _peekio()
-    next
-end
-def pokeregw(reg, dataw)
-    _pokeiow(reg)
-    _pokeio(dataw.1)
-    return _pokeio(dataw.0)
-end
-def peekregw(reg)
-    word dataw
-
-    _pokeiow(reg)
-    dataw.1 = _peekio()
-    _pokeiow(reg + 1)
-    dataw.0 = _peekio()
-    return dataw
-end
-//
-// DEBUG
-//
-def putb(hexb)
-    return call($FDDA, hexb, 0, 0, 0)
-end
-def puth(hex)
-    return call($F941, hex >> 8, hex, 0, 0)
-end
-def putip(ipptr)
-    byte i
-
-    for i = 0 to 2
-        puti(ipptr->[i]); putc('.')
-    next
-    return puti(ipptr->[i])
-end
-//
-// Send UDP datagram
-//
-def wizSendUDP(wiz, ipdst, portdst, data, len)
-    word wizregs, wizdata, txrr, txwr, splitlen
-
-    wizregs = wiz=>channel_regs
-    wizdata = wiz=>channel_txmem
-    if !ipdst
-        ipdst = @bcast
-    fin
-    //
-    // Wait for Tx room
-    //
-    repeat; until peekregw(wizregs + WIZ_SnFSR) >= len
-    //
-    // Calc new write ptr, check for split
-    //
-    txwr = peekregw(wizregs + WIZ_SnTXWR)
-    txrr = txwr & WIZ_TXMASK
-    if txrr + len > WIZ_TXSIZE
-        splitlen = WIZ_TXSIZE - txrr
-        pokeregs(wizdata + txrr, data,            splitlen)
-        pokeregs(wizdata,        data + splitlen, len - splitlen)
-     else
-        pokeregs(wizdata + txrr, data, len)
-    fin
-    //
-    // Set destination address/port
-    //
-    pokeregs(wizregs + WIZ_SnDIPR, ipdst, IP4ADR_SIZE)
-    pokeregw(wizregs + WIZ_SnDPORT, portdst)
-    //
-    // Update write pointer and send
-    //
-    pokeregw(wizregs + WIZ_SnTXWR, txwr + len)
-    pokereg(wizregs + WIZ_SnCR, $20) // SEND
-end
-//
-// Open UDP channel and set datagram received callback
-//
-def wizOpenUDP(localport, callback, param)
-    word wiz
-    byte i
-
-    if !localport; return -1; fin // invalid port
-    //
-    // Look for an existing notification on localport
-    //
-    //putc('O')
-    wiz = @wizChannel
-    for i = 1 to MAX_WIZ_CHANNELS
-        if wiz->channel_proto == IP_PROTO_UDP and wiz=>channel_lclport == localport
-            break
-	fin
-	wiz = wiz + t_channel
-    next
-    if i > MAX_WIZ_CHANNELS
-        //
-        // Add notification on localport if room
-        //
-        wiz = @wizChannel
-        for i = 1 to MAX_WIZ_CHANNELS
-            if !wiz->channel_proto
-                break
-	    fin
-	    wiz = wiz + t_channel
-        next
-        if i > MAX_WIZ_CHANNELS
-            return 0
-        fin
-    fin
-    //putc('0' + i);putln
-    //
-    // Fill in this channel and open it
-    //
-    wiz->channel_proto     = WIZ_PROTO_UDP
-    wiz=>channel_lclport   = localport
-    wiz=>channel_recv_func = callback
-    wiz=>channel_recv_parm = param
-    pokeregw(wiz=>channel_regs + WIZ_SnPORT, localport)
-    pokereg(wiz=>channel_regs + WIZ_SnMR, $02) // UDP protocol
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
-    return wiz
-end
-//
-// Close UDP port
-//
-def wizCloseUDP(wiz)
-    //putc('S')
-    if isuge(wiz, @wizChannel) and isult(wiz, @wizChannel + MAX_WIZ_CHANNELS * t_channel)
-	//
-	// Clear notiications on this port
-	//
-        if wiz->channel_proto == WIZ_PROTO_UDP
-	    //putc('1' + ((wiz=>channel_regs - WIZ_SREGS) >> 8));putln
-            wiz->channel_proto = WIZ_PROTO_CLOSED
-            pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-	    return 0
-	fin
-    fin
-    //putc('!');putln
-    //
-    // Invalid port
-    //
-    return -1
-end
-//
-// Open TCP socket in SERVER mode
-//
-def wizListenTCP(lclport, callback, param)
-    word wiz
-    byte i
-
-    //
-    // Look for an existing notification on localport
-    //
-    //putc('L')
-    wiz = @wizChannel
-    for i = 1 to MAX_WIZ_CHANNELS
-        if wiz->channel_proto == WIZ_PROTO_TCP and wiz->channel_state == TCP_STATE_LISTEN and wiz=>channel_lclport == lclport
-            break
-	fin
-	wiz = wiz + t_channel
-    next
-    if i > MAX_WIZ_CHANNELS
-        //
-        // Add notification on localport if room
-        //
-        wiz = @wizChannel
-        for i = 1 to MAX_WIZ_CHANNELS
-            if !wiz->channel_proto
-                break
-	    fin
-	    wiz = wiz + t_channel
-        next
-        if i > MAX_WIZ_CHANNELS
-            return 0
-        fin
-    fin
-    //putc('0' + i);putln
-    //
-    // Fill in this channel and open it
-    //
-    wiz->channel_proto     = WIZ_PROTO_TCP
-    wiz->channel_state     = TCP_STATE_LISTEN
-    wiz=>channel_remip:0   = 0
-    wiz=>channel_remip:2   = 0
-    wiz=>channel_remport   = 0
-    wiz=>channel_lclport   = lclport
-    wiz=>channel_recv_func = callback
-    wiz=>channel_recv_parm = param
-    pokereg(wiz=>channel_regs + WIZ_SnMR, $01) // TCP protocol
-    pokeregw(wiz=>channel_regs + WIZ_SnPORT, lclport)
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
-    while peekreg(wiz=>channel_regs + WIZ_SnSR) <> $13; loop // Wait for init
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $02) // LISTEN
-    return wiz
-end
-//
-// Open TCP socket in CLIENT mode
-//
-def wizConnectTCP(remip, remport, lclport, callback, param)
-    word wiz
-    byte i
-
-    //
-    // Look for an existing notification on localport
-    //
-    wiz = @wizChannel
-    for i = 1 to MAX_WIZ_CHANNELS
-        if wiz->channel_proto == WIZ_PROTO_TCP and wiz->channel_state == TCP_STATE_CONNECT and wiz=>channel_lclport == lclport
-            break
-	fin
-	wiz = wiz + t_channel
-    next
-    if i > MAX_WIZ_CHANNELS
-        //
-        // Add notification on localport if room
-        //
-        wiz = @wizChannel
-        for i = 1 to MAX_WIZ_CHANNELS
-            if !wiz->channel_proto
-                break
-	    fin
-	    wiz = wiz + t_channel
-        next
-        if i > MAX_WIZ_CHANNELS
-            return 0
-        fin
-    fin
-    //
-    // Fill in this channel and open it
-    //
-    wiz->channel_proto     = WIZ_PROTO_TCP
-    wiz->channel_state     = TCP_STATE_CONNECT
-    wiz=>channel_remip:0   = remip=>0
-    wiz=>channel_remip:2   = remip=>2
-    wiz=>channel_remport   = remport
-    wiz=>channel_lclport   = lclport
-    wiz=>channel_recv_func = callback
-    wiz=>channel_recv_parm = param
-    pokereg(wiz=>channel_regs + WIZ_SnMR, $01) // TCP protocol
-    pokeregs(wiz=>channel_regs + WIZ_SnDIPR, remip, IP4ADR_SIZE)
-    pokeregw(wiz=>channel_regs + WIZ_SnDPORT, remport)
-    pokeregw(wiz=>channel_regs + WIZ_SnPORT, lclport)
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
-    while peekreg(wiz=>channel_regs + WIZ_SnSR) <> $13; loop // Wait for init
-    pokereg(wiz=>channel_regs + WIZ_SnCR, $04) // CONNECT
-    return wiz
-end
-//
-// Write to TCP socket
-//
-def wizSendTCP(wiz, data, len)
-    word wizregs, wizdata, txrr, txwr, splitlen
-
-    if wiz->channel_state <> TCP_STATE_OPEN; return -1; fin
-    //putc('W');puti(len);putc(':')
-    wizregs = wiz=>channel_regs
-    wizdata = wiz=>channel_txmem
-    //
-    // Wait for Tx room
-    //
-    repeat; until peekregw(wizregs + WIZ_SnFSR) >= len
-    //
-    // Calc new write ptr, check for split
-    //
-    txwr = peekregw(wizregs + WIZ_SnTXWR)
-    txrr = txwr & WIZ_TXMASK
-    if txrr + len > WIZ_TXSIZE
-        splitlen = WIZ_TXSIZE - txrr
-        pokeregs(wizdata + txrr, data,            splitlen)
-        pokeregs(wizdata,        data + splitlen, len - splitlen)
-        //putc('(');puti(splitlen);putc(',');puti(len-splitlen);putc(')')
-     else
-        pokeregs(wizdata + txrr, data, len)
-    fin
-    //puth(txrr);putc('-');putc('>');puth(txwr+len);putln
-    //
-    // Update write pointer and send
-    //
-    pokeregw(wizregs + WIZ_SnTXWR, txwr + len)
-    pokereg(wizregs + WIZ_SnCR, $20) // SEND
-end
-//
-// Close TCP socket
-//
-def wizCloseTCP(wiz)
-    if isuge(wiz, @wizChannel) and isult(wiz, @wizChannel + MAX_WIZ_CHANNELS * t_channel)
-	//
-	// Clear notiications on this port
-	//
-        if wiz->channel_proto == WIZ_PROTO_TCP and (wiz->channel_state == TCP_STATE_OPEN or wiz->channel_state == TCP_STATE_CLOSING)
-            wiz->channel_state = TCP_STATE_CLOSING
-            pokereg(wiz=>channel_regs + WIZ_SnCR, $08) // DISCON
-	    repeat
-	        wizServiceIP()
-	    until wiz->channel_state == TCP_STATE_CLOSED
-	    wiz->channel_proto = WIZ_PROTO_CLOSED
-	    return 0
-	fin
-    fin
-    //
-    // Invalid port
-    //
-    return -1
-end
-//
-// Update notify callback
-//
-def wizSetCallback(wiz, callback)
-    if wiz->channel_proto == WIZ_PROTO_UDP or wiz->channel_proto == WIZ_PROTO_TCP
-        //
-	// Update callback on this port
-	//
-	wiz=>channel_recv_func = callback
-	return 0
-    fin
-    //
-    // Invalid port
-    //
-    return -1
-end
-//
-// Update notify param
-//
-def wizSetParam(wiz, param)
-    if wiz->channel_proto == WIZ_PROTO_UDP or wiz->channel_proto == WIZ_PROTO_TCP
-        //
-	// Update param on this port
-	//
-	wiz=>channel_recv_parm = param
-	return 0
-    fin
-    //
-    // Invalid port
-    //
-    return -1
-end
-//
-// Service incoming packets
-//
-def wizServiceIP
-    word wiz, wizregs, wizdata, rxlen, rxrr, rxwr, rxpkt, splitlen
-    byte ir, i, sir
-
-    ir = peekreg(WIZ_IR)
-    if ir and ir <> $FF // Ignore spurious read of IR
-        //putc('I');putb(ir)
-        wiz = @wizChannel
-        for i = 0 to 3
-            when ir & (1 << i)
-                is 1
-                is 2
-                is 4
-                is 8
-                    wizregs = wiz=>channel_regs
-                    wizdata = wiz=>channel_rxmem
-                    sir = peekreg(wizregs + WIZ_SnIR)
-                    when wiz->channel_proto
-                        is WIZ_PROTO_TCP
-			    if sir & $01
-			        //putc('C')
-				//
-				// Connect TCP socket
-				//
-				when wiz->channel_state
-				    is TCP_STATE_LISTEN
-				        peekregs(wiz=>channel_regs + WIZ_SnDIPR, @wiz=>channel_remip, IP4ADR_SIZE)
-					wiz=>channel_remport = peekregw(wiz=>channel_regs + WIZ_SnDPORT)
-				    is TCP_STATE_CONNECT
-				        wiz->channel_state = TCP_STATE_OPEN
-					break
-				    otherwise
-				        //putc('?')
-				wend
-			    fin
-                            if sir & $04
-                                //putc('R')
-                                //
-                                // Receive TCP packet
-                                //
-                                rxlen = peekregw(wizregs + WIZ_SnRSR)
-                                rxrr  = peekregw(wizregs + WIZ_SnRXRD)
-                                rxwr  = rxrr & WIZ_RXMASK
-                                rxpkt = heapalloc(rxlen)
-				//puti(rxlen);putc(':')
-				if rxwr + rxlen > WIZ_RXSIZE
-                                    splitlen = WIZ_RXSIZE - rxwr
-                                    peekregs(wizdata + rxwr, rxpkt,            splitlen)
-                                    peekregs(wizdata,        rxpkt + splitlen, rxlen - splitlen)
-				    //putc('(');puti(splitlen);putc(',');puti(rxlen-splitlen);putc(')')
-                                else
-                                    peekregs(wizdata + rxwr, rxpkt, rxlen)
-                                fin
-				//puth(rxwr);putc('-');putc('>');puth(rxwr+rxlen);putln
-                                pokeregw(wizregs + WIZ_SnRXRD, rxrr + rxlen)
-                                pokereg(wizregs + WIZ_SnCR, $40) // RECV
-                                wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,rxpkt,rxlen,wiz=>channel_recv_parm)
-                                heaprelease(rxpkt)
-                            fin
-			    if sir & $02
-			        //putc('S')
-				//
-				// Close TCP socket
-				//
-				when wiz->channel_state
-				    is TCP_STATE_OPEN
-				        wiz->channel_state = TCP_STATE_CLOSING
-					wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,0,wiz=>channel_lclport,0,wiz=>channel_recv_parm)
-					break
-				    is TCP_STATE_CLOSING
-				        wiz->channel_state = TCP_STATE_CLOSED
-				        pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-					break
-				    otherwise
-				        //putc('?')
-				wend
-			    fin
-			    if sir & $08
-			        //putc('T')
-				//
-				// Timeout on TCP socket
-				//
-				when wiz->channel_state
-				    is TCP_STATE_OPEN
-				        wiz->channel_state = TCP_STATE_CLOSING
-					wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
-					break
-				    is TCP_STATE_CONNECT
-					wiz=>channel_recv_func(@wiz=>channel_remip,wiz=>channel_remport,wiz=>channel_lclport,0,0,wiz=>channel_recv_parm)
-				    is TCP_STATE_CLOSING
-				        wiz->channel_state = TCP_STATE_CLOSED
-				        pokereg(wiz=>channel_regs + WIZ_SnCR, $10) // CLOSE
-					break
-				    otherwise
-				        //putc('?')
-				wend
-			    fin
-			    //if sir & $10
-			        //putc('W');putc('O');putc('K');puth(peekregw(wiz=>channel_regs+WIZ_SnTXWR));putln
-				//
-				// Write TCP socket OK
-				//
-			    //fin
-                            break
-                        is WIZ_PROTO_UDP
-                            //putc('U');putb(sir)
-                            if sir & $04
-                                //putc('R')
-                                //
-                                // Receive UDP packet
-                                //
-                                rxlen = peekregw(wizregs + WIZ_SnRSR)
-                                rxrr  = peekregw(wizregs + WIZ_SnRXRD)
-                                rxwr  = rxrr & WIZ_RXMASK
-                                rxpkt = heapalloc(rxlen)
-                                if rxwr + rxlen >= WIZ_RXSIZE
-                                    //putc('!')
-                                    splitlen = WIZ_RXSIZE - rxwr
-                                    peekregs(wizdata + rxwr, rxpkt,            splitlen)
-                                    peekregs(wizdata,        rxpkt + splitlen, rxlen - splitlen)
-                                else
-                                    peekregs(wizdata + rxwr, rxpkt, rxlen)
-                                fin
-                                //putc('=');putip(rxpkt);putc(' ');puti(rxlen)
-                                //putc('/');puti(swab(rxpkt=>6))
-                                //putc(' ');puth(rxrr);putc(' ');puth(rxwr);putln
-                                pokeregw(wizregs + WIZ_SnRXRD, rxrr + rxlen)
-                                pokereg(wizregs + WIZ_SnCR, $40) // RECV
-                                wiz=>channel_recv_func(rxpkt,swab(rxpkt=>4),rxpkt+8,rxlen-8,wiz=>channel_recv_parm)
-                                heaprelease(rxpkt)
-                            fin
-                            break
-                        otherwise
-                    wend
-                    pokereg(wiz=>channel_regs + WIZ_SnIR, sir) // Clear SnIR
-                    ir = ir ^ (1 << i)
-                break
-            wend
-            wiz = wiz + t_channel
-        next
-        if ir
-            //
-            // Clear IR for now
-            //
-            pokereg(WIZ_IR, ir)
-        fin
-    fin
-end
-//
-// Set the local IP addresses
-//
-def setWizIP(newIP, newSubnet, newGateway)
-    if newIP
-        localip:0 = newIP=>0; localip:2 = newIP=>2
-	pokeregs(WIZ_SIPR, newIP, IP4ADR_SIZE)
-    fin
-    if newSubnet
-        subnet:0 = newSubnet=>0; subnet:2 = newSubnet=>2
-	pokeregs(WIZ_SUBR, newSubnet, IP4ADR_SIZE)
-    fin
-    if newGateway
-	gateway:0 = newGateway=>0; gateway:2 = newGateway=>2
-	pokeregs(WIZ_GWR, newGateway, IP4ADR_SIZE)
-    fin
-end
-//
-// Get the interface hardware address
-//
-def getWizHA(ha)
-    if ha
-        ha=>0 = wizMAC:0; ha=>2 = wizMAC:2; ha=>4 = wizMAC:4
-    fin
-    return MAC_SIZE
-end
-//
-// Identify Wiznet card and initialize
-//
-for slot = $90 to $F0 step $10
-    regdata = peekio(slot)
-    if (regdata & $E4) == $00
-        pokeio(slot, $03) // Try setting auto-increment indirect I/F
-	if peekio(slot) == $03
-	    saveidx = peekiow(slot + 1)
-	    peekio(slot + 3) // Dummy read to data register should increment index
-	    if peekiow(slot + 1) == saveidx + 1
-	        //
-		// Good chance this is it
-		//
-		pokeio(slot, $80) // RESET
-		regidx      = slot + 1
-		regdata     = slot + 3
-		_pokedata.1 = regdata
-		_peekdata.1 = regdata
-		pokeio(slot, $03)  // Auto-increment indirect I/F + enable ping
-		//
-		// The following looks redundant, but it sets up the peek/poke locations
-		// for peekreg(s)/pokereg(s)
-		//
-		pokeiow(regidx, WIZ_MR)
-                pokeio(regdata, $03) // Auto-increment indirect I/F + enable ping
-                peekio(regdata)
-		//
-		// Initialize common registers
-		//
-		pokeregs(WIZ_SHAR, @wizMAC, 6) // MAC addr
-                pokeregw(WIZ_RTR, 5000) // Timeout period to 500ms
-                pokereg(WIZ_RMSR, $55) // 2K Rx memory/channel
-                pokereg(WIZ_TMSR, $55) // 2K Tx memory/channel
-                //
-                // Fill channel structure
-                //
-                saveidx = @wizChannel
-                for slot = 0 to 3
-                    saveidx=>channel_regs  = WIZ_SREGS + (WIZ_SSIZE * slot)
-                    saveidx=>channel_txmem = WIZ_TXMEM + (WIZ_TXSIZE * slot)
-                    saveidx=>channel_rxmem = WIZ_RXMEM + (WIZ_RXSIZE * slot)
-                    saveidx = saveidx + t_channel
-                next
-		//
-		// Fill in Net class
-		//
-		iNet:serviceIP      = @wizServiceIP
-		iNet:openUDP        = @wizOpenUDP
-		iNet:sendUDP        = @wizSendUDP
-		iNet:closeUDP       = @wizCloseUDP
-		iNet:listenTCP      = @wizListenTCP
-		iNet:connectTCP     = @wizConnectTCP
-		iNet:sendTCP        = @wizSendTCP
-		iNet:closeTCP       = @wizCloseTCP
-		iNet:setInterfaceIP = @setWizIP
-		iNet:getInterfaceHA = @getWizHA
-		iNet:setCallback    = @wizSetCallback
-		iNet:setParam       = @wizSetParam
-                return modkeep
-	    fin
-        fin
-	pokeio(slot, regdata) // Restore register
-    fin
-next
-//
-// Not found
-//
-return -1
-done

src/makefile

@@ -4,16 +4,33 @@ PLVM       = plvm
 PLVMZP_APL = vmsrc/apple/plvmzp.inc
 PLVM01     = rel/apple/A1PLASMA\#060280
 PLVM02	   = rel/apple/PLASMA.SYSTEM\#FF2000
-PLVM802	   = rel/apple/PLASMA16.SYSTEM\#FF2000
+PLVMJIT    = rel/apple/PLVM.128\#FF2000
+PLVM802	   = rel/apple/PLVM16\#FF2000
 PLVM03	   = rel/apple/SOS.INTERP\#050000
+PLVMJIT03  = rel/apple/SOS.INTERPJIT\#050000
+SOSCMD     = rel/apple/SOS.CMD\#FE1000
+SOSCMDJIT  = rel/apple/SOS.CMDJIT\#FE1000
 CMD        = rel/apple/CMD\#061000
+CMDJIT     = rel/apple/CMD128\#061000
 PLVMZP_C64 = vmsrc/c64/plvmzp.inc
 PLVMC64    = rel/c64/PLASMA
 ED         = rel/ED\#FE1000
+ZIPCHIP    = rel/apple/ZIPCHIP\#FE1000
+JIT        = rel/apple/JIT\#FE1000
+JIT16      = rel/apple/JIT16\#FE1000
+JITUNE     = rel/apple/JITUNE\#FE1000
 SOS        = rel/apple/SOS\#FE1000
-ROD        = rel/ROD\#FE1000
+ROD        = rel/apple/ROD\#FE1000
+COPY       = rel/apple/COPY\#FE1000
+DEL        = rel/apple/DEL\#FE1000
+REN        = rel/apple/REN\#FE1000
+CAT        = rel/apple/CAT\#FE1000
+NEWDIR     = rel/apple/NEWDIR\#FE1000
+TYPE       = rel/apple/TYPE\#FE1000
 SIEVE      = rel/SIEVE\#FE1000
+PRIMEGAP   = rel/PRIMEGAP\#FE1000
 ARGS       = rel/ARGS\#FE1000
+MATCHFILES = rel/apple/MATCHFILES\#FE1000
 SPIPORT    = rel/apple/SPIPORT\#FE1000
 SDFAT      = rel/apple/SDFAT\#FE1000
 FATCAT     = rel/apple/FATCAT\#FE1000
@@ -23,6 +40,8 @@ FATWDSK    = rel/apple/FATWRITEDSK\#FE1000
 FATRDSK    = rel/apple/FATREADDSK\#FE1000
 FILEIO_APL = rel/apple/FILEIO\#FE1000
 CONIO_APL  = rel/apple/CONIO\#FE1000
+INT32      = rel/INT32\#FE1000
+INT32TEST  = rel/INT32TEST\#FE1000
 SANE       = rel/SANE\#FE1000
 FPSTR      = rel/FPSTR\#FE1000
 FPU        = rel/FPU\#FE1000
@@ -30,14 +49,26 @@ SNDSEQ     = rel/apple/SNDSEQ\#FE1000
 PLAYSEQ    = rel/apple/PLAYSEQ\#FE1000
 SANITY     = rel/SANITY\#FE1000
 RPNCALC    = rel/RPNCALC\#FE1000
+LZ4        = rel/LZ4\#FE1000
+LZ4CAT     = rel/LZ4CAT\#FE1000
+MOUSE      = rel/apple/MOUSE\#FE1000
 UTHERNET2  = rel/apple/UTHERNET2\#FE1000
 UTHERNET   = rel/apple/UTHERNET\#FE1000
 ETHERIP    = rel/ETHERIP\#FE1000
 INET       = rel/INET\#FE1000
 DHCP       = rel/DHCP\#FE1000
 HTTPD      = rel/HTTPD\#FE1000
-DGR        = rel/apple/DGR\#FE1000
+TFTPD      = rel/TFTPD\#FE1000
+HGRLIB     = rel/apple/HGRLIB\#FE1000
+GRLIB      = rel/apple/GRLIB\#FE1000
+DGRLIB     = rel/apple/DGRLIB\#FE1000
+HGRSPRITE  = rel/apple/HGRSPRITE\#FE1000
+HGRTILE    = rel/apple/HGRTILE\#FE1000
+HGRFONT    = rel/apple/HGRFONT\#FE1000
+LINES      = rel/LINES\#FE1000
 GRAFIX     = rel/apple/GRAFIX\#FE1000
+SFM        = rel/apple/SFM\#FE1000
+SFMSPRT    = rel/apple/SFMSPRT\#FE1000
 GFXDEMO    = rel/apple/GFXDEMO\#FE1000
 JOYBUZZ    = rel/apple/JOYBUZZ\#FE1000
 PORTIO     = rel/apple/PORTIO\#FE1000
@@ -45,6 +76,9 @@ ROGUE      = rel/ROGUE\#FE1000
 ROGUEMAP   = rel/ROGUEMAP\#FE1000
 ROGUECOMBAT= rel/ROGUECOMBAT\#FE1000
 MON        = rel/apple/MON\#FE1000
+TILETEST   = rel/apple/TILETEST\#FE1000
+HGRTEST    = rel/apple/HGRTEST\#FE1000
+GRTEST     = rel/apple/GRTEST\#FE1000
 DGRTEST    = rel/apple/DGRTEST\#FE1000
 MEMMGR     = rel/MEMMGR\#FE1000
 MEMTEST    = rel/MEMTEST\#FE1000
@@ -75,7 +109,8 @@ TXTTYPE	= .TXT
 #SYSTYPE	= \#FF2000
 #TXTTYPE	= \#040000
 
-apple: $(PLVMZP_APL) $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVM802) $(PLVM03) $(CMD) $(PLASMAPLASM) $(CODEOPT) $(ARGS) $(MEMMGR) $(MEMTEST) $(FIBER) $(FIBERTEST) $(LONGJMP) $(ED) $(MON) $(SOS) $(ROD) $(SIEVE) $(UTHERNET2) $(UTHERNET) $(ETHERIP) $(INET) $(DHCP) $(HTTPD) $(ROGUE) $(ROGUEMAP) $(ROGUECOMBAT) $(GRAFIX) $(GFXDEMO) $(DGR) $(DGRTEST) $(FILEIO_APL) $(CONIO_APL) $(JOYBUZZ) $(PORTIO) $(SPIPORT) $(SDFAT) $(FATCAT) $(FATGET) $(FATPUT) $(FATWDSK) $(FATRDSK) $(SANE) $(FPSTR) $(FPU) $(SANITY) $(RPNCALC) $(SNDSEQ) $(PLAYSEQ)
+apple: $(PLVMZP_APL) $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVMJIT) $(PLVM802) $(PLVM03) $(PLVMJIT03) $(CMD) $(CMDJIT) $(JIT) $(JIT16) $(JITUNE) $(SOSCMD) $(SOSCMDJIT) $(PLASMAPLASM) $(CODEOPT) $(ZIPCHIP) $(MATCHFILES) $(ARGS) $(MEMMGR) $(MEMTEST) $(FIBER) $(FIBERTEST) $(LONGJMP) $(ED) $(MON) $(COPY) $(DEL) $(REN) $(CAT) $(NEWDIR) $(TYPE) $(SOS) $(ROD) $(SIEVE) $(PRIMEGAP) $(MOUSE) $(UTHERNET2) $(UTHERNET) $(ETHERIP) $(INET) $(DHCP) $(HTTPD) $(TFTPD) $(ROGUE) $(ROGUEMAP) $(ROGUECOMBAT) $(SFM) $(SFMSPRT) $(GRAFIX) $(GFXDEMO) $(LINES) $(HGRTILE) $(HGRFONT) $(HGRSPRITE) $(HGRLIB) $(TILETEST) $(HGRTEST) $(GRLIB) $(DGRLIB) $(GRTEST) $(DGRTEST) $(HGRTEST) $(FILEIO_APL) $(CONIO_APL) $(JOYBUZZ) $(PORTIO) $(SPIPORT) $(SDFAT) $(FATCAT) $(FATGET) $(FATPUT) $(FATWDSK) $(FATRDSK) $(INT32) $(INT32TEST) $(SANE) $(FPSTR) $(FPU) $(SANITY) $(LZ4) $(LZ4CAT) $(RPNCALC) $(SNDSEQ) $(PLAYSEQ)
+
 	-rm vmsrc/plvmzp.inc
 
 c64: $(PLVMZP_C64) $(PLASM) $(PLVM) $(PLVMC64) 
@@ -84,10 +119,8 @@ c64: $(PLVMZP_C64) $(PLASM) $(PLVM) $(PLVMC64)
 all: apple c64
 
 clean:
-	-rm *FE1000 *FF2000 $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVM03)
-	-rm rel/*
-	-rm rel/apple/*
-	-rm rel/c64/*
+	-rm *FE1000 *FF2000 $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVMJIT) $(PLVM03)
+	-rm -rf rel
 	-rm samplesrc/*.o samplesrc/*~ samplesrc/*.a
 	-rm toolsrc/*.o toolsrc/*~ toolsrc/*.a
 	-rm toolsrc/apple/*.o toolsrc/apple/*~ toolsrc/apple/*.a
@@ -98,7 +131,9 @@ clean:
 	-rm libsrc/*.o libsrc/*~ libsrc/*.a
 	-rm libsrc/apple/*.o libsrc/apple/*~ libsrc/apple/*.a
 	-rm libsrc/c64/*.o libsrc/c64/*~ libsrc/c64/*.a
-	-rm libsrc/*.o libsrc/*~ libsrc/*.a
+	-rm utilsrc/*.o utilsrc/*~ utilsrc/*.a
+	-rm utilsrc/apple/*.o utilsrc/apple/*~ utilsrc/apple/*.a
+	-rm utilsrc/c64/*.o utilsrc/c64/*~ utilsrc/c64/*.a
 
 #
 # PLASMA compiler: plasm
@@ -150,18 +185,38 @@ $(CMD): vmsrc/apple/cmd.pla vmsrc/apple/cmdstub.s $(PLVM02) $(PLASM)
 	./$(PLASM) -AOW < vmsrc/apple/cmd.pla > vmsrc/apple/cmd.a
 	acme --setpc 8192 -o $(CMD) vmsrc/apple/cmdstub.s
 
+$(CMDJIT): vmsrc/apple/cmdjit.pla vmsrc/apple/cmdjitstub.s $(PLVMJIT) $(PLASM)
+	./$(PLASM) -AOW < vmsrc/apple/cmdjit.pla > vmsrc/apple/cmdjit.a
+	acme --setpc 8192 -o $(CMDJIT) vmsrc/apple/cmdjitstub.s
+
+$(SOSCMD): vmsrc/apple/soscmd.pla $(PLVM03) $(PLASM)
+	./$(PLASM) -AMOW < vmsrc/apple/soscmd.pla > vmsrc/apple/soscmd.a
+	acme --setpc 4094 -o $(SOSCMD) vmsrc/apple/soscmd.a
+
+$(SOSCMDJIT): vmsrc/apple/soscmdjit.pla libsrc/jitcore.pla $(PLVMJIT03) $(PLASM)
+	./$(PLASM) -AMOW < vmsrc/apple/soscmdjit.pla > vmsrc/apple/soscmdjit.a
+	acme --setpc 4094 -o $(SOSCMDJIT) vmsrc/apple/soscmdjit.a
+
 $(PLVM02): vmsrc/apple/plvm02.s
 	acme -o $(PLVM02) -l vmsrc/apple/plvm02.sym vmsrc/apple/plvm02.s
 
+$(PLVMJIT): vmsrc/apple/plvmjit02.s
+	acme -o $(PLVMJIT) -l vmsrc/apple/plvmjit02.sym vmsrc/apple/plvmjit02.s
+
 $(PLVM802): vmsrc/apple/plvm802.s
 	acme -o $(PLVM802) -l vmsrc/apple/plvm802.sym vmsrc/apple/plvm802.s
 
-vmsrc/apple/soscmd.a: vmsrc/apple/soscmd.pla $(PLASM)
-	./$(PLASM) -AOW < vmsrc/apple/soscmd.pla > vmsrc/apple/soscmd.a
+vmsrc/apple/sossys.a: vmsrc/apple/sossys.pla $(PLASM)
+	./$(PLASM) -AOW < vmsrc/apple/sossys.pla > vmsrc/apple/sossys.a
 
-$(PLVM03): vmsrc/apple/plvm03.s vmsrc/apple/soscmd.a
+$(PLVM03): vmsrc/apple/plvm03.s vmsrc/apple/sossys.a
 	acme -o $(PLVM03) -l vmsrc/apple/plvm03.sym vmsrc/apple/plvm03.s
 
+vmsrc/apple/sossysjit.a: vmsrc/apple/sossysjit.pla $(PLASM)
+	./$(PLASM) -AOW < vmsrc/apple/sossysjit.pla > vmsrc/apple/sossysjit.a
+
+$(PLVMJIT03): vmsrc/apple/plvmjit03.s vmsrc/apple/sossysjit.a
+	acme -o $(PLVMJIT03) -l vmsrc/apple/plvmjit03.sym vmsrc/apple/plvmjit03.s
 #
 # Sample code
 #
@@ -176,6 +231,10 @@ $(ED): toolsrc/ed.pla $(PLVM02) $(PLASM) toolsrc/ed.pla
 	./$(PLASM) -AMOW < toolsrc/ed.pla > toolsrc/ed.a
 	acme --setpc 4094 -o $(ED) toolsrc/ed.a
 
+$(MATCHFILES): libsrc/apple/matchfiles.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/matchfiles.pla > libsrc/apple/matchfiles.a
+	acme --setpc 4094 -o $(MATCHFILES) libsrc/apple/matchfiles.a
+
 $(ARGS): libsrc/args.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/args.pla > libsrc/args.a
 	acme --setpc 4094 -o $(ARGS) libsrc/args.a
@@ -192,6 +251,10 @@ $(FIBER): libsrc/fiber.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/fiber.pla > libsrc/fiber.a
 	acme --setpc 4094 -o $(FIBER) libsrc/fiber.a
 
+$(LINES): libsrc/lines.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/lines.pla > libsrc/lines.a
+	acme --setpc 4094 -o $(LINES) libsrc/lines.a
+
 $(FIBERTEST): samplesrc/fibertest.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/fibertest.pla > samplesrc/fibertest.a
 	acme --setpc 4094 -o $(FIBERTEST) samplesrc/fibertest.a
@@ -200,6 +263,14 @@ $(LONGJMP): libsrc/longjmp.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/longjmp.pla > libsrc/longjmp.a
 	acme --setpc 4094 -o $(LONGJMP) libsrc/longjmp.a
 
+$(SFM): samplesrc/sfm.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/sfm.pla > samplesrc/sfm.a
+	acme --setpc 4094 -o $(SFM) samplesrc/sfm.a
+
+$(SFMSPRT): samplesrc/sfmsprt.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/sfmsprt.pla > samplesrc/sfmsprt.a
+	acme --setpc 4094 -o $(SFMSPRT) samplesrc/sfmsprt.a
+
 $(ROGUE): samplesrc/rogue.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/rogue.pla > samplesrc/rogue.a
 	acme --setpc 4094 -o $(ROGUE) samplesrc/rogue.a
@@ -217,13 +288,25 @@ hello:	samplesrc/hello.pla $(PLVM) $(PLASM)
 	acme --setpc 4094 -o $(HELLO) samplesrc/hello.a
 	./$(PLVM) HELLO
 $(ROD): samplesrc/rod.pla $(PLVM02) $(PLASM)
-	./$(PLASM) -AMO < samplesrc/rod.pla > samplesrc/rod.a
+	./$(PLASM) -AMOW < samplesrc/rod.pla > samplesrc/rod.a
 	acme --setpc 4094 -o $(ROD) samplesrc/rod.a
 
 $(SIEVE): samplesrc/sieve.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMW < samplesrc/sieve.pla > samplesrc/sieve.a
 	acme --setpc 4094 -o $(SIEVE) samplesrc/sieve.a
 
+$(PRIMEGAP): samplesrc/primegap.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMW < samplesrc/primegap.pla > samplesrc/primegap.a
+	acme --setpc 4094 -o $(PRIMEGAP) samplesrc/primegap.a
+
+$(INT32): libsrc/int32.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/int32.pla > libsrc/int32.a
+	acme --setpc 4094 -o $(INT32) libsrc/int32.a
+
+$(INT32TEST): samplesrc/int32test.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/int32test.pla > samplesrc/int32test.a
+	acme --setpc 4094 -o $(INT32TEST) samplesrc/int32test.a
+
 $(SANE): libsrc/sane.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/sane.pla > libsrc/sane.a
 	acme --setpc 4094 -o $(SANE) libsrc/sane.a
@@ -240,6 +323,14 @@ $(SANITY): samplesrc/sanity.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/sanity.pla > samplesrc/sanity.a
 	acme --setpc 4094 -o $(SANITY) samplesrc/sanity.a
 
+$(LZ4): libsrc/lz4.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/lz4.pla > libsrc/lz4.a
+	acme --setpc 4094 -o $(LZ4) libsrc/lz4.a
+
+$(LZ4CAT): samplesrc/lz4cat.pla inc/lz4.plh $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/lz4cat.pla > samplesrc/lz4cat.a
+	acme --setpc 4094 -o $(LZ4CAT) samplesrc/lz4cat.a
+
 $(RPNCALC): samplesrc/rpncalc.pla libsrc/fpu.pla inc/fpu.plh libsrc/fpstr.pla inc/fpstr.plh inc/conio.plh $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/rpncalc.pla > samplesrc/rpncalc.a
 	acme --setpc 4094 -o $(RPNCALC) samplesrc/rpncalc.a
@@ -260,6 +351,14 @@ $(HTTPD): samplesrc/httpd.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/httpd.pla > samplesrc/httpd.a
 	acme --setpc 4094 -o $(HTTPD) samplesrc/httpd.a
 
+$(TFTPD): utilsrc/tftpd.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/tftpd.pla > utilsrc/tftpd.a
+	acme --setpc 4094 -o $(TFTPD) utilsrc/tftpd.a
+
+$(MOUSE): libsrc/apple/mouse.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/mouse.pla > libsrc/apple/mouse.a
+	acme --setpc 4094 -o $(MOUSE) libsrc/apple/mouse.a
+
 $(UTHERNET): libsrc/apple/uthernet.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/apple/uthernet.pla > libsrc/apple/uthernet.a
 	acme --setpc 4094 -o $(UTHERNET) libsrc/apple/uthernet.a
@@ -336,19 +435,92 @@ $(PORTIO): libsrc/apple/portio.pla $(PLVM02) $(PLASM)
 	./$(PLASM) -AMOW < libsrc/apple/portio.pla > libsrc/apple/portio.a
 	acme --setpc 4094 -o $(PORTIO) libsrc/apple/portio.a
 
-$(DGR): libsrc/apple/dgr.pla $(PLVM02) $(PLASM)
-	./$(PLASM) -AMOW < libsrc/apple/dgr.pla > libsrc/apple/dgr.a
-	acme --setpc 4094 -o $(DGR) libsrc/apple/dgr.a
+$(HGRLIB): libsrc/apple/hgrlib.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/hgrlib.pla > libsrc/apple/hgrlib.a
+	acme --setpc 4094 -o $(HGRLIB) libsrc/apple/hgrlib.a
 
-$(DGRTEST): samplesrc/dgrtest.pla $(PLVM02) $(PLASM)
+$(GRLIB): libsrc/apple/grlib.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/grlib.pla > libsrc/apple/grlib.a
+	acme --setpc 4094 -o $(GRLIB) libsrc/apple/grlib.a
+
+$(DGRLIB): libsrc/apple/dgrlib.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/dgrlib.pla > libsrc/apple/dgrlib.a
+	acme --setpc 4094 -o $(DGRLIB) libsrc/apple/dgrlib.a
+
+$(TILETEST): samplesrc/tiletest.pla $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/tiletest.pla > samplesrc/tiletest.a
+	acme --setpc 4094 -o $(TILETEST) samplesrc/tiletest.a
+
+$(HGRTILE): libsrc/apple/hgrtile.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/hgrtile.pla > libsrc/apple/hgrtile.a
+	acme --setpc 4094 -o $(HGRTILE) libsrc/apple/hgrtile.a
+
+$(HGRFONT): libsrc/apple/hgrfont.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/hgrfont.pla > libsrc/apple/hgrfont.a
+	acme --setpc 4094 -o $(HGRFONT) libsrc/apple/hgrfont.a
+
+$(HGRSPRITE): libsrc/apple/hgrsprite.pla $(PLVM02) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/hgrsprite.pla > libsrc/apple/hgrsprite.a
+	acme --setpc 4094 -o $(HGRSPRITE) libsrc/apple/hgrsprite.a
+
+$(HGRTEST): samplesrc/hgrtest.pla $(HGRLIB) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/hgrtest.pla > samplesrc/hgrtest.a
+	acme --setpc 4094 -o $(HGRTEST) samplesrc/hgrtest.a
+
+$(GRTEST): samplesrc/grtest.pla $(GRLIB) $(PLASM)
+	./$(PLASM) -AMOW < samplesrc/grtest.pla > samplesrc/grtest.a
+	acme --setpc 4094 -o $(GRTEST) samplesrc/grtest.a
+
+$(DGRTEST): samplesrc/dgrtest.pla $(DGRLIB) $(PLASM)
 	./$(PLASM) -AMOW < samplesrc/dgrtest.pla > samplesrc/dgrtest.a
 	acme --setpc 4094 -o $(DGRTEST) samplesrc/dgrtest.a
 
-$(MON): samplesrc/mon.pla $(PLVM02) $(PLASM)
-	./$(PLASM) -AMOW < samplesrc/mon.pla > samplesrc/mon.a
-	acme --setpc 4094 -o $(MON) samplesrc/mon.a
+$(MON): utilsrc/apple/mon.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/mon.pla > utilsrc/apple/mon.a
+	acme --setpc 4094 -o $(MON) utilsrc/apple/mon.a
+
+$(COPY): utilsrc/apple/copy.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/copy.pla > utilsrc/apple/copy.a
+	acme --setpc 4094 -o $(COPY) utilsrc/apple/copy.a
+
+$(DEL): utilsrc/apple/del.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/del.pla > utilsrc/apple/del.a
+	acme --setpc 4094 -o $(DEL) utilsrc/apple/del.a
+
+$(REN): utilsrc/apple/ren.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/ren.pla > utilsrc/apple/ren.a
+	acme --setpc 4094 -o $(REN) utilsrc/apple/ren.a
+
+$(CAT): utilsrc/apple/cat.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/cat.pla > utilsrc/apple/cat.a
+	acme --setpc 4094 -o $(CAT) utilsrc/apple/cat.a
+
+$(NEWDIR): utilsrc/apple/newdir.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/newdir.pla > utilsrc/apple/newdir.a
+	acme --setpc 4094 -o $(NEWDIR) utilsrc/apple/newdir.a
+
+$(TYPE): utilsrc/apple/type.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/type.pla > utilsrc/apple/type.a
+	acme --setpc 4094 -o $(TYPE) utilsrc/apple/type.a
+
+$(SOS): utilsrc/apple/sos.pla $(PLVM03) $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/sos.pla > utilsrc/apple/sos.a
+	acme --setpc 4094 -o $(SOS) utilsrc/apple/sos.a
+
+$(ZIPCHIP): utilsrc/apple/zipchip.pla $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/zipchip.pla > utilsrc/apple/zipchip.a
+	acme --setpc 4094 -o $(ZIPCHIP) utilsrc/apple/zipchip.a
+
+$(JIT): libsrc/apple/jit.pla libsrc/jitcore.pla $(PLVMJIT) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/jit.pla > libsrc/apple/jit.a
+	acme --setpc 4094 -o $(JIT) libsrc/apple/jit.a
+
+$(JIT16): libsrc/apple/jit16.pla libsrc/jit16core.pla $(PLVMJIT) $(PLASM)
+	./$(PLASM) -AMOW < libsrc/apple/jit16.pla > libsrc/apple/jit16.a
+	acme --setpc 4094 -o $(JIT16) libsrc/apple/jit16.a
+
+$(JITUNE): utilsrc/apple/jitune.pla $(PLVMJIT) $(PLASM)
+	./$(PLASM) -AMOW < utilsrc/apple/jitune.pla > utilsrc/apple/jitune.a
+	acme --setpc 4094 -o $(JITUNE) utilsrc/apple/jitune.a
 
-$(SOS): libsrc/apple/sos.pla $(PLVM02) $(PLASM)
-	./$(PLASM) -AMO < libsrc/apple/sos.pla > libsrc/apple/sos.a
-	acme --setpc 4094 -o $(SOS) libsrc/apple/sos.a
 

src/mkrel

@@ -1,111 +1,251 @@
-cp rel/apple/CMD#061000 prodos/CMD.BIN
+cp rel/apple/CMD#061000           prodos/CMD.BIN
+cp rel/apple/CMD128#061000        prodos/CMD128.BIN
 cp rel/apple/PLASMA.SYSTEM#FF2000 prodos/PLASMA.SYSTEM.SYS
-cp rel/apple/PLASMA16.SYSTEM#FF2000 prodos/PLASMA16.SYSTEM.SYS
-cp rel/apple/SOS.INTERP#050000 prodos/SOS.INTERP.\$05
-cp ../doc/Editor.md prodos/EDITOR.README.TXT
+cp rel/apple/PLVM.128#FF2000      prodos/PLVM.128.SYS
+cp rel/apple/PLVM16#FF2000        prodos/PLVM16.SYS
+cp ../doc/Editor.md               prodos/EDITOR.README.TXT
 
 rm -rf prodos/sys
 mkdir prodos/sys
-cp rel/ARGS#FE1000 prodos/sys/ARGS.REL
-cp rel/apple/CONIO#FE1000 prodos/sys/CONIO.REL
-cp rel/apple/DGR#FE1000 prodos/sys/DGR.REL
-cp rel/DHCP#FE1000 prodos/sys/DHCP.REL
-cp rel/ED#FE1000 prodos/sys/ED.REL
-cp rel/ETHERIP#FE1000 prodos/sys/ETHERIP.REL
-cp rel/FIBER#FE1000 prodos/sys/FIBER.REL
-cp rel/apple/FILEIO#FE1000 prodos/sys/FILEIO.REL
-cp rel/FPSTR#FE1000 prodos/sys/FPSTR.REL
-cp rel/FPU#FE1000 prodos/sys/FPU.REL
-cp rel/INET#FE1000 prodos/sys/INET.REL
-cp rel/LONGJMP#FE1000 prodos/sys/LONGJMP.REL
-cp rel/MEMMGR#FE1000 prodos/sys/MEMMGR.REL
-cp rel/apple/PORTIO#FE1000 prodos/sys/PORTIO.REL
-cp rel/apple/JOYBUZZ#FE1000 prodos/sys/JOYBUZZ.REL
-cp rel/SANE#FE1000 prodos/sys/SANE.REL
-cp rel/apple/SDFAT#FE1000 prodos/sys/SDFAT.REL
-cp rel/apple/SPIPORT#FE1000 prodos/sys/SPIPORT.REL
-cp rel/apple/SNDSEQ#FE1000 prodos/sys/SNDSEQ.REL
-cp rel/apple/UTHERNET#FE1000 prodos/sys/UTHERNET.REL
-cp rel/apple/UTHERNET2#FE1000 prodos/sys/UTHERNET2.REL
-cp rel/apple/SOS#FE1000 prodos/sys/SOS.REL
-cp rel/apple/GRAFIX#FE1000 prodos/sys/GRAFIX.REL
+cp rel/apple/FILEIO#FE1000        prodos/sys/FILEIO.REL
+cp rel/apple/CONIO#FE1000         prodos/sys/CONIO.REL
+cp rel/LINES#FE1000               prodos/sys/LINES.REL
+cp rel/apple/HGRFONT#FE1000       prodos/sys/HGRFONT.REL
+cp rel/apple/HGRTILE#FE1000       prodos/sys/HGRTILE.REL
+cp rel/apple/HGRSPRITE#FE1000     prodos/sys/HGRSPRITE.REL
+cp rel/apple/HGRLIB#FE1000        prodos/sys/HGRLIB.REL
+cp rel/apple/GRLIB#FE1000         prodos/sys/GRLIB.REL
+cp rel/apple/DGRLIB#FE1000        prodos/sys/DGRLIB.REL
+cp rel/apple/COPY#FE1000          prodos/sys/COPY.REL
+cp rel/apple/DEL#FE1000           prodos/sys/DEL.REL
+cp rel/apple/REN#FE1000           prodos/sys/REN.REL
+cp rel/apple/CAT#FE1000           prodos/sys/CAT.REL
+cp rel/apple/NEWDIR#FE1000        prodos/sys/NEWDIR.REL
+cp rel/apple/TYPE#FE1000          prodos/sys/TYPE.REL
+cp rel/apple/MATCHFILES#FE1000    prodos/sys/MATCHFILES.REL
+cp rel/ARGS#FE1000                prodos/sys/ARGS.REL
+cp rel/ED#FE1000                  prodos/sys/ED.REL
+cp rel/FIBER#FE1000               prodos/sys/FIBER.REL
+cp rel/LONGJMP#FE1000             prodos/sys/LONGJMP.REL
+cp rel/MEMMGR#FE1000              prodos/sys/MEMMGR.REL
+cp rel/INET#FE1000                prodos/sys/INET.REL
+cp rel/DHCP#FE1000                prodos/sys/DHCP.REL
+cp rel/ETHERIP#FE1000             prodos/sys/ETHERIP.REL
+cp rel/apple/MOUSE#FE1000         prodos/sys/MOUSE.REL
+cp rel/apple/UTHERNET2#FE1000     prodos/sys/UTHERNET2.REL
+cp rel/apple/UTHERNET#FE1000      prodos/sys/UTHERNET.REL
+cp rel/apple/PORTIO#FE1000        prodos/sys/PORTIO.REL
+cp rel/apple/JOYBUZZ#FE1000       prodos/sys/JOYBUZZ.REL
+cp rel/apple/SNDSEQ#FE1000        prodos/sys/SNDSEQ.REL
+cp rel/apple/JIT#FE1000           prodos/sys/JIT.REL
+cp rel/apple/JIT16#FE1000         prodos/sys/JIT16.REL
+cp rel/apple/JITUNE#FE1000        prodos/sys/JITUNE.REL
+cp rel/apple/ZIPCHIP#FE1000       prodos/sys/ZIPCHIP.REL
+cp rel/LZ4#FE1000                 prodos/sys/LZ4.REL
+cp rel/TFTPD#FE1000               prodos/sys/TFTPD.REL
+cp rel/INT32#FE1000               prodos/sys/INT32.REL
+cp rel/FPSTR#FE1000               prodos/sys/FPSTR.REL
+cp rel/FPU#FE1000                 prodos/sys/FPU.REL
+cp rel/SANE#FE1000                prodos/sys/SANE.REL
 cp ../sysfiles/FP6502.CODE#060000 prodos/sys/FP6502.CODE.BIN
-cp ../sysfiles/ELEMS.CODE#060000 prodos/sys/ELEMS.CODE.BIN
+cp ../sysfiles/ELEMS.CODE#060000  prodos/sys/ELEMS.CODE.BIN
+cp rel/apple/SOS#FE1000           prodos/sys/SOS.REL
+cp rel/apple/GRAFIX#FE1000        prodos/sys/GRAFIX.REL
+
+rm -rf prodos/syspro
+mkdir prodos/syspro
+cp ../sysfiles/PRODOS#FF0000      prodos/syspro/PRODOS.SYS
+cp rel/apple/CMD#061000           prodos/syspro/CMD.BIN
+cp rel/apple/CMD128#061000        prodos/syspro/CMD128.BIN
+cp rel/apple/PLASMA.SYSTEM#FF2000 prodos/syspro/PLASMA.SYSTEM.SYS
+cp rel/apple/PLVM.128#FF2000      prodos/syspro/PLVM.128.SYS
+cp rel/apple/PLVM16#FF2000        prodos/syspro/PLVM16.SYS
+cp ../doc/Editor.md               prodos/syspro/EDITOR.README.TXT
+
+mkdir prodos/syspro/sys
+cp rel/apple/FILEIO#FE1000        prodos/syspro/sys/FILEIO.REL
+cp rel/apple/CONIO#FE1000         prodos/syspro/sys/CONIO.REL
+cp rel/LINES#FE1000               prodos/syspro/sys/LINES.REL
+cp rel/apple/HGRFONT#FE1000       prodos/syspro/sys/HGRFONT.REL
+cp rel/apple/HGRTILE#FE1000       prodos/syspro/sys/HGRTILE.REL
+cp rel/apple/HGRSPRITE#FE1000     prodos/syspro/sys/HGRSPRITE.REL
+cp rel/apple/HGRLIB#FE1000        prodos/syspro/sys/HGRLIB.REL
+cp rel/apple/GRLIB#FE1000         prodos/syspro/sys/GRLIB.REL
+cp rel/apple/DGRLIB#FE1000        prodos/syspro/sys/DGRLIB.REL
+cp rel/apple/COPY#FE1000          prodos/syspro/sys/COPY.REL
+cp rel/apple/DEL#FE1000           prodos/syspro/sys/DEL.REL
+cp rel/apple/REN#FE1000           prodos/syspro/sys/REN.REL
+cp rel/apple/CAT#FE1000           prodos/syspro/sys/CAT.REL
+cp rel/apple/NEWDIR#FE1000        prodos/syspro/sys/NEWDIR.REL
+cp rel/apple/TYPE#FE1000          prodos/syspro/sys/TYPE.REL
+cp rel/apple/MATCHFILES#FE1000    prodos/syspro/sys/MATCHFILES.REL
+cp rel/ARGS#FE1000                prodos/syspro/sys/ARGS.REL
+cp rel/ED#FE1000                  prodos/syspro/sys/ED.REL
+cp rel/FIBER#FE1000               prodos/syspro/sys/FIBER.REL
+cp rel/LONGJMP#FE1000             prodos/syspro/sys/LONGJMP.REL
+cp rel/MEMMGR#FE1000              prodos/syspro/sys/MEMMGR.REL
+cp rel/apple/MOUSE#FE1000         prodos/syspro/sys/MOUSE.REL
+cp rel/apple/PORTIO#FE1000        prodos/syspro/sys/PORTIO.REL
+cp rel/apple/JOYBUZZ#FE1000       prodos/syspro/sys/JOYBUZZ.REL
+cp rel/apple/SNDSEQ#FE1000        prodos/syspro/sys/SNDSEQ.REL
+cp rel/apple/JIT#FE1000           prodos/syspro/sys/JIT.REL
+cp rel/apple/JIT16#FE1000         prodos/syspro/sys/JIT16.REL
+cp rel/apple/JITUNE#FE1000        prodos/syspro/sys/JITUNE.REL
+cp rel/apple/ZIPCHIP#FE1000       prodos/syspro/sys/ZIPCHIP.REL
+cp rel/LZ4#FE1000                 prodos/syspro/sys/LZ4.REL
+cp rel/INT32#FE1000               prodos/syspro/sys/INT32.REL
+
+rm -rf prodos/sysinet
+mkdir prodos/sysinet
+mkdir prodos/sysinet/sys
+cp rel/INET#FE1000                prodos/sysinet/sys/INET.REL
+cp rel/DHCP#FE1000                prodos/sysinet/sys/DHCP.REL
+cp rel/ETHERIP#FE1000             prodos/sysinet/sys/ETHERIP.REL
+cp rel/apple/UTHERNET2#FE1000     prodos/sysinet/sys/UTHERNET2.REL
+cp rel/apple/UTHERNET#FE1000      prodos/sysinet/sys/UTHERNET.REL
+cp rel/TFTPD#FE1000               prodos/sysinet/sys/TFTPD.REL
+
+rm -rf prodos/fpsos
+mkdir prodos/fpsos
+cp ../sysfiles/SOS.KERNEL#0C0000  prodos/fpsos/SOS.KERNEL.\$0C
+cp ../sysfiles/SOS.DRIVER#0C0000  prodos/fpsos/SOS.DRIVER.\$0C
+cp rel/apple/SOS.INTERP#050000    prodos/fpsos/SOS.INTERP.\$05
+cp rel/apple/SOS.CMD#FE1000       prodos/fpsos/SOS.CMD.REL
+cp rel/apple/SOS.INTERPJIT#050000 prodos/fpsos/SOS.INTERPJIT.\$05
+cp rel/apple/SOS.CMDJIT#FE1000    prodos/fpsos/SOS.CMDJIT.REL
+
+mkdir prodos/fpsos/sys
+cp rel/apple/SOS#FE1000           prodos/fpsos/sys/SOS.REL
+cp rel/apple/GRAFIX#FE1000        prodos/fpsos/sys/GRAFIX.REL
+cp rel/FPSTR#FE1000               prodos/fpsos/sys/FPSTR.REL
+cp rel/FPU#FE1000                 prodos/fpsos/sys/FPU.REL
+cp rel/SANE#FE1000                prodos/fpsos/sys/SANE.REL
+cp ../sysfiles/FP6502.CODE#060000 prodos/fpsos/sys/FP6502.CODE.BIN
+cp ../sysfiles/ELEMS.CODE#060000  prodos/fpsos/sys/ELEMS.CODE.BIN
 
 rm -rf prodos/demos
 mkdir prodos/demos
-cp rel/apple/DGRTEST#FE1000 prodos/demos/DGRTEST.REL
-cp rel/RPNCALC#FE1000 prodos/demos/RPNCALC.REL
-cp rel/ROD#FE1000 prodos/demos/ROD.REL
+cp rel/INT32TEST#FE1000     prodos/demos/INT32TEST.REL
+cp rel/apple/ROD#FE1000     prodos/demos/ROD.REL
+cp rel/RPNCALC#FE1000       prodos/demos/RPNCALC.REL
+cp rel/LZ4CAT#FE1000        prodos/demos/LZ4CAT.REL
+cp rel/PRIMEGAP#FE1000      prodos/demos/PRIMEGAP.REL
 
 mkdir prodos/demos/rogue
-cp rel/ROGUE#FE1000 prodos/demos/rogue/ROGUE.REL
-cp rel/ROGUECOMBAT#FE1000 prodos/demos/rogue/ROGUECOMBAT.REL
-cp rel/ROGUEMAP#FE1000 prodos/demos/rogue/ROGUEMAP.REL
+cp rel/ROGUE#FE1000        prodos/demos/rogue/ROGUE.REL
+cp rel/ROGUECOMBAT#FE1000  prodos/demos/rogue/ROGUECOMBAT.REL
+cp rel/ROGUEMAP#FE1000     prodos/demos/rogue/ROGUEMAP.REL
 cp samplesrc/LEVEL0#040000 prodos/demos/rogue/LEVEL0.TXT
 cp samplesrc/LEVEL1#040000 prodos/demos/rogue/LEVEL1.TXT
 
-mkdir prodos/demos/sdutils
-cp rel/apple/FATCAT#FE1000 prodos/demos/sdutils/FATCAT.REL
-cp rel/apple/FATGET#FE1000 prodos/demos/sdutils/FATGET.REL
-cp rel/apple/FATPUT#FE1000 prodos/demos/sdutils/FATPUT.REL
-cp rel/apple/FATREADDSK#FE1000 prodos/demos/sdutils/FATREADDSK.REL
-cp rel/apple/FATWRITEDSK#FE1000 prodos/demos/sdutils/FATWRITEDSK.REL
-
-mkdir prodos/demos/apple3
-cp rel/apple/GFXDEMO#FE1000 prodos/demos/apple3/GFXDEMO.REL
-cp samplesrc/APPLE3.PIX#060000 prodos/demos/apple3/APPLE3.PIX.BIN
+mkdir prodos/demos/music
+cp rel/apple/PLAYSEQ#FE1000  prodos/demos/music/PLAYSEQ.REL
+cp mockingboard/ultima3.seq  prodos/demos/music/ULTIMA3.SEQ.BIN
+cp mockingboard/startrek.seq prodos/demos/music/STARTREK.SEQ.BIN
 
 mkdir prodos/demos/net
-cp rel/HTTPD#FE1000 prodos/demos/net/HTTPD.REL
+cp rel/HTTPD#FE1000     prodos/demos/net/HTTPD.REL
 cp samplesrc/index.html prodos/demos/net/INDEX.HTML.TXT
 
-mkdir prodos/demos/music
-cp rel/apple/PLAYSEQ#FE1000 prodos/demos/music/PLAYSEQ.REL
-cp mockingboard/ultima3.seq prodos/demos/music/ULTIMA3.SEQ.BIN
-cp mockingboard/startrek.seq prodos/demos/music/STARTREK.SEQ.BIN
+mkdir prodos/demos/apple2
+cp rel/apple/TILETEST#FE1000 prodos/demos/apple2/TILETEST.REL
+cp rel/apple/HGRTEST#FE1000  prodos/demos/apple2/HGRTEST.REL
+cp rel/apple/GRTEST#FE1000   prodos/demos/apple2/GRTEST.REL
+cp rel/apple/DGRTEST#FE1000  prodos/demos/apple2/DGRTEST.REL
+
+mkdir prodos/demos/apple2/spiders
+cp rel/apple/SFM#FE1000     prodos/demos/apple2/spiders/SFM.REL
+cp rel/apple/SFMSPRT#FE1000 prodos/demos/apple2/spiders/SFMSPRT.REL
+
+mkdir prodos/demos/apple2/sdutils
+cp rel/apple/SPIPORT#FE1000     prodos/demos/apple2/sdutils/SPIPORT.REL
+cp rel/apple/SDFAT#FE1000       prodos/demos/apple2/sdutils/SDFAT.REL
+cp rel/apple/FATCAT#FE1000      prodos/demos/apple2/sdutils/FATCAT.REL
+cp rel/apple/FATGET#FE1000      prodos/demos/apple2/sdutils/FATGET.REL
+cp rel/apple/FATPUT#FE1000      prodos/demos/apple2/sdutils/FATPUT.REL
+cp rel/apple/FATREADDSK#FE1000  prodos/demos/apple2/sdutils/FATREADDSK.REL
+cp rel/apple/FATWRITEDSK#FE1000 prodos/demos/apple2/sdutils/FATWRITEDSK.REL
+
+mkdir prodos/demos/apple3
+cp rel/apple/GFXDEMO#FE1000    prodos/demos/apple3/GFXDEMO.REL
+cp samplesrc/APPLE3.PIX#060000 prodos/demos/apple3/APPLE3.PIX.BIN
 
 rm -rf prodos/bld
 mkdir prodos/bld
-cp rel/PLASM#FE1000 prodos/bld/PLASM.REL
-cp rel/CODEOPT#FE1000 prodos/bld/CODEOPT.REL
-cp samplesrc/dgrtest.pla prodos/bld/DGRTEST.PLA.TXT
-cp samplesrc/hello.pla prodos/bld/HELLO.PLA.TXT
-cp samplesrc/hgr1test.pla prodos/bld/HGR1TEST.PLA.TXT
-cp samplesrc/fibertest.pla prodos/bld/FIBERTEST.PLA.TXT
-cp samplesrc/mon.pla prodos/bld/MON.PLA.TXT
-cp samplesrc/memtest.pla prodos/bld/MEMTEST.PLA.TXT
-cp samplesrc/rod.pla prodos/bld/ROD.PLA.TXT
-cp samplesrc/sieve.pla prodos/bld/SIEVE.PLA.TXT
-cp samplesrc/test.pla prodos/bld/TEST.PLA.TXT
-cp samplesrc/testlib.pla prodos/bld/TESTLIB.PLA.TXT
-cp samplesrc/playseq.pla prodos/bld/PLAYSEQ.PLA.TXT
-cp samplesrc/rpncalc.pla prodos/bld/RPNCALC.PLA.TXT
-cp samplesrc/httpd.pla prodos/bld/HTTPD.PLA.TXT
-cp samplesrc/fatcat.pla prodos/bld/FATCAT.PLA.TXT
-cp samplesrc/rogue.pla prodos/bld/ROGUE.PLA.TXT
-cp samplesrc/rogue.map.pla prodos/bld/ROGUE.MAP.PLA.TXT
-cp samplesrc/rogue.combat.pla prodos/bld/ROGUE.COMBAT.PLA.TXT
-cp samplesrc/gfxdemo.pla prodos/bld/GFXDEMO.PLA.TXT
+cp rel/PLASM#FE1000        prodos/bld/PLASM.REL
+cp rel/CODEOPT#FE1000      prodos/bld/CODEOPT.REL
+
+mkdir prodos/bld/samples
+cp samplesrc/hello.pla     prodos/bld/samples/HELLO.PLA.TXT
+cp samplesrc/int32test.pla prodos/bld/samples/INT32TEST.PLA.TXT
+cp samplesrc/grtest.pla    prodos/bld/samples/GRTEST.PLA.TXT
+cp samplesrc/dgrtest.pla   prodos/bld/samples/DGRTEST.PLA.TXT
+cp samplesrc/hgrtest.pla   prodos/bld/samples/HGRTEST.PLA.TXT
+cp samplesrc/tiletest.pla  prodos/bld/samples/TILETEST.PLA.TXT
+cp samplesrc/fibertest.pla prodos/bld/samples/FIBERTEST.PLA.TXT
+cp samplesrc/mousetest.pla prodos/bld/samples/MOUSETEST.PLA.TXT
+cp samplesrc/memtest.pla   prodos/bld/samples/MEMTEST.PLA.TXT
+cp samplesrc/rod.pla       prodos/bld/samples/ROD.PLA.TXT
+cp samplesrc/sieve.pla     prodos/bld/samples/SIEVE.PLA.TXT
+cp samplesrc/test.pla      prodos/bld/samples/TEST.PLA.TXT
+cp samplesrc/testlib.pla   prodos/bld/samples/TESTLIB.PLA.TXT
+cp samplesrc/playseq.pla   prodos/bld/samples/PLAYSEQ.PLA.TXT
+cp samplesrc/rpncalc.pla   prodos/bld/samples/RPNCALC.PLA.TXT
+cp samplesrc/fatcat.pla    prodos/bld/samples/FATCAT.PLA.TXT
+cp samplesrc/gfxdemo.pla   prodos/bld/samples/GFXDEMO.PLA.TXT
+cp samplesrc/lz4cat.pla    prodos/bld/samples/Z4CAT.PLA.TXT
+cp samplesrc/sfm.pla       prodos/bld/samples/SFM.PLA.TXT
+cp samplesrc/sfmsprt.pla   prodos/bld/samples/SFMSPRT.PLA.TXT
+cp utilsrc/apple/mon.pla   prodos/bld/samples/MON.PLA.TXT
+cp utilsrc/apple/zipchip.pla prodos/bld/samples/ZIPCHIP.PLA.TXT
+
+#mkdir prodos/bld/examples
+#cp samplesrc/examples/ex.1.pla  prodos/bld/examples/EX.1.PLA.TXT
+#cp samplesrc/examples/ex.2.pla  prodos/bld/examples/EX.2.PLA.TXT
+#cp samplesrc/examples/ex.3.pla  prodos/bld/examples/EX.3.PLA.TXT
+#cp samplesrc/examples/ex.4.pla  prodos/bld/examples/EX.4.PLA.TXT
+#cp samplesrc/examples/ex.5.pla  prodos/bld/examples/EX.5.PLA.TXT
+#cp samplesrc/examples/ex.6.pla  prodos/bld/examples/EX.6.PLA.TXT
+#cp samplesrc/examples/ex.7.pla  prodos/bld/examples/EX.7.PLA.TXT
+#cp samplesrc/examples/ex.8.pla  prodos/bld/examples/EX.8.PLA.TXT
+#cp samplesrc/examples/ex.9.pla  prodos/bld/examples/EX.9.PLA.TXT
+#cp samplesrc/examples/ex.10.pla prodos/bld/examples/EX.10.PLA.TXT
+#cp samplesrc/examples/ex.11.pla prodos/bld/examples/EX.11.PLA.TXT
+#cp samplesrc/examples/ex.12.pla prodos/bld/examples/EX.12.PLA.TXT
+#cp samplesrc/examples/ex.13.pla prodos/bld/examples/EX.13.PLA.TXT
+#cp samplesrc/examples/ex.14.pla prodos/bld/examples/EX.14.PLA.TXT
+#cp samplesrc/examples/ex.15.pla prodos/bld/examples/EX.15.PLA.TXT
+#cp samplesrc/examples/ex.16.pla prodos/bld/examples/EX.16.PLA.TXT
+#cp samplesrc/examples/ex.17.pla prodos/bld/examples/EX.17.PLA.TXT
 
 mkdir prodos/bld/inc
-cp inc/args.plh prodos/bld/inc/ARGS.PLH.TXT
-cp inc/cmdsys.plh prodos/bld/inc/CMDSYS.PLH.TXT
-cp inc/conio.plh prodos/bld/inc/CONIO.PLH.TXT
-cp inc/dgr.plh prodos/bld/inc/DGR.PLH.TXT
-cp inc/fiber.plh prodos/bld/inc/FIBER.PLH.TXT
-cp inc/fileio.plh prodos/bld/inc/FILEIO.PLH.TXT
-cp inc/fpstr.plh prodos/bld/inc/FPSTR.PLH.TXT
-cp inc/fpu.plh prodos/bld/inc/FPU.PLH.TXT
-cp inc/inet.plh prodos/bld/inc/INET.PLH.TXT
-cp inc/longjmp.plh prodos/bld/inc/LONGJMP.PLH.TXT
-cp inc/memmgr.plh prodos/bld/inc/MEMMGR.PLH.TXT
-cp inc/sane.plh prodos/bld/inc/SANE.PLH.TXT
-cp inc/joybuzz.plh prodos/bld/inc/JOYBUZZ.PLH.TXT
-cp inc/portio.plh prodos/bld/inc/PORTIO.PLH.TXT
-cp inc/sdfat.plh prodos/bld/inc/SDFAT.PLH.TXT
-cp inc/sndseq.plh prodos/bld/inc/SNDSEQ.PLH.TXT
-cp inc/spiport.plh prodos/bld/inc/SPIPORT.PLH.TXT
-cp inc/testlib.plh prodos/bld/inc/TESTLIB.PLH.TXT
-cp inc/grafix.plh prodos/bld/inc/GRAFIX.PLH.TXT
+cp inc/args.plh           prodos/bld/inc/ARGS.PLH.TXT
+cp inc/matchfiles.plh     prodos/bld/inc/MATCHFILES.PLH.TXT
+cp inc/cmdsys.plh         prodos/bld/inc/CMDSYS.PLH.TXT
+cp inc/conio.plh          prodos/bld/inc/CONIO.PLH.TXT
+cp inc/lines.plh          prodos/bld/inc/LINES.PLH.TXT
+cp inc/hgrfont.plh        prodos/bld/inc/HGRFONT.PLH.TXT
+cp inc/hgrtile.plh        prodos/bld/inc/HGRTILE.PLH.TXT
+cp inc/hgrsprite.plh      prodos/bld/inc/HGRSPRITE.PLH.TXT
+cp inc/hgrlib.plh         prodos/bld/inc/HGRLIB.PLH.TXT
+cp inc/grlib.plh          prodos/bld/inc/GRLIB.PLH.TXT
+cp inc/dgrlib.plh         prodos/bld/inc/DGRLIB.PLH.TXT
+cp inc/fiber.plh          prodos/bld/inc/FIBER.PLH.TXT
+cp inc/fileio.plh         prodos/bld/inc/FILEIO.PLH.TXT
+cp inc/int32.plh          prodos/bld/inc/INT32.PLH.TXT
+cp inc/fpstr.plh          prodos/bld/inc/FPSTR.PLH.TXT
+cp inc/fpu.plh            prodos/bld/inc/FPU.PLH.TXT
+cp inc/mouse.plh          prodos/bld/inc/MOUSE.PLH.TXT
+cp inc/inet.plh           prodos/bld/inc/INET.PLH.TXT
+cp inc/longjmp.plh        prodos/bld/inc/LONGJMP.PLH.TXT
+cp inc/memmgr.plh         prodos/bld/inc/MEMMGR.PLH.TXT
+cp inc/sane.plh           prodos/bld/inc/SANE.PLH.TXT
+cp inc/joybuzz.plh        prodos/bld/inc/JOYBUZZ.PLH.TXT
+cp inc/portio.plh         prodos/bld/inc/PORTIO.PLH.TXT
+cp inc/sdfat.plh          prodos/bld/inc/SDFAT.PLH.TXT
+cp inc/sndseq.plh         prodos/bld/inc/SNDSEQ.PLH.TXT
+cp inc/spiport.plh        prodos/bld/inc/SPIPORT.PLH.TXT
+cp inc/testlib.plh        prodos/bld/inc/TESTLIB.PLH.TXT
+cp inc/grafix.plh         prodos/bld/inc/GRAFIX.PLH.TXT
+cp inc/lz4.plh            prodos/bld/inc/LZ4.PLH.TXT
 cp vmsrc/apple/plvmzp.inc prodos/bld/inc/PLVMZP.INC.TXT

src/opstat

@@ -0,0 +1,82 @@
+echo -n "CN       "; grep -c '; CN' $1
+echo -n "MINUS1   "; grep -c '; MINUS' $1
+echo -n "BREQ     "; grep -c '; BREQ' $1
+echo -n "BRNE     "; grep -c '; BRNE' $1
+echo -n "LA       "; grep -c '; LA' $1
+echo -n "LLA      "; grep -c '; LLA' $1
+echo -n "CB       "; grep -c '; CB' $1
+echo -n "CW       "; grep -c '; CW' $1
+echo -n "CS       "; grep -c '; CS' $1
+echo -n "DROP     "; grep -c '; DROP ' $1
+echo -n "DROP2    "; grep -c '; DROP2' $1
+echo -n "DUP      "; grep -c '; DUP' $1
+echo -n "DIVMOD   "; grep -c '; DIVMOD' $1
+echo -n "ADDI     "; grep -c '; ADDI' $1
+echo -n "SUBI     "; grep -c '; SUBI' $1
+echo -n "ANDI     "; grep -c '; ANDI' $1
+echo -n "ORI      "; grep -c '; ORI' $1
+echo -n "ISEQ     "; grep -c '; ISEQ' $1
+echo -n "ISNE     "; grep -c '; ISNE' $1
+echo -n "ISGT     "; grep -c '; ISGT' $1
+echo -n "ISLT     "; grep -c '; ISLT' $1
+echo -n "ISGE     "; grep -c '; ISGE' $1
+echo -n "ISLE     "; grep -c '; ISLE' $1
+echo -n "BRFLS    "; grep -c '; BRFLS' $1
+echo -n "BRTRU    "; grep -c '; BRTRU' $1
+echo -n "BRNCH    "; grep -c '; BRNCH' $1
+echo -n "SEL      "; grep -c '; SEL' $1
+echo -n "CALL     "; grep -c '; CALL' $1
+echo -n "ICAL     "; grep -c '; ICAL' $1
+echo -n "ENTER    "; grep -c '; ENTER' $1
+echo -n "LEAVE    "; grep -c '; LEAVE' $1
+echo -n "RET      "; grep -c '; RET' $1
+echo -n "CFFB     "; grep -c '; CFFB' $1
+echo -n "LB       "; grep -c '; LB' $1
+echo -n "LW       "; grep -c '; LW' $1
+echo -n "LLB      "; grep -c '; LLB' $1
+echo -n "LLW      "; grep -c '; LLW' $1
+echo -n "LAB      "; grep -c '; LAB' $1
+echo -n "LAW      "; grep -c '; LAW' $1
+echo -n "DLB      "; grep -c '; DLB' $1
+echo -n "DLW      "; grep -c '; DLW' $1
+echo -n "SB       "; grep -c '; SB' $1
+echo -n "SW       "; grep -c '; SW' $1
+echo -n "SLB      "; grep -c '; SLB' $1
+echo -n "SLW      "; grep -c '; SLW' $1
+echo -n "SAB      "; grep -c '; SAB' $1
+echo -n "SAW      "; grep -c '; SAW' $1
+echo -n "DAB      "; grep -c '; DAB' $1
+echo -n "DAW      "; grep -c '; DAW' $1
+echo -n "NOT      "; grep -c '; NOT' $1
+echo -n "ADD      "; grep -c '; ADD ' $1
+echo -n "SUB      "; grep -c '; SUB ' $1
+echo -n "MUL      "; grep -c '; MUL' $1
+echo -n "DIV      "; grep -c '; DIV' $1
+echo -n "MOD      "; grep -c '; MOD' $1
+echo -n "INCR     "; grep -c '; INCR' $1
+echo -n "DECR     "; grep -c '; DECR' $1
+echo -n "NEG      "; grep -c '; NEG' $1
+echo -n "COMP     "; grep -c '; COMP' $1
+echo -n "AND      "; grep -c '; AND ' $1
+echo -n "OR       "; grep -c '; OR' $1
+echo -n "XOR      "; grep -c '; XOR' $1
+echo -n "SHL      "; grep -c '; SHL' $1
+echo -n "SHR      "; grep -c '; SHR' $1
+echo -n "IDXW     "; grep -c '; IDXW' $1
+echo -n "BRGT     "; grep -c '; BRGT' $1
+echo -n "BRLT     "; grep -c '; BRLT' $1
+echo -n "INCBRLE  "; grep -c '; INCBRLE' $1
+echo -n "ADDBRLE  "; grep -c '; ADDBRLE' $1
+echo -n "DECBRGE  "; grep -c '; DECBRGE' $1
+echo -n "SUBBRGE  "; grep -c '; SUBBRGE' $1
+echo -n "BRAND    "; grep -c '; BRAND' $1
+echo -n "BROR     "; grep -c '; BROR' $1
+echo -n "ADDLB    "; grep -c '; ADDLB' $1
+echo -n "ADDLW    "; grep -c '; ADDLW' $1
+echo -n "ADDAB    "; grep -c '; ADDAB' $1
+echo -n "ADDAW    "; grep -c '; ADDAW' $1
+echo -n "IDXLB    "; grep -c '; IDXLB' $1
+echo -n "IDXLW    "; grep -c '; IDXLW' $1
+echo -n "IDXAB    "; grep -c '; IDXAB' $1
+echo -n "IDXAW    "; grep -c '; IDXAW' $1
+

src/samplesrc/dgrtest.pla

@@ -1,4 +1,7 @@
-include "inc/dgr.plh"
+include "inc/cmdsys.plh"
+include "inc/dgrlib.plh"
+include "inc/lines.plh"
+sysflags restxt1|restxt2|resxtxt1|resxtxt2    // Reserve all text pages
 
 byte[] sprite1 = $80,$80,$00,$00,$00,$00,$80,$80
 byte[]         = $80,$00,$0A,$0A,$0A,$0A,$00,$80
@@ -18,42 +21,45 @@ byte[]       = $0A,$05,$0A,$05,$0A,$05,$0A,$00
 // Test routine
 //
 def dgrTest#0
-    byte b, l, k
-    word i, j, ii, ij
+  byte b, l, k
+  word i, j, ii, ij
 
-    b = dgrMode()
-    for k = 15 downto 0
-        dgrClear(dgrbuff[0], k)
-    next
-    for l = 0 to 79
-        dgrColor(l)
-        dgrLine(dgrbuff[0], 0, 0, l, 47)
-    next
-    for l = 47 downto 0
-        dgrColor(l)
-        dgrLine(dgrbuff[0], 0, 0, 79, l)
-    next
-    ii = 2
-    ij = -1
-    i = 40
-    j = 10
-    ^$C010
-    while ^$C000 < 128
-        dgrFill(dgrbuff[b], k, k, @tile1)
-        dgrBLT(dgrbuff[b], i, j, 8, 8, @sprite1)
-        b = dgrShow(b)
-        k++
-        i = i + ii
-        if i < -3 or i > 75
-            ii = -ii
-        fin
-        j = j + ij
-        if j < -3 or j > 43
-            ij = -ij
-        fin
-    loop
-    ^$C010
-    txtMode
+  b = dgrMode(TRUE)
+  dgrDrawBuf(0)
+  for k = 15 downto 0
+    dgrClear(k)
+  next
+  setlinespans(@dgrHLin, @dgrVLin)
+  for l = 0 to 79
+    dgrColor(l)
+    linespans(0, 0, l, 47)
+  next
+  for l = 47 downto 0
+    dgrColor(l)
+    linespans(0, 0, 79, l)
+  next
+  ii = 2
+  ij = -1
+  i = 40
+  j = 10
+  ^$C010
+  dgrDrawBuf(1)
+  while ^$C000 < 128
+    dgrFill(k, k, @tile1)
+    dgrBLT(i, j, 8, 8, @sprite1)
+    dgrSwap
+    k++
+    i = i + ii
+    if i < -3 or i > 75
+      ii = -ii
+    fin
+    j = j + ij
+    if j < -3 or j > 43
+      ij = -ij
+    fin
+  loop
+  ^$C010
+  dgrMode(FALSE)
 end
 
 dgrTest

src/samplesrc/grtest.pla

@@ -0,0 +1,66 @@
+include "inc/cmdsys.plh"
+include "inc/grlib.plh"
+include "inc/lines.plh"
+sysflags restxt1|restxt2    // Reserve all text pages
+
+byte[] sprite1 = $80,$80,$00,$00,$00,$00,$80,$80
+byte[]         = $80,$00,$0A,$0A,$0A,$0A,$00,$80
+byte[]         = $00,$0A,$0F,$0F,$0F,$0F,$0A,$00
+byte[]         = $00,$0A,$0F,$80,$80,$0F,$0A,$00
+byte[]         = $00,$0A,$0F,$80,$80,$0F,$0A,$00
+byte[]         = $00,$0A,$0F,$0F,$0F,$0F,$0A,$00
+byte[]         = $80,$00,$0A,$0A,$0A,$0A,$00,$80
+byte[]         = $80,$80,$00,$00,$00,$00,$80,$80
+
+byte[] tile1 = $11,$11,$11,$11,$11,$11,$55,$00
+byte[]       = $11,$11,$11,$11,$11,$11,$55,$00
+byte[]       = $11,$11,$11,$11,$11,$11,$55,$00
+byte[]       = $05,$05,$05,$05,$05,$05,$05,$00
+
+//
+// Test routine
+//
+def grTest#0
+  byte b, l, k
+  word i, j, ii, ij
+
+  b = grMode(TRUE)
+  grDrawBuf(0)
+  for k = 15 downto 0
+    grClear(k)
+  next
+  setlinespans(@grHLin, @grVLin)
+  for l = 0 to 39
+    grColor(l)
+    linespans(0, 0, l, 47)
+  next
+  for l = 47 downto 0
+    grColor(l)
+    linespans(0, 0, 39, l)
+  next
+  ii = 2
+  ij = -1
+  i = 20
+  j = 10
+  ^$C010
+  grDrawBuf(1)
+  while ^$C000 < 128
+    grFill(k, k, @tile1)
+    grBLT(i, j, 8, 8, @sprite1)
+    grSwap
+    k++
+    i = i + ii
+    if i < -3 or i > 35
+      ii = -ii
+    fin
+    j = j + ij
+    if j < -3 or j > 43
+      ij = -ij
+    fin
+  loop
+  ^$C010
+  grMode(FALSE)
+end
+
+grTest
+done

src/samplesrc/hgr1test.pla

@@ -1,56 +0,0 @@
-include "inc/cmdsys.plh"
-sysflags reshgr1 // Reserve HGR page 1
-
-//
-// Hardware addresses
-//
-const speaker      = $C030
-const showgraphics = $C050
-const showtext     = $C051
-const showfull     = $C052
-const showmix      = $C053
-const showpage1    = $C054
-const showpage2    = $C055
-const showlores    = $C056
-const showhires    = $C057
-const keyboard     = $C000
-const keystrobe    = $C010
-const hgr1         = $2000
-const hgr2         = $4000
-const page1        = 0
-const page2        = 1
-word hgrpage[] = hgr1, hgr2
-word hgrscan[] = $0000,$0400,$0800,$0C00,$1000,$1400,$1800,$1C00
-word           = $0080,$0480,$0880,$0C80,$1080,$1480,$1880,$1C80
-word           = $0100,$0500,$0900,$0D00,$1100,$1500,$1900,$1D00
-word           = $0180,$0580,$0980,$0D80,$1180,$1580,$1980,$1D80
-word           = $0200,$0600,$0A00,$0E00,$1200,$1600,$1A00,$1E00
-word           = $0280,$0680,$0A80,$0E80,$1280,$1680,$1A80,$1E80
-word           = $0300,$0700,$0B00,$0F00,$1300,$1700,$1B00,$1F00
-word           = $0380,$0780,$0B80,$0F80,$1380,$1780,$1B80,$1F80
-word           = $0028,$0428,$0828,$0C28,$1028,$1428,$1828,$1C28
-word           = $00A8,$04A8,$08A8,$0CA8,$10A8,$14A8,$18A8,$1CA8
-word           = $0128,$0528,$0928,$0D28,$1128,$1528,$1928,$1D28
-word           = $01A8,$05A8,$09A8,$0DA8,$11A8,$15A8,$19A8,$1DA8
-word           = $0228,$0628,$0A28,$0E28,$1228,$1628,$1A28,$1E28
-word           = $02A8,$06A8,$0AA8,$0EA8,$12A8,$16A8,$1AA8,$1EA8
-word           = $0328,$0728,$0B28,$0F28,$1328,$1728,$1B28,$1F28
-word           = $03A8,$07A8,$0BA8,$0FA8,$13A8,$17A8,$1BA8,$1FA8
-word           = $0050,$0450,$0850,$0C50,$1050,$1450,$1850,$1C50
-word           = $00D0,$04D0,$08D0,$0CD0,$10D0,$14D0,$18D0,$1CD0
-word           = $0150,$0550,$0950,$0D50,$1150,$1550,$1950,$1D50
-word           = $01D0,$05D0,$09D0,$0DD0,$11D0,$15D0,$19D0,$1DD0
-word           = $0250,$0650,$0A50,$0E50,$1250,$1650,$1A50,$1E50
-word           = $02D0,$06D0,$0AD0,$0ED0,$12D0,$16D0,$1AD0,$1ED0
-word           = $0350,$0750,$0B50,$0F50,$1350,$1750,$1B50,$1F50
-word           = $03D0,$07D0,$0BD0,$0FD0,$13D0,$17D0,$1BD0,$1FD0
-word hcolor[]  = $0000,$552A,$2A55,$7F7F,$8080,$D5AA,$AAD5,$FFFF
-memset(hgr1, 0, $2000) // Clear HGR page 1
-^showpage1
-^showfull
-^showhires
-^showgraphics
-getc
-^showpage1
-^showtext
-done

src/samplesrc/hgrtest.pla

@@ -0,0 +1,80 @@
+include "inc/cmdsys.plh"
+include "inc/hgrlib.plh"
+include "inc/hgrsprite.plh"
+include "inc/lines.plh"
+sysflags reshgr1|reshgr2 // Reserve HGR page 1 and 2
+
+byte ball = $88, $83, $33, $38, $88
+byte      = $88, $33, $11, $33, $88
+byte      = $83, $31, $11, $13, $38
+byte      = $33, $11, $11, $11, $33
+byte      = $33, $11, $11, $11, $33
+byte      = $33, $11, $11, $11, $33
+byte      = $33, $11, $11, $11, $33
+byte      = $83, $31, $11, $13, $38
+byte      = $88, $33, $11, $33, $88
+byte      = $88, $83, $33, $38, $88
+var sprtBall
+def testline#0
+  var i
+
+  setlinespans(@hgrHlin, @hgrVlin)
+  setlineplot(@hgrXorPlot)
+  hgrColor(7)
+  for i = 0 to 191 step 8
+    linespans(0, i, 279, 191 - i)
+    //line(0, i, 279, 191 - i)
+  next
+  for i = 0 to 279 step 9
+    linespans(i, 0, 279 - i, 191)
+    //line(i, 0, 279 - i, 191)
+  next
+end
+def testblt(sprtnum)#0
+  var[16] i, j, ii, jj
+  byte k
+
+  sprtnum = sprtnum - 1
+  i[0] = 100
+  ii[0] = 1
+  j[0] = 80
+  jj[0] = -1
+  if sprtnum
+    for k = 1 to sprtnum
+      spriteAdd(k, spriteDup(sprtBall))
+      i[k] = ((i[k - 1] ^ 37) + 97) % 270
+      ii[k] = -ii[k - 1]
+      j[k] = ((j[k - 1] ^ 29) + 53) % 180
+      jj[k] = -jj[k - 1]
+    next
+  fin
+  while ^$C000 < 128
+    for k = 0 to sprtnum
+      i[k] = i[k] + ii[k]
+      if i[k] < -5 or i[k] > 284
+        ii[k] = -ii[k]
+      fin
+      j[k] = j[k] + jj[k]
+      if j[k] < -5 or j[k] > 196
+        jj[k] = -jj[k]
+      fin
+      spritePosIndex(i[k], j[k], k)
+    next
+    spriteDrawList()
+    spriteDrawBuf(hgrSwap())
+  loop
+end
+
+hgrMode(TRUE)
+spriteDrawBuf(hgrDrawBuf(0)) // So we can see the compile process
+sprtBall = spriteCompile(10, 10, 5, 5, @ball)
+hgrColor(0)
+hgrClear()
+testline
+memcpy($4000, $2000, $2000) // Copy to both buffers
+spriteDrawBuf(hgrDrawBuf(1))
+spriteAdd(0, sprtBall)
+testblt(16)
+getc
+hgrMode(FALSE)
+done

src/samplesrc/int32test.pla

@@ -0,0 +1,72 @@
+include "inc/cmdsys.plh"
+include "inc/int32.plh"
+
+def testi32#0
+    word il, ih
+    res[t_i32] i32
+    
+    ih = 0
+    for il = 0 to 10
+        load32(@il)
+        muli16(10)
+        divi16(2)
+        store32(@i32)
+        puti32(@i32); putln
+    next
+    muli16(-30000)
+    store32(@i32)
+    puti32(@i32); putln
+    loadi16(100)
+    if islti16(50)
+        puts("100 < 50\n")
+    fin
+    if islti16(500)
+        puts("100 < 500\n")
+    fin
+    if isgti16(50)
+        puts("100 > 50\n")
+    fin
+    if isgti16(500)
+        puts("100 > 500\n")
+    fin
+    if islei16(50)
+        puts("100 <= 50\n")
+    fin
+    if islei16(500)
+        puts("100 <= 500\n")
+    fin
+    if isgei16(50)
+        puts("100 >= 50\n")
+    fin
+    if isgei16(500)
+        puts("100 >= 500\n")
+    fin
+
+    if islti16(100)
+        puts("100 < 100\n")
+    fin
+    if islti16(100)
+        puts("100 < 100\n")
+    fin
+    if isgti16(100)
+        puts("100 > 100\n")
+    fin
+    if isgti16(100)
+        puts("100 > 100\n")
+    fin
+    if islei16(100)
+        puts("100 <= 100\n")
+    fin
+    if islei16(100)
+        puts("100 <= 100\n")
+    fin
+    if isgei16(100)
+        puts("100 >= 100\n")
+    fin
+    if isgei16(100)
+        puts("100 >= 100\n")
+    fin
+end
+
+testi32
+done

src/samplesrc/lz4cat.pla

@@ -0,0 +1,107 @@
+include "inc/cmdsys.plh"
+include "inc/args.plh"
+include "inc/fileio.plh"
+include "inc/lz4.plh"
+
+struc t_header
+    word magic[2]
+    byte FLG
+    byte BD
+end
+word arg
+byte ref
+
+def lz4ReadBlock(flags)#2
+    word size[2], block, data, len
+    
+    len = fileio:read(ref, @size, 4)
+    if len <> 4 or size[0] == 0 or size[1] & $7FFF
+        return NULL, 0
+    fin
+    block = heapalloc(size[0])
+    if block
+        len = fileio:read(ref, block, size[0])
+        if len <> size[0]
+            heaprelease(block)
+            return NULL, 0
+        fin
+    else
+        return NULL, 0
+    fin
+    if size[1] & $8000
+        //
+        // Uncompressed block
+        //
+        data = block
+    else
+        //
+        // Decompress block
+        //
+        len  = heapavail - 256 // Allocate almost entire heap to decompress into
+        data = heapalloc(len)
+        if data
+            len = lz4Unpack(block, block + size[0], data, data + len)
+            memcpy(block, data, len)
+            data = block
+        else
+            len = 0
+        fin
+        heaprelease(block + len)
+    fin
+    if flags & $10 // Block Checksum
+        fileio:read(ref, @size, 4)
+    fin
+    return data, len
+end
+def lz4ReadFrame#0
+    word data, len
+    byte header[t_header], opt
+
+    fileio:read(ref, @header, t_header)
+    if header:magic[1] <> $184D or header:magic[0] <> $2204
+        puts("Not LZ4 file.\n")
+        return
+    fin
+    if header.FLG & $C0 <> $40
+        puts("Wrong LZ4 version.\n")
+        return
+    fin
+    if header.BD & $70 <> $40
+        puts("Not 64K block size.\n")
+        return
+    fin
+    opt = 1
+    if header.FLG & $08 // Content Size
+        opt = opt + 8
+    fin
+    if header.FLG & $01 // Dictionary ID
+        opt = opt + 4
+    fin
+    fileio:read(ref, heapmark, opt) // Read rest of header and throw away
+    repeat
+        data, len = lz4ReadBlock(header.FLG)
+        if len
+            while len
+                putc(^data <> $0A ?? ^data :: $0D)
+                data++
+                len--
+            loop
+            heaprelease(data)
+        fin
+    until not data
+    if header.FLG & $04 // Content Checksun
+        fileio:read(ref, heapmark, 4)
+    fin
+end
+arg = argNext(argFirst)
+if ^arg
+    ref = fileio:open(arg)
+    if ref
+        lz4ReadFrame
+        fileio:close(ref)
+    else
+        puts("File not found.\n")
+    fin
+fin
+
+done

src/samplesrc/mousetest.pla

@@ -0,0 +1,22 @@
+include "inc/cmdsys.plh"
+include "inc/conio.plh"
+include "inc/mouse.plh"
+
+var count
+var xPos, yPos, bttn
+
+Mouse:clampMouse(0, 39, 0, 23)
+Mouse:setMouse(VBL_INT_ENABLE|MOVE_INT_ENABLE|BUTTON_INT_ENABLE|MOUSE_ENABLE)
+while ^$C000 < 128
+    if Mouse:chkMouse()
+        conio:gotoxy(xPos, yPos); putc(' ')
+        xPos, yPos, bttn = Mouse:readMouse()#3
+        conio:gotoxy(xPos, yPos); putc(bttn & BUTTON_DOWN ?? '+' :: '^')
+    fin
+    if Mouse:chkVBL()
+        ^$400++
+    fin
+loop
+getc
+Mouse:detachMouse()
+done

src/samplesrc/playseq.pla

@@ -6,8 +6,8 @@ include "inc/sndseq.plh"
 //
 // These are utility sequences/routines needed to test the music sequencer code.
 //
-word arg
-word ref
+word arg, seq, len
+byte ref
 //
 // Sample background process to show it's working
 //
@@ -19,9 +19,11 @@ arg = argNext(argFirst)
 if ^arg
     ref = fileio:open(arg)
     if ref
-        fileio:read(ref, heapmark(), heapavail())
+        seq = heapalloc(heapavail - 256)
+        len = fileio:read(ref, seq, heapmark - seq)
         fileio:close(ref)
-        musicPlay(heapmark(), TRUE)
+        heaprelease(seq + len)
+        musicPlay(seq, TRUE)
         musicGetKey(8, @backgroundProc) // Yield every 8/16 second
         musicStop
     else

src/samplesrc/primegap.pla

@@ -0,0 +1,41 @@
+include "inc/cmdsys.plh"
+
+var a, b, i,loprim,hiprim
+
+def getnum
+    var str, num
+    num = 0
+    str = gets(':'|$80) + 1
+    while ^str >= '0' and ^str <= '9'
+        num = num * 10 + (^str - '0')
+        str++
+    loop
+    return num
+end
+
+def prim(x)
+    var i
+    i = 3
+    while i*i < x and x % i; i = i + 2; loop
+    return x < i*i
+end
+
+puts("Geben Sie den oberen Grenzwert ein")
+a = getnum
+puts("Geben Sie die minimale Differenz ein")
+b = getnum
+loprim, hiprim, i = 1, 1, 3
+while i <= a and hiprim-loprim < b
+    if prim(i)
+        loprim = hiprim
+        hiprim = i
+    fin
+    i = i + 2
+loop
+if hiprim-loprim < b
+    puts("keine Loesung gefunden !")
+else
+    puti(hiprim); putc(' '); puti(loprim); putc(' '); puti(hiprim-loprim)
+fin
+putln
+done

src/samplesrc/rod.pla

@@ -3,8 +3,8 @@ include "inc/conio.plh"
 //
 // Rod's Colors
 //
-def rod
-  var i, j, k, w, fmi, fmk, color
+def rod#0
+  byte i, j, k, w, fmi, fmk, color
 
   while TRUE
     for w = 3 to 50
@@ -24,7 +24,8 @@ def rod
           conio:grplot(i, fmk)
           conio:grplot(fmk, i)
           if conio:keypressed()
-            return getc
+            getc
+            return
           fin
         next
       next

src/samplesrc/rogue.combat.pla

@@ -162,48 +162,47 @@ export def fight(player, enemy)
     if toupper(conio:getkey()) == 'R'
       conio:echo(ECHO_OFF)
       return 1
+    fin
+    //
+    // Turn player in random direction
+    //
+    player->angle = conio:rnd() & 7
+    //
+    // Calculate attack (with a little random variation)
+    //
+    p_atck = player->skill + player->energy / 10 - enemy->power / 25  + (conio:rnd() & 7)
+    e_atck = enemy->power  - player->skill / 5   - player->energy / 20 + (conio:rnd() & 7)
+    if enemy->life > p_atck
+      enemy->life = enemy->life - p_atck
     else
+      win
+      enemy->life = 0
+      p_atck      = player->skill + enemy->power / 3
+      if p_atck > 100 // Limit skill
+        p_atck = 100
+      fin
+      player->skill = p_atck
       //
-      // Turn player in random direction
+      // Unlink dead enemy from entities list
       //
-      player->angle = conio:rnd() & 7
-      //
-      // Calculate attack (with a little random variation)
-      //
-      p_atck = player->skill + player->energy / 10 - enemy->power / 25  + (conio:rnd() & 7)
-      e_atck = enemy->power  - player->skill / 5   - player->energy / 20 + (conio:rnd() & 7)
-      if enemy->life > p_atck
-        enemy->life = enemy->life - p_atck
-      else
-        win
-        enemy->life = 0
-        p_atck      = player->skill + enemy->power / 3
-        if p_atck > 100 // Limit skill
-          p_atck = 100
-        fin
-        player->skill = p_atck
-        //
-        // Unlink dead enemy from entities list
-        //
-        if enemy == entities
-          entities = enemy=>next_other
-        fin
-    if enemy=>next_other
-          enemy=>next_other=>prev_other = enemy=>prev_other
+      if enemy == entities
+        entities = enemy=>next_other
+      fin
+      if enemy=>next_other
+        enemy=>next_other=>prev_other = enemy=>prev_other
+      fin
+      if enemy=>prev_other
+        enemy=>prev_other=>next_other = enemy=>next_other
+      fin
     fin
-    if enemy=>prev_other
-          enemy=>prev_other=>next_other = enemy=>next_other
+    if player->health > e_atck
+      player->health = player->health - e_atck
+    else
+      player->energy = 0
+      player->health = 0
     fin
-      fin
-      if player->health > e_atck
-        player->health = player->health - e_atck
-      else
-        player->energy = 0
-        player->health = 0
-      fin
-      if player->energy >= 4
-        player->energy = player->energy - 4
-      fin
+    if player->energy >= 4
+      player->energy = player->energy - 4
     fin
   until player->health == 0 or enemy->life == 0
   conio:echo(ECHO_OFF)

src/samplesrc/rogue.map.pla

@@ -260,8 +260,8 @@ end
 //
 
 export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
-  byte o, l, dist, tile, adjtile, occluded, darkness
-  word ymap, xmap, imap
+  byte l, dist, tile, adjtile, occluded, darkness
+  word ymap, xmap, imap, o
   byte yscr, xscr
 
   if viewdist > beamdepth
@@ -279,7 +279,7 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
   //
   darkness = 1
   imap     = (yorg << rowshift) + xorg
-  if ^(map + imap) & LIT_TILE or lightdist
+  if lightdist or ^(map + imap) & LIT_TILE
     //
     // Update current spot in viewmap
     //
@@ -358,7 +358,7 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
         //
         // Run through visible octant beam points
         //
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           //
           // Check parent visiblity
           //
@@ -402,7 +402,7 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             // Update distance
             //
             occluded = 1
-            dist    = dist + 1
+            dist     = dist + 1
           fin
         next
         break
@@ -419,17 +419,17 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap - mapcols) = adjtile | VIEWED_TILE
                 screen.[ycentr-xbeam[l]-1, xcentr+ybeam[l]] = adjtile
-          fin
+              fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr-xbeam[l], xcentr+ybeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg - xbeam[l]) << rowshift) + xorg + ybeam[l]
             tile = ^(map + imap)
@@ -437,24 +437,24 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
               vispix[l] = 0
             else
               vispix[l] = 1
-          occluded  = 0
+              occluded  = 0
             fin
-        if tile & LIT_TILE
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr-xbeam[l], xcentr+ybeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
       is 2
         for l = 1 to dbeam[lightdist]
@@ -464,47 +464,47 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap + mapcols) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap + mapcols) & INV_TILE
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap + mapcols) = adjtile | VIEWED_TILE
                 screen.[ycentr+xbeam[l]+1, xcentr+ybeam[l]] = adjtile
               fin
-        fin
+            fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr+xbeam[l], xcentr+ybeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg + xbeam[l]) << rowshift) + xorg + ybeam[l]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr+xbeam[l], xcentr+ybeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
       is 3
         for l = 1 to dbeam[lightdist]
@@ -514,47 +514,47 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap + 1) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap + 1) & INV_TILE
               if  adjtile & OPAQUE_TILE
                 ^(viewmap + imap + 1) = adjtile | VIEWED_TILE
                 screen.[ycentr+ybeam[l], xcentr+xbeam[l]+1] = adjtile
               fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr+ybeam[l], xcentr+xbeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg + ybeam[l]) << rowshift) + xorg + xbeam[l]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr+ybeam[l], xcentr+xbeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
       is 4
         for l = 1 to dbeam[lightdist]
@@ -564,47 +564,47 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap - 1) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap - 1) & INV_TILE
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap - 1) = adjtile | VIEWED_TILE
                 screen.[ycentr+ybeam[l], xcentr-xbeam[l]-1] = adjtile
               fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr+ybeam[l], xcentr-xbeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg + ybeam[l]) << rowshift) + xorg - xbeam[l]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr+ybeam[l], xcentr-xbeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
       is 5
         for l = 1 to dbeam[lightdist]
@@ -614,48 +614,48 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap + mapcols) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap + mapcols) & INV_TILE
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap + mapcols) = adjtile | VIEWED_TILE
                 screen.[ycentr+xbeam[l]+1, xcentr-ybeam[l]] = adjtile
               fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr+xbeam[l], xcentr-ybeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg + xbeam[l]) << rowshift) + xorg - ybeam[l]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr+xbeam[l], xcentr-ybeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
-    break
+            dist     = dist + 1
+          fin
+        next
+        break
       is 6
         for l = 1 to dbeam[lightdist]
           if vispix[vbeam[l]]
@@ -664,47 +664,47 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap - mapcols) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap - mapcols) & INV_TILE
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap - mapcols) = adjtile | VIEWED_TILE
                 screen.[ycentr-xbeam[l]-1, xcentr-ybeam[l]] = adjtile
               fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr-xbeam[l], xcentr-ybeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           if vispix[vbeam[l]]
             imap = ((yorg - xbeam[l]) << rowshift) + xorg - ybeam[l]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr-xbeam[l], xcentr-ybeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
       is 7
         for l = 1 to dbeam[lightdist]
@@ -714,47 +714,47 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          adjtile = ^(map + imap - 1) & INV_TILE
+              vispix[l] = 1
+              adjtile = ^(map + imap - 1) & INV_TILE
               if adjtile & OPAQUE_TILE
                 ^(viewmap + imap - 1) = adjtile | VIEWED_TILE
                 screen.[ycentr-ybeam[l], xcentr-xbeam[l]-1] = adjtile
               fin
             fin
             ^(viewmap + imap) =  tile | VIEWED_TILE
-        if tile <> PIT_TILE
+            if tile <> PIT_TILE
               screen.[ycentr-ybeam[l], xcentr-xbeam[l]] = tile & INV_TILE
-        fin
+            fin
           else
             vispix[l] = 0
           fin
         next
-        for l = l to dbeam[viewdist]
+        for l = dbeam[lightdist]+1 to dbeam[viewdist]
           imap = ((yorg - ybeam[l]) << rowshift) + xorg - xbeam[l]
           if vispix[vbeam[l]]
             tile = ^(map + imap)
             if tile & OPAQUE_TILE
               vispix[l] = 0
             else
-          vispix[l] = 1
-          occluded  = 0
-        fin
-        if tile & LIT_TILE
+              vispix[l] = 1
+              occluded  = 0
+            fin
+            if tile & LIT_TILE
               ^(viewmap + imap) =  tile | VIEWED_TILE
               screen.[ycentr-ybeam[l], xcentr-xbeam[l]] = tile & INV_TILE
               darkness = 0
-        fin
+            fin
           else
             vispix[l] = 0
           fin
-      if l == dbeam[dist]
-        if occluded
-          break
-        fin
+          if l == dbeam[dist]
+            if occluded
+              break
+            fin
             occluded = 1
-            dist    = dist + 1
-      fin
-    next
+            dist     = dist + 1
+          fin
+        next
         break
     wend
   next

src/samplesrc/rogue.pla

@@ -535,47 +535,47 @@ def play
         is KEY_TILE
           player.key = 1
           updtmaptile(player.xpos, player.ypos, FLOOR_TILE)
-      gotit
-      break
+          gotit
+          break
         is RAFT_TILE
           player.raft = 1
           updtmaptile(player.xpos, player.ypos, FLOOR_TILE)
-      gotit
-      break
+          gotit
+          break
         is GOLD_TILE
           player.gold = player.gold + 1
           updtmaptile(player.xpos, player.ypos, FLOOR_TILE)
-      gotit
+          gotit
           break
         is TORCH_TILE
-      if player.oil < 1000
+          if player.oil < 1000
             player:oil = player:oil + TORCH_OIL
-        if player:oil > 1000
-          player:oil = 1000
-        fin
+            if player:oil > 1000
+              player:oil = 1000
+            fin
             setmaptile(player.xpos, player.ypos, FLOOR_TILE)
             for yt = player.ypos - 1 to player.ypos + 1
-          for xt = player.xpos - 1 to player.xpos + 1
-            setmaptile(xt, yt, getmaptile(xt, yt) & MAP_TILE)
-          next
-        next
-        gotit
-      fin
+              for xt = player.xpos - 1 to player.xpos + 1
+                setmaptile(xt, yt, getmaptile(xt, yt) & MAP_TILE)
+              next
+            next
+            gotit
+          fin
           break
         is FOOD_TILE
-      if player.health < 100 or player.energy < 100
+          if player.health < 100 or player.energy < 100
             player.health = player.health + MANA/2
-        if player.health > 100
-          player.health = 100
-        fin
+            if player.health > 100
+              player.health = 100
+            fin
             player.energy = player.energy + MANA
-        if player.energy > 100
-          player.energy = 100
-        fin
-        updtmaptile(player.xpos, player.ypos, FLOOR_TILE)
-        player.fov = 1
-        gotit
-      fin
+            if player.energy > 100
+              player.energy = 100
+            fin
+            updtmaptile(player.xpos, player.ypos, FLOOR_TILE)
+            player.fov = 1
+            gotit
+          fin
           break
       wend
       break

src/samplesrc/sfm.pla

@@ -0,0 +1,637 @@
+//
+// Ziggy Stardust and the Spiders from Mars
+//
+include "inc/cmdsys.plh"
+include "inc/hgrlib.plh"
+include "inc/hgrsprite.plh"
+include "inc/joybuzz.plh"
+sysflags reshgr1 // Reserve HGR page 1
+
+const NUMSTARS         = 32
+const SHIP_SPRTNUM     = 0
+const MISSLE_SPRTNUM   = 1
+const WEB_SPRTBASE     = 2
+const SPIDER_SPRTEBASE = 8
+const LASER_RECHARGE   = 20
+const MISSLE_RELOAD    = 10
+const ATTACK_SPEED     = 12
+const SWARM_LIMIT      = 52
+const FASTMOVE_LIMIT   = 120
+const WEB_LIMIT        = 152
+const YSHIP            = 180
+const LASER_BUZZ       = 20
+const ATTACK_BUZZ      = 5
+const WEB1_BUZZ        = 10
+const WEB2_BUZZ        = 12
+const WEB3_BUZZ        = 14
+const SPLAT_BUZZ       = 40
+
+var sprtEgg1, sprtEgg2, sprtEgg3, sprtEgg
+var sprtSpider1, sprtSpider2, sprtSpider3, sprtSpider
+var sprtSplat1, sprtSplat2
+var sprtWeb1, sprtWeb2, sprtWeb3
+var sprtShip, sprtMissle, sprtDummy, heapstart
+var[NUMSTARS]  xstar
+byte[NUMSTARS] ystar
+byte curstar, buzz
+
+//
+// Apple II speaker tone generator routine
+//
+//asm spkrTone(pitch, duration)#0
+byte _spkrTone[]
+byte = $86, $E5         // STX ESP
+byte = $B4, $C0         // LDY ESTKH,X 
+byte = $B5, $D0         // LDA ESTKL,X
+byte = $F0, $01         // BEQ +1
+byte = $C8              // INY
+byte = $85, $08         // STA DSTL
+byte = $84, $09         // STY DSTH
+byte = $B4, $C1         // LDY ESTKL+1,X
+byte = $B5, $D1         // LDA ESTKL+1,X
+byte = $F0, $01         // BEQ +1
+byte = $C8              // INY
+byte = $85, $E7         // STA TMPL
+byte = $84, $E8         // STY TMPH
+byte = $AA              // TAX
+byte = $A9, $FF         // LDA #$FF
+byte = $08              // PHP
+byte = $78              // SEI
+byte = $EA              // NOP
+byte = $EA              // NOP
+byte = $B0, $00         // BCS +0
+byte = $38              // SEC
+byte = $CA              // DEX
+byte = $D0, $18         // BNE +18
+byte = $88              // DEY
+byte = $D0, $17         // BNE +17
+byte = $2C, $30, $C0    // BIT $C030
+byte = $A6, $E7         // LDX TMPL
+byte = $A4, $E8         // LDY TMPH
+byte = $E9, $01         // SBC #$01
+byte = $B0, $EA         // BCS -EA
+byte = $C6, $08         // DEC DSTL
+byte = $D0, $EA         // BNE -EA
+byte = $C6, $09         // DEC DSTH
+byte = $D0, $E6         // BNE -E6
+byte = $F0, $07         // BEQ +8
+byte = $EA              // NOP
+byte = $EA              // NOP
+byte = $EA, $EA         // BIT $C000 (nope)
+byte = $EA              // NOP
+byte = $D0, $EB         // BNE -EA
+byte = $28              // PLP
+byte = $A6, $E5         // LDX ESP
+byte = $E8              // INX
+byte = $E8              // INX
+byte = $60              // RTS
+
+def game(spdrcnt)#1
+  var[8] xspdr, yspdr, ixspdr, iyspdr, hatch
+  var xship, xmissle, leftxlaser, rightxlaser, attack
+  byte[8] life, death
+  byte lasercharging, missleloading, misslecnt, ymissle
+  byte leftylaser, rightylaser, lefthit, righthit, sprtnum[], width
+  byte spdrnum, k, xdelta, ydelta, btn0, btn1, webstate
+
+  xship         = 140
+  ymissle       = 255 // Not active value
+  misslecnt     = 6
+  missleloading = FALSE
+  lasercharging = FALSE
+  //
+  // Initialize the spiders (first is special)
+  //
+  xspdr[0]  = 100
+  ixspdr[0] = 1
+  yspdr[0]  = 60
+  iyspdr[0] = -1
+  hatch[0]  = 1
+  life[0]   = 3
+  death[0]  = 0
+  attack    = -1
+  webstate  = 0
+  //
+  // Initialize spiders
+  //
+  spdrnum   = spdrcnt - 1
+  for k = 1 to spdrnum
+    spriteAdd(k + SPIDER_SPRTEBASE, spriteDup(sprtEgg3))
+    xspdr[k]  = ((xspdr[k - 1] ^ 37) + 97) & 255
+    ixspdr[k] = -ixspdr[k - 1]
+    yspdr[k]  = ((yspdr[k - 1] ^ 29) + 53) & 63
+    iyspdr[k] = -iyspdr[k - 1]
+    hatch[k]  = k / 2 + 1//hatch[k - 1] + 1
+    life[k]   = 3
+    death[k]  = 0
+  next
+  //
+  // Initialize missle display
+  //
+  hgrColor(3)
+  hgrRect(0, YSHIP+3, 279, 191)
+  for k = 0 to misslecnt-1
+    spritePos(k * 16 + 160, 184, sprtMissle)
+    spriteDrawXor(sprtMissle)
+  next
+  hgrColor(1)
+  hgrRect(4, YSHIP+6, LASER_RECHARGE * 4 + 4, 188)
+  //
+  // Main game loop
+  //
+  repeat
+    //
+    // Move living spiders
+    //
+    for k = 0 to spdrnum
+      if life[k]
+        yspdr[k] = yspdr[k] + iyspdr[k]
+        if yspdr[k] < -5
+          //
+          // Above screen
+          //
+          iyspdr[k] = 1
+          if hatch[k]
+            hatch[k]--
+            if hatch[k] == 0
+              //
+              // Hatch this egg into a spider
+              //
+              life[k] = 3 // Reset life
+              spriteAdd(k + SPIDER_SPRTEBASE, spriteDup(sprtSpider3))
+            fin
+          fin
+        fin
+        if yspdr[k] > SWARM_LIMIT
+          //
+          // Attack or not?
+          //
+          if hatch[k] == 0 and attack < 0
+            attack = k
+            iyspdr[k] = ATTACK_SPEED
+          fin
+          if attack == k
+            //
+            // Attacking
+            //
+            if yspdr[k] > WEB_LIMIT
+              //
+              // Iterate through web sequence
+              //
+              when webstate
+                is 10
+                  iyspdr[k] = -8 // Retreat
+                  yspdr[k]  = WEB_LIMIT
+                  spriteDel(2)
+                  spriteDel(3)
+                  spriteDel(4)
+                  webstate = 0
+                  break
+                is 0
+                  iyspdr[k] = 0
+                  spriteAdd(2, sprtWeb1)
+                  spritePosIndex(xspdr[k], WEB_LIMIT+7, 2)
+                  buzz = WEB1_BUZZ
+                  webstate = 1
+                  break
+                is 1
+                  spriteAdd(3, sprtWeb2)
+                  spritePosIndex(xspdr[k], WEB_LIMIT+15, 3)
+                  buzz = WEB2_BUZZ
+                  webstate = 2
+                  break
+                is 2
+                  spriteAdd(4, sprtWeb3)
+                  spritePosIndex(xspdr[k], WEB_LIMIT+22, 4)
+                  webstate = 3
+                otherwise
+                  //
+                  // States 3..9 just repeat this
+                  //
+                  if xship >= xspdr[k] - 17 and xship <= xspdr[k] + 17
+                    //
+                    // Capture ship
+                    //
+                    return FALSE
+                  fin
+                  buzz = WEB3_BUZZ
+                  webstate++
+              wend
+            else
+              if iyspdr[k] > 0
+                //
+                // Move towards player during attack, but not too fast
+                //
+                xdelta   = yspdr[k] > FASTMOVE_LIMIT ?? 2 :: 4
+                xspdr[k] = xspdr[k] + (xship - xspdr[k]) / xdelta
+                buzz = ATTACK_BUZZ
+              else
+                //
+                // Retreat at a progressively faster rate
+                //
+                if ixspdr[k] > 0
+                  xspdr[k] = xspdr[k] + (WEB_LIMIT - yspdr[k]) / 8
+                else
+                  xspdr[k] = xspdr[k] - (WEB_LIMIT - yspdr[k]) / 8
+                fin
+              fin
+            fin
+          else
+            //
+            // Just reverse direction towards top of screen
+            //
+            iyspdr[k] = -1
+          fin
+        else
+          if attack == k
+            //
+            // Retreated back to swarm zone so stop attack
+            //
+            attack    = -1
+            iyspdr[k] = -1
+          fin
+          //
+          // Swarm movement
+          //
+          if ixspdr[k] > 0
+            xspdr[k] = xspdr[k] + yspdr[k] / 8
+          else
+            xspdr[k] = xspdr[k] - yspdr[k] / 8
+          fin
+          if xspdr[k] < -5 or xspdr[k] > 284
+            if xspdr[k] < -5
+              xspdr[k]  = -5
+              ixspdr[k] = 1
+            else
+              xspdr[k]  = 284
+              ixspdr[k] = -1
+            fin
+          fin
+        fin
+        spritePosIndex(xspdr[k], yspdr[k], k+SPIDER_SPRTEBASE)
+      elsif death[k]
+        //
+        // Splat sequence
+        //
+        death[k]--
+        if death[k]
+          spriteAdd(k+SPIDER_SPRTEBASE, spriteDup(sprtSplat2))
+          spritePosIndex(xspdr[k], yspdr[k], k+SPIDER_SPRTEBASE)
+        else
+          spriteAdd(k+SPIDER_SPRTEBASE, spriteDup(sprtDummy))
+          spritePosIndex(0, 0, k+SPIDER_SPRTEBASE)
+          spdrcnt--
+          if not spdrcnt
+             return TRUE
+          fin
+          buzz = SPLAT_BUZZ
+        fin
+      fin
+    next
+    //
+    // Move ship
+    //
+    xdelta, ydelta, btn0, btn1 = joypos(buzz)
+    buzz  = spdrcnt * 4
+    xship = xship + ((xdelta + 4) / 8 - 5)
+    if xship < 0;   xship = 0;   fin
+    if xship > 279; xship = 279; fin
+    spritePosIndex(xship, YSHIP, SHIP_SPRTNUM)
+    //
+    // Missle
+    //
+    if misslecnt and missleloading
+        missleloading--
+    fin
+    if btn1 and not missleloading and ymissle == 255
+      //
+      // Fire missle
+      //
+      xmissle       = xship
+      ymissle       = YSHIP-15
+      missleloading = MISSLE_RELOAD
+      misslecnt--
+      spritePos(misslecnt * 16 + 160, 184, sprtMissle) // Erase from armory
+      spriteDrawXor(sprtMissle)
+      spriteAdd(1, sprtMissle)
+    fin
+    if ymissle <> 255
+      if ymissle < 8
+        //
+        // Missle off top of screen
+        //
+        spriteDel(1)
+        ymissle = 255
+      else
+        ymissle = ymissle - 8
+        spritePosIndex(xmissle, ymissle, MISSLE_SPRTNUM)
+        for k = 0 to spdrnum
+          if life[k]
+            //
+            // Hit test will all living spiders
+            //
+            if ymissle >= yspdr[k] - 15 and ymissle <= yspdr[k] + 5
+              if hatch[k]
+                width = 7 // Egg width
+              else
+                width = 10 // Spider width
+              fin
+              if xmissle >= xspdr[k] - width and xmissle <= xspdr[k] + width
+                //
+                // Hit & kill spider
+                //
+                life[k]  = 0
+                death[k] = 2
+                spriteAdd(k+SPIDER_SPRTEBASE, spriteDup(sprtSplat1))
+                spritePosIndex(xspdr[k], yspdr[k], k+SPIDER_SPRTEBASE)
+                if attack == k // Was it attacking?
+                  attack = -1
+                  spriteDel(2)
+                  spriteDel(3)
+                  spriteDel(4)
+                  webstate = 0
+                fin
+                //
+                // Remove missle
+                //
+                spriteDel(MISSLE_SPRTNUM)
+                ymissle = 255
+              fin
+            fin
+          fin
+        next
+        buzz = ymissle/4
+      fin
+    fin
+    //
+    // Update sprites
+    //
+    spriteDrawXorList()
+    //
+    // Lasers
+    //
+    if lasercharging
+      lasercharging--
+      hgrColor(1)
+      hgrRect(81 - lasercharging*4, YSHIP+6, 84 - lasercharging*4, 188)
+    fin
+    if btn0 and not lasercharging
+      //
+      // Fire laser
+      //
+      hgrColor(0)
+      hgrRect(4, YSHIP+6, LASER_RECHARGE * 4 + 4, 188)
+      lasercharging = LASER_RECHARGE
+      leftxlaser    = xship - 7
+      rightxlaser   = xship + 7
+      leftylaser    = 0
+      rightylaser   = 0
+      lefthit       = 255
+      righthit      = 255
+      for k = 0 to spdrnum
+        if life[k]
+          //
+          // Hit test will all living spiders
+          //
+          if hatch[k]
+            width = 7 // Egg width
+          else
+            width = 10 // Spider width
+          fin
+          if leftxlaser >= xspdr[k]-width and leftxlaser <= xspdr[k]+width
+            if yspdr[k] + 5 > leftylaser
+              lefthit    = k
+              leftylaser = yspdr[k] + 5
+            fin
+          fin
+          if rightxlaser >= xspdr[k]-width and rightxlaser <= xspdr[k]+width
+            if yspdr[k] + 5 > rightylaser
+              righthit    = k
+              rightylaser = yspdr[k] + 5
+            fin
+          fin
+        fin
+      next
+      //
+      // Draw Laser beams
+      //
+      hgrColor(3)
+      if leftxlaser >= 0
+        hgrXorVLin(leftylaser,  YSHIP-8, leftxlaser)
+        hgrXorVLin(leftylaser,  YSHIP-8, leftxlaser+1)
+      fin
+      if rightxlaser < 280
+        hgrXorVLin(rightylaser,  YSHIP-8, rightxlaser)
+        hgrXorVLin(rightylaser,  YSHIP-8, rightxlaser-1)
+      fin
+      buzz = LASER_BUZZ
+      (@_spkrTone)(15, 1)#0
+      if lefthit <> 255
+        sprtnum = lefthit + SPIDER_SPRTEBASE
+        //
+        // Hit
+        //
+        life[lefthit]--
+        if not life[lefthit]
+          //
+          // Kill spider
+          //
+          death[lefthit] = 2
+          spriteAdd(sprtnum, spriteDup(sprtSplat1))
+          spritePosIndex(xspdr[lefthit], yspdr[lefthit], sprtnum)
+          if attack == lefthit // Was it attacking?
+            spriteDel(2)
+            spriteDel(3)
+            spriteDel(4)
+            webstate = 0
+            attack   = -1
+          fin
+        else
+          //
+          // Dim color to show life status
+          //
+          if hatch[lefthit]
+            sprtEgg = life[lefthit] == 2 ?? sprtEgg2 :: sprtEgg1
+            spriteAdd(sprtnum, spriteDup(sprtEgg))
+          else
+            sprtSpider = life[lefthit] == 2 ?? sprtSpider2 :: sprtSpider1
+            spriteAdd(sprtnum, spriteDup(sprtSpider))
+          fin
+          spritePosIndex(xspdr[lefthit], yspdr[lefthit], sprtnum)
+        fin
+      fin
+      if righthit <> 255 and life[righthit]
+        sprtnum = righthit + SPIDER_SPRTEBASE
+        //
+        // Hit
+        //
+        life[righthit]--
+        if not life[righthit]
+          //
+          // Kill spider
+          //
+          death[righthit] = 2
+          spriteAdd(sprtnum, spriteDup(sprtSplat1))
+          spritePosIndex(xspdr[righthit], yspdr[righthit], sprtnum)
+          if attack == righthit // Was it attacking?
+            spriteDel(2)
+            spriteDel(3)
+            spriteDel(4)
+            webstate = 0
+            attack   = -1
+          fin
+        else
+          //
+          // Dim color to show life status
+          //
+          if hatch[righthit]
+            sprtEgg = life[righthit] == 2 ?? sprtEgg2 :: sprtEgg1
+            spriteAdd(sprtnum, spriteDup(sprtEgg))
+          else
+            sprtSpider = life[righthit] == 2 ?? sprtSpider2 :: sprtSpider1
+            spriteAdd(sprtnum, spriteDup(sprtSpider))
+          fin
+          spritePosIndex(xspdr[righthit], yspdr[righthit], sprtnum)
+        fin
+      fin
+      //
+      // Undraw lasers
+      //
+      hgrColor(3)
+      if leftxlaser >= 0
+        hgrXorVLin(leftylaser,  YSHIP-8, leftxlaser)
+        hgrXorVLin(leftylaser,  YSHIP-8, leftxlaser+1)
+      fin
+      if rightxlaser < 280
+        hgrXorVLin(rightylaser,  YSHIP-8, rightxlaser)
+        hgrXorVLin(rightylaser,  YSHIP-8, rightxlaser-1)
+      fin
+    fin
+    //
+    // Update stars
+    //
+    hgrColor(3)
+    hgrXorPlot(xstar[curstar], ystar[curstar])
+    ystar[curstar]++
+    if ystar[curstar] > YSHIP
+        ystar[curstar] = 0
+    fin
+    hgrXorPlot(xstar[curstar], ystar[curstar])
+    curstar++
+    if curstar >= NUMSTARS; curstar = 0; fin
+  until ^$C000 == $9B // ESCape key pressed
+  getc
+  return FALSE
+end
+//
+// Initialization
+//
+puts("Loading");
+putc('.')
+sprtShip = spriteRead("SHIP")
+if not sprtShip
+  cmdsys:modexec("SFMSPRT")
+  sprtShip = spriteRead("SHIP")
+  if not sprtShip
+    puts("\nError: Unable to compile sprites.\n")
+    return -1
+  fin
+fin
+putc('.')
+sprtMissle = spriteRead("MISSLE")
+putc('.')
+sprtEgg3   = spriteRead("EGG3")
+putc('.')
+sprtEgg2   = spriteRead("EGG2")
+putc('.')
+sprtEgg1   = spriteRead("EGG1")
+putc('.')
+sprtSpider3= spriteRead("SPIDER3")
+putc('.')
+sprtSpider2= spriteRead("SPIDER2")
+putc('.')
+sprtSpider1= spriteRead("SPIDER1")
+putc('.')
+sprtWeb1   = spriteRead("WEB1")
+putc('.')
+sprtWeb2   = spriteRead("WEB2")
+putc('.')
+sprtWeb3   = spriteRead("WEB3")
+putc('.')
+sprtSplat1 = spriteRead("SPLAT1")
+putc('.')
+sprtSplat2 = spriteRead("SPLAT2")
+putc('.')
+sprtDummy  = spriteRead("DUMMY")
+//
+// Heat up JIT compiler
+//
+for curstar = 0 to 50
+  putc('.')
+  spriteAdd(0, sprtDummy)
+  spritePosIndex(0, 0, 0)
+  spriteDrawXorList()
+next
+heapstart = heapmark()
+//puts("\nBeginning available memory: "); puti(heapavail()); putln
+repeat
+  hgrMode(TRUE)
+  spriteDrawBuf(hgrDrawBuf(0)) // Single buffered
+  spriteAdd(SHIP_SPRTNUM, sprtShip)
+  spriteAdd(SPIDER_SPRTEBASE, sprtEgg3)
+  //
+  // Init stars
+  //
+  xstar[0] = 99
+  ystar[0] = 10
+  hgrColor(3)
+  hgrXorPlot(xstar[0], ystar[0])
+  for curstar = 1 to NUMSTARS-1
+    xstar[curstar] = (xstar[curstar - 1] + 97 - curstar) % 280
+    ystar[curstar] = (ystar[curstar - 1] + 19 + curstar) % YSHIP
+    hgrXorPlot(xstar[curstar], ystar[curstar])
+  next
+  curstar = 0
+  if game(8)
+    //
+    // Won
+    //
+    spriteDrawXorList()
+    (@_spkrTone)(100, 20)#0
+    (@_spkrTone)(75,  20)#0
+    (@_spkrTone)(15,  20)#0
+    (@_spkrTone)(25,  100)#0
+    puts("\nZiggy Stardust has saved Earth!\n")
+  else
+    //
+    // Lost
+    //
+    spriteDrawXorList()
+    (@_spkrTone)(100, 50)#0
+    spriteDrawXor(sprtShip)
+    (@_spkrTone)(150, 50)#0
+    spriteDrawXor(sprtShip)
+    (@_spkrTone)(100, 50)#0
+    spriteDrawXor(sprtShip)
+    (@_spkrTone)(150, 50)#0
+    puts("\nEarth has been overrun")
+    puts("\nby the Spiders from Mars\n")
+  fin
+  hgrMode(FALSE)
+  //
+  // Clear sprite lists
+  //
+  for curstar = 0 to 15
+    spriteDel(curstar)
+  next
+  spriteDrawXorList()
+  spriteDrawXorList()
+  //
+  // Reset heap
+  //
+  heaprelease(heapstart)
+  //puts("\nAvailable memory: "); puti(heapavail()); putln
+  puts("Play again (Y/N)?")
+until toupper(getc) <> 'Y'
+putln
+done

src/samplesrc/sfmsprt.pla

@@ -0,0 +1,203 @@
+include "inc/cmdsys.plh"
+include "inc/hgrlib.plh"
+include "inc/hgrsprite.plh"
+sysflags reshgr1 // Reserve HGR page 1
+
+
+byte egg3   = $88,$88,$83,$33,$38,$88,$88
+byte        = $88,$83,$33,$11,$33,$38,$88
+byte        = $83,$31,$11,$11,$11,$13,$38
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $33,$11,$11,$11,$11,$11,$33
+byte        = $83,$31,$11,$11,$11,$13,$38
+byte        = $88,$83,$33,$11,$33,$38,$88
+byte        = $88,$88,$83,$33,$38,$88,$88
+byte egg2   = $88,$88,$83,$33,$38,$88,$88
+byte        = $88,$83,$33,$11,$33,$38,$88
+byte        = $83,$30,$11,$00,$11,$13,$38
+byte        = $33,$11,$00,$11,$00,$11,$33
+byte        = $33,$00,$11,$00,$11,$00,$33
+byte        = $33,$11,$00,$11,$00,$11,$33
+byte        = $33,$00,$11,$00,$11,$00,$33
+byte        = $33,$11,$00,$11,$00,$11,$33
+byte        = $33,$00,$11,$00,$11,$00,$33
+byte        = $83,$31,$00,$11,$00,$13,$38
+byte        = $88,$83,$33,$00,$33,$38,$88
+byte        = $88,$88,$83,$33,$38,$88,$88
+byte egg1   = $88,$88,$83,$33,$38,$88,$88
+byte        = $88,$83,$33,$00,$33,$38,$88
+byte        = $83,$30,$00,$00,$00,$03,$38
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $33,$00,$00,$00,$00,$00,$33
+byte        = $83,$30,$00,$00,$00,$03,$38
+byte        = $88,$83,$33,$11,$33,$38,$88
+byte        = $88,$88,$83,$33,$38,$88,$88
+byte spider3 = $33,$88,$88,$33,$33,$33,$33,$88,$88,$33
+byte         = $33,$88,$83,$32,$22,$22,$23,$38,$88,$33
+byte         = $83,$38,$83,$32,$22,$22,$23,$38,$83,$38
+byte         = $88,$83,$33,$22,$22,$22,$22,$33,$38,$88
+byte         = $33,$88,$33,$22,$22,$22,$22,$33,$88,$33
+byte         = $88,$33,$38,$33,$22,$22,$33,$83,$33,$88
+byte         = $88,$88,$83,$33,$22,$22,$33,$38,$88,$88
+byte         = $88,$33,$33,$33,$22,$22,$33,$33,$33,$88
+byte         = $33,$88,$88,$88,$33,$33,$88,$88,$88,$33
+byte         = $88,$88,$33,$33,$22,$22,$33,$33,$88,$88
+byte         = $88,$33,$88,$33,$22,$22,$33,$88,$33,$88
+byte         = $33,$88,$88,$83,$32,$23,$38,$88,$88,$33
+byte         = $88,$88,$88,$88,$33,$33,$88,$88,$88,$88
+byte spider2 = $33,$88,$88,$33,$33,$33,$33,$88,$88,$33
+byte         = $33,$88,$83,$30,$02,$20,$03,$38,$88,$33
+byte         = $83,$38,$83,$32,$20,$02,$23,$38,$83,$38
+byte         = $88,$83,$33,$20,$02,$20,$02,$33,$38,$88
+byte         = $33,$88,$33,$02,$20,$02,$20,$33,$88,$33
+byte         = $88,$33,$38,$30,$02,$20,$03,$83,$33,$88
+byte         = $88,$88,$83,$33,$20,$02,$33,$38,$88,$88
+byte         = $88,$33,$33,$30,$02,$20,$03,$33,$33,$88
+byte         = $33,$88,$88,$88,$33,$33,$88,$88,$88,$33
+byte         = $88,$88,$33,$30,$02,$20,$03,$33,$88,$88
+byte         = $88,$33,$88,$33,$20,$02,$33,$88,$33,$88
+byte         = $33,$88,$88,$83,$32,$23,$38,$88,$88,$33
+byte         = $88,$88,$88,$88,$33,$33,$88,$88,$88,$88
+byte spider1 = $33,$88,$88,$33,$33,$33,$33,$88,$88,$33
+byte         = $33,$88,$83,$30,$00,$00,$03,$38,$88,$33
+byte         = $83,$38,$83,$30,$00,$00,$03,$38,$83,$38
+byte         = $88,$83,$33,$00,$00,$00,$00,$33,$38,$88
+byte         = $33,$88,$33,$00,$00,$00,$00,$33,$88,$33
+byte         = $88,$33,$38,$33,$00,$00,$33,$83,$33,$88
+byte         = $88,$88,$83,$33,$00,$00,$33,$38,$88,$88
+byte         = $88,$33,$33,$30,$00,$00,$03,$33,$33,$88
+byte         = $33,$88,$88,$88,$33,$33,$88,$88,$88,$33
+byte         = $88,$88,$33,$30,$00,$00,$03,$33,$88,$88
+byte         = $88,$33,$88,$33,$00,$00,$33,$88,$33,$88
+byte         = $33,$88,$88,$83,$30,$03,$38,$88,$88,$33
+byte         = $88,$88,$88,$88,$33,$33,$88,$88,$88,$88
+byte web1    =             $88,$83,$38,$88
+byte         =             $88,$38,$83,$88
+byte         =             $88,$38,$83,$88
+byte         =             $88,$33,$33,$88
+byte         =             $83,$38,$83,$38
+byte         =             $83,$38,$83,$38
+byte         =             $83,$38,$83,$38
+byte         =             $33,$33,$33,$33
+byte web2    =         $88,$33,$83,$38,$33,$88
+byte         =         $88,$38,$83,$38,$83,$88
+byte         =         $83,$38,$83,$38,$83,$38
+byte         =         $83,$33,$33,$33,$33,$38
+byte         =         $83,$38,$83,$38,$83,$38
+byte         =         $83,$38,$83,$38,$83,$38
+byte         =         $33,$88,$83,$38,$88,$33
+byte         =         $33,$33,$33,$33,$33,$33
+byte web3    = $88,$83,$38,$83,$38,$83,$38,$83,$38,$88
+byte         = $88,$83,$38,$83,$38,$83,$38,$83,$38,$88
+byte         = $88,$33,$88,$33,$88,$88,$33,$88,$33,$88
+byte         = $88,$33,$33,$33,$33,$33,$33,$33,$33,$88
+byte         = $83,$38,$88,$33,$83,$38,$33,$88,$83,$38
+byte         = $83,$38,$83,$38,$83,$38,$83,$38,$83,$38
+byte         = $33,$88,$83,$38,$83,$38,$83,$38,$88,$33
+byte         = $33,$38,$33,$33,$33,$33,$33,$33,$33,$33
+byte splat1 = $88,$88,$88,$22,$22,$22,$22,$88,$88,$88
+byte        = $88,$88,$88,$22,$11,$11,$22,$88,$88,$88
+byte        = $88,$88,$88,$22,$11,$11,$22,$88,$88,$88
+byte        = $88,$82,$22,$11,$11,$11,$11,$22,$28,$88
+byte        = $22,$22,$22,$11,$11,$11,$11,$22,$22,$22
+byte        = $88,$22,$28,$22,$11,$11,$22,$82,$22,$88
+byte        = $88,$88,$82,$22,$11,$11,$22,$28,$88,$88
+byte        = $88,$22,$22,$22,$11,$11,$22,$22,$22,$88
+byte        = $22,$22,$88,$88,$22,$22,$88,$88,$22,$22
+byte        = $88,$88,$22,$22,$11,$11,$22,$22,$88,$88
+byte        = $88,$22,$22,$22,$11,$11,$22,$22,$22,$88
+byte        = $22,$22,$88,$82,$21,$12,$28,$88,$22,$22
+byte        = $88,$88,$88,$88,$22,$22,$88,$88,$88,$88
+byte splat2 = $88,$88,$88,$88,$22,$22,$22,$22,$88,$88,$88,$88
+byte        = $88,$88,$88,$88,$22,$11,$11,$22,$88,$88,$88,$88
+byte        = $88,$88,$88,$82,$22,$11,$11,$22,$88,$88,$88,$88
+byte        = $88,$88,$88,$22,$11,$11,$11,$11,$22,$88,$88,$88
+byte        = $88,$88,$82,$22,$11,$18,$81,$11,$22,$28,$88,$88
+byte        = $88,$22,$22,$22,$11,$88,$88,$11,$22,$22,$22,$88
+byte        = $22,$28,$82,$22,$11,$88,$88,$11,$22,$28,$82,$22
+byte        = $88,$88,$22,$28,$88,$88,$88,$88,$82,$22,$88,$88
+byte        = $88,$88,$88,$22,$88,$88,$88,$11,$22,$88,$88,$88
+byte        = $88,$88,$22,$22,$11,$88,$88,$11,$22,$22,$88,$88
+byte        = $88,$22,$22,$22,$11,$18,$81,$11,$22,$22,$22,$88
+byte        = $88,$88,$88,$22,$11,$18,$81,$11,$22,$88,$88,$88
+byte        = $88,$88,$22,$22,$11,$11,$11,$11,$22,$22,$88,$88
+byte        = $88,$22,$22,$88,$22,$11,$11,$22,$88,$22,$22,$88
+byte        = $22,$28,$88,$88,$88,$22,$22,$88,$88,$88,$82,$22
+byte        = $88,$88,$22,$22,$22,$11,$11,$22,$22,$22,$88,$88
+byte        = $88,$88,$22,$28,$22,$11,$11,$22,$82,$22,$88,$88
+byte ship = $CC,$CC,$CC,$77,$CC,$CC,$CC
+byte      = $CC,$CC,$C7,$77,$7C,$CC,$CC
+byte      = $CC,$CC,$C7,$77,$7C,$CC,$CC
+byte      = $CC,$CC,$C7,$77,$7C,$CC,$CC
+byte      = $CC,$CC,$C7,$77,$7C,$CC,$CC
+byte      = $77,$CC,$77,$66,$77,$CC,$77
+byte      = $77,$CC,$77,$66,$77,$CC,$77
+byte      = $77,$CC,$77,$66,$77,$CC,$77
+byte      = $77,$CC,$77,$77,$77,$CC,$77
+byte      = $77,$CC,$77,$77,$77,$CC,$77
+byte      = $77,$CC,$77,$77,$77,$CC,$77
+byte      = $77,$C7,$77,$77,$77,$7C,$77
+byte      = $77,$77,$75,$55,$57,$77,$77
+byte      = $77,$77,$75,$55,$57,$77,$77
+byte missle = $CC,$55,$CC
+byte        = $CC,$55,$CC
+byte        = $CC,$55,$CC
+byte        = $CC,$55,$CC
+byte        = $CC,$55,$CC
+byte        = $CC,$55,$CC
+byte        = $C5,$55,$5C
+byte        = $55,$55,$55
+byte dummy = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+byte       = $88,$88,$88,$88
+var sprtEgg1, sprtEgg2, sprtEgg3
+var sprtSpider1, sprtSpider2, sprtSpider3
+var sprtSplat1, sprtSplat2
+var sprtWeb1, sprtWeb2, sprtWeb3
+var sprtShip, sprtMissle, sprtDummy
+
+hgrMode(TRUE)
+spriteDrawBuf(hgrDrawBuf(0)) // So we can see the compile process
+sprtShip   = spriteCompile(14, 14,  7, 13, @ship)
+sprtMissle = spriteCompile( 6,  8,  3,  0, @missle)
+sprtEgg3   = spriteCompile(14, 12,  7,  6, @egg3)
+sprtEgg2   = spriteCompile(14, 12,  7,  6, @egg2)
+sprtEgg1   = spriteCompile(14, 12,  7,  6, @egg1)
+sprtSpider3= spriteCompile(20, 13, 10,  6, @spider3)
+sprtSpider2= spriteCompile(20, 13, 10,  6, @spider2)
+sprtSpider1= spriteCompile(20, 13, 10,  6, @spider1)
+sprtWeb1   = spriteCompile( 8,  8,  4,  0, @web1)
+sprtWeb2   = spriteCompile(12,  8,  6,  0, @web2)
+sprtWeb3   = spriteCompile(20,  8, 10,  0, @web3)
+sprtSplat1 = spriteCompile(20, 13, 10,  6, @splat1)
+sprtSplat2 = spriteCompile(24, 17, 12,  8, @splat2)
+sprtDummy  = spriteCompile( 7,  8,  0,  0, @dummy)
+hgrMode(FALSE)
+spriteSave("SHIP", sprtShip)
+spriteSave("MISSLE", sprtMissle)
+spriteSave("EGG3", sprtEgg3)
+spriteSave("EGG2", sprtEgg2)
+spriteSave("EGG1", sprtEgg1)
+spriteSave("SPIDER1", sprtSpider1)
+spriteSave("SPIDER2", sprtSpider2)
+spriteSave("SPIDER3", sprtSpider3)
+spriteSave("WEB1", sprtWeb1)
+spriteSave("WEB2", sprtWeb2)
+spriteSave("WEB3", sprtWeb3)
+spriteSave("SPLAT1", sprtSplat1)
+spriteSave("SPLAT2", sprtSplat2)
+spriteSave("DUMMY", sprtDummy)
+done

src/samplesrc/sieve.pla

@@ -11,26 +11,30 @@ def beep#0
   putc(7)
 end
 
-beep
-//for iter = 1 to 10
-  flag = heapalloc(sizepl)
-  memset(flag, TRUE, sizepl)
-  count = 0
-  for i = 0 to size
-    if flag->[i]
-      prime = i + i + 3
-      k = i + prime
-      while k <= size
-        flag->[k] = FALSE
-        k = k + prime
-      loop
-      count = count + 1
-      puti(prime)
-      putln
-    fin
-  next
-//next
-beep
+def sieve#0
+  beep
+  //for iter = 1 to 10
+    flag = heapalloc(sizepl)
+    memset(flag, TRUE, sizepl)
+    count = 0
+    for i = 0 to size
+      if flag->[i]
+        prime = i + i + 3
+        k = i + prime
+        while k <= size
+          flag->[k] = FALSE
+          k = k + prime
+        loop
+        count = count + 1
+        puti(prime)
+        putln
+      fin
+    next
+  //next
+  beep
+end
+
+sieve
 puti(count)
 puts(" primes.\n")
 done

src/samplesrc/test.pla

@@ -204,5 +204,9 @@ puti(array:0); puts(" >  "); puti(array:0); puts (" is ")
 puts(array:0 >  array:0 ?? "TRUE\n" :: "FALSE\n")
 puti(array:0); puts(" <  "); puti(array:0); puts (" is ")
 puts(array:0 <  array:0 ?? "TRUE\n" :: "FALSE\n")
-ptr = 0
+ptr = 5
+puts("5*0="); puti(ptr*0); putln
+puts("5*1="); puti(ptr*1); putln
+puts("5*2="); puti(ptr*2); putln
+puts("5/1="); puti(ptr/1); putln
 done

src/samplesrc/tiletest.pla

@@ -0,0 +1,13 @@
+include "inc/cmdsys.plh"
+include "inc/hgrtile.plh"
+include "inc/hgrfont.plh"
+sysflags reshgr1 // Reserve HGR page 1
+
+tileMode(TRUE)
+hgrPutStr(5, 1, "Hello HiRes Tile Demo")
+getc
+tileFromText(0, @hgrFont)
+getc
+tileMode(FALSE)
+done
+

src/tftpbld

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# Build tools
+echo "BLD/PLASM";    atftp $1 --put -l rel/PLASM#FE1000   -r $2/BLD/PLASM#FE1000
+echo "BLD/CODEOPT";  atftp $1 --put -l rel/CODEOPT#FE1000 -r $2/BLD/CODEOPT#FE1000
+
+#Build incs
+echo "BLD/INC/ARGS.PLH";     atftp $1 --put -l inc/args.plh    -r $2/BLD/INC/ARGS.PLH#040000
+echo "BLD/INC/MATCHFILES.PLH"; atftp $1 --put -l inc/matchfiles.plh -r $2/BLD/INC/MATCHFILES.PLH#040000
+echo "BLD/INC/CMDSYS.PLH";   atftp $1 --put -l inc/cmdsys.plh  -r $2/BLD/INC/CMDSYS.PLH#040000
+echo "BLD/INC/CONIO.PLH";    atftp $1 --put -l inc/conio.plh   -r $2/BLD/INC/CONIO.PLH#040000
+echo "BLD/INC/LINES.PLH";    atftp $1 --put -l inc/lines.plh -r $2/BLD/INC/LINES.PLH#040000
+echo "BLD/INC/HGRTILE.PLH";  atftp $1 --put -l inc/hgrtile.plh -r $2/BLD/INC/HGRTILE.PLH#040000
+echo "BLD/INC/HGRFONT.PLH";atftp $1 --put -l inc/hgrfont.plh -r $2/BLD/INC/HGRFONT.PLH#040000
+echo "BLD/INC/HGRSPRITE.PLH";atftp $1 --put -l inc/hgrsprite.plh -r $2/BLD/INC/HGRSPRITE.PLH#040000
+echo "BLD/INC/HGRLIB.PLH";   atftp $1 --put -l inc/hgrlib.plh   -r $2/BLD/INC/HGRLIB.PLH#040000
+echo "BLD/INC/GRLIB.PLH";    atftp $1 --put -l inc/grlib.plh   -r $2/BLD/INC/GRLIB.PLH#040000
+echo "BLD/INC/DGRLIB.PLH";   atftp $1 --put -l inc/dgrlib.plh  -r $2/BLD/INC/DGRLIB.PLH#040000
+echo "BLD/INC/FIBER.PLH";    atftp $1 --put -l inc/fiber.plh   -r $2/BLD/INC/FIBER.PLH#040000
+echo "BLD/INC/FILEIO.PLH";   atftp $1 --put -l inc/fileio.plh  -r $2/BLD/INC/FILEIO.PLH#040000
+echo "BLD/INC/INT32.PLH";    atftp $1 --put -l inc/int32.plh   -r $2/BLD/INC/INT32.PLH#040000
+echo "BLD/INC/FPSTR.PLH";    atftp $1 --put -l inc/fpstr.plh   -r $2/BLD/INC/FPSTR.PLH#040000
+echo "BLD/INC/FPU.PLH";      atftp $1 --put -l inc/fpu.plh     -r $2/BLD/INC/FPU.PLH#040000
+echo "BLD/INC/GRAFIX.PLH";   atftp $1 --put -l inc/grafix.plh  -r $2/BLD/INC/GRAFIX.PLH#040000
+echo "BLD/INC/INET.PLH";     atftp $1 --put -l inc/inet.plh    -r $2/BLD/INC/INET.PLH#040000
+echo "BLD/INC/JOYBUZZ.PLH";  atftp $1 --put -l inc/joybuzz.plh -r $2/BLD/INC/JOYBUZZ.PLH#040000
+echo "BLD/INC/LONGJUMP.PLH"; atftp $1 --put -l inc/longjmp.plh -r $2/BLD/INC/LONGJUMP.PLH#040000
+echo "BLD/INC/LZ4.PLH";      atftp $1 --put -l inc/lz4.plh     -r $2/BLD/INC/LZ4.PLH#040000
+echo "BLD/INC/MEMMGR.PLH";   atftp $1 --put -l inc/memmgr.plh  -r $2/BLD/INC/MEMMGR.PLH#040000
+echo "BLD/INC/MOUSE.PLH";    atftp $1 --put -l inc/mouse.plh   -r $2/BLD/INC/MOUSE.PLH#040000
+echo "BLD/INC/PORTIO.PLH";   atftp $1 --put -l inc/portio.plh  -r $2/BLD/INC/PORTIO.PLH#040000
+echo "BLD/INC/SANE.PLH";     atftp $1 --put -l inc/sane.plh    -r $2/BLD/INC/SANE.PLH#040000
+echo "BLD/INC/SDFAT.PLH";    atftp $1 --put -l inc/sdfat.plh   -r $2/BLD/INC/SDFAT.PLH#040000
+echo "BLD/INC/SNDSEQ.PLH";   atftp $1 --put -l inc/sndseq.plh  -r $2/BLD/INC/SNDSEQ.PLH#040000
+echo "BLD/INC/SPIPORT.PLH";  atftp $1 --put -l inc/spiport.plh -r $2/BLD/INC/SPIPORT.PLH#040000
+echo "BLD/INC/TESTLIB.PLH";  atftp $1 --put -l inc/testlib.plh -r $2/BLD/INC/TESTLIB.PLH#040000
+
+# Sample sources
+echo "BLD/SAMPLES/HELLO.PLA";     atftp $1 --put -l samplesrc/hello.pla     -r $2/BLD/SAMPLES/HELLO.PLA#040000
+echo "BLD/SAMPLES/TESTLIB.PLA";   atftp $1 --put -l samplesrc/testlib.pla   -r $2/BLD/SAMPLES/TESTLIB.PLA#040000
+echo "BLD/SAMPLES/TEST.PLA";      atftp $1 --put -l samplesrc/test.pla      -r $2/BLD/SAMPLES/TEST.PLA#040000
+echo "BLD/SAMPLES/FIBERTEST.PLA"; atftp $1 --put -l samplesrc/fibertest.pla -r $2/BLD/SAMPLES/FIBERTEST.PLA#040000
+echo "BLD/SAMPLES/MOUSETEST.PLA"; atftp $1 --put -l samplesrc/mousetest.pla -r $2/BLD/SAMPLES/MOUSETEST.PLA#040000
+echo "BLD/SAMPLES/ROD.PLA";       atftp $1 --put -l samplesrc/rod.pla       -r $2/BLD/SAMPLES/ROD.PLA#040000
+echo "BLD/SAMPLES/INT32TEST.PLA"; atftp $1 --put -l samplesrc/int32test.pla -r $2/BLD/SAMPLES/INT32TEST.PLA#040000
+echo "BLD/SAMPLES/HGRTEST.PLA";   atftp $1 --put -l samplesrc/hgrtest.pla    -r $2/BLD/SAMPLES/HGRTEST.PLA#040000
+echo "BLD/SAMPLES/GRTEST.PLA";    atftp $1 --put -l samplesrc/grtest.pla    -r $2/BLD/SAMPLES/GRTEST.PLA#040000
+echo "BLD/SAMPLES/DGRTEST.PLA";   atftp $1 --put -l samplesrc/dgrtest.pla   -r $2/BLD/SAMPLES/DGRTEST.PLA#040000
+echo "BLD/SAMPLES/TILETEST.PLA";  atftp $1 --put -l samplesrc/tiletest.pla   -r $2/BLD/SAMPLES/TILETEST.PLA#040000
+echo "BLD/SAMPLES/HGRTEST.PLA";   atftp $1 --put -l samplesrc/hgrtest.pla   -r $2/BLD/SAMPLES/HGRTEST.PLA#040000
+echo "BLD/SAMPLES/PLAYSEQ.PLA";   atftp $1 --put -l samplesrc/playseq.pla   -r $2/BLD/SAMPLES/PLAYSEQ.PLA#040000
+echo "BLD/SAMPLES/RPNCALC.PLA";   atftp $1 --put -l samplesrc/rpncalc.pla   -r $2/BLD/SAMPLES/RPNCALC.PLA#040000
+echo "BLD/SAMPLES/SIEVE.PLA";     atftp $1 --put -l samplesrc/sieve.pla     -r $2/BLD/SAMPLES/SIEVE.PLA#040000
+echo "BLD/SAMPLES/MEMTEST.PLA";   atftp $1 --put -l samplesrc/memtest.pla   -r $2/BLD/SAMPLES/MEMTEST.PLA#040000
+echo "BLD/SAMPLES/FATCAT.PLA";    atftp $1 --put -l samplesrc/fatcat.pla    -r $2/BLD/SAMPLES/FATCAT.PLA#040000
+echo "BLD/SAMPLES/GFXDEMO.PLA";   atftp $1 --put -l samplesrc/gfxdemo.pla   -r $2/BLD/SAMPLES/GFXDEMO.PLA#040000
+echo "BLD/SAMPLES/LZ4CAT.PLA";    atftp $1 --put -l samplesrc/lz4cat.pla    -r $2/BLD/SAMPLES/LZ4CAT.PLA#040000
+echo "BLD/SAMPLES/SFM.PLA";       atftp $1 --put -l samplesrc/sfm.pla       -r $2/BLD/SAMPLES/SFM.PLA#040000
+echo "BLD/SAMPLES/SFMSPRT.PLA";   atftp $1 --put -l samplesrc/sfmsprt.pla   -r $2/BLD/SAMPLES/SFMSPRT.PLA#040000
+echo "BLD/SAMPLES/MON.PLA";       atftp $1 --put -l utilsrc/apple/mon.pla   -r $2/BLD/SAMPLES/MON.PLA#040000
+

src/tftpdemos

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+# Demos
+echo "DEMOS/RPNCALC";             atftp $1 --put -l rel/RPNCALC#FE1000            -r $2/DEMOS/RPNCALC#FE1000
+echo "DEMOS/LZ4CAT";              atftp $1 --put -l rel/LZ4CAT#FE1000             -r $2/DEMOS/LZ4CAT#FE1000
+echo "DEMOS/SIEVE";               atftp $1 --put -l rel/SIEVE#FE1000              -r $2/DEMOS/SIEVE#FE1000
+echo "DEMOS/ROD";                 atftp $1 --put -l rel/apple/ROD#FE1000          -r $2/DEMOS/ROD#FE1000
+echo "DEMOS/INT32TEST";           atftp $1 --put -l rel/INT32TEST#FE1000       -r $2/DEMOS/INT32TEST#FE1000
+
+# Music demo
+echo "DEMOS/MUSIC/PLAYSEQ";       atftp $1 --put -l rel/apple/PLAYSEQ#FE1000      -r $2/DEMOS/MUSIC/PLAYSEQ#FE1000
+                                  atftp $1 --put -l mockingboard/ultima3.seq      -r $2/DEMOS/MUSIC/ULTIMA3.SEQ#060000
+                                  atftp $1 --put -l mockingboard/startrek.seq     -r $2/DEMOS/MUSIC/STARTREK.SEQ#060000
+
+# Rogue demo
+echo "DEMOS/ROGUE/ROGUE";         atftp $1 --put -l rel/ROGUE#FE1000              -r $2/DEMOS/ROGUE/ROGUE#FE1000
+echo "DEMOS/ROGUE/ROGUEMAP";      atftp $1 --put -l rel/ROGUEMAP#FE1000           -r $2/DEMOS/ROGUE/ROGUEMAP#FE1000
+echo "DEMOS/ROGUE/ROGUECOMBAT";   atftp $1 --put -l rel/ROGUECOMBAT#FE1000        -r $2/DEMOS/ROGUE/ROGUECOMBAT#FE1000
+                                  atftp $1 --put -l samplesrc/LEVEL0#040000       -r $2/DEMOS/ROGUE/LEVEL0#040000
+                                  atftp $1 --put -l samplesrc/LEVEL1#040000       -r $2/DEMOS/ROGUE/LEVEL1#040000
+
+# Net demos
+echo "DEMOS/NET/HTTPD";           atftp $1 --put -l rel/HTTPD#FE1000              -r $2/DEMOS/NET/HTTPD#FE1000
+                                  atftp $1 --put -l samplesrc/index.html          -r $2/DEMOS/NET/INDEX.HTML#040000
+
+# Apple 2 demos
+echo "DEMOS/APPLE2/TILETEST";            atftp $1 --put -l rel/apple/TILETEST#FE1000       -r $2/DEMOS/APPLE2/TILETEST#FE1000
+echo "DEMOS/APPLE2/HGRTEST";             atftp $1 --put -l rel/apple/HGRTEST#FE1000       -r $2/DEMOS/APPLE2/HGRTEST#FE1000
+echo "DEMOS/APPLE2/GRTEST";              atftp $1 --put -l rel/apple/GRTEST#FE1000       -r $2/DEMOS/APPLE2/GRTEST#FE1000
+echo "DEMOS/APPLE2/DGRTEST";             atftp $1 --put -l rel/apple/DGRTEST#FE1000      -r $2/DEMOS/APPLE2/DGRTEST#FE1000
+
+# Spiders from Mars
+echo "DEMOS/APPLE2/SPIDERS/SFM";         atftp $1 --put -l rel/apple/SFM#FE1000      -r $2/DEMOS/APPLE2/SPIDERS/SFM#FE1000
+echo "DEMOS/APPLE2/SPIDERS/SFMSPRT";     atftp $1 --put -l rel/apple/SFMSPRT#FE1000      -r $2/DEMOS/APPLE2/SPIDERS/SFMSPRT#FE1000
+
+# Arduino+SD card demos
+echo "DEMOS/APPLE2/SDUTILS/SPIPORT";     atftp $1 --put -l rel/apple/SPIPORT#FE1000      -r $2/DEMOS/APPLE2/SDUTILS/SPIPORT#FE1000
+echo "DEMOS/APPLE2/SDUTILS/SDFAT";       atftp $1 --put -l rel/apple/SDFAT#FE1000        -r $2/DEMOS/APPLE2/SDUTILS/SDFAT#FE1000
+echo "DEMOS/APPLE2/SDUTILS/FATCAT";      atftp $1 --put -l rel/apple/FATCAT#FE1000       -r $2/DEMOS/APPLE2/SDUTILS/FATCAT#FE1000
+echo "DEMOS/APPLE2/SDUTILS/FATGET";      atftp $1 --put -l rel/apple/FATGET#FE1000       -r $2/DEMOS/APPLE2/SDUTILS/FATGET#FE1000
+echo "DEMOS/APPLE2/SDUTILS/FATPUT";      atftp $1 --put -l rel/apple/FATPUT#FE1000       -r $2/DEMOS/APPLE2/SDUTILS/FATPUT#FE1000
+echo "DEMOS/APPLE2/SDUTILS/FATREADDSK";  atftp $1 --put -l rel/apple/FATREADDSK#FE1000   -r $2/DEMOS/APPLE2/SDUTILS/FATREADDSK#FE1000
+echo "DEMOS/APPLE2/SDUTILS/FATWRITEDSK"; atftp $1 --put -l rel/apple/FATWRITEDSK#FE1000  -r $2/DEMOS/APPLE2/SDUTILS/FATWRITEDSK#FE1000
+

src/tftprel

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+./tftpsys $1 $2
+./tftputil $1 $2
+./tftpsane $1 $2
+./tftpbld $1 $2
+./tftpdemos $1 $2

src/tftpsane

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# SANE libraries
+echo "SYS/SANE";        atftp $1 --put -l rel/SANE#FE1000 -r $2/SYS/SANE#FE1000
+echo "SYS/FPSTR";       atftp $1 --put -l rel/FPSTR#FE1000 -r $2/SYS/FPSTR#FE1000
+echo "SYS/FPU";         atftp $1 --put -l rel/FPU#FE1000 -r $2/SYS/FPU#FE1000
+echo "SYS/FP6502.CODE"; atftp $1 --put -l ../sysfiles/FP6502.CODE#060000 -r $2/SYS/FP6502.CODE#060000
+echo "SYS/ELEMS.CODE";  atftp $1 --put -l ../sysfiles/ELEMS.CODE#060000 -r $2/SYS/ELEMS.CODE#060000

src/tftpsys

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Core VM, CMDSYS, JITC files
+echo "PLASMA.SYSTEM"; atftp $1 --put -l rel/apple/PLASMA.SYSTEM#FF2000 -r $2/PLASMA.SYSTEM#FF2000
+echo "PLVM.128";      atftp $1 --put -l rel/apple/PLVM.128#FF2000 -r $2/PLVM.128#FF2000
+echo "PLVM16";        atftp $1 --put -l rel/apple/PLVM16#FF2000 -r $2/PLVM16#FF2000
+echo "CMD";           atftp $1 --put -l rel/apple/CMD#061000 -r $2/CMD#061000
+echo "CMD128";        atftp $1 --put -l rel/apple/CMD128#061000 -r $2/CMD128#061000
+echo "SYS/JIT";       atftp $1 --put -l rel/apple/JIT#FE1000 -r $2/SYS/JIT#FE1000
+echo "SYS/JIT16";     atftp $1 --put -l rel/apple/JIT16#FE1000 -r $2/SYS/JIT16#FE1000
+echo "SYS/JITUNE";    atftp $1 --put -l rel/apple/JITUNE#FE1000 -r $2/SYS/JITUNE#FE1000
+
+# Core libraries
+echo "SYS/MATCHFILES"; atftp $1 --put -l rel/apple/MATCHFILES#FE1000 -r $2/SYS/MATCHFILES#FE1000
+echo "SYS/ARGS";     atftp $1 --put -l rel/ARGS#FE1000 -r $2/SYS/ARGS#FE1000
+echo "SYS/INT32";    atftp $1 --put -l rel/INT32#FE1000 -r $2/SYS/INT32#FE1000
+echo "SYS/DHCP";     atftp $1 --put -l rel/DHCP#FE1000 -r $2/SYS/DHCP#FE1000
+echo "SYS/ETHERIP";  atftp $1 --put -l rel/ETHERIP#FE1000 -r $2/SYS/ETHERIP#FE1000
+echo "SYS/MOUSE";    atftp $1 --put -l rel/apple/MOUSE#FE1000 -r $2/SYS/MOUSE#FE1000
+echo "SYS/FIBER";    atftp $1 --put -l rel/FIBER#FE1000 -r $2/SYS/FIBER#FE1000
+echo "SYS/INET";     atftp $1 --put -l rel/INET#FE1000 -r $2/SYS/INET#FE1000
+echo "SYS/LONGJUMP"; atftp $1 --put -l rel/LONGJMP#FE1000 -r $2/SYS/LONGJMP#FE1000
+echo "SYS/MEMMGR";   atftp $1 --put -l rel/MEMMGR#FE1000 -r $2/SYS/MEMMGR#FE1000
+echo "SYS/LZ4";      atftp $1 --put -l rel/LZ4#FE1000 -r $2/SYS/LZ4#FE1000
+echo "SYS/CONIO";    atftp $1 --put -l rel/apple/CONIO#FE1000 -r $2/SYS/CONIO#FE1000
+echo "SYS/HGRTILE";  atftp $1 --put -l rel/apple/HGRTILE#FE1000 -r $2/SYS/HGRTILE#FE1000
+echo "SYS/HGRFONT";  atftp $1 --put -l rel/apple/HGRFONT#FE1000 -r $2/SYS/HGRFONT#FE1000
+echo "SYS/HGRSPRITE"; atftp $1 --put -l rel/apple/HGRSPRITE#FE1000 -r $2/SYS/HGRSPRITE#FE1000
+echo "SYS/LINES"; atftp $1 --put -l rel/LINES#FE1000 -r $2/SYS/LINES#FE1000
+echo "SYS/HGRLIB";   atftp $1 --put -l rel/apple/HGRLIB#FE1000 -r $2/SYS/HGRLIB#FE1000
+echo "SYS/GRLIB";    atftp $1 --put -l rel/apple/GRLIB#FE1000 -r $2/SYS/GRLIB#FE1000
+echo "SYS/DGRLIB";   atftp $1 --put -l rel/apple/DGRLIB#FE1000 -r $2/SYS/DGRLIB#FE1000
+echo "SYS/FILEIO";   atftp $1 --put -l rel/apple/FILEIO#FE1000 -r $2/SYS/FILEIO#FE1000
+echo "SYS/JOYBUZZ";  atftp $1 --put -l rel/apple/JOYBUZZ#FE1000 -r $2/SYS/JOYBUZZ#FE1000
+echo "SYS/SNDSEQ";   atftp $1 --put -l rel/apple/SNDSEQ#FE1000 -r $2/SYS/SNDSEQ#FE1000
+echo "SYS/PORTIO";   atftp $1 --put -l rel/apple/PORTIO#FE1000 -r $2/SYS/PORTIO#FE1000
+echo "SYS/UTHERNET2";atftp $1 --put -l rel/apple/UTHERNET2#FE1000 -r $2/SYS/UTHERNET2#FE1000
+echo "SYS/UTHERNET"; atftp $1 --put -l rel/apple/UTHERNET#FE1000 -r $2/SYS/UTHERNET#FE1000

src/tftputil

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Core utilities
+echo "SYS/ED";       atftp $1 --put -l rel/ED#FE1000 -r $2/SYS/ED#FE1000
+echo "SYS/TFTPD";    atftp $1 --put -l rel/TFTPD#FE1000 -r $2/SYS/TFTPD#FE1000
+echo "SYS/COPY";     atftp $1 --put -l rel/apple/COPY#FE1000 -r $2/SYS/COPY#FE1000
+echo "SYS/DEL";      atftp $1 --put -l rel/apple/DEL#FE1000 -r $2/SYS/DEL#FE1000
+echo "SYS/REN";      atftp $1 --put -l rel/apple/REN#FE1000 -r $2/SYS/REN#FE1000
+echo "SYS/CAT";      atftp $1 --put -l rel/apple/CAT#FE1000 -r $2/SYS/CAT#FE1000
+echo "SYS/NEWDIR";   atftp $1 --put -l rel/apple/NEWDIR#FE1000 -r $2/SYS/NEWDIR#FE1000
+echo "SYS/TYPE";     atftp $1 --put -l rel/apple/TYPE#FE1000 -r $2/SYS/TYPE#FE1000
+echo "SYS/MON";      atftp $1 --put -l rel/apple/MON#FE1000 -r $2/SYS/MON#FE1000
+echo "SYS/SOS";      atftp $1 --put -l rel/apple/SOS#FE1000 -r $2/SYS/SOS#FE1000
+echo "SYS/ZIPCHIP";  atftp $1 --put -l rel/apple/ZIPCHIP#FE1000 -r $2/SYS/ZIPCHIP#FE1000

src/toolsrc/codegen.c

@@ -89,6 +89,16 @@ int idconst_add(char *name, int len, int value)
         printf("Constant count overflow\n");
         return (0);
     }
+    if (idconst_lookup(name, len) > 0)
+    {
+        parse_error("const/global name conflict\n");
+        return (0);
+    }
+    if (idglobal_lookup(name, len) > 0)
+    {
+        parse_error("global label already defined\n");
+        return (0);
+    }
     name[len] = '\0';
     emit_idconst(name, value);
     name[len] = c;
@@ -382,12 +392,13 @@ void emit_header(void)
 }
 void emit_rld(void)
 {
-    int i;
+    int i, j;
 
     printf(";\n; RE-LOCATEABLE DICTIONARY\n;\n");
     /*
      * First emit the bytecode definition entrypoint information.
      */
+    /*
     for (i = 0; i < globals; i++)
         if (!(idglobal_type[i] & EXTERN_TYPE) && (idglobal_type[i] & DEF_TYPE))
         {
@@ -395,6 +406,14 @@ void emit_rld(void)
             printf("\t%s\t_C%03d\t\t\n", DW, idglobal_tag[i]);
             printf("\t%s\t$00\n", DB);
         }
+    */
+    j = outflags & INIT ? defs - 1 : defs;
+    for (i = 0; i < j; i++)
+    {
+        printf("\t%s\t$02\t\t\t; CODE TABLE FIXUP\n", DB);
+        printf("\t%s\t_C%03d\t\t\n", DW, i);
+        printf("\t%s\t$00\n", DB);
+    }
     /*
      * Now emit the fixup table.
      */
@@ -600,8 +619,10 @@ void emit_codetag(int tag)
 void emit_const(int cval)
 {
     emit_pending_seq();
-    if (cval == 0x0000)
-        printf("\t%s\t$00\t\t\t; ZERO\n", DB);
+    if ((cval & 0xFFFF) == 0xFFFF)
+        printf("\t%s\t$20\t\t\t; MINUS ONE\n", DB);
+    else if ((cval & 0xFFF0) == 0x0000)
+        printf("\t%s\t$%02X\t\t\t; CN\t%d\n", DB, cval*2, cval);
     else if ((cval & 0xFF00) == 0x0000)
         printf("\t%s\t$2A,$%02X\t\t\t; CB\t%d\n", DB, cval, cval);
     else if ((cval & 0xFF00) == 0xFF00)
@@ -614,6 +635,26 @@ void emit_conststr(long conststr)
     printf("\t%s\t$2E\t\t\t; CS\n", DB);
     emit_data(0, STRING_TYPE, conststr, 0);
 }
+void emit_addi(int cval)
+{
+    emit_pending_seq();
+    printf("\t%s\t$38,$%02X\t\t\t; ADDI\t%d\n", DB, cval, cval);
+}
+void emit_subi(int cval)
+{
+    emit_pending_seq();
+    printf("\t%s\t$3A,$%02X\t\t\t; SUBI\t%d\n", DB, cval, cval);
+}
+void emit_andi(int cval)
+{
+    emit_pending_seq();
+    printf("\t%s\t$3C,$%02X\t\t\t; ANDI\t%d\n", DB, cval, cval);
+}
+void emit_ori(int cval)
+{
+    emit_pending_seq();
+    printf("\t%s\t$3E,$%02X\t\t\t; ORI\t%d\n", DB, cval, cval);
+}
 void emit_lb(void)
 {
     printf("\t%s\t$60\t\t\t; LB\n", DB);
@@ -630,6 +671,22 @@ void emit_llw(int index)
 {
     printf("\t%s\t$66,$%02X\t\t\t; LLW\t[%d]\n", DB, index, index);
 }
+void emit_addlb(int index)
+{
+    printf("\t%s\t$B0,$%02X\t\t\t; ADDLB\t[%d]\n", DB, index, index);
+}
+void emit_addlw(int index)
+{
+    printf("\t%s\t$B2,$%02X\t\t\t; ADDLW\t[%d]\n", DB, index, index);
+}
+void emit_idxlb(int index)
+{
+    printf("\t%s\t$B8,$%02X\t\t\t; IDXLB\t[%d]\n", DB, index, index);
+}
+void emit_idxlw(int index)
+{
+    printf("\t%s\t$BA,$%02X\t\t\t; IDXLW\t[%d]\n", DB, index, index);
+}
 void emit_lab(int tag, int offset, int type)
 {
     if (type)
@@ -658,6 +715,62 @@ void emit_law(int tag, int offset, int type)
         printf("\t%s\t$6A,$%02X,$%02X\t\t; LAW\t%d\n", DB, offset&0xFF,(offset>>8)&0xFF, offset);
     }
 }
+void emit_addab(int tag, int offset, int type)
+{
+    if (type)
+    {
+        int fixup = fixup_new(tag, type, FIXUP_WORD);
+        char *taglbl = tag_string(tag, type);
+        printf("\t%s\t$B4\t\t\t; ADDAB\t%s+%d\n", DB, taglbl, offset);
+        printf("_F%03d%c\t%s\t%s+%d\t\t\n", fixup, LBL, DW, type & EXTERN_TYPE ? "0" : taglbl, offset);
+    }
+    else
+    {
+        printf("\t%s\t$B4,$%02X,$%02X\t\t; ADDAB\t%d\n", DB, offset&0xFF,(offset>>8)&0xFF, offset);
+    }
+}
+void emit_addaw(int tag, int offset, int type)
+{
+    if (type)
+    {
+        int fixup = fixup_new(tag, type, FIXUP_WORD);
+        char *taglbl = tag_string(tag, type);
+        printf("\t%s\t$B6\t\t\t; ADDAW\t%s+%d\n", DB, taglbl, offset);
+        printf("_F%03d%c\t%s\t%s+%d\t\t\n", fixup, LBL, DW, type & EXTERN_TYPE ? "0" : taglbl, offset);
+    }
+    else
+    {
+        printf("\t%s\t$B6,$%02X,$%02X\t\t; ADDAW\t%d\n", DB, offset&0xFF,(offset>>8)&0xFF, offset);
+    }
+}
+void emit_idxab(int tag, int offset, int type)
+{
+    if (type)
+    {
+        int fixup = fixup_new(tag, type, FIXUP_WORD);
+        char *taglbl = tag_string(tag, type);
+        printf("\t%s\t$BC\t\t\t; IDXAB\t%s+%d\n", DB, taglbl, offset);
+        printf("_F%03d%c\t%s\t%s+%d\t\t\n", fixup, LBL, DW, type & EXTERN_TYPE ? "0" : taglbl, offset);
+    }
+    else
+    {
+        printf("\t%s\t$BC,$%02X,$%02X\t\t; IDXAB\t%d\n", DB, offset&0xFF,(offset>>8)&0xFF, offset);
+    }
+}
+void emit_idxaw(int tag, int offset, int type)
+{
+    if (type)
+    {
+        int fixup = fixup_new(tag, type, FIXUP_WORD);
+        char *taglbl = tag_string(tag, type);
+        printf("\t%s\t$BE\t\t\t; IDXAW\t%s+%d\n", DB, taglbl, offset);
+        printf("_F%03d%c\t%s\t%s+%d\t\t\n", fixup, LBL, DW, type & EXTERN_TYPE ? "0" : taglbl, offset);
+    }
+    else
+    {
+        printf("\t%s\t$BE,$%02X,$%02X\t\t; IDXAW\t%d\n", DB, offset&0xFF,(offset>>8)&0xFF, offset);
+    }
+}
 void emit_sb(void)
 {
     printf("\t%s\t$70\t\t\t; SB\n", DB);
@@ -747,11 +860,41 @@ void emit_globaladdr(int tag, int offset, int type)
 }
 void emit_indexbyte(void)
 {
-    printf("\t%s\t$02\t\t\t; IDXB\n", DB);
+    printf("\t%s\t$82\t\t\t; IDXB\n", DB);
 }
 void emit_indexword(void)
 {
-    printf("\t%s\t$1E\t\t\t; IDXW\n", DB);
+    printf("\t%s\t$9E\t\t\t; IDXW\n", DB);
+}
+void emit_select(int tag)
+{
+    emit_pending_seq();
+    printf("\t%s\t$52\t\t\t; SEL\n", DB);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_caseblock(int casecnt, int *caseof, int *casetag)
+{
+    int i;
+
+    if (casecnt < 1 || casecnt > 256)
+        parse_error("Switch count under/overflow\n");
+    emit_pending_seq();
+    printf("\t%s\t$%02lX\t\t\t; CASEBLOCK\n", DB, casecnt & 0xFF);
+    for (i = 0; i < casecnt; i++)
+    {
+        printf("\t%s\t$%04lX\n", DW, caseof[i] & 0xFFFF);
+        printf("\t%s\t_B%03d-*\n", DW, casetag[i]);
+    }
+}
+void emit_breq(int tag)
+{
+    printf("\t%s\t$22\t\t\t; BREQ\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_brne(int tag)
+{
+    printf("\t%s\t$24\t\t\t; BRNE\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
 }
 void emit_brfls(int tag)
 {
@@ -769,28 +912,52 @@ void emit_brnch(int tag)
     printf("\t%s\t$50\t\t\t; BRNCH\t_B%03d\n", DB, tag);
     printf("\t%s\t_B%03d-*\n", DW, tag);
 }
-void emit_breq(int tag)
+void emit_brand(int tag)
 {
     emit_pending_seq();
-    printf("\t%s\t$3C\t\t\t; BREQ\t_B%03d\n", DB, tag);
+    printf("\t%s\t$AC\t\t\t; BRAND\t_B%03d\n", DB, tag);
     printf("\t%s\t_B%03d-*\n", DW, tag);
 }
-void emit_brne(int tag)
+void emit_bror(int tag)
 {
     emit_pending_seq();
-    printf("\t%s\t$3E\t\t\t; BRNE\t_B%03d\n", DB, tag);
+    printf("\t%s\t$AE\t\t\t; BROR\t_B%03d\n", DB, tag);
     printf("\t%s\t_B%03d-*\n", DW, tag);
 }
 void emit_brgt(int tag)
 {
     emit_pending_seq();
-    printf("\t%s\t$38\t\t\t; BRGT\t_B%03d\n", DB, tag);
+    printf("\t%s\t$A0\t\t\t; BRGT\t_B%03d\n", DB, tag);
     printf("\t%s\t_B%03d-*\n", DW, tag);
 }
 void emit_brlt(int tag)
 {
     emit_pending_seq();
-    printf("\t%s\t$3A\t\t\t; BRLT\t_B%03d\n", DB, tag);
+    printf("\t%s\t$A2\t\t\t; BRLT\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_incbrle(int tag)
+{
+    emit_pending_seq();
+    printf("\t%s\t$A4\t\t\t; INCBRLE\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_addbrle(int tag)
+{
+    emit_pending_seq();
+    printf("\t%s\t$A6\t\t\t; ADDBRLE\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_decbrge(int tag)
+{
+    emit_pending_seq();
+    printf("\t%s\t$A8\t\t\t; DECBRGE\t_B%03d\n", DB, tag);
+    printf("\t%s\t_B%03d-*\n", DW, tag);
+}
+void emit_subbrge(int tag)
+{
+    emit_pending_seq();
+    printf("\t%s\t$AA\t\t\t; SUBBRGE\t_B%03d\n", DB, tag);
     printf("\t%s\t_B%03d-*\n", DW, tag);
 }
 void emit_call(int tag, int type)
@@ -839,11 +1006,17 @@ void emit_start(void)
 void emit_drop(void)
 {
     emit_pending_seq();
-    printf("\t%s\t$30\t\t\t; DROP\n", DB);
+    printf("\t%s\t$30\t\t\t; DROP \n", DB);
+}
+void emit_drop2(void)
+{
+    emit_pending_seq();
+    printf("\t%s\t$32\t\t\t; DROP2\n", DB);
 }
 void emit_dup(void)
 {
-    printf("\t%s\t$32\t\t\t; DUP\n", DB);
+    emit_pending_seq();
+    printf("\t%s\t$34\t\t\t; DUP\n", DB);
 }
 int emit_unaryop(t_token op)
 {
@@ -851,19 +1024,19 @@ int emit_unaryop(t_token op)
     switch (op)
     {
         case NEG_TOKEN:
-            printf("\t%s\t$10\t\t\t; NEG\n", DB);
+            printf("\t%s\t$90\t\t\t; NEG\n", DB);
             break;
         case COMP_TOKEN:
-            printf("\t%s\t$12\t\t\t; COMP\n", DB);
+            printf("\t%s\t$92\t\t\t; COMP\n", DB);
             break;
         case LOGIC_NOT_TOKEN:
-            printf("\t%s\t$20\t\t\t; NOT\n", DB);
+            printf("\t%s\t$80\t\t\t; NOT\n", DB);
             break;
         case INC_TOKEN:
-            printf("\t%s\t$0C\t\t\t; INCR\n", DB);
+            printf("\t%s\t$8C\t\t\t; INCR\n", DB);
             break;
         case DEC_TOKEN:
-            printf("\t%s\t$0E\t\t\t; DECR\n", DB);
+            printf("\t%s\t$8E\t\t\t; DECR\n", DB);
             break;
         case BPTR_TOKEN:
             emit_lb();
@@ -883,34 +1056,34 @@ int emit_op(t_token op)
     switch (op)
     {
         case MUL_TOKEN:
-            printf("\t%s\t$06\t\t\t; MUL\n", DB);
+            printf("\t%s\t$86\t\t\t; MUL\n", DB);
             break;
         case DIV_TOKEN:
-            printf("\t%s\t$08\t\t\t; DIV\n", DB);
+            printf("\t%s\t$88\t\t\t; DIV\n", DB);
             break;
         case MOD_TOKEN:
-            printf("\t%s\t$0A\t\t\t; MOD\n", DB);
+            printf("\t%s\t$8A\t\t\t; MOD\n", DB);
             break;
         case ADD_TOKEN:
-            printf("\t%s\t$02\t\t\t; ADD\n", DB);
+            printf("\t%s\t$82\t\t\t; ADD \n", DB);
             break;
         case SUB_TOKEN:
-            printf("\t%s\t$04\t\t\t; SUB\n", DB);
+            printf("\t%s\t$84\t\t\t; SUB \n", DB);
             break;
         case SHL_TOKEN:
-            printf("\t%s\t$1A\t\t\t; SHL\n", DB);
+            printf("\t%s\t$9A\t\t\t; SHL\n", DB);
             break;
         case SHR_TOKEN:
-            printf("\t%s\t$1C\t\t\t; SHR\n", DB);
+            printf("\t%s\t$9C\t\t\t; SHR\n", DB);
             break;
         case AND_TOKEN:
-            printf("\t%s\t$14\t\t\t; AND\n", DB);
+            printf("\t%s\t$94\t\t\t; AND \n", DB);
             break;
         case OR_TOKEN:
-            printf("\t%s\t$16\t\t\t; IOR\n", DB);
+            printf("\t%s\t$96\t\t\t; OR \n", DB);
             break;
         case EOR_TOKEN:
-            printf("\t%s\t$18\t\t\t; XOR\n", DB);
+            printf("\t%s\t$98\t\t\t; XOR\n", DB);
             break;
         case EQ_TOKEN:
             printf("\t%s\t$40\t\t\t; ISEQ\n", DB);
@@ -930,12 +1103,6 @@ int emit_op(t_token op)
         case LE_TOKEN:
             printf("\t%s\t$4A\t\t\t; ISLE\n", DB);
             break;
-        case LOGIC_OR_TOKEN:
-            printf("\t%s\t$22\t\t\t; LOR\n", DB);
-            break;
-        case LOGIC_AND_TOKEN:
-            printf("\t%s\t$24\t\t\t; LAND\n", DB);
-            break;
         case COMMA_TOKEN:
             break;
         default:
@@ -1067,7 +1234,11 @@ int crunch_seq(t_opseq **seq, int pass)
                     {
                         op->code = DUP_CODE;
                         opnext->code = BINARY_CODE(ADD_TOKEN);
-                        crunched = 1;
+                        break;
+                    }
+                    if (opnext->code == BINARY_CODE(MUL_TOKEN) || opnext->code == BINARY_CODE(DIV_TOKEN))
+                    {
+                        freeops = -2;
                         break;
                     }
                 }
@@ -1127,6 +1298,22 @@ int crunch_seq(t_opseq **seq, int pass)
                             freeops  = 1;
                         }
                         break;
+                    case BRGT_CODE:
+                        if (opprev && (opprev->code == CONST_CODE) && (op->val <= opprev->val))
+                            freeops = 1;
+                        break;
+                    case BRLT_CODE:
+                        if (opprev && (opprev->code == CONST_CODE) && (op->val >= opprev->val))
+                            freeops = 1;
+                        break;
+                    case BROR_CODE:
+                        if (!op->val)
+                            freeops = -2; // Remove zero constant
+                        break;
+                    case BRAND_CODE:
+                        if (op->val)
+                            freeops = -2; // Remove non-zero constant
+                        break;
                     case NE_CODE:
                         if (!op->val)
                             freeops = -2; // Remove ZERO:ISNE
@@ -1207,32 +1394,96 @@ int crunch_seq(t_opseq **seq, int pass)
                                     op->val = op->val <= opnext->val ? 1 : 0;
                                     freeops  = 2;
                                     break;
-                                case BINARY_CODE(LOGIC_OR_TOKEN):
-                                    op->val = op->val || opnext->val ? 1 : 0;
-                                    freeops  = 2;
-                                    break;
-                                case BINARY_CODE(LOGIC_AND_TOKEN):
-                                    op->val = op->val && opnext->val ? 1 : 0;
-                                    freeops  = 2;
-                                    break;
                             }
                         // End of collapse constant operation
                         if ((pass > 0) && (freeops == 0) && (op->val != 0))
                             crunched = try_dupify(op);
                         break; // CONST_CODE
-                    case BINARY_CODE(MUL_TOKEN):
-                        for (shiftcnt = 0; shiftcnt < 16; shiftcnt++)
+                    case BINARY_CODE(ADD_TOKEN):
+                        if (op->val == 0)
                         {
-                            if (op->val == (1 << shiftcnt))
+                            freeops = -2;
+                        }
+                        else if (op->val > 0 && op->val <= 255)
+                        {
+                            op->code = ADDI_CODE;
+                            freeops  = 1;
+                        }
+                        else if (op->val >= -255 && op->val < 0)
+                        {
+                            op->code = SUBI_CODE;
+                            op->val  = -op->val;
+                            freeops  = 1;
+                        }
+                        break;
+                    case BINARY_CODE(SUB_TOKEN):
+                        if (op->val == 0)
+                        {
+                            freeops = -2;
+                        }
+                        else if (op->val > 0 && op->val <= 255)
+                        {
+                            op->code = SUBI_CODE;
+                            freeops  = 1;
+                        }
+                        else if (op->val >= -255 && op->val < 0)
+                        {
+                            op->code = ADDI_CODE;
+                            op->val  = -op->val;
+                            freeops  = 1;
+                        }
+                        break;
+                    case BINARY_CODE(AND_TOKEN):
+                        if (op->val >= 0 && op->val <= 255)
+                        {
+                            op->code = ANDI_CODE;
+                            freeops  = 1;
+                        }
+                        break;
+                    case BINARY_CODE(OR_TOKEN):
+                        if (op->val == 0)
+                        {
+                            freeops = -2;
+                        }
+                        else if (op->val > 0 && op->val <= 255)
+                        {
+                            op->code = ORI_CODE;
+                            freeops  = 1;
+                        }
+                        break;
+                    case BINARY_CODE(MUL_TOKEN):
+                        if (op->val == 0)
+                        {
+                            op->code = DROP_CODE;
+                            opnext->code = CONST_CODE;
+                            opnext->val = 0;
+                        }
+                        else if (op->val == 2)
+                        {
+                            op->code = DUP_CODE;
+                            opnext->code = BINARY_CODE(ADD_TOKEN);
+                        }
+                        else
+                        {
+                            //
+                            // Constants 0, 1 and 2 handled above
+                            //
+                            for (shiftcnt = 2; shiftcnt < 16; shiftcnt++)
                             {
-                                op->val = shiftcnt;
-                                opnext->code = BINARY_CODE(SHL_TOKEN);
-                                break;
+                                if (op->val == (1 << shiftcnt))
+                                {
+                                    op->val = shiftcnt;
+                                    opnext->code = BINARY_CODE(SHL_TOKEN);
+                                    break;
+                                }
                             }
                         }
                         break;
                     case BINARY_CODE(DIV_TOKEN):
-                       for (shiftcnt = 0; shiftcnt < 16; shiftcnt++)
+                        //
+                        // Constant 1 handled above
+                        //
+                        for (shiftcnt = 1; shiftcnt < 16; shiftcnt++)
                         {
                             if (op->val == (1 << shiftcnt))
                             {
@@ -1325,7 +1576,17 @@ int crunch_seq(t_opseq **seq, int pass)
                     crunched = try_dupify(op);
                 break; // GADDR_CODE
             case LLB_CODE:
-                if (pass > 0)
+                if ((opnext->code == ADD_CODE) || (opnext->code == INDEXB_CODE))
+                {
+                    op->code = ADDLB_CODE;
+                    freeops  = 1;
+                }
+                else if (opnext->code == INDEXW_CODE)
+                {
+                    op->code = IDXLB_CODE;
+                    freeops  = 1;
+                }
+                else if (pass > 0)
                     crunched = try_dupify(op);
                 break; // LLB_CODE
             case LLW_CODE:
@@ -1343,11 +1604,31 @@ int crunch_seq(t_opseq **seq, int pass)
                         }
                     }
                 }
-                if ((pass > 0) && (freeops == 0))
+                else if ((opnext->code == ADD_CODE) || (opnext->code == INDEXB_CODE))
+                {
+                    op->code = ADDLW_CODE;
+                    freeops  = 1;
+                }
+                else if (opnext->code == INDEXW_CODE)
+                {
+                    op->code = IDXLW_CODE;
+                    freeops  = 1;
+                }
+                else if (pass > 0)
                     crunched = try_dupify(op);
                 break; // LLW_CODE
             case LAB_CODE:
-                if ((pass > 0) && (op->type || !is_hardware_address(op->offsz)))
+                if ((opnext->code == ADD_CODE) || (opnext->code == INDEXB_CODE))
+                {
+                    op->code = ADDAB_CODE;
+                    freeops  = 1;
+                }
+                else if (opnext->code == INDEXW_CODE)
+                {
+                    op->code = IDXAB_CODE;
+                    freeops  = 1;
+                }
+                else if ((pass > 0) && (op->type || !is_hardware_address(op->offsz)))
                     crunched = try_dupify(op);
                 break; // LAB_CODE
             case LAW_CODE:
@@ -1365,8 +1646,17 @@ int crunch_seq(t_opseq **seq, int pass)
                         }
                     }
                 }
-                if ((pass > 0) && (freeops == 0) &&
-                    (op->type || !is_hardware_address(op->offsz)))
+                else if ((opnext->code == ADD_CODE) || (opnext->code == INDEXB_CODE))
+                {
+                    op->code = ADDAW_CODE;
+                    freeops  = 1;
+                }
+                else if (opnext->code == INDEXW_CODE)
+                {
+                    op->code = IDXAW_CODE;
+                    freeops  = 1;
+                }
+                else if ((pass > 0) && (op->type || !is_hardware_address(op->offsz)))
                     crunched = try_dupify(op);
                 break; // LAW_CODE
             case LOGIC_NOT_CODE:
@@ -1384,6 +1674,36 @@ int crunch_seq(t_opseq **seq, int pass)
                         break;
                 }
                 break; // LOGIC_NOT_CODE
+            case EQ_CODE:
+                switch (opnext->code)
+                {
+                    case BRFALSE_CODE:
+                        op->code = BRNE_CODE;
+                        op->tag  = opnext->tag;
+                        freeops  = 1;
+                        break;
+                    case BRTRUE_CODE:
+                        op->code = BREQ_CODE;
+                        op->tag  = opnext->tag;
+                        freeops  = 1;
+                        break;
+                }
+                break; // EQ_CODE
+            case NE_CODE:
+                switch (opnext->code)
+                {
+                    case BRFALSE_CODE:
+                        op->code = BREQ_CODE;
+                        op->tag  = opnext->tag;
+                        freeops  = 1;
+                        break;
+                    case BRTRUE_CODE:
+                        op->code = BRNE_CODE;
+                        op->tag  = opnext->tag;
+                        freeops  = 1;
+                        break;
+                }
+                break; // NE_CODE
             case SLB_CODE:
                 if ((opnext->code == LLB_CODE) && (op->offsz == opnext->offsz))
                 {
@@ -1577,8 +1897,6 @@ int emit_pending_seq()
             case LT_CODE:
             case GT_CODE:
             case LE_CODE:
-            case LOGIC_OR_CODE:
-            case LOGIC_AND_CODE:
                 emit_op(op->code);
                 break;
             case CONST_CODE:
@@ -1587,6 +1905,18 @@ int emit_pending_seq()
             case STR_CODE:
                 emit_conststr(op->val);
                 break;
+            case ADDI_CODE:
+                emit_addi(op->val);
+                break;
+            case SUBI_CODE:
+                emit_subi(op->val);
+                break;
+            case ANDI_CODE:
+                emit_andi(op->val);
+                break;
+            case ORI_CODE:
+                emit_ori(op->val);
+                break;
             case LB_CODE:
                 emit_lb();
                 break;
@@ -1599,12 +1929,36 @@ int emit_pending_seq()
             case LLW_CODE:
                 emit_llw(op->offsz);
                 break;
+            case ADDLB_CODE:
+                emit_addlb(op->offsz);
+                break;
+            case ADDLW_CODE:
+                emit_addlw(op->offsz);
+                break;
+            case IDXLB_CODE:
+                emit_idxlb(op->offsz);
+                break;
+            case IDXLW_CODE:
+                emit_idxlw(op->offsz);
+                break;
             case LAB_CODE:
                 emit_lab(op->tag, op->offsz, op->type);
                 break;
             case LAW_CODE:
                 emit_law(op->tag, op->offsz, op->type);
                 break;
+            case ADDAB_CODE:
+                emit_addab(op->tag, op->offsz, op->type);
+                break;
+            case ADDAW_CODE:
+                emit_addaw(op->tag, op->offsz, op->type);
+                break;
+            case IDXAB_CODE:
+                emit_idxab(op->tag, op->offsz, op->type);
+                break;
+            case IDXAW_CODE:
+                emit_idxaw(op->tag, op->offsz, op->type);
+                break;
             case SB_CODE:
                 emit_sb();
                 break;
@@ -1662,12 +2016,30 @@ int emit_pending_seq()
             case BRNCH_CODE:
                 emit_brnch(op->tag);
                 break;
+            case BRAND_CODE:
+                emit_brand(op->tag);
+                break;
+            case BROR_CODE:
+                emit_bror(op->tag);
+                break;
+            case BREQ_CODE:
+                emit_breq(op->tag);
+                break;
+            case BRNE_CODE:
+                emit_brne(op->tag);
+                break;
             case BRFALSE_CODE:
                 emit_brfls(op->tag);
                 break;
             case BRTRUE_CODE:
                 emit_brtru(op->tag);
                 break;
+            case BRGT_CODE:
+                emit_brgt(op->tag);
+                break;
+            case BRLT_CODE:
+                emit_brlt(op->tag);
+                break;
             case CODETAG_CODE:
                 printf("_B%03d%c\n", op->tag, LBL);
                 break;

src/toolsrc/codegen.h

@@ -31,8 +31,6 @@ typedef struct _opseq {
 #define LT_CODE     (0x0200|LT_TOKEN)
 #define GT_CODE     (0x0200|GT_TOKEN)
 #define LE_CODE     (0x0200|LE_TOKEN)
-#define LOGIC_OR_CODE (0x0200|LOGIC_OR_TOKEN)
-#define LOGIC_AND_CODE (0x0200|LOGIC_AND_TOKEN)
 #define CONST_CODE  0x0300
 #define STR_CODE    0x0301
 #define LB_CODE     0x0302
@@ -59,11 +57,29 @@ typedef struct _opseq {
 #define INDEXW_CODE 0x0317
 #define DROP_CODE   0x0318
 #define DUP_CODE    0x0319
-#define BRNCH_CODE  0x031C
-#define BRFALSE_CODE 0x031D
-#define BRTRUE_CODE 0x031E
-#define CODETAG_CODE 0x031F
-#define NOP_CODE    0x0320
+#define ADDI_CODE   0x031A
+#define SUBI_CODE   0x031B
+#define ANDI_CODE   0x031C
+#define ORI_CODE    0x31D
+#define BRNCH_CODE  0x0320
+#define BRFALSE_CODE 0x0321
+#define BRTRUE_CODE 0x0322
+#define BREQ_CODE   0x0323
+#define BRNE_CODE   0x0324
+#define BRAND_CODE  0x0325
+#define BROR_CODE   0x0326
+#define BRLT_CODE   0x0327
+#define BRGT_CODE   0x0328
+#define CODETAG_CODE 0x0329
+#define NOP_CODE    0x032A
+#define ADDLB_CODE  0x0330
+#define ADDLW_CODE  0x0331
+#define ADDAB_CODE  0x0332
+#define ADDAW_CODE  0x0333
+#define IDXLB_CODE  0x0334
+#define IDXLW_CODE  0x0335
+#define IDXAB_CODE  0x0336
+#define IDXAW_CODE  0x0337
 
 #define gen_uop(seq,op)     gen_seq(seq,UNARY_CODE(op),0,0,0,0)
 #define gen_op(seq,op)      gen_seq(seq,BINARY_CODE(op),0,0,0,0)
@@ -79,6 +95,10 @@ typedef struct _opseq {
 #define gen_sw(seq)         gen_seq(seq,SW_CODE,0,0,0,0)
 #define gen_icall(seq)      gen_seq(seq,ICAL_CODE,0,0,0,0)
 #define gen_drop(seq)       gen_seq(seq,DROP_CODE,0,0,0,0)
+#define gen_brand(seq,tag)  gen_seq(seq,BRAND_CODE,0,tag,0,0)
+#define gen_bror(seq,tag)   gen_seq(seq,BROR_CODE,0,tag,0,0)
+#define gen_brgt(seq,tag)   gen_seq(seq,BRGT_CODE,0,tag,0,0)
+#define gen_brlt(seq,tag)   gen_seq(seq,BRLT_CODE,0,tag,0,0)
 #define gen_brfls(seq,tag)  gen_seq(seq,BRFALSE_CODE,0,tag,0,0)
 #define gen_brtru(seq,tag)  gen_seq(seq,BRTRUE_CODE,0,tag,0,0)
 #define gen_brnch(seq,tag)  gen_seq(seq,BRNCH_CODE,0,tag,0,0)
@@ -102,6 +122,10 @@ int emit_data(int vartype, int consttype, long constval, int constsize);
 void emit_codetag(int tag);
 void emit_const(int cval);
 void emit_conststr(long conststr);
+void emit_addi(int cval);
+void emit_subi(int cval);
+void emit_andi(int cval);
+void emit_ori(int cval);
 void emit_lb(void);
 void emit_lw(void);
 void emit_llb(int index);
@@ -126,14 +150,23 @@ void emit_indexbyte(void);
 void emit_indexword(void);
 int emit_unaryop(t_token op);
 int emit_op(t_token op);
+void emit_select(int tag);
+void emit_caseblock(int casecnt, int *caseof, int *casetag);
+void emit_brand(int tag);
+void emit_bror(int tag);
 void emit_brtru(int tag);
 void emit_brfls(int tag);
-void emit_brgt(int tag);
-void emit_brlt(int tag);
 void emit_brne(int tag);
 void emit_brnch(int tag);
+void emit_brgt(int tag);
+void emit_brlt(int tag);
+void emit_addbrle(int tag);
+void emit_incbrle(int tag);
+void emit_subbrge(int tag);
+void emit_decbrge(int tag);
 void emit_empty(void);
 void emit_drop(void);
+void emit_drop2(void);
 void emit_dup(void);
 void emit_leave(void);
 void emit_ret(void);

src/toolsrc/codegen.pla

@@ -132,8 +132,10 @@ def emit_codeseg#0
 end
 def emit_const(cval)#0
     emit_pending_seq
-    if cval == $0000            // ZERO
-        emit_byte($00)
+    if cval == $FFFF            // MINUS ONE
+        emit_byte($20)
+    elsif cval & $FFF0 == $0000 // Constant NYBBLE
+        emit_byte(cval*2)
     elsif cval & $FF00 == $0000 // Constant BYTE
         emit_byte($2A)
         emit_byte(cval)
@@ -151,6 +153,26 @@ def emit_code(bval)#0
     codeptr++
     if codeptr - codebuff > codebufsz; exit_err(ERR_OVER|ERR_CODE|ERR_TABLE); fin
 end
+def emit_slb(offset)#0
+    emit_pending_seq
+    emit_byte($74)
+    emit_byte(offset)
+end
+def emit_slw(offset)#0
+    emit_pending_seq
+    emit_byte($76)
+    emit_byte(offset)
+end
+def emit_sab(tag, offset)#0
+    emit_pending_seq
+    emit_byte($78)
+    emit_addr(tag, offset)
+end
+def emit_saw(tag, offset)#0
+    emit_pending_seq
+    emit_byte($7A)
+    emit_addr(tag, offset)
+end
 def emit_dlb(offset)#0
     emit_pending_seq
     emit_byte($6C)
@@ -171,26 +193,67 @@ def emit_daw(tag, offset)#0
     emit_byte($7E)
     emit_addr(tag, offset)
 end
-def emit_brgt(tag)#0
+def emit_select(tag)#0
     emit_pending_seq
-    emit_byte($38)
+    emit_byte($52)
     emit_reladdr(tag)
 end
-def emit_brlt(tag)#0
+def emit_caseblock(cnt, oflist, taglist)#0
+    byte i
+
+    if not cnt or cnt > 256; exit_err(ERR_OVER|ERR_STATE); fin
     emit_pending_seq
-    emit_byte($3A)
-    emit_reladdr(tag)
-end
-def emit_brne(tag)#0
-    emit_pending_seq
-    emit_byte($3E)
-    emit_reladdr(tag)
+    emit_byte(cnt)
+    for i = 0 to cnt-1
+        emit_word(oflist=>[i])
+        emit_reladdr(taglist=>[i])
+    next
 end
 def emit_branch(tag)#0
     emit_pending_seq
     emit_byte($50)
     emit_reladdr(tag)
 end
+def emit_brgt(tag)#0
+    emit_pending_seq
+    emit_byte($A0)
+    emit_reladdr(tag)
+end
+def emit_brlt(tag)#0
+    emit_pending_seq
+    emit_byte($A2)
+    emit_reladdr(tag)
+end
+def emit_incbrle(tag)#0
+    emit_pending_seq
+    emit_byte($A4)
+    emit_reladdr(tag)
+end
+def emit_addbrle(tag)#0
+    emit_pending_seq
+    emit_byte($A6)
+    emit_reladdr(tag)
+end
+def emit_decbrge(tag)#0
+    emit_pending_seq
+    emit_byte($A8)
+    emit_reladdr(tag)
+end
+def emit_subbrge(tag)#0
+    emit_pending_seq
+    emit_byte($AA)
+    emit_reladdr(tag)
+end
+def emit_brand(tag)#0
+    emit_pending_seq
+    emit_byte($AC)
+    emit_reladdr(tag)
+end
+def emit_bror(tag)#0
+    emit_pending_seq
+    emit_byte($AE)
+    emit_reladdr(tag)
+end
 def emit_leave#0
     emit_pending_seq
     if framesize
@@ -266,8 +329,11 @@ def emit_pending_seq#0
             //
             is CONST_GROUP
                 if op->opcode == CONST_CODE
-                    if op=>opval == $0000            // ZERO
-                        ^codeptr = $00
+                    if op=>opval == $FFFF            // MINUS 1
+                        ^codeptr = $20
+                        codeptr++
+                    elsif op=>opval & $FFF0 == $0000 // Constant NYBBLE
+                        ^codeptr = op->opval*2
                         codeptr++
                     elsif op=>opval & $FF00 == $0000 // Constant BYTE
                         *codeptr = $2A | (op->opval << 8)
@@ -280,6 +346,9 @@ def emit_pending_seq#0
                         codeptr=>1 = op=>opval
                         codeptr    = codeptr + 3
                     fin
+                else
+                    *codeptr = op->opcode | (op->opval << 8) // IMMEDIATE BYTE OP
+                    codeptr  = codeptr + 2
                 fin
                 break
             //
@@ -382,9 +451,10 @@ def idmatch(nameptr, len, idptr, idcnt)
 
     while idcnt
         if len == idptr->idname
-            for i = 1 to len
-                if nameptr->[i - 1] <> idptr->idname.[i]; break; fin
-            next
+            i = 1; while i <= len and nameptr->[i - 1] == idptr->idname.[i]; i++; loop
+            //for i = 1 to len
+            //    if nameptr->[i - 1] <> idptr->idname.[i]; break; fin
+            //next
             if i > len; return idptr; fin
         fin
         idptr = idptr + idptr->idname + t_id
@@ -479,11 +549,13 @@ def init_idglobal#0
     word op
     word i
 
+    dfd_num     = DFDNUM
     tag_num     = TAGNUM
     fixup_num   = FIXUPNUM
     globalbufsz = IDGLOBALSZ
     localbufsz  = IDLOCALSZ
-    if isult(heapavail, $8000)
+    if isult(heapavail, $6000)
+        dfd_num     = DFDNUM/2
         tag_num     = TAGNUM/2
         fixup_num   = FIXUPNUM/2
         globalbufsz = IDGLOBALSZ
@@ -502,6 +574,7 @@ def init_idglobal#0
     //
     // Allocate remaining buffers
     //
+    dfd_tag      = heapalloc(dfd_num*2)
     tag_addr     = heapalloc(tag_num*2)
     tag_type     = heapalloc(tag_num)
     fixup_tag    = heapalloc(fixup_num*2)
@@ -512,7 +585,6 @@ def init_idglobal#0
     codebuff     = heapalloc(codebufsz)
     codeptr      = codebuff
     lastglobal   = idglobal_tbl
-    puts("Data+Code buffer size = "); puti(codebufsz); putln
 end
 def new_idlocal(nameptr, len, type, size)#0
     if idmatch(nameptr, len, @idlocal_tbl, locals); exit_err(ERR_DUP|ERR_ID); fin
@@ -534,13 +606,15 @@ def save_idlocal#0
     savelocals = locals
     savesize   = framesize
     savelast   = lastlocal
-    memcpy(heapmark, idlocal_tbl, lastlocal - idlocal_tbl)
+    savetbl    = heapalloc(lastlocal - idlocal_tbl)
+    memcpy(savetbl, idlocal_tbl, lastlocal - idlocal_tbl)
 end
 def restore_idlocal#0
     locals    = savelocals
     framesize = savesize
     lastlocal = savelast
-    memcpy(idlocal_tbl, heapmark, lastlocal - idlocal_tbl)
+    memcpy(idlocal_tbl, savetbl, lastlocal - idlocal_tbl)
+    heaprelease(savetbl)
 end
 //
 // Module dependency list
@@ -554,6 +628,14 @@ def new_moddep(nameptr, len)#0
     if moddep_cnt > MODDEPNUM; parse_warn("Module dependency overflow"); fin
 end
 //
+// DFD list
+//
+def new_dfd(tag)#0
+    if dfd_cnt >= dfd_num; exit_err(ERR_OVER|ERR_CODE|ERR_TABLE); fin
+    dfd_tag=>[dfd_cnt] = tag
+    dfd_cnt++
+end
+//
 // Generate/add to a sequence of code
 //
 def gen_op(seq, code)
@@ -690,15 +772,15 @@ def gen_uop(seq, tkn)
     fin
     when tkn
         is NEG_TKN
-            code = $10; break
+            code = $90; break
         is COMP_TKN
-            code = $12; break
+            code = $92; break
         is LOGIC_NOT_TKN
-            code = $20; break
+            code = $80; break
         is INC_TKN
-            code = $0C; break
+            code = $8C; break
         is DEC_TKN
-            code = $0E; break
+            code = $8E; break
         is BPTR_TKN
             code = $60; break
         is WPTR_TKN
@@ -725,25 +807,25 @@ def gen_bop(seq, tkn)
     fin
     when tkn
         is MUL_TKN
-            code = $06; break
+            code = $86; break
         is DIV_TKN
-            code = $08; break
+            code = $88; break
         is MOD_TKN
-            code = $0A; break
+            code = $8A; break
         is ADD_TKN
-            code = $02; break
+            code = $82; break
         is SUB_TKN
-            code = $04; break
+            code = $84; break
         is SHL_TKN
-            code = $1A; break
+            code = $9A; break
         is SHR_TKN
-            code = $1C; break
+            code = $9C; break
         is AND_TKN
-            code = $14; break
+            code = $94; break
         is OR_TKN
-            code = $16; break
+            code = $96; break
         is EOR_TKN
-            code = $18; break
+            code = $98; break
         is EQ_TKN
             code = $40; break
         is NE_TKN
@@ -756,10 +838,6 @@ def gen_bop(seq, tkn)
             code = $44; break
         is LE_TKN
             code = $4A; break
-        is LOGIC_OR_TKN
-            code = $22; break
-        is LOGIC_AND_TKN
-            code = $24; break
         otherwise
             exit_err(ERR_INVAL|ERR_SYNTAX)
     wend
@@ -824,30 +902,27 @@ end
 // Write DeFinition Directory
 //
 def writeDFD(refnum, modfix)#0
-    word dfd, idptr, idcnt
+    word dfd, idptr, cnt
     byte defdir[128]
 
-    dfd, idptr, idcnt = @defdir, idglobal_tbl, globals
-    while idcnt
-        if idptr=>idtype & (FUNC_TYPE|EXTERN_TYPE) == FUNC_TYPE
-            dfd->0 = $02
-            dfd=>1 = tag_addr=>[idptr=>idval] + modfix
-            dfd->3 = 0
-            dfd    = dfd + 4
-        fin
-        idptr = idptr + idptr->idname + t_id
-        idcnt--
-    loop
+    dfd = @defdir
+    for cnt = 0 to dfd_cnt-1
+        dfd->0 = $02
+        dfd=>1 = tag_addr=>[dfd_tag=>[cnt]] + modfix
+        dfd->3 = 0
+        dfd    = dfd + 4
+    next
     fileio:write(refnum, @defdir, dfd - @defdir)
 end
 //
 // Build External Symbol Directory on heap
 //
 def buildESD(modfix)#2
-    word modofst, esd, idptr, idcnt, len
+    word modofst, esdtbl, esd, idptr, idcnt, len
     byte symnum
 
-    symnum, esd, idptr, idcnt = 0, heapmark, idglobal_tbl, globals
+    symnum, esdtbl, idptr, idcnt = 0, heapalloc(heapavail - 256), idglobal_tbl, globals
+    esd = esdtbl
     while idcnt
         if idptr=>idtype & EXPORT_TYPE
             esd           = esd + stodci(@idptr->idname, esd)
@@ -866,26 +941,27 @@ def buildESD(modfix)#2
         idcnt--
     loop
     ^esd = 0
-    len  = esd - heapmark + 1
-    esd  = heapalloc(len)
-    return esd, len
+    len  = esd - esdtbl + 1
+    heaprelease(esdtbl + len)
+    return esdtbl, len
 end
 //
 // Write ReLocation Directory
 //
 def writeRLD(refnum, modofst)#0
-    word rld, rldlen, fixups, updtptr, idptr, idcnt, tag
+    word rldtbl, rld, rldlen, fixups, updtptr, idptr, idcnt, tag
     byte type
 
-    rld    = heapmark
+    rldtbl = heapalloc(heapavail - 256)
+    rld    = rldtbl
     rldlen = 0
     for fixups = fixup_cnt-1 downto 0
         tag  = fixup_tag=>[fixups]
         type = tag_type->[tag]
         if not (type & RELATIVE_FIXUP)
             if rldlen == 64 // Write out blocks of entries
-                fileio:write(refnum, heapmark, rld - heapmark)
-                rld    = heapmark
+                fileio:write(refnum, rldtbl, rld - rldtbl)
+                rld    = rldtbl
                 rldlen = 0
             fin
             if type & EXTERN_FIXUP
@@ -907,7 +983,8 @@ def writeRLD(refnum, modofst)#0
         fin
     next
     ^rld = 0
-    fileio:write(refnum, heapmark, rld - heapmark + 1)
+    fileio:write(refnum, rldtbl, rld - rldtbl + 1)
+    heaprelease(rldtbl)
 end
 //
 // Write Extended REL file

src/toolsrc/codeopt.pla

@@ -83,7 +83,10 @@ def crunch_seq(seq, pass)
                         op->opcode     = DUP_CODE
                         op->opgroup    = STACK_GROUP
                         nextop->opcode = ADD_CODE
-                        crunched       = 1
+                        break
+                    fin
+                    if nextop->opcode == MUL_CODE or nextop->opcode == DIV_CODE
+                        freeops = -2
                         break
                     fin
                 fin
@@ -120,6 +123,26 @@ def crunch_seq(seq, pass)
                             freeops     = 1
                         fin
                         break
+                    is BRGT_CODE
+                        if opprev and (opprev->opcode == CONST_CODE) and (op=>opval <= opprev=>opval)
+                            freeops = 1
+                        fin
+                        break
+                    is BRLT_CODE
+                        if opprev and (opprev->opcode == CONST_CODE) and (op=>opval >= opprev=>opval)
+                            freeops = 1
+                        fin
+                        break
+                    is BROR_CODE
+                        if not op=>opval
+                            freeops = -2 // Remove zero constant
+                        fin
+                        break
+                    is BRAND_CODE
+                        if op=>opval
+                            freeops = -2 // Remove non-zero constant
+                        fin
+                        break
                     is NE_CODE
                         if not op=>opval
                             freeops = -2 // Remove ZERO:ISNE
@@ -129,7 +152,7 @@ def crunch_seq(seq, pass)
                         if not op=>opval
                             op->opcode  = LOGIC_NOT_CODE // Replace ZERO:ISEQ
                             op->opgroup = STACK_GROUP
-                      freeops    = 1
+                            freeops     = 1
                         fin
                         break
                     is CONST_CODE // Collapse constant operation
@@ -200,31 +223,73 @@ def crunch_seq(seq, pass)
                                     op=>opval = op=>opval <= nextop=>opval
                                     freeops   = 2
                                     break
-                                is LOGIC_OR_CODE
-                                    op=>opval = op=>opval or nextop=>opval
-                                    freeops   = 2
-                                    break
-                                is LOGIC_AND_CODE
-                                    op=>opval = op=>opval and nextop=>opval
-                                    freeops   = 2
-                                    break
                             wend // End of collapse constant operation
                         fin
                         if pass and not freeops and op=>opval
                             crunched = try_dupify(op)
                         fin
                         break // CONST_CODE
+                    is ADD_CODE
+                        if op=>opval == 0
+                            freeops = -2
+                        elsif op=>opval > 0 and op=>opval <= 255
+                            op->opcode = ADDI_CODE
+                            freeops    = 1
+                        elsif op=>opval >= -255 and op=>opval < 0
+                            op->opcode = SUBI_CODE
+                            op=>opval  = -op=>opval
+                            freeops    = 1
+                        fin
+                        break
+                    is SUB_CODE
+                        if op=>opval == 0
+                            freeops = -2
+                        elsif op=>opval > 0 and op=>opval <= 255
+                            op->opcode = SUBI_CODE
+                            freeops    = 1
+                        elsif op=>opval >= -255 and op=>opval < 0
+                            op->opcode = ADDI_CODE
+                            op=>opval  = -op=>opval
+                            freeops    = 1
+                        fin
+                        break
+                    is AND_CODE
+                        if op=>opval >= 0 and op=>opval <= 255
+                            op->opcode = ANDI_CODE
+                            freeops    = 1
+                        fin
+                        break
+                    is OR_CODE
+                        if op=>opval == 0
+                            freeops = -2
+                        elsif op=>opval > 0 and op=>opval <= 255
+                            op->opcode = ORI_CODE
+                            freeops    = 1
+                        fin
+                        break
                     is MUL_CODE
-                        for shiftcnt = 0 to 15
-                            if op=>opval == 1 << shiftcnt
-                                op=>opval       = shiftcnt
-                                nextop->opcode  = SHL_CODE
-                                break
-                            fin
-                        next
+                        if op=>opval == 0
+                            op->opcode      = DROP_CODE
+                            op->opgroup     = STACK_GROUP
+                            nextop->opcode  = CONST_CODE
+                            nextop->opgroup = CONST_GROUP
+                            nextop=>opval   = 0
+                        elsif op=>opval == 2
+                            op->opcode     = DUP_CODE
+                            op->opgroup    = STACK_GROUP
+                            nextop->opcode = ADD_CODE
+                        else
+                            for shiftcnt = 2 to 15
+                                if op=>opval == 1 << shiftcnt
+                                    op=>opval       = shiftcnt
+                                    nextop->opcode  = SHL_CODE
+                                    break
+                                fin
+                            next
+                        fin
                         break
                     is DIV_CODE
-                       for shiftcnt = 0 to 15
+                       for shiftcnt = 1 to 15
                             if op=>opval == 1 << shiftcnt
                                 op=>opval      = shiftcnt
                                 nextop->opcode = SHR_CODE
@@ -240,7 +305,7 @@ def crunch_seq(seq, pass)
                         if nextop=>opnext
                             nextopnext = nextop=>opnext
                             when nextopnext->opcode
-                                is INDEXB_CODE // ADD_CODE
+                                is ADD_CODE // INDEXB_CODE
                                     op=>opoffset = op=>opoffset + nextop=>opval
                                     freeops      = 2
                                     break
@@ -278,7 +343,7 @@ def crunch_seq(seq, pass)
                         if nextop=>opnext
                             nextopnext = nextop=>opnext
                             when nextopnext->opcode
-                                is INDEXB_CODE // ADD_CODE
+                                is ADD_CODE // INDEXB_CODE
                                     op=>opoffset = op=>opoffset + nextop=>opval
                                     freeops      = 2
                                     break
@@ -315,45 +380,85 @@ def crunch_seq(seq, pass)
                 fin
                 break // GADDR_CODE
             is LLB_CODE
-                if pass
+                when nextop->opcode
+                    is ADD_CODE // INDEXB_CODE
+                        op->opcode = ADDLB_CODE
+                        freeops    = 1
+                        break
+                    is INDEXW_CODE
+                        op->opcode = IDXLB_CODE
+                        freeops    = 1
+                        break
+                wend
+                if pass and not freeops
                     crunched = try_dupify(op)
                 fin
                 break // LLB_CODE
             is LLW_CODE
-                // LLW [n]:CB 8:SHR -> LLB [n+1]
-                if nextop->opcode == CONST_CODE and nextop=>opval == 8
-                    if nextop=>opnext
-                        nextopnext = nextop=>opnext
-                        if nextopnext->opcode == SHR_CODE
-                            op->opcode = LLB_CODE
-                            op=>opoffset++
-                            freeops = 2
-                            break
+                when nextop->opcode
+                    is ADD_CODE // INDEXB_CODE
+                        op->opcode = ADDLW_CODE
+                        freeops    = 1
+                        break
+                    is INDEXW_CODE
+                        op->opcode = IDXLW_CODE
+                        freeops    = 1
+                        break
+                    is CONST_CODE
+                        // LLW [n]:CB 8:SHR -> LLB [n+1]
+                        if nextop=>opval == 8 and nextop=>opnext
+                            nextopnext = nextop=>opnext
+                            if nextopnext->opcode == SHR_CODE
+                                op->opcode = LLB_CODE
+                                op=>opoffset++
+                                freeops = 2
+                                break
+                            fin
                         fin
-                    fin
-                fin
+                        break
+                wend
                 if pass and not freeops
                     crunched = try_dupify(op)
                 fin
                 break // LLW_CODE
             is LAB_CODE
-                if pass and not is_hardware_address(op=>opoffset)
+                when nextop->opcode
+                    is ADD_CODE // INDEXB_CODE
+                        op->opcode = ADDAB_CODE
+                        freeops    = 1
+                        break
+                    is INDEXW_CODE
+                        op->opcode = IDXAB_CODE
+                        freeops    = 1
+                        break
+                wend
+                if pass and not freeops and not is_hardware_address(op=>opoffset)
                     crunched = try_dupify(op)
                 fin
                 break // LAB_CODE
             is LAW_CODE
-                // LAW x:CB 8:SHR -> LAB x+1
-                if nextop->opcode == CONST_CODE and nextop=>opval == 8
-                    if nextop=>opnext
-                        nextopnext = nextop=>opnext
-                        if nextopnext->opcode == SHR_CODE
-                            op->opcode = LAB_CODE
-                            op=>opoffset++
-                            freeops = 2
-                            break
+                when nextop->opcode
+                    is ADD_CODE // INDEXB_CODE
+                        op->opcode = ADDAW_CODE
+                        freeops    = 1
+                        break
+                    is INDEXW_CODE
+                        op->opcode = IDXAW_CODE
+                        freeops    = 1
+                        break
+                    is CONST_CODE
+                        // LLW [n]:CB 8:SHR -> LLB [n+1]
+                        if nextop=>opval == 8 and nextop=>opnext
+                            nextopnext = nextop=>opnext
+                            if nextopnext->opcode == SHR_CODE
+                                op->opcode = LAB_CODE
+                                op=>opoffset++
+                                freeops = 2
+                                break
+                            fin
                         fin
-                    fin
-                fin
+                        break
+                wend
                 if pass and not freeops and not is_hardware_address(op=>opoffset)
                     crunched = try_dupify(op)
                 fin
@@ -374,6 +479,38 @@ def crunch_seq(seq, pass)
                         break
                 wend
                 break // LOGIC_NOT_CODE
+            is EQ_CODE
+                when nextop->opcode
+                    is BRFALSE_CODE
+                        op->opcode  = BRNE_CODE
+                        op->opgroup = RELATIVE_GROUP
+                        op=>optag   = nextop=>optag
+                        freeops     = 1
+                        break
+                    is BRTRUE_CODE
+                        op->opcode  = BREQ_CODE
+                        op->opgroup = RELATIVE_GROUP
+                        op=>optag   = nextop=>optag
+                        freeops     = 1
+                        break
+                wend
+                break // EQ_CODE
+            is NE_CODE
+                when nextop->opcode
+                    is BRFALSE_CODE
+                        op->opcode  = BREQ_CODE
+                        op->opgroup = RELATIVE_GROUP
+                        op=>optag   = nextop=>optag
+                        freeops     = 1
+                        break
+                    is BRTRUE_CODE
+                        op->opcode  = BRNE_CODE
+                        op->opgroup = RELATIVE_GROUP
+                        op=>optag   = nextop=>optag
+                        freeops     = 1
+                        break
+                wend
+                break // NE_CODE
             is SLB_CODE
                 if nextop->opcode == LLB_CODE and op=>opoffset == nextop=>opoffset
                     op->opcode = DLB_CODE

src/toolsrc/codeseq.plh

@@ -3,33 +3,36 @@
 //
 const CONST_GROUP       = $00
 const CONST_CODE        = $2C
+const ADDI_CODE         = $38
+const SUBI_CODE         = $3A
+const ANDI_CODE         = $3C
+const ORI_CODE          = $3E
 const CONSTR_GROUP      = $01
 const CONSTR_CODE       = $2E
 //
 // Stack code group
 //
 const STACK_GROUP       = $02
-const INDEXB_CODE       = $02
-const ADD_CODE          = $02
-const SUB_CODE          = $04
-const MUL_CODE          = $06
-const DIV_CODE          = $08
-const MOD_CODE          = $0A
-const INC_CODE          = $0C
-const DEC_CODE          = $0E
-const NEG_CODE          = $10
-const COMP_CODE         = $12
-const AND_CODE          = $14
-const OR_CODE           = $16
-const EOR_CODE          = $18
-const SHL_CODE          = $1A
-const SHR_CODE          = $1C
-const INDEXW_CODE       = $1E
-const LOGIC_NOT_CODE    = $20
-const LOGIC_OR_CODE     = $22
-const LOGIC_AND_CODE    = $24
+const INDEXB_CODE       = $82
+const ADD_CODE          = $82
+const SUB_CODE          = $84
+const MUL_CODE          = $86
+const DIV_CODE          = $88
+const MOD_CODE          = $8A
+const INC_CODE          = $8C
+const DEC_CODE          = $8E
+const NEG_CODE          = $90
+const COMP_CODE         = $92
+const AND_CODE          = $94
+const OR_CODE           = $96
+const EOR_CODE          = $98
+const SHL_CODE          = $9A
+const SHR_CODE          = $9C
+const INDEXW_CODE       = $9E
+const LOGIC_NOT_CODE    = $80
 const DROP_CODE         = $30
-const DUP_CODE          = $32
+const DROP2_CODE        = $32
+const DUP_CODE          = $34
 const EQ_CODE           = $40
 const NE_CODE           = $42
 const GT_CODE           = $44
@@ -55,6 +58,10 @@ const DLB_CODE          = $6C
 const DLW_CODE          = $6E
 const SLB_CODE          = $74
 const SLW_CODE          = $76
+const ADDLB_CODE        = $B0
+const ADDLW_CODE        = $B2
+const IDXLB_CODE        = $B8
+const IDXLW_CODE        = $BA
 //
 // Global address code group
 //
@@ -67,13 +74,23 @@ const SAB_CODE          = $78
 const SAW_CODE          = $7A
 const DAB_CODE          = $7C
 const DAW_CODE          = $7E
+const ADDAB_CODE        = $B4
+const ADDAW_CODE        = $B6
+const IDXAB_CODE        = $BC
+const IDXAW_CODE        = $BE
 //
 // Relative address code group
 //
 const RELATIVE_GROUP    = $05
+const BREQ_CODE         = $22
+const BRNE_CODE         = $24
 const BRFALSE_CODE      = $4C
 const BRTRUE_CODE       = $4E
 const BRNCH_CODE        = $50
+const BRAND_CODE        = $AC
+const BROR_CODE         = $AE
+const BRGT_CODE         = $A0
+const BRLT_CODE         = $A2
 //
 // Code tag address group
 //

src/toolsrc/lex.c

@@ -50,7 +50,6 @@ t_token keywords[] = {
     BYTE_TOKEN,             'R', 'E', 'S',
     BYTE_TOKEN,             'B', 'Y', 'T', 'E',
     BYTE_TOKEN,             'C', 'H', 'A', 'R',
-    BYTE_TOKEN,             'R', 'E', 'S',
     WORD_TOKEN,             'W', 'O', 'R', 'D',
     WORD_TOKEN,             'V', 'A', 'R',
     CONST_TOKEN,            'C', 'O', 'N', 'S', 'T',

src/toolsrc/lex.pla

@@ -36,7 +36,9 @@
 //    loop
 //    chrptr = tknptr - 1
 //    while keywrds[keypos] == tknlen
-//        i = 1; while i <= tknlen and ^(chrptr + i) == keywrds[keypos + i]; i++; loop
+//        for i = 1 to tknlen
+//            if ^(chrptr + i) <> keywrds[keypos + i]; break; fin
+//         next
 //        if i > tknlen
 //            return keywrds[keypos + keywrds[keypos] + 1]
 //        fin
@@ -325,7 +327,7 @@ def nextln
         scanptr++
         scan
     else
-        if token <> EOL_TKN and token <> EOF_TKN; puti(token&$7F); puts("Extraneous characters\n"); exit_err(0); fin
+        if token <> EOL_TKN and token <> EOF_TKN; putc(token&$7F); puts("Extraneous characters\n"); exit_err(0); fin
         scanptr = inbuff
         ^instr  = fileio:read(refnum, inbuff, 127)
         if ^instr

src/toolsrc/parse.c

@@ -1,10 +1,13 @@
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include "plasm.h"
 #define LVALUE      0
 #define RVALUE      1
 #define MAX_LAMBDA  64
 
+int parse_mods(void);
+
 int infunc = 0, break_tag = 0, cont_tag = 0, stack_loop = 0;
 long infuncvals = 0;
 t_token prevstmnt;
@@ -23,9 +26,7 @@ t_token binary_ops_table[] = {
     EOR_TOKEN,
     OR_TOKEN,
     GT_TOKEN, GE_TOKEN, LT_TOKEN, LE_TOKEN,
-    EQ_TOKEN, NE_TOKEN,
-    LOGIC_AND_TOKEN,
-    LOGIC_OR_TOKEN
+    EQ_TOKEN, NE_TOKEN
     /* Lowest precedence  */
 };
 t_token binary_ops_precedence[] = {
@@ -37,9 +38,7 @@ t_token binary_ops_precedence[] = {
     5,
     6,
     7, 7, 7, 7,
-    8, 8,
-    9,
-    10
+    8, 8
     /* Lowest precedence  */
 };
 
@@ -652,9 +651,13 @@ t_opseq *parse_value(t_opseq *codeseq, int rvalue, int *stackdepth)
             cfnparms = 0; cfnvals = 1;
             type &= ~FUNC_TYPE;
         }
-        else if (type & (BYTE_TYPE | BPTR_TYPE))
+        else if (type & (BPTR_TYPE)) // Prefer the pointer type.
             valseq = gen_lb(valseq);
-        else if (type & (WORD_TYPE | WPTR_TYPE))
+        else if (type & (WPTR_TYPE))
+            valseq = gen_lw(valseq);
+        else if (type & (BYTE_TYPE))
+            valseq = gen_lb(valseq);
+        else if (type & (WORD_TYPE))
             valseq = gen_lw(valseq);
         else
             parse_error("What are we dereferencing?");
@@ -682,7 +685,7 @@ t_opseq *parse_value(t_opseq *codeseq, int rvalue, int *stackdepth)
     }
     return (cat_seq(codeseq, valseq));
 }
-t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
+t_opseq *parse_subexpr(t_opseq *codeseq, int *stackdepth)
 {
     int prevmatch;
     int matchop = 0;
@@ -729,14 +732,60 @@ t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
         if (stackdepth)
             (*stackdepth)--;
     }
-    /*
-     * Look for ternary operator
-     */
+    if (scantoken == LOGIC_AND_TOKEN)
+    {
+        int tag_and;
+        int stackdepth1;
+
+        /*
+         * Short-circuit AND
+         */
+        if (*stackdepth != 1)
+            parse_error("AND must evaluate to single value");
+        tag_and = tag_new(BRANCH_TYPE);
+        codeseq = gen_brand(codeseq, tag_and);
+        codeseq = parse_subexpr(codeseq, &stackdepth1);
+        if (stackdepth1 != *stackdepth)
+            parse_error("Inconsistent AND value counts");
+        codeseq = gen_codetag(codeseq, tag_and);
+    }
+    else if (scantoken == LOGIC_OR_TOKEN)
+    {
+        int tag_or;
+        int stackdepth1;
+
+        /*
+         * Short-circuit OR
+         */
+        if (*stackdepth != 1)
+            parse_error("OR must evaluate to single value");
+        tag_or  = tag_new(BRANCH_TYPE);
+        codeseq = gen_bror(codeseq, tag_or);
+        codeseq = parse_subexpr(codeseq, &stackdepth1);
+        if (stackdepth1 != *stackdepth)
+            parse_error("Inconsistent AND value counts");
+        codeseq = gen_codetag(codeseq, tag_or);
+    }
+    return (codeseq);
+}
+t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
+{
+    int prevmatch;
+    int matchop = 0;
+    int optos = opsptr;
+    int i, valdepth;
+    int prevtype, type = 0;
+    t_opseq *valseq;
+
+    codeseq = parse_subexpr(codeseq, stackdepth);
     if (scantoken == TERNARY_TOKEN)
     {
         int tag_else, tag_endtri;
         int stackdepth1;
 
+        /*
+         * Look for ternary operator
+         */
         if (*stackdepth != 1)
             parse_error("Ternary op must evaluate to single value");
         tag_else   = tag_new(BRANCH_TYPE);
@@ -753,8 +802,7 @@ t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
         codeseq = gen_codetag(codeseq, tag_endtri);
     }
     return (codeseq);
-}
-t_opseq *parse_set(t_opseq *codeseq)
+}t_opseq *parse_set(t_opseq *codeseq)
 {
     char *setptr = tokenstr;
     int lparms = 0, rparms = 0;
@@ -798,9 +846,11 @@ t_opseq *parse_set(t_opseq *codeseq)
 int parse_stmnt(void)
 {
     int tag_prevbrk, tag_prevcnt, tag_else, tag_endif, tag_while, tag_wend, tag_repeat, tag_for, tag_choice, tag_of;
-    int type, addr, step, cfnvals;
+    int type, addr, step, cfnvals, constsize, casecnt, i;
+    int *caseval, *casetag;
+    long constval;
     char *idptr;
-    t_opseq *seq;
+    t_opseq *seq, *fromseq, *toseq;
 
     /*
      * Optimization for last function LEAVE and OF clause.
@@ -859,9 +909,10 @@ int parse_stmnt(void)
             tag_while   = tag_new(BRANCH_TYPE);
             tag_wend    = tag_new(BRANCH_TYPE);
             tag_prevcnt = cont_tag;
-            cont_tag    = tag_while;
+            cont_tag    = tag_new(BRANCH_TYPE);
             tag_prevbrk = break_tag;
             break_tag   = tag_wend;
+            emit_brnch(cont_tag);
             emit_codetag(tag_while);
             if (!(seq = parse_expr(NULL, &cfnvals)))
                 parse_error("Bad expression");
@@ -870,12 +921,12 @@ int parse_stmnt(void)
                 parse_warn("Expression value overflow");
                 while (cfnvals-- > 1) seq = gen_drop(seq);
             }
-            seq = gen_brfls(seq, tag_wend);
-            emit_seq(seq);
+            seq = gen_brtru(seq, tag_while);
             while (parse_stmnt()) next_line();
             if (scantoken != LOOP_TOKEN)
                 parse_error("Missing WHILE/END");
-            emit_brnch(tag_while);
+            emit_codetag(cont_tag);
+            emit_seq(seq);
             emit_codetag(tag_wend);
             break_tag = tag_prevbrk;
             cont_tag  = tag_prevcnt;
@@ -906,46 +957,38 @@ int parse_stmnt(void)
             break_tag = tag_prevbrk;
             break;
         case FOR_TOKEN:
-            stack_loop++;
+            stack_loop += 2;
             tag_prevbrk = break_tag;
             break_tag   = tag_new(BRANCH_TYPE);
             tag_for     = tag_new(BRANCH_TYPE);
             tag_prevcnt = cont_tag;
-            cont_tag    = tag_for;
+            cont_tag    = tag_new(BRANCH_TYPE);
             if (scan() != ID_TOKEN)
                 parse_error("Missing FOR variable");
             type = id_type(tokenstr, tokenlen);
             addr = id_tag(tokenstr, tokenlen);
             if (scan() != SET_TOKEN)
                 parse_error("Missing FOR =");
-            if (!(seq = parse_expr(NULL, &cfnvals)))
+            if (!(fromseq = parse_expr(NULL, &cfnvals)))
                 parse_error("Bad FOR expression");
             if (cfnvals > 1)
             {
                 parse_warn("Expression value overflow");
                 while (cfnvals-- > 1) seq = gen_drop(seq);
             }
-            emit_seq(seq);
-            emit_codetag(tag_for);
-            if (type & LOCAL_TYPE)
-                type & BYTE_TYPE ? emit_dlb(addr) : emit_dlw(addr);
-            else
-                type & BYTE_TYPE ? emit_dab(addr, 0, type) : emit_daw(addr, 0, type);
             if (scantoken == TO_TOKEN)
                 step = 1;
             else if (scantoken == DOWNTO_TOKEN)
                 step = -1;
             else
                 parse_error("Missing FOR TO");
-            if (!(seq = parse_expr(NULL, &cfnvals)))
+            if (!(toseq = parse_expr(NULL, &cfnvals)))
                 parse_error("Bad FOR TO expression");
             if (cfnvals > 1)
             {
                 parse_warn("Expression value overflow");
                 while (cfnvals-- > 1) seq = gen_drop(seq);
             }
-            emit_seq(seq);
-            step > 0 ? emit_brgt(break_tag) : emit_brlt(break_tag);
             if (scantoken == STEP_TOKEN)
             {
                 if (!(seq = parse_expr(NULL, &cfnvals)))
@@ -955,27 +998,59 @@ int parse_stmnt(void)
                     parse_warn("Expression value overflow");
                     while (cfnvals-- > 1) seq = gen_drop(seq);
                 }
-                emit_seq(seq);
-                emit_op(step > 0 ? ADD_TOKEN : SUB_TOKEN);
             }
             else
-                emit_unaryop(step > 0 ? INC_TOKEN : DEC_TOKEN);
+            {
+                seq = NULL;
+            }
+            toseq = cat_seq(toseq, fromseq);
+            emit_seq(step > 0 ? gen_brgt(toseq, break_tag) : gen_brlt(toseq, break_tag));
+            emit_codetag(tag_for);
+            if (type & LOCAL_TYPE)
+                type & BYTE_TYPE ? emit_dlb(addr) : emit_dlw(addr);
+            else
+                type & BYTE_TYPE ? emit_dab(addr, 0, type) : emit_daw(addr, 0, type);
             while (parse_stmnt()) next_line();
             if (scantoken != NEXT_TOKEN)
                 parse_error("Missing FOR/NEXT");
-            emit_brnch(tag_for);
+            emit_codetag(cont_tag);
             cont_tag = tag_prevcnt;
+            if (step > 0)
+            {
+                if (seq)
+                {
+                    emit_seq(seq);
+                    emit_addbrle(tag_for);
+                }
+                else
+                    emit_incbrle(tag_for);
+            }
+            else
+            {
+                if (seq)
+                {
+                    emit_seq(seq);
+                    emit_subbrge(tag_for);
+                }
+                else
+                    emit_decbrge(tag_for);
+            }
             emit_codetag(break_tag);
+            if (type & LOCAL_TYPE)
+                type & BYTE_TYPE ? emit_slb(addr) : emit_slw(addr);
+            else
+                type & BYTE_TYPE ? emit_sab(addr, 0, type) : emit_saw(addr, 0, type);
             emit_drop();
-            break_tag = tag_prevbrk;
-            stack_loop--;
+            break_tag   = tag_prevbrk;
+            stack_loop -= 2;
             break;
         case CASE_TOKEN:
-            stack_loop++;
             tag_prevbrk = break_tag;
             break_tag   = tag_new(BRANCH_TYPE);
             tag_choice  = tag_new(BRANCH_TYPE);
-            tag_of      = tag_new(BRANCH_TYPE);
+            caseval     = malloc(sizeof(int)*256);
+            casetag     = malloc(sizeof(int)*256);
+            casecnt     = 0;
             if (!(seq = parse_expr(NULL, &cfnvals)))
                 parse_error("Bad CASE expression");
             if (cfnvals > 1)
@@ -984,33 +1059,48 @@ int parse_stmnt(void)
                 while (cfnvals-- > 1) seq = gen_drop(seq);
             }
             emit_seq(seq);
+            emit_select(tag_choice);
             next_line();
             while (scantoken != ENDCASE_TOKEN)
             {
                 if (scantoken == OF_TOKEN)
                 {
-                    if (!(seq = parse_expr(NULL, &cfnvals)))
-                        parse_error("Bad CASE OF expression");
-                    if (cfnvals > 1)
+                    tag_of   = tag_new(BRANCH_TYPE);
+                    constval = 0;
+                    parse_constexpr(&constval, &constsize);
+                    i = casecnt;
+                    while ((i > 0) && (caseval[i-1] > constval))
                     {
-                        parse_warn("Expression value overflow");
-                        while (cfnvals-- > 1) seq = gen_drop(seq);
+                        //
+                        // Move larger case consts up
+                        //
+                        caseval[i] = caseval[i-1];
+                        casetag[i] = casetag[i-1];
+                        i--;
                     }
-                    emit_seq(seq);
-                    emit_brne(tag_choice);
+                    if ((i < casecnt) && (caseval[i] == constval))
+                        parse_error("Duplicate CASE");
+                    caseval[i] = constval;
+                    casetag[i] = tag_of;
+                    casecnt++;
                     emit_codetag(tag_of);
                     while (parse_stmnt()) next_line();
-                    tag_of = tag_new(BRANCH_TYPE);
-                    if (prevstmnt != BREAK_TOKEN) // Fall through to next OF if no break
-                        emit_brnch(tag_of);
-                    emit_codetag(tag_choice);
-                    tag_choice = tag_new(BRANCH_TYPE);
                 }
                 else if (scantoken == DEFAULT_TOKEN)
                 {
-                    emit_codetag(tag_of);
-                    tag_of = 0;
+                    if (prevstmnt != BREAK_TOKEN) // Branch around caseblock if falling through
+                    {
+                        tag_of = tag_new(BRANCH_TYPE);
+                        emit_brnch(tag_of);
+                    }
+                    else
+                        tag_of = 0;
+                    emit_codetag(tag_choice);
+                    emit_caseblock(casecnt, caseval, casetag);
+                    tag_choice = 0;
                     scan();
+                    if (tag_of)
+                        emit_codetag(tag_of);
                     while (parse_stmnt()) next_line();
                     if (scantoken != ENDCASE_TOKEN)
                         parse_error("Bad CASE DEFAULT clause");
@@ -1020,12 +1110,16 @@ int parse_stmnt(void)
                 else
                     parse_error("Bad CASE clause");
             }
-            if (tag_of)
-                emit_codetag(tag_of);
+            if (tag_choice)
+            {
+                emit_brnch(break_tag);
+                emit_codetag(tag_choice);
+                emit_caseblock(casecnt, caseval, casetag);
+            }
+            free(caseval);
+            free(casetag);
             emit_codetag(break_tag);
-            emit_drop();
             break_tag = tag_prevbrk;
-            stack_loop--;
             break;
         case BREAK_TOKEN:
             if (break_tag)
@@ -1040,12 +1134,19 @@ int parse_stmnt(void)
                 parse_error("CONTINUE without loop");
             break;
         case RETURN_TOKEN:
+            cfnvals = stack_loop;
+            while (cfnvals >= 2)
+            {
+                emit_drop2();
+                cfnvals -= 2;
+            }
+            if (cfnvals)
+            {
+                emit_drop();
+                cfnvals--;
+            }
             if (infunc)
             {
-                int i;
-                for (i = 0; i < stack_loop; i++)
-                    emit_drop();
-                cfnvals = 0;
                 emit_seq(parse_list(NULL, &cfnvals));
                 if (cfnvals > infuncvals)
                     parse_error("Too many return values");
@@ -1243,7 +1344,7 @@ int parse_struc(void)
 int parse_vars(int type)
 {
     long value;
-    int idlen, size, cfnparms;
+    int idlen, size, cfnparms, emit = 0;
     long cfnvals;
     char *idstr;
 
@@ -1306,6 +1407,7 @@ int parse_vars(int type)
             if (type & WORD_TYPE)
                 cfnvals *= 2;
             do parse_var(type, cfnvals); while (scantoken == COMMA_TOKEN);
+            emit = type == GLOBAL_TYPE;
             break;
         case PREDEF_TOKEN:
             /*
@@ -1346,6 +1448,12 @@ int parse_vars(int type)
                 else
                     parse_error("Bad function pre-declaration");
             } while (scantoken == COMMA_TOKEN);
+            break;
+        case IMPORT_TOKEN:
+            if (emit || type != GLOBAL_TYPE)
+                parse_error("IMPORT after emitting data");
+            parse_mods();
+            break;
         case EOL_TOKEN:
             break;
         default:
@@ -1436,11 +1544,16 @@ int parse_defs(void)
     char c, *idstr;
     int idlen, func_tag, cfnparms, cfnvals, type = GLOBAL_TYPE, pretype;
     static char bytecode = 0;
-    if (scantoken == EXPORT_TOKEN)
+
+    switch (scantoken)
     {
-        if (scan() != DEF_TOKEN && scantoken != ASM_TOKEN)
-            parse_error("Bad export definition");
-        type = EXPORT_TYPE;
+        case CONST_TOKEN:
+        case STRUC_TOKEN:
+            return parse_vars(GLOBAL_TYPE);
+        case EXPORT_TOKEN:
+            if (scan() != DEF_TOKEN && scantoken != ASM_TOKEN)
+                parse_error("Bad export definition");
+            type = EXPORT_TYPE;
     }
     if (scantoken == DEF_TOKEN)
     {
@@ -1520,8 +1633,9 @@ int parse_defs(void)
                 emit_const(0);
             emit_leave();
         }
-        while (lambda_cnt--)
-            emit_lambdafunc(lambda_tag[lambda_cnt], lambda_id[lambda_cnt], lambda_cparams[lambda_cnt], lambda_seq[lambda_cnt]);
+        for (cfnvals = 0; cfnvals < lambda_cnt; cfnvals++)
+            emit_lambdafunc(lambda_tag[cfnvals], lambda_id[cfnvals], lambda_cparams[cfnvals], lambda_seq[cfnvals]);
+        lambda_cnt = 0;
         return (1);
     }
     else if (scantoken == ASM_TOKEN)
@@ -1589,6 +1703,7 @@ int parse_defs(void)
             next_line();
         } while (scantoken != END_TOKEN);
         scan();
+        infunc = 0;
         return (1);
     }
     return (scantoken == EOL_TOKEN);
@@ -1601,21 +1716,21 @@ int parse_module(void)
         while (parse_mods())            next_line();
         while (parse_vars(GLOBAL_TYPE)) next_line();
         while (parse_defs())            next_line();
+        emit_bytecode_seg();
+        emit_start();
+        idlocal_reset();
+        emit_idfunc(0, 0, NULL, 1);
+        prevstmnt = 0;
         if (scantoken != DONE_TOKEN && scantoken != EOF_TOKEN)
         {
-            emit_bytecode_seg();
-            emit_start();
-            idlocal_reset();
-            emit_idfunc(0, 0, NULL, 1);
-            prevstmnt = 0;
             while (parse_stmnt()) next_line();
             if (scantoken != DONE_TOKEN)
                 parse_error("Missing DONE");
-            if (prevstmnt != RETURN_TOKEN)
-            {
-                emit_const(0);
-                emit_ret();
-            }
+        }
+        if (prevstmnt != RETURN_TOKEN)
+        {
+            emit_const(0);
+            emit_ret();
         }
     }
     emit_trailer();

src/toolsrc/parse.pla

@@ -80,8 +80,6 @@ def calc_binaryop(op)#0
     push_val(val1, size1, type1)
 end
 def parse_constterm
-    word val
-    byte size, type
 
     when scan
         is OPEN_PAREN_TKN
@@ -463,9 +461,13 @@ def parse_value(codeseq, r_val)#2
             valseq     = gen_op(valseq, ICAL_CODE)
             stackdepth = stackdepth + cfnvals - 1
             type       = type & ~FUNC_TYPE
-        elsif type & (BYTE_TYPE | BPTR_TYPE)
+        elsif type & (BPTR_TYPE)  // Prefer the pointer type.
             valseq = gen_op(valseq, LB_CODE)
-        elsif type & (WORD_TYPE | WPTR_TYPE)
+        elsif type & (WPTR_TYPE)
+            valseq = gen_op(valseq, LW_CODE)
+        elsif type & (BYTE_TYPE)
+            valseq = gen_op(valseq, LB_CODE)
+        elsif type & (WORD_TYPE)
             valseq = gen_op(valseq, LW_CODE)
         else
             exit_err(ERR_INVAL|ERR_CODE)
@@ -491,10 +493,10 @@ def parse_value(codeseq, r_val)#2
     fin
     return cat_seq(codeseq, valseq), stackdepth
 end
-def parse_expr(codeseq)#2
+def parse_subexpr(codeseq)#2
     byte stackdepth, matchdepth, stkdepth1, prevmatch, matchop, i
     word optos
-    word tag_else, tag_endtri
+    word tag_else, tag_endop
 
     stackdepth = 0
     matchop    = 0
@@ -524,21 +526,40 @@ def parse_expr(codeseq)#2
         codeseq = gen_bop(codeseq, pop_op)
         stackdepth--
     loop
-    //
-    // Look for ternary operator
-    //
+    if token == LOGIC_AND_TKN
+        if stackdepth <> 1; exit_err(ERR_OVER|ERR_SYNTAX); fin
+        tag_endop          = new_tag(RELATIVE_FIXUP)
+        codeseq            = gen_oprel(codeseq, BRAND_CODE, tag_endop)
+        codeseq, stkdepth1 = parse_subexpr(codeseq)
+        if stkdepth1 <> stackdepth; exit_err(ERR_INVAL|ERR_CODE); fin
+        codeseq            = gen_ctag(codeseq, tag_endop)
+    elsif token == LOGIC_OR_TKN
+        if stackdepth <> 1; exit_err(ERR_OVER|ERR_SYNTAX); fin
+        tag_endop          = new_tag(RELATIVE_FIXUP)
+        codeseq            = gen_oprel(codeseq, BROR_CODE, tag_endop)
+        codeseq, stkdepth1 = parse_subexpr(codeseq)
+        if stkdepth1 <> stackdepth; exit_err(ERR_INVAL|ERR_CODE); fin
+        codeseq            = gen_ctag(codeseq, tag_endop)
+    fin
+    return codeseq, stackdepth
+end
+def parse_expr(codeseq)#2
+    byte stackdepth, stkdepth1
+    word tag_else, tag_endop
+
+    codeseq, stackdepth = parse_subexpr(codeseq)
     if token == TERNARY_TKN
         if stackdepth <> 1; exit_err(ERR_OVER|ERR_SYNTAX); fin
         tag_else            = new_tag(RELATIVE_FIXUP)
-        tag_endtri          = new_tag(RELATIVE_FIXUP)
+        tag_endop           = new_tag(RELATIVE_FIXUP)
         codeseq             = gen_oprel(codeseq, BRFALSE_CODE, tag_else)
         codeseq, stkdepth1  = parse_expr(codeseq)
         if token <> TRIELSE_TKN; exit_err(ERR_MISS|ERR_SYNTAX); fin
-        codeseq             = gen_oprel(codeseq, BRNCH_CODE, tag_endtri)
+        codeseq             = gen_oprel(codeseq, BRNCH_CODE, tag_endop)
         codeseq             = gen_ctag(codeseq, tag_else)
         codeseq, stackdepth = parse_expr(codeseq)
         if stkdepth1 <> stackdepth; exit_err(ERR_INVAL|ERR_CODE); fin
-        codeseq             = gen_ctag(codeseq, tag_endtri)
+        codeseq             = gen_ctag(codeseq, tag_endop)
     fin
     return codeseq, stackdepth
 end
@@ -587,9 +608,10 @@ def parse_set(codeseq)
     return codeseq
 end
 def parse_stmnt
-    byte type, elem_type, elem_size, i, cfnvals
-    word seq, tag_prevbrk, tag_prevcnt, tag_else, tag_endif, tag_while, tag_wend
+    byte type, elem_type, elem_size, cfnvals
+    word seq, fromseq, toseq, tag_prevbrk, tag_prevcnt, tag_else, tag_endif, tag_while, tag_wend
     word tag_repeat, tag_for, tag_choice, tag_of, idptr, addr, stepdir
+    word caseconst, casecnt, caseval, casetag, i
 
     if token <> END_TKN and token <> DONE_TKN and token <> OF_TKN and token <> DEFAULT_TKN
         prevstmnt = token
@@ -643,9 +665,10 @@ def parse_stmnt
             tag_while   = new_tag(RELATIVE_FIXUP)
             tag_wend    = new_tag(RELATIVE_FIXUP)
             tag_prevcnt = cont_tag
-            cont_tag    = tag_while
+            cont_tag    = new_tag(RELATIVE_FIXUP)
             tag_prevbrk = break_tag
             break_tag   = tag_wend
+            emit_branch(cont_tag)
             emit_tag(tag_while)
             seq, cfnvals = parse_expr(NULL)
             if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
@@ -653,13 +676,13 @@ def parse_stmnt
                 parse_warn("Expression value overflow")
                 while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
             fin
-            seq = gen_oprel(seq, BRFALSE_CODE, tag_wend)
-            emit_seq(seq)
+            seq = gen_oprel(seq, BRTRUE_CODE, tag_while)
             while parse_stmnt
                 nextln
             loop
             if token <> LOOP_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
-            emit_branch(tag_while)
+            emit_tag(cont_tag)
+            emit_seq(seq)
             emit_tag(tag_wend)
             break_tag = tag_prevbrk
             cont_tag  = tag_prevcnt
@@ -690,10 +713,10 @@ def parse_stmnt
             break_tag = tag_prevbrk
             break
         is FOR_TKN
-            stack_loop++
+            stack_loop  = stack_loop + 2
             tag_for     = new_tag(RELATIVE_FIXUP)
             tag_prevcnt = cont_tag
-            cont_tag    = tag_for
+            cont_tag    = new_tag(RELATIVE_FIXUP)
             tag_prevbrk = break_tag
             break_tag   = new_tag(RELATIVE_FIXUP)
             if scan <> ID_TKN; exit_err(ERR_MISS|ERR_ID); fin
@@ -705,19 +728,12 @@ def parse_stmnt
                 exit_err(ERR_INVAL|ERR_ID)
             fin
             if scan <> SET_TKN; exit_err(ERR_INVAL|ERR_STATE); fin
-            seq, cfnvals = parse_expr(NULL)
-            if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
+            fromseq, cfnvals = parse_expr(NULL)
+            if !fromseq; exit_err(ERR_INVAL|ERR_STATE); fin
             if cfnvals > 1
                 parse_warn("Expression value overflow")
                 while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
             fin
-            emit_seq(seq)
-            emit_tag(tag_for)
-            if type & LOCAL_TYPE
-                if type & BYTE_TYPE; emit_dlb(addr); else; emit_dlw(addr); fin
-            else
-                if type & BYTE_TYPE; emit_dab(addr, 0); else; emit_daw(addr, 0); fin
-            fin
             if token == TO_TKN
                 stepdir = 1
             elsif token == DOWNTO_TKN
@@ -725,14 +741,12 @@ def parse_stmnt
             else
                 exit_err(ERR_INVAL|ERR_STATE)
             fin
-            seq, cfnvals = parse_expr(NULL)
-            if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
+            toseq, cfnvals = parse_expr(NULL)
+            if !toseq; exit_err(ERR_INVAL|ERR_STATE); fin
             if cfnvals > 1
                 parse_warn("Expression value overflow")
                 while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
             fin
-            emit_seq(seq)
-            if stepdir > 0; emit_brgt(break_tag); else; emit_brlt(break_tag); fin
             if token == STEP_TKN
                 seq, cfnvals = parse_expr(NULL)
                 if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
@@ -740,28 +754,54 @@ def parse_stmnt
                     parse_warn("Expression value overflow")
                     while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
                 fin
-                emit_seq(seq)
-                emit_code(stepdir > 0 ?? ADD_CODE :: SUB_CODE)
             else
-                emit_code(stepdir > 0 ?? INC_CODE :: DEC_CODE)
+                seq = NULL
+            fin
+            emit_seq(gen_oprel(cat_seq(toseq, fromseq), stepdir > 0 ?? BRGT_CODE :: BRLT_CODE, break_tag))
+            emit_tag(tag_for)
+            if type & LOCAL_TYPE
+                if type & BYTE_TYPE; emit_dlb(addr); else; emit_dlw(addr); fin
+            else
+                if type & BYTE_TYPE; emit_dab(addr, 0); else; emit_daw(addr, 0); fin
             fin
             while parse_stmnt
                 nextln
             loop
             if token <> NEXT_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
-            emit_branch(tag_for)
+            emit_tag(cont_tag)
             cont_tag = tag_prevcnt
+            if stepdir > 0
+                if seq
+                    emit_seq(seq)
+                    emit_addbrle(tag_for)
+                else
+                    emit_incbrle(tag_for)
+                fin
+            else
+                if seq
+                    emit_seq(seq)
+                    emit_subbrge(tag_for)
+                else
+                    emit_decbrge(tag_for)
+                fin
+            fin
             emit_tag(break_tag)
+            if type & LOCAL_TYPE
+                if type & BYTE_TYPE; emit_slb(addr); else; emit_slw(addr); fin
+            else
+                if type & BYTE_TYPE; emit_sab(addr, 0); else; emit_saw(addr, 0); fin
+            fin
             emit_code(DROP_CODE)
-            break_tag = tag_prevbrk
-            stack_loop--
+            break_tag  = tag_prevbrk
+            stack_loop = stack_loop - 2
             break
         is CASE_TKN
-            stack_loop++
             tag_prevbrk = break_tag
             break_tag   = new_tag(RELATIVE_FIXUP)
             tag_choice  = new_tag(RELATIVE_FIXUP)
-            tag_of      = new_tag(RELATIVE_FIXUP)
+            caseval     = heapalloc(CASENUM)
+            casetag     = heapalloc(CASENUM)
+            casecnt     = 0
             seq, cfnvals = parse_expr(NULL)
             if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
             if cfnvals > 1
@@ -769,32 +809,44 @@ def parse_stmnt
                 while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
             fin
             emit_seq(seq)
+            emit_select(tag_choice)
             nextln
             while token <> ENDCASE_TKN
                 when token
                     is OF_TKN
-                        seq, cfnvals = parse_expr(NULL)
-                        if !seq; exit_err(ERR_INVAL|ERR_STATE); fin
-                        if cfnvals > 1
-                            parse_warn("Expression value overflow")
-                            while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
-                        fin
-                        emit_seq(seq)
-                        emit_brne(tag_choice)
+                        if casecnt == CASENUM; exit_err(ERR_OVER|ERR_TABLE); fin
+                        caseconst, drop, drop = parse_constexpr
+                        tag_of                = new_tag(RELATIVE_FIXUP)
+                        i                     = casecnt
+                        while i > 0 and caseval=>[i-1] > caseconst
+                            //
+                            // Move larger case consts up
+                            //
+                            caseval=>[i] = caseval=>[i-1]
+                            casetag=>[i] = casetag=>[i-1]
+                            i--
+                        loop
+                        if i < casecnt and caseval=>[i] == caseconst; exit_err(ERR_DUP|ERR_STATE); fin
+                        caseval=>[i] = caseconst
+                        casetag=>[i] = tag_of
+                        casecnt++
                         emit_tag(tag_of)
                         while parse_stmnt
                             nextln
                         loop
-                        tag_of = new_tag(RELATIVE_FIXUP)
-                        if prevstmnt <> BREAK_TKN // Fall through to next OF if no break
+                        break
+                    is DEFAULT_TKN
+                        tag_of = 0
+                        if prevstmnt <> BREAK_TKN // Branch around caseblock if falling through
+                            tag_of = new_tag(RELATIVE_FIXUP)
                             emit_branch(tag_of)
                         fin
                         emit_tag(tag_choice)
-                        tag_choice = new_tag(RELATIVE_FIXUP)
-                        break
-                    is DEFAULT_TKN
-                        emit_tag(tag_of)
-                        tag_of = 0
+                        emit_caseblock(casecnt, caseval, casetag)
+                        tag_choice = 0
+                        if tag_of
+                            emit_tag(tag_of)
+                        fin
                         scan
                         while parse_stmnt
                             nextln
@@ -808,13 +860,14 @@ def parse_stmnt
                         exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE)
                 wend
             loop
-            if (tag_of)
-                emit_tag(tag_of)
+            if tag_choice
+                emit_branch(break_tag)
+                emit_tag(tag_choice)
+                emit_caseblock(casecnt, caseval, casetag)
             fin
+            heaprelease(caseval)
             emit_tag(break_tag)
-            emit_code(DROP_CODE)
             break_tag = tag_prevbrk
-            stack_loop--
             break
         is BREAK_TKN
             if break_tag
@@ -831,10 +884,15 @@ def parse_stmnt
             fin
             break
         is RETURN_TKN
+            i = stack_loop
+            while i >= 2
+                emit_code(DROP2_CODE)
+                i = i - 2
+            loop
+            if i
+                emit_code(DROP_CODE)
+            fin
             if infunc
-                for i = 1 to stack_loop
-                    emit_code(DROP_CODE)
-                next
                 seq, cfnvals = parse_list
                 emit_seq(seq)
                 if cfnvals > infuncvals
@@ -1076,6 +1134,10 @@ def parse_vars(type)
                 fin
             until token <> COMMA_TKN
             break
+        is IMPORT_TKN
+            if codeptr <> codebuff or type <> GLOBAL_TYPE; exit_err(ERR_INVAL|ERR_INIT); fin
+            parse_mods
+            break
         is EOL_TKN
             break
         otherwise
@@ -1157,81 +1219,95 @@ def parse_lambda
     return func_tag
 end
 def parse_defs
-    byte idlen, cfnparms, cfnvals
-    word type, idstr, func_tag, idptr
-
+    byte idlen, cfnparms, cfnvals, defstr[17]
+    word type, idstr, func_tag, idptr, defcodeptr
     type = FUNC_TYPE
-    if token == EXPORT_TKN
-        if scan <> DEF_TKN; exit_err(ERR_INVAL|ERR_STATE); fin
-        type = type | EXPORT_TYPE
-    fin
-    if token == DEF_TKN
-        if scan <> ID_TKN; exit_err(ERR_INVAL|ERR_ID); fin
-        lambda_cnt = 0
-        cfnparms   = 0
-        infuncvals = 1
-        infunc     = TRUE
-        idstr      = tknptr
-        idlen      = tknlen
-        init_idlocal
-        if scan == OPEN_PAREN_TKN
-            repeat
-                if scan == ID_TKN
-                    cfnparms++
-                    new_idlocal(tknptr, tknlen, WORD_TYPE, 2)
-                    scan
-                fin
-            until token <> COMMA_TKN
-            if token <> CLOSE_PAREN_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_SYNTAX); fin
+    when token
+        is CONST_TKN
+        is STRUC_TKN
+            return parse_vars(GLOBAL_TYPE)
+        is EXPORT_TKN
+            if scan <> DEF_TKN; exit_err(ERR_INVAL|ERR_STATE); fin
+            type = type | EXPORT_TYPE
+        is DEF_TKN
+            if scan <> ID_TKN; exit_err(ERR_INVAL|ERR_ID); fin
+            lambda_cnt = 0
+            cfnparms   = 0
+            infuncvals = 1
+            infunc     = TRUE
+            idstr      = tknptr
+            idlen      = tknlen
+            init_idlocal
+            if scan == OPEN_PAREN_TKN
+                repeat
+                    if scan == ID_TKN
+                        cfnparms++
+                        new_idlocal(tknptr, tknlen, WORD_TYPE, 2)
+                        scan
+                    fin
+                until token <> COMMA_TKN
+                if token <> CLOSE_PAREN_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_SYNTAX); fin
+                scan
+            fin
+            if token == POUND_TKN
+                if not parse_const(@infuncvals); exit_err(ERR_INVAL|ERR_CONST); fin
+                scan
+            fin
+            idptr = lookup_idglobal(idstr, idlen)
+            if idptr
+                if not idptr=>idtype & PREDEF_TYPE; exit_err(ERR_DUP|ERR_ID); fin
+                if idptr->funcparms <> cfnparms or idptr->funcvals <> infuncvals; exit_err(ERR_DUP|ERR_CODE|ERR_ID); fin
+                func_tag = idptr=>idval
+                idptr=>idtype = idptr=>idtype | type
+            else
+                func_tag = new_tag(WORD_FIXUP)
+                new_idfunc(idstr, idlen, type, func_tag, cfnparms, infuncvals)
+            fin
+            //
+            // Print def name
+            //
+            nametostr(idstr, idlen > 16 ?? 16 :: idlen, @defstr); puts(@defstr); putc(':')
+            defcodeptr = codeptr
+            emit_tag(func_tag)
+            new_dfd(func_tag)
+            while parse_vars(LOCAL_TYPE); nextln; loop
+            emit_enter(cfnparms)
+            prevstmnt = 0
+            while parse_stmnt; nextln; loop
+            infunc = FALSE
+            if token <> END_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
             scan
-        fin
-        if token == POUND_TKN
-            if not parse_const(@infuncvals); exit_err(ERR_INVAL|ERR_CONST); fin
-            scan
-        fin
-        idptr = lookup_idglobal(idstr, idlen)
-        if idptr
-            if not idptr=>idtype & PREDEF_TYPE; exit_err(ERR_DUP|ERR_ID); fin
-            if idptr->funcparms <> cfnparms or idptr->funcvals <> infuncvals; exit_err(ERR_DUP|ERR_CODE|ERR_ID); fin
-            func_tag = idptr=>idval
-            idptr=>idtype = idptr=>idtype | type
-        else
-            func_tag = new_tag(WORD_FIXUP)
-            new_idfunc(idstr, idlen, type, func_tag, cfnparms, infuncvals)
-        fin
-        emit_tag(func_tag)
-        while parse_vars(LOCAL_TYPE); nextln; loop
-        emit_enter(cfnparms)
-        prevstmnt = 0
-        while parse_stmnt; nextln; loop
-        infunc = FALSE
-        if token <> END_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
-        scan
-        if prevstmnt <> RETURN_TKN
-            if infuncvals; parse_warn("No return values"); fin
-            for cfnvals = infuncvals - 1 downto 0
-                emit_const(0)
+            if prevstmnt <> RETURN_TKN
+                if infuncvals; parse_warn("No return values"); fin
+                for cfnvals = infuncvals - 1 downto 0
+                    emit_const(0)
+                next
+                emit_leave
+            fin
+            for cfnvals = 0 to lambda_cnt-1
+                emit_lambdafunc(lambda_tag[cfnvals], lambda_cparms[cfnvals], lambda_seq[cfnvals])
+                new_dfd(lambda_tag[cfnvals])
             next
-            emit_leave
-        fin
-        while lambda_cnt
-            lambda_cnt--
-            emit_lambdafunc(lambda_tag[lambda_cnt], lambda_cparms[lambda_cnt], lambda_seq[lambda_cnt])
-        loop
-    fin
+            puti(codeptr - defcodeptr); puts(@bytesln)
+
+    wend
     return token == EOL_TKN ?? TRUE :: FALSE
 end
 def parse_module#0
     init_idglobal
     init_idlocal
+    puts("Data+Code buffer size = "); puti(codebufsz); putln
     if nextln
         //
         // Compile module
         //
+        puts("\nDATA:");
         while parse_mods;              nextln; loop
         while parse_vars(GLOBAL_TYPE); nextln; loop
         emit_codeseg
+        puti(codeptr - codebuff); puts(@bytesln)
         while parse_defs;              nextln; loop
+        puts("INIT:")
         entrypoint = codeptr
         prevstmnt  = 0
         init_idlocal
@@ -1243,6 +1319,8 @@ def parse_module#0
             emit_const(0)
             emit_leave
         fin
+        puti(codeptr - entrypoint); puts(@bytesln)
+        puts("\nTotal bytes compiled: "); puti(codeptr - codebuff); putln
         if token <> DONE_TKN; parse_warn("Missing DONE\n"); fin
         //dumpsym(idglobal_tbl, globals)
     fin