Re: TIB: idea->86ASM Module Builder
[Prev][Next][Index][Thread]
Re: TIB: idea->86ASM Module Builder
In a message dated 12/06/98 9:24:34 PM, RichardCry@aol.com writes:
>I know a lot of people are skeptic about this whole on-calc idea for
>assembly, but I'm not one of them. A TSR would be great to program...
>there has to be some vector that you can redirect, check for something,
>and direct it back when finished. A way to alter your own program (for
>experts, this is needed)...for example...you have an installation program
>inside a normal program but you want it deleted when finished installing
>or something. This is also great when you need to alter minor things (like
>numbers in installing new versions). If you combine this with the TSR, you
>can have a getkey program to automatically place the variable inside the
>program at a specific location, or automatically change the program counter
>to the location that executes the commands for that specific getkey.
>
>Another great idea is a compiler. I'm not saying have a full blown compiler
>from BASIC into ASM...just have JMPs to ROMcalls that jump straight into
>the location where the BASIC code is used (making sure the parameters are
>done properly before-hand). Also, have the GOTO and LBL commands work
>properly (instead of searching the whole program and setting the program
>counter, just automatically set the program counter by ASM command). This
>will make it a little bit faster than using the basic parser, and maybe even
>cut down a lot of space. I've always wondered why people couldn't do this,
>maybe they couldn't find the specific ROM locations for the commands, but I
>still think this can be done and should be done.
>
>-Rob
>p.s. does this make any sense?
I didn't quite catch what TSR meant, but I think I got the idea... I'm all for
it too, but in mixing Basic and ASM here, I want to allow features in ASM with
ease of use to the Basic Programmers... I think you're turning it into ASM
here, with all this relocating of the memory and physically rewriting the
basic program 'n stuff... Yeah, we all know the limited abilities of Basic,
but unless you just go program directly in ASM, its practically impossible to
use the speed and functionality of ASM in a Basic Program...
With the Basic Compiler, I'm sure its possible Somehow, but very difficult...
Here's something Justin Karneges (creator of Jolitma) said once about
compiling for Basic... "I think there's a ROM call available for every BASIC
command. It's not that complicated, it would just take a lot of work to put in
all the ROM calls. Basically, you'd have a zillion IF's. Then you need a
good parser. I've written a TI-BASIC parser before (i made a ti82 basic
emulator, never released though cuz it looked like crap) and it's not that
hard to do, just a little recursion. Remember that TI-BASIC doesn't allow
spacing and stuff, so you don't have to account for that. The hard part with
the parsing is that you have to handle all the function calls. Oh
yeah, and the hardcoded labels. It's not a simple project, but it could
definitely be done..."
Well, anything could be done, but this would not be too practical... =P I
figure that it will not be an On-Calc Basic Compiler though, since I imagine
something like this would be very unstable and crash a lot, since we can
barely come up with an idea how to implement it... Converting the Whole ASM
program would be a definite challenge, but I think the idea you mentioned
about converting the Gotos and Labels to ASM, seems reasonably easy... I can
picture how it will work from ASM, but I don't see how to incorporate that
into the Basic Program, though... =P Well, this is all Idealistic crap, Lets
see someone make it... =P Anyone who has the capabilities to do something
like this already professionally programs for higher languages. I think
implementing something like for the calc would be out of the range for the TI
programmers already out there. Maybe someone is up to the challenge, but it
would be very time consuming also to incorporate all of the commands from ASM
to correspond to Basic ones... Hmm, we'll see what happens in the future, as
we programmers discover more about the capabilities of these Graphing
Calculators... =P
--Jason K.