In this series we'll learn a simple self contained 'Hello World'... Well learn how to compile it, and run on an emulator, We'll then learn a more complex example, which includes a 'monitor' function which will show the status of the registers to screen.

Lesson H1 - Hello World on RISC-OS In this lesson we'll use to use Software Interrupt "SWI 0x00" to show characters to the screen We'll use another SWI to do a newline, and a final one to exit our program, we'll use this to show Hello World.

ROS_Hello.asm ROS_Hello_Advanced.asm

For RISC OS to run our program, it needs to start at memory address 0x8000, we do this with an ORG statement. We need to set up a valid stack for our program, and allocate some space for it, We put this at the start of our program, and skip over the allocated space with a branch command. Our program will load the address of the Hello World string, and use our Printstring function to show it to the screen We return back to the OS with "SWI 0x11" - this takes an error code in R0 (We set it to zero)

When we want to print a character to the screen, we'll use SWI 0x0 (OS_WriteC). This will show the character into R0 to the screen.
We'll use this PrintChar routine to print a Char 255 terminated string We'll create a function called 'PrintString' which will print the string at address [r1]
When we want to start a new line, we use OS function SWI 0x03 (OS_NewLine)

these tutorials use VASM as an assembler, it's free and open source! We compile it on the command line with the following command: Defined Symbols... We're defining some symbols on the command line (equivalent of the equ command).. you don't need this for the basic hello world  FBIN... Tell the assembler to output a binary file Listing File... we're specify a listing file - it shows the source and resulting bytecode, it's for debugging, so you don't need it, but it helps! Output file... this is the resulting program file, it needs a ,FF8 extension to be runnable by RISC OS (COMMA FFA) Source file... the ASM file we're compiling, in this example %buildFile% will be defined by the batchfile - it would be Hello.asm or something if you're writing your own build script a2... We're specifying to compile ARM2 CheckLabels,NoCase... We're disabling case sensitivity, we're also enabling 'Label Checking' - this will warn us if we've forgotton a tab, meaning or command is being treated as a label. OPT options... We're enabling a couple of assembler optimizations - these will automatically convert and break up our commands into multiple commands where a parameter is too large to load directly, The assembler will add ADD or SUB command to produce the value we wanted.
We need to transfer our program to the '\RPCEmu\hostfs' folder - this is treated as the disk drive by RPCEmu
We need to set up the run file "!Run,feb" (ExclaimationMark RUN COMMA FEB) in the !BOOT folder to start our program automatically
Here is the result

Different versions of RISC-OS will work differently with boot and executables. This example was done with "riscos-3.71.rom" if you're using a different ROM, you will probably need to do things differently.

We need to include the monitor tools as a separate file. We also define the width of the memdump - as smaller screen systems cannot output 8 chars per line.

Writing your own monitor tools may seem a bit odd, but writing our own means we don't have to worry about the functionality our emulator does or does not provide. The Monitor tools are pretty complex, so we're not going to discuss their workings here!

In these tutorials we use some software debugging tools, A Monitor which shows the state of the registers, a Mem Dump which shows some lines of the memory
Here is the result

Lesson H5 - Hello World on RISC-OS via BBC Basic! We created a 'Hello world' example before on RISC-OS, but this time we'll remake it, this time assembling and running it from the BBC BASIC assembler built into RISC-OS itself!

BasicFile_HELLO.txt

Unlike most BASICs, BBC BASIC is CASE SENSITIVE, so you need to put all the commands in CAPS! But the Assembler also seemed to have trouble with all uppercase labels, so we'll leave labels as lowercase

The Basic wrapper

Our emulator is set to mount the folder "HostFS" as a drive on our RiscOS Machine Lets create a script file to start BASIC and load a text file as it's program. We call this file basic,feb (BASIC COMMA FEB)
Lets look at a simple wrapper for a minimal ASM program (It just returns to basic!) :REM - A basic REM comment statement ;;- an Assembly comment statement (\ also works) [ ] - Start and end of the ASM block DIM MC% 100 - This Defines a block of 101 bytes from free memory and calls it MC% FOR opt%=0 TO 3 STEP 3 - This runs two passes of our assembly file, once with option 0 (No Errors shown)  and once with option 3 (Errors shown + Listing) P%=MC% - This sets the program counter  (P%) for the start of the pass OPT opt% - This is an assembler directive, and tells the assembler what OPTions to use for the pass We also had to replace TAB characters with SPACES, as the assembler doesn't like TABs
if we start with our BASIC script, it will load the file "BasicFile" in automatically for us so we don't need to type anything into basic!
To assemble our program we just use RUN We can start our program with CALL MC% , or by calling the address we assembled to (CALL 6681)

Showing Hello World to the screen

We're going to convert our previous hello world example to BBC BASIC format. The main changes are: Hexadecimal needs to be specified with & prefix Labels need to be prefixed with . (full stop) TABs needed to be replaced with spaces SP needs to be referred to as R13 LR needs to be referred to as R14 Bytes, Words and Longs need to be defined with EQU
When we want to print a character to the screen, we'll use SWI &00 (OS_WriteC). This will show the character into R0 to the screen.
We'll use this PrintChar routine to print a Char 255 terminated string We'll create a function called 'PrintString' which will print the string at address [r1]
When we want to start a new line, we use OS function SWI &03 (OS_NewLine)
We need to define our string! We define a string with EQUS, and a byte with EQUB We also define a 32 bit pointer to our string with EQUD (Double) We re-align to 32 bits with an ALIGN statement
We push the return address R14 onto the stack We load the address of our string, and call our subroutine. We then return to the address on the stack to get back to basic.
We start our program with CALL MC% Our Hello World message will be shown to screen