How can I generate a compilation error to prevent certain values from being passed to a function

Question

Not this: How to generate a compilation error when pointer types differ?

That is useful but I wanted to block values, not types. For example:

#include <stdio.h>
#include <conio.h>

char * num_sys_convert(int num_value,  int old_base, int targeted_base) {
    /* These are the codes. Only clever people can see it. The king would surely be pleased to see this. */
}

int main() {
    printf("%s",num_sys_convert(10011,2,10));    // this should be fine
    printf("%s",num_sys_convert(10021,2,10));    // this should generate a compile-time error
    getch();
}

I'm trying to make a header, in case of there will be mistake(s) while typing, I wanted to add a little function to help that out. Since the old base is binary, the digit 2 (or higher) should NOT exist in the decimal representation of the given number.

Is it possible in C to block certain values to go into the function as parameter at compilation time?

Okay, then let's simply simplify (ugh) the question into `how to do this in C`. — , Dec 26 '18 at 13:23
@AnttiHaapala That's just an example. :p I can't think of other examples right now. — , Dec 26 '18 at 13:24
Do **what**? To ensure that a constant argument does not have digits other than 0 or 1 in base 10 representation at compile time? Yes it can be done in C11, and it doesn't make any sense. If you mean checking an argument at compile time, then the only thing that is going to work about 100 % is to cause the erroneous condition to create a bitfield of negative length. — Antti Haapala -- Слава Україні, Dec 26 '18 at 13:26
Fine, let's change the example to converting **IT** into **hexadecimal form**. — , Dec 26 '18 at 13:27
@LaiYanHui it doesn't help any. The example is bad. You need a proper example to motivate an answer. — Antti Haapala -- Слава Україні, Dec 26 '18 at 13:29
@LaiYanHui worse. Now that cannot be done at build time with C. — Antti Haapala -- Слава Україні, Dec 26 '18 at 13:36
@AnttiHaapala What did you have in mind for the digit checking? I admit I can't figure out how you'd do that. — dbush, Dec 26 '18 at 13:37
@dbush well, a horrible terrible dreadful nested conditional expression using divisions and remainders that will then set the field width in a throwaway bitfield... — Antti Haapala -- Слава Україні, Dec 26 '18 at 13:39
@AnttiHaapala Please, you're an expert in C. (Hey, not trying to argue here.) All I want is to BLOCK away certain values to become the parameter. **`And the point of the question is mainly how to do that,`** but not how's the conversion can be done. — , Dec 26 '18 at 13:42
You cannot block values from becoming arguments to a function. You can use a *macro* to mask the actual function and it can do **some dirty tricks** with **some values** given as the macro arguments. — Antti Haapala -- Слава Україні, Dec 26 '18 at 13:44
How can this be done? Can you please answer the question by `Post Your Answer` beneath? Kinda desperate here. — , Dec 26 '18 at 13:56
Hello~ echos? Where are you? `But nobody came.` `But nobody came. (echoes through the walls)` — , Dec 26 '18 at 14:06
FYI: often the idea of a question is good but the way it is asked lead to downvotes. See how [another version of this question](https://stackoverflow.com/q/53933634/5470596) is well received by the C++ community. — YSC, Dec 26 '18 at 15:16
LOL, nice explanation StoryTeller. (That's good to know, BTW.) — , Dec 26 '18 at 15:21

dbush · Accepted Answer · 2018-12-26T14:43:21.437

This is an ugly cludge that will be specific to this function, but you can do it like this:

#define num_sys_convert(x, b1, b2) \
    ((void)(struct digits { \
        int d1:(( (x)             %10 >= (b1) ? -1 : 1)); \
        int d2:((((x) /        10)%10 >= (b1) ? -1 : 1)); \
        int d3:((((x) /       100)%10 >= (b1) ? -1 : 1)); \
        int d4:((((x) /      1000)%10 >= (b1) ? -1 : 1)); \
        int d5:((((x) /     10000)%10 >= (b1) ? -1 : 1)); \
        int d6:((((x) /    100000)%10 >= (b1) ? -1 : 1)); \
        int d7:((((x) /   1000000)%10 >= (b1) ? -1 : 1)); \
        int d8:((((x) /  10000000)%10 >= (b1) ? -1 : 1)); \
        int d9:((((x) / 100000000)%10 >= (b1) ? -1 : 1)); \
        int da:((((x) /1000000000)%10 >= (b1) ? -1 : 1)); \
    }){0}, num_sys_convert_real(x, b1, b2))


char * num_sys_convert_real(int num_value,  int old_base, int targeted_base) {
    ...
}

The real function is wrapped by a call to the above macro. This macro defines a struct with a number of bitfields, where the length of each bitfield is dependent on a specific decimal digit of the first argument. If that digit is greater than or equal to the value of the second argument (i.e. the base), the size of the bitfield is set to -1, which is invalid and produces a compliation error.

If the number does look like a valid number for the given base, the end result is that an temporary object of the given struct type is created via a compound literal and used in an expression as the left side of the comma operator, meaning its value is discarded, and the actual function call is the right side of the comma operator.

This works under the assumption that:

The first argument to the function is decimal integer literal
The second argument to the function is an integer literal
The literal has type int, i.e. no type suffix
An int is 32 bits in length

It will always fail to compile if you do this:

int value = 101;
num_sys_convert(value, 2, 10);

Or this:

int base = 2;
num_sys_convert(101, base, 10);

Because an expression used to set the size of a bitfield must be a compile time constant expressions.

Also, this would fail the check:

num_sys_convert(0x10, 2, 10);

Because the hex value 0x10 has the decimal value 16.

And this would pass the check:

num_sys_convert(0xa, 2, 10);

Because the hex value 0xa has the decimal value 10.

As this is such a cludge, don't do this!

Rather than attempting to check parameters at compile time, the proper thing to do is to validate the parameters at run time inside of the function and to return some sort of error code if the parameters are invalid.

And... of course you can skip this test with `(num_sys_convert)(911, base, 10)` and by explicitly declaring the function without the macro and... — Antti Haapala -- Слава Україні, Dec 26 '18 at 14:23
LOL, that's funny but better than nothing. (I think I'll use this if there are no more better answers/suggestions, XD.) — , Dec 26 '18 at 15:09
@LaiYanHui While this "works", the best thing to do is perform the check at run time. Trying to do something like this is asking for trouble. — dbush, Dec 26 '18 at 15:11
Roger that. Actually I had thought of doing that during run time but it would result in building a program instead of making a header so I gave this a try. #wink — , Dec 26 '18 at 15:14

How can I generate a compilation error to prevent certain values from being passed to a function

1 Answers1

Linked