_________________
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?

I like this! A Code Field is a place where there's some interesting data. A CFA is the address of the code field. Is that it?

If I've understood correctly, and I'm not at all expert in this, then I feel perhaps a bit confused by, for example, Garth's statement

because it doesn't seem clear if that's the CFA (an address) or the CF itself (a piece of data, which might well be a two byte address.)

Likewise with IamRob's statement

because it feels to me that these might not be Code Field Addresses but Code Fields.

But this might be my own confusion, and not a problem with the terminology.

_________________
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?

DECIMAL & HEX are overwriting TOS in A.

Thanks for following along and trouble shooting. Those were supposed to be LDY and STY. Will correct that.

A lot of what you are saying here is a large part of the reason for so much confusion, especially for beginners. And basically, I feel some of these references need to stop being quoted over and over again.

Who's to say why we can't make up, adjust or even re-write any standards ourselves to make a better standard, or at least a better understood one? Obviously the people who wrote those standards in the first place maybe didn't see or have the entire picture.

I can see and understand the Code Field area of a definition being better understood as being the "Body" of a definition better than calling the primitive part of a definition, "The Body".

"The Body", would also not include the CFA, as that is part of the header. And, "The Body" should not include primitives as primitives do not necessarily have to be joined to the header, but Code Field addresses always are.

The CFA though, can point to a primitive, or it can point to code that interprets what is in the body. I am using the word "primitive" to mean code that is created to indicate the intention of a word without the help of interpreted words or a higher language.

Therefore, there would basically be a Header, a Code Field Address (the CFA is named separately due to its duel use) and a Body. The Code Field Address always points to low level code. But the low level code can have one of two uses. It can be used to handle parameters directly (making it a primitive), or it can be used to interpret whatever is in the "The Body". Whether it be a number for a variable or constant, or, a compiled CFA of a word.

Does this sound more reasonably understood by everyone? Anyone game for creating our own standard and making it accessible to everyone?

_________________
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?

For me, a picture or a diagram is always a huge help. It takes a lot of words to do the same work, and if we're not all agreed, with complete clarity, on what the words mean, even more so.

_________________
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?

Thanks Garth, very helpful (to me at least). From Moving Forth:




It feels like part of the problem (at least in my head) is that the Code Field is certainly a field, and always contains an address, and so perhaps it feels natural to speak of it as the CFA, whereas the address of the Code Field would in my mind be the thing to refer to as the CFA. So it seems that most uses of the term CFA are actually meaning the Code Field.

Part of the confusion may be that the contents of the code field IS an address -- an address of executable code. Sometimes people MEAN "the address in the code field", but instead WRITE "CFA", or, IOW, the address OF the code field, not the one IN the code field.

Perhaps that is happening in one or two of the examples given.

That is also why there is no code field in subroutine, direct or bit threaded code... in subroutine or direct threaded code, the word always starts with executable code, and in bit threaded code, whether it is a secondary or a primitive is inferred from its entry in the compiled definition.

JSR DUP : JSR ONEPL : JSR SWAP : JMP CFETCH
; No code field

JSR ENTER : !word DUP,ONEPL,SWAP,CFETCH,EXIT
; No code field

!word DUP+$80,ONEPL+$80,SWAP+$80
!word CFETCH+$80,EXIT+$80
; No code field

_________________
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?

But there is no code field, so in what sense does it have an address?

"CFA" is not a generic term for Forth, it's a term specific to Forth implemented with indirect threaded code (or some other code done with a similar indirection).

In other words, the address to put into the operand field of a JSR instruction is NOT the address of a field that contains the address of an executable routine. The address to compile for direct threaded cde is NOT the address of a field that contains the address of an executable routine. Both are the addresses of executable routines themselves.

"Compile a list of values that specify which words to execute" is something that every Forth will do. "Compile a list of values that point to the address of a field that contains an address of an executable routine" is something that an Indirect Threaded model Forth will do ...

... after all, that is the INDIRECT in Indirect Threaded: point to something which points to the thing that you execute.



... doesn't USE "an address that points to an address that points to executable code" to do that, it uses an address that points directly to executable code. The trade-off is that a compiled definition has to be prefaced by an executable stub.

Or consider a bit-threaded model where definitions are composed of cells aligned on even addresses, primitives are called with subroutine vectors (so are always odd) and compiled words called with the address of their definition. As well, executable code is all in the range of $8000-$FFFF, so any address in $0000-$7FFF is assumed to be a branch to code in the $8000-$FFFF range, rather than a call.





... is right, here ... for a primitive, the code field contents points to the parameter field, so for a primitive, the CFA "points to the pointer to," the parameter field". In other words, for fig-Forth primitives, the CFA is not a pointer to the primitive code, it's a handle to the primitive code.

The fig-Forth word CFA is a shorthand, which in a verbose system could be named PFA>CFA to make clear what it translates from as well as what it translates to -- but I like the fig-Forth version better, perhaps because I started with a version of fig-Forth customized for the C64.

_________________
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?

And in fig-Forth terms, the beginning address of the code of a primitive is NOT the CFA, it is the PFA. In subroutine or direct threaded Forth, the code field is snipped out and both primitives and compiled code either are executable routines ... or at least, for direct threaded compiled words, presents itself as an executable routine.
~~~~~~~~~~~



There's also token/bit-threaded. You don't have to reserve all 256 bytes for tokens ... you can reserve 128 or 127 for tokens and have one byte primitives and two byte calls.

I'm interested in trying this one out in xForth for the X16/C64, if I ever get it out of alpha state (eg, at present DOES> is borked, and I don't have time for debugging sessions at the moment). Now, I would have to experiment with what works best for the 6502, since the only example I saw, back in the 90s I think, was for the Z80. I'd have to tinker to see which allocation of stacks and IP to registers (X/Y/S) works best for the 65C02, but with primitives being a single byte dispatch, I might try a (zp,X) instruction pointer on top of the return stack.

The idea of this version is that executable code is in the high half of a 64K memory space, but now the compiled address is compiled with the high byte first, in the reverse to the normal 6502 order. The high byte of the OP vector is initialized with the page of the table of vectors of primitives ... a certain number are reserved for "FASTCODE" words, while general CODE words begin with an "embed code" token and compiled/called as compiled words.



For compiling words, you need an XT, word, so that you only compile a byte for a token and compile a word address in big-endian order. You can't get away with just using , as you can in fig-Forth.

Whether that bit-threading model has Forth words compiled into the high or low half of the memory map, the execution token for a TBTC model on the 6502 benefits from the fact that there won't be compiled code in the zero page, so EXECUTE just checks whether the high byte of the execution token is zero when deciding whether it is a primitive token or a compiled Forth word address. I think it might be something like: