I shall be interested in seeing how popular this becomes. I am definitely going to have to test this out...

I love the name! Antidisassemblage and SquirrelBox. Great names!

This shall be interesting, compiling for all the calculators with the click of a button? There has to be some catch...Maybe not. Maybe this is the program we have all been waiting for that does EVERYTHING for you!

There is a catch: no mulitplication or division operators and no strings. That kinda' eliminates the point of using it, if you ask me.

Yeah, really. I started reading the article and began to think... "Wow, I might start writing z80 software" Then I saw no mult/div operators... "Oh, crap, nevermind." No strings either? That does kind of eliminate the point. I hope he adds these kind of things, it seems like an awful lot amount of work to put into a project and have it go unused due to a simple problem as this.

Using bitshifting and char array's is just as good as using * or / or string. And bitshifting is 30x faster then * or / because is takes the processor 15 clock cycle's to do * or / while it only takes half a clock cycle to do a bitshift.

What are you talking about? On the z80 the minimum instruction time is 4 cc. Most shifts take twice as much though. The fastest byte-byte multiplication takes almost 200 cc. Anyway, you can't use shifts effectively in a high level language on arrays, because you cannot make use of the carry flag.

Heh... no strings attached!...

shifting is not such a hot idea if you ask me... we might as well be using Brainf__k (don't ban this message, that's the actual name of a Turing-machine-like PL)...

I once proposed a similar idea in a ticalc forum: a PL called "calC++", which would output a program for ANY programmable calculator out there... Casio, HP, Lovely lovely Ti, Sharp, etc... me & my geeks are still working on it... hopefully we'll come up with a beta soon ;)

I dont have any of the ti's supported by Antidissassemblage :(, but i'll check it out anyway...

Turing-based? Those are damn near impossible to program for.
It makes basic look advanced.
If you don't believe me, google "Turing Machine Simulator".

i was being sarcastic.
search for that programming language (type the name correctly, use your imagination).

4 example, here's a hellowolrd in BF:

>+++++++++ [<++++++++>-] <.>+++++++[<++++>-] <+.+++++++..+++.[-]
>++++++++ [<++++>-] <.>+++++++++++ [<++++++++>-] <-.--------.+++
.------.--------. [-]>++++++++[<++++>- ] <+.[-]++++++++++.

see what i mean?

If you click the "Web Site" link above, there's a BF interpreter I wrote for thr TI-83 Plus (runs in Ion). You can create BF programs in the on-calc BASIC editor.

How can something take half a cycle? I thought it was just a figure of speech, until I realized you said half a clock is thirty times faster than fifteen clocks... Is this some weird 68K thing?

But it makes things a whole lot easier if you can just say "FMyVar := FMyVar * 5" (that's Pascal) or "myVar *= 5" (for the C lovers) and have the compiler take care of the shifting.
Multiplying by any integer is possible using only shifts but it's a rather complicated trick (I've seen the code, but can't exactly reproduce it of the top of my head). I'd think this is one of the things the compiler should 'protect' you against / let you abstract from.

bitshifting only works for powers of two

It can actually be rigged up to work for any number, it just takes some semi-abstract coding. It will work for any number and is much faster than a loop based multiplication. I don't know enough to say the same for division, but I know bitshift multiplication can be done for all numbers.

In the majority of cases an "add a,a" is faster than shifting the byte leftwards.

This is news to me. I only thought bitshifting worked for powers of two as well. Could somebody explain to me how this would work for other numbers (not 2^k)? I think that's rather interesting. If that could be done, then it could be integrated into the project to at least allow multiplication.

You cannot directly multiply a number by a non-power-of-two just by bitshifting (or at least, I assume not). However, you can do something like:

ld a,5 ; a=5

add a,a ;Shift a left: a=a*2=10
ld b,a ;b=a=10
add a,a ;a=a*2=20
add a,b ;a=a+b=20+10=30

...to provide a multiplication by 6.

seems inefficient for 256!

To multiply by 256, you would do this:

xor a ; a=0, because every bit overflows :)

Actually, you'd use a register pair, like HL, like this:

ld hl,5 ; hl=5 (initial value)
ld h,l
ld l,0 ; now hl=256*5

You shouldn't just shift the bits if you know the multiplier is 256.

nono, I meant 256 factorial, like 256*255*254... etc.

How else do you multiply numbers without using shift and add? That's the best way AFAIK to do it on the Z80 and other MPU's that lack a multiply instruction.

I'll try to explain. Its not 100% bitshifting, and I've never actually written a program to use it, but heres the basic idea. The two numbers A and B are being multiplied (A*B). We will save our result in C. The basic idea is that each 1 in B means A times 2 to the power of that bit is added. So start with bit 1 (the 1 value). If it is 1, add A to C. Next, look at bit 2 (the 2 value). Double A so it is *2. If bit 2 of B is 1, add A to C. Next, look at bit 3 (the 4 value). Double A so it is *4. If bit 3 of B is 1, add A to C. Next, look at bit 4 of B (the 8 value). Double A so it is *8. If bit 4 of B is set, add A to C. You get the idea for the last 4 bits. Just be careful of an overflow, maybe use a 16 bit number for C. I believe this is more efficient than simply looping, but definitely less efficient than powers of 2.

Here's the code:

{ A >= 0 /\ B > 0 }
|[ var b : int;
____q, r, b := 0, A, B
__; do r >= b -> b := b * 2 od
__; do b <> B
______-> q, b := q * 2, b div 2
_______; if r < b -> skip [] r >= b -> q, r := q + 1, r - b fi
____od
]|
{ q = A div B /\ r = A mod B }

Source: Programming: The Derivation of Algorithms - Anne Kaldewaij (ISBN 0-13-204108-1)

For the people who can't read GCL (Guarded Command Language), here's a Pascal version:

procedure Div ( a, b: Integer; var q, r: integer ): Integer;
// input:
// a >= 0
// b > 0
// q [doesn't matter, only used for output]
// r [doesn't matter, only used for output]
//
// output:
// q = a div b
// r = a mod b
var
__i: Integer;
begin
__q := 0;
__r := a;
__i := b;
__while r >= i do
____i := i * 2;
__while i <> b do
__begin
____q := q * 2;
____i := i div 2;
____if r < i then
______{skip}
____else
____begin
______q := q + 1;
______r := r - i;
____end
__end;
end;

In order to prevent HTML from killing multiple spaces, I used underscores. If you copy-paste this code to an editor which uses a fixed-width font, it should be a lot more readable. If you copy-paste the Pascal code to Delphi (or another Pascal compiler) and replace-all the underscores with spaces, you're ready to go.

antidissawhat?!?