FreeBasic Bare Bones: Difference between revisions

While the forum has several flamewars about BASIC, it is a turing-complete language. FreeBasic adds functionality that makes it suitable for OS development. This tutorial provides a working kernel in Basic, together with the pitfalls associated with it.

 

 

In FreeBasic, a pointer is defined by adding the Ptr keyword.

Dim mypointer As Byte Ptr

This one holds the location of a byte of memory.

Dim mypointer As Long Ptr

This one points to the first of 4 bytes of memory, which together form the number.

 

You can not use pointers straight away. Consider sending a letter with no address on it will not do any good. So we must first put an address in there. That leads to the question: how do we get an address. Some things have fixed addresses, like the video card.

You can also ask variables for their addresses.

Dim variable as Byte

Dim pointer as Byte Ptr

pointer = @variable

The @ returns the address of the variable that follows it.

Dim pointer as Byte Ptr

Dim address as Long

address = 12345

pointer = CPtr(Byte Ptr, address)

Here CPtr (Convert to Pointer) is used to create pointers. You give it a type (Byte Ptr) and the address. You can also change pointers:

Dim pointer1 as Byte Ptr

Dim pointer2 as Long Ptr

pointer2 = CPtr(Long Ptr, pointer1)

Be careful when you do so: a byte occupies one location in memory, a long occupies four. if we would use this pointer, we would use three locations in memory of which we know nothing about. Sometimes, they are necessary, like when we want to work with strings without having the Runtime.

 

You can access pointers with an index:

Dim value as Long

Dim pointer as Long Pointer

pointer = @value

' value = pointer[0]

when we want to know what is behind the pointer, we ask for the memory at its location with the [ ], and then we add a number which tells us how many locations further to look. When we use [0] it simply means that we do not want to do anything with the address stored in the pointer. The result is the value stored in the memory locations pointed to by the pointer. For byte pointers, this will look at the address stored and return the result. For other pointers, it will look at a series of locations and return what those values represent.

 

Strings are useful, but tedious. A string is stored as a series of bytes in consecutive addresses. You can build a pointer to a string as well:

Dim s as String

Dim pointer as String Ptr

pointer = @s

But since we do not have the Runtime, we have to use something that does not use it.

Const s = "Text"

Dim pointer as Byte Ptr

' pointer[3] = Asc("t")

' pointer[4] = 0

The first example uses the Runtime which will not compile. The second example shows the only working method of using strings: Define one using Const, then ask for a pointer to that. Since a string is a sequence of characters (bytes), we change the type of the pointer in the process. Next we can ask for individual characters as if it were an array. However, they now appear as numbers. The ASCII codes to be precise, and the same as when you use Chr$() and Asc().

 

Basic uses an borrowed trick to tell us the end of the string. After the last character, there will always be a 0. So if we read a string in order, we can tell when it has ended.

 

Sub PrintString(src As Byte Ptr, x As Long, y As Long)

wend

End Sub

 

 

== Tuning FreeBasic for OS Development ==

 

=== kernel.bas ===

Declare Sub PrintString(src As Byte Ptr, x As Long, y As Long)

Declare Sub main ()

wend

End Sub

 

=== link.ld ===

OUTPUT_FORMAT("elf32-i386")

ENTRY (loader)

}

}

 

=== Build instructions ===

 

<tt>kernel.bin</tt> can then be loaded by [[GRUB]]

The Runtime is built on top of the C library. FreeBasic provides sources to the Runtime (which are written in C). You'll need to provide the C library. Since many parts of the kernel rely heavily upon each other, you will probably add the Runtime in steps.

Some functions compile cleanly with minimal effort. When you compile the CType, String and Stdlib (excluding malloc, calloc, and free) parts of the runtime can be compiled on top of those.

 

[[Category:Bare bones tutorials]]