On 6/21/2022 at 8:55 PM, Greg King said:
buf should be increased before the test. Otherwise, the current wrap-around won't be seen. But, if tmp is zero, then there's no point in doing any increases/decreases.
On 6/21/2022 at 8:55 PM, Greg King said:
But, if tmp is zero, then there's no point in doing any increases/decreases.
On 6/21/2022 at 1:10 PM, ZeroByte said:
As promised, here's the code that I'm using to harness MACPTR. It's incomplete in that it doesn't fall back on ACPTR (cbm_load() in this case) if MACPTR returns -1. I'm not happy with the return type being signed, and will probably fix this by either making it a signed log, or else just returning zero on failure and requiring that the calling code check status byte to know if it's zero because EOF or because of unsupported device.
Most likely, though, this is a case that will never happen with files, as the OS supports block reads from disk - but if you pass it an LFN that's connected to the screen or keyboard or whatever, then that would fail....
extern int __fastcall__ macptr(unsigned char numbytes, void* buffer);
int cx16_read(unsigned char lfn, void* buffer, unsigned int size) {
int error = 0;
char* buf = (char*)buffer;
static unsigned int bytesread;
static int tmp;
/* if we can't change to the inputchannel #lfn then return an error */
if (_oserror = cbm_k_chkin(lfn)) return -1;
bytesread = 0;
printf("\n");
while (size > 0 && !cbm_k_readst()) {
if (size>=512)
tmp = macptr(0,buf); // let MACPTR read as much as it wants
else if (size>=256)
tmp = macptr(255,buf); // If size 256..512, unlimited MACPTR would read past desired stopping point.
else
tmp = macptr((size), buf);
if (tmp == -1) return -1;
bytesread += tmp;
size -= tmp;
// wrap the buffer pointer back into the bank window
// if it advances above 0xbfff. Note that MACPTR did
// wrap banks correctly, but our calculation must match.
// also note that MACPTR incremented the active bank,
// so there is no need to do RAM_BANK++ here.
if (buf >= (char*)0xc000) buf -= 0x2000;
buf += tmp;
if (cbm_k_readst() & 0xBF) break;
if (tmp == 0) break;
}
And the assembly is short:
MACPTR := $FF44
.import popa
.export _macptr ; the _ is important - C symbols all start with _
.proc _macptr: near
phx
tax
jsr popa
ply
jsr MACPTR
bcs macptr_unsupported
macptr_supported:
txa ; C wants int in .AX not .XY
phy
plx
rts
macptr_unsupported: ; return -1 on error
ldx #$ff
lda #$ff
rts
.endproc
Note that the MACPTR function itself returning a signed int is fine, since MACPTR will return 512 bytes at most.
On 7/18/2022 at 5:16 PM, ZeroByte said:
LFN needs to be 2..14 for sequential read. (which is what this is)
0 and 1 have special meanings that've been explained to me, and which I've read about, but I really haven't grasped what's truly going on - I just know use 0 for LOAD, use >=2 for sequential access. If you use 0 or 1, the call to send P: command to DOS will fail and you will not have seeked anywhere in the file.
On 7/19/2022 at 1:07 PM, ZeroByte said:
oh, and one other thing I mentioned earlier in the thread but forgot about here - for whatever reason, only values 2, 6, and 10 allow seeking in my experience. So if you want to just do sequential reads from start of file - no big deal I guess, but if you want to use the P command, you have to use 2 6 or 10, and the LFN needs to match the SA for some odd reason.
On 7/19/2022 at 1:58 PM, BruceMcF said:
AFAICT, the P command only works on Relative files. I haven't ever seen any limitation on the LFN or SA being 2, 6 or 10, but on the other hand, the relative files I used were used to implement Block files for a Commodore 64 port of fig-Forth, so back in the day, while I USED relative files heavily, I didn't do any manipulation of REL files in either Basic or Assembler -- they were always hiding behind the BLOCK word.
On 7/19/2022 at 1:58 PM, BruceMcF said:
As far as LFN and SA matching, I recall everyone doing that anyway, except for normally opening the Command Channel with an LFN of 1. For one thing, that makes it easier to keep track, and for another, when you use a variable in the OPEN command, you can re-use the same variable in both the LFN and SA positions.