Prompted by a nearby comment, here's a pointless mini-challenge: what kinds of useful interrupt handler can be written without using A, X, or Y and therefore without saving or restoring them?

Is it even the case that such a hampered ISR can perform an arbitrary function, by means of great cunning?

I'm thinking.... Some kind of debugging stuff...

Use an indirect zp addressing to store the accumulator into some position in memory. Then, increment the zp pointer.

Then you can inspect the different values the accumulator has had.

Can't see any real use for it though... But I'm just thinking out loud I guess

Use BIT to check the interrupt request bits (which you have carefully placed in bits 6 and 7 of IO locations) and see which interrupt source needs handling.
Use LSR to read the bit coming in from your serial interface, and ROR to place it into your 'incoming bits' data.
If that location was initialised with $80, you can use the carry flag to see when all 8 bits have been shifted in, and use INC to set the "you have a new byte" flag for the main program. You'd have to ensure that it uses that byte before another bit comes in, but we're not going for practicality here. Or you can do 8 more shift/rotates and copy the byte somewhere else (setting 'incoming bits' back to $80 in the process).

Rotate instructions can be used to read and copy data (one bit at a time), and BCC/BCS can branch depending on their values. I'd say that's more than sufficient for general processing. If you don't mind horrendous inefficiency.

In general, nothing of much value can be done without registers. However, you could possibly have a free-running hardware timer that generates an interrupt at "x" clocks, ns, ms, etc. The ISR could simply increment or decrement a memory or I/O register and not much else... if in Page Zero, one could leverage some of Rockwell enhanced instructions for bit set/reset/test/branch... and could possibly be useful if I/O is located in Page Zero.

Beyond this, the mini-challenge falls into an old category we used to call "a solution in search of a problem".

_________________
Regards, KM
https://github.com/floobydust

How about the following untested code:

Now brainfuck code can be translated as follows:

Brainfuck is turing-complete (memory-limitations aside), so you should be able to compute arbitrary functions.

That's nice John - serial without registers!

And vbc - good one, as you say, once you have Turing-complete, you're there!

Excellent, however I believe your [] test is the wrong way round - it's a while !0 BF code, not BF code while !0, so



That way the loop can be executed zero times and using [] is a common way to write a comment at the start of a BF program (not that I've written many!)

Now to write a BF to 6502 translator...

(Also note that there is a C to BF 'compiler' which should probably raise more questions that is answers...)

-Gordon

_________________
--
Gordon Henderson.
See my Ruby 6502 and 65816 SBC projects here: https://projects.drogon.net/ruby/

_________________
http://WilsonMinesCo.com/ lots of 6502 resources
The "second front page" is http://wilsonminesco.com/links.html .
What's an additional VIA among friends, anyhow?

Yes, you are right (and we need a jmp back for ]).

I would toggle the speaker approx every 64 secs. Although 60 vblints in a second, the counters go to 64.

inc vblintcounter
bit vblintcounter
bvs secondary
rti

secondary equ *
asl vblintcounter ; clear bit 6
inc secscounter
bit secscounter
bvs togglespeaker
rti

togglespeaker equ *
]lp bit speaker
dec secscounter
bne ]lp
rti

Since I inspired the challenge, I can't very well avoid participating can I?

My suggestion does require special hardware, but if you have a FastIO port then you can read and write to the FastIO port, branch based on those values and (using zero-page rotates) receive or transmit serial values, all without touching a register. See these macros.

_________________
Want to design a PCB for your project? I strongly recommend KiCad. Its free, its multiplatform, and its easy to learn!
Also, I maintain KiCad libraries of Retro Computing and Arduino components you might find useful.

@vbc, that self modifying code to create a Brainf#%k VM is a classic.