Login [Register]
Don't have an account? Register now to chat, post, use our tools, and much more.
I'm trying to build the OS, but it seems that trunk/src/tools/ihx2rom.cpp is missing and it's causing the compilation to fail. Any ideas where I can get this?
I am due to look at committing again, however, I am a bit stuck... The OS has its launcher disabled and boots into a FORTH interpreter running in a test mode. I can try to get the toolchain change added to svn without breaking anything. Hopefully tonight if this hockey game doesn't go too late.

<edit>

Added revisions 86,87, and 88. You should be ok to build. I don't know if there any side effects from the missing forth code.
The rom compiles now, but I can't get glasslink to compile. it fails saying that the cmake variable "USB" was not defined while executing the task "gosusbcommd_"
You need to have libusb1 development packages installed. I lack any warnings there :/
Well I can't find the development package on my mac, so I tried building it on my fedora emulator after running `yum install libusb-devel`, but it still fails with the same error. Any ideas? Is that maybe the development package for libusb2.0?
Quote:
You need to have libusb1 development packages installed.


libusb0.1 != libusb1

To grab it, use

Code:
yum install -y libusb1-devel
I have been looking at the COMPILE word in FORTH that would take bytecode for FORTH words and compile them down to z80 op codes. Right now, the FORTH system has a main interpreter loop that will read a byte, parse it and either treat it as data, a branch, or a word call. This is a "safe" way as errors can be detected and reported back.

This isn't a good way to run programs quickly as each byte must be handled by the interpreter. Instead, a branch table will be added to allow redirecting words finishing execution, exception throwing, etc.. This will let me replace the bytecode with call/ret/ld/push/pop/jr/etc. removing unneeded code running.

I still have yet to code anything new for the OS, my focus is on other things right now :/
AHelper, did you base your forth implementation on any prior code? There's a full z80 implementation intended for CP/M in CamelForth, which also claims that it's suitable for conversion for usage on embedded systems.

GPLv3 license on it. Not sure if that's an issue for you.

http://www.camelforth.com/page.php?5

They claim 6KB of Program ROM and 640B of RAM for a standalone implementation, not counting programs you execute.
No, I wrote it from scratch mainly because I haven't made any z80 asm projects yet.

Thanks for the link, I will try to look and use parts of it when possible (I am also GPLv3, no issues).
What happened to GlassOS, you may ask?

Firstly, college. I am "busy"... I have been focusing my time on Redintegrate right now. However, that says nothing about the status of GlassOS.

Right now, I have glassFORTH on my plate. The OS is unstable to be put into subversion else my rom and 8xus will be made unusable. glassFORTH currently can run compiled programs using bytecode and mixed in z80 asm. It can't compile yet, I am writing the actual compiler in FORTH and hand-compiling that.

After that, I will need to make a optimizer that can look at the bytecode of FORTH programs and insert z80 asm into the program, optimizing register usage. Instead of having a bunch of stack manipulation ops run together in bytecode, I can take the asm version of them, allocate registers and output an optimized asm form. A bit more than a normal peep-hole optimizer.

I will probably look at working on this over break once my finals are done and I have fully enjoyed Doctor Who on Saturday.
Currently throwing out details on gFORTH, mainly because I will forget eventually:

gFORTH runs by interpreting bytecode, simple as that. Right now, that all works.

The bytecode has the following rules:
Code:
If bit 7 is reset
  Bits 0-6 are ID of a word
  if word == 0b01111110
    return from word
  else
    lookup word by ID and execute either asm section or jump into bytecode.
else
  if bit 6 is set
    Bulk text data is embedded. bits 0-5 are length
    Push string address, push string length
    Move PC past string data
  else
    if bit 5 is set
      Control structure!
      if bit 0-2 == 001
        if stack is false, then advance by next byte
      else if bit 0-2 == 000
        forced jump by next byte
    else
      bits 0-4 describe how many literal bytes should be pushed.
      push each byte to the stack.  If odd-numbered, pad with 0 byte.

Since it just reads bytecode, it has no words in it and no code to run. So, I have to bootstrap it with built-in words. I have quite a few built-in core words that are written in asm, which are made into words. In order for gFORTH to do something when ran, I also need to get it to interpret input. This means I have to write the interpreter by hand. I now can compile the FORTH code into bytecode instead of hand-compiling, so that is a big plus. For example, here is the source for a basic interpreter and the C structure output from the compiler (PC):

Code:
BEGIN
  ( WORD ) TIB 80 ACCEPT TIB + #TIB ! BL EMIT 0 >IN ! ( END WORD ) BEGIN
    BL ( WORD ) TIB 80 ACCEPT TIB + #TIB ! BL EMIT 0 >IN ! ( END WORD ) 1+ HERE @ 255 AND DUP IF ( str len )
      ( length != 0 ) 2DUP FIND-WORD DUP IF ( str len word )
        ( Good name ) SWAP DROP SWAP DROP EXECUTE 1 ( 1 )
      ELSE
        DROP ( Is a number? ) S>NUMBER? 0= IF ( Is a number ) ( d|0 )
          DROP 0 ( )
        ELSE
          1
        THEN
      THEN
    ELSE
      DROP DROP 0 ( )
    THEN ( number/??? 1|0 -- )
  0= UNTIL s" Ok" type
AGAIN

10, 0x82, 0x0, 0x50, 14, 10, 5, 11, 1, 12,
30, 0x82, 0x0, 0x0, 22, 1, 12, 10, 0x82, 0x0,
0x50, 14, 10, 5, 11, 1, 12, 30, 0x82, 0x0,
0x0, 22, 1, 18, 21, 16, 0x82, 0x0, 0xff, 20,
19, 0xa1, 31, 31, 25, 19, 0xa1, 10, 23, 27,
23, 27, 26, 0x82, 0x0, 0x1, 0xa0, 14, 27, 24,
29, 0xa1, 6, 27, 0x82, 0x0, 0x0, 0xa0, 3, 0x82,
0x0, 0x1, 0xa0, 5, 27, 27, 0x82, 0x0, 0x0, 29,
0xa1, -66, -62, 'O', 'k', 13, 0xa0, -88
Writing the compiler in C helped a LOT with taking care of jump offsets. Those were hell to do by hand.

I currently have some code for a compiler, I just need to look it over and compile/tweek it and see how it runs. I might want to change up how the compiling works in relation to the interpreter, such as having compiling just change the mode that the interpreter works rather than taking control from it (current code does that).
An interpreter is working!... again?

My old interpreter, shown above, needed some love, so I rewrote it with a compiling mode built in. The interpreter and compiler (compiler almost done) are sitting at about 330 bytes in bytecode. I still need to get aborting working as it... has no where to go yet.

Expect me to show off what is working on HCWP today.
So I decided to try compiling GlassOS, and I get two errors about float_long being redefined. This is strange, as the source has an #ifndef that should prevent this.

I went ahead and commented the "extra" float definitions out, only to have a linker warning for __sdcc_isdigit not existing, while being referenced by _atof. Whether that's a real issue or not, it is preventing the makefile from finishing. I find this strange, since from what I can tell _atof is a reference to SDCC's own library, and not your code at all.
Is the most recent build of GlassOS up online to download? I looked on its site and there's missing gifs of GlassOS on the Ti 84+ CSE?
If you want a recent version at all, you'll have to build it yourself. However, unless you also make and install some apps for it, you won't have much to do aside from a game or two.

There's an extremely outdated version up on the sourcefourge page, here.
http://sf.net/projects/glassos/files

I did get it to compile after installing the right version of sdcc. It's quite promising. Once the FORTH finishes I might actually be able to use it for something Razz
You actually got GlassOS compiled? On Linux or Windows?
Linux, but I can send you the OS file if you want it. I wouldn't recommend using it on an actual calc yet, since it doesn't do much as of now.

Once gCAS and the FORTH interpreter are done it will be a different story. You'll have math and programming then, as well as linker software. From there you've got about as much as TI-OS provides.
Can you please send me the OS file?
Here's a link to a 7z of the entire build folder. The 8xu and the rom should both work fine in an emulator.

https://dl.dropboxusercontent.com/u/10071991/glassos%20april%202014%20build/bin/GlassOS%20April%202014%20Build.7z

AHelper said he wasn't releasing official builds recently because the OS isn't really that usable for anything practical yet. Keep that in mind.

I don't think I'm breaking any rules by doing this, but if ahelper tells me to take down the link I will.

I strongly recommend installing it onto your calculator until you've tried it out on an emulator first. Then you can know if it's good enough for your purposes or not.
I understand. Thankyou so much will!

I shall install the correct revision of SDCC (639, correct?) to compile this myself too!
  
Register to Join the Conversation
Have your own thoughts to add to this or any other topic? Want to ask a question, offer a suggestion, share your own programs and projects, upload a file to the file archives, get help with calculator and computer programming, or simply chat with like-minded coders and tech and calculator enthusiasts via the site-wide AJAX SAX widget? Registration for a free Cemetech account only takes a minute.

» Go to Registration page
» Goto page Previous  1, 2, 3 ... , 26, 27, 28  Next
» View previous topic :: View next topic  
Page 27 of 28
» All times are GMT - 5 Hours
 
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum

 

Advertisement