In the previous post we saw a couple of variable types and the basic arithmetic operators. Today we’ll complete this part by taking a look at the bitwise operators and seeing a couple of characteristics of the char type.

Bitwise arithmetic operators

You may be aware already that computers store all data internally in binary. This is also the case with all the data types in MSX-C. As an example, the table below shows how some integer values are represented internally in the MSX computer memory:

Integer values represented in binary

The computer always works in binary, but in most cases we don’t care how MSX-C stores data internally because the compiler handles these details for us. However, there are situations when working with binary data makes sense, as in the case of working with graphics or programming hardware devices.

In the previous post we saw how to print text and numbers on the screen. This time we’ll learn how to use variables and how to operate with them.

You probably know already what a variable is. It’s just some place in the computer memory that we use to store a piece of data. In C, a variable can contain data of one of several basic types. Let’s take a look at them.

Character variables – the char type

We have already seen this type in some of the examples in previous posts. The program below assigns the character ‘X’ to the character variable c and prints it to the screen using putchar():

26-1.C (Click to enlarge)

The last two posts were very technical: we saw how to write assembler routines and use them in MSX-C and also the opposite, how to write MSX-C code and then use it in assembler programs.

Today we’re going to go back to where we left it in chapter 18 and continue learning the basics of MSX-C. First, we’re going to see how to display text and numbers on the screen.

Displaying characters one at a time: putchar()

We already saw the function putchar() in chapter 18, but we didn’t explain at the time what this function does.

putchar() outputs a single character to the screen. We can pass the character inside single quotes (this is known as a character constant), or we can pass a variable that contains the character we want to output.

Let’s see a very simple example:

25-1.C (Click to enlarge)

We saw in the previous post how to run assembler routines from MSX-C. I’m sure you’re about to ask whether it’s possible to do the opposite: Is it possible to write programs in assembler and use the functions from the MSX-C Standard Library or the MSX-C Library disk?

I’m glad you asked. Yes, it’s possible, and it’s actually very easy to do.

Here’s how.

Calling MSX-C library functions from assembler programs

The rules that we saw for how MSX-C passes parameters to assembler functions also apply to MSX-C’s own library functions. This means that we can leave arguments in the CPU registers or in the stack as appropriate and call the function just like that.

As always, let’s see an example:

EXAMPLE.MAC (Click to enlarge)

Good news for all retro computer users, including MSX:

A new retro shop will be opening in Akihabara during the next few weeks. The name: BEEP.

According to their still under construction website (http://www.akihabara-beep.com), they’ll deal with retro computers, retro games, arcade games, and fanmade items. In the updates they’re posting on Twitter (@BEEP_akihabara) we can see that they have lots and lots of MSX-related stuff, including several piles of unopened, brand new Pioneer PX-V60 MSX computers that they’re selling for 19,800 yen each (they sell used ones for 8,000 yen).

They’re planning to open during the Japanese silver week, which is the week from September 21st to 25th. Unfortunately, that week I’ll be traveling out of the country, so I really, really hope they get a bit delayed so I can attend during the opening. :-)

Take a look at their Twitter feed: it’s worth it.

URL: http://www.akihabara-beep.com
Twitter: @BEEP_akihabara

Address:

Akihabara BEEP
Nakaei Building (basement)
3-9-8 Sotokanda, Chiyoda-ku
Tokyo 101-0021

MSXですがPX-V60の販売ですが中古は8000円と消費税、新品は19800円と消費税での販売です。お一人様一台まででお願い致します pic.twitter.com/6x8izI1vtx

— BEEP秋葉原店 (@BEEP_akihabara) August 10, 2015

並べるとそれらしくなってきました これから防犯の準備します pic.twitter.com/Qfza2OxCP4

— BEEP秋葉原店 (@BEEP_akihabara) September 3, 2015

In the previous post we learnt a couple things about how MSX-DOS manages files and runs programs.

This post is more technical: we’ll see how to use assembler routines from MSX-C.

This subject is a bit more advanced that what we’ve seen so far. Feel free to skip this chapter for the time being if you don’t need to mix C and assembler yet. The reason why we’re going to see this now is that there are advanced users playing around with MSX-C who have asked how to do this.

Standard types in MSX-C

First of all we need to understand how the standard MSX-C data types are stored in memory.

16-bit values are always stored in memory with the low order byte first (little endian), and the high order byte in the memory address after it.

There’s also a couple things we have to keep in mind:

• In MSX-C pointers are always 16-bit values, the same as integer values
• The numeric types short and int are exactly the same thing

The previous post ended with the description of the first of the three MSX-DOS functions: I/O. This time we will see an introduction to the other two: file management and program execution.

File management

Without doubt, the most useful peripheral in a computer system is the storage device, whether it’s a floppy disk drive, a hard disk, optical media, or some kind of flash storage attached via a generic interface.

Early MSX computers supported only cassette tape as storage media. It was slow and somewhat unreliable, but it was very cheap.

A cassette data recorder used in personal computers during the mid-80s. This model supported reading tapes at 2400 bps, twice the normal speed (MSX Magazine, May 1985) (Click to enlarge)

Besides the low speed, the big drawback of tapes was that the only way to access the data on them was sequentially: in order to access a program in a tape, you had to either read all other data stored before it, or manually rewind the tape to the location of the program you wanted to load. Needless to say, this wasn’t very fun.

Typical gaming session when loading games from cassette tape during the 80s.

In the previous post we learnt about mnemonics and pseudoinstructions, symbols and labels. This is a good start, but learning assembler won’t be any use at all if we don’t also learn the environment where our programs will run. In our case this environment is going to be MSX-DOS, the MSX Disk Operating System. Let’s see what this means.

Functions of the operating system

The most basic functions of any operating system are:

• Input and output of data from/to peripherals (keyboard, screen, printer, etc)
• File management
• Running programs

MSX-DOS is able to handle all these, plus a few other tasks. let’s look at them in more detail:

In the previous post we learnt what an assembler does and also the differences between assembly language and two high-level programming languages: BASIC and C.

This time we’ll see an actual assembly language program and compare it with a BASIC program that does the same function.  We’ll learn about pseudoinstructions and labels, and we’ll see an example of an assemble list for our first assembly language program.

Note: so far I’ve been using the terms assembly language and assembler, the first one when talking about the programming language we use to write programs, and the second one to refer to the program that handles the task of converting the source code into a file we can run. However, many people often use the term assembler to refer to the assembly language as well. I’m one of these people. Because of this, keep the following in mind:

• Assembly language (or just assembly) always refers to the programming language
• Assembler may refer to either the programming language, or to the program used to assemble the source code

The context in the sentence should always make it clear to see which one we’re talking about.

Let’s start:

It’s been a looong while since the last post. Almost half a year. That’ll teach me to set deadlines for stuff I do in my free time.

Let’s continue where we left it in the last post: we’re going to start learning how to code in assembly language. It will be very handy even when working with C because often we will need to understand what the computer is doing behind the scenes. Plus, it’s actually very simple to learn (though mastering it and learning the underlying hardware will take some more time.)

In this series of articles we’re going to follow the book MSX-DOSアセンブラプルグラミング (MSX-DOS Assembler Programming) by Tetsuya Kageyama,  published by ASCII Publications in 1988:

MSX-DOS Assembler Programming (ASCII Publications, 1988)

Without further ado:

Assemblers and the assembly language

When reading a book on machine code, we often read sentences like this:

…to create programs in machine code we write an assembly language program and we use a tool called an assembler.

Sometimes the meaning of this isn’t obvious to everybody. What does the assembler do? What kind of programming language is assembly?

Let’s try and answer these questions.