# Assembly bubble sort for z80

I have an assignment for my university. I need to make a program in assembly for the z80 processor. The program should do the following.

There are 20 numbers stored in 20 continuous memory addresses starting from 0201H.

The program should check the number stored in 0200H first. If the value is 0 the program should sort the number in ascending order, otherwise descending. Finally after the sorting is over the program should calculate the average of these 20 numbers.

I know that this question is not formed according to the rules of the site but I really need help.

Here's a quick guide to Z-80 assembly language. Think of it like C but with most of the features removed. Fundamentally you only have a few variables to work with:

``````unsigned char A;
unsigned short BC, DE, HL, IX, IY;
unsigned char memory;
``````

There are no structures, no blocks, no for or while loops and a sort of mangled `if`. There is `goto` which will jump to a label. Or you can `call` a label which is like a subroutine but it takes no arguments and returns void. We can always build up more functionality from these pieces, but for simple programs the variables we have and a few pieces of `memory[]` will be enough.

You can use `=` for assignment but there are a lot of rules. For instance, all these are legal:

``````A = memory;
memory = A;
A = memory[BC];
memory[DE] = A;
``````

But you can't use any old expression like:

``````A = memory[BC + DE];
``````

The `short` variables can be assigned to and from `memory[]` but since they're bigger than `char` they are automatically split up. When you say `memory = BC;` it recognizes that it won't fit and does this on your behalf:

``````memory = BC % 256;
memory = BC / 256;
``````

And to be useful, the opposite happens when you say `BC = memory`:

``````BC = memory + memory * 256;
``````

To get even weirder, you can talk about these high and low parts of `BC` independently as `B` and `C`. But you can't do `B = memory`. If you want that, you need to use `A` as in intermediary:

``````A = memory;
B = A;
``````

`DE` can be addressed as `D` and `E` and `HL` as `H` and `L`. But not `IX` and `IY` (well, not legally, but let's not get into that).

All of the variables can be incremented and decremented. `A = A + 1` or `A++` if you like. `A = A - 1`. Same with `BC`, `DE`, `HL`, `IX`, `B`, `C` and so on.

Can you do `D = D + 2`? No! You have to do `D++; D++;`. When it comes to math, `A` is special. You can add any unsigned character to it or a constant. Or subtract. There are some logical operations like `&`, `|` and `^` but let's not worry about those. You can also add or subtract any of our `unsigned char` variables like `D` or `L`. But you can't add or subtract `memory[]`. That also has to be done in pieces. Suppose you want `A = A + memory`:

``````B = A; // save A
A = memory;
A = A + B;
``````

Yes, it can get tedious. One comes to appreciate compilers. You can also add and subtract from HL, IX and IY but in even more limited cases:

``````HL = HL + BC;
HL = HL + DE;
HL = HL + HL;  // Same as HL = 2 * HL.
IX = IX + BC;
IX = IX + DE;
IX = IX + IX;
// And follow the same pattern for IY
``````

What about multiplying and dividing? Nope, not supported. With loops and bit shift operators you can manage to simulate them, though. Or less efficiently you can do multiplication by repeated addition and division by repeated subtraction.

But what about loops, anyways? Well, you could fill memory with something like this:

``````HL = 9; // You can assign constants to all your variables, thankfully.
A = 0;
loop:
memory[HL] = A;
HL = HL + 1;
goto loop;
``````

Did I mention that your program lives in `memory[]`? No? Well, it does so that's a problem. If you only want to clear only 10 of `memory[]`, how would you do that? Here's where the deranged `if` comes in. You'd like to write something like this:

``````HL = 9;
A = 0;
B = 10;
loop:
memory[HL] = A;
HL++;
B = B - 1;
if (B == 0) goto loop
``````

[ Ooops, that's a bug. Should be != 0, but pretend it was the right thing; I'm too lazy to retype this all. ] But `if (B == 0)` isn't something that is supported. Too complicated. But there is a `goto loop if zero;` What does that mean? Well, every time you do math the processor remembers a few things about the result. One is if the result was equal to zero. As it turns out we can simply replace that `if` with:

``````goto loop if zero;
``````

And we'll do our loop 10 times. We can even generalize the code to, say, clear out a number of `memory[]` entries as given by `C`. How? By having `B` count up and looping back as long as it isn't equal to `C` yet. We can't do `if (B == C)`, but we can subtract `B` from `C` and check on a zero result which is the same thing. Well, we can't do `C = C - B`, only A can do that. The loop will look something like this:

``````loop:
memory[HL] = 0; // turns out we can do this
HL = HL + 1;
B = B + 1;
A = C;
A = A - B;
goto done if zero;
goto loop;
done:
``````

Awkward, but it'll work. The designers have some mercy. You can `goto` if the result is not zero:

``````A = A - B;
goto loop if not zero;
``````

There are some other tests allowed like if the result is less than or greater than zero. But simple testing against zero can take us far.

Special cases abound. What if we accidentally wrote this:

``````loop:
memory[HL] = 0;
B = B - 1;
HL = HL + 1;
goto loop if not-zero;
``````

Looks like a bug, doesn't it. Instead of doing `B` iterations we'll just keep on going until `HL` wraps around to 0. But it isn't so. When we add or subtract a short value like `HL` it doesn't affect the `zero/not-zero` condition. The code will work. In fact, this is considered a feature by the designers of the Z-80.

About the only other thing I'll mention is function calls or subroutines, if you will. Given how every little thing has to be spelled out you can see how even a simple function that multiplies a number by 4 would be nice. But there are no arguments and no return values. Can't say things like `B = mult4(B);` Instead we just set up conventions where we decide what variables or memory locations are used specially to pass parameters and where the results go. The caller then as to figure it out. We might define a subroutine that multiplies `B` by 4 and returns the result in `A`:

``````mult4:
A = B;
A = A + A; // that is, B * 2
A = A + A; // B * 4, we're don!
return;
``````

If we wan't to multiply `D` by 4 we'd do this:

``````B = D;
mult4();
D = A;
``````

Fair enough. We'd also have to remember that mult4() wiped out the value in `A` so we better have saved it if we needed it. And for that matter we ourselves have to use up `B` to make the call. If we needed those variables then we'd just have to find somewhere to stash them away in `memory[]`.

``````memory = A; // can't forget A
B = D;
mult4();
D = A;
A = memory; // back to what it was.
``````

So that's Z-80 assembly language programming. Oh, there's a bunch of other stuff. And you have do say everything with an accent, but if you look up information about Z-80 assembly language I'm sure you'll get the idea. Here are a few examples:

``````A = memory;               LD A,(4)
A = 3;                       LD A,3
memory = A;               LD (2),A
A = A + B;                   ADD A,B
B = B + 1;                   INC B
``````