Compile Time Error Checking?
 

I am looking a way to do error checking on a string at compile time,
and if the string isn't the correct length have then have the compiler
throw an error.

I am working an embedded software that will require individual builds
for each device so that the device serial number is contained in the
program memory. To do this, the C application must be compiled with
the serial number assigned to a variable within the source code file.
I would like to provide compile time error checking within the .c file
if possible so that if the length of the string is not correct, then
the build process will fail and there is no risk of having an
executable that has a bad serial number.

Has anyone heard of this or done this sort of thing? Any advice would
be greatly appreciated.

Thanks!

Re: Compile Time Error Checking?
 

Bryan Crouse wrote:
> I am looking a way to do error checking on a string at compile time,
> and if the string isn't the correct length have then have the compiler
> throw an error.
>
> I am working an embedded software that will require individual builds
> for each device so that the device serial number is contained in the
> program memory. To do this, the C application must be compiled with
> the serial number assigned to a variable within the source code file.
> I would like to provide compile time error checking within the .c file
> if possible so that if the length of the string is not correct, then
> the build process will fail and there is no risk of having an
> executable that has a bad serial number.
>
> Has anyone heard of this or done this sort of thing? Any advice would
> be greatly appreciated.
>
> Thanks!
>

Say the serial number has 9 positions:

char SerialNumnber[] = "12345678";

Then, declare an array of 1 position like this

int m[sizeof(SerialNumber) == 9];

If sizeof(SerialNumber) != 8 the expression will yield
zero, and you can't declare an array of negative
size or zero.

--------------------------------------------

I hope it works!

Re: Compile Time Error Checking?
 

On Sep 4, 9:07 am, Bryan Crouse <crou...@ieee.org> wrote:
> I am looking a way to do error checking on a string at compile time,
> and if the string isn't the correct length have then have the compiler
> throw an error.
>
> I am working an embedded software that will require individual builds
> for each device so that the device serial number is contained in the
> program memory. To do this, the C application must be compiled with
> the serial number assigned to a variable within the source code file.
> I would like to provide compile time error checking within the .c file
> if possible so that if the length of the string is not correct, then
> the build process will fail and there is no risk of having an
> executable that has a bad serial number.
>
> Has anyone heard of this or done this sort of thing? Any advice would
> be greatly appreciated.
>
> Thanks!

Whoops... An article on compile time assertions can be found here:
http://www.ddj.com/architect/184401873

Re: Compile Time Error Checking?
 

Bryan Crouse wrote On 09/04/07 10:07,:
> I am looking a way to do error checking on a string at compile time,
> and if the string isn't the correct length have then have the compiler
> throw an error.
>
> I am working an embedded software that will require individual builds
> for each device so that the device serial number is contained in the
> program memory. To do this, the C application must be compiled with
> the serial number assigned to a variable within the source code file.
> I would like to provide compile time error checking within the .c file
> if possible so that if the length of the string is not correct, then
> the build process will fail and there is no risk of having an
> executable that has a bad serial number.
>
> Has anyone heard of this or done this sort of thing? Any advice would
> be greatly appreciated.

Here's one horrid hack:

char serial[] = "..."; /* should be 42 characters */

/* If the following line produces an error, it means
* that `serial' (above) does not have the expected
* length. Pay no attention to the text of the error
* message the compiler issues; the problem is with
* the definition of `serial'.
*/
static char fake[ (sizeof serial == 42 + 1) * 2 - 1 ];

If the serial number is indeed 42 characters long (plus one
for the trailing '\0'), fake[1] is a legal array declaration.
If the length is something other than 42, you get fake[-1] and
an error message.

It seems to me, though, that you're attacking the problem
at the wrong place. This hack can check the length and can
maybe be extended to check a few other things, but it's not
going to be easy (or maintainable) to get more thorough
validation from it. If you've got a rule like "The first
two characters are upper-case letters, followed by five
digits and three letters or by six digits and two letters,
followed by ..." then this technique will be far more trouble
than it's worth. Instead, consider arranging your build
procedure so the serial number gets validated by a program
which then runs the build using that number. (For example,
it might write the validated number to a small .c file that
then gets compiled and linked in with the rest, or it might
compile everything with a `-DSERIAL=AB1234ZX999' option, or
something of that sort.) I think you'll find this more
reliable than telling the builders "Edit the file serial.c
and then rebuild the product. Be sure no one else is trying
to build it at the same time ..."

--
Eric.Sosman@sun.com

Re: Compile Time Error Checking?
 

jacob navia wrote, On 04/09/07 15:28:
> Bryan Crouse wrote:
>> I am looking a way to do error checking on a string at compile time,
>> and if the string isn't the correct length have then have the compiler
>> throw an error.
>>
>> I am working an embedded software that will require individual builds
>> for each device so that the device serial number is contained in the
>> program memory. To do this, the C application must be compiled with
>> the serial number assigned to a variable within the source code file.
>> I would like to provide compile time error checking within the .c file
>> if possible so that if the length of the string is not correct, then
>> the build process will fail and there is no risk of having an
>> executable that has a bad serial number.
>>
>> Has anyone heard of this or done this sort of thing? Any advice would
>> be greatly appreciated.
>>
>> Thanks!
>>
>
> Say the serial number has 9 positions:
>
> char SerialNumnber[] = "12345678";
>
> Then, declare an array of 1 position like this
>
> int m[sizeof(SerialNumber) == 9];
>
> If sizeof(SerialNumber) != 8 the expression will yield
> zero, and you can't declare an array of negative
> size or zero.
>
> --------------------------------------------
>
> I hope it works!

It doesn't work and does not do what you claim. It won't error if the
string is too long, only if it is too short. A string being too long can
be just as serious an error. See Eric's post for a solution that will do
what you claimed.
--
Flash Gordon

Re: Compile Time Error Checking?
 

Flash Gordon wrote:
> jacob navia wrote, On 04/09/07 15:28:
>> Bryan Crouse wrote:
>>> I am looking a way to do error checking on a string at compile time,
>>> and if the string isn't the correct length have then have the compiler
>>> throw an error.
>>>
>>> I am working an embedded software that will require individual builds
>>> for each device so that the device serial number is contained in the
>>> program memory. To do this, the C application must be compiled with
>>> the serial number assigned to a variable within the source code file.
>>> I would like to provide compile time error checking within the .c file
>>> if possible so that if the length of the string is not correct, then
>>> the build process will fail and there is no risk of having an
>>> executable that has a bad serial number.
>>>
>>> Has anyone heard of this or done this sort of thing? Any advice would
>>> be greatly appreciated.
>>>
>>> Thanks!
>>>
>>
>> Say the serial number has 9 positions:
>>
>> char SerialNumnber[] = "12345678";
>>
>> Then, declare an array of 1 position like this
>>
>> int m[sizeof(SerialNumber) == 9];
>>
>> If sizeof(SerialNumber) != 8 the expression will yield
>> zero, and you can't declare an array of negative
>> size or zero.
>>
>> --------------------------------------------
>>
>> I hope it works!
>
> It doesn't work and does not do what you claim. It won't error if the
> string is too long, only if it is too short. A string being too long can
> be just as serious an error. See Eric's post for a solution that will do
> what you claimed.

I forgot the -1
char SerialNumber[]="123456789";

int m[(sizeof(SerialNumber) == 9)-1];

Re: Compile Time Error Checking?
 

jacob navia wrote, On 04/09/07 19:26:
> Flash Gordon wrote:
>> jacob navia wrote, On 04/09/07 15:28:
>>> Bryan Crouse wrote:
>>>> I am looking a way to do error checking on a string at compile time,
>>>> and if the string isn't the correct length have then have the compiler
>>>> throw an error.
>>>>
>>>> I am working an embedded software that will require individual builds
>>>> for each device so that the device serial number is contained in the
>>>> program memory. To do this, the C application must be compiled with
>>>> the serial number assigned to a variable within the source code file.
>>>> I would like to provide compile time error checking within the .c file
>>>> if possible so that if the length of the string is not correct, then
>>>> the build process will fail and there is no risk of having an
>>>> executable that has a bad serial number.
>>>>
>>>> Has anyone heard of this or done this sort of thing? Any advice would
>>>> be greatly appreciated.
>>>>
>>>> Thanks!
>>>>
>>>
>>> Say the serial number has 9 positions:
>>>
>>> char SerialNumnber[] = "12345678";
>>>
>>> Then, declare an array of 1 position like this
>>>
>>> int m[sizeof(SerialNumber) == 9];
>>>
>>> If sizeof(SerialNumber) != 8 the expression will yield
>>> zero, and you can't declare an array of negative
>>> size or zero.
>>>
>>> --------------------------------------------
>>>
>>> I hope it works!
>>
>> It doesn't work and does not do what you claim. It won't error if the
>> string is too long, only if it is too short. A string being too long
>> can be just as serious an error. See Eric's post for a solution that
>> will do what you claimed.
>
> I forgot the -1
> char SerialNumber[]="123456789";
>
> int m[(sizeof(SerialNumber) == 9)-1];

Actually, I misread your code and reported it as wrong for the wrong reason.
--
Flash Gordon

Re: Compile Time Error Checking?
 

Flash Gordon wrote On 09/04/07 13:53,:
> jacob navia wrote, On 04/09/07 15:28:
>
>>Bryan Crouse wrote:
>>
>>>I am looking a way to do error checking on a string at compile time,
>>>and if the string isn't the correct length have then have the compiler
>>>throw an error.
>>>
>>>I am working an embedded software that will require individual builds
>>>for each device so that the device serial number is contained in the
>>>program memory. To do this, the C application must be compiled with
>>>the serial number assigned to a variable within the source code file.
>>>I would like to provide compile time error checking within the .c file
>>>if possible so that if the length of the string is not correct, then
>>>the build process will fail and there is no risk of having an
>>>executable that has a bad serial number.
>>>
>>>Has anyone heard of this or done this sort of thing? Any advice would
>>>be greatly appreciated.
>>>
>>>Thanks!
>>>
>>
>>Say the serial number has 9 positions:
>>
>>char SerialNumnber[] = "12345678";
>>
>>Then, declare an array of 1 position like this
>>
>>int m[sizeof(SerialNumber) == 9];
>>
>>If sizeof(SerialNumber) != 8 the expression will yield
>>zero, and you can't declare an array of negative
>>size or zero.
>>
>>--------------------------------------------
>>
>>I hope it works!
>
>
> It doesn't work and does not do what you claim. It won't error if the
> string is too long, only if it is too short. A string being too long can
> be just as serious an error. See Eric's post for a solution that will do
> what you claimed.

I see a minor typo in Jacob's solution (oscillating
between 8 and 9, or between size and length), but no more.
The idea is the same in both cases. I see no basis for
claiming that Jacob's method fails on too-long strings.

The only serious difference I see is that Jacob's
error-provoker is a [0] dimension and mine is a [-1].
Both are illegal and will produce diagnostics from a
conforming compiler. Mine also attempts to arouse the
ire of a non-conforming compiler (see the recent thread
"memcpy() where assignment would do?" for a report of
a compiler that did not complain about a [0] dimension).

Now that I think of it, there's another difference:
I made the array static to ensure that it could not be a
C99-style variable-length array. I don't use VLA's and
am not conversant with the rules, so I made sure to avoid
them just in case a zero-element VLA is in fact legal, or
is an error that wouldn't crop up until run-time.

--
Eric.Sosman@sun.com

Re: Compile Time Error Checking?
 

Eric Sosman wrote, On 04/09/07 21:51:
> Flash Gordon wrote On 09/04/07 13:53,:
>> jacob navia wrote, On 04/09/07 15:28:

<snip>

> I see a minor typo in Jacob's solution (oscillating
> between 8 and 9, or between size and length), but no more.
> The idea is the same in both cases. I see no basis for
> claiming that Jacob's method fails on too-long strings.

It's not my day. I spotted that I had misread Jacob's code when I saw
his correction and posted to that effect.
--
Flash Gordon

Re: Compile Time Error Checking?
 

On Sep 5, 8:51 am, Eric Sosman <Eric.Sos...@sun.com> wrote:
> > jacob navia wrote, On 04/09/07 15:28:
> >>int m[sizeof(SerialNumber) == 9];
>
> Now that I think of it, there's another difference:
> I made the array static to ensure that it could not be a
> C99-style variable-length array. I don't use VLA's and
> am not conversant with the rules, so I made sure to avoid
> them just in case a zero-element VLA is in fact legal, or
> is an error that wouldn't crop up until run-time.

These issues can be avoided by making the array
a typedef (this also prevents dumb compilers from
actually wasting memory for the array).