bin/0040755000076400007640000000000007056266227010334 5ustar frerfrerbin/mary0100755000076400007640000000446207056266222011230 0ustar frerfrer#!/bin/sh # Mary V1.0a50 # Released on February 2000 # Copyright Francisco Rodrigo Escobedo Robles, 2000 # Visit http://www.pepix.net/proyectos/glazz/mary/ for info and latest versions # Contact frer@pepix.net for suggestions # This version is covered by GNU General Public License version 2 # Calls Pic Forth compiler with the necessary files, etc VERSION=1.0a50 DATE="February 2000" #DEBUG=1 PREFIX=/usr/lib/share/mary [ -n "$DEBUG" ] && PREFIX=../lib/share/mary FORTH=gforth PICASM=${PREFIX}/picasm.fs PICFORTH=${PREFIX}/picforth.fs PICFORTHSUPPORT=${PREFIX}/picforthsupp.fs TMPFILE=/tmp/maryO$(date +%s)O$$.tmp SAVESTATE=${PREFIX}/savestate.fs RESTORESTATE=${PREFIX}/restorestate.fs PROCESSOR=16c63 # put your favourite processor here while test $# -gt 0 do opt="$1" case "$opt" in -h|--help) cat << EOF mary V$VERSION Released on $DATE Copyright Francisco Rodrigo Escobedo Robles, 2000 Visit http://www.pepix.net/proyectos/glazz/mary/ for info and latest versions Contact frer@pepix.net for suggestions This version is covered by GNU General Public License version 2 usage: mary [ { -p | --processor } ] infile options: { -p | --processor } : selects PIC processor model { -h | --help } : this help EOF exit ;; -p|--processor) PROCESSOR=$(echo "$2" | tr '[:upper:]' '[:lower:]') shift ;; *) INFILE="$1" ;; esac shift done [ -z "$INFILE" ] && echo "mary: no input file" && exit 1 [ ! -f "$INFILE" ] && echo "mary: can't read file $INFILE" && exit 1 PROCESSORCONSTS=${PREFIX}/$PROCESSOR-consts.fs PROCESSORDATA=${PREFIX}/$PROCESSOR-data.fs PROCESSORCODE=${PREFIX}/$PROCESSOR-code.fs [ ! -f "$PROCESSORCONSTS" ] && echo "mary: unsupported proccessor $PROCESSOR" && exit 1 echo " PICFORTH DEFINITIONS" > ${TMPFILE}-PICFORTH echo " PROGDUMP BYE" > ${TMPFILE}-PROGDUMP # We include 2 times $PROCESSORCONSTS, one for picasm, the other for picforth cat $SAVESTATE $PICASM $PROCESSORCONSTS $PROCESSORDATA $PICFORTHSUPPORT \ $PROCESSORCODE $PICFORTH $PROCESSORCONSTS $RESTORESTATE \ ${TMPFILE}-PICFORTH $INFILE ${TMPFILE}-PROGDUMP > $TMPFILE $FORTH $TMPFILE rm -f $TMPFILE ${TMPFILE}-PICFORTH ${TMPFILE}-PROGDUMP doc/0040755000076400007640000000000007056301215010314 5ustar frerfrerdoc/README0100644000076400007640000000205607056301057011200 0ustar frerfrermary 1.0a50 - an optimizing native code Forth compiler for PIC microcontrollers Released on February 2000 Copyright Francisco Rodrigo Escobedo Robles, 2000 Visit http://www.pepix.net/proyectos/glazz/mary/ for info and latest versions Contact frer@pepix.net for suggestions mary is free as in freedom, as it's an Open Source work This version is covered by GNU General Public License version 2 mary is currently in alpha state, so it's released to be used with caution. I honestly believe it works, but it can cause unknown errors, for which I cannot be held responsible. Particularly, if the entire Universe is collapsed into itself, I am innocent. This is the README file mary is in alpha state. The docs are also in alpha. Important changes may occur before beta. mary is an optimizing native code Forth compiler for PIC microcontrollers. It generates machine code instructions and optimizes sequences of them, constant values and logical operators. Read mary-manual.txt for documentation. For installing it: tar -C /usr/local -zxvf mary-1.0a50.tar.gz doc/COPYING0100644000076400007640000004307605022066500011352 0ustar frerfrer GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. doc/mary-manual.txt0100644000076400007640000014361207056276663013326 0ustar frerfrermary 1.0a50 - an optimizing native code Forth compiler for PIC microcontrollers Released on February 2000 Copyright Francisco Rodrigo Escobedo Robles, 2000 Visit http://www.pepix.net/proyectos/glazz/mary/ for info and latest versions Contact frer@pepix.net for suggestions mary is free as in freedom, as it's an Open Source work This version is covered by GNU General Public License version 2 mary is currently in alpha state, so it's released to be used with caution. I honestly believe it works, but it can cause unknown errors, for which I cannot be held responsible. Particularly, if the entire Universe is collapsed into itself, I am innocent. This is the mary-manual.txt file "Size does matter. Who wants a dinosaur in his/her desktop?" - FRER CONTENTS -------- 1 - General 1.1 - What is mary? 1.2 - Where does the name mary came from? 1.3 - WHY IS THE SOURCE IN ALL CAPS? 1.4 - What is Forth? 1.5 - What is this PIC thing? 1.6 - What is the current status of mary? 1.7 - Why use mary instead of assembler or C? 1.8 - How good are the optimizations? 1.9 - What are the system requirements? 2 - Forth model 2.1 - What kind of Forth is mary? 2.2 - How is it implemented on the PIC? 2.3 - How is mary made? 2.4 - Is it possible to mix assembler code with Forth? 2.5 - What is this strange CONST, word? 2.6 - I can't find my favourite words... 2.7 - Highlights of new/improved words 2.8 - Examples of code that take full advantage of optimizations 3 - Files 3.1 - mary 3.2 - savestate.fs 3.3 - restorestate.fs 3.4 - picasm.fs 3.5 - picforthsupp.fs 3.6 - picforth.fs 3.7 - 16cXX-data.fs 3.8 - 16cXX-consts.fs 3.9 - 16cXX-code.fs 4 - Vocabularies 4.1 - PICASM, the PIC assembler 4.1.1 - Assembler pseudodirectives 4.1.2 - Support words 4.1.3 - PIC assembly language support 4.1.4 - PIC assembler mnemonics 4.1.5 - Utilities 4.2 - PICFORTH, the free mary PIC Forth optimizing native code compiler 4.2.1 - Forth words 4.2.2 - Forth support words 4.2.3 - PIC specific support words 5 - Programming with mary 5.1 - A little example Appendixes A - A Taoist-like story about Forth ----- 1 - General =========== 1.1 - What is mary? ------------------- "This is a code generator-less compiler for a syntax-less language in which variables are constants" - FRER mary is an optimizing native code Forth compiler for PIC microcontrollers. It generates machine code instructions and optimizes sequences of them, constant values and logical operators. mary is part of the Glazz project, whose original aim was world domination, later changed to the creation of a native code Forth system with multiple targets. The idea behind Glazz is to be able to create an interesting and portable application developing framework that run fast and without consuming resources as if they were unlimited. Right now, as spare time is scarce, mary, the free PIC Forth native code optimizing compiler, is the first work in the Glazz project to see the light. It was planned to run on the Glazz Forth system, but it doesn't exist right now (at least in executable form). Back to mary. The code generated is optimized for speed, and the optimizations try to make it small. The result is (hopefully) an efficient substitute for the assembly language programming. mary contains an essential but useful subset of Forth, as well as some extensions unique to PIC programming. Current target is the mid-range of PIC processors, the ones with 14-bit wide instruction set. Low-range PICs, while useful, are not contemplated for a future release, but who knows. Anyway, mary does optimize the use of the hardware return stack, it's possible that mary would compile well for a 2-level stack as low-range PICs. High-range PICs are more likely to be supported in the future but, again, there are not currently any plans to do so. Supplied with version 1.0a50 of mary are the necessary files for compiling Forth code for the 16C63 and 16C84 PIC models. It's easy to add new PIC models, so support for the full mid-range is projected for future releases. 1.2 - Where does the name mary came from? ----------------------------------------- You know how this things are. This is a Forth compiler for PIC microcontrollers. A PIC Forth. Mary PIC Forth. Do you know who Mary Pickford was? Remember that good ol' movies? I do. 1.3 - WHY IS THE SOURCE IN ALL CAPS? ------------------------------------ ANS Forth stated that a program that uses lowercase for standard definition names or that depends on case sensitivity has an environmental dependency. Although mary is not (yet) aimed to ANS Forth compliancy, I decided to make such a little effort in order to compile inside an ANS Forth system. Comments suffered the same luck, for no good (nor bad) reason. Depending on the host Forth system it's possible that you can use lowercase when writing programs with mary, but don't bet on that. 1.4 - What is Forth? -------------------- There are probably more definitions than stars are in the sky. Let's say that Forth is an unusual but useful programming language with a strong philosophic background. If you learn Forth well, it will help you in you everyday life too and even in your understanding of the Universe as a whole. You see, I told you there were too many definitions. In the late 1960s, Charles "Chuck" Moore worked at a radiotelescope at Kitt Peak, Arizona (U.S.A.). The main language for developing his control and statistics programs was FORTRAN. The edit-compile-run-debug cycle was too boring and inefficient, he was almost forced to make a new way to do things. He started to write assembly language subroutines, later connected in address lists. After some time, the first Forth system was born. He thouugh of his language to be a fourth-generation language (in the third-generation computers of then), but the IBM 1130 he worked on rejected names with more than 5 characters, so FOURTH became FORTH (it was the all-caps FORTRAN era, too). Since then, there has been some Forth standards through time, as FORTH-78, FORTH-79, FORTH-83 and FIG-FORTH. In 1994, the American National Standards Institute, Technical Commitee X3J14, issued that was called ANS Forth (X3.215-1994). Its goal was to collect all common programming practices and create a global standard that contemplated them all, or at least, invalidate the lesser possible number of programs. But there are areas in which a full ANS Forth system is not required. As Chuck Moore, the inventor of Forth, put it: "Underground Forths are still needed". That is, non-ANSI systems. ANS Forth systems are regarded as "dinosaurs" by some people. They even think that programmers educated in the ANSI standard but without a previous Forth knowledge tend to use Forth the same way as (for example) C, writing poor code as they don't really understand the Forth concept. Maybe that's true, but I am not an ANS Forth-minded person myself. I started programming in Forth in 1984, left it in 1986, came back in 1989 (ANSI TC X3J14 was already working on ANS Forth), left again in 1991 and came back again in 1999. I have always found Forth new and refreshing, and regret not using it more time. It could have helped me with my life (really). So, Forth means different things to different people. 1.5 - What is this PIC thing? ----------------------------- PIC stands for Peripheral Intelligent Controller, and was the name for a dedicated type of processors. Nowadays, Arizona Microchip Technologies, or Microchip for short, manufactures PIC microcontrollers for many uses. They are small computers, with a processor, ROM, RAM, some peripherals built-in and I/O ports. Microchip is currently the #2 microcontroller manufacturer in the world (second to Motorola), and the range of applications for their PIC chips is amazing. From remote controllers to microbots, from doorbells to serial encoders. PICs are normally programmed in assembly language or C. Now there is a free (as in freedom) alternative: Forth. 1.6 - What is the current status of mary? ----------------------------------------- Version 1.0a50 is an alpha version. It needs some testing before entering beta stage. A useful library of words and examples on how to manage peripherals is currently lacking, but not difficult to implement. The documentation is fairly complete for a start, but Forth words are listed in definition order. More examples and a full tutorial are needed. 1.7 - Why use mary instead of assembler or C? --------------------------------------------- Although assembler is the most powerful language, it tends to be cumbersome and boring for large programs, not to mention error-prone. It shows its excellence when used for short, carefully handcrafted routines. It's my believing as a computer scientist that no programmer should be working with at least a grasp of what assembly programming is. C can be a great language. I used to program a lot on it. But (as most of other languages), it has a syntax, with you must deal in order to express your problem's solution. Forth, in the other hand, gives you a much greater freedom for developing your systems. It's perfect for embedded applications. You control all the enviroment and make your own operating system, totally tailored for your application. mary is a free optimizing native code Forth compiler whose aim is to substitute assembly language programming while being fun and powerful. 1.8 - How good are the optimizations? ------------------------------------- There is no code generator, so there is no optimizer at all. Every word generates its own code and makes its own optimizations. There is little context sharing, as the only thing a word can do is look to the previously generated code and try to optimize it, merging, suppressing or modifying. All the optimizations have been done thinking in what I would have written if the sequence was originally in assembly language. Several tradeoffs had to be taken into account, resulting in the following kinds of optimizations: - constant optimization: when all the operands to a word are known at compile time, the code for the constant result is generated; in some cases there are important optimizations that can be done if only one of two operators are known. E.g.: "1 CONST, 2 CONST, +" is compiled as "3 CONST,". See below for explanation of CONST, - operation combinations: adding up constant optimization and operation combinations, we can get rid of some redundant operations, like 1+ - logical expression reduction: when a logical operator precedes an IF, it they can be merged to a more compact code - dead code elimination: if a constant expression is used as dicriminator in a conditional control flow word (like IF or UNTIL), a branch can be never reached, so that code is deleted. There is currently an exception to this, see the code for IF for explanations - exit code compaction: when exitting a word prematurely, a jump is done instead of a call 1.9 - What are the system requirements? --------------------------------------- Currently mary uses only standard ANS Forth words, but it doesn't provide a Forth system of its own. So an ANS Forth system is required to use mary. As of version 1.0a50, gforth 0.4.0 has been used for developing and testing. I use gforth in a Linux/Intel PC, so reports for use of different Forth systems and architectures are welcome. I think that I have got ridden of all the octet order dependencies, but one never knows. One important environment dependency is that mary must be run on a Forth system whose cell width is at least 16 bits. This is so because mary uses system cells to contain PIC instruction words. Mid-range PICs use 14 bits, but high-range ones use 16 bits. A system with 14-bit words could be used for mid-range. mary generates a Intel HEX file that can be feeded to the Microchip suite of PIC programming utilities. Some non-commercial programming systems accept HEX files as input also. 2 - Forth model =============== 2.1 - What kind of Forth is mary? --------------------------------- An "underground" Forth, that is, a non-ANS Forth. It follows tradition where possible, and incorporates some additions. It can't recompile itself because mid-range PICs are not powerful enough to use their own model for regenerating code. There are some improvements in mary in order to substitute assembly programming, as : and ; being possible to be used several times in a word. As for word description, I use the common stack notation written as: ( n1 n2 ... nn -- n1' n2' ... nm' ) read as: "before word execution, data items n1, n2, ..., nn were on the stack, nn being the top of stack (TOS); after word execution, items n1', n2', ..., nm' are in the stack, nm' being the top of stack". Parentheses indicate this is a comment. 2.2 - How is it implemented on the PIC? --------------------------------------- PIC architecture is a Harvard one, so data, code and even stack spaces are different. There are different address and word widths in every of them, making difficult to mix code and data. Besides, the return stack is not directly addressable. All of this adds up to make very difficult to make an efficient traditional indirect threading Forth system. So, the way to go is a native code system. The words are compiled as subroutines, and then the hardware return stack is used as return stack in mary. There are no return stack manipulation words in mary. The data stack is implemented using the indirect addressing register, holding the TOS in the W register. The data stack depth is a processor-specific feature, can be a maximum recommended of 16 words (as in 16C63), or reduced to 8 words (as in 16C84). The limit of 16 words is proposed for 2 reasons: - Chuck Moore estimated a stack depth of 18 as effectively "infinite", so 16 is not far from that - there are PIC models in that the highest 16 data words in every bank are shared (or, said another way, the highest 16 data words in banks 1, 2 and 3 are mapped to the real ones in bank 0) There are 3 locations reserved for temporary data, named TMP1, TMP2 and TMP3, intended to be used only in the compiler, not in applications. mary currently adresses only 2 banks of RAM, instead of the possible 4 that some PIC models have. The reason is that indirect addressing can't go further, and the stack width (8 bits) don't make it possible also. In the future is possible that this situation will change, but currently think in using the other banks for specific words that deal with them as buffers (e.g.: serial communication drivers, D/A samplers, etc). Code is stored in ROM, as are constant tables. Variables are stored in RAM, as is the data stack. Cell size is 8 bits, so the stack and the variable width is also 8 bits. Currently, no double number operators are available. 2.3 - How is mary made? ----------------------- First, a PIC assembler was made in Forth. It contains every mnemonic supported by Microchip assembler for mid-range PICs, with the reverse "syntax" typical of Forth assemblers. The only changes are the following: - TRIS instruction is _not_ supported, as it is marked as deprecated by Microchip - OPTION instruction is _not_ supported for the same reason as TRIS - default destination is W instead of F. Use always ,F or ,W to specify destination. There was no easy solution for this problem, but I am open to suggestions The assembler has some pseudodirectives in order to make it easy to use and support mary. Keep in mind that, while a backward reference can be used from many points in the code, a forward reference can only be resolved once. This is not such a great problem, as its purpose is only to be used inside the PIC assembler. 2.4 - Is it possible to mix assembler code with Forth? ------------------------------------------------------ Yes, but you must follow the conventions in order not to interfere with mary. Besides, it may be needed to use NOOPT to indicate mary that optimization is not possible. When writing assembler code, it's not necessary to use CONST, for the constants. 2.5 - What is this strange CONST, word? --------------------------------------- I knew you would ask that. In order to compile a constant in the code, CONST, must be used. Example: "2 3 +" in Forth becomes "2 CONST, 3 CONST, +" in mary. This is just the same as in standard Forth, the only difference is that you never see that. The reason is that the text interpreter must be changed for doing this automatically, and this is an alpha release. Internally is also used for compiling constants, so CONST, will not go away in the future. When a _portable_ text interpreter is written, I will do my best to signal errors like use of words not in mary. Currently you must learn the vocabularies and adhere to them. Note that for defining a named constant, you would write: 31 CONSTANT LIMIT so, no CONST, is to be used in this case. 2.6 - I can't find my favourite words... ---------------------------------------- Most of the Forth words not implemented fall in one of this categories: - not applicable to PIC architecture - not applicable to a target-only, non-recompiling, non-interactive Forth - easily substitutable by reordering arguments - optimization eliminates the need for them The rest of words not implemented fall in one of this categories: - intended to be written by me in the future - not intended to be written by me in the future The words in this last category fall in one of this categories: - intended to be written by anyone else in the future - not intended to be written by anyone else in the future Said that, let's see some of the words that didn't get implemented and the reasons: - ( : mary currently uses ( from the Forth host system - 1+ : "1 CONST, +" is a perfect optimized equivalent. The same goes for 1- - 0< : "0 CONST, <" is a perfect optimized equivalent - DO ... LOOP : too complex, use WHILE instead - >R R> : there is no user manageable return stack in mary - ROT : usually reordering or repeating the arguments does the trick - PICK : this is Forth, you know. Factor, factor, factor - strings: some basic support planned for the future - floating point: fixed point is faster - fixed point: */ planned for the future. Scaling is fast, too :) - <# # #S #> : probably in the future - EXIT : use ; instead - ?DUP : normally used before IF, use AIF instead (see) - local variables: this is Forth, again, do you remember? - CASE ... OF ... ENDOF ... ENDCASE : probably in the future. If you are an ANS Forth-minded person, it will take you some more effort to love mary. Sorry, one has to make decisions. Suggestions (and code) are welcome. 2.7 - Highlights of new/improved words -------------------------------------- mary words fall in one of this categories (again :) - assembly language instructions - assembly directives - Forth compiler support - Forth words - specific processor word versions - specific processor constants For more details, see the documentation for each of these. Forth words that are improved include: - : : can be used as traditionally or to make several entry points to a subroutine (word). Example: : ENTRY1 ... ( no ; here ) : ENTRY2 - ; : can be used as traditionally or to make several exit points from a subroutine (word). Example: ... IF DO-IF-TRUE ; ( exit point 1 ) ELSE DO-IF-FALSE ; ( exit point 2 ) THEN ; ( traditional use ) - AIF : alternative/advanced IF. it doesn't drop its argument, generating much better code than a ?DUP (inexistent in mary) and normal IF. Don't forget to DROP argument after ELSE, unless you want to chain several AIFs. 2.8 - Examples of code that take full advantage of optimizations ---------------------------------------------------------------- @ and ! are optimized for constants. They generate optimum code when preceded by the variable: MYVAR1 @ MYVAR2 ! is efficient but MYVAR1 @ MYVAR2 ! MYVAR3 @ MYVAR4 ! is even more efficient, as the restacking between "MYVAR2 !" and "MYVAR3 @" is suppressed. If you want to know, the first example generates 6 instructions while the second generates 8 instead of 12, as it eliminates 2 instructions for restoring TOS and avoids to generate 2 more for saving TOS. Similarly, sequences like 1 CONST, MYVAR1 ! are full optimized, as they use a special sequence to save TOS, generating only 4 instructions. Again, things like 1 CONST, MYVAR1 ! 2 CONST, MYVAR2 ! generates 6 instructions instead of 8, as the TOS resaving (restore/save) is avoided. mary can't optimize after THEN, so ... 0 < IF MYVAR1 @ ELSE MYVAR2 @ THEN ... produces a _much_ better code than ... 0 < IF MYVAR1 ELSE MYVAR2 THEN @ ... not to mention that "0 <" is optimized also, not requiring a specific 0< word. IF optimizes the < > and 0= operators and makes dead code elimination. Constants are optimized as much as possible, so 1 CONST, + generates one instruction incrementing TOS (register W), while 2 CONST, + generates one instruction adding 2 to the TOS. +! is very optimized, so 1 CONST, MYVAR +! generates one instruction directly incrementing MYVAR, 2 CONST, MYVAR +! generates two instructions incrementing MYVAR, and 37 CONST, MYVAR +! generates 5 instructions saving TOS, adding 37 to MYVAR and restoring TOS. Similarly, 37 CONST, MYVAR1 +! 42 CONST, MYVAR2 +! generates 8 instructions instead of 10, suppressing one restore/save sequence. 3 - Files ========= 3.1 - mary ---------- This is the compiler caller. Customize here the Forth system (currently gforth) and the prefix directory (currently /usr/local/lib/mary). Optionally, you can select a different default processor (currently 16c63). All the needed files are joined in the apropriate order. One of them, the one with the processor-specific constants, is included twice in the list: one for use with the assembler, the other for use with Forth. A typical invocation would be: mary -p 16c84 myfile.fs where the processor selected is different from the default one (16c84 in this case) and tries to compile myfile.fs 3.2 - savestate.fs ------------------ A minimal file for saving the host Forth system status. 3.3 - restorestate.fs --------------------- A minimal file for restoring the host Forth system status. 3.4 - picasm.fs --------------- The mid-range PIC assembler. For supporting the Forth compiler, although it can be used for writing low-level subroutines. However, accesing peripeherals don't need this, as they are mapped in memory, which is very efficiently accessed in mary. 3.5 - picforthsupp.fs --------------------- Some words needed for supporting the Forth compiler itself. They deal mainly with the code identifying for the corresponding optimizations. 3.6 - picforth.fs ----------------- The Forth compiler, except for the memory access words and some other processor-specific features. All the optimizations are done here. 3.7 - 16CXX-data.fs ------------------- Variables and constants defining the specific processor, mainly memory space. 3.8 - 16CXX-consts.fs --------------------- Constants taken from Microchip documentation for the specific processor. Included twice, one for the assembler, the other for the compiler. 3.9 - 16CXX-code.fs ------------------- Processor-specific code for dealing with memory access and some other peculiarities. 4 - Vocabularies ================ 4.1 - PICASM, the PIC assembler ------------------------------- PICASM is a traditional Forth-style assembler. Its target is (currently) the mid-range of Microchip PIC microcontrollers. Thanks to the simple addressing modes of the PIC family, there is only one word for every possible PIC instruction. There are additional words for defining every type of instruction, but this is of use only in defining the assembler. Several tools and pseudodirectives are available, some of them for use in the assembler, others for supporting the Forth compiler. Normally you only worry about them when creating some kind of words for the compiler, not for normal programming. 4.1.1 - Assembler pseudodirectives ---------------------------------- These are the words that allow to control the assembly. $ Variable containing the current assembly location pointer. Use it through the other manipulators. ORG ( N -- ) Sets the current assembly location pointer to PIC address N. Example: 200 ORG LABEL ( -- ; -- ADDR ) Creates a named label with the current value of $. When executing, it behaves as a constant that represents a PIC program memory address. As such, it can be used to be back referenced from any place in the program. Example: LABEL RIGHTHERE ... RIGHTHERE GOTO FLABEL ( -- ; -- ) Prepares a _SINGLE_ forward label reference for use with GOTO and CALL. The reason it only supports one forward reference is that its only use is in the assembler for supporting Forth, and that's the only requirement that arose. Feel free to submit new code for dealing with more than one reference, if you will. It probably implies making a sort of stack or array with associative addressing. Example: FLABEL FARAWAY GOTO ... FARAWAY HIGH ( N -- N ) Leaves the high bits of a PIC address. Use in assembly programming when defining special memory access words (as TABLE). Example: 173 HIGH LOW ( N -- N ) Leaves the low bits of a PIC address. Use in assembly programming when defining special memory access words (as TABLE). Example: 173 LOW 4.1.2 - Support words --------------------- These are the words that form the base for the assembler and support the Forth compiler in some way. $+ ( N -- $+N ) Aid for forward references. Calculates the address that is at N words from $. Used for jumping. Example: 3 $+ GOTO ( 3 instructions to be skipped here ) >PICROM ( PICADDR -- REALADDR ) Translates PIC address to real memory addres. Use only in the assembler. Example: 100 >PICROM $>PICROM ( -- ADDR ) Translates $ to real memory address. Use only in the assembler. Example: $>PICROM PICROM@ ( ADDR -- OPCODE ) Gets content at specified PIC ROM address. Use only in the Forth compiler. Example: 100 PICROM@ $@ ( -- OPCODE ) Gets content at current compiling address. Use only for optimizations in the Forth compiler. Example: $@ $! ( OPCODE -- ) Sets content at current compiling address. Use only in the assembler. Example: 0800 $! $+1 ( -- ) Advances current compiling address pointer. Use only for optimizations in the Forth compiler. Example: $+1 $-1 ( -- ) Backs current compiling addres pointer. Use only for optimizations in the Forth compiler. Example: $-1 $, ( OPCODE -- ) Compiles value at $ and advances 1 word. Use only in the assembler. Example: 0080 $, PATCHJUMP ( ADDR -- ) Patches a back reference of a forward jump. Example: (see definition or FLABEL or control flow words in PICFORTH for practical examples) 4.1.3 - PIC assembly language support ------------------------------------- These are the words that make PICASM possible. They deal with the various instruction types in the PIC instruction set. Use them in the assembler definition only. HIGH5BITS ( N -- N ) Gets the high 5 bits of an addres. For HIGH. Example: 173 HIGH5BITS LOW8BITS ( N -- N ) For constants, and registers with ,F or ,W. Example: 173 LOW8BITS LOW7BITS ( N -- N ) For registers in bit operations. Example: 173 LOW7BITS LOW11BITS ( N -- N ) For addresses. Example: 34582 LOW11BITS CONST ( OPCODE N -- OPCODE ) Embeds an 8-bit constant in an opcode. Example: 3F00 17 CONST ,F ( N -- N ) Selects file register as destination. Use when assembling. Example: 37 ,F DECF ,W ( N -- N ) Selects the W register as destination. Use when assembling. THIS IS THE DEFAULT IN PICASM, AS OPPOSITE TO MICROCHIP ASSEMBLER. Example: 37 ,W DECF REG ( OPCODE N -- OPCODE ) Defaults destination in an OPCODE as W. Use ,F or ,W for selecting the destination. Example: 0700 17 REG REGBIT ( OPCODE N -- OPCODE ) Selects bit for bit operations. Example: (see definition of BIT-OPCODE) BITSEL ( OPCODE BIT -- OPCODE ) For bit selection. Example: 1800 3 BITSEL ADDR ( OPCODE N -- OPCODE ) Embeds an address in an opcode. Example: 2800 173 ADDR IMMED-OPCODE ( N -- ; -- ) Defines an assembler mnemonic with immediate addressing mode (no arguments). Example: 0100 IMMED-OPCODE CLRW CONST-OPCODE ( N -- ; CONST -- ) Defines an assembler mnemonic with an embedded constant. Example: 3800 CONST-OPCODE IORLW REG-OPCODE ( N -- ; REG -- ) Defines an assembler mnemonic with register addressing. Example: 0A00 REG-OPCODE INCF BIT-OPCODE ( N -- ; REG BIT -- ) Defines an assembler mnemonic with register bit addressing. Example: 1000 BIT-OPCODE BCF ADDR-OPCODE ( N -- ; ADDR -- ) Defines an assembler mnemonic with register addressing. Example: 2000 ADDR-OPCODE CALL 4.1.4 - PIC assembler mnemonics ------------------------------- They are all identical to the ones used by the Microchip assembler. Don't forget to use the operands in reverse order: BTFSC STATUS,C becomes STATUS C BTFSC CALL SUB1 becomes SUB1 CALL DECF COUNT,F becomes COUNT ,F DECF As you can see, the STATUS register bits have a name equal to the Microchip assembler definitions, but they don't have a comma prepended. That's because they are named constants. The complete mnemonic list: ADDLW ADDWF ANDLW ANDWF BCF BSF BTFSC BTFSS CALL CLRF CLRW CLRWDT COMF DECF DECFSZ GOTO INCF INCFSZ IORLW IORWF MOVLW MOVF MOVWF NOP RETFIE RETLW RETURN RLF RRF SLEEP SUBLW SUBWF SWAPF XORLW XORWF 4.1.5 - Utilities ----------------- These are the words that can be used externally, although most of them are used inside the assembler. Documenting them is mandatory, you know... INIT-PICASM ( -- ) Initalizes the PIC assembler, namely clears the ROM space, etc. Example: INIT-PICASM PICPROGSIZE ( -- N ) Leaves in the stack the current program size. Example: PICPROGSIZE .PICPROGSIZE Shows an self-explaining text about the current program size. Example: .PICPROGSIZE HEX8. ( N -- ) Shows an 8-bit hex number. Example: 37 HEX8. HEX16. ( N -- ) Shows a 16-bit hex number. Example: 34582 HEX16. MEMDUMPLINE ( ADDR -- ) Shows 8 PIC program memory words starting at ADDR. Example: 100 MEMDUMPLINE MEMDUMP ( ADDR COUNT -- ) Shows COUNT MEMDUMPLINEs starting at ADDR. Useful for debugging the compiler. Example: 100 4 MEMDUMP HEXDUMPLINE ( ADDR -- ) Shows 8 PIC program memory words in Intel HEX format. Example: 100 HEXDUMPLINE HEXDUMP ( ADDR COUNT -- ) Shows COUNT HEXDUMPLINEs starting at ADDR. Example: 100 4 HEXDUMP PROGDUMP ( -- ) Dumps current program in Intel HEX format from 0 TO $. Used for generating a text describing your program in order to be burned into a PIC. The mary driver calls it accordingly, so you don't need to care for this. Example: PROGDUMP 4.2 - PICFORTH, the free mary PIC Forth optimizing native code compiler ----------------------------------------------------------------------- PICFORTH (mary) is an "underground" (in Chuck Moore's sense) Forth. As such, it tries to be useful by containing a subset of Forth well suited to PIC programming. Some words have changed their usual semantics, several other have been added for unique PIC functions. 4.2.1 - Forth words ------------------- These are words making the Forth vocabulary in which you will write your programs most of the time. Most of them are semantically equivalent to their homonyms in any normal Forth system. There are some variations and additions. All arithmetic words are optimized for constants. Additionally, several logical operators (<, > and 0=) are optimized in IF. Other ones (= and <>) are not, because they are not further optimizable. All words whose name is (WORD) are assembler subroutines intended for use by the compiler. Don't use them directly, as they can't optimized anything and will be compiled as a subroutine call, when there may be another faster solution. CONSTANT ( N -- ) Creates a named constant. Example: 173 CONSTANT WHATEVER VARIABLE ( -- ) Creates a named global variable. Example: VARIABLE COUNT TABLE ( -- ; N1 -- N2 ) Creates a header for indexed table access. Unique to PIC programming. At compilation time, no parameters are needed; just add elements with ",". At run time, it takes the TOS as an index into the table and leaves the value of that element. Optimized for constant. Example: TABLE CONVERSION ... 4 CONVERSION , ( N -- ) Compiles value in current compiling address. Use only for adding elements to a TABLE. Example: TABLE CONVERSION 4 , 3 , 2 , 1 , 0 , DROP ( N -- ) Drops the top of stack (TOS). Discards the TOS by making the second on stack the new TOS. Example: DROP DUP ( N -- N N ) Copies TOS in a new TOS. Old TOS becomes second on stack. Example: DUP NIP ( N1 N2 -- N2 ) Equivalent to: "SWAP DROP". A handy word, and it compiles to only 1 PIC instruction. Example: NIP OVER ( N1 N2 -- N1 N2 N1 ) Copies second on stack to new TOS Example: OVER SWAP ( N1 N2 -- N2 N1 ) Exchanges the 2 topmost elements on stack. Example: SWAP S>D ( U -- UD ) Converts to double precision. In fact, pushes a 0 into the stack, not doing sign extension. Example: S>D D>S ( UD -- U ) Converts to single precision. Drops the TOS. Example: D>S - ( N1 N2 -- N1-N2 ) Substracts N2 from N1. Example: - 1 - ( optimization gets rid of 1- ) + ( N1 N2 -- N1+N2 ) Adds N1 to N2. Example: + 1 + ( optimization gets rid of 1+ ) 2* ( U -- U*2 ) Multiplies TOS by 2. Example: 2* 2/ ( U -- U/2 ) Divides TOS by 2. Example: 2/ ABS ( N -- U ) Calculates absolute value of TOS. Example: ABS NEGATE ( N -- -N ) Calculates negative of TOS. Example: NEGATE AND ( N1 N2 -- N3 ) Bitwise and. Example: AND INVERT ( N1 -- !N1 ) Bitwise not. Example: NOT OR ( N1 N2 -- N3 ) Bitwise or. Example: OR XOR ( N1 N2 -- N3 ) Bitwise XOR (exclusive-or). Example: XOR < ( U1 U2 -- F ) Leaves a TRUE flag if U1 < U2. Example: < 0 < ( optimization gets rid of 0< ) < IF ( optimization possible ) <> ( N1 N2 -- F ) Leaves a TRUE flag if N1 is not equal to N2. Example: <> = ( N1 N2 -- F ) Leaves a TRUE flag if N1 = N2. Example: = = IF > ( U1 U2 -- F ) Leaves a TRUE flag if U1 > U2. Example: > 0= ( N -- F ) Logical invert. Example: 0= IF ( optimization possible ) IF ( -- ADDR CF ; F -- ) Condition for IF ... ELSE ... THEN. At run time, checks and discards the TOS: if 0, skips code up to next ELSE or THEN; if not 0, executes following code. It optimizes <, > and 0=, and deals with dead code suppression. Example: MYVAR @ IF SOMETHING ELSE OTHER THEN ( executes SOMETHING if MYVAR is not 0, else executes OTHER ) AIF ( -- ADDR CF ; F -- F ) Alternative-IF for AIF ... ELSE ... THEN. Similar to IF, but it don't discard TOS. The construction "?DUP IF ... THEN" becomes "AIF ... ELSE DROP THEN" in mary. It optimizes <, > and 0=, and deals with dead code suppression. Example: MYVAR @ AIF ... ELSE DROP THEN ( optimized for TRUE branch ) ELSE ( ADDR1 CF -- ADDR2 CF ; -- ) FALSE condition branch for IF/AIF ... ELSE ... THEN. Deals with dead code suppression. Example: MYVAR @ IF SOMETHING ELSE OTHER THEN ( executes SOMETHING if MYVAR is not 0, else executes OTHER ) THEN ( ADDR CF -- ; -- ) Ends IF/AIF ... ELSE ... THEN. Deals with dead code suppression. Example: MYVAR @ IF SOMETHING ELSE OTHER THEN ( executes SOMETHING if MYVAR is not 0, else executes OTHER ) BEGIN ( -- ADDR CF ; -- ) Starts BEGIN loop. Use it for BEGIN ... AGAIN, BEGIN ... UNTIL and BEGIN ... WHILE ... REPEAT loops. Example: BEGIN BORING AGAIN ( a sure way to get bored ) AGAIN ( ADDR CF -- ; -- ) Ends BEGIN ... AGAIN LOOP. This is an indefinite loop, you must exit from inside, else it will loop forever (if the computer is eternal, at least). Example: BEGIN BORING AGAIN ( a sure way to get bored ) UNTIL ( ADDR CF -- ; F -- ) Ends BEGIN ... UNTIL loop. When execution reaches UNTIL, it will loop back from BEGIN if value at TOS is non FALSE. TOS is discarded. Example: 5 CONST, BEGIN OTHER 1 - DUP UNTIL ( does OTHER 5 times ) WHILE ( ADDR1 CF -- ADDR1 ADDR2 CF ; F -- ) Condition for BEGIN ... WHILE ... REPEAT loop. When execution reaches WHILE, it will exit loop if value at TOS is non FALSE. TOS is discarded. Loops back from REPEAT to BEGIN. Example: 5 CONST, BEGIN 1 - DUP WHILE OTHER REPEAT ( does OTHER 4 times ) REPEAT ( ADDR CF -- ; -- ) Ends BEGIN ... WHILE ... REPEAT loop. When execution reaches REPEAT, it will loop back to BEGIN. Example: 5 CONST, BEGIN 1 - DUP WHILE OTHER REPEAT ( does OTHER 4 times ) : ( -- ) Creates a named subroutine entry point. It can be used for creating a word in the traditional way or to create several entry points (useful for substituting assembler code, as this is a known technique). Example: : ENTRY1 ... : ENTRY2 ... ; ; ( -- ) Creates a return point. It makes the word/routine to return immediately to caller. It optimizes return stack use, so that a word call before ; translates to a jump when possible, saving one stack level. Example: : MYWORD IF OTHER ; ELSE ANOTHER ; THEN ; ( 3 exit points ) (!) ( N ADDR -- ) Stores N in ADDR. _DON'T USE THIS WORD DIRECTLY_, use ! instead. Example: 5 CONST, MYVAR (!) (+!) ( N ADDR -- ) Adds N to the contents of ADDR. _DON'T USE THIS WORD DIRECTLY_, use +! instead. Example: 5 CONST, MYVAR (+!) (@) ( ADDR -- N ) Fetches contents of ADDR. _DON'T USE THIS WORD DIRECTLY_, use @ instead. Example: MYVAR (@) (*) ( U1 U2 -- U1*U2 ) Multiplies U1*U2, giving an 8-bit result. _DON'T USE THIS WORD DIRECTLY_, use * instead. Example: 5 CONST, 6 CONST, (*) (/MOD) ( U1 U2 -- U1\U2 U1/U2 ) Divides U1/U2, U1\U2 is the remainder. _DON'T USE THIS WORD DIRECTLY_, use /MOD instead. Example: 5 CONST, 2 CONST, (/MOD) (LSHIFT) ( U1 U2 -- U3 ) Left shifts U2 times U1, giving U3. _DON'T USE THIS WORD DIRECTLY_, use LSHIFT instead. Example: 5 CONST, 3 CONST, (LSHIFT) (RSHIFT) ( U1 U2 -- U3 ) ( RIGHT SHIFTS U2 TIMES U1 GIVING U3 ) Right shifts U2 times U1, giving U3. _DON'T USE THIS WORD DIRECTLY_, use RSHIFT instead. Example: 35 CONST, 3 CONST, (RSHIFT) / ( U1 U2 -- U1/U2 ) Divides U1/U2, giving an 8-bit result. Example: 5 CONST, 2 CONST, / /MOD ( U1 U2 -- U1\U2 U1/U2 ) Divides U1/U2, U1\U2 is the remainder. All are 8-bit entities. Example: 5 CONST, 2 CONST, /MOD * ( N1 N2 -- N1*N2 ) Multiplies N1*N2, giving an 8-bit result. Example: 5 CONST, 6 CONST, * MOD ( U1 U2 -- U1\U2 ) Calculates the remainder of U1/U2. Example: 5 CONST, 2 CONST, MOD @ ( ADDR -- N ) Fetches contents at ADDR. Optimum code is generated when preceded by a variable. Example: MYVAR @ INCDECLOOP ( ADDR N -- ) Generates code for +! INCF/DECF loops. Internal use only. Example: INCDECLOOP +! ( N ADDR -- ) Adds N to the contents of ADDR. Example: 5 CONST, MYVAR (+!) ! ( N ADDR -- ) Stores N in ADDR. Optimum code is generated when preceded by its arguments. Example: 5 CONST, MYVAR (!) LSHIFT ( U1 U2 -- U3 ) Left shifts U2 times U1, giving U3. Example: 35 CONST, 3 CONST, (RSHIFT) RSHIFT ( U1 U2 -- U3 ) Right shifts U2 times U1, giving U3. _DON'T USE THIS WORD DIRECTLY_, use RSHIFT instead. Example: 35 CONST, 3 CONST, (RSHIFT) 4.2.2 - Forth support words --------------------------- These are words necessary for supporting the Forth compiler. A few of them are to be used when programming, but here instead of in the Forth compiler because they are needed for some of the words in this group. INIT-PIC ( -- ) Minimal startup code for PIC Forth. Currently, gives an initial value to the indirect addressing register, used as data stack pointer. Called by INIT-PICFORTH Example: INIT-PIC INIT-PICFORTH ( -- ) Initializes PIC Forth system. The mary driver uses it for starting the system. Example: INIT-PICFORTH PHERE ( -- ADDR ) Current compiling address; as HERE in the host Forth. Name changed for several reasons. Example: PHERE TOPATCH ( -- ADDR 0 ) An address to be patched later by PATCHJUMP. Uses the curren value of $. Example: TOPATCH DONTPATCH ( -- ADDR ) Marks a spot in order not to be patched. Used in dead code suppression. Example: DONTPATCH DEADCODE ( -- ) Marks a spot as dead code begin, to be suppressed later by KILLDEADCODE. Example: DEADCODE NODEADCODE ( -- ) Marks a spot as dead code cancellation. Example: NODEADCODE DEADCODE? ( ADDR -- ADDR F ) Leaves a TRUE flag if we are in dead code. Example: PHERE DEADCODE? KILLDEADCODE ( ADDR -- ) Suppress dead code by backskipping it. Example: PHERE ... KILLDEADCODE ( would suppress back to PHERE ) OPT ( -- ) Marks a spot as optimizable. Use in case you know it's possible to optimize, but code shape don't permit. Freely usable. Example: : ENTRY1 ... : ENTRY2 OPT ( normally can't optimize here ) NOOPT ( -- ) Marks a spot as non-optimizable. Use in case you know the optimizer would want to alter code you prefer not to. Freely usable. Example: : VALIDDEF 2* ; : NULLDEF NOOPT ; ( NULLDEF would be empty if not ) OPT? ( -- F ) Leaves a TRUE flag if optimization is possible. Example: OPT? RETURN? ( -- F ) Leaves a TRUE flag if last assembled opcode is a return. Example: RETURN? CALL? ( -- OPCODE F ) OPCODE and TRUE flag if call optimization is possible. Example: CALL? CALL>JUMP ( OPCODE -- ) Convertes a CALL into a jump (GOTO in PIC parlance). A kind of optimization. Use _ONLY_ in conjunction with CALL? Example: CALL? IF CALL>JUMP POP ( -- ) Generates code to pop W from stack. Used by DROP, etc. Use in the compiler. Example: POP PUSH ( -- ) Generates code to push W into stack. Used by CONST, and so. Use in the compiler. Example: PUSH RESTACK? ( -- F ) TRUE flag if restacking POP/PUSH optimization is possible. Example: RESTACK? CONST, ( N -- ) Embeds a constant in the code. Use manually for this task, the compiler uses it internally to embed any constant. Example: 37 CONST, MYVAR ! ( store 37 in MYVAR ) CONST? ( -- N F ) Constant and TRUE flag if constant optimization is possible. Example: CONST? IF KILLCONSTANT DROP ( excerpt from DROP ) KILLCONST ( -- ) Backs $ in order to suppress a constant. Example: CONST? IF KILLCONSTANT DROP ( excerpt from DROP ) SAVETOS ( -- ) Generates code to save TOS. Used by the compiler when optimizing 1 level of operands. Example: SAVETOS RESTORETOS ( -- ) Generates code to restore TOS. Used by the compiler when optimizing 1 level of operands. Example: SAVETOS ABS8 ( N -- |N| ) Calculates the absolute value of N for 8-bit data values. Used internally. Example: -3 ABS8 42 ABS8 ?PAIRS ( F1 F2 -- ) Check parts of a flow control structure. Aborts with an error message if flags F1 and F2 are different. Example: (see definition of ELSE for practical examples) 0=? ( -- F ) TRUE flag if 0= optimization is possible. _USE ONLY IN IF_ Example: (see definition of IF for practical examples) ? ( -- F ) TRUE flag if > optimization is possible. _USE ONLY IN IF_ Example: (see definition of IF for practical examples) 4.2.3 - PIC specific support words ---------------------------------- These are words for dealing with the rather strange PIC data space. They must be redefined for every PIC model, although there are some models that share memory layout, so the code can be copied. PIC data space is laid out in banks, possibly with not all RAM locations implemented and with different free RAM (peripherals are mapped in this space too). There can be up to 4 different banks in mid-range PICs. Don't use directly these words, only in the compiler. ALLOC ( N -- ADDR ) Allocates N contiguous cell and leaves starting ADDR. Don't use it for dynamic allocation, as there is no provision for freeing memory later. Example: 15 ALLOC ALLOT ( N -- ) Reserves N cells in variable space. _USE ALLOC INSTEAD_ Example: 15 ALLOT BANK0 ( ADDR -- ) Generates code for switching to RAM bank 0 if needed. mary assumes we are always in bank 0. Example: MYVAR BANK1 FETCH BANK0 BANK0FREE ( -- N ) Gives the free space in bank 0 for variable allocation. ALLOC uses it. Example: BANK0FREE BANK1 ( ADDR -- ADDR ) Generates code for switching to RAM bank 1 if needed. mary assumes we are always in bank 0. ADDR remains in the stack for easy chaining. Example: MYVAR BANK1 FETCH BANK0 BANK1FREE ( -- N ) Gives the free space in bank 1 for variable allocation. ALLOC uses it. Example: BANK1FREE BVARIABLE ( N -- ) Creates a named global "big" variable, N cells in size. It uses ALLOC, so it allocates in the proper bank. If your program has memory problems, remember these easy rules: - allocate variables in descending size order (biggest first) - you can define different constants to index a shared memory area - think first of the real memory requirements and switch to a better processor if needed (most of the time the previous rules make the deal) Example: 5 BVARIABLE MYVAR FETCH ( ADDR -- ) Generates code for fetching from a constant address. Takes into account bank changes. Used by @ Example: MYVAR FETCH INIT-PICMEM ( -- ) Initializes PIC memory system. Called from INIT-PICFORTH. Example: INIT-PICMEM STORE ( ADDR -- ) Generates code for storing to a constant address. Takes into account bank changes. Used by ! Example: MYVAR STORE 5 - Programming with mary ========================= 5.1 - A little example ---------------------- This is a very little example. More to come when the docs leave alpha stage. Let's say our file is example.fs (fs meaning "Forth stream", as opposite to a bunch of Forth screens (1k-octet blocks), the classical way). Our project is a silly one: connect 4 switches to RA0 ... RA3 in the PIC, and 4 LEDs with serial resistors to RB0 ... RB3. Don't forget to make an oscillator and a power supply. The program couldn't be simpler: -----8<----- PICFORTH INIT-PICFORTH ( CLEARS MEMORY ) INIT-PIC : SILLYTEST BEGIN PORTA @ PORTB ! AGAIN ; -----8<----- Compile it with: mary -p 16c84 example.fs > example.hex and burn into the C84 with our favorite programmer. And that's all. The program doesn't use any external resources, so the code is very small. In the general case, we don't use INIT-PICFORTH, as there are some subroutines needed for words like @. A - A Taoist-like story about Forth ----------------------------------- I have said that Forth could have helped me with my life. I have said even that Forth can help you to understand the Universe. This appendix don't try to teach you Forth, Taoism, the Universe, the life or anything. It simply is here, and you are there. Or maybe "here" and "there" mean the same, or even nothing. For learning Forth, there are many texts around, I will do my best to recommend one if I can find an adecuate one. About Taoism, the definitive text is the "Tao Te King", translated to too many languages to list here. It's interesting and appropriate for this appendix, not meaning anything about religion nor following a given philosophy. As for your life, the one who best know it and can help you is yourself. A mirror can help. Forth can help. A friend can help. But the only one able to change what is to be changed (in case that is the case) is you. Said that, lets begin. In Forth, the variables are constants. The constants are executed. There is no compiler, no code generator, no optimizer, no syntax nor syntax checker, no lexical analyzer. There are no programs. But everything works. Frequently, the Forth novices, seeing too many differences with their previous learning, abandon desperately. Paradoxically, the simplicity of Forth seems to them a great complexity when compared to other languages. Time to unlearn and learn again. This is an important lesson for life. The computer memory when clear is like the Void: it has the potential to contain anything. Only by making the decision to change its content to any value we like, we give it a sensible meaning. The meaning is not in the value, but in us. The memory remains being memory, and any value change is not permanent (obvioulsy true for RAMs; but ROMs do break, you know). The memory is permanent, and its content can be data or code. Variables in Forth are really constants, representing the address where we can change or read the values. But constants are Forth words, and as such, executable code. So, the variables are executable, too. If data represent inanimated objects (matter, if you prefer) in our everyday lives, by realizing that variables are code, we now see that matter is a process. And everything in Forth is executable, so in our analogy, everything is a process, matter and energy. In the computer (in a Von Neumann architecture, at least), code and data seems all alike. Only the fact that the processor reads ones instead the others makes a difference. A difference in the observer's mind, be it a machine or a human being. There is no such thing as a Forth compiler (not even mary). Seen in perspective from a certain distance, it's possible to say that there is a compiler, but we must keep in mind that the program to be compiled is calling actively every needed word to make the compilation possible. So, there is no compiler, but compiling words that generate their own code and make their optimizations. They don't exist outside a Forth system, nor outside the memory when running. There are no big programs that do everything, but everything is done. Forth applications are not programs, also. They are words defined to do a job when used in a whole. But they may seem that individually don't do anything useful. They are little parts of a whole, everyone taking care of an aspect of the problem, until there is no problem at all. The "Not Doing" as a practical philosophy. Once you have defined words suited to your problem, you have the right tool, and the "program" to solve it is done by itself (really). doc/LEEME0100644000076400007640000000320207056301062011060 0ustar frerfrermary 1.0a50 - un compilador optimizador de Forth de código nativo para microcontroladores PIC Publicado en febrero de 2000 Copyright Francisco Rodrigo Escobedo Robles, 2000 Visita http://www.pepix.net/proyectos/glazz/mary/ para más información y últimas versiones Contacta con frer@pepix.net para cualquier sugerencia mary es libre al ser una obra Open Source Esta versión está publicada bajo la licencia GNU General Public License en su versión 2 mary está actualmente en fase alfa, así que se publica para usarlo con las debidas precauciones. Honestamente, creo que funciona, pero puede causar errores inesperados, de los cuales no me hago responsable. Particularmente, si todo el Universo se colapsa, soy inocente. Este es el fichero LEEME mary está en fase alfa. La documentación también. Pueden haber cambios importantes antes de entrar en beta. mary es un compilador optimizador de Forth de código nativo para microcontroladores PIC. Genera instrucciones en lenguaje máquina y optimiza secuencias, constantes y operadores lógicos. El manual es el fichero mary-manual.txt, y el único motivo por el que no hay versión en español todavía es que me falta el tiempo. Para cuando esté en beta o en gamma espero poder hacer uno. Aunque el inglés sólo es el segundo idioma del mundo (el primero es el chino), mucha gente no habla español y me interesa que puedan echarle un ojo a mi obra y aportar sugerencias. Por eso los comentarios también se hallan en inglés. Mis disculpas. Pero no me enviéis mensajes quejándoos de esto, porque entonces las siguientes versiones estarán en esperanto. Para instalarlo: tar -C /usr/local -zxvf mary-1.0a50.tar.gz lib/0040755000076400007640000000000007056262650010326 5ustar frerfrerlib/share/0040755000076400007640000000000007056262650011430 5ustar frerfrerlib/share/mary/0040755000076400007640000000000007056266235012403 5ustar frerfrerlib/share/mary/16c63-code.fs0100644000076400007640000000733007055270266014405 0ustar frerfrer( FORTH MID-RANGE SPECIFIC PIC 16C63 CODE, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB18. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) ( REQUIRING DEFINITIONS FROM THE SEARCH WORD SET ) ( REQUIRING FORTH, ALSO FROM THE SEARCH EXT WORD SET ) ( REQUIRING THE PICASM WORD SET ) ( PIC FORTH SPACE ) FORTH DEFINITIONS VOCABULARY PICFORTH PICFORTH ALSO PICASM ALSO FORTH ALSO PICFORTH DEFINITIONS HEX ( PROCESSOR-SPECIFIC CODE ) ( THE FOLLOWING WORDS MUST BE REDEFINED ) ( FOR EACH PROCESSOR IN ORDER TO DEAL ) ( WITH THE RATHER STRANGE PIC DATA SPACE ) : BANK0FREE ( -- N ) ( GIVES THE FREE SPACE IN BANK 0 FOR VARIABLE ALLOCATION ) MAXPICRAM0 @ VARP0 @ - ; : BANK1FREE ( -- N ) ( GIVES THE FREE SPACE IN BANK 1 FOR VARIABLE ALLOCATION ) MAXPICRAM1 @ VARP1 @ - ; : ALLOC ( N -- ADDR ) ( ALLOCATES N CONTIGUOUS CELLS AND LEAVES STARTING ADDR ) BANK0FREE OVER < 0= IF VARP0 @ SWAP VARP0 +! EXIT THEN BANK1FREE OVER < 0= IF VARP1 @ SWAP VARP1 +! EXIT THEN DROP PICERROR ABORT" NOT ENOUGH MEMORY FOR VARIABLE" ; : ALLOT ( N -- ) ( RESERVES N CELLS IN VARIABLE SPACE. _USE ALLOC INSTEAD_ ) ALLOC DROP ; : BVARIABLE ( N -- ) ( CREATES A NAMED GLOBAL BIG VARIABLE, N CELLS IN SIZE ) CREATE ALLOC ( ALLOCATES MEMORY FOR VARIABLE ) , ( STORES VARIABLE POINTER ) DOES> @ CONST, ; ( VARIABLE ACCESS ) ( IT IS ASSUMED THAT WE ARE ALWAYS IN BANK 0. SO, BEFORE AND AFTER AN ) ( ACCESS POSSIBLY REQUIRING A BANK CHANGE, USE BANK1 AND BANK0. THEY ) ( ARE OPTIMIZED IN ORDER TO CHANGE BANK ONLY WHEN NEEDED ) : BANK0 ( ADDR -- ) ( GENERATES CODE FOR SWITCHING TO RAM BANK 0 IF NEEDED ) OPT? IF ( OPTIMIZATION POSSIBLE? ) CURRENTBANK @ 0 = IF DROP EXIT ( ALREADY IN BANK 0 ) THEN 80 AND IF $-1 $@ 1403 = ( PRECEDED BY BANK1? ) IF ( YES, SUPPRESS IT ) ELSE $+1 STATUS RP0 BCF ( SWITCH TO BANK 0 ) THEN THEN ELSE STATUS RP0 BCF ( SWITCH TO BANK 0 ) THEN 0 CURRENTBANK ! ; : BANK1 ( ADDR -- ADDR ) ( GENERATES CODE FOR SWITCHING TO RAM BANK 1 IF NEEDED ) OPT? IF ( OPTIMIZATION POSSIBLE? ) CURRENTBANK @ 1 = IF EXIT ( ALREADY IN BANK 1 ) THEN DUP 80 AND IF ( ADDR IN BANK 1? ) $-1 $@ 1003 = ( PRECEDED BY BANK0? ) IF ( YES, SUPPRESS IT ) ELSE $+1 STATUS RP0 BSF ( NO, SWITCH TO BANK 1 ) THEN THEN ELSE STATUS RP0 BSF ( NO, SWITCH TO BANK 1 ) THEN 1 CURRENTBANK ! ; : FETCH ( ADDR -- ) ( GENERATES CODE FOR FETCHING FROM A CONSTANT ADDRESS ) DUP BANK1 ,W MOVF ( VALUE IN TOS ) BANK0 ; : STORE ( ADDR -- ) ( GENERATES CODE FOR STORING IN A CONSTANT ADDRESS ) DUP BANK1 MOVWF ( VALUE IN TOS ) BANK0 ; : INIT-PICMEM ( -- ) ( INITIALIZES PIC MEMORY SYSTEM ) 0 CURRENTBANK ! ( BANK 0 ) ; lib/share/mary/16c63-consts.fs0100644000076400007640000000706707055041225015002 0ustar frerfrer( FORTH MID-RANGE PIC CONSTANTS FOR 16C63, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB18. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) HEX ( CONSTANTS FOR 16C63 BASED PIC FORTH ) ( COMMON REGISTER NAMES ) 00 CONSTANT INDF 01 CONSTANT TMR0 02 CONSTANT PCL 03 CONSTANT STATUS 04 CONSTANT FSR 05 CONSTANT PORTA 06 CONSTANT PORTB 07 CONSTANT PORTC 0A CONSTANT PCLATH 0B CONSTANT INTCON 0C CONSTANT PIR1 0D CONSTANT PIR2 0E CONSTANT TMR1L 0F CONSTANT TMR1H 10 CONSTANT T1CON 11 CONSTANT TMR2 12 CONSTANT T2CON 13 CONSTANT SSPBUF 14 CONSTANT SSPCON 15 CONSTANT CCPR1L 16 CONSTANT CCPR1H 17 CONSTANT CCP1CON 18 CONSTANT RCSTA 19 CONSTANT TXREG 1A CONSTANT RCREG 1B CONSTANT CCPR2L 1C CONSTANT CCPR2H 1D CONSTANT CCP2CON 81 CONSTANT OPTION_REG 85 CONSTANT TRISA 86 CONSTANT TRISB 87 CONSTANT TRISC 8C CONSTANT PIE1 8D CONSTANT PIE2 8E CONSTANT PCON 92 CONSTANT PR2 93 CONSTANT SSPADD 94 CONSTANT SSPSTAT 98 CONSTANT TXSTA 99 CONSTANT SPBRG ( STATUS BITS ) 07 CONSTANT IRP 06 CONSTANT RP1 05 CONSTANT RP0 04 CONSTANT NOT_TO 03 CONSTANT NOT_PD 02 CONSTANT Z 01 CONSTANT DC 00 CONSTANT C ( INTCON BITS ) 07 CONSTANT GIE 06 CONSTANT PEIE 05 CONSTANT T0IE 04 CONSTANT INTE 03 CONSTANT RBIE 02 CONSTANT T0IF 01 CONSTANT INTF 00 CONSTANT RBIF ( PIR1 BITS ) 05 CONSTANT RCIF 04 CONSTANT TXIF 03 CONSTANT SSPIF 02 CONSTANT CCP1IF 01 CONSTANT TMR2IF 00 CONSTANT TMR1IF ( PIR2 BITS ) 00 CONSTANT CCP2IF ( T1CON BITS ) 05 CONSTANT T1CKPS1 04 CONSTANT T1CKPS0 03 CONSTANT T1OSCEN 02 CONSTANT NOT_T1SYNC 02 CONSTANT T1INSYNC 01 CONSTANT TMR1CS 00 CONSTANT TMR1ON ( T2CON BITS ) 06 CONSTANT TOUTPS3 05 CONSTANT TOUTPS2 04 CONSTANT TOUTPS1 03 CONSTANT TOUTPS0 02 CONSTANT TMR2ON 01 CONSTANT T2CKPS1 00 CONSTANT T2CKPS0 ( SSPCON BITS ) 07 CONSTANT WCOL 06 CONSTANT SSPOV 05 CONSTANT SSPEN 04 CONSTANT CKP 03 CONSTANT SSPM3 02 CONSTANT SSPM2 01 CONSTANT SSPM1 00 CONSTANT SSPM0 ( CCP1CON BITS ) 05 CONSTANT CCP1X 04 CONSTANT CCP1Y 03 CONSTANT CCP1M3 02 CONSTANT CCP1M2 01 CONSTANT CCP1M1 00 CONSTANT CCP1M0 ( RCSTA BITS ) 07 CONSTANT SPEN 06 CONSTANT RX9 06 CONSTANT RC9 06 CONSTANT NOT_RC8 06 CONSTANT RC8_9 05 CONSTANT SREN 04 CONSTANT CREN 02 CONSTANT FERR 01 CONSTANT OERR 00 CONSTANT RX9D 00 CONSTANT RCD8 ( CCP2CON BITS ) 05 CONSTANT CCP2X 04 CONSTANT CCP2Y 03 CONSTANT CCP2M3 02 CONSTANT CCP2M2 01 CONSTANT CCP2M1 00 CONSTANT CCP2M0 ( OPTION BITS ) 07 CONSTANT NOT_RBPU 06 CONSTANT INTEDG 05 CONSTANT T0CS 04 CONSTANT T0SE 03 CONSTANT PSA 02 CONSTANT PS2 01 CONSTANT PS1 00 CONSTANT PS0 ( PIE1 BITS ) 05 CONSTANT RCIE 04 CONSTANT TXIE 03 CONSTANT SSPIE 02 CONSTANT CCP1IE 01 CONSTANT TMR2IE 00 CONSTANT TMR1IE ( PIE2 BITS ) 00 CONSTANT CCP2IE ( PCON BITS ) 01 CONSTANT NOT_POR 00 CONSTANT NOT_BO 00 CONSTANT NOT_BOR ( SSPSTAT BITS ) 05 CONSTANT D 05 CONSTANT I2C_DATA 05 CONSTANT NOT_A 05 CONSTANT NOT_ADDRESS 05 CONSTANT D_A 05 CONSTANT DATA_ADDRESS 04 CONSTANT P 04 CONSTANT I2C_STOP 03 CONSTANT S 03 CONSTANT I2C_START 02 CONSTANT R 02 CONSTANT I2C_READ 02 CONSTANT NOT_W 02 CONSTANT NOT_WRITE 02 CONSTANT R_W 02 CONSTANT READ_WRITE 01 CONSTANT UA 00 CONSTANT BF ( TXSTA BITS ) 07 CONSTANT CSRC 06 CONSTANT TX9 06 CONSTANT NOT_TX8 06 CONSTANT TX8_9 05 CONSTANT TXEN 04 CONSTANT SYNC 02 CONSTANT BRGH 01 CONSTANT TRMT 00 CONSTANT TX9D 00 CONSTANT TXD8 lib/share/mary/16c63-data.fs0100644000076400007640000000266607055041225014402 0ustar frerfrer( FORTH MID-RANGE PIC DATA FOR 16C63, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB19. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) HEX ( HERE ARE THE VARIABLES AND CONSTANTS NEEDED ) ( FOR THE PROCESSOR-SPECIFIC CODE AND RELATED ) ( WORDS IN THE PIC FORTH ) ( PIC MEMORY VARIABLES ) VARIABLE MAXPICRAM0 ( HIGHEST RAM ADDRESS, BANK 0 ) VARIABLE MINPICRAM0 ( LOWEST RAM ADDRESS, BANK 0 ) VARIABLE VARP0 ( VARIABLE POINTER FOR BANK 0 ) VARIABLE MAXPICRAM1 ( HIGHEST RAM ADDRESS, BANK 1 ) VARIABLE MINPICRAM1 ( LOWEST RAM ADDRESS, BANK 1 ) VARIABLE VARP1 ( VARIABLE POINTER FOR BANK 1 ) 7F MAXPICRAM0 ! 20 MINPICRAM0 ! 0FF MAXPICRAM1 ! 0A0 MINPICRAM1 ! 1000 MAXPICROM ! ( PIC MEMORY CONSTANTS ) MINPICRAM0 @ CONSTANT TMP1 MINPICRAM0 @ 1 + CONSTANT TMP2 MINPICRAM0 @ 2 + CONSTANT TMP3 MINPICRAM0 @ 3 + MINPICRAM0 ! ( FOR VARIABLE ALLOCATION ) 10 CONSTANT STACKSIZE ( DATA STACK SIZE ) MAXPICRAM0 @ CONSTANT INITSP ( INITIAL DATA STACK POINTER ) MINPICRAM0 @ VARP0 ! MINPICRAM1 @ VARP1 ! STACKSIZE NEGATE MAXPICRAM0 +! lib/share/mary/16c84-code.fs0100644000076400007640000000703307055270271014404 0ustar frerfrer( FORTH MID-RANGE SPECIFIC PIC 16C84 CODE, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) ( REQUIRING DEFINITIONS FROM THE SEARCH WORD SET ) ( REQUIRING FORTH, ALSO FROM THE SEARCH EXT WORD SET ) ( REQUIRING THE PICASM WORD SET ) ( PIC FORTH SPACE ) FORTH DEFINITIONS VOCABULARY PICFORTH PICFORTH ALSO PICASM ALSO FORTH ALSO PICFORTH DEFINITIONS HEX ( PROCESSOR-SPECIFIC CODE ) ( THE FOLLOWING WORDS MUST BE REDEFINED ) ( FOR EACH PROCESSOR IN ORDER TO DEAL ) ( WITH THE RATHER STRANGE PIC DATA SPACE ) : BANK0FREE ( -- N ) ( GIVES THE FREE SPACE IN BANK 0 FOR VARIABLE ALLOCATION ) MAXPICRAM0 @ VARP0 @ - ; : ALLOC ( N -- ADDR ) ( ALLOCATES N CONTIGUOUS CELLS AND LEAVES STARTING ADDR ) BANK0FREE OVER < 0= IF VARP0 @ SWAP VARP0 +! EXIT THEN DROP PICERROR ABORT" NOT ENOUGH MEMORY FOR VARIABLE" ; : ALLOT ( N -- ) ( RESERVES N CELLS IN VARIABLE SPACE. _USE ALLOC INSTEAD_ ) ALLOC DROP ; : BVARIABLE ( N -- ) ( CREATES A NAMED GLOBAL BIG VARIABLE, N CELLS IN SIZE ) CREATE ALLOC ( ALLOCATES MEMORY FOR VARIABLE ) , ( STORES VARIABLE POINTER ) DOES> @ CONST, ; ( VARIABLE ACCESS ) ( IT IS ASSUMED THAT WE ARE ALWAYS IN BANK 0. SO, BEFORE AND AFTER AN ) ( ACCESS POSSIBLY REQUIRING A BANK CHANGE, USE BANK1 AND BANK0. THEY ) ( ARE OPTIMIZED IN ORDER TO CHANGE BANK ONLY WHEN NEEDED ) : BANK0 ( ADDR -- ) ( GENERATES CODE FOR SWITCHING TO RAM BANK 0 IF NEEDED ) OPT? IF ( OPTIMIZATION POSSIBLE? ) CURRENTBANK @ 0 = IF DROP EXIT ( ALREADY IN BANK 0 ) THEN 80 AND IF $-1 $@ 1403 = ( PRECEDED BY BANK1? ) IF ( YES, SUPPRESS IT ) ELSE $+1 STATUS RP0 BCF ( SWITCH TO BANK 0 ) THEN THEN ELSE STATUS RP0 BCF ( SWITCH TO BANK 0 ) THEN 0 CURRENTBANK ! ; : BANK1 ( ADDR -- ADDR ) ( GENERATES CODE FOR SWITCHING TO RAM BANK 1 IF NEEDED ) OPT? IF ( OPTIMIZATION POSSIBLE? ) CURRENTBANK @ 1 = IF EXIT ( ALREADY IN BANK 1 ) THEN DUP 80 AND IF ( ADDR IN BANK 1? ) $-1 $@ 1003 = ( PRECEDED BY BANK0? ) IF ( YES, SUPPRESS IT ) ELSE $+1 STATUS RP0 BSF ( NO, SWITCH TO BANK 1 ) THEN THEN ELSE STATUS RP0 BSF ( NO, SWITCH TO BANK 1 ) THEN 1 CURRENTBANK ! ; : FETCH ( ADDR -- ) ( GENERATES CODE FOR FETCHING FROM A CONSTANT ADDRESS ) DUP BANK1 ,W MOVF ( VALUE IN TOS ) BANK0 ; : STORE ( ADDR -- ) ( GENERATES CODE FOR STORING IN A CONSTANT ADDRESS ) DUP BANK1 MOVWF ( VALUE IN TOS ) BANK0 ; : INIT-PICMEM ( -- ) ( INITIALIZES PIC MEMORY SYSTEM ) 0 CURRENTBANK ! ( BANK 0 ) ; lib/share/mary/16c84-consts.fs0100644000076400007640000000262307055041225014776 0ustar frerfrer( FORTH MID-RANGE PIC CONSTANTS FOR 16C84, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) HEX ( CONSTANTS FOR 16C84 BASED PIC FORTH ) ( COMMON REGISTER NAMES ) 00 CONSTANT INDF 01 CONSTANT TMR0 02 CONSTANT PCL 03 CONSTANT STATUS 04 CONSTANT FSR 05 CONSTANT PORTA 06 CONSTANT PORTB 08 CONSTANT EEDATA 09 CONSTANT EEADR 0A CONSTANT PCLATH 0B CONSTANT INTCON 81 CONSTANT OPTION_REG 85 CONSTANT TRISA 86 CONSTANT TRISB 88 CONSTANT EECON1 89 CONSTANT EECON2 ( STATUS BITS ) 07 CONSTANT IRP 06 CONSTANT RP1 05 CONSTANT RP0 04 CONSTANT NOT_TO 03 CONSTANT NOT_PD 02 CONSTANT Z 01 CONSTANT DC 00 CONSTANT C ( INTCON BITS ) 07 CONSTANT GIE 06 CONSTANT EEIE 05 CONSTANT T0IE 04 CONSTANT INTE 03 CONSTANT RBIE 02 CONSTANT T0IF 01 CONSTANT INTF 00 CONSTANT RBIF ( OPTION BITS ) 07 CONSTANT NOT_RBPU 06 CONSTANT INTEDG 05 CONSTANT T0CS 04 CONSTANT T0SE 03 CONSTANT PSA 02 CONSTANT PS2 01 CONSTANT PS1 00 CONSTANT PS0 ( EECON1 BITS ) 04 CONSTANT EEIF 03 CONSTANT WRERR 02 CONSTANT WREN 01 CONSTANT WR 00 CONSTANT RD lib/share/mary/16c84-data.fs0100644000076400007640000000233507055041225014376 0ustar frerfrer( FORTH MID-RANGE PIC DATA FOR 16C84, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED PICCOLO ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( USE IN CONJUNCTION WITH PIC ASSEMBLER PIKASHU AND PIC FORTH MARY ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) HEX ( HERE ARE THE VARIABLES AND CONSTANTS NEEDED ) ( FOR THE PROCESSOR-SPECIFIC CODE AND RELATED ) ( WORDS IN THE PIC FORTH ) ( PIC MEMORY VARIABLES ) VARIABLE MAXPICRAM0 ( HIGHEST RAM ADDRESS, BANK 0 ) VARIABLE MINPICRAM0 ( LOWEST RAM ADDRESS, BANK 0 ) VARIABLE VARP0 ( VARIABLE POINTER FOR BANK 0 ) 2F MAXPICRAM0 ! 0C MINPICRAM0 ! 400 MAXPICROM ! ( PIC MEMORY CONSTANTS ) MINPICRAM0 @ CONSTANT TMP1 MINPICRAM0 @ 1 + CONSTANT TMP2 MINPICRAM0 @ 2 + CONSTANT TMP3 MINPICRAM0 @ 3 + MINPICRAM0 ! ( FOR VARIABLE ALLOCATION ) 8 CONSTANT STACKSIZE ( DATA STACK SIZE ) MAXPICRAM0 @ CONSTANT INITSP ( INITIAL DATA STACK POINTER ) MINPICRAM0 @ VARP0 ! STACKSIZE NEGATE MAXPICRAM0 +! lib/share/mary/picasm.fs0100644000076400007640000001770107055041225014201 0ustar frerfrer( FORTH MID-RANGE PIC ASSEMBLER, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB19. VERSION 1.0a50 CODENAMED PIKASHU ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) ( REQUIRING DEFINITIONS FROM THE SEARCH WORD SET ) ( WITH ENVIRONMENTAL DEPENDENCIES ON CELL WIDTH ) ( BEING GREATER THAN OR EQUAL TO 16 BITS ) ( IMPORTANT NOTES: ) ( 1 - USE PROGDUMP TO GENERATE AN HEXFILE ) ( IN ORDER TO BURN WITH MPLAB. DO NOT ) ( USE THE MEMORY IMAGE, ITS ONLY ) ( PURPOSE IS TO DEBUG THE ASSEMBLER ) ( 2 - REGISTER ADDRESSING OPERATIONS TAKE ) ( W AS DEFAULT DESTINATION, AS OPPOSED ) ( TO F IN MPASM. THIS IS A FEATURE OF ) ( THE PICASM ) ( 3 - TRIS AND OPTION INSTRUCTIONS _NOT_ ) ( SUPPORTED, AS THEY ARE MARKED AS ) ( DEPRECATED BY MICROCHIP ) ( 4 - FORWARD LABEL DECLARATION CURRENTLY ) ( SUPPORTS ONLY _1_ REFERENCE ) ( 5 - IT IS ASSUMED THAT A CELL IS 14 BITS ) ( WIDE AT LEAST, PREFERABLY 16 ) ( ASSEMBLER SPACE ) FORTH DEFINITIONS VOCABULARY PICASM PICASM ALSO PICASM DEFINITIONS HEX VARIABLE $ ( ASSEMBLY LOCATION POINTER ) VARIABLE MAXPICROM ( PIC ROM SIZE ) VARIABLE PICROM ( PIC ROM SPACE ) 2000 MAXPICROM ! ( AT MOST 8192 WORDS IN MID-RANGE ) MAXPICROM @ CELLS ALLOT ( PERHAPS LESS, NEVER MORE ) -1 CONSTANT CANTPATCH ( FOR NOT PATCHING ) -2 CONSTANT CANTOPT ( FOR NOT OPTIMIZING ) -3 CONSTANT CANTKILLDEADCODE ( FOR NOT SUPPRESSING CODE ) -1 CONSTANT PICERROR ( FOR ABORT" ) ( HELPER WORDS ) : INIT-PICASM 0 $ ! PICROM MAXPICROM @ 0 FILL ; INIT-PICASM : $+ ( N -- $+N ) ( AID FOR FORWARD REFERENCES ) $ @ + ; : >PICROM ( PICADDR -- REALADDR ) ( TRANSLATES PIC ADDRESS TO REAL MEMORY ADDRESS ) CELLS PICROM + ; : $>PICROM ( -- ADDR ) ( TRANSLATES $ TO REAL MEMORY ADDRESS ) $ @ >PICROM ; : PICROM@ ( ADDR -- OPCODE ) ( GETS CONTENT AT SPECIFIED PIC ROM ADDRESS ) >PICROM @ 3FFF AND ( 14-BIT CONTENT FOR MID-RANGE PIC ) ; : $@ ( -- OPCODE ) ( GETS CONTENT AT CURRENT COMPILING ADDRESS ) $ @ PICROM@ ; : $! ( OPCODE -- ) ( SETS CONTENT AT CURRENT COMPILING ADDRESS ) 3FFF AND $>PICROM ! ; : $+1 ( -- ) ( ADVANCES CURRENT COMPILING ADDRESS POINTER ) $ DUP @ 1+ SWAP ! ; : $-1 ( -- ) ( BACKS CURRENT COMPILING ADDRESS POINTER ) $ DUP @ 1- SWAP ! ; : $, ( OPCODE -- ) ( COMPILES AT CURRENT $ AND ADVANCES 1 WORD ) $ @ MAXPICROM @ 1- > IF PICERROR ABORT" PIC PROGRAM MEMORY EXCEEDED" THEN $! $+1 ; : PICPROGSIZE ( -- N ) ( PIC PROGRAM SIZE ) $ @ ; : .PICPROGSIZE BASE @ DECIMAL ." PROGRAM SIZE IS " PICPROGSIZE . ." WORDS" CR BASE ! ; : HIGH5BITS ( N -- N ) ( FOR HIGH BITS OF AN ADDRESS ) 01F00 AND 8 RSHIFT ; : HIGH ( N -- N ) HIGH5BITS ; : LOW8BITS ( N -- N ) ( FOR CONSTANTS, AND REGISTERS WITH ,F OR ,W ) 0FF AND ; : LOW ( N -- N ) LOW8BITS ; : LOW7BITS ( N -- N ) ( FOR REGISTERS IN BIT OPERATIONS ) 7F AND ; : LOW11BITS ( N -- N ) ( FOR ADDRESSES ) 7FF AND ; : CONST ( OPCODE N -- OPCODE ) LOW8BITS OR ; : ,F ( N -- N ) ( SELECTS F AS DESTINATION ) 80 OR ; : ,W ( N -- N ) ( SELECTS W AS DESTINATION ) 7F AND ; : REG ( OPCODE N -- OPCODE ) ( DEFAULTS DESTINATION AS W ) LOW8BITS OR ( USE ,F OR ,W FOR SELECTING THE DESTINATION ) ; : REGBIT ( OPCODE N -- OPCODE ) LOW7BITS OR ; : BITSEL ( OPCODE BIT -- OPCODE ) ( FOR BIT SELECTION ) 7 AND 80 * OR ( ANDS AND SHIFTS 7 PLACES ) ; : ADDR ( OPCODE N -- OPCODE ) LOW11BITS OR ; : IMMED-OPCODE ( N -- ; -- ) ( FOR IMMEDIATE OPERATIONS ) CREATE , DOES> @ $, ; : CONST-OPCODE ( N -- ; CONST -- ) ( FOR OPERATIONS ON CONSTANTS ) CREATE , DOES> @ SWAP CONST $, ; : REG-OPCODE ( N -- ; REG -- ) ( FOR OPERATIONS ON REGISTERS ) CREATE , DOES> @ SWAP REG $, ; : BIT-OPCODE ( N -- ; REG BIT -- ) ( FOR OPERATIONS ON BITS ) CREATE , DOES> @ SWAP BITSEL SWAP REGBIT $, ; : ADDR-OPCODE ( N -- ; ADDR -- ) ( FOR JUMPS AND CALLS ) CREATE , DOES> @ SWAP ADDR $, ; ( ASSEMBLY INSTRUCTIONS ) 3F00 CONST-OPCODE ADDLW 0700 REG-OPCODE ADDWF 3900 CONST-OPCODE ANDLW 0500 REG-OPCODE ANDWF 1000 BIT-OPCODE BCF 1400 BIT-OPCODE BSF 1800 BIT-OPCODE BTFSC 1C00 BIT-OPCODE BTFSS 2000 ADDR-OPCODE CALL 0180 REG-OPCODE CLRF 0100 IMMED-OPCODE CLRW 0064 IMMED-OPCODE CLRWDT 0900 REG-OPCODE COMF 0300 REG-OPCODE DECF 0B00 REG-OPCODE DECFSZ 2800 ADDR-OPCODE GOTO 0A00 REG-OPCODE INCF 0F00 REG-OPCODE INCFSZ 3800 CONST-OPCODE IORLW 0400 REG-OPCODE IORWF 3000 CONST-OPCODE MOVLW 0800 REG-OPCODE MOVF 0080 REG-OPCODE MOVWF 0000 IMMED-OPCODE NOP 0009 IMMED-OPCODE RETFIE 3400 CONST-OPCODE RETLW 0008 IMMED-OPCODE RETURN 0D00 REG-OPCODE RLF 0C00 REG-OPCODE RRF 0063 IMMED-OPCODE SLEEP 3C00 CONST-OPCODE SUBLW 0200 REG-OPCODE SUBWF 0E00 REG-OPCODE SWAPF 3A00 CONST-OPCODE XORLW 0600 REG-OPCODE XORWF ( ASSEMBLY DIRECTIVES ) : ORG ( N -- ) ( SETS THE CURRENT ASSEMBLY LOCATION POINTER ) $ ! ; ( LABEL CREATES A LABEL FOR LATER REFERENCE ) ( FLABEL CREATES A _SINGLE_ FORWARD LABEL REFERENCE ) ( EXAMPLE: ) ( LABEL NEARTHIS STATUS C BTFSC ) ( FLABEL FARAWAY GOTO ) ( ... ) ( NEARTHIS GOTO ) ( FARAWAY RETURN ) : LABEL ( -- ; -- ADDR ) ( CREATES A LABEL WITH THE CURRENT VALUE OF $ ) CREATE $ @ , DOES> @ ; : PATCHJUMP ( ADDR -- ) ( PATCHES A BACK REFERENCE OF A FORWARD JUMP ) DUP CANTPATCH = IF DROP ELSE >PICROM DUP @ $ @ ADDR SWAP ! THEN ; : FLABEL ( -- ; -- ) ( PREPARES A _SINGLE_ FORWARD LABEL REFERENCE; ONLY GOTO, CALL ) CREATE $ @ , 0 DOES> @ PATCHJUMP ; ( TOOLS ) : HEX8. ( N -- ) ( SHOWS A 8-BIT HEX NUMBER ) BASE @ HEX SWAP 0FF AND S>D <# # # #> TYPE BASE ! ; : HEX16. ( N -- ) ( SHOWS A 16-BIT HEX NUMBER ) BASE @ HEX SWAP 0FFFF AND S>D <# # # # # #> TYPE BASE ! ; : MEMDUMPLINE ( ADDR -- ) ( SHOWS 8 PIC PROGRAM MEMORY WORDS STARTING AT ADDR ) DUP CR HEX16. ." : " 8 0 DO DUP I + PICROM@ HEX16. ." " LOOP DROP ; : MEMDUMP ( ADDR COUNT -- ) ( SHOWS COUNT MEMDUMPLINES STARTING AT ADDR ) 0 DO DUP I 8 * + MEMDUMPLINE LOOP DROP CR ; : HEXDUMPLINE ( ADDR -- ) ( SHOWS 8 PIC PROGRAM MEMORY WORDS IN INTEL HEX FORMAT ) CR ." :10" DUP HEX16. ." 00" ( ADDRESS AND TYPE FOR THIS LINE ) DUP 0FF AND OVER 0FF00 AND 8 RSHIFT + ( SPLITS ADDR AND SUMS THE PARTS ) ( FOR THE CHECKSUM ) 10 + ( ADD BYTE COUNT TO THE CHECKSUM ) 8 0 DO ( 8 PIC WORDS TO SHOW ) OVER I + PICROM@ 0FF AND DUP HEX8. + ( INTEL FORMAT IS LITTLE ENDIAN, ) OVER I + PICROM@ 0FF00 AND 8 RSHIFT DUP HEX8. + ( SO SHOW THE LSB, THEN THE MSB ) LOOP NEGATE HEX8. ( NEGATED CHECKSUM FOR THIS LINE ) DROP ( LAST COPY OF THE ADDRESS ) ; : HEXDUMP ( ADDR COUNT -- ) ( SHOWS PIC PROGRAM MEMORY IN INTEL HEX FORMAT ) 0 DO DUP I 8 * + HEXDUMPLINE ( SHOW IN 8-WORD LINES ) LOOP DROP CR ." :00000001FF" CR ( EOF RECORD ) ; : PROGDUMP ( -- ) ( DUMPS CURRENT PROGRAM IN INTEL HEX FORMAT FROM 0 TO $ ) 0 $ @ 1- 8 / 1+ HEXDUMP ; lib/share/mary/picforth.fs0100644000076400007640000007323107056263765014563 0ustar frerfrer( FORTH MID-RANGE PIC FORTH COMPILER, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED MARY ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( "THIS IS A CODE GENERATOR-LESS COMPILER FOR A SYNTAX-LESS LANGUAGE ) ( IN WHICH VARIABLES ARE CONSTANTS" - FRER ) ( THIS IS A NATIVE CODE FORTH COMPILER WITH CONSTANTS AND DEAD CODE ) ( OPTIMIZATIONS BUILT-IN. THE CODE GENERATED IS OPTIMIZED FOR SPEED, ) ( THE OPTIMIZATIONS ALSO MAKE IT AS SMALL AS POSSIBLE IN THIS MODEL. ) ( THERE ARE SOME OPTIMIZATIONS IN ORDER TO USE AS FEW AS POSSIBLE ) ( RETURN STACK WORDS, AS WELL AS AVOIDING TO USE THE DATA STACK WHEN ) ( PRACTICAL. ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) ( REQUIRING DEFINITIONS FROM THE SEARCH WORD SET ) ( REQUIRING FORTH, ALSO FROM THE SEARCH EXT WORD SET ) ( REQUIRING THE PICASM WORD SET ) ( GENERAL HOUSEKEEPING ) PICFORTH DEFINITIONS HEX PICFORTH ALSO PICASM ALSO FORTH ALSO ( DEFINING WORDS ) : CONSTANT ( N -- ) ( CREATES A NAMED CONSTANT ) CREATE , DOES> @ CONST, ; : VARIABLE ( -- ) ( CREATES A NAMED GLOBAL VARIABLE ) 1 BVARIABLE ; ( TABLE ACCESSES ONLY IN SUBROUTINE FORM ) ( OPTIMIZED FOR CONSTANT INDEX ) ( TABLE BEGINS AT ELEMENT INDEX 0 ) ( E.G.: ) ( TABLE 7PRIMES ) ( 1 , 2 , 3 , 5 , 7 , 11 , 13 , ) : TABLE ( -- ; N1 -- N2 ) ( CREATES A HEADER FOR INDEXED TABLE ACCESSES ) CREATE $ @ , PCL MOVWF DOES> CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) SWAP @ 1 + + ( CALCULATES REAL ADDRESS OF ELEMENT ) PICROM@ DUP ( GETS ELEMENT ) 0FF00 AND 3400 = ( IS IT A RETLW? ) IF MOVLW ( TABLE ELEMENT ) ELSE DROP PICERROR ABORT" ATTEMPT TO ACCESS TABLE BEYOND LIMIT" THEN ELSE @ DUP LOW ADDLW TMP1 MOVWF DUP HIGH MOVLW STATUS C BTFSC 1 ADDLW PCLATH MOVWF TMP1 ,W MOVF CALL THEN ; ( USE , _ONLY_ FOR TABLES ) : , ( N -- ) ( COMPILES VALUE IN CURRENT COMPILING ADDRESS) ( N ) RETLW ; ( STACK OPERATORS ) ( ?DUP IS MISSING, I AM MOVING TO MINIMALISM. ) ( SEE THE AIF DEFINITION FOR AN EXPLANATION ) ( TUCK IS MISSING TOO. IT WAS HERE, BUT FELT ) ( BAD AND HAD TO LEAVE ) ( ONE CAN IMAGINE A FULL SUITE OF SILLY CODE ) ( THAT CAN PRECEDE DROP AND BE OPTIMIZED BY ) ( SUPPRESING BOTH, E.G: DUP DROP, 5 DROP, ETC ) ( FOR FUNNY REASONS, 5 DROP-LIKE CODE WILL BE ) : DROP ( N -- ) ( DROPS THE TOP OF STACK ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) DROP ( DROP THE CONSTANT ) ELSE POP THEN ; : DUP ( N -- N N ) ( COPIES TOS IN A NEW TOS ) PUSH ; : NIP ( N1 N2 -- N2 ) ( EQUIVALENT TO: SWAP DROP ) FSR ,F INCF ; : OVER ( N1 N2 -- N1 N2 N1 ) ( COPIES SECOND ON STACK TO NEW TOS ) PUSH FSR ,F INCF INDF ,W MOVF FSR ,F DECF ; : SWAP ( N1 N2 -- N2 N1 ) ( EXCHANGES THE TWO TOPMOST ELEMENTS ON STACK ) SAVETOS INDF ,W MOVF TMP2 MOVWF RESTORETOS INDF MOVWF TMP2 ,W MOVF ; ( ARITHMETIC WORDS ) : S>D ( U -- UD ) ( CONVERTS TO DOUBLE PRECISION ) 0 CONST, ; : D>S ( UD -- U ) ( CONVERTS TO SINGLE PRECISION ) POP ; : - ( N1 N2 -- N1-N2 ) ( SUBSTRACTS N2 FROM N1 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST - ( CALCULATE OPERATION RESULT ) CONST, ELSE SUBLW ( VALUE IN TOS ) THEN ELSE INDF ,W SUBWF FSR ,F INCF THEN ; : + ( N1 N2 -- N1+N2 ) ( ADDS N1 TO N2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST + ( CALCULATE OPERATION RESULT ) CONST, ELSE ADDLW ( VALUE IN TOS ) THEN ELSE INDF ,W ADDWF FSR ,F INCF THEN ; : 2* ( U -- U*2 ) ( MULTIPLIES TOS BY 2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) 2* MOVLW ( VALUE IN TOS ) ELSE STATUS C BCF TMP1 MOVWF TMP1 ,W RLF THEN ; : 2/ ( U -- U/2 ) ( DIVIDES TOS BY 2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) 2/ MOVLW ( VALUE IN TOS ) ELSE STATUS C BCF TMP1 MOVWF TMP1 ,W RRF THEN ; : ABS ( N -- U ) ( CALCULATES ABSOLUTE VALUE OF TOS ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) DUP ABS8 MOVLW ( VALUE IN TOS ) ELSE SAVETOS TMP1 7 BTFSS 3 $+ GOTO ( JUMPS AFTER THE INCF ) TMP1 ,F COMF TMP1 ,W INCF THEN ; : NEGATE ( N -- -N ) ( CALCULATES NEGATIVE OF TOS ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) NEGATE MOVLW ( VALUE IN TOS ) ELSE 0 SUBLW THEN ; ( BIT OPERATORS ) : AND ( N1 N2 -- N3 ) ( BITWISE AND ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST AND ( CALCULATE OPERATION RESULT ) CONST, ELSE ANDLW ( VALUE IN TOS ) THEN ELSE INDF ,W ANDWF FSR ,F INCF THEN ; : INVERT ( N1 -- !N1 ) ( BITWISE NOT ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) INVERT ( CALCULATE OPERATION RESULT ) MOVLW ELSE 0FF XORLW THEN ; : OR ( N1 N2 -- N3 ) ( BITWISE OR ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST OR ( CALCULATE OPERATION RESULT ) CONST, ELSE IORLW ( VALUE IN TOS ) THEN ELSE INDF ,W IORWF FSR ,F INCF THEN ; : XOR ( N1 N2 -- N3 ) ( BITWISE XOR ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST OR ( CALCULATE OPERATION RESULT ) CONST, ELSE XORLW ( VALUE IN TOS ) THEN ELSE INDF ,W XORWF FSR ,F INCF THEN ; ( LOGICAL WORDS ) : < ( U1 U2 -- F ) ( LEAVES A TRUE FLAG IF U1 < U2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP < ( OPERANDS WERE IN REVERSE ORDER ) CONST, EXIT ELSE SUBLW THEN ELSE INDF ,F SUBWF THEN 0FF MOVLW ( TRUE ) STATUS Z BTFSS ( IS IT ZERO? ) STATUS C BTFSC ( IS IS LESS? ) CLRW ( FALSE ) FSR ,F INCF ; : <> ( N1 N2 -- F ) ( LEAVES A TRUE FLAG IF N1 IS NOT EQUAL TO N2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST <> ( CALCULATE OPERATION RESULT ) CONST, EXIT ELSE XORLW THEN ELSE INDF ,F XORWF THEN ( OMIT THE 2 NEXT INSTRUCTIONS IF ) ( WE DON'T CARE FOR VALUE OF TRUE ) ( STATUS Z BTFSC ( 0FF MOVLW ( 0FF IF TRUE ) FSR ,F INCF ; : = ( N1 N2 -- F ) ( LEAVES A TRUE FLAG IF N1 = N2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST = ( CALCULATE OPERATION RESULT ) CONST, EXIT ELSE SUBLW THEN ELSE INDF ,F SUBWF THEN ( OMIT THE 3 NEXT INSTRUCTIONS IF ) ( WE DON'T CARE FOR VALUE OF TRUE ) ( 0FF MOVLW ( 0FF IF TRUE ) ( STATUS Z BTFSS ( 0 MOVLW ( 00 IF FALSE ) FSR ,F INCF ; : > ( U1 U2 -- F ) ( LEAVES A TRUE FLAG IF U1 > U2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP > ( OPERANDS WERE IN REVERSE ORDER ) CONST, EXIT ELSE SUBLW THEN ELSE INDF ,F SUBWF THEN 0FF MOVLW ( TRUE ) STATUS Z BTFSS ( IS IT ZERO? ) STATUS C BTFSS ( IS IS LESS? ) CLRW ( FALSE ) FSR ,F INCF ; : 0= ( N -- F ) ( LOGICAL INVERT ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) 0= IF 0FF MOVLW ELSE 0 MOVLW THEN ELSE 0 IORLW 0 MOVLW STATUS Z BTFSC 0FF XORLW ( AVOID GENERATING A MOVLW, SEE CONST? ) THEN ; ( FLOW CONTROL WORDS ) ( THERE IS NO EXIT, USE ; INSTEAD ) FORTH ( IF ... ELSE ... THEN CONSTRUCT: FLAG IS 2 ) ( THERE IS A GOOD DEAL OF OPTIMIZATIONS IN IF, BECAUSE ) ( IT CAN BE PRECEDED BY SEVERAL LOGICAL OPERATORS ) : IF ( -- ADDR CF ; F -- ) ( CONDITION FOR IF ... ELSE ... THEN ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) IF ( ALWAYS TRUE: ) DONTPATCH ( EXECUTE FOLLOWING CODE ) ELSE ( ALWAYS FALSE: ) DEADCODE ( DEAD CODE, TRY TO SUPPRESS IT ) TOPATCH GOTO ( IF NOT, SKIP FOLLOWING CODE ) THEN 2 EXIT ( LEAVE IF FLAG AND EXIT ) THEN ? IF ( > OPTIMIZATION POSSIBLE? ) STATUS Z BTFSS STATUS C BTFSS 4 $+ GOTO FSR ,F INCF POP TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) FSR ,F INCF POP 2 EXIT THEN 0=? IF ( 0= OPTIMIZATION POSSIBLE? ) 0 IORLW STATUS Z BTFSS ( INVERT THE CONDITION CHECKING ) 4 $+ GOTO POP TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) POP 2 EXIT THEN ( NO OPTIMIZATIONS POSSIBLE ) 0 IORLW STATUS Z BTFSC 4 $+ GOTO POP TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) POP 2 ( FLAG FOR IF/ELSE/THEN ) ; ( ALTERNATIVE IF. AIF DOESN'T ALTER THE ) ( STACK, GETTING RID OF THE NEED FOR ) ( ?DUP. DON'T FORGET TO USE DROP AFTER ) ( ELSE WHEN USING AIF. DEFINE ) ( : AIF DUP [COMPILE] IF ; IN THE HOST ) ( FORTH FOR TESTING AND DEBUGGING APPS ) : AIF ( -- ADDR CF ; F -- F ) ( ALTERNATIVE IF FOR AIF ... ELSE ... THEN ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) IF ( ALWAYS TRUE: ) DONTPATCH ( EXECUTE FOLLOWING CODE ) ELSE ( ALWAYS FALSE: ) DEADCODE ( DEAD CODE, TRY TO SUPPRESS IT ) TOPATCH GOTO ( IF NOT, SKIP FOLLOWING CODE ) THEN 2 EXIT ( LEAVE IF FLAG AND EXIT ) THEN ? IF ( > OPTIMIZATION POSSIBLE? ) STATUS Z BTFSS STATUS C BTFSS 2 $+ GOTO FSR ,F INCF TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) FSR ,F INCF 2 EXIT THEN 0=? IF ( 0= OPTIMIZATION POSSIBLE? ) 0 IORLW STATUS Z BTFSS ( INVERT THE CONDITION CHECKING ) TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) 2 EXIT THEN ( NO OPTIMIZATIONS POSSIBLE ) 0 IORLW STATUS Z BTFSC TOPATCH GOTO ( TO BE ADJUSTED LATER BY ELSE/THEN ) 2 ( FLAG FOR IF/ELSE/THEN ) ; ( DEAD CODE MARKING FAILS ONLY WHEN IF FLAG IS TRUE AND THERE IS AN ELSE ) : ELSE ( ADDR1 CF -- ADDR2 CF ; -- ) ( FALSE CONDITION BRANCH FOR IF ... ELSE ... THEN ) 2 ?PAIRS DEADCODE? ( CHECK FOR DEAD CODE ) IF ( IS THERE DEAD CODE? ) KILLDEADCODE ( SUPPRESS IT ) DONTPATCH ELSE TOPATCH GOTO ( TO BE ADJUSTED LATER BY THEN ) SWAP PATCHJUMP ( ADJUST CONDITIONAL FLOW ) THEN 2 ; : THEN ( ADDR CF -- ; -- ) ( ENDS IF ... ELSE ... THEN ) 2 ?PAIRS ( CHECK FOR PREVIOUS IF ) DEADCODE? ( CHECK FOR DEAD CODE ) IF ( IS THERE DEAD CODE? ) KILLDEADCODE ( SUPPRESS IT ) ELSE PATCHJUMP ( ADJUST CONDITIONAL FLOW ) NOOPT ( CAN'T OPTIMIZE HERE ) THEN ; ( BEGIN FOR BEGIN ... AGAIN, BEGIN ... UNTIL ) ( AND BEGIN ... WHILE ... REPEAT LOOPS ) : BEGIN ( -- ADDR CF ; -- ) ( STARTS BEGIN LOOP FLAG IS 1 ) PHERE ( FOR LATER JUMPING ) 1 ; ( BEGIN ... AGAIN LOOP: FLAG IS 1 ) : AGAIN ( ADDR CF -- ; -- ) ( ENDS BEGIN ... AGAIN LOOP ) 1 ?PAIRS GOTO ; ( BEGIN ... UNTIL LOOP: FLAG IS 1 ) : UNTIL ( ADDR CF -- ; F -- ) ( ENDS BEGIN ... UNTIL LOOP ) 1 ?PAIRS CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) IF ( ALWAYS TRUE: ) GOTO ( LOOP ALWAYS ) ELSE ( ALWAYS FALSE: ) DROP ( DON'T LOOP AND DROP PATCH ADDRESS ) THEN ELSE 0 IORLW STATUS Z BTFSC 4 $+ GOTO POP GOTO POP THEN ; ( BEGIN ... WHILE ... REPEAT LOOP: FLAGS ARE 1, 3 ) : WHILE ( ADDR1 CF -- ADDR1 ADDR2 CF ; F -- ) ( CONDITION FOR BEGIN ... WHILE ... REPEAT ) 1 ?PAIRS [ PICFORTH ] [COMPILE] IF [ FORTH ] 1 + ; : REPEAT ( ADDR CF -- ; -- ) ( ENDS BEGIN ... WHILE ... REPEAT LOOP ) 3 ?PAIRS DEADCODE? ( CHECK FOR DEAD CODE ) IF ( IS THERE DEAD CODE? ) KILLDEADCODE ( SUPPRESS IT ) DONTPATCH ELSE SWAP GOTO PATCHJUMP ( ADJUST CONDITIONAL FLOW ) THEN ; ( DEFINING WORDS ) ( : DOESN'T CHECK COMPILING STATE, WHICH ) ( ALLOWS FOR MULTIPLE ENTRY POINT WORDS ) : : ( -- ) ( CREATES A NAMED SUBROUTINE ENTRY POINT ) CREATE $ @ , ( SUBROUTINE START ) NOOPT ( DON'T OPTIMIZE HERE ) NODEADCODE ( AN ENTRY POINT IS NOT DEAD CODE ) DOES> @ CALL ( PERFORMS THE CALL ON WORD INVOCATION ) ; ( ; CAN BE USED MORE THAN ONCE IN A WORD ) ( IN ORDER TO MAKE MULTIPLE RETURN POINT ) ( WORDS ) : ; ( -- ) ( CREATES A RETURN POINT ) ( HAS MID-RANGE PIC SPECIFIC OPTIMIZATIONS ) CALL? ( PREVIOUS CALL? ) IF CALL>JUMP ( MAKE IT A JUMP; ) ( THE CALLED WILL RETURN, ) ( SAVING ONE STACK LEVEL ) OPT? ( OPTIMIZATION POSSIBLE? ) ELSE RETURN? ( PREVIOUS RETURN? ) THEN 0= IF ( NOT OPTIMIZABLE OR NOT PREVIOUS RETURN ) RETURN THEN ; ( NOTES: ) ( - WHEN CALLING TO A SECOND ENTRY POINT FROM ) ( THE SAME WORD, A ; IS NEEDED IN ORDER NOT TO ) ( DRAIN THE RETURN STACK. E.G.: ) ( : ENTRY1 ) ( ... ) ( : ENTRY2 ) ( ... ) ( IF ) ( ENTRY2 ; ) ( THEN ) ( ... ) ( ; ) ( THIS IS NOT STRICT RECURSIVITY, BUT RATHER ) ( SOME SORT OF LOOPING. ) ( PIC SYSTEM START ) 5 ORG ( PRESERVES FOR MAIN PROGRAM JUMP AND INTERRUPT JUMP ) ( PIC FORTH SUBROUTINES ) PICFORTH ( MEMORY ACCESS ) : (!) ( N ADDR -- ) ( STORES N IN ADDR ) TMP1 MOVWF INDF ,W MOVF TMP2 MOVWF FSR ,W MOVF TMP3 MOVWF TMP1 ,W MOVF FSR MOVWF TMP2 ,W MOVF INDF MOVWF TMP3 ,W INCF FSR MOVWF INDF ,W MOVF FSR ,F INCF ; : (+!) ( N ADDR -- ) ( ADDS N TO THE CONTENTS OF ADDR ) TMP1 MOVWF INDF ,W MOVF TMP2 MOVWF FSR ,W MOVF TMP3 MOVWF TMP1 ,W MOVF FSR MOVWF TMP2 ,W MOVF INDF ,F ADDWF TMP3 ,W INCF FSR MOVWF POP ; : (@) ( ADDR -- N ) ( FETCHES CONTENTS OF ADDR ) TMP1 MOVWF FSR ,W MOVF TMP2 MOVWF TMP1 ,W MOVF FSR MOVWF INDF ,W MOVF TMP1 MOVWF TMP2 ,W MOVF FSR MOVWF TMP1 ,W MOVF ; ( ARITHMETIC SUBROUTINES ) : (*) ( U1 U2 -- U1*U2 ) ( MULTIPLIES U1*U2 8*8=8 BITS ) TMP2 MOVWF 8 MOVLW TMP1 MOVWF INDF ,W MOVF INDF CLRF LABEL STAR.1 STATUS C BCF TMP2 0 BTFSC INDF ,F ADDWF INDF ,F RRF TMP2 ,F RRF TMP1 ,F DECFSZ STAR.1 GOTO FSR ,F INCF TMP2 ,W MOVF ; : (/MOD) ( U1 U2 -- U1\U2 U1/U2 ) ( DIVIDES U1/U2, U1\U2 IS THE REMAINDER ) TMP3 MOVWF ( U2 ) INDF ,W MOVF TMP1 MOVWF ( U1 ) INDF CLRF ( REMAINDER ) 8 MOVLW ( LOOP COUNTER ) TMP2 MOVWF ( TO INDEX ) LABEL SLASHM.0 TMP1 ,W RLF ( ROTATE U1 ) INDF ,F RLF ( INTO REMAINDER ) TMP3 ,W MOVF ( GET U2 ) INDF ,F SUBWF STATUS C BTFSC FLABEL SLASHM.1 GOTO INDF ,F ADDWF STATUS C BCF SLASHM.1 TMP1 ,F RLF ( RESULT IN TMP1 ) TMP2 ,F DECFSZ SLASHM.0 GOTO TMP1 ,W MOVF ( RESULT, REMAINDER ON TOS-1 ) RETURN ; : (LSHIFT) ( U1 U2 -- U3 ) ( LEFT SHIFTS U2 TIMES U1 GIVING U3 ) 0FF XORLW ( INVERTS U2, SO 0 WILL BE 7, ETC ) 7 ANDLW ( MASKS U2 IN ORDER TO MAKE IT < 7 ) TMP2 MOVWF FSR ,F INCF INDF ,W MOVF TMP1 MOVWF STATUS C BCF TMP2 ,W RLF ( MULTIPLIES W BY 2 ) PCL ADDWF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF STATUS C BCF TMP1 ,W RLF FSR ,F INCF ( LEAVES RESULT IN THE STACK ) ; : (RSHIFT) ( U1 U2 -- U3 ) ( RIGHT SHIFTS U2 TIMES U1 GIVING U3 ) 0FF XORLW ( INVERTS U2, SO 0 WILL BE 7, ETC ) 7 ANDLW ( MASKS U2 IN ORDER TO MAKE IT < 7 ) TMP2 MOVWF FSR ,F INCF INDF ,W MOVF TMP1 MOVWF STATUS C BCF TMP2 ,W RLF ( MULTIPLIES W BY 2 ) PCL ADDWF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF STATUS C BCF TMP1 ,W RRF FSR ,F INCF ( LEAVES RESULT IN THE STACK ) ; ( PIC FORTH FORTH DEFINITIONS THAT DEPEND ON THE SUBROUTINES ) FORTH ( ARITHMETIC WORDS ) : / ( U1 U2 -- U1/U2 ) ( DIVIDES U1/U2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP / ( CALCULATE OPERATION RESULT ) CONST, ELSE CONST, [COMPILE] (/MOD) [ PICFORTH ] [COMPILE] NIP [ FORTH ] THEN ELSE [COMPILE] (/MOD) [ PICFORTH ] [COMPILE] NIP [ FORTH ] THEN ; : /MOD ( U1 U2 -- U1\U2 U1/U2 ) ( DIVIDES U1/U2, U1\U2 IS THE REMAINDER ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP /MOD ( CALCULATE OPERATION RESULT ) CONST, ELSE CONST, [COMPILE] (/MOD) THEN ELSE [COMPILE] (/MOD) THEN ; : * ( N1 N2 -- N1*N2 ) ( MULTIPLIES N1 AND N2 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST * ( CALCULATE OPERATION RESULT ) CONST, ELSE CONST, [COMPILE] (*) THEN ELSE [COMPILE] (*) THEN ; : MOD ( U1 U2 -- U1\U2 ) ( CALCULATES THE REMAINDER OF U1/U2 ) /MOD DROP ; ( MEMORY ACCESS WORDS ) : @ ( ADDR -- N ) ( FETCHES CONTENTS AT ADDR ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) FETCH ( FETCH THE VALUE ) ELSE [COMPILE] (@) THEN ; ( HELPER FOR +! ) : INCDECLOOP ( ADDR N -- ) ( GENERATES CODE FOR +! INCF/DECF LOOPS ) DUP 80 AND ( <0? ) IF ABS8 0 DO DUP ,F DECF LOOP ELSE ( >=0 ) 0 DO DUP ,F INCF LOOP THEN DROP ( ADDR ) ; ( THERE IS AN ADDITIONAL OPTIMIZATION FOR +! DEPENDING ON THE VALUE OF N ) ( AS THE BEST GENERAL CASE MAKES FOR 5 INSTRUCTIONS. SO IF |N| < 4, WE ) ( CAN GET 3 INCF/DECF INSTRUCTIONS. IF |N| = 4, WE OPT FOR THE GENERAL ) ( OPTIMIZATION, AS IT CAN OPTIMIZE A FOLLOWING +! ) ( E.G.: 4 CONST, MYVAR1 +! 5 CONST, MYVAR2 +! IS BETTER OPTIMIZED THIS WAY ) ( OF COURSE, ALL OF THIS CHANGES IF THE VARIABLE IS IN BANK 1, SO THE ) ( NUMBER OF GENERATED INSTRUCTIONS VARY, BUT THE PRINCIPLE IS THE SAME ) : +! ( N ADDR -- ) ( ADDS N TO THE CONTENTS OF ADDR ) CONST? IF ( CONSTANT VALUE OPTIMIZATION POSSIBLE? ) KILLCONST ( THE VARIABLE ADDRESS ) CONST? IF ( CONSTANT VALUE? ) KILLCONST DUP 0= IF EXIT ( IF N = 0, THERE IS NOTHING TO DO ) THEN DUP ABS8 4 < ( SPECIAL OPTIMIZATION CASE: INCF/DECF ) IF OVER BANK1 SWAP ( CHANGE TO BANK 1 IF NEEDED ) INCDECLOOP ( MAKE LOOPS ) BANK0 ( CHANGE TO BANK 0 IF NEEDED ) ELSE ( |N| >= 5 ) OVER ( STACK IS NOW: ADDR N ADDR ) SAVETOS FETCH ( FETCH THE VALUE ) ADDLW ( ADD VALUE N ) STORE ( AND STORE IT ) RESTORETOS THEN ELSE DUP SAVETOS FETCH ( FETCH THE VALUE ) TMP1 ,W ADDF ( ADD SAVED TOS ) STORE ( STORE THE VALUE IN W ) POP THEN ELSE [COMPILE] (+!) THEN ; : ! ( N ADDR -- ) ( STORES N AT ADDR ) CONST? IF ( CONSTANT VALUE OPTIMIZATION POSSIBLE? ) KILLCONST ( THE CONSTANT/VARIABLE ADDRESS VALUE ) CONST? IF ( CONSTANT ADDRESS? ) KILLCONST SAVETOS MOVLW STORE ( STORE THE VALUE IN W ) RESTORETOS ELSE STORE ( STORE THE VALUE IN W ) POP THEN ELSE [COMPILE] (!) THEN ; : LSHIFT ( U1 U2 -- U3 ) ( LEFT SHIFTS U2 TIMES U1 GIVING U3 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP 07 AND LSHIFT ( CALCULATE OPERATION RESULT ) CONST, ELSE CONST, ( U2 ) [COMPILE] (LSHIFT) THEN ( TWO CONSTANT OPERANDS ) ELSE ( NO CONSTANT OPERAND ) [COMPILE] (LSHIFT) THEN ( ANY CONSTANT OPERAND ) ; : RSHIFT ( U1 U2 -- U3 ) ( RIGHT SHIFTS U2 TIMES U1 GIVING U3 ) CONST? IF ( CONSTANT OPTIMIZATION POSSIBLE? ) KILLCONST ( SUPPRESS CONSTANT STACKING ) CONST? ( IS THERE A PREVIOUS CONSTANT? ) IF KILLCONST SWAP 07 AND RSHIFT ( CALCULATE OPERATION RESULT ) CONST, ELSE SWAP CONST, ( U1 ) CONST, ( U2 ) [COMPILE] (RSHIFT) THEN ( TWO CONSTANT OPERANDS ) ELSE ( NO CONSTANT OPERAND ) [COMPILE] (RSHIFT) THEN ( ANY CONSTANT OPERAND ) ; PICFORTH lib/share/mary/picforthsupp.fs0100644000076400007640000002164607056266052015466 0ustar frerfrer( FORTH MID-RANGE PIC FORTH SUPPORT, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED MARY ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( REQUIRED ANSI LABELLING: ) ( THIS IS AN ANS FORTH PROGRAM ) ( REQUIRING DEFINITIONS FROM THE SEARCH WORD SET ) ( REQUIRING FORTH, ALSO FROM THE SEARCH EXT WORD SET ) ( REQUIRING THE PICASM, PICFORTH WORD SETS ) ( PIC FORTH VARIABLES ) VARIABLE LASTNOOPT ( HELPER FOR THE OPTIMIZING WORDS ) VARIABLE FIRSTDEADCODE ( HELPER FOR THE OPTIMIZING WORDS ) VARIABLE CURRENTBANK ( DATA BANK SWITCHING OPTIMIZATION ) ( COMPILER WORDS ) : INIT-PIC ( -- ) ( MINIMAL STARTUP CODE FOR PIC FORTH ) $ @ 0= IF 5 ORG THEN $ @ ( SAVES $ FOR MAIN PROGRAM JUMP ) INITSP MOVLW FSR MOVWF ( INITIAL DATA STACK POINTER ) $ @ SWAP ( SAVES CURRENT $ ) 0 ORG ( $ ) GOTO ( JUMPS TO THE MAIN PROGRAM ) $ ! ( RESTORES $ ) ; : INIT-PICFORTH ( -- ) ( INITIALIZES PIC FORTH SYSTEM ) CANTOPT LASTNOOPT ! CANTKILLDEADCODE FIRSTDEADCODE ! INIT-PICASM ( INIT-PICMEM ) ; INIT-PICFORTH : PHERE ( -- ADDR ) ( CURRENT COMPILING ADDRESS; AS HERE IN FORTH ) $ @ ; : TOPATCH ( -- ADDR 0 ) ( AN ADDRESS TO BE PATCHED LATER BY PATCHJUMP ) PHERE 0 ; : DONTPATCH ( -- ADDR ) ( MARKS A SPOT IN ORDER NOT TO BE PATCHED ) CANTPATCH ; : DEADCODE ( -- ) ( MARKS A SPOT AS DEAD CODE BEGIN ) FIRSTDEADCODE @ CANTKILLDEADCODE = ( IS THERE A PREVIOUS DEAD CODE MARK? ) IF ( NO, MARK IT NOW ) PHERE FIRSTDEADCODE ! THEN ; : NODEADCODE ( -- ) ( MARKS A SPOT AS DEAD CODE CANCELLATION ) CANTKILLDEADCODE FIRSTDEADCODE ! ; : DEADCODE? ( ADDR -- ADDR F ) ( LEAVES A TRUE FLAG IF WE ARE IN DEAD CODE ) DUP FIRSTDEADCODE @ = ; : KILLDEADCODE ( ADDR -- ) ( SUPPRESS DEAD CODE BY BACKSKIPPING IT ) ORG ( RESETS $ TO THE BEGINNING OF THE DEAD CODE ) NODEADCODE ( RESETS DEAD CODE BEGINNING ADDRESS ) ; : OPT ( -- ) ( MARKS A SPOT AS OPTIMIZABLE ) CANTOPT LASTNOOPT ! ; : NOOPT ( -- ) ( MARKS A SPOT AS NON-OPTIMIZABLE ) PHERE LASTNOOPT ! ; : OPT? ( -- F ) ( LEAVES A TRUE FLAG IF OPTIMIZATION IS POSSIBLE ) PHERE LASTNOOPT @ > ; : RETURN? ( -- F ) ( TRUE IF LAST ASSEMBLED OPCODE IS A RETURN ) $-1 $@ $+1 0008 = ; : CALL? ( -- OPCODE F ) ( OPCODE AND TRUE FLAG IF OPTIMIZATION IS POSSIBLE ) $-1 $@ DUP 0F800 AND ( MASK OUT THE ADDRESS ) 2000 = ( TRUE IF IT'S A CALL ) IF TRUE ( TRUE, BACKS $ ) ELSE $+1 DROP FALSE ( FALSE, UNBACKS $ DROPS OPCODE ) THEN ; : CALL>JUMP ( OPCODE -- ) ( CONVERTS A CALL INTO A JUMP ) ( USE _ONLY_ IN CONJUNCTION WITH CALL? ) 2800 OR ( MAKE IT A GOTO; ) $! ( THE CALLED WILL RETURN, ) $+1 ( SAVING ONE STACK LEVEL ) ; : POP ( -- ) ( GENERATES CODE TO POP W FROM STACK ) INDF ,W MOVF FSR ,F INCF ; : PUSH ( -- ) ( GENERATES CODE TO PUSH W INTO STACK ) FSR ,F DECF INDF MOVWF ; : RESTACK? ( -- F ) ( TRUE FLAG IF RESTACKING POP/PUSH OPTIMIZATION IS POSSIBLE ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ 0A84 = AND ( INCF FSR,F OPCODE ) $-1 $@ 0800 = AND ( MOVF INDF,W OPCODE ) IF ( POP/PUSH OPTIMIZATION POSSIBLE? ) TRUE ( YES, BACK $ 2 WORDS AND TRUE FLAG ) ELSE $+1 $+1 FALSE ( NO, UNBACKS $ AND FALSE FLAG ) THEN ; ( CONST, IS SIMILAR TO LITERAL, BUT CURRENTLY MUST ) ( BE USED NOT ONLY BY THE COMPILER, BUT EVEN FOR ) ( COMPILING NUMERIC ARGUMENTS ) ( EXAMPLE: 37 CONST, ) : CONST, ( N -- ) ( EMBEDS A CONSTANT IN THE CODE ) RESTACK? ( RESTACKING OPTIMIZATION POSSIBLE? ) 0= IF PUSH ( NO, GENERATE CODE FOR SAVING W ) THEN ( N ) MOVLW ( CONSTANT VALUE ) ; ( WARNING: FOR CONST? TO WORK PROPERLY, ESPECIALLY FOR IF OPTIMIZATIONS, ) ( NO WORD EXCEPT FOR CONST, MUST GENERATE A MOVLW INSTRUCTION AT THE END ) : CONST? ( -- N F ) ( CONSTANT AND TRUE FLAG IF OPTIMIZATION IS POSSIBLE ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ DUP 0FF00 AND 3000 = ( MOVLW OPCODE ) ROT AND ( THE CODE FOR CONSTANT AND VARIABLE ) IF ( CONSTANT OPTIMIZATION POSSIBLE? ) LOW8BITS TRUE ( POSSIBLE: LEAVE CONSTANT AND TRUE FLAG ) ( CAUTION: $ IS BACKED 1 WORD ) ELSE $+1 DROP FALSE ( NOT POSSIBLE: LEAVE ONLY FALSE FLAG ) THEN ; : KILLCONST ( -- ) ( BACKS $ IN ORDER TO SUPPRESS A CONSTANT ) ( USE _ONLY_ IN CONJUNCTION WITH CONST? ) $-1 $@ 0080 = ( MOVWF INDF OPCODE ) $-1 $@ 0384 = AND ( DECF FSR,F OPCODE ) IF ELSE $+1 $+1 THEN ; ( SAVETOS AND RESTORETOS USE TMP1; USE THEM _ONLY_ IN THE SAME WORD ) : SAVETOS ( -- ) ( GENERATES CODE TO SAVE TOS, EXCEPT IF PRECEDED BY RESTORETOS ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ 0800 TMP1 OR = AND ( PRECEDED BY RESTORETOS? ) IF ( YES, SUPPRESS IT ) ELSE $+1 TMP1 MOVWF ( NO, SAVE TOS ) THEN ; : RESTORETOS ( -- ) ( GENERATES CODE TO RESTORE TOS ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ 0080 TMP1 OR = AND ( PRECEDED BY SAVETOS? ) IF ( YES, SUPPRESS IT ) ELSE $+1 TMP1 ,W MOVF ( NO, RESTORE TOS ) THEN ; : ABS8 ( N -- |N| ) ( CALCULATES THE ABSOLUTE VALUE OF N FOR 8 BITS ) DUP 80 AND IF 7F AND 80 SWAP - THEN ; : ?PAIRS ( F1 F2 -- ) ( CHECK PARTS OF A FLOW CONTROL STRUCTURE ) = 0= IF ( FLAGS DON'T MATCH ) PICERROR ABORT" CONDITIONALS NOT PAIRED" THEN ; : 0=? ( -- F ) ( TRUE FLAG IF 0= OPTIMIZATION. _USE ONLY IN IF_ ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ 3AFF = AND ( XORLW 0FF OPCODE ) $-1 $@ 1903 = AND ( BTFSC STATUS,Z OPCODE ) $-1 $@ 3000 = AND ( MOVLW 00 OPCODE ) $-1 $@ 3800 = AND ( IORLW 00 OPCODE ) IF ( 0= OPTIMIZATION POSSIBLE? ) TRUE ( TRUE FLAG, $ IS BACKED 4 WORDS ) ELSE $+1 $+1 $+1 $+1 ( UNBACKS $ ) FALSE ( NOT POSSIBLE: LEAVE ONLY FALSE FLAG ) THEN ; : ? ( -- F ) ( TRUE FLAG IF > OPTIMIZATION. _USE ONLY IN IF_ ) OPT? ( OPTIMIZATION POSSIBLE? ) $-1 $@ 0A84 = AND ( INCF FSR,F OPCODE ) $-1 $@ 0100 = AND ( CLRW OPCODE ) $-1 $@ 1C03 = AND ( BTFSS STATUS,C OPCODE ) $-1 $@ 1D03 = AND ( BTFSS STATUS,Z OPCODE ) $-1 $@ 30FF = AND ( MOVLW FF OPCODE ) $-1 $@ DUP 0280 = ( SUBWF INDF,F OPCODE ) SWAP 0FF00 AND 3C00 = OR ( SUBLW NN OPCODE ) AND IF ( 0= OPTIMIZATION POSSIBLE? ) $+1 TRUE ( TRUE FLAG, $ IS BACKED 5 WORDS ) ELSE $+1 $+1 $+1 ( UNBACKS $ ) $+1 $+1 $+1 FALSE ( NOT POSSIBLE: LEAVE ONLY FALSE FLAG ) THEN ; lib/share/mary/restorestate.fs0100644000076400007640000000074407055041225015450 0ustar frerfrer( FORTH MID-RANGE PIC FORTH COMPILER, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED MARY ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( RESTORE STATE ) FORTH BASE ! ( RESTORE NUMERIC BASE ) CURRENT ! ( RESTORE CURRENT VOCABULARY ) CONTEXT ! ( RESTORE CONTEXT VOCABULARY ) lib/share/mary/savestate.fs0100644000076400007640000000072507055041225014722 0ustar frerfrer( FORTH MID-RANGE PIC FORTH COMPILER, PART OF THE GLAZZ PROJECT. ) ( WRITTEN BY FRANCISCO RODRIGO ESCOBEDO ROBLES ON 1999DEC28. ) ( LAST REVISED ON 2000FEB21. VERSION 1.0a50 CODENAMED MARY ) ( MORE INFO AT http://www.pepix.net/proyectos/glazz/mary/ ) ( CONTACT frer@pepix.net FOR SUGGESTIONS ) ( SAVE STATE ) CONTEXT @ ( SAVE CONTEXT VOCABULARY ) CURRENT @ ( SAVE CURRENT VOCABULARY ) BASE @ ( SAVE NUMERIC BASE )