Converting a decimal number stored as a string into Binary, Octal and Hexadecimal

In this tutorial we are going to manually convert a decimal number stored inside a string into:

• Base 2 (Binary)

• Base 8 (Octal)

• Base 16 (Hexadecimal)

This example avoids built-in conversion commands on purpose, so beginners can see how the process works internally.

Example Output Usage

s$="87654321"
print s$ +"="+ ConvertTo(S$,2)
print s$ +"="+ ConvertTo(S$,8)
print s$ +"="+ ConvertTo(S$,16)
print ""

s$="-12345678"
print s$ +"="+ ConvertTo(S$,2)
print s$ +"="+ ConvertTo(S$,8)
print s$ +"="+ ConvertTo(S$,16)
print ""

s$="255"
print s$ +"="+ ConvertTo(S$,2)
print s$ +"="+ ConvertTo(S$,8)
print s$ +"="+ ConvertTo(S$,16)
print ""

Sync
waitkey

Step 1: Manually Converting the String to an Integer

Before we can convert to another base, we must first turn the string into an actual integer value.

This is done digit-by-digit using basic decimal math.

Function ConvertTo(S$,Base)
rem assumed 32bit integers
Total =0
Negate=0

for lp=1 to len(s$)
    Total=Total*10
    ThisCHR = asc(mid$(s$,lp))

    if ThisChr = asc("-") then Negate=1   

    if ThisChr >= asc("0") and ThisCHR<=asc("9")
        Total=Total+(ThisCHR-Asc("0"))       
    endif
next

if Negate then Total *= -1   

What’s happening here?

• Each digit is multiplied into place using base-10 math

• `ASC()` is used to convert characters into numeric values

• The minus symbol `"-"` is detected and applied at the end

This is essentially how a basic `Val()` function works internally.

Step 2: Preparing for Base Conversion

Each output base is selected using bit grouping.

select base
case 2
Shift=1
Characters$="01"
case 8
Shift=3
Characters$="01234567"
case 16
Shift=4
Characters$="0123456789ABCDEF"
endselect

Why these values?

• Binary uses 1 bit per digit

• Octal uses 3 bits per digit

• Hexadecimal uses 4 bits per digit

Step 3: Bitwise Conversion Loop

Now the number is converted using bit masking and bit shifting.

if Shift
Mask    = (2^Shift)-1
Digits = 32 / Shift

    For lp=0 to Digits-1
        ThisCHR = Total and MASK
        Result$ = Mid$(Characters$,ThisChr+1,1) + Result$
        Total = Total >> Shift                               
    next
endif
   

EndFunction Result$

Important notes:

• Output is a fixed 32-bit representation

• Leading zeros are expected and correct

• Negative numbers are shown using two’s complement

The result string is built from right to left because the least-significant bits are processed first.

Summary

This tutorial demonstrates:

• Manual string → integer conversion

• Decimal positional maths

• Bit masking and shifting

• Why binary, octal and hex exist

• How CPUs naturally represent numbers

This approach may not be the shortest, but it clearly shows how the conversion works under the hood — making it ideal for learners.

Complete Code:

    s$="87654321"
    print s$ +"="+ ConvertTo(S$,2)
    print s$ +"="+ ConvertTo(S$,8)
    print s$ +"="+ ConvertTo(S$,16)
    print ""

    s$="-12345678"
    print s$ +"="+ ConvertTo(S$,2)
    print s$ +"="+ ConvertTo(S$,8)
    print s$ +"="+ ConvertTo(S$,16)
    print ""

    s$="255"
    print s$ +"="+ ConvertTo(S$,2)
    print s$ +"="+ ConvertTo(S$,8)
    print s$ +"="+ ConvertTo(S$,16)
    print ""

    Sync
    waitkey
   

Function ConvertTo(S$,Base)
    rem assumed 32bit integers
    Total =0
    Negate=0
    for lp=1 to len(s$)
        Total    =Total*10
        ThisCHR = mid(s$,lp)
        if ThisChr = asc("-") then Negate=1   
        if ThisChr >= asc("0") and ThisCHR<=asc("9")
            Total=Total+(ThisCHR-Asc("0"))       
        endif
    next
    if Negate then Total *= -1   

    Characters$    ="0123456789ABCDEF"
    select base
                case 2
                    Shift=1   
                case 8
                    Shift=3   
                case 16
                    Shift=4   
    endselect   
   
    if Shift
        Mask        =(2^Shift)-1
        For lp=1 to 32 / Shift
                ThisCHR = Total and MASK
                Result$ = Mid$(CHaracters$,ThisChr+1,1) +Result$
                Total = Total >> Shift                               
        next
    endif
       
EndFunction Result$

Introduction

Welcome back, PlayBASIC coders!

In this live session, I set out to build something every programming language and tool needs — a lexer (or lexical scanner). If you’ve never written one before, don’t worry — this guide walks through the whole process step by step.

A lexer’s job is simple: it scans through a piece of text and classifies groups of characters into meaningful types — things like words, numbers, and whitespace. These little building blocks are called tokens, and they form the foundation for everything that comes next in a compiler or interpreter.

So, let’s dive in and build one from scratch in PlayBASIC.

Starting with a Simple String

We begin with a test string — just a small bit of text containing words, spaces, and a number:

s$ = "   1212123323      This is a message number"
Print s$

This gives us something to analyze. The plan is to loop through this string character by character, figure out what each character represents, and then group similar characters together.

In PlayBASIC, strings are 1-indexed, which means the first character is at position 1 (not 0 like in some other languages). So our loop will run from 1 to the length of the string.

Stepping Through Characters

The core of our lexer is a simple `For/Next` loop that moves through each character:

For lp = 1 To Len(s$)
    ThisCHR = Mid(s$, lp)
Next

At this stage, we’re just reading characters — no classification yet.

The next question is: how do we know what type of character we’re looking at?

Detecting Alphabetical Characters

We start by figuring out if a character is alphabetical. The simplest way is by comparing ASCII values:

If ThisCHR >= Asc("A") And ThisCHR <= Asc("Z")
    ; Uppercase
EndIf

If ThisCHR >= Asc("a") And ThisCHR <= Asc("z")
    ; Lowercase
EndIf

That works, but it’s messy to write out in full every time. So let’s clean it up by rolling it into a helper function:

Function IsAlphaCHR(ThisCHR)
    State = (ThisCHR >= Asc("a") And ThisCHR <= Asc("z")) Or _
            (ThisCHR >= Asc("A") And ThisCHR <= Asc("Z"))
EndFunction State

Now we can simply check:

If IsAlphaCHR(ThisCHR)
    Print Chr$(ThisCHR)
EndIf

That already gives us all the letters from our string — but one at a time.

To make it more useful, we’ll start grouping consecutive letters into words.

Grouping Characters into Words

Instead of reacting to each character individually, we look ahead to find where a run of letters ends. This is done with a nested loop:

If IsAlphaCHR(ThisCHR)
    For ChrLP = lp To Len(s$)
        If Not IsAlphaCHR(Mid(s$, ChrLP)) Then Exit
        EndPOS = ChrLP
    Next
    ThisWord$ = Mid$(s$, lp, (EndPOS - lp) + 1)
    Print "Word: " + ThisWord$
    lp = EndPOS
EndIf

Now our lexer can detect whole words — groups of letters treated as a single unit.

That’s the first real step toward tokenization.

Detecting Whitespace

The next type of token is whitespace — spaces and tabs.

We’ll build another helper function:

Function IsWhiteSpace(ThisCHR)
    State = (ThisCHR = Asc(" ")) Or (ThisCHR = 9)
EndFunction State

Then use the same nested-loop pattern:

If IsWhiteSpace(ThisCHR)
    For ChrLP = lp To Len(s$)
        If Not IsWhiteSpace(Mid(s$, ChrLP)) Then Exit
        EndPOS = ChrLP
    Next
    WhiteSpace$ = Mid$(s$, lp, (EndPOS - lp) + 1)
    Print "White Space: " + Str$(Len(WhiteSpace$))
    lp = EndPOS
EndIf

Now we can clearly see which parts of the string are spaces and how many characters each whitespace block contains.

Detecting Numbers

Finally, let’s detect numeric characters using another helper:

Function IsNumericCHR(ThisCHR)
    State = (ThisCHR >= Asc("0")) And (ThisCHR <= Asc("9"))
EndFunction State

And apply it just like before:

If IsNumericCHR(ThisCHR)
    For ChrLP = lp To Len(s$)
        If Not IsNumericCHR(Mid(s$, ChrLP)) Then Exit
        EndPOS = ChrLP
    Next
    Number$ = Mid$(s$, lp, (EndPOS - lp) + 1)
    Print "Number: " + Number$
    lp = EndPOS
EndIf

Now we can identify three types of tokens:

Words (alphabetical groups)

Whitespace (spaces and tabs)

Numbers (digits)

Type tToken
    TokenType
    Value$
    Position
EndType
Dim Tokens(1000) As tToken

Constant TokenTYPE_WORD        = 1
Constant TokenTYPE_NUMERIC     = 2
Constant TokenTYPE_WHITESPACE  = 4

Tokens(TokenCount).TokenType = TokenTYPE_WORD
Tokens(TokenCount).Value$    = ThisWord$
TokenCount++

For lp = 0 To TokenCount - 1
    Select Tokens(lp).TokenType
        Case TokenTYPE_WORD:       c = $00FF00 ; green
        Case TokenTYPE_NUMERIC:    c = $0000FF ; blue
        Case TokenTYPE_WHITESPACE: c = $000000 ; black
        Default:                   c = $FF0000
    EndSelect

    Ink c
    Print Tokens(lp).Value$
Next

Compilers use it as the first step in parsing code.

Adventure games might use it to process typed player commands.

Expression evaluators or script interpreters rely on it to break down formulas and logic.

The big takeaway? A lexer doesn’t have to be complicated.

This simple approach — scanning text, detecting groups, and tagging them — is the heart of it. Once you understand that, you can expand it to handle symbols, punctuation, operators, and beyond.

If you’d like to see more about extending this lexer or turning it into a parser, let me know in the comments — or check out the full live session on YouTube.

Links:

🔍 Is XOR Decryption in PlayBASIC as Fast as Assembly?

Every now and then, a forum question pops up that really catches my attention — and this one did just that. A PlayBASIC user recently asked:

> "Is using XOR decryption when loading media from memory in PlayBASIC as fast as doing it in assembly?"

At first, I was a little puzzled. Why? Because the function in question is written in assembly — it's already doing exactly what the user thought might be a separate optimization path. So, let's unpack what's really going on behind the scenes when you XOR encrypted media in memory using PlayBASIC.

🔐 XOR Media Loading: A Quick Recap

Years ago, PlayBASIC added support for loading media directly from memory. Earlier versions relied on external packer tools to encrypt and wrap media, but these days, you can load and decode encrypted content entirely from within your program.

The basic workflow is:

1. 1. Load your file into memory.
2. 2. Call the `XORMemory` function with a key.
3. 3. The content is decrypted and ready to use.

You can use any XOR key you like. While XOR encryption is relatively simple and easily reversible, it’s still useful for basic protection against casual asset ripping.

🧠 What Happens Internally?

When you call `XORMemory`, PlayBASIC doesn’t interpret the data — it pushes the work down to the engine’s internal rendering system. Specifically, it uses the XOR ink mode inside the `Box` drawing function.

This function writes color data onto a surface by XOR’ing it with the existing pixels. Here’s what makes it cool: that surface isn’t necessarily a visible screen — it's just treated as raw memory.

To decrypt, the engine: