hehe, thanks

@Sorunome: If I were to include all that, I would just have one giant app like DoorsCS7

Quote

I'm just curious, but is it possible to run apps from grammer program? (or just any kind of program)

I'm not sure, but If you can find a pointer to the App, you may execute the code like an assembly program.

(I don't know how to run assembly programs in a Grammer code...If a Grammer code runs with expr( , maybe an assembly prog needs Asm(expr( ? )


PS: Quite good readme, now   There is much more info.

If you know the assembly code to run an app, then yes, you can actually run an app from Grammer. I never even thought about that because it is complicated to do in Assembly.

To run assembly programs, use Asm( and to run hex codes, use AsmPrgm. To execute an App, you want to use AsmPrgm. Be warned that this will exit the program and not return:
.0:
Get("EAppName    ;Yes, actually use E. I'm hacking Grammer >.>
AsmPrgm2178843614EF4E4CD8D306C38040
solve(4,2,"App Not Found
Stop
This will leave garbage on the screen in some cases, just as a warning. Also, if the App name does not work, try adding spaces until their are 8 chars. For example, Axe is really named
"Axe     "

Version 2.29.04.12
I have rewritten the readme, added in support for the menu options, and modified some commands. I tried fixing bugs like the fact that length( wasn't returning what it was supposed to. I also made more arguments optional for certain functions like the sprite and circle commands. Any comments or suggestions can go in the appropriate topic

Hmm, it doesn't look quite right if you are trying to multiply registers. I don't know if this will help you?

D_Times_E:
;Inputs:
;     D and E are factors
;Outputs:
;     A is the product (lower 8 bits)
;     B is 0
;     C,DE, HL are not changed
;Size:  12 bytes
;Speed: 304+b cycles where b is the number of set bits in E
     xor a         ;This is an optimised way to set A to zero. 4 cycles, 1 byte.
     ld b,8        ;Number of bits in E, so number of times we will cycle through
Loop:
     add a,a       ;We double A, so we shift it left.
     rlc e         ;We want the next bit in E, so it is shifted into the c flag
     jr nc,$+3     ;If it is 0, we don't need to add anything to A
       add a,d     ;Since it was 1, we do A+1*D
     djnz Loop     ;Decrements B, if it isn't zero yet, jump back to Loop:
     ret
Basically, this works like regular multiplication that you would do by hand. Since the above code is using 8-bit registers, there are 8 digits per number. Since bits are only 1 or 0, we only have to multiply by one or zero. Then we just add the result to the accumulator. When we get ready to add the next multiplication, we need to shift the accumulator left. In Decimal, we do this by multiplying by ten (tacking on a zero at the end). In binary, we multiply by 2. I hope this helps?

As for division, the algorithm is actually very similar and uses long division like you learned in grade school, except with binary. Say you have 37/5. In binary, you are doing:

00100101/101.

so you shift the 00100101 and move the overflow into another register. Pretend I have done this 5 times already:
0000010010100000
Now you see, the overflow is not greater than 5, so shift once more:
0000100101000000
Now it is, so we get tricky. First, subtract five from the overflow and increment the other number by 1:
0000010001000001
Now shift again:
0000100010000010
Now it is greater than 5 again, so:
0000001110000011
Shift again:
00000011100000110
And do the proper adjustment:
00000001000000111

Now look at that o_O You have the remainder as 2 and the division is 7. Note that in all, there were 8 shifts. I hope this helps! If you want a division code, feel free to ask

I am currently working on it

If you want to edit the first byte, you can try this:
     ld hl,NAME
     rst rMOV9TOOP1
     bcall(_ChkFindSym)
     ret c                ;The program doesn't exist, so exit
     ex de,hl
;Just checking to make sure the size isn't zero, otherwise it will edit unknown data
     ld a,(hl)
     inc hl
     or (hl)
     ret z
     inc hl
     ld (hl),30h     ;or whatever byte you want
     ret
NAME:
     .db 5,"HELLO",0 ;5 means program, 0 terminates
If you want to see more complicated code that edits the first byte of the second line:
     ld hl,NAME
     rst rMOV9TOOP1
     bcall(_ChkFindSym)
     ret c
     ex de,hl
;Just checking to make sure the size isn't zero, otherwise it will edit unknown data
     ld c,(hl)
     ld a,c
     inc hl
     or (hl)
     ret z
     ld b,(hl)
     inc hl
;BC is now the size of the program
;HL points to the data
     ld a,3Fh        ;3Fh is the newline token
     cpir            ;Search a max of BC bytes at HL for the first instance of A
     ret po          ;No bytes left in the program
;HL now points to the byte after the start of the second line
;Make sure it isn't another newline. (means Line 2 was empty)
     cp (hl)
     ret z
     ld (hl),30h     ;or whatever byte you want
     ret
NAME:
     .db 5,"HELLO",0


Ah, okay I'll go ahead and answer it in the other topic then I was thinking about adding it directly to Grammer as well, since it is very small. If I do have enough space after fixing everything up, I probably will add it to Grammer 2. I am currently working on rewriting the code for the main menu to be smaller and then add the code to handle all the options.

I am still confused
I've no clue what is going on !_!


EDIT: Do you mean like a Menu( command?
EDIT2: Or do you mean that MenuKeyHook? o.o That I could do, but I have 878 bytes of space left.