Linux - NewbieThis Linux forum is for members that are new to Linux.
Just starting out and have a question?
If it is not in the man pages or the how-to's this is the place!
Notices
Welcome to LinuxQuestions.org, a friendly and active Linux Community.
You are currently viewing LQ as a guest. By joining our community you will have the ability to post topics, receive our newsletter, use the advanced search, subscribe to threads and access many other special features. Registration is quick, simple and absolutely free. Join our community today!
Note that registered members see fewer ads, and ContentLink is completely disabled once you log in.
If you have any problems with the registration process or your account login, please contact us. If you need to reset your password, click here.
Having a problem logging in? Please visit this page to clear all LQ-related cookies.
Get a virtual cloud desktop with the Linux distro that you want in less than five minutes with Shells! With over 10 pre-installed distros to choose from, the worry-free installation life is here! Whether you are a digital nomad or just looking for flexibility, Shells can put your Linux machine on the device that you want to use.
Exclusive for LQ members, get up to 45% off per month. Click here for more info.
You might consider taking the posts on this topic and writing a book. It would be very useful to people 1)Building a stack machine, 2) building a compiler especially with bison. I would have found it useful for my work.
It is one of the things I've thought of - Especially by taking a relatively simple language and providing the steps to go from creating a grammar, to parsing to code generation... then to interpretation - and showing the interaction between the code generation and the interpretation (almost need the interpreter before the code generator as in our case).
May still try that as a E-book or a blog series (what I have now would need a lot of cleanup, improvement in the data structures, symbol tables, and maybe even adding data structures). It would be introductory only, as the topic is actually quite large and there are several 300+ page books on the subjects (Aho and Ullman has done an entire series). There are also several that could be done with the LLVM compiler construction base, which aims at producing retargetable compilers (haven't used it yet) which came out just a couple of years ago. One of the known limitations of LR(1) parser generators (like Bison is basically) is that it is harder to get error handling right. It is easy to say "parser error at line #" but to say WHY it is an error, to make correction suggestions, and recover to continue looking for more errors is much harder. Bison has extensions to make it easier, but it also starts taking it out of the LR(1) grammar to do so. Complex grammars (even GCC) have been migrating from an LR(1) parser to an LL(1) parser (this uses recursive decent instead of parse tables) because it makes the context of an error MUCH easier to handle. Its just that LL(1) parser generators have not been generally available (they exist, but are rather difficult to use, but things are improving - I believe that is how LLVM works, but I'm not sure). One thing I will need is to get a newer book ("Flex and Bison" from O'Rilly). The new stuff is hard to follow from the reference manual (which is on line by the way).
I remember one of the early Pascal books - I learned a lot about both the Pascal compiler/interpreter (I was the maintainer while a senior) was at the end of the book... It included a "tiny Pascal" with the P-code interpreter. Another was the Concurrent Pascal book that added extensions (~1975 by Per Brinch Hanson) to turn Pascal into a system implementation language - it too included a lot of the compiler, though mostly it had what Microsoft now calls "managed software" for creating a "near-realtime" (as long as you aren't trying to do hard realtime) operating systems and utilities (one of which was the compiler...).
The interpreter itself was for a PDP-11/45, and turned a 16 bit CPU (with 16 bit addressing), with 18 bit hardware address into a threaded code machine with 256k addressability. As I recall, the interpreter itself was fairly small - 8-12K or so.
I think I am going to take the week off between Christmas and New Years and do something else. Probably some electronics and have to help out an elderly lady with house repairs. I will get a kit for a radio that operates around 49 MHz as well as I have an oscillator to try to test for repeat-ability and temperature stability.
I'm going to think about the data structures, and (if my wife lets me get to the computer) think about adding experiments with local variables. Might add a bit to the stack machine (a block transfer would be useful).
Merry Christmas Jesse. One thing about errors in code is that you really get to know what you wrote. The code is becoming like an old friend. The more I look at it the better I know it.
Depending on how it is used, that will call for a kernel running too - device drivers, buffers, applications, and filesystem. Possibly two - one for the FAT32, and one for flash and updates, though that second one might be optional.
The real time clock maintains itself and is accessed over I2C bus. There is only one program running - the interpreter. File I/O through the FAT system is also through the interpreter.
The main issue is that unless you use programmed I/O on the USB, you now have interrupts (or a huge amount of spin lock delay loops waiting for the data). It also means that unless you have interrupts, the interpreter will stop until the file system activity and I/O are completed - per action, thus introducing a rather long delay for any responses.
It also means that the filesystem support, and USB support have to implemented locally - along with the debugging.
It isn't impossible... just time consuming. It usually means the interpreter becomes the operating system.
I have since changed my mind and will use a SD Card instead of USB port. The only USB port will be a serial I/O port to the PC and is handled by an FTDI chip with RX, TX, CTS and RTS. Any interrupts will be built into the interpreter with no user interaction except through PRINT and INPUT statements through the interpreter.
I've made some data structure changes - it simplified the grammar action routines considerably, but did make the code walking a bit trickier (meaning: I haven't debugged it yet .
Considering ARM CORTEX M3(!?) You might want to consider ARMv7 for your stack machine as it is a 32 bit GPR RISC system. For information see: http://www.youtube.com/watch?v=7LqPJGnBPMM
LinuxQuestions.org is looking for people interested in writing
Editorials, Articles, Reviews, and more. If you'd like to contribute
content, let us know.