6502/PLASMA
1
0
Fork 0
mirror of https://github.com/dschmenk/PLASMA.git synced 2026-03-12 16:42:08 +00:00
Code Issues Projects Releases Wiki Activity

Compare commits

base: 6502:Alpha1
Branches Tags
6502:master 6502:ver-1
6502:v2.20 6502:v2.11 6502:v2.1 6502:v2.0 6502:Beta 6502:Alpha2 6502:Alpha1 6502:DP4 6502:DP3 6502:DP2 6502:v1.1a 6502:v1.0.0
..
compare: 6502:ver-1
Branches Tags
6502:master 6502:ver-1
6502:v2.20 6502:v2.11 6502:v2.1 6502:v2.0 6502:Beta 6502:Alpha2 6502:Alpha1 6502:DP4 6502:DP3 6502:DP2 6502:v1.1a 6502:v1.0.0

14 Commits
Alpha1 ... ver-1

Author SHA1 Message Date
David Schmenk
7aaba1f9ef Update notes to 1.2 2018-05-11 06:17:28 -07:00
David Schmenk
a61da48e5d Update README.md 2018-05-11 06:16:07 -07:00
David Schmenk
45489b3ab8 Update image 2018-05-07 12:41:06 -07:00
David Schmenk
81e40c4c7f Fix unhandled IRQ on IIGS 2018-05-07 10:23:31 -07:00
David Schmenk
6ff3cc2673 Update images 2018-05-02 18:26:37 -07:00
David Schmenk
f964099c24 Stop continuous events when mouse button pressed 2018-05-02 13:27:58 -07:00
David Schmenk
54ecb3eec7 Generate mouse event on button state change 2018-05-02 13:18:00 -07:00
David Schmenk
bb97fe6353 Fix infunc for asm defs 2018-05-01 07:39:51 -07:00
David Schmenk
9e441de1c2 Version 1.2 with IRQ fixes and mouse module 2018-04-29 19:13:03 -07:00
David Schmenk
3d337f4fa8 Change TFTPD text file EOL strategy 2018-04-29 14:50:39 -07:00
David Schmenk
15e4013f97 Fix tftp xlte bug when writing text files. Bunp version 2018-04-29 07:25:43 -07:00
David Schmenk
5f1656b6a1 Backport some fixes from V2 2018-04-27 14:10:26 -07:00
David Schmenk
9809c2b5b2 Add TFTPD to release 1 2018-04-23 13:47:42 -07:00
David Schmenk
c0ddb5d197 Add TFTPD to release 1 2018-04-23 13:46:08 -07:00
127 changed files with 7287 additions and 30037 deletions
Expand all files Collapse all files

157
LICENSE.md
View File

@@ -1,157 +0,0 @@
### 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.

674
LICENSE.txt Executable file
View File

@@ -0,0 +1,674 @@
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>.

BIN
PLASMA-BLD1.PO Normal file
View File

Binary file not shown.

BIN
images/apple/PLASMA2-INET.PO → PLASMA-DEM1.PO
View File

Binary file not shown.

BIN
images/apple/PLASMA2-FPSOS.PO → PLASMA-SOS1.PO
View File

Binary file not shown.

BIN
PLASMA-SYS1.PO Normal file
View File

Binary file not shown.

0
images/c64/PLASMA.D64 → PLASMA.D64
View File

109
README.md
View File

@@ -1,8 +1,3 @@
# 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)
@@ -11,7 +6,7 @@
![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**ll
PLASMA: **P**roto **L**anguage **A**s**S**e**M**bler for **A**pple
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.
@@ -99,7 +94,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](https://github.com/dschmenk/PLASMA/wiki/PLASMA-Byte-Codes)
- [The Bytecodes](#the-bytecodes)
- [Apple 1 PLASMA](#apple-1-plasma)
- [Apple II PLASMA](#apple-ii-plasma)
- [Apple /// PLASMA](#apple--plasma)
@@ -111,7 +106,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 [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.
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.
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:
@@ -523,7 +518,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 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.
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.
```
when keypressed
@@ -1144,7 +1139,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 must be a constant.
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.
```
when key
@@ -1167,6 +1162,26 @@ 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
@@ -1298,6 +1313,80 @@ 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.

BIN
SANDBOX.PO Executable file
View File

Binary file not shown.

55
doc/Editor.md
View File

@@ -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,23 +18,22 @@ 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.
@@ -53,17 +52,13 @@ EDIT COMMANDS:
CTRL-Q = JUMP BEGIN
CTRL-E = JUMP END
CTRL-D = DELETE CHAR
CTRL-B = BEGIN SELECTION
CTRL-C = COPY SELECTION INTO CLIPBOARD
CTRL-X = CUT SELECTION INTO CLIPBOARD
CTRL-V = PASTE CLIPBOARD
CTRL-X = DELETE/CUT LINE
CTRL-V = COPY DELETED LINE
CTRL-O = OPEN NEW LINE
CTRL-F = OPEN A FOLLOWING NEW LINE
CTRL-T = JOIN LINES
CTRL-Y = TOGGLE INSERT/OVERWRITE
CTRL-B = 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
@@ -83,7 +78,7 @@ EDIT COMMANDS:
APPLE ][, UPPER AND LOWER CASE
ENTRY WORKS AS EXPECTED.
ESC T C = FORCE LOWER-CASE CHARS
CTRL-C = FORCE LOWER-CASE CHARS
If you have a lower-case character
generator installed, you can force
@@ -98,12 +93,11 @@ EDIT COMMANDS:
The 'SOLID-APPLE' key will modify
theese keys:
SA-RETURN = OPEN FOLLOWING LINE
SA-RETURN = OPEN 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:
-------------------
@@ -112,12 +106,11 @@ EDIT COMMANDS:
these keys:
OA-\ = DELETE CHAR LEFT
OA-RETURN = OPEN FOLLOWING LINE
OA-RETURN = OPEN 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:
@@ -131,9 +124,9 @@ EDIT COMMANDS:
OA-7 = JUMP BEGIN
OA-1 = JUMP END
OA-5 = DELETE CHAR
OA-- = CUT SELECTION INTO CLIPBOARD
OA-0 = PASTE CLIPBOARD
OA-ENTER = OPEN FOLLOWING LINE
OA-- = DELETE/CUT LINE
OA-0 = COPY DELETED LINE
OA-ENTER = OPEN NEW LINE
OA-. = TOGGLE INSERT/OVERWRITE
COMMAND MODE:
@@ -149,9 +142,5 @@ 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

276
doc/Version 2.0.md
View File

@@ -1,276 +0,0 @@
# 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

BIN
images/apple/PLASMA2-BLD.PO
View File

Binary file not shown.

BIN
images/apple/PLASMA2-DEM.PO
View File

Binary file not shown.

BIN
images/apple/PLASMA2-SYS.PO
View File

Binary file not shown.

BIN
images/apple/PLASMA2.2mg
View File

Binary file not shown.

BIN
images/apple/SFM.PO
View File

Binary file not shown.

BIN
images/apple/TFTPD.PO
View File

Binary file not shown.

BIN
images/apple/apple3.hd
View File

Binary file not shown.

14
src/inc/cmdsys.plh
View File

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

16
src/inc/dgr.plh Normal file
View File

@@ -0,0 +1,16 @@
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

15
src/inc/dgrlib.plh
View File

@@ -1,15 +0,0 @@
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

24
src/inc/fileio.plh
View File

@@ -18,27 +18,7 @@ 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
@@ -57,9 +37,7 @@ import fileio
word getpfx
word setpfx
word getfileinfo
word setfileinfo
word geteof
word seteof
word iobufalloc
word open
word close
@@ -67,9 +45,7 @@ import fileio
word write
word create
word destroy
word rename
word newline
word online
word readblock
word writeblock
end

15
src/inc/grlib.plh
View File

@@ -1,15 +0,0 @@
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

3
src/inc/hgrfont.plh
View File

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

24
src/inc/hgrlib.plh
View File

@@ -1,24 +0,0 @@
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

19
src/inc/hgrsprite.plh
View File

@@ -1,19 +0,0 @@
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

13
src/inc/hgrtile.plh
View File

@@ -1,13 +0,0 @@
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

32
src/inc/int32.plh
View File

@@ -1,32 +0,0 @@
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

6
src/inc/lines.plh
View File

@@ -1,6 +0,0 @@
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

3
src/inc/lz4.plh
View File

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

5
src/inc/matchfiles.plh
View File

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

1831
src/libsrc/apple/cleanjit.pla
View File

File diff suppressed because it is too large Load Diff

1
src/libsrc/apple/conio.pla
View File

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

322
src/libsrc/apple/dgrlib.pla → src/libsrc/apple/dgr.pla
View File

@@ -1,4 +1,5 @@
include "inc/cmdsys.plh"
sysflags restxt1|restxt2|resxtxt1|resxtxt2 // Reserve all text pages
//
// Apple II hardware constants.
//
@@ -23,15 +24,13 @@ const page2 = 1
//
// Screen row address arrays.
//
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
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
//
// Color mapping.
//
@@ -50,13 +49,13 @@ end
//
// Plot pixel
//
export asm dgrPlot(x, y)#0
; GET ROW BUFFER ADDRESSES
LDA $3000
STA SRCL
LDA $3001
STA SRCH
export asm dgrPlot(buff, x, y)#0
; GET BUFFER ADDRESS
STX ESP
LDA ESTKL+2,X
STA SRCL
LDA ESTKH+2,X
STA SRCH
LDA ESTKL,X ; Y COORD
AND #$FE
TAY
@@ -77,21 +76,22 @@ asm _dgrPlotPix
LDX ESP
INX
INX
INX
RTS
end
//
// Plot horizontal row of pixels
//
export asm dgrHLin(x1, x2, y)#0
; GET ROW BUFFER ADDRESSES
LDA $3000
STA SRCL
LDA $3001
STA SRCH
export asm dgrHLin(buff, x1, x2, y)#0
; GET BUFFER ADDRESS
STX ESP
LDA ESTKL+3,X
STA SRCL
LDA ESTKH+3,X
STA SRCH
LDA ESTKL+1,X ; X2 COORD
STA TMPH
LDA ESTKL+0,X ; Y COORD
LDA ESTKL,X ; Y COORD
AND #$FE
TAY
LDA (SRC),Y
@@ -102,7 +102,7 @@ export asm dgrHLin(x1, x2, y)#0
LDY ESTKL+2,X ; X1 COORD
PHP
SEI
- LDA ESTKL+0,X ; Y COORD
- LDA ESTKL,X
LSR
TYA
LDX GCLR ; COLOR
@@ -119,19 +119,20 @@ asm _dgrHLinPix
INX
INX
INX
INX
RTS
end
//
// Plot horizontal row of pixels
//
export asm dgrVLin(y1, y2, x)#0
; GET ROW BUFFER ADDRESSES
LDA $3000
STA SRCL
LDA $3001
STA SRCH
export asm dgrVLin(buff, x, y1, y2)#0
; GET BUFFER ADDRESS
STX ESP
LDA ESTKL+2,X ; Y1 COORD
LDA ESTKL+3,X
STA SRCL
LDA ESTKH+3,X
STA SRCH
LDA ESTKL+1,X ; Y1 COORD
PHP
SEI
- AND #$FE
@@ -141,38 +142,38 @@ export asm dgrVLin(y1, y2, x)#0
INY
LDA (SRC),Y
STA GBASH
LDA ESTKL+2,X
LDA ESTKL+1,X
LSR
LDA ESTKL+0,X ; X COORD
LDA ESTKL+2,X ; X COORD
LDX GCLR ; COLOR
end
asm _dgrVLinPix
JSR $3000 ; _dgrSetPix
LDX ESP
INC ESTKL+2,X ; Y1 COORD
LDA ESTKL+2,X
CMP ESTKL+1,X ; Y2 COORD
INC ESTKL+1,X ; Y1 COORD
LDA ESTKL+1,X
CMP ESTKL,X ; Y2 COORD
BCC -
BEQ -
PLP
INX
INX
INX
INX
RTS
end
//
// Draw sprite
//
export asm dgrBLT(x, y, width, height, src)#0
; GET ROW BUFFER ADDRESSES
LDA $3000
STA DSTL
LDA $3001
STA DSTH
export asm dgrBLT(buff, x, y, width, height, src)#0
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 ++++
@@ -196,8 +197,9 @@ export asm dgrBLT(x, y, width, height, src)#0
CLC
ADC ESTKL+2,X ; WIDTH
STA SRCL
BCC +++
INC SRCH
LDA SRCH
ADC #$00
STA SRCH
BNE +++
+ AND #$FE
TAY
@@ -243,6 +245,7 @@ asm _dgrBLTPix
INX
INX
INX
INX
RTS
end
//
@@ -323,17 +326,16 @@ end
//
// Draw 8x8 tile (forced to 2x2 block address)
//
export asm dgrTile(x, y, src)#0
; GET ROW BUFFER ADDRESSES
LDA $3000
STA DSTL
LDA $3001
STA DSTH
export asm dgrTile(buff, x, y, src)#0
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 ++++
@@ -355,8 +357,9 @@ export asm dgrTile(x, y, src)#0
LDA SRCL ; SKIP TO NEXT ROW
ADC #$07 ; CARRY = 1
STA SRCL
BCC +++
INC SRCH
LDA SRCH
ADC #$00
STA SRCH
BNE +++
+ AND #$FE
TAY
@@ -389,9 +392,9 @@ export asm dgrTile(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
@@ -402,6 +405,7 @@ export asm dgrTile(x, y, src)#0
CMP ESTKH+1,X ; Y2 COORD
BCC -
++++ INX
INX
INX
INX
RTS
@@ -409,17 +413,22 @@ end
//
// Draw a string of tiles
//
export asm dgrTileStr(x, y, tilestr, strlen, tilebuff)#0
export asm dgrTileStr(buff, x, y, tilestr, strlen, tilebuff)#0
- DEX
DEX
DEX
LDA ESTKL+7,X ; X COORD
DEX
LDA ESTKL+9,X ; BUFF
STA ESTKL+3,X
LDA ESTKH+9,X
STA ESTKH+3,X
LDA ESTKL+8,X ; X COORD
STA ESTKL+2,X
LDA ESTKL+6,X ; Y COORD
LDA ESTKL+7,X ; Y COORD
STA ESTKL+1,X
LDA ESTKL+3,X ; TILE
LDA ESTKL+4,X ; TILE
STA ESTKL,X
LDA ESTKH+3,X ; TILE
LDA ESTKH+4,X ; TILE
STA ESTKH,X
end
asm _dgrTileTile
@@ -432,17 +441,16 @@ asm _dgrTileTile
STA ESTKL+4,X
DEC ESTKL+1,X ; DEC STRLEN
BNE -
+ INX
INX
INX
INX
INX
+ TXA
CLC
ADC #6
TAX
RTS
end
//
// Fill a buffer with tiles
//
export asm dgrFill(x, y, tile)#0
export asm dgrFill(buff, x, y, tile)#0
LDA ESTKL+2,X
AND #$0F
STA ESTKL+2,X
@@ -461,13 +469,18 @@ export asm dgrFill(x, y, tile)#0
- DEX
DEX
DEX
LDA ESTKL+5,X ; X COORD
DEX
LDA ESTKL+7,X ; BUFF
STA ESTKL+3,X
LDA ESTKH+7,X
STA ESTKH+3,X
LDA ESTKL+6,X ; X COORD
STA ESTKL+2,X
LDA ESTKL+4,X ; Y COORD
LDA ESTKL+5,X ; Y COORD
STA ESTKL+1,X
LDA ESTKL+3,X ; TILE
LDA ESTKL+4,X ; TILE
STA ESTKL,X
LDA ESTKH+3,X ; TILE
LDA ESTKH+4,X ; TILE
STA ESTKH,X
end
asm _dgrFillTile
@@ -489,10 +502,11 @@ asm _dgrFillTile
INX
INX
INX
INX
RTS
end
//
// Wait for VLB - Only IIe/IIGS.
// Wait for VLB - Shouldn't work on //c, but seems to.
//
asm vlbWait#0
- LDA $C019
@@ -501,59 +515,23 @@ 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
//
// wait for VBL:
// - bit $C019
// bpl -
// lda $C070 ; $c019 bit 7 is sticky, reset it
// Set double lores graphics, return draw buffer
//
// 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)
export def dgrMode#1
^showlores
^showfull
^showgraphics
^showpage1
^ena80 = 0
^show80 = 0
^an3on
return 1
end
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
//
//
// Set text mode
//
export def txtMode#0
^showtext
^showpage1
^ena80 = 0
@@ -561,7 +539,6 @@ export def dgrMode(mode)#1
^mapmain = 0
^an3off
call($FC58, 0, 0, 0, 0) // home()
return 0
end
//
// Set display page, return other page
@@ -571,15 +548,6 @@ 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
//
@@ -587,6 +555,91 @@ 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
@@ -608,19 +661,6 @@ _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

138
src/libsrc/apple/fileio.pla
View File

@@ -26,9 +26,7 @@ struc t_fileio
word getpfx
word setpfx
word getfileinfo
word setfileinfo
word geteof
word seteof
word iobufalloc
word open
word close
@@ -36,22 +34,20 @@ 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), 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)
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)
//
// Exported function table.
//
word fileio[]
word = @a2getpfx, @a23setpfx, @a2getfileinfo, @a2setfileinfo, @a23geteof, @a23seteof, @a2iobufs, @a2open, @a2close
word = @a23read, @a2write, @a2create, @a23destroy, @a23rename
word = @a2newline, @a2online, @a2readblock, @a2writeblock
word = @a2getpfx, @a23setpfx, @a2getfileinfo, @a23geteof, @a2iobufs, @a2open, @a2close
word = @a23read, @a2write, @a2create, @a23destroy
word = @a2newline, @a2readblock, @a2writeblock
//
// SOS/ProDOS error code
//
@@ -121,53 +117,17 @@ def a3getfileinfo(path, fileinfo)
perr = syscall($C4, @params)
return perr
end
def a1setfileinfo(path, fileinfo)
perr = $01
return perr
def a1geteof(refnum)
return 0
end
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)
def a23geteof(refnum)
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)
@@ -298,7 +258,7 @@ def a3write(refnum, buff, len)
params:2 = buff
params:4 = len
perr = syscall($CB, @params)
return perr ?? 0 :: len
return perr
end
def a1create(path, type, aux)
return perr
@@ -311,7 +271,7 @@ def a2create(path, type, aux)
params.3 = $C3
params.4 = type
params:5 = aux
params.7 = type == $0F ?? $0D :: $01
params.7 = $1
params:8 = 0
params:10 = 0
perr = syscall($C0, @params)
@@ -324,15 +284,13 @@ def a3create(path, type, aux)
params.0 = 3
params:1 = path
params:3 = @options
params.5 = 4
params.5 = 3
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)
@@ -343,19 +301,6 @@ 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
@@ -379,57 +324,6 @@ 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
@@ -465,14 +359,12 @@ 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
@@ -480,9 +372,7 @@ 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
@@ -490,9 +380,7 @@ 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

493
src/libsrc/apple/grlib.pla
View File

@@ -1,493 +0,0 @@
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

140
src/libsrc/apple/hgrfont.pla
View File

@@ -1,140 +0,0 @@
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

1295
src/libsrc/apple/hgrlib.pla
View File

File diff suppressed because it is too large Load Diff

365
src/libsrc/apple/hgrsprite.pla
View File

@@ -1,365 +0,0 @@
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

435
src/libsrc/apple/hgrtile.pla
View File

@@ -1,435 +0,0 @@
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

56
src/libsrc/apple/jit.pla
View File

@@ -1,56 +0,0 @@
//
// 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

67
src/libsrc/apple/jit16.pla
View File

@@ -1,67 +0,0 @@
//
// 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

117
src/libsrc/apple/matchfiles.pla
View File

@@ -1,117 +0,0 @@
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

3
src/libsrc/apple/mouse.pla
View File

@@ -270,7 +270,7 @@ CHKSIG: LDY #$05
LDA (TMPTR),Y
CMP #$01
BNE :+
INY
LDY #$0C
TXA ; LOOK FOR MATCHING ID
CMP (TMPTR),Y
BNE :+
@@ -283,6 +283,7 @@ CHKSIG: LDY #$05
LDA TMPTR+1
CMP #$C8
BCC CHKSIG
SEC
RTS
;*

181
src/libsrc/apple/shrlib.pla
View File

@@ -1,181 +0,0 @@
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

2
src/libsrc/apple/sndseq.pla
View File

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

8
src/utilsrc/apple/sos.pla → src/libsrc/apple/sos.pla
View File

@@ -35,10 +35,10 @@ asm sosexec(addr)#0
STA SRCL
BCC +
INC SRCH
+; LDA SRCL
CMP DSTL
LDA SRCH
SBC DSTH
+ LDA DSTL
CMP SRCL
LDA DSTH
SBC SRCH
BCC REVCPY
;
; FORWARD COPY

250
src/libsrc/apple/uthernet.pla
View File

@@ -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,14 +22,13 @@ 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
//
@@ -38,155 +37,156 @@ 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)#0
LDA ESTKL,X
asm _pokeiow(val)
LDA ESTKL,X
end
asm _pokeiowl
STA $C000
LDA ESTKH,X
STA $C000
LDA ESTKH,X
end
asm _pokeiowh
STA $C000
INX
RTS
STA $C000
RTS
end
//
// PEEK BYTE FROM I/O SPACE
// _peekio()
//
asm _peekio#1
DEX
asm _peekio
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#1
DEX
asm _peekiow
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)#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
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
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)#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
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 -
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)#0
def pokeiow(io, data)
_pokeiowl.1 = io
_pokeiowh.1 = io+1
_pokeiow(data)
return _pokeiow(data)
end
def peekio(io)#1
def peekio(io)
_peekiol.1 = io
return _peekio()
end
def peekiow(io)#1
def peekiow(io)
_peekiowl.1 = io
_peekiowh.1 = io+1
return _peekiow()
end
def pokepreg(reg, data)#0
def pokepreg(reg, data)
pokeiow(pregidx, reg)
pokeiow(pregdata, data)
return pokeiow(pregdata, data)
end
def peekpreg(reg)#1
def peekpreg(reg)
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)#1
def pokefrmlen(len)
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#1
def peekfrmlen
word len
len = 0
if peekiow(isq) & $3F == $04
@@ -214,37 +214,35 @@ end
// Identify Uthernet card and initialize
//
for slot = $90 to $F0 step $10
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
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
fin
fin
next

474
src/libsrc/apple/uthernet2.pla
View File

@@ -71,11 +71,10 @@ const WIZ_RXMEM3 = $7800
//
// Wiznet indirect registers
//
word[] rom
word saveidx
byte regidx
byte regdata
byte slot
byte slot
word saveidx
byte regidx
byte regdata
//
// Wiznet MAC address
//
@@ -138,15 +137,16 @@ 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] wizChannel[MAX_WIZ_CHANNELS]
byte[t_channel * MAX_WIZ_CHANNELS] wizChannel
//
// 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,122 +239,118 @@ end
// POKE WORD TO I/O SPACE
// Note: Big Endian format
//
asm _pokeiow(val)#0
LDA ESTKH,X
asm _pokeiow(val)
LDA ESTKH,X
end
asm _pokeiowl
STA $C000
LDA ESTKL,X
STA $C000
LDA ESTKL,X
end
asm _pokeiowh
STA $C000
INX
RTS
STA $C000
RTS
end
//
// POKE BYTE TO I/O SPACE
//
asm _pokeio(val)#0
LDA ESTKL,X
asm _pokeio(val)
LDA ESTKL,X
end
asm _pokeiol
STA $C000
INX
RTS
STA $C000
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)#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
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
end
asm _pokedata
STA $C000
INY
BNE +
INC SRCH
+ DEC ESTKL,X
BNE POKELP
DEC ESTKH,X
BNE POKELP
INX
INX
RTS
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(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
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
end
asm _peekdata
PEEKLP LDA $C000
STA (DST),Y
INY
BNE +
INC DSTH
+ DEC ESTKL,X
BNE PEEKLP
DEC ESTKH,X
BNE PEEKLP
INX
INX
RTS
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)#0
def pokeiow(io, data)
_pokeiowl.1 = io
_pokeiowh.1 = io+1
_pokeiow(data)
return _pokeiow(data)
end
def pokeio(io, data)#0
def pokeio(io, data)
_pokeiol.1 = io
_pokeio(data)
return _pokeio(data)
end
def peekio(io)
_peekiol.1 = io
@@ -365,26 +361,26 @@ def peekiow(io)
_peekiowh.1 = io+1
return _peekiow()
end
def pokereg(reg, data)#0
def pokereg(reg, data)
_pokeiow(reg)
_pokeio(data)
return _pokeio(data)
end
def peekreg(reg)
_pokeiow(reg)
return _peekio()
end
def pokeregs(reg, buf, len)#0
def pokeregs(reg, buf, len)
_pokeiow(reg)
pokedata(buf, len)
return pokedata(buf, len)
end
def peekregs(reg, buf, len)#0
def peekregs(reg, buf, len)
_pokeiow(reg)
peekdata(buf, len)
return peekdata(buf, len)
end
def pokeregw(reg, dataw)#0
def pokeregw(reg, dataw)
_pokeiow(reg)
_pokeio(dataw.1)
_pokeio(dataw.0)
return _pokeio(dataw.0)
end
def peekregw(reg)
word dataw
@@ -419,7 +415,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
//
@@ -474,9 +470,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_SnCR, $01) // OPEN
pokereg(wiz=>channel_regs + WIZ_SnMR, $02) // UDP protocol
pokereg(wiz=>channel_regs + WIZ_SnCR, $01) // OPEN
return wiz
end
//
@@ -484,14 +480,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
@@ -512,8 +508,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
//
@@ -523,8 +519,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
@@ -541,9 +537,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
@@ -623,7 +619,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
//
@@ -638,9 +634,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
@@ -674,10 +670,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
@@ -702,7 +698,7 @@ def wizServiceIP
wizregs = wiz=>channel_regs
wizdata = wiz=>channel_rxmem
sir = peekreg(wizregs + WIZ_SnIR)
pokereg(wizregs + WIZ_SnIR, sir) // Clear SnIR
pokereg(wiz=>channel_regs + WIZ_SnIR, sir) // Clear SnIR
when wiz->channel_proto
is WIZ_PROTO_UDP
if sir & $04
@@ -739,63 +735,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)
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)
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
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
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
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
//
@@ -843,77 +839,71 @@ end
// Identify Uthernet II card and initialize
//
for slot = $90 to $F0 step $10
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
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
fin
pokeio(slot, regdata) // Restore register
fin
pokeio(slot, regdata) // Restore register
fin
next
//

1
src/libsrc/args.pla
View File

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

13
src/libsrc/dhcp.pla
View File

@@ -3,7 +3,6 @@
//
include "inc/cmdsys.plh"
include "inc/inet.plh"
sysflags nojitc // No need to JITC this temp loaded module
//
// Needed to init subnet
//
@@ -138,7 +137,7 @@ end
def recvDHCP(remip, remport, pkt, len, param)
word servopts, maskopts, gwopts, dnsopts
//puts("recvDHCP: ");putip(remip);putc(':');puti(remport);putln
//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]
@@ -156,10 +155,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
@@ -188,7 +187,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
//
@@ -207,17 +206,17 @@ repeat
optsSRV = 255
DHCP.dhcp_secs.1 = retry
iNet:sendUDP(portDHCP, 0, DHCP_SERVER_PORT, @DHCP, @optsSRV - @DHCP + 1)
for timeout = 0 to 4000
for timeout = 0 to 1000
iNet:serviceIP()
if optsOP.2 == DHCP_ACK
break
fin
next
retry++
retry = retry + 1
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

10
src/libsrc/etherip.pla
View File

@@ -52,6 +52,7 @@ const IP_PROTO_TCP = $06
//
// ICMP type/codes
//
const IP_PROTO_ICMP = 1
const ICMP_ECHO_REQST = 8
const ICMP_ECHO_REPLY = 0
//
@@ -100,7 +101,7 @@ const ARP_REQST = $0100 // BE format
const ARP_REPLY = $0200 // BE format
struc t_arp
word arp_hw
word arp_prot
word arp_proto
byte arp_hlen
byte arp_plen
word arp_op
@@ -154,8 +155,8 @@ struc t_notify
word notify_func
word notify_parm
end
byte[t_notify] portsUDP[MAX_UDP_NOTIFIES]
byte[t_notify] portsTCP[MAX_TCP_NOTIFIES]
byte[t_notify * MAX_UDP_NOTIFIES] portsUDP
byte[t_notify * MAX_TCP_NOTIFIES] portsTCP
//
// Service ICMP hook
//
@@ -378,14 +379,12 @@ 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
//
@@ -587,6 +586,7 @@ def getEtherHA(ha)
if ha; memcpy(ha, @myMAC, MAC_SIZE); fin
return MAC_SIZE
end
//
// Fill in iNet class
//

63
src/libsrc/inet.pla
View File

@@ -33,7 +33,7 @@ end
//
// External interface to net class. Must be first.
//
res[t_inet] iNet
export byte[t_inet] iNet
//
// List of loadable network device drivers
//
@@ -54,6 +54,12 @@ 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
//
@@ -81,14 +87,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
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
loop
if ^ipstr <> '.' and ipstr < endstr
return 0
fin
next
return i == 3
end
@@ -99,11 +105,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
@@ -148,7 +154,7 @@ def recvDNS(remip, remport, pkt, len, ipaddr)
resptr = resptr + 8
//dumpbytes(resptr + 2, ^(resptr + 1))
resptr = resptr + 2 + ^(resptr + 1); putln
r--
r = r - 1
loop
fin
stateDNS = DNS_ANSWER
@@ -165,7 +171,7 @@ def iNetResolve(namestr, ipaddr)
//
// Query Domain Name Server for address
//
dnspkt = heapalloc(^namestr + t_dnshdr + 8) // Use heap as working DNS query packet
dnspkt = heapmark // Use heap as working DNS query packet
msgptr = dnspkt
msgptr=>dnsID = $BEEF
msgptr=>dnsCode = $0001 // RD (Recursion Desired)
@@ -175,8 +181,9 @@ 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
//
@@ -197,27 +204,29 @@ 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
//
// Get an IP address
//
cmdsys:modexec("DHCP")
iNet:resolveIP = @iNetResolve
return @iNet
break
fin
driver = driver + ^driver + 1
loop
puts("No network adapters found.\n")
return NULL
if !^driver
return 0
fin
//
// Get an IP address
//
cmdsys:modexec("DHCP")
iNet:resolveIP = @iNetResolve
return @iNet
end
//
// Fill iNet class
//

682
src/libsrc/int32.pla
View File

@@ -1,682 +0,0 @@
//
// 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

1321
src/libsrc/jit16core.pla
View File

File diff suppressed because it is too large Load Diff

1548
src/libsrc/jitcore.pla
View File

File diff suppressed because it is too large Load Diff

506
src/libsrc/lines.pla
View File

@@ -1,506 +0,0 @@
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

91
src/libsrc/lz4.pla
View File

@@ -1,91 +0,0 @@
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

5
src/libsrc/memmgr.pla
View File

@@ -544,7 +544,7 @@ export def hmemNew(size)
//
// Allocate 3/4 of available heap on 128K machine, 1/2 on 64K machine
//
poolsize = (heapavail >> 1) & $7FFF
poolsize = ((@page - heapmark) >> 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 = heapalloc(t_initdata) // Use data on heap for initialization
initdata = heapmark // Use data at top of heap for initialization
initdata=>volparms.0 = 2
initdata=>volparms.1 = 0
initdata=>volparms:2 = sysbuf
@@ -733,6 +733,5 @@ repeat
fin
until !initdata->filecnt
fileio:close(initdata->catref)
heaprelease(initdata)
//puts(@swapvol); putln
done

4
src/libsrc/sane.pla
View File

@@ -734,21 +734,19 @@ def loadcode(codefile)
ref = fileio:open(strcat(strcpy(@filepath, cmdsys:syspath), codefile))
//puts("ref = "); prbyte(ref); puts(" perr = "); prbyte(perr); putln
if ref
pcode = heapalloc(512)
pcode = heapmark
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

993
src/libsrc/wiznet.pla Normal file
View File

@@ -0,0 +1,993 @@
//
// 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

214
src/makefile
View File

@@ -4,33 +4,16 @@ PLVM = plvm
PLVMZP_APL = vmsrc/apple/plvmzp.inc
PLVM01 = rel/apple/A1PLASMA\#060280
PLVM02 = rel/apple/PLASMA.SYSTEM\#FF2000
PLVMJIT = rel/apple/PLVM.128\#FF2000
PLVM802 = rel/apple/PLVM16\#FF2000
PLVM802 = rel/apple/PLASMA16.SYSTEM\#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/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
ROD = rel/ROD\#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
@@ -40,8 +23,6 @@ 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
@@ -49,8 +30,6 @@ 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
@@ -59,16 +38,8 @@ INET = rel/INET\#FE1000
DHCP = rel/DHCP\#FE1000
HTTPD = rel/HTTPD\#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
DGR = rel/apple/DGR\#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
@@ -76,9 +47,6 @@ 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
@@ -109,8 +77,7 @@ TXTTYPE = .TXT
#SYSTYPE = \#FF2000
#TXTTYPE = \#040000
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)
apple: $(PLVMZP_APL) $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVM802) $(PLVM03) $(CMD) $(PLASMAPLASM) $(CODEOPT) $(ARGS) $(MEMMGR) $(MEMTEST) $(FIBER) $(FIBERTEST) $(LONGJMP) $(ED) $(MON) $(SOS) $(ROD) $(SIEVE) $(MOUSE) $(UTHERNET2) $(UTHERNET) $(ETHERIP) $(INET) $(DHCP) $(HTTPD) $(TFTPD) $(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)
-rm vmsrc/plvmzp.inc
c64: $(PLVMZP_C64) $(PLASM) $(PLVM) $(PLVMC64)
@@ -119,8 +86,10 @@ c64: $(PLVMZP_C64) $(PLASM) $(PLVM) $(PLVMC64)
all: apple c64
clean:
-rm *FE1000 *FF2000 $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVMJIT) $(PLVM03)
-rm -rf rel
-rm *FE1000 *FF2000 $(PLASM) $(PLVM) $(PLVM01) $(PLVM02) $(PLVM03)
-rm rel/*
-rm rel/apple/*
-rm rel/c64/*
-rm samplesrc/*.o samplesrc/*~ samplesrc/*.a
-rm toolsrc/*.o toolsrc/*~ toolsrc/*.a
-rm toolsrc/apple/*.o toolsrc/apple/*~ toolsrc/apple/*.a
@@ -131,9 +100,7 @@ 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 utilsrc/*.o utilsrc/*~ utilsrc/*.a
-rm utilsrc/apple/*.o utilsrc/apple/*~ utilsrc/apple/*.a
-rm utilsrc/c64/*.o utilsrc/c64/*~ utilsrc/c64/*.a
-rm libsrc/*.o libsrc/*~ libsrc/*.a
#
# PLASMA compiler: plasm
@@ -185,38 +152,18 @@ $(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/sossys.a: vmsrc/apple/sossys.pla $(PLASM)
./$(PLASM) -AOW < vmsrc/apple/sossys.pla > vmsrc/apple/sossys.a
vmsrc/apple/soscmd.a: vmsrc/apple/soscmd.pla $(PLASM)
./$(PLASM) -AOW < vmsrc/apple/soscmd.pla > vmsrc/apple/soscmd.a
$(PLVM03): vmsrc/apple/plvm03.s vmsrc/apple/sossys.a
$(PLVM03): vmsrc/apple/plvm03.s vmsrc/apple/soscmd.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
#
@@ -231,10 +178,6 @@ $(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
@@ -251,10 +194,6 @@ $(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
@@ -263,14 +202,6 @@ $(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
@@ -288,25 +219,13 @@ hello: samplesrc/hello.pla $(PLVM) $(PLASM)
acme --setpc 4094 -o $(HELLO) samplesrc/hello.a
./$(PLVM) HELLO
$(ROD): samplesrc/rod.pla $(PLVM02) $(PLASM)
./$(PLASM) -AMOW < samplesrc/rod.pla > samplesrc/rod.a
./$(PLASM) -AMO < 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
@@ -323,14 +242,6 @@ $(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
@@ -351,9 +262,9 @@ $(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
$(TFTPD): samplesrc/tftpd.pla $(PLVM02) $(PLASM)
./$(PLASM) -AMOW < samplesrc/tftpd.pla > samplesrc/tftpd.a
acme --setpc 4094 -o $(TFTPD) samplesrc/tftpd.a
$(MOUSE): libsrc/apple/mouse.pla $(PLVM02) $(PLASM)
./$(PLASM) -AMOW < libsrc/apple/mouse.pla > libsrc/apple/mouse.a
@@ -435,92 +346,19 @@ $(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
$(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
$(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
$(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)
$(DGRTEST): samplesrc/dgrtest.pla $(PLVM02) $(PLASM)
./$(PLASM) -AMOW < samplesrc/dgrtest.pla > samplesrc/dgrtest.a
acme --setpc 4094 -o $(DGRTEST) samplesrc/dgrtest.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
$(MON): samplesrc/mon.pla $(PLVM02) $(PLASM)
./$(PLASM) -AMOW < samplesrc/mon.pla > samplesrc/mon.a
acme --setpc 4094 -o $(MON) samplesrc/mon.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

322
src/mkrel
View File

@@ -1,251 +1,115 @@
cp rel/apple/CMD#061000 prodos/CMD.BIN
cp rel/apple/CMD128#061000 prodos/CMD128.BIN
cp rel/apple/CMD#061000 prodos/CMD.BIN
cp rel/apple/PLASMA.SYSTEM#FF2000 prodos/PLASMA.SYSTEM.SYS
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
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
rm -rf prodos/sys
mkdir prodos/sys
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 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/MOUSE#FE1000 prodos/sys/MOUSE.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 ../sysfiles/FP6502.CODE#060000 prodos/sys/FP6502.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
cp ../sysfiles/ELEMS.CODE#060000 prodos/sys/ELEMS.CODE.BIN
rm -rf prodos/demos
mkdir prodos/demos
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
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
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/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 samplesrc/index.html prodos/demos/net/INDEX.HTML.TXT
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/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 rel/apple/GFXDEMO#FE1000 prodos/demos/apple3/GFXDEMO.REL
cp samplesrc/APPLE3.PIX#060000 prodos/demos/apple3/APPLE3.PIX.BIN
mkdir prodos/demos/net
cp rel/HTTPD#FE1000 prodos/demos/net/HTTPD.REL
cp samplesrc/index.html prodos/demos/net/INDEX.HTML.TXT
cp rel/TFTPD#FE1000 prodos/sys/TFTPD.REL
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
rm -rf prodos/bld
mkdir prodos/bld
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
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 samplesrc/mousetest.pla prodos/bld/MOUSETEST.PLA.TXT
mkdir prodos/bld/inc
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 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/mouse.plh prodos/bld/inc/MOUSE.PLH.TXT
cp vmsrc/apple/plvmzp.inc prodos/bld/inc/PLVMZP.INC.TXT

82
src/opstat
View File

@@ -1,82 +0,0 @@
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

78
src/samplesrc/dgrtest.pla
View File

@@ -1,7 +1,4 @@
include "inc/cmdsys.plh"
include "inc/dgrlib.plh"
include "inc/lines.plh"
sysflags restxt1|restxt2|resxtxt1|resxtxt2 // Reserve all text pages
include "inc/dgr.plh"
byte[] sprite1 = $80,$80,$00,$00,$00,$00,$80,$80
byte[] = $80,$00,$0A,$0A,$0A,$0A,$00,$80
@@ -21,45 +18,42 @@ 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(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)
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
end
dgrTest

66
src/samplesrc/grtest.pla
View File

@@ -1,66 +0,0 @@
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

56
src/samplesrc/hgr1test.pla Normal file
View File

@@ -0,0 +1,56 @@
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

80
src/samplesrc/hgrtest.pla
View File

@@ -1,80 +0,0 @@
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

72
src/samplesrc/int32test.pla
View File

@@ -1,72 +0,0 @@
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

107
src/samplesrc/lz4cat.pla
View File

@@ -1,107 +0,0 @@
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

0
src/utilsrc/apple/mon.pla → src/samplesrc/mon.pla
View File

10
src/samplesrc/playseq.pla
View File

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

41
src/samplesrc/primegap.pla
View File

@@ -1,41 +0,0 @@
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

7
src/samplesrc/rod.pla
View File

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

73
src/samplesrc/rogue.combat.pla
View File

@@ -162,47 +162,48 @@ 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
//
// Unlink dead enemy from entities list
// Turn player in random direction
//
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
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
fin
if player->health > e_atck
player->health = player->health - e_atck
else
player->energy = 0
player->health = 0
if enemy=>prev_other
enemy=>prev_other=>next_other = enemy=>next_other
fin
if player->energy >= 4
player->energy = player->energy - 4
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
fin
until player->health == 0 or enemy->life == 0
conio:echo(ECHO_OFF)

242
src/samplesrc/rogue.map.pla
View File

@@ -279,7 +279,7 @@ export def drawmap(xorg, yorg, viewfield, viewdir, lightdist, viewdist)
//
darkness = 1
imap = (yorg << rowshift) + xorg
if lightdist or ^(map + imap) & LIT_TILE
if ^(map + imap) & LIT_TILE or lightdist
//
// 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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 = dbeam[lightdist]+1 to dbeam[viewdist]
for l = l 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

52
src/samplesrc/rogue.pla
View File

@@ -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

637
src/samplesrc/sfm.pla
View File

@@ -1,637 +0,0 @@
//
// 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

203
src/samplesrc/sfmsprt.pla
View File

@@ -1,203 +0,0 @@
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

44
src/samplesrc/sieve.pla
View File

@@ -11,30 +11,26 @@ def beep#0
putc(7)
end
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
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
puti(count)
puts(" primes.\n")
done

6
src/samplesrc/test.pla
View File

@@ -204,9 +204,5 @@ 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 = 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
ptr = 0
done

33
src/utilsrc/tftpd.pla → src/samplesrc/tftpd.pla
View File

@@ -260,8 +260,7 @@ def writeUDP(ipsrc, portsrc, data, len, param)
end
def servUDP(ipsrc, portsrc, data, len, param)
byte info[24]
byte l, prefix[48]
when *data
is RRQ // Read request
//
@@ -318,17 +317,6 @@ def servUDP(ipsrc, portsrc, data, len, param)
// Extract filename
//
netscii, type, aux = mkProName(data + 2, @filename)
//
// Scan filename prefix and create
//
prefix[1] = filename[1]
for l = 2 to filename[0]
if filename[l] == '/'
prefix[0] = l-1
fileio:create(@prefix, $0F, $0000)
fin
prefix[l] = filename[l]
next
fileio:destroy(@filename)
if fileio:create(@filename, type, aux)
puts("Create file error: "); putb(perr); putln
@@ -354,26 +342,10 @@ def servUDP(ipsrc, portsrc, data, len, param)
return 0
end
def volumes#0
word strbuf
byte i
strbuf = heapmark()
fileio:online(0, strbuf)
for i = 0 to 15
^strbuf = ^strbuf & $0F
if ^strbuf
putc('/'); puts(strbuf); putln()
fin
strbuf = strbuf + 16
next
end
puts("TFTP Server Version 2.0 ALPHA1\n")
if !iNet:initIP()
return -1
fin
puts("Online volumes:\n"); volumes()
puts("TFTP Server Version 0.1\n")
portTFTP = iNet:openUDP(TFTP_PORT, @servUDP, 0)
//
// Alloc aligned file/io buffers
@@ -386,7 +358,6 @@ buff=>datOp = $0300 // Data op
repeat
iNet:serviceIP()
until conio:keypressed()
getc // eat keypress
done
Experpts from: RFC 1350, TFTP Revision 2, July 1992

13
src/samplesrc/tiletest.pla
View File

@@ -1,13 +0,0 @@
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

61
src/tftpbld
View File

@@ -1,61 +0,0 @@
#!/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

44
src/tftpdemos
View File

@@ -1,44 +0,0 @@
#!/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

7
src/tftprel
View File

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

8
src/tftpsane
View File

@@ -1,8 +0,0 @@
#!/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

38
src/tftpsys
View File

@@ -1,38 +0,0 @@
#!/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

14
src/tftputil
View File

@@ -1,14 +0,0 @@
#!/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

484
src/toolsrc/codegen.c
View File

@@ -89,16 +89,6 @@ 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;
@@ -392,13 +382,12 @@ void emit_header(void)
}
void emit_rld(void)
{
int i, j;
int i;
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))
{
@@ -406,14 +395,6 @@ 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.
*/
@@ -619,10 +600,8 @@ void emit_codetag(int tag)
void emit_const(int cval)
{
emit_pending_seq();
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);
if (cval == 0x0000)
printf("\t%s\t$00\t\t\t; ZERO\n", DB);
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)
@@ -635,26 +614,6 @@ 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);
@@ -671,22 +630,6 @@ 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)
@@ -715,62 +658,6 @@ 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);
@@ -860,41 +747,11 @@ void emit_globaladdr(int tag, int offset, int type)
}
void emit_indexbyte(void)
{
printf("\t%s\t$82\t\t\t; IDXB\n", DB);
printf("\t%s\t$02\t\t\t; IDXB\n", DB);
}
void emit_indexword(void)
{
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);
printf("\t%s\t$1E\t\t\t; IDXW\n", DB);
}
void emit_brfls(int tag)
{
@@ -912,52 +769,28 @@ 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_brand(int tag)
void emit_breq(int tag)
{
emit_pending_seq();
printf("\t%s\t$AC\t\t\t; BRAND\t_B%03d\n", DB, tag);
printf("\t%s\t$3C\t\t\t; BREQ\t_B%03d\n", DB, tag);
printf("\t%s\t_B%03d-*\n", DW, tag);
}
void emit_bror(int tag)
void emit_brne(int tag)
{
emit_pending_seq();
printf("\t%s\t$AE\t\t\t; BROR\t_B%03d\n", DB, tag);
printf("\t%s\t$3E\t\t\t; BRNE\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$A0\t\t\t; BRGT\t_B%03d\n", DB, tag);
printf("\t%s\t$38\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$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$3A\t\t\t; BRLT\t_B%03d\n", DB, tag);
printf("\t%s\t_B%03d-*\n", DW, tag);
}
void emit_call(int tag, int type)
@@ -1006,17 +839,11 @@ void emit_start(void)
void emit_drop(void)
{
emit_pending_seq();
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);
printf("\t%s\t$30\t\t\t; DROP\n", DB);
}
void emit_dup(void)
{
emit_pending_seq();
printf("\t%s\t$34\t\t\t; DUP\n", DB);
printf("\t%s\t$32\t\t\t; DUP\n", DB);
}
int emit_unaryop(t_token op)
{
@@ -1024,19 +851,19 @@ int emit_unaryop(t_token op)
switch (op)
{
case NEG_TOKEN:
printf("\t%s\t$90\t\t\t; NEG\n", DB);
printf("\t%s\t$10\t\t\t; NEG\n", DB);
break;
case COMP_TOKEN:
printf("\t%s\t$92\t\t\t; COMP\n", DB);
printf("\t%s\t$12\t\t\t; COMP\n", DB);
break;
case LOGIC_NOT_TOKEN:
printf("\t%s\t$80\t\t\t; NOT\n", DB);
printf("\t%s\t$20\t\t\t; NOT\n", DB);
break;
case INC_TOKEN:
printf("\t%s\t$8C\t\t\t; INCR\n", DB);
printf("\t%s\t$0C\t\t\t; INCR\n", DB);
break;
case DEC_TOKEN:
printf("\t%s\t$8E\t\t\t; DECR\n", DB);
printf("\t%s\t$0E\t\t\t; DECR\n", DB);
break;
case BPTR_TOKEN:
emit_lb();
@@ -1056,34 +883,34 @@ int emit_op(t_token op)
switch (op)
{
case MUL_TOKEN:
printf("\t%s\t$86\t\t\t; MUL\n", DB);
printf("\t%s\t$06\t\t\t; MUL\n", DB);
break;
case DIV_TOKEN:
printf("\t%s\t$88\t\t\t; DIV\n", DB);
printf("\t%s\t$08\t\t\t; DIV\n", DB);
break;
case MOD_TOKEN:
printf("\t%s\t$8A\t\t\t; MOD\n", DB);
printf("\t%s\t$0A\t\t\t; MOD\n", DB);
break;
case ADD_TOKEN:
printf("\t%s\t$82\t\t\t; ADD \n", DB);
printf("\t%s\t$02\t\t\t; ADD\n", DB);
break;
case SUB_TOKEN:
printf("\t%s\t$84\t\t\t; SUB \n", DB);
printf("\t%s\t$04\t\t\t; SUB\n", DB);
break;
case SHL_TOKEN:
printf("\t%s\t$9A\t\t\t; SHL\n", DB);
printf("\t%s\t$1A\t\t\t; SHL\n", DB);
break;
case SHR_TOKEN:
printf("\t%s\t$9C\t\t\t; SHR\n", DB);
printf("\t%s\t$1C\t\t\t; SHR\n", DB);
break;
case AND_TOKEN:
printf("\t%s\t$94\t\t\t; AND \n", DB);
printf("\t%s\t$14\t\t\t; AND\n", DB);
break;
case OR_TOKEN:
printf("\t%s\t$96\t\t\t; OR \n", DB);
printf("\t%s\t$16\t\t\t; IOR\n", DB);
break;
case EOR_TOKEN:
printf("\t%s\t$98\t\t\t; XOR\n", DB);
printf("\t%s\t$18\t\t\t; XOR\n", DB);
break;
case EQ_TOKEN:
printf("\t%s\t$40\t\t\t; ISEQ\n", DB);
@@ -1103,6 +930,12 @@ 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:
@@ -1234,11 +1067,7 @@ int crunch_seq(t_opseq **seq, int pass)
{
op->code = DUP_CODE;
opnext->code = BINARY_CODE(ADD_TOKEN);
break;
}
if (opnext->code == BINARY_CODE(MUL_TOKEN) || opnext->code == BINARY_CODE(DIV_TOKEN))
{
freeops = -2;
crunched = 1;
break;
}
}
@@ -1298,22 +1127,6 @@ 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
@@ -1394,96 +1207,32 @@ 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(ADD_TOKEN):
if (op->val == 0)
{
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)
for (shiftcnt = 0; shiftcnt < 16; shiftcnt++)
{
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++)
if (op->val == (1 << shiftcnt))
{
if (op->val == (1 << shiftcnt))
{
op->val = shiftcnt;
opnext->code = BINARY_CODE(SHL_TOKEN);
break;
}
op->val = shiftcnt;
opnext->code = BINARY_CODE(SHL_TOKEN);
break;
}
}
break;
case BINARY_CODE(DIV_TOKEN):
//
// Constant 1 handled above
//
for (shiftcnt = 1; shiftcnt < 16; shiftcnt++)
for (shiftcnt = 0; shiftcnt < 16; shiftcnt++)
{
if (op->val == (1 << shiftcnt))
{
@@ -1576,17 +1325,7 @@ int crunch_seq(t_opseq **seq, int pass)
crunched = try_dupify(op);
break; // GADDR_CODE
case LLB_CODE:
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)
if (pass > 0)
crunched = try_dupify(op);
break; // LLB_CODE
case LLW_CODE:
@@ -1604,31 +1343,11 @@ int crunch_seq(t_opseq **seq, int pass)
}
}
}
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)
if ((pass > 0) && (freeops == 0))
crunched = try_dupify(op);
break; // LLW_CODE
case LAB_CODE:
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)))
if ((pass > 0) && (op->type || !is_hardware_address(op->offsz)))
crunched = try_dupify(op);
break; // LAB_CODE
case LAW_CODE:
@@ -1646,17 +1365,8 @@ int crunch_seq(t_opseq **seq, int pass)
}
}
}
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)))
if ((pass > 0) && (freeops == 0) &&
(op->type || !is_hardware_address(op->offsz)))
crunched = try_dupify(op);
break; // LAW_CODE
case LOGIC_NOT_CODE:
@@ -1674,36 +1384,6 @@ 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))
{
@@ -1897,6 +1577,8 @@ 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:
@@ -1905,18 +1587,6 @@ 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;
@@ -1929,36 +1599,12 @@ 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;
@@ -2016,30 +1662,12 @@ 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;

51
src/toolsrc/codegen.h
View File

@@ -31,6 +31,8 @@ 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
@@ -57,29 +59,11 @@ typedef struct _opseq {
#define INDEXW_CODE 0x0317
#define DROP_CODE 0x0318
#define DUP_CODE 0x0319
#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 BRNCH_CODE 0x031C
#define BRFALSE_CODE 0x031D
#define BRTRUE_CODE 0x031E
#define CODETAG_CODE 0x031F
#define NOP_CODE 0x0320
#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)
@@ -95,10 +79,6 @@ 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)
@@ -122,10 +102,6 @@ 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);
@@ -150,23 +126,14 @@ 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_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_brne(int tag);
void emit_brnch(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);

193
src/toolsrc/codegen.pla
View File

@@ -132,10 +132,8 @@ def emit_codeseg#0
end
def emit_const(cval)#0
emit_pending_seq
if cval == $FFFF // MINUS ONE
emit_byte($20)
elsif cval & $FFF0 == $0000 // Constant NYBBLE
emit_byte(cval*2)
if cval == $0000 // ZERO
emit_byte($00)
elsif cval & $FF00 == $0000 // Constant BYTE
emit_byte($2A)
emit_byte(cval)
@@ -153,26 +151,6 @@ 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)
@@ -193,65 +171,24 @@ def emit_daw(tag, offset)#0
emit_byte($7E)
emit_addr(tag, offset)
end
def emit_select(tag)#0
emit_pending_seq
emit_byte($52)
emit_reladdr(tag)
end
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(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_byte($38)
emit_reladdr(tag)
end
def emit_brlt(tag)#0
emit_pending_seq
emit_byte($A2)
emit_byte($3A)
emit_reladdr(tag)
end
def emit_incbrle(tag)#0
def emit_brne(tag)#0
emit_pending_seq
emit_byte($A4)
emit_byte($3E)
emit_reladdr(tag)
end
def emit_addbrle(tag)#0
def emit_branch(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_byte($50)
emit_reladdr(tag)
end
def emit_leave#0
@@ -329,11 +266,8 @@ def emit_pending_seq#0
//
is CONST_GROUP
if op->opcode == CONST_CODE
if op=>opval == $FFFF // MINUS 1
^codeptr = $20
codeptr++
elsif op=>opval & $FFF0 == $0000 // Constant NYBBLE
^codeptr = op->opval*2
if op=>opval == $0000 // ZERO
^codeptr = $00
codeptr++
elsif op=>opval & $FF00 == $0000 // Constant BYTE
*codeptr = $2A | (op->opval << 8)
@@ -346,9 +280,6 @@ 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
//
@@ -451,10 +382,9 @@ def idmatch(nameptr, len, idptr, idcnt)
while idcnt
if len == idptr->idname
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
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
@@ -549,13 +479,11 @@ def init_idglobal#0
word op
word i
dfd_num = DFDNUM
tag_num = TAGNUM
fixup_num = FIXUPNUM
globalbufsz = IDGLOBALSZ
localbufsz = IDLOCALSZ
if isult(heapavail, $6000)
dfd_num = DFDNUM/2
if isult(heapavail, $8000)
tag_num = TAGNUM/2
fixup_num = FIXUPNUM/2
globalbufsz = IDGLOBALSZ
@@ -574,7 +502,6 @@ 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)
@@ -585,6 +512,7 @@ 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
@@ -606,15 +534,13 @@ def save_idlocal#0
savelocals = locals
savesize = framesize
savelast = lastlocal
savetbl = heapalloc(lastlocal - idlocal_tbl)
memcpy(savetbl, idlocal_tbl, lastlocal - idlocal_tbl)
memcpy(heapmark, idlocal_tbl, lastlocal - idlocal_tbl)
end
def restore_idlocal#0
locals = savelocals
framesize = savesize
lastlocal = savelast
memcpy(idlocal_tbl, savetbl, lastlocal - idlocal_tbl)
heaprelease(savetbl)
memcpy(idlocal_tbl, heapmark, lastlocal - idlocal_tbl)
end
//
// Module dependency list
@@ -628,14 +554,6 @@ 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)
@@ -772,15 +690,15 @@ def gen_uop(seq, tkn)
fin
when tkn
is NEG_TKN
code = $90; break
code = $10; break
is COMP_TKN
code = $92; break
code = $12; break
is LOGIC_NOT_TKN
code = $80; break
code = $20; break
is INC_TKN
code = $8C; break
code = $0C; break
is DEC_TKN
code = $8E; break
code = $0E; break
is BPTR_TKN
code = $60; break
is WPTR_TKN
@@ -807,25 +725,25 @@ def gen_bop(seq, tkn)
fin
when tkn
is MUL_TKN
code = $86; break
code = $06; break
is DIV_TKN
code = $88; break
code = $08; break
is MOD_TKN
code = $8A; break
code = $0A; break
is ADD_TKN
code = $82; break
code = $02; break
is SUB_TKN
code = $84; break
code = $04; break
is SHL_TKN
code = $9A; break
code = $1A; break
is SHR_TKN
code = $9C; break
code = $1C; break
is AND_TKN
code = $94; break
code = $14; break
is OR_TKN
code = $96; break
code = $16; break
is EOR_TKN
code = $98; break
code = $18; break
is EQ_TKN
code = $40; break
is NE_TKN
@@ -838,6 +756,10 @@ 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
@@ -902,27 +824,30 @@ end
// Write DeFinition Directory
//
def writeDFD(refnum, modfix)#0
word dfd, idptr, cnt
word dfd, idptr, idcnt
byte defdir[128]
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
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
fileio:write(refnum, @defdir, dfd - @defdir)
end
//
// Build External Symbol Directory on heap
//
def buildESD(modfix)#2
word modofst, esdtbl, esd, idptr, idcnt, len
word modofst, esd, idptr, idcnt, len
byte symnum
symnum, esdtbl, idptr, idcnt = 0, heapalloc(heapavail - 256), idglobal_tbl, globals
esd = esdtbl
symnum, esd, idptr, idcnt = 0, heapmark, idglobal_tbl, globals
while idcnt
if idptr=>idtype & EXPORT_TYPE
esd = esd + stodci(@idptr->idname, esd)
@@ -941,27 +866,26 @@ def buildESD(modfix)#2
idcnt--
loop
^esd = 0
len = esd - esdtbl + 1
heaprelease(esdtbl + len)
return esdtbl, len
len = esd - heapmark + 1
esd = heapalloc(len)
return esd, len
end
//
// Write ReLocation Directory
//
def writeRLD(refnum, modofst)#0
word rldtbl, rld, rldlen, fixups, updtptr, idptr, idcnt, tag
word rld, rldlen, fixups, updtptr, idptr, idcnt, tag
byte type
rldtbl = heapalloc(heapavail - 256)
rld = rldtbl
rld = heapmark
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, rldtbl, rld - rldtbl)
rld = rldtbl
fileio:write(refnum, heapmark, rld - heapmark)
rld = heapmark
rldlen = 0
fin
if type & EXTERN_FIXUP
@@ -983,8 +907,7 @@ def writeRLD(refnum, modofst)#0
fin
next
^rld = 0
fileio:write(refnum, rldtbl, rld - rldtbl + 1)
heaprelease(rldtbl)
fileio:write(refnum, heapmark, rld - heapmark + 1)
end
//
// Write Extended REL file

225
src/toolsrc/codeopt.pla
View File

@@ -83,10 +83,7 @@ def crunch_seq(seq, pass)
op->opcode = DUP_CODE
op->opgroup = STACK_GROUP
nextop->opcode = ADD_CODE
break
fin
if nextop->opcode == MUL_CODE or nextop->opcode == DIV_CODE
freeops = -2
crunched = 1
break
fin
fin
@@ -123,26 +120,6 @@ 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
@@ -152,7 +129,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
@@ -223,73 +200,31 @@ 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
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
for shiftcnt = 0 to 15
if op=>opval == 1 << shiftcnt
op=>opval = shiftcnt
nextop->opcode = SHL_CODE
break
fin
next
break
is DIV_CODE
for shiftcnt = 1 to 15
for shiftcnt = 0 to 15
if op=>opval == 1 << shiftcnt
op=>opval = shiftcnt
nextop->opcode = SHR_CODE
@@ -305,7 +240,7 @@ def crunch_seq(seq, pass)
if nextop=>opnext
nextopnext = nextop=>opnext
when nextopnext->opcode
is ADD_CODE // INDEXB_CODE
is INDEXB_CODE // ADD_CODE
op=>opoffset = op=>opoffset + nextop=>opval
freeops = 2
break
@@ -343,7 +278,7 @@ def crunch_seq(seq, pass)
if nextop=>opnext
nextopnext = nextop=>opnext
when nextopnext->opcode
is ADD_CODE // INDEXB_CODE
is INDEXB_CODE // ADD_CODE
op=>opoffset = op=>opoffset + nextop=>opval
freeops = 2
break
@@ -380,85 +315,45 @@ def crunch_seq(seq, pass)
fin
break // GADDR_CODE
is LLB_CODE
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
if pass
crunched = try_dupify(op)
fin
break // LLB_CODE
is LLW_CODE
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
// 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
fin
break
wend
fin
fin
if pass and not freeops
crunched = try_dupify(op)
fin
break // LLW_CODE
is LAB_CODE
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)
if pass and not is_hardware_address(op=>opoffset)
crunched = try_dupify(op)
fin
break // LAB_CODE
is LAW_CODE
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
// 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
fin
break
wend
fin
fin
if pass and not freeops and not is_hardware_address(op=>opoffset)
crunched = try_dupify(op)
fin
@@ -479,38 +374,6 @@ 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

57
src/toolsrc/codeseq.plh
View File

@@ -3,36 +3,33 @@
//
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 = $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 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 DROP_CODE = $30
const DROP2_CODE = $32
const DUP_CODE = $34
const DUP_CODE = $32
const EQ_CODE = $40
const NE_CODE = $42
const GT_CODE = $44
@@ -58,10 +55,6 @@ 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
//
@@ -74,23 +67,13 @@ 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
//

1235
src/toolsrc/ed.pla
View File

File diff suppressed because it is too large Load Diff

3173
src/toolsrc/forthtran.c
View File

File diff suppressed because it is too large Load Diff

1
src/toolsrc/lex.c
View File

@@ -50,6 +50,7 @@ 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',

6
src/toolsrc/lex.pla
View File

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

272
src/toolsrc/parse.c
View File

@@ -1,13 +1,10 @@
#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;
@@ -26,7 +23,9 @@ t_token binary_ops_table[] = {
EOR_TOKEN,
OR_TOKEN,
GT_TOKEN, GE_TOKEN, LT_TOKEN, LE_TOKEN,
EQ_TOKEN, NE_TOKEN
EQ_TOKEN, NE_TOKEN,
LOGIC_AND_TOKEN,
LOGIC_OR_TOKEN
/* Lowest precedence */
};
t_token binary_ops_precedence[] = {
@@ -38,7 +37,9 @@ t_token binary_ops_precedence[] = {
5,
6,
7, 7, 7, 7,
8, 8
8, 8,
9,
10
/* Lowest precedence */
};
@@ -651,13 +652,9 @@ t_opseq *parse_value(t_opseq *codeseq, int rvalue, int *stackdepth)
cfnparms = 0; cfnvals = 1;
type &= ~FUNC_TYPE;
}
else if (type & (BPTR_TYPE)) // Prefer the pointer type.
else if (type & (BYTE_TYPE | BPTR_TYPE))
valseq = gen_lb(valseq);
else if (type & (WPTR_TYPE))
valseq = gen_lw(valseq);
else if (type & (BYTE_TYPE))
valseq = gen_lb(valseq);
else if (type & (WORD_TYPE))
else if (type & (WORD_TYPE | WPTR_TYPE))
valseq = gen_lw(valseq);
else
parse_error("What are we dereferencing?");
@@ -685,7 +682,7 @@ t_opseq *parse_value(t_opseq *codeseq, int rvalue, int *stackdepth)
}
return (cat_seq(codeseq, valseq));
}
t_opseq *parse_subexpr(t_opseq *codeseq, int *stackdepth)
t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
{
int prevmatch;
int matchop = 0;
@@ -732,60 +729,14 @@ t_opseq *parse_subexpr(t_opseq *codeseq, int *stackdepth)
if (stackdepth)
(*stackdepth)--;
}
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);
/*
* Look for ternary operator
*/
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);
@@ -802,7 +753,8 @@ 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;
@@ -846,11 +798,9 @@ t_opseq *parse_expr(t_opseq *codeseq, int *stackdepth)
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, constsize, casecnt, i;
int *caseval, *casetag;
long constval;
int type, addr, step, cfnvals;
char *idptr;
t_opseq *seq, *fromseq, *toseq;
t_opseq *seq;
/*
* Optimization for last function LEAVE and OF clause.
@@ -909,10 +859,9 @@ int parse_stmnt(void)
tag_while = tag_new(BRANCH_TYPE);
tag_wend = tag_new(BRANCH_TYPE);
tag_prevcnt = cont_tag;
cont_tag = tag_new(BRANCH_TYPE);
cont_tag = tag_while;
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");
@@ -921,12 +870,12 @@ int parse_stmnt(void)
parse_warn("Expression value overflow");
while (cfnvals-- > 1) seq = gen_drop(seq);
}
seq = gen_brtru(seq, tag_while);
seq = gen_brfls(seq, tag_wend);
emit_seq(seq);
while (parse_stmnt()) next_line();
if (scantoken != LOOP_TOKEN)
parse_error("Missing WHILE/END");
emit_codetag(cont_tag);
emit_seq(seq);
emit_brnch(tag_while);
emit_codetag(tag_wend);
break_tag = tag_prevbrk;
cont_tag = tag_prevcnt;
@@ -957,38 +906,46 @@ int parse_stmnt(void)
break_tag = tag_prevbrk;
break;
case FOR_TOKEN:
stack_loop += 2;
stack_loop++;
tag_prevbrk = break_tag;
break_tag = tag_new(BRANCH_TYPE);
tag_for = tag_new(BRANCH_TYPE);
tag_prevcnt = cont_tag;
cont_tag = tag_new(BRANCH_TYPE);
cont_tag = tag_for;
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 (!(fromseq = parse_expr(NULL, &cfnvals)))
if (!(seq = 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 (!(toseq = parse_expr(NULL, &cfnvals)))
if (!(seq = 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)))
@@ -998,59 +955,27 @@ 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
{
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);
emit_unaryop(step > 0 ? INC_TOKEN : DEC_TOKEN);
while (parse_stmnt()) next_line();
if (scantoken != NEXT_TOKEN)
parse_error("Missing FOR/NEXT");
emit_codetag(cont_tag);
emit_brnch(tag_for);
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 -= 2;
break_tag = tag_prevbrk;
stack_loop--;
break;
case CASE_TOKEN:
stack_loop++;
tag_prevbrk = break_tag;
break_tag = tag_new(BRANCH_TYPE);
tag_choice = tag_new(BRANCH_TYPE);
caseval = malloc(sizeof(int)*256);
casetag = malloc(sizeof(int)*256);
casecnt = 0;
tag_of = tag_new(BRANCH_TYPE);
if (!(seq = parse_expr(NULL, &cfnvals)))
parse_error("Bad CASE expression");
if (cfnvals > 1)
@@ -1059,48 +984,33 @@ 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)
{
tag_of = tag_new(BRANCH_TYPE);
constval = 0;
parse_constexpr(&constval, &constsize);
i = casecnt;
while ((i > 0) && (caseval[i-1] > constval))
if (!(seq = parse_expr(NULL, &cfnvals)))
parse_error("Bad CASE OF expression");
if (cfnvals > 1)
{
//
// Move larger case consts up
//
caseval[i] = caseval[i-1];
casetag[i] = casetag[i-1];
i--;
parse_warn("Expression value overflow");
while (cfnvals-- > 1) seq = gen_drop(seq);
}
if ((i < casecnt) && (caseval[i] == constval))
parse_error("Duplicate CASE");
caseval[i] = constval;
casetag[i] = tag_of;
casecnt++;
emit_seq(seq);
emit_brne(tag_choice);
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)
{
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;
emit_codetag(tag_of);
tag_of = 0;
scan();
if (tag_of)
emit_codetag(tag_of);
while (parse_stmnt()) next_line();
if (scantoken != ENDCASE_TOKEN)
parse_error("Bad CASE DEFAULT clause");
@@ -1110,16 +1020,12 @@ int parse_stmnt(void)
else
parse_error("Bad CASE clause");
}
if (tag_choice)
{
emit_brnch(break_tag);
emit_codetag(tag_choice);
emit_caseblock(casecnt, caseval, casetag);
}
free(caseval);
free(casetag);
if (tag_of)
emit_codetag(tag_of);
emit_codetag(break_tag);
emit_drop();
break_tag = tag_prevbrk;
stack_loop--;
break;
case BREAK_TOKEN:
if (break_tag)
@@ -1134,19 +1040,12 @@ 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");
@@ -1344,7 +1243,7 @@ int parse_struc(void)
int parse_vars(int type)
{
long value;
int idlen, size, cfnparms, emit = 0;
int idlen, size, cfnparms;
long cfnvals;
char *idstr;
@@ -1407,7 +1306,6 @@ 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:
/*
@@ -1448,12 +1346,6 @@ 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:
@@ -1544,16 +1436,11 @@ int parse_defs(void)
char c, *idstr;
int idlen, func_tag, cfnparms, cfnvals, type = GLOBAL_TYPE, pretype;
static char bytecode = 0;
switch (scantoken)
if (scantoken == EXPORT_TOKEN)
{
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 (scan() != DEF_TOKEN && scantoken != ASM_TOKEN)
parse_error("Bad export definition");
type = EXPORT_TYPE;
}
if (scantoken == DEF_TOKEN)
{
@@ -1633,9 +1520,8 @@ int parse_defs(void)
emit_const(0);
emit_leave();
}
for (cfnvals = 0; cfnvals < lambda_cnt; cfnvals++)
emit_lambdafunc(lambda_tag[cfnvals], lambda_id[cfnvals], lambda_cparams[cfnvals], lambda_seq[cfnvals]);
lambda_cnt = 0;
while (lambda_cnt--)
emit_lambdafunc(lambda_tag[lambda_cnt], lambda_id[lambda_cnt], lambda_cparams[lambda_cnt], lambda_seq[lambda_cnt]);
return (1);
}
else if (scantoken == ASM_TOKEN)
@@ -1716,21 +1602,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();

376
src/toolsrc/parse.pla
View File

@@ -80,6 +80,8 @@ 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
@@ -461,13 +463,9 @@ def parse_value(codeseq, r_val)#2
valseq = gen_op(valseq, ICAL_CODE)
stackdepth = stackdepth + cfnvals - 1
type = type & ~FUNC_TYPE
elsif type & (BPTR_TYPE) // Prefer the pointer type.
elsif type & (BYTE_TYPE | BPTR_TYPE)
valseq = gen_op(valseq, LB_CODE)
elsif type & (WPTR_TYPE)
valseq = gen_op(valseq, LW_CODE)
elsif type & (BYTE_TYPE)
valseq = gen_op(valseq, LB_CODE)
elsif type & (WORD_TYPE)
elsif type & (WORD_TYPE | WPTR_TYPE)
valseq = gen_op(valseq, LW_CODE)
else
exit_err(ERR_INVAL|ERR_CODE)
@@ -493,10 +491,10 @@ def parse_value(codeseq, r_val)#2
fin
return cat_seq(codeseq, valseq), stackdepth
end
def parse_subexpr(codeseq)#2
def parse_expr(codeseq)#2
byte stackdepth, matchdepth, stkdepth1, prevmatch, matchop, i
word optos
word tag_else, tag_endop
word tag_else, tag_endtri
stackdepth = 0
matchop = 0
@@ -526,40 +524,21 @@ def parse_subexpr(codeseq)#2
codeseq = gen_bop(codeseq, pop_op)
stackdepth--
loop
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)
//
// Look for ternary operator
//
if token == TERNARY_TKN
if stackdepth <> 1; exit_err(ERR_OVER|ERR_SYNTAX); fin
tag_else = new_tag(RELATIVE_FIXUP)
tag_endop = new_tag(RELATIVE_FIXUP)
tag_endtri = 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_endop)
codeseq = gen_oprel(codeseq, BRNCH_CODE, tag_endtri)
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_endop)
codeseq = gen_ctag(codeseq, tag_endtri)
fin
return codeseq, stackdepth
end
@@ -608,10 +587,9 @@ def parse_set(codeseq)
return codeseq
end
def parse_stmnt
byte type, elem_type, elem_size, cfnvals
word seq, fromseq, toseq, tag_prevbrk, tag_prevcnt, tag_else, tag_endif, tag_while, tag_wend
byte type, elem_type, elem_size, i, cfnvals
word seq, 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
@@ -665,10 +643,9 @@ def parse_stmnt
tag_while = new_tag(RELATIVE_FIXUP)
tag_wend = new_tag(RELATIVE_FIXUP)
tag_prevcnt = cont_tag
cont_tag = new_tag(RELATIVE_FIXUP)
cont_tag = tag_while
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
@@ -676,13 +653,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, BRTRUE_CODE, tag_while)
seq = gen_oprel(seq, BRFALSE_CODE, tag_wend)
emit_seq(seq)
while parse_stmnt
nextln
loop
if token <> LOOP_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
emit_tag(cont_tag)
emit_seq(seq)
emit_branch(tag_while)
emit_tag(tag_wend)
break_tag = tag_prevbrk
cont_tag = tag_prevcnt
@@ -713,10 +690,10 @@ def parse_stmnt
break_tag = tag_prevbrk
break
is FOR_TKN
stack_loop = stack_loop + 2
stack_loop++
tag_for = new_tag(RELATIVE_FIXUP)
tag_prevcnt = cont_tag
cont_tag = new_tag(RELATIVE_FIXUP)
cont_tag = tag_for
tag_prevbrk = break_tag
break_tag = new_tag(RELATIVE_FIXUP)
if scan <> ID_TKN; exit_err(ERR_MISS|ERR_ID); fin
@@ -728,12 +705,19 @@ def parse_stmnt
exit_err(ERR_INVAL|ERR_ID)
fin
if scan <> SET_TKN; exit_err(ERR_INVAL|ERR_STATE); fin
fromseq, cfnvals = parse_expr(NULL)
if !fromseq; exit_err(ERR_INVAL|ERR_STATE); fin
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_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
@@ -741,67 +725,6 @@ def parse_stmnt
else
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
if token == STEP_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
else
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_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 = stack_loop - 2
break
is CASE_TKN
tag_prevbrk = break_tag
break_tag = new_tag(RELATIVE_FIXUP)
tag_choice = 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
@@ -809,44 +732,69 @@ def parse_stmnt
while cfnvals > 1;cfnvals--; seq = gen_op(seq, DROP_CODE); loop
fin
emit_seq(seq)
emit_select(tag_choice)
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
if cfnvals > 1
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)
fin
while parse_stmnt
nextln
loop
if token <> NEXT_TKN; exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE); fin
emit_branch(tag_for)
cont_tag = tag_prevcnt
emit_tag(break_tag)
emit_code(DROP_CODE)
break_tag = tag_prevbrk
stack_loop--
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)
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)
nextln
while token <> ENDCASE_TKN
when token
is OF_TKN
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++
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)
emit_tag(tag_of)
while parse_stmnt
nextln
loop
break
is DEFAULT_TKN
tag_of = 0
if prevstmnt <> BREAK_TKN // Branch around caseblock if falling through
tag_of = new_tag(RELATIVE_FIXUP)
tag_of = new_tag(RELATIVE_FIXUP)
if prevstmnt <> BREAK_TKN // Fall through to next OF if no break
emit_branch(tag_of)
fin
emit_tag(tag_choice)
emit_caseblock(casecnt, caseval, casetag)
tag_choice = 0
if tag_of
emit_tag(tag_of)
fin
tag_choice = new_tag(RELATIVE_FIXUP)
break
is DEFAULT_TKN
emit_tag(tag_of)
tag_of = 0
scan
while parse_stmnt
nextln
@@ -860,14 +808,13 @@ def parse_stmnt
exit_err(ERR_MISS|ERR_CLOSE|ERR_STATE)
wend
loop
if tag_choice
emit_branch(break_tag)
emit_tag(tag_choice)
emit_caseblock(casecnt, caseval, casetag)
if (tag_of)
emit_tag(tag_of)
fin
heaprelease(caseval)
emit_tag(break_tag)
emit_code(DROP_CODE)
break_tag = tag_prevbrk
stack_loop--
break
is BREAK_TKN
if break_tag
@@ -884,15 +831,10 @@ 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
@@ -1134,10 +1076,6 @@ 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
@@ -1219,95 +1157,81 @@ def parse_lambda
return func_tag
end
def parse_defs
byte idlen, cfnparms, cfnvals, defstr[17]
word type, idstr, func_tag, idptr, defcodeptr
type = FUNC_TYPE
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
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
puti(codeptr - defcodeptr); puts(@bytesln)
byte idlen, cfnparms, cfnvals
word type, idstr, func_tag, idptr
wend
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
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)
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
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
@@ -1319,8 +1243,6 @@ 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

Some files were not shown because too many files have changed in this diff Show More