Ca65 "Constant expression expected"

So, I have a struct for an object slot, and that's fine, but for whatever reason, ca65 doesn't like what I'm doing here:


Doesn't "*-" mean the size of?

I read *-ObjectSlot-16 to mean "{whatever the assembler thinks PC or the current 16-bit address is} minus {whatever ObjectSlot is} minus 16".

It's multiplied by 16.

You can use .sizeof to get the size of a struct.

When applying that to the code, it says "unexpected trailing garbage characters"

Try a space after .res and an asterisk instead of an x:

1. No space between .res and .sizeof?
2. Are you expecting x16 to mean "times 16"? You might meant * 16?
(Edit: tepples made both those points already.)

What's ObjectSlot? Is it in the same segment?

It seems like ObjectTable - ObjectSlot might substitute for * - ObjectSlot in this case. The expression * is constant at link time, but not at assembly time. I'm not sure how smart the assembler is at deducing relative constants with it; it might fare better with labels in this respect? Possibly the problem is exacerbated because .res needs to evaluate constant immediately during the single pass assembly.

It sounds like ObjectSlot is a struct, so they definitely don't want ObjectTable - ObjectSlot or * - ObjectSlot.

Yeah, thanks guys, this works.

Not directly related to the problem earlier, but why start a new thread. I saw that I had something like:


So I went and replaced every instance of SpriteBuf1Size with *-SpriteBuf1. I also had something that was SpriteBuf1Size+SpriteBuf2Size, that was just called "SpriteBufSize". It was being used at this "assert" that I noticed:


So I changed it to this:


However, for some reason unknown to me, it triggers the error. Is this not right? There's no way it could be too big:


Actually, wait, what? (referring to "*")


How does this minus where something is equal the size of something?

You don't seem to understand what * actually does, or what it is for.

If there was a label on the current line, * would be the address of that label. It has a different value on every line.

I don't know what you expect to be doing by measuring some current address (wherever that assert gets assembled) against both SpriteBuf1 and SpriteBuf2 at the same time. Both * in that statement must have the same value! * is just a single address value, it is not some sort of "sizeof" operator.


Have fun replacing them all again to fix the problems you've just created for yourself.

Here's a alternative:

Put another way, * is the current address wherever you happen to use it.

So, for this code:

Let's say SpriteBuf1 is at the address $1000. Then, after reserving $200 bytes, the current address is now $1200. Therefore, * is $1200 at this point, so (* - SpriteBuf1) = ($1200 - $1000) = $200. This is why your old code worked.

However, you can't just replace everywhere you used SpriteBuf1Size with * - SpriteBuf1, because *'s value changes depending on where it's used.

If you later have a line like this at address $5000:

This won't have the desired effect, because the calculation will now be $5000 - $1000 = $4000.

I don't know where you got that "* minus something is the size of something" thing from, but like Nicole showed, this is only true if you do this calculation immediately after "something" is defined. Do this anywhere else you'll not get the size of "something".

He got it from me, where I misread *16 as -16, which he promptly noticed, which just makes (his) misunderstanding even more confusing.

I just figured I'd point out to Espozo that this is not wrong, it's a valid way to get the size of something that isn't a struct, but only if you do it right after the thing is defined. Just in case this wasn't clear in the place where he read about this.

Still, I wouldn't use this to get the size of a simple array... I would probably use a constant to hold the size, kinda like rainwarrior suggested. I use PC calculations for more complicated scenarios though, such as a bunch of variables I need 2 versions of (related to raster effects): the first block is declared normally, and then I get its size to reserve space for the second block. I also use the size as an index when I need to access the second block.

The only time I seem to use * in my code is with asserts.

Most often I use it to verify that I didn't make a mistake when creating a table (same as the "sizeof" idiom):


Sometimes I use it to verify code page alignment when specific timing is needed:


Note that * is just a way of creating a temporary label for the current line, i.e. you can do the same stuff with a regular label: