World: r3wp

Go John Go!

:)

Oh ...I thought we were going to see a 6502 emulator!

One step at a time!

single stepping?

Yeah, I'm only a level 1multitasker or so.

You see, now I have a 6502 assembler written in REBOL, so now it 
will be easy for me to test a 6502 emulator, while I'm writing it.

I've found, that it's best to test while I develop. It's traditionally 
design-programming-test. I don't find this the best way, if you want 
fast progress and few errors.

Agreed;  write a line, test a line.  

Personal comment:

Then forget you wrote it so a few days later you can  write a line, 
test a line and then go "whoa, deja-vu"  :)

Since it's line-based, could the syntax error tell you which line, 
in addition to what op it's near?

Yes, for the syntax errors it's fixed now: http://www.fys.ku.dk/~niclasen/rebol/language/asm6502.r

For labels not found, you have to search you source, where you branch 
to that label.

It's a one pass assembler and then some. After first pass, it checks, 
if there is forward referencing to labels and then fix those relative 
addresses directly in the produced code. Should be fast, as it's 
not a completely two-pass.

I haven't played with it, but it's still veyr impressive for such 
a short project.

It's about 10k REBOL source. 2644 bytes compressed.

It amuses me to use REBOL for things like this. The most enjoyable 
language around! It took me like 3 halves evenings.

Elite, John.  Elite.

Instructions can be separated by : on the same line, and comments 
put at the end. Example:
asm6502 "inx:iny This is a comment!"
UPPER/lower case can be used:
asm6502 "INX : INY This is a comment!"

btiffin, hehe :)

The asm6502 can take the refinement /at to tell the starting address 
in the 64kb ram area for the produced code. I don't like the refinement 
being called /at, because we already have the word AT. Any suggestions 
for a better name?

The Program Counter get set to the argument for that refinement, 
else 1, if the refinement isn't there.

So it could be named something like: /pc /target /address /start 
...

/begin maybe?

Or I should just stick with /at, because that's the word, we usually 
use to position ourselves within a series. (And the ram can be seen 
as a series.)

/skip would be the rebolious name I think, but /org would resonate 
with me as well.

Elite was done on the C64 as well as other computers of that era, 
so would have been done in 6502 assembler.

Yes! :)
From http://www.bbcmicrogames.com/acornsoft.html

It has been ported to just about every other platform out there however, 
it appeared first on the BBC.

The BBC had a 6502 too, and it's the platform, I'm testing up against, 
so let's hope, it all work out well.

/at is probably fine.

Is there an emulator for this Elite release?

I'm a little stuck here with a simple problem:

a: func [v] [

  parse v [
 
    any [
      'a (prin "a")

      | 'b (prin "b")
      | 'c (prin "c")

      (prin "-")

    ]
 
  ]

]

>> 

a [a b c c a]
abc-c-a


I want to print the dash after every letter. Do I have to include 
it after each word?

a: func [v] [
  parse v [
    any [
    	[
        	'a (prin "a")
      		| ['b (prin "b")]
      		| ['c (prin "c")]
      	]
      	(prin "-")
    ]
  ]
]

a: func [v] [
  parse v [
    any [
    	[
        	'a (prin "a")
          | 'b (prin "b")
          | 'c (prin "c")
      	]
      	(prin "-")
    ]
  ]
]

beautiful, thanks

Robert, there's no emulator written in REBOL, that can run Elite, 
afaik. But there are emulators emulating the BBC computer, if that's 
what you mean, and they can run Elite. I use an emulator called BeebEm3.

I have a question on the above parse by Oldes on Feb 8th.  
If you feed in a [a b c d e f] you will get a-b-c-==false

How can you change the parse so that it will put a dash in between 
all characters, without defining each character?

Now that I think of it, I would not even use a parse to do that. 
 But what could I do if I wanted only a subset of characters to show 
up without defining them all

Patrick, in answer to your first question:
parse [a b c d e f] [
    set x word! (prin form x)
    any [set x word! (prin join "-" form x)]
]

Super -- Thanks for the info.  I'm still learning about parse!

You have to remember to structure your rules using LL style. Do you 
notice that I checked for one word first, then looped over the subsequent 
words? That was to avoid putting the "-" after the last word as well. 
Parse uses right recursion - not like yacc, which uses left recursion.

I was just wondering about the trailing dash, but thought that could 
be handled in a different step.  Your method is cleaner.

replace/all form [a b c d e f] " " "-"

Cleaner yet.

Can anyone help me why the following appears to work, but still returns 
false?

data: [ table [1 2 3] [4 5 6] ]

parse data ['table some into [ some [ set n integer! (print n) ] 
(print "-")] ]

do you need an 'end ?

just found out that this seems to work, but I don't really see why 
I have to include end. As I've understood "into" is supposed to fail 
and continue if the next item isn't a block!


parse data ['table some into [ end | some [ set n integer! (print 
n) ] (print "-") ]  ]

Ahh, another block around the into statement did the trick :P Thanks 
for the help though


parse data ['table some [ into [ some [ set n integer! (print n) 
] (print "-") ] ]  ]

shouldn't datatype! be included in rule block parsing?

how do you do this:

blk: ["somestring" string!]

We can't do:

parse blk [string! datatype!]

and get a match.

I see I can do a reduce on the blk when passed to parse and get it 
true but not sure that is safe for my situation.

be nice if there was a lit-type!

string! is considered a word here. you must provide the datatype 
in its serialized state:

parse ["something" #[datatype string!]] [string! datatype!]

same if you use none or other things that would be considered words 
in an unreduced block.