IOCCC 1984/decot.c - can it be compiled in the 21st century?

Question

This fascinating piece of code was featured in the very first (1984) edition of the International Obfuscated C Code Contest:

http://www.ioccc.org/years.html#1984 (decot)

After clearing through the debris of preprocessor abuse and unused code caused by a goto and some sneaky comments, you end up with the following surviving code (please correct me if I am wrong!):

#include <stdio.h> //used to suppress warnings
#include <math.h> //used to suppress warnings
extern int fl00r; //renamed to not clash with floor from math.h - unless it's part of the trickery???
int b, k['a'] = {
    sizeof(int(*)()),
    };
struct tag {int x0,*xO;}

*main(int i, int dup, int signal) { //int added to suppress warnings
  for(signal=0;*k *= * __FILE__ *i;) {
   printf(&*"'\",=);    /*\n\\", (*((int(*)())&fl00r))(i)); //see line 3
   if(b&&k+sin(signal)/ * ((main) (b)-> xO));
  }
}

There is a single compiler error left to conquer:

decot.c: In function 'main':
decot.c:12:28: error: too few arguments to function 'main'
   12 |    if(b&&k+sin(signal)/ * ((main) (b)-> xO));
      |                            ^
decot.c:9:2: note: declared here
    9 | *main(int i, int dup, int signal) {
      |  ^~~~

I suspect that the way compilers worked back in the day meant that you could somehow call main with just 1 argument even though it was specifically defined with 3 as in this case.

Is this accurate? Am I missing something? What are the least changes necessary to enable this code to compile nowadays?

I used GCC 9.2.0 with the suggested build command in the Makefile.

Thanks in advance and apologies if I have missed something very obvious!

Answer 1

You cannot compile the original code anymore as it is. The earliest C standard GCC claims to support is C89, and the code from this contest is from before that. You did already a good job at porting it to more modern compilers. But there are more issues left than just the number of arguments of main():

• Clang and GCC both know that sin() returns a double, even if you don't #include <math.h>, and refuse to do add a double to an int * in the subexpression k+sin(signal). TCC seems to accept it though.
• The variable fl00r is declared but not defined, the linker will complain about an undefined reference to it.

Note that the original code can be compiled by TCC by just avoiding using x in combinations such as <<x (the preprocessor nowadays only substitutes complete tokens, and <<x counts as one token), and by calling main() with three arguments.

Your version of the code can be compiled by GCC by removing the #include statements, going back to using floor(), but forward declaring it as following:

floor();

To avoid complaints about sin(), use the -fno-builtin compiler flag. Then fix the issue with main() by calling it like (main) (b,b,b).

Answer 2

tl;dr; your mistake was to give an ANSI C prototype to the main function (i.e. changing i to int i, etc), which directed the compiler to check its arguments where it was called and cause that too few arguments error.

Example:

echo 'int foo(a,b){return a+b;} int main(){return foo(3);}' |
  cc -Wall -std=c89 -xc -
# K&R C function OK, no errors

echo 'int foo(int a, int b){return a+b;} int main(){return foo(3);}' |
  cc -Wall -std=c89 -xc -
...
<stdin>:1:54: error: too few arguments to function ‘foo’

---

That code should be preprocessed with a traditional C preprocessor, not with an "ANSI C" one. Using a standard preprocessor will result in some artifacts, like << = instead of <<=, * = instead of *=, etc.

cpp -traditional-cpp -P decot.c > decot1.c

After adding correct function declarations, and adding a cast --see the diff & result at the end of this answer-- you get something that compiles with a single warning in c89 (and a couple of them in c99), and, as described, prints some garbage to stdout:

$ cc -std=c89 decot1.c -lm -o decot1
decot1.c: In function ‘main’:
decot1.c:13:33: warning: function called through a non-compatible type
    (printf(&*"'\",x); /*\n\\", (*((int(*)())&floor))(i)));
                                ~^~~~~~~~~~~~~~~~~~~~
$ ./decot1
'",x);  /*
\

Which is exactly the same thing I get when compiling & running the original on V7 Unix, so it should be just right ;-)

decot1.c

double floor(double);
double sin(double);
int printf(const char*, ...);
int b,
k['a'] = {sizeof(
    int(*)())
,};
struct tag{int x0,*xO;}

*main(i, dup, signal) {
{
  for(signal=0;*k *= * "decot.c" *i;) do {
   (printf(&*"'\",x);   /*\n\\", (*((int(*)())&floor))(i)));
        goto _0;

_O: while (!(k['a'] <<= - dup)) {
        static struct tag u ={4};
  }
}


while(b = 3, i); {
k['a'] = b,i;
  _0:if(b&&k+
  (int)(sin(signal)             / *    ((main) (b)-> xO)));}}}

diff

$ diff -u decot1.c~ decot1.c
--- decot1.c~
+++ decot1.c
@@ -1,4 +1,6 @@
-extern int floor;
+double floor(double);
+double sin(double);
+int printf(const char*, ...);
 int b,
 k['a'] = {sizeof(
     int(*)())
@@ -20,4 +22,4 @@
 while(b = 3, i); {
 k['a'] = b,i;
   _0:if(b&&k+
-  sin(signal)          / *    ((main) (b)-> xO));}}}
+  (int)(sin(signal)            / *    ((main) (b)-> xO)));}}}

Answer 3

Yes it can be compiled ... but not quite as is. You also need the C pre-processor option -traditional-cpp which clang does not support. You might need -m32 (perhaps just for 32-bit systems ... on my 64-bit systems it would not compile this way) also but I'm not sure of that.

Note that even though it might appear to be gcc in macOS gcc is actually clang so it won't compile like this under macOS unless maybe you install a real gcc compiler.

The IOCCC champion (as in the one with the most winning entries) Yusuke Endoh has written about all the entries from 1984 through 2020 (originally in Japanese) (including my entries) and has provided patches and compilation tips for those that can be compiled (not all can be).

BTW we're working on getting older entries to compile on more modern systems. (No I'm not a judge but I'm working with the judges and Landon is a good friend of mine). The website I linked to is not current however but it's the 'official' one still.

As for 1984/decot: apply the patch from here and then compile as:

gcc -traditional-cpp -o decot decot.c -lm

Write-up is at: https://mame-github-io.translate.goog/ioccc-ja-spoilers/1984/decot.html?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=en-US&_x_tr_pto=wapp.

--

Example run:

$ patch < 1984-decot.patch 
patching file decot.c
$ $ gcc -traditional-cpp decot.c -lm
decot.c:6:12: warning: built-in function 'floor' declared as non-function [-Wbuiltin-declaration-mismatch]
    6 | extern int floor;
      |            ^~~~~
decot.c: In function 'main':
decot.c:13:2: warning: type of 'i' defaults to 'int' [-Wimplicit-int]
   13 | *main(i, dup, signal) {
      |  ^~~~
decot.c:13:2: warning: type of 'dup' defaults to 'int' [-Wimplicit-int]
decot.c:13:2: warning: type of 'signal' defaults to 'int' [-Wimplicit-int]
decot.c:16:5: warning: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
   16 |    (printf(&*"'\",x);   /*\n\\", (*((double(tag,u)(*)())&floor))(i)));
      |     ^~~~~~
decot.c:1:1: note: include '<stdio.h>' or provide a declaration of 'printf'
  +++ |+#include <stdio.h>
    1 | #define x =
decot.c:16:5: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
   16 |    (printf(&*"'\",x);   /*\n\\", (*((double(tag,u)(*)())&floor))(i)));
      |     ^~~~~~
decot.c:16:5: note: include '<stdio.h>' or provide a declaration of 'printf'
decot.c:27:12: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
   27 |   _0:if(b&&(int)k+
      |            ^
decot.c:28:3: warning: implicit declaration of function 'sin' [-Wimplicit-function-declaration]
   28 |   sin(signal)           / *    ((main) (b)-> xO));/*}
      |   ^~~
decot.c:1:1: note: include '<math.h>' or provide a declaration of 'sin'
  +++ |+#include <math.h>
    1 | #define x =
decot.c:28:3: warning: incompatible implicit declaration of built-in function 'sin' [-Wbuiltin-declaration-mismatch]
   28 |   sin(signal)           / *    ((main) (b)-> xO));/*}
      |   ^~~
decot.c:28:3: note: include '<math.h>' or provide a declaration of 'sin'
$ ./a.out 
'",x);  /*
\$

Answer 4

As I am working with the judges on fixing entries etc. I have fixed a lot of entries for modern day. I just fixed this one. It's quite simple actually. The macros are problematic but you handled that well. I'll give some hints later.

The fixed version in its entirety, requiring no special compile flags (except for some systems -lm), looks like this:

int b,
k['a'] = {sizeof(
    int(*)())
,};
struct tag{int x0,*xO;};

int dup, signal;
*main(int i) {
{
  for(signal=0;*k *= * __FILE__ *i;) do {
   (printf(&*"'\",x);   /*\n\\", (*((int(*)())&floor))(i)));
        goto _0;

_O: while (!(k['a'] <<= - dup)) {       /*/*\*/
        static struct tag u = {4};
  }
}


while(b = 3, i); {
k['a'] = b,i;
  _0:if(b&&(int)k+
sin(signal)              / *    ((main) (((struct tag *)b)-> xO)));/*}
  ;      
}         
         
*/}}}   

Well you might need to add to the compiler -include stdio.h -include math.h or else add those includes in the code itself but that's it.

That's all it takes.

Compiling

We could disable more warnings as you'll get more most likely but different compilers have different warnings. These are compatible with both clang and gcc:

cc -std=gnu90 -Wall -Wextra -Wno-array-bounds -Wno-error -Wno-implicit-function-declaration -Wno-keyword-macro -Wno-main-return-type -Wno-missing-field-initializers -Wno-unused-value -Wno-unused-variable   -include stdio.h -include math.h -O3 decot.c -o decot -lm

Running it

$ ./decot 
'",x);  /*
\

Tips

• You don't want to rename floor. Just remove that extern int floor;.
• Change main() prototype to only take one arg - the int. This is non standard but it works with both clang and gcc.
• You might find you need to cast b for the dereferencing in the call to main() as I did above.
• You did well on the macro replacements.
• About main() only having one arg. What happened to signal and dup? Well in the older days they would have defaulted to int so they're now global variables in the code. But why? Well try changing main() about and see what problem you encounter! In fact you already did. Fixing that will cause the problem that the cast I mentioned solves.

That's really all there is to it.

You did well!