It is very important you read all of this before you vote.  This is a crucial part to the future of Axe Parser.

The original concept behind going through the trouble of renaming some of the Tokens is that I am very quickly running out of intuitive TI-BASIC tokens to use for more complicated Axe Commands.  I've often resorted to using the ^r or sometimes even the double ^rr but that's not going to cut it soon.  In this last version, I was all out of sprite tokens, so I used what was left in the drawing menu: Tangent().  The name has no meaning to the intended function and may force one to read the documentation before figuring out what it might be used for.

This is okay though.  I realize that a lot of TI-BASIC programmers are used to their tokens and they know where they are on all the menus lightning fast.  If you hear the word "Str1" you might immediately think "[VARS][7][1]" as I usually do.  But if you hear "Bitmap()" you have no idea where it might be.  The catalog isn't in alphabetical order either so that doesn't help much (maybe I can change that with hooks in the future but I'm unsure).  So there is a concern that you have to learn new shortcuts.

There are many many new commands still to come.  For my example, I will mention the commands for reading from archive.  There would need to be an openfile and a readbyte command.  It is entirely possible that I just use maybe log() to open the files and prod() to read a byte, there is no problem with that.  But I imagine the code is much more readable with Open() and ReadByte() for instance.  This is not an isolated case, there are more than 20 other commands I can think of that don't have any meaningful tokens.

One other advantage of renaming some tokens is that often in BASIC, commands such as int() have totally different uses in Axe.   This can ease any potential misuse since the new names imply that the interpretation of the commands have changed.  While tokens that have the same name will be interpreted as working the same way in both Axe and BASIC.

So, if I start using the new token names, then that raises the new issue of documentation.  Sure, it may be possible to document both in the commands list, and maybe even the user's guide, but not having a single standard can get very confusing when reading other people's source code, writing your own tutorials or routines, and even regular conversations like asking for help and fixing code.

I could still offer the option of using the old tokens but just have them minimally documented (like a simple table that tells you the equivalences between tokens).  That way, it encourages the new standard among the forums and when documenting the code.

If I have the tokens be completely "Mandatory" then I can hook the program editor so that the tokens are automatically enabled when editing Axe programs and then automatically disabled when you quit to the home screen or edit a regular TI-BASIC program.  There could be an option to toggle this behavior in the parser even if the old names names are documented or undocumented.

The last thing I'm going to throw out there: These are only name changes.  The actual position in the menus for each token does not change and all past and future source code is totally compatible since the tokes themselves are still the same, only the physical letters displayed on the calculator are affected.

Please ask more questions if you want clarification on something or want to bring up another point.  You can change your vote at any time.

While that is true, and he probably would, what about things like TI-GraphLink?  I don't know if anyone still uses that but that's what I used to use a lot for basic editing.  But I suppose as long as there is at least one computer editor that supports it, then it at least gives you the option.  Does anyone here code on the computer in something other than SourceCoder and would be uncomfortable switching?

Ah yes, the good ol' bcall(_DisplayImage)

Here is how you use it.  Define the sprite like this:
Data(height,width)->Pic1
[row1]
[row2]
...
[last row]

Then, when you want to display the sprite:
Tangent(X,Y,Pic1)

Okay, first thing, Axe Tokens.  Enable and disable them with Alpha+Vars.  If the screen flashes, you know they have been toggled.  The current token remapping is this:

conj <-> Copy
Expr <-> Exch
SinReg <-> Freq
det <-> Zeros
int <-> sign
>Frac <-> >Char
deltalist <-> Data
Repeat <-> Until
Tangent <-> Bitmap

Let me know if you all like it.  I might decide to make it  quote unquote 'Mandatory'.  Like the code would be pretty unreadable without it.

I modified my RPG demo to use subroutines if you want to look at it.  Basically, you call it with up to 6 arguments and then in the subroutines, the arguments turn into r1 through r6.  Do not use subroutines with arguments in subroutines with arguments otherwise there could be conflicts since they all share these values.  While these new variables can be used outside of subroutines, it is discouraged because they get erased every time you call a subroutine with arguments.

EDIT: Oops, I just realized I accidentally switched Fill( with Zeros( instead of det(.  I'm releasing another version soon to fix stupid typos like this.  I think that will be the pattern from now on.  Big improvements followed by corrections.  I'll wait to see what other corrections need to be made first of course.

Neither.  Use Bitmap().  Its coming soon to an Axe near you

The pause would have to be fairly long, about 50-100μs and more if in 15MHz mode presumably (a little less than "Pause 2").  All it would do is slow down the command and increase the code size.  Since the normal use is not flashing the screen back and forth, its best left to the programmer to decide if they need the pause or not.

1 byte = 8 bits
1 bit = 1 pixel
Need 64 pixels

Therefore: Size = 64/8 = 8 bytes