Which one?

Quote from: ztrumpet on April 09, 2011, 05:15:43 pm

Can we have a feature like "Zeros()," but for any data.  For instance, something like this:
Command(1,12) would be the same as [010101010101010101010101]
Command([56],4) would be the same as [56565656]
Command(127,6) would be the same as Data(127,127,127,127,127,127)
Potentially, this command could even be used for repeating sets of data.  For instance:
Command([010203],12) would be the same as [010203010203010203010203]
Command("Text"[00],15) would be the same as "Text"[00]"Text"[00]"Text"[00]

So, what do you think?  Could this be a command?  I think it's a good idea, to avoid situations like this.

I really like that idea. What about changing Zeros( (det() to something more universal?

I would suggest changing the token replacement to Block(). Feeding 1 argument would create a block of the specified size filled with zeroes. Feeding 2 arguments would create a block of the specified size filled with a specified value. Maybe you could even add a Block()^r command for creating a block filled with a specified word while you're at it, although this probably isn't as necessary as a normal byte-filling block command.

Quote from: Runer112 on April 09, 2011, 08:59:14 pm

I would suggest changing the token replacement to Block(). Feeding 1 argument would create a block of the specified size filled with zeroes. Feeding 2 arguments would create a block of the specified size filled with a specified value.

I like that idea. It would make it compatible with previous versions.

That's the idea.

A way to Exit the program from within a subroutine, because both Return and goto end-of-program just end the subroutine.

A way to Exit the program from within a subroutine, because both Return and goto end-of-program just end the subroutine.

There's no real command to do that in ASM either. In fact, you could think of the program itself as a big subroutine that calls smaller subroutines. There's are JForce bcalls in ASM, but they leave an extra copy of the program in RAM, causing a memory leak.

There are workarounds though, but the one Scout suggested will not work. It just returns control to wherever the routine was called at the first Return (at the end of the program).

Also Scout, where are Lbl SR and Lbl CP defined?

Scout, that would not work. The problem has to do with the state of the stack when hitting a Return. If you're in a subroutine, the return address to actually exit the program, and not just return from the subroutine, is somewhere hidden in the stack. When your program is just starting up, the stack will look something like this:
OS return location
Stuff
...

But when you're in a subroutine, the stack will look something like this:
Subroutine return location
Possibly more subroutine return locations
...
OS return location
Stuff
...

Because the OS return location is dug into the stack at an unknown depth, you cannot access it. The solution to this is to backup the OS return location at the start of your program when you know that it is the topmost stack entry. I would suggest using code like the following:


.MYPROG

Asm(ED73E383)          .Back up the OS return location

.YOUR PROGRAM GOES HERE

Asm(ED7BE383ED56C9)    .Exit program from anywhere, put this wherever you want it


---

EDIT: Quigibo, perhaps you could add a Return^r function for this? I could be wrong, but I believe I see a very easy way to handle this. If a Return^r is detected in the first pass, set a flag to say so, but otherwise parse the Return^r command and the rest of the pass as normal. Before starting the second pass but after the header has been added, check this flag. If it isn't set, resume as normal. If it is set, add the 4-byte stack pointer backup code to the beginning of the program and then step through every static pointer, increasing them by 4. The rest of the program should then be able to be parsed normally.

My best suggestion is to store sp somewhere, and then load sp back when you are done, and then return.  This works because something calls $9D95 or your ASM program, and the address to return to is stored at sp.  So you store sp at the start to some location, and then change it back to sp when you are done, and return.

EDIT: Uber-ninja'd with code.

What about Basic's Stop? How does that work?