Yeah, the 'C02 is a *very* worthwhile upgrade! The extra instructions and new address modes make a real difference! And the pinout changes (compared to NMOS '02) are easily manageable.

As an aside, it's worth noting that the modern C02's made by WDC, though an excellent choice for many applications, are IMO not the best choice for dropping into an existing NMOS project (especially a home-built). You'd be better off with an older 'C02 if you can find one, such as those made in days of yore by Rockwell, CMD and others.

To be clear, many hobbyists have used the WDC chip and had no trouble. But the older devices have much gentler rise and fall times on the outputs, and thus are less prone to noise problems and flaky operation that can result from construction and design shortcomings. Another benefit that helps avoid noise and flakiness issues is the TTL compatibility featured by the inputs on older C02's but not on WDC -- more on that here.

-- Jeff

_________________
In 1988 my 65C02 got six new registers and 44 new full-speed instructions!
https://laughtonelectronics.com/Arcana/ ... mmary.html

Thank you for your information.
I already read some articles here, how to pass parameters to a function without a stack.

I want to figure out how people wrote programs on old hardware of the 60s and 70s.
My first programming language was Algol60. It was implemented on stack machines.
I did some assembly on my C64 back then - but I do not remember how I programmed at this time. I was a child at that time - not a professional assembly programmer.

I might try to run an old Fortan compiler on an emulated PET or Apple-II. I want to see what code the compiler generates for the 6502. And I also will check what code the cc65 generates for the NMOS 6502.
If I know what code a Fortran77 compiler generates, I might write a Fortran77 cross compiler for PC (or B, BCPL, PL/M).

Thank you for the hint that the WDC65C02 is not TTL compatible on its inputs.
I also have the Olimex Neo6502 (with the WDC65C02) and I can use that, if I want to use the extended instruction set.
It has an external bus, but sadly the bus (and the 65C02) run on 3.3V - not 5V. Now I understand that the 74LVC245 on this board does not reach the 5V CMOS levels when supplied with 3.3V which is needed for the rp2040.

For the programming of the Elektor Junior together with my friend: he will probably stick to his old NMOS 6502.
(If you don't know the Junior - it is a KIM-1 clone)

Welcome, Hermes. I think in some ways the usual programming approach for 6502 is like FORTRAN's common block - the programmer will arrange allocations and deal in global addresses, and probably re-use some addresses for multiple purposes.

And that is the reason that I am interested in Fortran.
The compiler would do some work for me that I had to do if I would use hand coded assembly.
I am looking for a replacement of assembly with as few overhead and performance loss as possible.

I also took a look at the source code of CP/M-65 by David Given. He uses a special assembler that can generate functions and nested loops and IF statements. I have never seen such an assembler before. He wrote some macros to implement that. Those macros look different from what I have seen before.
I try to understand those macros: https://github.com/davidgiven/cpm65/blo ... de/zif.inc
The assembler is called MADS and implemented in FreePascal. That is all I know about it.
It might be this one: https://github.com/tebe6502/Mad-Assembler/tree/master
It looks very interesting to me.

I figured out, that MADS can define procedures with ".PROC" . They are reentrant (which I do not need) and use a software stack (which I want to avoid). MADS can also generate loops and ifs.

David Given defines his own macros in MADS for functions and loops.
To me it looks like a strategy that a Fortran compiler might use. I have to analyze that in more detail.

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

Maybe I should not use X and Y for loops counters and A for passing parameters (except in functions that do not call other functions or in the innermost loop which does not call any function). And I should not pass parameters on the stack. I also must not have local variables on the stack.
Sounds like ancient Fortran to me

Thank you very much Garth Wilson for your link about structured macros.
I think, this is exactly what I was searching for.
This is amazing!

I never could find a good tutorial about advanced macro techniques.

Garth makes them appear useful and easy, but (for better of worse) my brain doesn't process macros nearly as well as plain assembly language, so I only use what limited knowledge I have of them to traverse the code of others, never for my own projects. I have found "includes" to be mentally cumbersome too, but I do my best to respect the preferences of others. Ctrl+Z, Ctrl+X, Ctrl+C, and Ctrl+V get a lot of well-deserved use on my keyboard.

_________________
Got a kilobyte lying fallow in your 65xx's memory map? Sprinkle some VTL02C on it and see how it grows on you!

Mike B. (about me) (learning how to github)

I am used to structured programming in higher languages, and I never had a teacher who showed me assembly on a professional level.
I do not like C and I always joke about C, that it is just a better macro assembler. And maybe this is kind of true.

Today I learned how to do loops and branches (even nested ones) in macro assembly without using labels.
I still have to learn how to have arithmetic expressions in assembly that look like in a higher language (not RPN or FORTH).
And I have some clue how to pass parameters without a stack and maybe how to have local variables without stack. I need to learn more about that.

I always wondered how the first Fortran compiler could be implemented without Fortran (or any other higher language).
Now I have some understanding how it could be done with macro assembly. (It does not mean that it actually was done like this)

I will practice some 6502 assembly programming (with macros) to gain more skill.

I am still curious how efficient the 6502 code is that a good Fortran compiler can produce.
I assume, there was a fight in the 1960s between the traditional assembly programmers and the modern Fortran/Algol programmers. I did not program during that time period.

For me the 6502 is the most simple microprocessor. (not looking at the 1802 or any older ones)
I want to figure out what I can do with that.

I apologize that I "stole" this thread and it turned into macro assembly. But I am still open for Fortran 6502.

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

Do you mean write a FORTRAN compiler in .. BCPL ... etc. ?

If so, I'm interested.

However there is only one BCPL implementation that runs on the 6502 that I'm aware of and that's the one for the BBC Micro. It uses 16-bit integers but there is a separate numbers package with 48 bit floating point and a number of fixed point (and fast integer) routines. I used it extensively in the 80s... Which a number of years later (about 40) led me to implement BCPL on my '816 board.

BCPL can also run under Linux and maybe under MS Windows, but I've no idea about the latter.

A "classic" FORTRAN (77) compiler ought to be relatively easy to write to generate 6502 code - there is always the question of who wants to write it and why. The hard part is the optimiser - vectorising array operations which the good compilers can do on systems which support such a thing.

-Gordon

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