I did a bit more work on the ezetool code - most improvements to the output. Added labels, each function has the cycle counters reset, and branch targets are calculated.
As a bit of an experiment I wrote a tiny bit of a simulator - just enough to simulate all the instructions in isqrt().
Simulation of calculating an approximation to iqsrt(9) (i.e. 1/3):
000000: mov.l r2,#0x0000 r2 <- 00000000 0.000000 000004: movt.l r2,#0x3f00 r2 <- 3f000000 0.500000 000008: mov.l r1,#0x59df r1 <- 000059df 0.000000 00000c: fmul.s r2,r0,r2 r2 <- 40900000 4.500000 00000e: movt.l r1,#0x5f37 r1 <- 5f3759df 13211836172961055000.000000 000012: asr.s r0,r0,#0x0001 r0 <- 20880000 41100000 000014: sub.s r0,r1,r0 r0 <- 3eaf59df 000016: mov.l r1,#0x0000 r1 <- 00000000 0.000000 00001a: movt.l r1,#0x3fc0 r1 <- 3fc00000 1.500000 00001e: fmul.s r2,r2,r0 r2 <- 3fc5451b 1.541171 000020: fmsub.s r1,r2,r0 r1 <- 3f78e082 0.972176 000022: fmul.s r0,r1,r0 r0 <- 3eaa78d8 0.332953 000024: jr.l r14
But it was just using the string names of the instructions in a switch statement and was a bit bulky so I started looking into ways of making it easier to write and ended up falling down a pretty deep rabbit hole before I decided I don't really want to write a simulator anyway (well, probably not).
One thing I was looking at was including the instruction operation in the instruction definition file directly, so i started playing with an expression parser. I came up with a pretty novel (or perhaps, just shit) non-recursive parser implemented using a hand-coded state machine and a few stacks but it wasn't anything more than a bit of piss farting about.
But this playing with an expression parser got me thinking about a programmers calculator. I mostly fire up a random xterm and run gdb whenever I want to do some sort of calculation (going by ps i currently have 9 littered across 4 virtual desktops amongst 38 xterms and 8 copies of emacs) but although that serves most of my needs very well sometimes it just doesn't. Sometimes I need to write little C or java snippets or resort to an old Sharp calculator.
Today mostly out of curiosity I had a look at some compiler generator tools - i found that bison has a Java output which although it doesn't seem to be actively developed appears to function ok. I started with my own lexical analyser but that quickly got messy so I tried jflex which did the job fine. These are the sort of tools I play with out of curiosity every few years but never do anything useful with - i think they're kinda nifty but never seem to have a real need for them.
gdb also has has a command line. Thus deeper down the rabbit hole I went looking for a readline equivalent for Java. I looked at one but it had a few external dependencies and uses maven to resolve them (which means: just no). So ... I mucked about for a couple of hours writing my own. Using stty to set the terminal to raw mode and then creating a stream which decodes the escape sequences. Of course I've forgotten everything i did with zvt (gnome-terminal 1.0) but it didn't take long to get a single-line editor going with basic functions like navigation, editing, and history. But probably it may as well just have it's own window so that was mostly just a bit of pointless mucking about and I probably should've just been playing with doing it with a gui toolkit.
Then the weekend ended.
I dunno, maybe I'll keep playing around with it, or maybe I wont.
At least I finally pruned the roses and re-trained some of them onto stakes. Kinda been letting them go a bit. Did a bit of other gardening stuff too - it turned out to be an ok enough day with a bit of sunshine and a little warmth although it didn't last long.