pawwkm / topz

Toolchain, OS and the Pi Zero

Toolchain, OS and the Pi Zero

At the moment I work on the toolchain, such as the Linker or Disk utility. The project is at its infancy and is designed to take a long time, so I have delicious to work on when I have time to tinker with it. The whole thing is MIT licensed, so no strings attached if you want to play around. However I have only tested it on Windows 7 and at the time of writing the Disk utility is hardwired to the WinApi.

I have no clear idea of what the system is supposed to be able to, but I plan to experiment with just about anything related such as file system design, language design, hardware and so on.

topz's Issues

Handle Fat32 formatted streams

Verify that there is either 0 or 1 main procedure at any time.

Title says it all. There must only be 0 or 1 main procedure for a Program instance.

Streaming the disk

Implement a stream that streams the raw contents of a disk, such as an SD card. This will be useful later when I need to create disk images.

Baking the Pi

There is a bare metal tutorial for the Raspberry Pi which shows how to use the screen. Follow this tutorial to get an idea on how to get started. The result should be an api for writing text to the screen.

Define Assembler Architecture

Define the architecture for the assembler. The library should be called Topz.ArmV6Z. The assembly language is somewhat an high level assembly language since it targets Atom.

procedure Main
{
    MOV  R0, #0     ; R0 accumulates total.
    MOV  R1, #10    ; R1 counts from 10 down to 1.

again:
    ADD  R0, R0, R1
    SUBS R1, R1, #1
    BNE  again

halt:
    B    halt       ; infinite loop to stop computation
}

string str "abc"

data myData 
{
    0x00, 0x01, 0x03
    0x04, 0x05, 0x06
}

data myOtherData "path/to/file.bin"

external data extData
external procedure extProcecure
external string extString

As for now there is no reason to make a big deal out of the assembler. Take in a single file and produce an Atom file from it. No need for expressions and such, but make it easy to add in the future if the need should arise.

Read Atom Files

Link Object Files

Encode Instructions

Encode the follwing instructions in a pass over the AST:

• ADD
• AND
• B
• CMP
• LDR
• LDRB
• LDRD
• MOV
• STR
• STRH
• SUB
• TEQ
• TST

ObjDump

Implement a console program that can dump information about atoms and the object file itself.
Check this out for some ideas.

Parse Arm Procedure

Refactor FormatFat32Command.Execute()

The FormatFat32Command.Execute() method contains code that looks like it should be a simpler overload of Fat32FileSystem.Create.

Assembler Program

Wrap the assembler library in a console program.

• It should accept one or more *.s files.
• -f program.bin
• -o 1231 to specify origin

All parameters are mandatory.

Write Atom Object Files

Implement the Assembler's lexer

USB OTG

The Pi Zero is capable of OTG. It would be cool to implement that ao it could connect to another computer and do some funky stuff via USB.

Master Boot Record

The Pi understands MBR, so I don't need to implement some hackery to have multiple file systems on the SD card. Implement MBR in the virtual file system.

Verify that all nodes have unique names

The Program must check that all of its nodes have unique names. Note that names are case sensitive.

Linker Console

Implement a console program that takes a list of *.o files and links them to a binary or another library.

Define an object code format

Disk utility

Use the virtual file systems api in a disk program. The program should have the following functions.

• Zero out the stream.
• Partition a stream.
• Place a file system in a partition.
• Handle the functions given in the abstract FileSystem class.

In most cases the functions are going to stringed together. To decrease the amount of redundant command line arguments there should be some form of scripting. Much in the same vein of DiskPart.

Rename the project

Rename the project to Topz which stand for Toolchain, OS and the Pi Zero.

Language Integration with Visual Studio

It seems relatively easy to integrate a language and the compiler with Visual Studio.
Custom Compiler Target
Legacy Language Service