Tag Archives: BASIC

Programmatic Loops in Commodore BASIC

In this episode I’ll demonstrate how to use programmatic loops in Commodore BASIC.

I’ll show you how to use the FOR/NEXT loop (available in all versions of Commodore BASIC), as well as the DO/WHILE loops (available on the Plus/4 and C128).

Enjoy!

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

Flow Control in Commodore BASIC

In this episode I’ll explain the concept of Flow Control in Commodore BASIC. It’s kind of a video update of a post I did a while ago.

In essence, it means that we can tell the programme to take a different route in the code depending on a condition that’s met. We’ll explore the IF/THEN and ON… GOTO/GOSUB statements (available on all versions of Commodore BASIC), as well as the expanded IF/THEN/ELSE version (available on the C128 and Plus/4 only).

In addition, I’ll also show you how to use the BEGIN and BEND clauses that were introduced with the C128.

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

How to run Commodore BASIC as a Scripting Language on macOS

Did you know you can run Commodore BASIC v2 on your Mac and Linux systems as a scripting language? It’s true – thanks to the marvellous efforts of Michael Steil and James Abbatiello. They’ve adapted the original BASIC v2 as featured on the VIC-20 and C64 with additional routines so that it works natively on modern machines. It’s ingenious!

You can get the full source code on GitHub – it works a treat!

For those who don’t quite know what to do with it, here are some instructions that’ll help you get CBM BASIC up and running on macOS.

Download

GitHub provides a convenient way to either clone a repository on your local machine if you have GitHub for Desktop installed, or you can download a ZIP file and unZIP it somewhere on your system. Once done, you should see a directory structure that looks exactly like the repo on GitHub.

Compile

You need a few utilities installed your your Mac to be able to compile files. Downloading Xcode will ptovide you with an excellent (and free) IDE as well as the command line tools needed to do that (gcc, make and several other goodies). You might be able to bring those components in using the Homebrew package manager.

Using your Terminal app, navigate to your unZIPped folder. It includes a MAKEFILE so there’s no need to mess with any parameters. Enter “make” at the command prompt, and after a few moments you should have a file called “cbmbasic” without an extension in the same directory. That’s the binary for your Mac.

To make it executable, we’ll have to tweak the file permissions – otherwise our operating system won’t be able to run it. We’ll do it using the chmod command:

You can test if it works by calling the binary without any parameters like this:

If all goes well you should see something like this:

For easy access, copy the binary over to your /usr/bin directory. That’s where common command line utilities are installed on Mac and Linux systems. The added benefit is that the path to that folder is already in your local $PATH variable, and as such you can simply type “cbmbasic” from any location when you’re on the command line.

Here’s how to copy the binary over (this will ask for your administrator password):

Using Direct Mode

When you run the binary it will bring up something like the standard BASIC command prompt we’re used to seeing on the Commodore 64. There are however a few important differences between a C64 emulator and this implementation:

  • this is NOT an emulator
  • cursor keys DO NOT work
  • all commands typed in must be CAPITALISED

Other than that, you can start typing like on a real machine. Be careful with certain POKE commands though as those may call system routines that might not be implemented.

LOAD and SAVE commands have been tweaked to reference the command line structure. They work just fine, but will load and save files in Commodore file format (which is not clear text ASCII – more on that later). For example:

The above displays the directory of the current folder, much like it was an attached floppy drive. How cool is that? You can reference folders using both LOAD and SAVE just as if you were on the command line.

You can also type in programmes and run them – however the cursor keys won’t work, so there’s no screen editing options. Programmes SAVEd from direct mode cannot be loaded from the command line, only from direct mode (i.e. when launching the binary without parameters).

To quit direct mode, hit CTRL+C.

Running Programmes from the Command Line

The real power of this implementation can be seen when we run files from the command line. Those files must not be SAVEd from direct mode, but instead are simple clear text files. The extension doesn’t matter, but for good practice, let’s store them as .BAS files (much like shell scripts are stored with the.SH extension, or PHP files would be stored with the .PHP extension… you get the idea).

You can write standard BASIC programmes use your favourite text editor (like vi from the command line), or try one from the “test” directory that’s provided with the repository.

Imagine we had a file called “hello.bas” that we’ve created with vi, looking like this:

To run our file, we can simply define it behind the binary like this:

cbmbasic hello.bas

This will greet us with the “Hello World” message on the command line.

Running Script Files

Alternatively, we can specify the full path to cbmbasic at the beginning of a file (she-bang notation) and run it just like any other script file. Observe please:

#!/usr/bin/cbmbasic
10 PRINT “Hello World”
20 PRINT “from CBM BASIC :-)”

If the file was called “hello”, we’d need to change the permissions again so that the file can be executed:

Now we can run it like this:

Sweet – but I can’t work out how to compile this on macOS…

Fear not – I’ve got a macOS binary that was compiled on 10.12 “Sierra”. You can find it in my fork of the project. Check out the “binaries” folder.

Does it work on Windows? Or on Linux?

I’ve tested compiling and running this puppy on CentOS 6 and 7 with roaring success. The above steps worked fine for it, so I’m assuming it’ll work on other Linux flavours just as well (the beauty of portable C code).

According to the author, it works fine on Windows too – however I have no idea how to compile source code on Windows, so you’ll have to figure that out for yourself. I hear good things about Visual Studio  – if I work out how to do it, I’ll add it to the “binaries” folder on my GitHub Fork.

Can I write my own extensions to BASIC?

Apparently so – check our Michael’s site and repo for details:

  • https://www.pagetable.com/?p=48
  • https://www.pagetable.com/?p=35
  • https://github.com/mist64/cbmbasic

Right now, if you run SYS 1 from direct mode first, you can use the SYSTEM command (followed by anything you’d like to execute on the command line in “double quotes”) as well as LOCATE (followed by an x and y coordinate to place the text cursor) and WAIT.

Have fun hacking BASIC and letting it run with the blistering speed of modern CPUs 🙂

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

Lottery Statistics in Commodore BASIC

In this episode I’m adding statistics support to my previous lottery generator on the Commodore 64.

I’ll add an array that is updated if my supplied numbers have been matched, and how many times over how many draws this has happened. I’ll also add an option to pause the programme and display the statistics before random draws can continue.

When this app is run continuously it will collect statistical data on how many lottery draws are necessary to match all supplied numbers.

PS: By the time the video had uploaded, my emulator had drawn over one million sets, and none of them have matched my numbers 🙁

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

Matching Lottery Numbers on the Commodore 64

In this episode I’m amending my previous lottery number generator to take six lucky numbers from the user to match against the randomly drawn numbers from the Commodore 64.

This will allow us to compare what the computer has drawn to the user’s input, as well as keep drawing numbers until the user input comes up. It’ll be an interesting experiment to see how many draws that will take…

Enjoy!

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

Working with Keyboard Input in Commodore BASIC

In this episode I’ll show you three ways to take user input from the keyboard in Commodore BASIC.

The INPUT and GET commands work on all systems, while the GETKEY command only works on the Plus/4 and C128. I’ll demonstrate how to use all of them.

This will come in handy for our little lottery programme we’ve been working on, so that we can prompt the user for some numbers to compare against later.

Enjoy!

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

How to print numbers as columns in Commodore BASIC

In this episode I’m demonstrating how to print numbers in evenly spaced columns in Commodore BASIC.

On the C128 and the Plus/4 we can use a nifty little function called PRINT USING for this, with which we can format the output of any printed text or variable.

On the C64 and VIC-20 that function doesn’t exist, so we’ll have to convert a numeric value into a string (using the STR$ function), and then determine how long our string is. Following that we’ll have to manually pad our string value with as many spaces as are required. Continue reading How to print numbers as columns in Commodore BASIC

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

How to build a Word Splitter on the C64 in Commodore BASIC

In this episode I’m demonstrating how to build a word splitter on the Commodore 64. We’ll use string functions to parse a sentence and split each word off into an array of words so that they can be analysed later (for example, as part of an adventure game).

Here’s the code I’m building:

The interesting part starts in line 100 and onwards, where I’m building a subroutine that deals with the string functions. In line 110 I’m resetting/initialising two of the three important variables: LT$ holds a single letter from the phrase we’re getting in A$, while WD is counting each word we’re splitting out.

The FOR loop in line 120 parses each letter of the phrase, and if it finds a space character (line 140), the word count is increased. If the letter is not a space, then it’s added to the current word held in WD$(WD). The current word is assembled character by character.

Apologies for the audio quality, I did this on my laptop while sitting on the balcony, hence sea planes flying overhead can be heard (as well as the neighbours dog and kids).

Happy hacking 🙂

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

How to build a time of day clock on the Commodore 64

In this video I’ll demonstrate how to build a simple clock on the C64. We’ll go through this process step by step, including the built-in TI and TI$ variables, string formatting with LEFT$, RIGHT$ and MID$, as well as screen formatting.

Here’s the code I’m writing – works in Commodore BASIC v2 and above:

Many of the characters that appear in this listing are cursor control characters and appear in reverse in the video. They either position the cursor or print PETSCII graphics.

Inspired by David’s video, in which he connects an LCD screen to his C64’s User Port: https://www.youtube.com/watch?v=vV8FbwobrKY

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast:

How to create random YouTube URLs in Commodore BASIC v2

In this episode I’ll demonstrate how to create those seemingly random YouTube Video IDs using a Commodore 64.

Here’s the code I’m writing – works in BASIC v2 and above:

The first line switches to lower case letters (I forgot to show that in the video).

NOTE: In addition to the upper case and lower case alphabet, and the numbers 0-9, YouTube also use two special characters that I forgot to mention in the video. One is the standard minus sign (-), and the other one is the underscore (_). The Commodore machines cannot produce the latter. For simplicity’s sake, I’ve left both of those out (just though I’d mention it here).

Inspired by Tom Scott’s video “Will YouTube ever run out of Video IDs” – watch it here: https://www.youtube.com/watch?v=gocwRvLhDf8

Watch the full course in one convenient playlist:
Catch this episode on my Commodore Podcast: