P2Q>aN2\nP2Hbdd!.Xop.\
fssps!.Xop.jnqmjdju.gvodujpo.efdmbsbujpo!.Xop.jnqmjdju.jou!.jodmvef!tuejp/i!\
b/d";
```
and it now is `system(q-87);`.
It is hoped that this is the last time the string has to be updated to work with
all versions of `clang`, but if not the above is how it works.
With these changes in place it will compile and work with both `gcc` and `clang` and
the C code generated will use `fgets(3)`, not `gets(3)`, therefore removing the
annoying warnings. Note that the array passed to `fgets(3)` is an `int` but that
was the same for `gets()` and is not necessary to update to a `char[]`. Thus you
might still get some warnings there.
The key to the string is that it rotates the character by `+1`. This was not
immediately clear until reading the author's remarks so there was an alt version
that was something of a kludge, running `make a` instead, but after the proper
fix was implemented the alternate code was removed.
Cody also fixed a typo in `LANDER.BAS` and made it so that if a file could not be
opened for reading or a file could not be opened for writing it would not crash.
The definition of whether that should be a bug to fix or a feature to not fix
was pondered and changed numerous times and ultimately that problem with this
entry was fixed. It has not been done in all.
Jump to: [top](#)
## Winning entry: [1991/fine](1991/fine/index.html)
### Winning entry source code: [fine.c](%%REPO_URL%%/1991/fine/fine.c)
[Cody](#cody) made it look much more like the original entry even after the fix
for `clang` (made by the judges) that increased the count in characters from 80 to
106, getting it back down to just 85 (and later back down to the original 80,
see below).
This was done by redefining `main` at the compiler line so that it looks like
the original where one didn't have to worry about the type of args of `main()`
(when there were fewer restrictions), and also by removing a cast that was
not strictly necessary (this created a new warning: `ordered comparison
between pointer and integer ('char **' and 'int')` but it's no longer there, as
described below).
That was `fine` as well but Cody decided to drop it back down to its original 80
characters which also resolved the warning described above. This was by more clever use of
the `Makefile` which now has a `-DB=(int)b` so that `B` can be used in place where
`(int)b` used to be necessary.
Cody also added the [try.sh](%%REPO_URL%%/1991/fine/try.sh) script which feeds the program
some fun input for fun but mostly different output. He added a great string from
Brian Westley and Cody also added several of his own (can you figure out exactly
which ones? :-) )
Jump to: [top](#)
## Winning entry: [1991/rince](1991/rince/index.html)
### Winning entry source code: [rince.c](%%REPO_URL%%/1991/rince/rince.c)
[Cody](#cody) fixed it so that the messages that show if you won or lost will be seen
after the end of the game. The reason it did not work before is curses was ended
at the end of the program which clears the screen. To make it look most like the
original entry Cody left the message before ending curses in and printed another
message of the same kind after `endwin()` was called with the exception that he
added a newline at the end of the screen to be more user friendly.
Cody also added [two alt versions](1991/rince/index.html#alternate-code), one to
remove the maximum number of moves you may make and another to let you configure
the maximum number of moves, even if that is making it harder to win. Naturally
the above fix was applied to these versions too.
The file `map-key.jpg` was added to help those with smaller screens as
unfortunately the formatting of the key to the map was not easy to change in a
way without ruining how it looks (beyond making it one column only).
Jump to: [top](#)
## Winning entry: [1991/westley](1991/westley/index.html)
### Winning entry source code: [westley.c](%%REPO_URL%%/1991/westley/westley.c)
[Cody](#cody) fixed a segfault in this program which prevented it from working. The
problem was that the read-only `char` array `char *z[]` was being written to. The
fix was to change it to `char z[][100]` in two spots (see if you can determine
why two places, not one!). Why 100 when the longest string is < 100? Because a
shorter value caused strange output and it's easier to just choose a larger
value that works without having to find the correct value.
Cody also fixed the `ttt.sh` script that prevented the game from working and he
also improved it so that warnings/errors/about to compile messages are not shown
unless the `-e` option is used. This is because the errors being shown kind of
ruins the experience. Finally he made it pass
[ShellCheck](https://www.shellcheck.net).
Cody also added the [alt version](1991/westley/index.html#alternate-code) which
is based on the author's remarks, a version that supposedly (:-) ) always wins.
Cody also fixed the make clobber rule where a file was left lying about when it
should have been removed.
Jump to: [top](#)
# [1992 - The 9th IOCCC](1992/index.html)
Jump to: [top](#)
## Winning entry: [1992/adrian](1992/adrian/index.html)
### Winning entry source code: [adrian.c](%%REPO_URL%%/1992/adrian/adrian.c)
[Cody](#cody) fixed the code so that it will try opening the file the code was compiled
from (`__FILE__`), not `adgrep.c`, as the latter does not exist: `adgrep` is
simply a link to `adrian` as `adgrep` is what the program was submitted as but
the entry's winning source file is `adrian.c`.
Not fixing the above problem would have also caused the program to crash if no
arg was specified as the file doesn't exist. In making the above fix, at first
the change to check for a `NULL` file was added. Then it was noticed that the
problem is that `adgrep.c` was an incorrect reference that never existed and it
was never fixed in any of the files, not the code or the documentation, and thus
was entirely incorrect code. A fun fact is that one can do:
```
W= fopen(wc>= 2 ? V[1] : __FILE__,"rt");if(!W)exit(1);
```
but one _CANNOT_ do:
```
W= fopen(wc>= 2 ? V[1] : __FILE__,"rt");if(!W)exit(1);
if (W==NULL)exit(1);
```
because `adwc.c` will be empty! The difference is it is on a newline, the check.
This is an example of how a simple change in code can break it and this is also
true of another change as further below.
Cody also restored a slightly more obscure line of code that had been changed:
```
- putc("}|uutsrq`_^bji`[Zkediml[PO]a_M__]ISOYIRGTNR"[i]+i-9,stderr);
+ putc(i["}|uutsrq`_^bji`[Zkediml[PO]a_M__]ISOYIRGTNR"]+i-9,stderr);
```
though it's questionable how much more (if at all) obscure that is :-)
Cody also changed the location that it used `gets()` to be `fgets(3)`.
See the
FAQ on "[gets and fgets](faq.html#gets)"
for general information about to why this was done.
This was complicated because of how the other source files are generated (as
above); simply changing the code could cause invalid output in the program which
made other files fail to compile (for this example specifically, see below).
One might think that simply changing the `gets(3)` to `fgets(3)` (with `stdin`)
would work but it did not because `fgets(3)` stores the newline and `gets(3)` does
not. That is well known but this code was relying on not having this newline in
a different way (see also above).
With `fgets(3)` the code `if(A(Y)) puts(Y);` ended up printing an extra line
which made the generation of some files (like `adhead.c`) fail to compile. Why?
There was a blank line after a `\` at the end of the first line of a _macro
definition_! Thus the code now first trims off the last character of the buffer
read to get the same correct functionality but in a safe and non obnoxious way.
In this case the macro for `gets` could not be changed to have the macro do the
removal of the extra line (as in with a comma operator or a `&&`) as this, as
might be expected from the above, caused compilation errors with another
generated file (`adwc.c`)! Thus after the `gets(3)` call in the line that looks
like:
```
while( gets(Y) ){ Y[strlen(Y)-1]='\0'; if(A(Y)) puts(Y); }
```
one must keep the `Y[strlen(Y)-1]='\0';` part and keep it there.
These fixes are complex changes due to the way the program and `Makefile` generate
the additional tools.
Cody finally added the [try.sh](%%REPO_URL%%/1992/adrian/try.sh) script that shows the entry
and some of the tools this entry generates. Unlike other scripts, it does not
clear the screen after compilation so that one can see how the other files are
generated.
Jump to: [top](#)
## Winning entry: [1992/albert](1992/albert/index.html)
### Winning entry source code: [albert.c](%%REPO_URL%%/1992/albert/albert.c)
[Cody](#cody) fixed this to compile with modern systems. Note that in 1996 a bug fix was
applied to the code, provided as the alternate code as that version is not obfuscated.
Thus Cody's fix applies to the original entry. The problems were that `malloc.h`
is not the correct header file now (at least in some systems) and a non-void
(implicit `int`) function returning without a value. That function was changed to
return `void`.
Cody also added the [try.sh](%%REPO_URL%%/1992/albert/try.sh) and
[try.alt.sh](%%REPO_URL%%/1992/albert/try.alt.sh) scripts that correspond to the entry and
the alternate code.
Even so, check [1992/albert in bugs.html](bugs.html#1992_albert).
Jump to: [top](#)
## Winning entry: [1992/ant](1992/ant/index.html)
### Winning entry source code: [ant.c](%%REPO_URL%%/1992/ant/ant.c)
[Cody](#cody) fixed the `Makefile` so that the program will actually work with it (or at
least the rule to clobber files and link `am` to `ant`). The issue was that the
variables in the `Makefile` could not be evaluated in the same way as it's not as
feature-rich as other implementations of `make(1)`. Thus the use of `${RM}` and
`${CP}` were in the respective rules changed to `rm` and `cp`, for two examples.
A new rule had to be added as well. The variable situation might be because they
are obtained from the root variable `Makefile` `var.mk` via `include` which the
program might not support (this has not been tested, however) and also because
it appears that the syntax for this program is to use `$()` rather than `${}`.
Cody also fixed another problem, unrelated, in the `Makefile` with the `.PHONY`
rule where a line was not ended with a `\` but should have been.
The author stated that in some systems like DOS with Turbo C, it might be
necessary to include `time.h` so Cody did this as well as this exists in other
systems too.
Cody also added the [try.sh](%%REPO_URL%%/1992/ant/try.sh) script.
The author, [Anthony C Howe](authors.html#Anthony_C_Howe), provided an
[unobfuscated version](%%REPO_URL%%/1992/ant/ant.alt.c) that Cody added in, with
thanks to Anthony! For this version,
[try.alt.sh](%%REPO_URL%%/1992/ant/try.alt.sh) was added and an alternate test
Makefile (along the lines of the author's provided test Makefile) was added,
updated to use `ant.alt`.
Jump to: [top](#)
## Winning entry: [1992/buzzard.1](1992/buzzard.1/index.html)
### Winning entry source code: [buzzard.1.c](%%REPO_URL%%/1992/buzzard.1/buzzard.1.c)
[Cody](#cody) added a check for the right number of args, exiting 1 if not enough (2)
used. This was not originally done but at a time it was changed to be considered
a bug so it was fixed at that point as it only took a few seconds and had to be
verified that it was consistent with the [bugs.html](bugs.html) file.
He also added the [try.sh](%%REPO_URL%%/1992/buzzard.1/try.sh) script to try out some
commands that we suggested and some additional ones that he provide for some fun.
Jump to: [top](#)
## Winning entry: [1992/buzzard.2](1992/buzzard.2/index.html)
### Winning entry source code: [buzzard.2.c](%%REPO_URL%%/1992/buzzard.2/buzzard.2.c)
[Cody](#cody) fixed the alternate code to compile. The problem was it assumed that
`exit(3)` returns a value, not `void`. This was fixed with a `,0`.
Cody also added the [try.sh](%%REPO_URL%%/1992/buzzard.2/try.sh) and
[try.alt.sh](%%REPO_URL%%/1992/buzzard.2/try.alt.sh) scripts that correspond to the entry
and its alternate code.
Jump to: [top](#)
## Winning entry: [1992/gson](1992/gson/index.html)
### Winning entry source code: [gson.c](%%REPO_URL%%/1992/gson/gson.c)
[Cody](#cody) fixed a crash that prevented this entry from working in some cases in some
systems (like macOS) by disabling the optimiser in the Makefile.
Cody also added the [try.sh](%%REPO_URL%%/1992/gson/try.sh) script.
Cody also added the [mkdict.sh](%%REPO_URL%%/1992/gson/mkdict.sh) script that the author
included in their remarks. See the index.html for its purpose. It was NOT fixed
for [ShellCheck](https://www.shellcheck.net)
because the author deliberately obfuscated it so **PLEASE _DO NOT_ FIX THIS OR
MODERNISE IT**.
Jump to: [top](#)
## Winning entry: [1992/imc](1992/imc/index.html)
### Winning entry source code: [imc.c](%%REPO_URL%%/1992/imc/imc.c)
[Cody](#cody) provided the [try.sh](%%REPO_URL%%/1992/imc/try.sh) script.
The original code, [imc.orig.c](%%REPO_URL%%/1992/imc/imc.orig.c), assumed that `exit(3)`
returned a value but this will cause problems where `exit(3)` returns `void`. The
source code was modified to avoid this problem but like Cody did with other fixes
he made this more like the original by redefining `exit` to use the comma
operator so that it could be used in binary expressions.
Jump to: [top](#)
## Winning entry: [1992/kivinen](1992/kivinen/index.html)
### Winning entry source code: [kivinen.c](%%REPO_URL%%/1992/kivinen/kivinen.c)
It was observed that on modern systems this goes much too quick. [Yusuke](#yusuke) created
a patch that calls `usleep(3)` but [Cody](#cody) thought the value was too slow so he
made it a macro in the `Makefile` `Z` (which can be redefined with `make
SLEEP=...`), defaulting at 15000. This was made an [alternate
version](1992/kivinen/index.html#alternate-code) and it is recommended one use
the alternate version first. See the index.html file to see how to reconfigure it.
Cody also made the fixed version (the code relied on `exit(3)` returning to use
in binary expressions) (and alternate code from it) more like the original by renaming
the `ext` macro to be `exit` which uses the comma operator. He made it so the
line lengths match the original code, at least as best as possible (if not
perfectly), including start and end columns, often (if not all) with the same
start and end character.
Cody made `main()` have two args, not one, as some versions of `clang` have a
defect with the number of args to `main()` though when it comes to 1 arg it is
only in an error message if say 4 args are used. This is out of an abundance of
caution as it's quite possible that `clang` or the ANSI C committee end up further
changing this. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Yusuke also noted that there is a bug in the program where right after starting
it moves towards the right but if you click the mouse it goes back. See
[1992/kivinen in bugs.html](bugs.html#1992_kivinen) for more details.
Jump to: [top](#)
## Winning entry: [1992/lush](1992/lush/index.html)
### Winning entry source code: [lush.c](%%REPO_URL%%/1992/lush/lush.c)
[Yusuke](#yusuke) supplied a patch which makes this work with `gcc`. Due to how
it works (see [Judges' remarks in the index.html
file](1992/lush/index.html#judges-remarks)) this will not work with `clang`.
[Cody](#cody) also provided the [lush.sh](%%REPO_URL%%/1992/lush/lush.sh) script to
demonstrate it as using make was problematic.
Cody made it use `fgets()` instead of `gets()`. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
**NOTE**: this entry cannot work with `clang` due to different compiler messages (it
will compile fine but it won't work). See [1992/lush in
bugs.html](bugs.html#1992_lush) for details.
Jump to: [top](#)
## Winning entry: [1992/marangon](1992/marangon/index.html)
### Winning entry source code: [marangon.c](%%REPO_URL%%/1992/marangon/marangon.c)
[Cody](#cody) made this more portable by changing the `void main()` to be `int main()`.
Jump to: [top](#)
## Winning entry: [1992/nathan](1992/nathan/index.html)
### Winning entry source code: [nathan.c](%%REPO_URL%%/1992/nathan/nathan.c)
[Cody](#cody) added the original file back as it was deemed that the export
restrictions should no longer be a cause of concern for this entry. An entry
that referred to this previous code was updated and the originally published
code is now also in [nathan.alt.c](%%REPO_URL%%/1992/nathan/nathan.alt.c). The astute
viewer would note that it has the same typos as the originally published code.
Cody cynically noted that if he goes quiet, for instance if he no longer
participates in the IOCCC, that it must be our fault! :-)
Cody also added the [try.sh](%%REPO_URL%%/1992/nathan/try.sh) script that runs a
few commands that we suggested as well as one he provided.
Jump to: [top](#)
## Winning entry: [1992/vern](1992/vern/index.html)
### Winning entry source code: [vern.c](%%REPO_URL%%/1992/vern/vern.c)
[Cody](#cody) fixed an infinite loop if one were to input numbers < `0` or > `077`. The
problem was that it tried to use `scanf(3)` with the format specifier `"%o %o"` in a
loop, reading again if `scanf(3)` did not return 2 (that was not a problem in
that `scanf(2)` will not return until the number of specifiers have been
processed or some error occurs) or a function it called returned non-zero.
Instead the fix involves the `scanf(3)` specifiers being `"%4s %4s"` on two
new char arrays (always cleared in the beginning of the loop) and then using
`strtol(3)` with a base of `8` (as it's octal), checking for `< 0 || > 077` on
both numbers (using `"%o %o"` does not solve the problem).
This was deemed a problem to fix as the Judges' remarks hinted that this was how
it used to be.
Jump to: [top](#)
## Winning entry: [1992/westley](1992/westley/index.html)
### Winning entry source code: [westley.c](%%REPO_URL%%/1992/westley/westley.c)
[Cody](#cody) fixed this to work for `clang` by changing the third and fourth arg of
`main()` to be `char **` inside `main()`; `clang` requires args 2 - 4 to be `char
**` and some versions do not even allow a fourth arg.
He also added the alternate version that the author gave in the remarks that is
specifically for the USA rather than the world. This had to be fixed for `clang`
as well to make the args of `main()` be the correct type and by moving the body
of main() to another function, `pain()`, which does the work since not all
versions of `clang` support four args to `main()`.
Cody also removed the restriction that one has to have a terminal that wraps at
80 columns so that as long as the terminal's columns (try `echo $COLUMNS`) is >=
80 it should work. As most people have wider terminals than back in 1992 this
should help make it much easier to use. Note that if the number of columns is <
80 it will not work right. The way this was done is that every 80 iterations in
the final loop it prints another newline. This fix has another bonus in that
resizing the terminal after running it should not mess up the display either,
unless of course it becomes too small.
Cody added the scripts [whereami.sh](%%REPO_URL%%/1992/westley/whereami.sh) and
[whereami.alt.sh](%%REPO_URL%%/1992/westley/whereami.alt.sh) which correspond to the entry and
the alternate code but first check that the number of columns is at least 80 and if
not it is an error.
Cody added the [try.sh](%%REPO_URL%%/1992/westley/try.sh) script that shows the different
cities that the author recommended one try as well as the one recommended by the
judges (approximate judging location), labelling each city and printing a
newline before the next city. The try.sh script uses the `whereami.sh` and
`whereami.alt.sh` scripts, as long as they're executable (if they're not it
first tries to make it executable and if it fails to do so it just uses
`westley` or `westley.alt`. The scripts can be deceived by `COLUMNS=80 ./try.sh`
(or `COLUMNS=80 ./whereami.sh` etc.) but this is a feature, not a bug.
Cody also added an arg check because the program and the
[alternate version](%%REPO_URL%%/1992/westley/westley.alt.c) might have crashed or
[nuked](https://en.wikipedia.org/wiki/Nuclear_weapon) the [entire
world](https://en.wikipedia.org/wiki/Earth) or just the
[USA](https://en.wikipedia.org/wiki/United_States), respectively, without enough
args (2). And not that we need the help or anything for this :-) but we
encourage you to try the original without two args :-)
Jump to: [top](#)
# [1993 - The 10th IOCCC](1993/index.html)
Jump to: [top](#)
## Winning entry: [1993/ant](1993/ant/index.html)
### Winning entry source code: [ant.c](%%REPO_URL%%/1993/ant/ant.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1993/ant/try.sh) script and a data file,
[ants.txt](1993/ant/ants.txt), full of ants for the script.
The author, [Anthony C Howe](authors.html#Anthony_C_Howe), provided an
unobfuscated version that Cody added in, with thanks to Anthony! The source code
This was put in as [ant.alt.c](%%REPO_URL%%/1991/ant/ant.alt.c). There were two
versions, one which was converted from `K&R` and worked without modification and
another which Cody had to slightly modify to get it to work in modern systems.
But since only one was needed the one that worked already was used.
Jump to: [top](#)
## Winning entry: [1993/cmills](1993/cmills/index.html)
### Winning entry source code: [cmills.c](%%REPO_URL%%/1993/cmills/cmills.c)
[Yusuke](#yusuke) suggested that with modern systems this goes too fast so he added a call
to `usleep(3)` in a patch he made. [Cody](#cody) made it configurable at compilation by
using a macro. This is in the [alternate
version](1993/cmills/cmills.alt.c) which is the recommended one to try
first.
Jump to: [top](#)
## Winning entry: [1993/dgibson](1993/dgibson/index.html)
### Winning entry source code: [dgibson.c](%%REPO_URL%%/1993/dgibson/dgibson.c)
[Cody](#cody) fixed the [dgibson.sh](%%REPO_URL%%/1993/dgibson/dgibson.sh) script to work
which assumed that `.` is in the path.
Cody also added the [try.sh](%%REPO_URL%%/1993/dgibson/try.sh) script which runs the above
mentioned script on all the data files.
Jump to: [top](#)
## Winning entry: [1993/ejb](1993/ejb/index.html)
### Winning entry source code: [ejb.c](%%REPO_URL%%/1993/ejb/ejb.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1993/ejb/try.sh) script.
Jump to: [top](#)
## Winning entry: [1993/jonth](1993/jonth/index.html)
### Winning entry source code: [jonth.c](%%REPO_URL%%/1993/jonth/jonth.c)
Both [Cody](#cody) and [Yusuke](#yusuke) fixed this so that it will work with modern systems. Yusuke
provided some fixes of the X code (it is not known at the time of writing this
what changed) and Cody fixed the C pre-processor directives
so that it would compile. It used to be that you could get away with code like:
```
G int i,j
K case
```
and expect `G;` to equate to `int i, j;` (though it's now a long) and `K` to mean
`case` but that's no longer the case so the offending lines had `#define`
prepended to them.
Jump to: [top](#)
## Winning entry: [1993/leo](1993/leo/index.html)
### Winning entry source code: [leo.c](%%REPO_URL%%/1993/leo/leo.c)
[Cody](#cody) fixed this to work with modern compilers. This involved different header
files for functions.
Jump to: [top](#)
## Winning entry: [1993/lmfjyh](1993/lmfjyh/index.html)
### Winning entry source code: [lmfjyh.c](%%REPO_URL%%/1993/lmfjyh/lmfjyh.c)
[Cody](#cody) added an [alternate
version](1993/lmfjyh/index.html#alternate-code) which does what the program did
with `gcc` < 2.3.3. See the index.html file for details and for why this was made
the alternate version, not the actual entry.
Cody also made the `Makefile` delete the very unsafe filename that is compiled (or
would be compiled if `gcc` < 2.3.3) whether or not compilation succeeds (which is
highly unlikely).
Jump to: [top](#)
## Winning entry: [1993/plummer](1993/plummer/index.html)
### Winning entry source code: [plummer.c](%%REPO_URL%%/1993/plummer/plummer.c)
[Cody](#cody) added check for two args during a time that this was considered a
bug to fix.
Cody also added an [alternate version](%%REPO_URL%%/1993/plummer/plummer.alt.c)
which uses `usleep(3)` so you can see how this entry used to look, if you're
using a more modern system. This version also checks for two args and it is the
one we recommend one try first. See the index.html files for details.
Cody also added the [try.sh](%%REPO_URL%%/1993/plummer/try.sh) and
[try.alt.sh](%%REPO_URL%%/1993/plummer/try.alt.sh) scripts that correspond to the original
entry and the alt version, both allowing one to change the args (and in the case
of the alt one allowing one to change the amount to sleep).
Jump to: [top](#)
## Winning entry: [1993/rince](1993/rince/index.html)
### Winning entry source code: [rince.c](%%REPO_URL%%/1993/rince/rince.c)
[Yusuke](#yusuke) supplied a patch to get this to work in modern systems. This fix also
applies the compatibility issue of `select(2)` described in the index.html file.
[Cody](#cody) added a call to `endwin()` to help with terminal sanity after the program
ends.
Cody provided two alternate versions to simplify slowing the game down and, for
the second one, to make movement keys (of the default game) more familiar to vi
users. The slowing down was based on our suggestion that it might be desired to
slow down but Cody did it in such a way that makes it easy to configure at
compile time. See the index.html for details.
Jump to: [top](#)
## Winning entry: [1993/schnitzi](1993/schnitzi/index.html)
### Winning entry source code: [schnitzi.c](%%REPO_URL%%/1993/schnitzi/schnitzi.c)
[Cody](#cody) made this use `fgets(3)` not `gets(3)`. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
Jump to: [top](#)
## Winning entry: [1993/vanb](1993/vanb/index.html)
### Winning entry source code: [vanb.c](%%REPO_URL%%/1993/vanb/vanb.c)
[Cody](#cody) fixed this to work with `clang`. The problem was that the third arg to main()
was not a `char **. Instead `O5()` (which was `main()` via `-DO5=main`) is now
its own function which main() calls with the right parameters.
Later Cody fixed it again to look much more like the original where only a
single line is added, that of `main()`, which calls `O5()`. This was done through
`-include stdio.h` at the compiler (in the `Makefile`) and by removing the `O3`
variable (an int) at the top of the file, instead making it a `char ** in
`main()` (`O5()` had three args) but then passing in `0` to `O5()` for the third
arg (as it was 0 at file scope already this is perfectly fine and it means
there's no need to cast it to an int in the function call though that would also
work).
Cody also added the alternate code, provided by the author, which is:
> ... a version of the program before it got formatted into the VIII, augmented
with comments showing where each state begins. N1 and N2 are notes.
but fixed to work with `clang` as well.
**NOTE**: the `N1` and `N2` are provided as notes in the index.html file describing
this code. Other code is also described there.
Cody also added the [try.sh](%%REPO_URL%%/1993/vanb/try.sh) script.
Jump to: [top](#)
# [1994 - The 11th IOCCC](1994/index.html)
Jump to: [top](#)
## Winning entry: [1994/dodsond2](1994/dodsond2/index.html)
### Winning entry source code: [1994/dodsond2](%%REPO_URL%%/1994/dodsond2/dodsond2.c)
[Cody](#cody) fixed an infinite loop that could happen when you shoot an arrow
and end up having no arrows, thus making one force quit the game. The problem
was in a condition in the outer loop it would repeatedly get input (if
`getchar()` returned `'\n'`), only if one has more than one arrow, returning
after that. But if there were 0 arrows left it did not return and so the loop
started over, doing nothing. This fix also seems to have fixed a problem where
if you shoot your last arrow it would not move you to the room you shoot into
(whereas if you had more arrows it would).
Cody added an alt version that allows one to cheat by specifying how many arrows
to start with (this does make for fun but it allowed to easily debug the above
mentioned infinite loop which hanged the program).
As in some places it would properly say that you have '1 arrow' or else, if you
have any other number of arrows (including 0), it would say 'arrows', Cody fixed
a place where it always said 'arrows'. A minor fix and not that important.
Cody also fixed the problem where one could only get the arrows back from the
robber if the robber stole as many arrows as you ever found rather than that
minus how many you have shot. In other words if you had three arrows and shot
one and found no more you could never get the arrows back from the robber
because you could never lose all three since you spent one. This bug manifested
itself in another way too: once you got the arrows back the counter was not
reset so you could only get the arrows back once even if the robber stole more.
Now the counters are reset. The way this bug was fixed is that there is now a
counter for how many you have found and how many you shot in addition to the two
that already existed, how many you had and how many were stolen.
Jump to: [top](#)
## Winning entry: [1994/horton](1994/horton/index.html)
### Winning entry source code: [1994/horton](%%REPO_URL%%/1994/horton/horton.c)
[Cody](#cody) fixed this to check that four args were specified (at a time it
was considered a bug to fix). With the use of the C pre-processor macro and
inclusion of `stdlib.h` in the `Makefile` the layout of the source is exactly the
same column width and no additional lines were added. This was done during one
of the times where this was changed to bug to fix status, for better or worse.
Cody also fixed the `Makefile` which was causing alternate code to be compiled when it
shouldn't be.
Cody also added the scripts [try.sh](%%REPO_URL%%/1994/horton/try.sh) and
[try.alt.sh](%%REPO_URL%%/1994/horton/try.alt.sh).
Finally he added the article (written by the entry's author) cited in
[login_sept92-pp28-31.pdf](1994/horton/login_sept92-pp28-31.pdf).
Jump to: [top](#)
## Winning entry: [1994/imc](1994/imc/index.html)
### Winning entry source code: [imc.c](%%REPO_URL%%/1994/imc/imc.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1994/imc/try.sh) script.
Cody also added inclusion of `unistd.h` for `getpid(2)`. While strictly speaking
this was not necessary (in multiple systems) it can sometimes be a problem and
as it was noticed it was changed (the only case this was done except in the
entries that actually did not work because of missing or incorrect prototypes).
Jump to: [top](#)
## Winning entry: [1994/ldb](1994/ldb/index.html)
### Winning entry source code: [ldb.c](%%REPO_URL%%/1994/ldb/ldb.c)
[Cody](#cody) fixed this so it would compile and work with modern compilers. The problem
was that `srand()` returns `void` but it was used in a `||` expression. Thus the
comma operator was needed.
Cody also fixed it for `clang` under Linux which objected to incompatible pointer
type (because `time(2)` takes a `time_t *` which in some systems is a `long *`
but what was being passed to it is an `int`).
Cody also changed the entry to use `fgets(3)` instead of `gets(3)`. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
This one has
a minor annoyance in that it now prints a newline after the output but this
seems like a worthy compromise for preventing the interspersed output in macOS
and at the same time it's safer and allows for parsing file with longer lines.
Fixing it it to not have the extra newline is more problematic than it's worth,
in macOS another line of output would be shown without the change anyway -
unless `2>/dev/null` - and the difference is that now it's just a blank line
rather than an annoying warning. A subtlety about this fix: if a line is greater
than 231 in length if the program chooses that line it might print the first 231
characters or it might print (up to) the next 231 characters and so on.
Cody also added the [try.sh](%%REPO_URL%%/1994/ldb/try.sh) script.
Jump to: [top](#)
## Winning entry: [1994/schnitzi](1994/schnitzi/index.html)
### Winning entry source code: [schnitzi.c](%%REPO_URL%%/1994/schnitzi/schnitzi.c)
[Cody](#cody) added two alt versions, [one which uses
fgets_()](%%REPO_URL%%/1994/schnitzi/schnitzi.alt.c) but when fed its own source code cannot
generate code that compile and another [one with a bigger buffer
size](%%REPO_URL%%/1994/schnitzi/schnitzi.alt2.c) which, when fed its own source code, will
generate compilable code but not with the same buffer size but rather the
original buffer size. Cody explains this at [1994/schnitzi in
bugs.html](bugs.html#1994-schnitzi). See also the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
The purpose for these versions it both demonstrate how the magic works behind it
and to help others, should they wish, get the code to work with `fgets(3)`, with
or without an increase in buffer size. Note that without this feeding longer
files, say the index.html file, will crash the program. See [1994/schnitzi in
bugs.html](bugs.html#1994_schnitzi) where Cody also explains the magic for more
details. Later on, if nobody takes up the task, Cody might resume it, but for
now there is more important work to do so that the next contest can run.
Cody also added the [try.sh](%%REPO_URL%%/1994/schnitzi/try.sh) and
[try.alt.sh](%%REPO_URL%%/1994/schnitzi/try.alt.sh) scripts.
Jump to: [top](#)
## Winning entry: [1994/shapiro](1994/shapiro/index.html)
### Winning entry source code: [shapiro.c](%%REPO_URL%%/1994/shapiro/shapiro.c)
[Cody](#cody) fixed a bug on systems where `EOF != -1`. The problem is that `getc()` and
the related functions do not return `-1` on EOF or error but rather `EOF`.
However `EOF` is not required to be `-1` but merely an int < 0 and this program
assumed that `getc()` will return `-1` on EOF or error, not `EOF`. On systems
where `EOF != -1` it could result in an infinite loop.
For an interesting problem that occurred here and what was done to solve it,
check [1994/shapiro in bugs.html](bugs.html#1994_shapiro).
Cody also provided the missing
[shapiro.alt.c](%%REPO_URL%%/1994/shapiro/shapiro.alt.c) file, found by Leo.
Thanks Leo!
Jump to: [top](#)
## Winning entry: [1994/smr](1994/smr/index.html)
### Winning entry source code: [smr.c](%%REPO_URL%%/1994/smr/smr.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1994/smr/try.sh) script.
Jump to: [top](#)
## Winning entry: [1994/tvr](1994/tvr/index.html)
### Winning entry source code: [1994/tvr](%%REPO_URL%%/1994/tvr/tvr.c)
[Cody](#cody) added the try scripts, four total, colour and black and white
pairs for the original entry and the alternate code. These scripts are
[try.color.sh](%%REPO_URL%%/1994/tvr/try.color.sh) (color to match the author's
remarks), [try.bw.sh](%%REPO_URL%%/1994/tvr/try.bw.sh),
[try.alt.color.sh](%%REPO_URL%%/1994/tvr/try.alt.color.sh) and
[try.alt.bw.sh](%%REPO_URL%%/1994/tvr/try.alt.bw.sh), respectively. The scripts go through
each mode allowed with two sizes, 128 and 256, allowing one to quit or skip each
(given that there are a lot of invocations this seemed like a good idea).
Cody also made this use `fgets(3)` instead of `gets(3)`.
In this case the newline had
to be terminated but it was a pretty straightforward fix. `gets()` was defined
to use `fgets()` and the inclusion of `stdio.h` had to be added but to make it
more like the original entry this was done in the Makefile. The alternate code was
also changed to use `fgets(3)`. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
Jump to: [top](#)
## Winning entry: [1994/weisberg](1994/weisberg/index.html)
### Winning entry source code: [weisberg.c](%%REPO_URL%%/1994/weisberg/weisberg.c)
[Cody](#cody) changed the `Makefile` to make this program more user friendly and easier to
use with other tools as well by making the program output not a space after each
number but rather a newline.
Cody also added the scripts [try.sh](%%REPO_URL%%/1994/weisberg/try.sh) and
[primes.sh](%%REPO_URL%%/1994/weisberg/primes.sh). The `primes.sh` script is used by
`try.sh` and if both `primes(1)` and `rev(1)` are installed it will reverse the
lines of the `weisberg`, feeding it to `primes(1)`, showing those that are
primes. It only does the reversed output because the program actually prints
primes.
Jump to: [top](#)
## Winning entry: [1994/westley](1994/westley/index.html)
### Winning entry source code: [westley.c](%%REPO_URL%%/1994/westley/westley.c)
[Cody](#cody) converted the deobfuscation compiler options (provided by the author) to be
compiler commands and added a script [try.sh](%%REPO_URL%%/1994/westley/try.sh) to
automate the deobfuscation commands to make it easier to see the game in action from
start to finish.
Cody also added the [alternate version](%%REPO_URL%%/1994/westley/westley.alt.c)
that will look fine on terminals not set to 80 columns and the
[try.alt.sh](%%REPO_URL%%/1994/westley/try.alt.sh) script to automate the play
along the lines of the [try.sh](%%REPO_URL%%/1994/westley/try.sh) script. We
recommend you use this version first, whether you use the script or not.
Jump to: [top](#)
# [1995 - The 12th IOCCC](1995/index.html)
Jump to: [top](#)
## Winning entry: [1995/cdua](1995/cdua/index.html)
### Winning entry source code: [cdua.c](%%REPO_URL%%/1995/cdua/cdua.c)
[Cody](#cody) fixed this so that it would work with macOS. Once it could compile it
additionally segfaulted under macOS which he also fixed.
Cody also provided the [alternate code](1995/cdua/cdua.alt.c) for fun :-) ) (in
particular to make it easier to see the program do what it does in systems that
are too fast ... if there is such a thing anyway :-) ). See the index.html for
details on this.
Out of an abundance of caution with `clang`, Cody also added a second arg to
`main()` as some versions of `clang` whine about the number of args on top of the
type of args. In particular some versions supposedly only allow 0, 2 or 3 args.
It actually appears to allow 1 but if you specify 4 it says 0, 2 or 3 and it is
an error but it's entirely possible that they will eventually make the defect
function as the error message claims. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Jump to: [top](#)
## Winning entry: [1995/dodsond1](1995/dodsond1/index.html)
### Winning entry source code: [dodsond1.c](%%REPO_URL%%/1995/dodsond1/dodsond1.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/dodsond1/try.sh) script that uses the text file he
provided which is input we suggested one try with the entry.
Jump to: [top](#)
## Winning entry: [1995/esde](1995/esde/index.html)
### Winning entry source code: [esde.c](%%REPO_URL%%/1995/esde/esde.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/esde/try.sh) script.
Jump to: [top](#)
## Winning entry: [1995/garry](1995/garry/index.html)
### Winning entry source code: [garry.c](%%REPO_URL%%/1995/garry/garry.c)
[Cody](#cody) fixed the alternate code so that it will compile with modern compilers. The
problem was a missing `int` for the `f` variable. He felt it was even more
important that it works because the layout does indeed look to him like a rat is
dropping core :-), something that [the judges
suggested](1995/garry/index.html#alternate-code).
In this entry, because of the number of things it does (some added by Cody),
Cody moved the renamed `garry.test.sh` to
[try.sh](%%REPO_URL%%/1995/garry/try.sh) script (improved and fixed). For the
alt version he also added the [try.alt.sh](%%REPO_URL%%/1995/garry/try.alt.sh)
script to use the alt code, though the alt version is not as important as
alternate code in other entries. In order to get the paging to work right for
the `garry.data` file leading blank lines had to be added.
Jump to: [top](#)
## Winning entry: [1995/heathbar](1995/heathbar/index.html)
### Winning entry source code: [1995/heathbar](%%REPO_URL%%/1995/heathbar/heathbar.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/heathbar/try.sh) script.
Jump to: [top](#)
## Winning entry: [1995/leo](1995/leo/index.html)
### Winning entry source code: [leo.c](%%REPO_URL%%/1995/leo/leo.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/leo/try.sh) script.
At our change in how to deal with spoilers, Cody also uudecoded the spoiler
information about the secret switch, provided by the author, putting it in
[secret.html](1995/leo/secret.html).
Jump to: [top](#)
## Winning entry: [1995/makarios](1995/makarios/index.html)
### Winning entry source code: [makarios.c](%%REPO_URL%%/1995/makarios/makarios.c)
[Cody](#cody) fixed this so that it will compile with versions of `clang` that has a defect
which only allows `main()` to have 0, 2 or 3 args. This is done by a new
function (`pain()` as it's annoying that `clang` is this way :-) ) that `main()`
calls which has the four args.
Jump to: [top](#)
## Winning entry: [1995/savastio](1995/savastio/index.html)
### Winning entry source code: [savastio.c](%%REPO_URL%%/1995/savastio/savastio.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/savastio/try.sh) script.
Jump to: [top](#)
## Winning entry: [1995/schnitzi](1995/schnitzi/index.html)
### Winning entry source code: [schnitzi.c](%%REPO_URL%%/1995/schnitzi/schnitzi.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1995/schnitzi/try.sh) script.
Jump to: [top](#)
## Winning entry: [1995/vanschnitz](1995/vanschnitz/index.html)
### Winning entry source code: [vanschnitz.c](%%REPO_URL%%/1995/vanschnitz/vanschnitz.c)
[Cody](#cody) added the authors' [deobfuscation source code](%%REPO_URL%%/1995/vanschnitz/vanschnitz.alt.c)
as in 2023 we have decided that in most
cases all the code should be available for the wider audience, without having to
extract it (the exception, of course, is when the files are created by the entry or the
entry decrypts the text or something like that).
Cody also added the [try.sh](%%REPO_URL%%/1995/vanschnitz/try.sh) script.
Jump to: [top](#)
# [1996 - The 13th IOCCC](1996/index.html)
Jump to: [top](#)
## Winning entry: [1996/august](1996/august/index.html)
### Winning entry source code: [august.c](%%REPO_URL%%/1996/august/august.c)
[Cody](#cody) fixed a segfault in this program that prevented it from working right and
also fixed an infinite loop in the try commands. This infinite loop prevented it
from working with some systems or compilers which we noted a long time ago.
The problem with the infinite loop is that the file `august.oc` had to have
lines starting with `#` removed and it was not being done. After this is done
with say `sed(1)` (like `sed -i'' '/^#/d' august.oc` which has been added to
both the remarks and the `try.sh` script noted below) the code can proceed. This
problem existed in macOS.
Cody also added the [try.sh](%%REPO_URL%%/1996/august/try.sh) script that runs all the
commands that were given by the judges in the try section, with the fix above
applied.
Jump to: [top](#)
## Winning entry: [1996/dalbec](1996/dalbec/index.html)
### Winning entry source code: [dalbec.c](%%REPO_URL%%/1996/dalbec/dalbec.c)
[Cody](#cody) proposed a fix for this to compile with `clang` and Landon implemented it
after some discussion (though Cody changed the function name). The reason Cody
did not do it is because he thought it was the wrong output but as it happens
the try section below was worded a bit confusingly. He looked at [Yusuke](#yusuke)'s
analysis found
[here](https://mame-github-io.translate.goog/ioccc-ja-spoilers/1996/dalbec.html?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=en-US&_x_tr_pto=wapp)
but he missed that Yusuke added a '...' after the result which made him think
the fix was wrong.
Cody also made the recommended change of the author to make it so that each
number is printed on a line by itself rather than having a long string of
numbers on the same line.
Cody also added the [try.sh](%%REPO_URL%%/1996/dalbec/try.sh) script.
Jump to: [top](#)
## Winning entry: [1996/eldby](1996/eldby/index.html)
### Winning entry source code: [eldby.c](%%REPO_URL%%/1996/eldby/eldby.c)
[Cody](#cody) provided an [alternate version](%%REPO_URL%%/1996/eldby/eldby.alt.c) which uses
`usleep()` in between writing the output to make it easier to see what it looked
like back in 1996 with modern systems and importantly also for those who are sensitive to text
flashing by rapidly. We recommend that you try the alternate version first due to
these reasons.
Jump to: [top](#)
## Winning entry: [1996/gandalf](1996/gandalf/index.html)
### Winning entry source code: [gandalf.c](%%REPO_URL%%/1996/gandalf/gandalf.c)
[Cody](#cody) fixed this to compile and work with modern systems. As he loved the
references in the code that could not compile he just commented out as little as
possible to get this to compile.
Cody also added the rather useful [try.sh](%%REPO_URL%%/1996/gandalf/try.sh) script to
really demonstrate the different ways of running the program ends up showing
either different output or the same output that we briefly pointed out.
**BTW**: it is perilous to try the patience of
[Gandalf](https://www.glyphweb.com/arda/g/gandalf.html). Go ahead, try it! :-)
Jump to: [top](#)
## Winning entry: [1996/huffman](1996/huffman/index.html)
### Winning entry source code: [huffman.c](%%REPO_URL%%/1996/huffman/huffman.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1996/huffman/try.sh) script.
Jump to: [top](#)
## Winning entry: [1996/jonth](1996/jonth/index.html)
### Winning entry source code: [jonth.c](%%REPO_URL%%/1996/jonth/jonth.c)
[Cody](#cody) fixed this to not segfault under macOS. The problem was that the function
pointer `w`, which points to `XCreateWindow()`, did not specify the parameters of
the function in the pointer assignment.
**NOTE**: if there is no X server running this program will still crash.
Jump to: [top](#)
## Winning entry: [1996/rcm](1996/rcm/index.html)
### Winning entry source code: [rcm.c](%%REPO_URL%%/1996/rcm/rcm.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1996/rcm/try.sh) script.
Jump to: [top](#)
## Winning entry: [1996/schweikh1](1996/schweikh1/index.html)
### Winning entry source code: [schweikh1.c](%%REPO_URL%%/1996/schweikh1/schweikh1.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1996/schweikh1/try.sh) script.
The author stated that `-I/usr/include` is needed by `gcc` in Solaris because
`errno.h` has two identical extern declarations of `errno`. That leads to an
error due to the redefinition of `main` but the `-I` option makes sure the
working `/usr/include/rrno.h` is found first, which shouldn't cause any problems
on other systems (the other file is
`gcc-lib/sparc-sun-solaris2.5/2.7.2/include/errno.h`). Thus Cody also added this to
the `Makefile` for the (likely?) few who still use Solaris.
Jump to: [top](#)
## Winning entry: [1996/schweikh2](1996/schweikh2/index.html)
### Winning entry source code: [schweikh2.c](%%REPO_URL%%/1996/schweikh2/schweikh2.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1996/schweikh2/try.sh) script with
a few commands to try along with a shorter version of something the author
suggested one try (at the end of the script it prompts if you wish to run the
author's idea, with a `sleep` and `echo` in between to help one distinguish the
output better, with the warning that it is an infinite loop).
Jump to: [top](#)
## Winning entry: [1996/schweikh3](1996/schweikh3/index.html)
## Source code: [schweikh3.c](%%REPO_URL%%/1996/schweikh3/schweikh3.c)
[Cody](#cody) updated the `Makefile` so that if it fails to compile it will try the
method suggested for SunOS rather than having to update the `Makefile` manually or
running a more complicated command: now one can just run `make`.
Jump to: [top](#)
## Winning entry: [1996/westley](1996/westley/index.html)
### Winning entry source code: [westley.c](%%REPO_URL%%/1996/westley/westley.c)
[Cody](#cody) fixed a segfault in this entry as well as it displaying environmental
variables. Although the scripts showed correct output, it somewhat lessened the
usability because they segfaulted and showed (an) environmental variable,
interspersed with the output of the program. With the fix they no longer have
this problem. If `argc < 5` (`argv[4]` is referenced) it will not do anything
and it will not segfault either - this was caused by the body of the `for()` loop
which is now empty (it doesn't appear to be needed at all at least modernly).
Note that you should check the [westley.alt.c](%%REPO_URL%%/1996/westley/westley.alt.c) file
when reading the author's comments. To see how to use the original, see the
index.html file.
Cody also added the [try.sh](%%REPO_URL%%/1996/westley/try.sh) and
[try.alt.sh](%%REPO_URL%%/1996/westley/try.alt.sh) scripts to automate showing the different
clocks, both with the fixed version and the original (alt) version.
Also, to fix any potential problem with displaying in GitHub the scripts
provided by the author, Cody added '.sh' to the `clock[1-3].sh` scripts (this
was done before the displaying / downloading of files was devised but it helps
to show that they are scripts anyway).
Jump to: [top](#)
# [1998 - The 14th IOCCC](1998/index.html)
Jump to: [top](#)
## Winning entry: [1998/banks](1998/banks/index.html)
### Winning entry source code: [banks.c](%%REPO_URL%%/1998/banks/banks.c)
[Cody](#cody) improved the `Makefile` to allow for easier redefining the control
keys and time step that the author set up.
Cody also set up the `Makefile` to have an alt build (using the same code) for those
who do not have a page up or page down key and added the
[keysym.h](%%REPO_URL%%/1998/banks/keysym.h) header file as a reference for other keys one
can use if they wish to modify the controls. One can certainly do this even if
they do have page up and page down but this gives a default for those who don't
have them like with Macs. The alt build hard codes the page up and page down
alternatives because not doing so would overly complicate both builds and since
you can configure them all in both builds it shouldn't matter.
Jump to: [top](#)
## Winning entry: [1998/bas1](1998/bas1/index.html)
### Winning entry source code: [bas1.c](%%REPO_URL%%/1998/bas1/bas1.c)
[Cody](#cody), out of an abundance of caution, added a second arg to `main()` as some
versions of `clang` whine about the number of args on top of what type they are
In particular some versions claim that they only allow 0, 2 or 3 args. It
appears that they do allow 1 but for instance 4 is not allowed. However as it's
quite possible they will 'fix' this defect it would be better to have this not
be a problem at such a time. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody also added the [bas1.sh](%%REPO_URL%%/1998/bas1/bas1.sh) script to simplify running the
program.
Jump to: [top](#)
## Winning entry: [1998/bas2](1998/bas2/index.html)
### Winning entry source code: [bas2.c](%%REPO_URL%%/1998/bas2/bas2.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1998/bas2/try.sh) script which runs some default actions
as well as allowing one to pass in different file names or strings.
Jump to: [top](#)
## Winning entry: [1998/chaos](1998/chaos/index.html)
### Winning entry source code: [chaos.c](%%REPO_URL%%/1998/chaos/chaos.c)
[Cody](#cody) added a call to `endwin()` to restore terminal sanity (echo etc.) when
exiting the program (in both versions).
Cody also added the [try.sh](%%REPO_URL%%/1998/chaos/try.sh) script that runs the program on
all the data files, giving instructions on how to rotate and zoom in and out,
prior to each run.
Jump to: [top](#)
## Winning entry: [1998/df](1998/df/index.html)
### Winning entry source code: [df.c](%%REPO_URL%%/1998/df/df.c)
[Cody](#cody) changed a `int *` used for `fopen(3)` to be a `FILE *` to be more correct
and prevent any possible problems in some systems (which has happened).
Cody also made the fixed version to look more like the original version by using
the old style of `main()` args so that it reads `i,love_unix` more naturally,
and by changing the `typedef int lint` to be `typedef int _int`. See the code
for why this has to be done this way.
Cody also added the [try.sh](%%REPO_URL%%/1998/df/try.sh) script which runs the program in a
loop until one hits `q` (or `Q`) or sends intr/ctrl-c. He also proposed there's
a way to cheat very easily. Can you figure out how?
Jump to: [top](#)
## Winning entry: [1998/dlowe](1998/dlowe/index.html)
### Winning entry source code: [dlowe.c](%%REPO_URL%%/1998/dlowe/dlowe.c)
[Cody](#cody) made the program more portable by changing the void return type of `main()`
to be `int` (in both versions).
Cody added the scripts [try.sh](%%REPO_URL%%/1998/dlowe/try.sh),
[try.alt.sh](%%REPO_URL%%/1998/dlowe/try.alt.sh), [pootify.sh](%%REPO_URL%%/1998/dlowe/pootify.sh) and
[pootify.cgi.sh](%%REPO_URL%%/1998/dlowe/pootify.cgi.sh) for a fun example use of the
program, a local pootifier of web pages and a CGI pootifier. See [historical
remarks](1998/dlowe/index.html#historical-remarks) for more details on the
pootify scripts.
Jump to: [top](#)
## Winning entry: [1998/dloweneil](1998/dloweneil/index.html)
### Winning entry source code: [dloweneil.c](%%REPO_URL%%/1998/dloweneil/dloweneil.c)
[Cody](#cody) added [alternate code](%%REPO_URL%%/1998/dloweneil/dloweneil.alt.c) which has vi(m) movement
(in addition to the other keys except for dropping it's not `d` but `j` or
space) keys as well as allowing one to quit the game. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Jump to: [top](#)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/1998/dorssel/try.sh) script.
Jump to: [top](#)
## Winning entry: [1998/fanf](1998/fanf/index.html)
### Winning entry source code: [fanf.c](%%REPO_URL%%/1998/fanf/fanf.c)
[Cody](#cody) fixed this to compile. Tony Finch fixed it again to be
more like the original submission. The double preprocessing is a joke
about C and a joke about OFL so the program is less funny without it.
There were a couple of problems with the double preprocessing that
upset modern compilers:
* Recent versions of `gcc` wrap `#line` marks around the expansion
of `EOF` which broke up `#define ef E(EOF)` across multiple lines.
This can be avoided by processing `#include` in the second
preprocessor phase.
(Tony vaguely remembers some indecision about when to `#include`,
in particular whether preprocessing the headers twice would lead
to trouble. Early `#include` seemed to work and was shorter so
that was what the original submission did.)
* System headers can be sensitive to compiler options, for example
`restrict` keywords might be omitted when compiling with
`-std=gnu90`. Consistency options need to be used at all stages.
Cody also added a second arg to `main()`. Tony removed both args since
neither of them are used and it's shorter that way (though it provokes
a warning about a non-prototype function definition). See the FAQ on
"[main function args](faq.html#arg_count)" for more details.
In some versions of `clang` `-Wno-int-conversion` had to be added to the
`CSILENCE` variable of the Makefile.
Cody also added the [try.sh](%%REPO_URL%%/1998/fanf/try.sh) script to show the output of some
of the expressions that we selected.
Jump to: [top](#)
## Winning entry: [1998/schnitzi](1998/schnitzi/index.html)
### Winning entry source code: [schnitzi.c](%%REPO_URL%%/1998/schnitzi/schnitzi.c)
[Cody](#cody) fixed invalid data types which prevented this entry from working, causing a
segfault. This showed itself in two parts which required two fixes, one for
Linux and further changes for macOS. He also fixed a segfault (after printing
garbage) when the arg specified evaluated to 0. It was decided by us, the
judges, that these segfault fixes should be made because the program is so
beautiful.
Later on Cody improved the fixes by checking that the arg is a number `>0 &&
<27` as that was noted by the author as a requirement and again since it's such
a beautiful program it is worth it, especially as the larger the number the
larger the resulting program becomes. It can be gigabytes in length if it
doesn't crash. At this point since the author stated it has no `while`,
`do...while`, `for`, `if/else`, `switch`, `?:` Cody removed the if statement by
doing:
```
((V[1]&&((atoi(V[1])>0&&atoi(V[1])<27))||(exit(1),1)));
```
Cody also added the [try.sh](%%REPO_URL%%/1998/schnitzi/try.sh) script to help users try the
commands that we recommended as well as some added by him.
Jump to: [top](#)
## Winning entry: [1998/schweikh1](1998/schweikh1/index.html)
### Winning entry source code: [1998/schweikh1](%%REPO_URL%%/1998/schweikh1/schweikh1.c)
[Cody](#cody) fixed this for modern systems (it did not work at all) and added an
alternate version that works with macOS. Cody also made it ever so slightly more
portable by removing the hard-coding of `gcc`, instead hard-coding it `cc`. Doing
this not only lets it work with systems without `gcc` (though in macOS it does
exist but is actually `clang`) as `cc` always should.
Getting this entry to work was quite complicated but is also very interesting.
To see how the macOS fixes works, see the [macos.html](1998/schweikh1/macos.html)
file but do note that this includes deobfuscation information for both versions! The fixes to get
it to work at all are described next.
So what was wrong with the original?
The call to `freopen(3)` was incorrect with the second arg (the mode) being
`5+__FILE__`; it is now `"r"`. (Observe that the mode to the `fopen(3)`
call is: `43+__FILE__`. This might seem incorrect and indeed it can be changed
to `"r"` as well but this was not actually necessary so once this was noticed it
was changed back to the original.)
Another important change is that the files are only closed if the `FILE *H` is
`!= NULL`. Without this check, because it's almost certain that some files will
not exist, it would dereference a NULL pointer and very likely crash or halt and
catch fire :-), preventing the entry from working. Notice how `H` is a funny
macro defined as:
```
%:define H(x)
```
and yet the `FILE *` can be called `H`! This might or might not make sense to
you but if it doesn't can you figure out why?
Another fix is that previously the program would `return 1` if a file failed to
open but for the same reason as above, it being very likely some files will not
exist, the return was removed so that if the statement of the `if` is true the
`while` loop run, rather than having the loop by itself. It was done this way to
make it as close to the original as possible and to maintain the obfuscation as
close as possible as well.
Also crucial, and the final fixes to make it work, is that the arrays `K` and
`L` had to be increased in size. They were originally (somewhat bewildering at
first glance) defined as `K[X(*)], L[X(<<)]` but they were changed to
`K[(X(*))*4], L[4*X(<<)]` though it is no longer clear just how necessary this
might be.
As noted, a limitation of `gcc` existing was removed by Cody to make it so that
`gcc` is not required as `cc` should exist in every system with a C compiler and
as the author stated: as long as the options `-E -dM` of the compiler prints out
the macros in the form of `gcc -dM` i.e., the lines are in the form `#define
MACRO value` it will work, assuming that compiler can run, of course.
Cody also added the perl script that the author provided that they used to
compute the character count in the code according to the contest rules of 1998
in the file [charcount.pl](%%REPO_URL%%/1998/schweikh1/charcount.pl).
Jump to: [top](#)
## Winning entry: [1998/schweikh2](1998/schweikh2/index.html)
### Winning entry source code: [schweikh2.c](%%REPO_URL%%/1998/schweikh2/schweikh2.c)
[Cody](#cody) fixed the code to not trigger an internal compiler error in `gcc`:
```
:10:16: warning: type defaults to 'int' in declaration of 'zero' [-Wimplicit-int]
: In function 'main':
:12:1: warning: missing terminating " character
:12:19: internal compiler error: invalid built-in macro "__FILE__"
```
The string `"01\015"` had to be changed to `ONE(O(1,1,2,6,0,6))`. For an
interesting historical explanation and further details and fun, see the
[historical remarks](1998/schweikh2/index.html#historical-remarks) in the
index.html.
Cody also added an `int` after `register` in `main()` in case `clang` decides to
have a problem with that in the future which is not entirely out of the
question.
Cody also added the [try.sh](%%REPO_URL%%/1998/schweikh2/try.sh) script.
Jump to: [top](#)
## Winning entry: [1998/schweikh3](1998/schweikh3/index.html)
### Winning entry source code: [schweikh3.c](%%REPO_URL%%/1998/schweikh3/schweikh3.c)
[Cody](#cody) added the [alternate
code](1998/schweikh3/index.html#alternate-code) which allows one
to reconfigure the size constant in the rare case that the author wrote about
occurs. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Cody made `main()` have two args out of an abundance of caution as some versions
of `clang` say that `main()` can only have 0, 2 or 3 args. These versions accept 1
arg but it is entirely possible that they fix this so this should prevent it
from breaking if that happens. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody added the [try.sh](%%REPO_URL%%/1998/schweikh3/try.sh) script to make it easier to try
the commands that we suggested. One command was not added, that of the to use
command.
Cody also made the `Makefile` rule `all` symlink the entry to `samefile` as that
is the name of the program.
The author stated that:
> In the remote event that the input has more than `8192` files with the same
size (on systems where `sizeof (char *) == 4`, or `4096` when `sizeof (char *)
== 8`), increase the manifest constant 32767 on line 31.
... so Cody changed the constant to a macro in the `Makefile` called `SZ` so one can
more easily do this (though it indeed seems highly unlikely). See the index.html
for more details.
There actually is a web page for the tool and this was added to the author
information for the entry. It has not been added to any JSON file.
Jump to: [top](#)
## Winning entry: [1998/tomtorfs](1998/tomtorfs/index.html)
### Winning entry source code: [tomtorfs.c](%%REPO_URL%%/1998/tomtorfs/tomtorfs.c)
[Cody](#cody) fixed the assumption that `EOF` is `-1` (the author noted that it assumes
it is `-1` and it's indeed a valid concern as the standard only guarantees that
it's a value `< 0`) and that `1` is a valid code to return failure (it seems
unlikely that it wouldn't be but since the author suggested it it was changed to
`EXIT_FAILURE`). To make it so the lines end at the same columns as the original
the `EXIT_FAILURE` change was done by redefining `exit(3)` to be `exit(a) return
EXIT_FAILURE` and `1` was passed to it (`return` was used because the original
program had `return 1`).
Cody also added the [try.sh](%%REPO_URL%%/1998/tomtorfs/try.sh) script to try out a few
commands that we recommended.
Jump to: [top](#)
# [2000 - The 15th IOCCC](2000/index.html)
Jump to: [top](#)
## Winning entry: [2000/anderson](2000/anderson/index.html)
### Winning entry source code: [anderson.c](%%REPO_URL%%/2000/anderson//anderson.c)
[Cody](#cody) changed this entry to use `fgets(3)` instead of `gets(3)`.
This involved changing the `K` arg to `gets(3)` to `&K` in `fgets(3)`.
Cody also added the [try.sh](%%REPO_URL%%/2000/anderson/try.sh) script. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
Jump to: [top](#)
## Winning entry: [2000/bmeyer](2000/bmeyer/index.html)
### Winning entry source code: [bmeyer.c](%%REPO_URL%%/2000/bmeyer//bmeyer.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2000/bmeyer/try.sh) script with some improvements to the
commands we recommended like not assuming the number of columns one has in their
terminal.
Jump to: [top](#)
## Winning entry: [2000/briddlebane](2000/briddlebane/index.html)
### Winning entry source code: [briddlebane.c](%%REPO_URL%%/2000/briddlebane//briddlebane.c)
[Cody](#cody) fixed this to compile in systems that require one to explicitly link in
`libm`.
Cody also added the [try.sh](%%REPO_URL%%/2000/briddlebane/try.sh) script for those who are
feeling a bit too confident, cocky or even happy :-)
Jump to: [top](#)
## Winning entry: [2000/dhyang](2000/dhyang/index.html)
### Winning entry source code: [dhyang.c](%%REPO_URL%%/2000/dhyang//dhyang.c)
[Cody](#cody) made this more portable by changing the `void main` to `int main`.
He also added the [try.sh](%%REPO_URL%%/2000/dhyang/try.sh) script.
Jump to: [top](#)
## Winning entry: [2000/dlowe](2000/dlowe/index.html)
### Winning entry source code: [dlowe.c](%%REPO_URL%%/2000/dlowe//dlowe.c)
[Cody](#cody) fixed this to compile with more recent perl versions; the symbol that's now
`PL_na` was once `na`.
Cody also added the [try.sh](%%REPO_URL%%/2000/dlowe/try.sh) script.
[John Dalbec](#johndalbec) fixed the remaining known bugs in
[2000/dlowe](2000/dlowe/index.html) by causing the embedded Perl code in
C in order to perform system-specific tune up of the C runtime environment
necessary to run Perl interpreters. Moreover [John Dalbec](#johndalbec)
fixed a buffering problem by forcing a `flush(3)` after every write or print.
Jump to: [top](#)
## Winning entry: [2000/jarijyrki](2000/jarijyrki/index.html)
### Winning entry source code: [jarijyrki.c](%%REPO_URL%%/2000/jarijyrki//jarijyrki.c)
[Cody](#cody) made it easier to compile this in some cases by adding `X11/` to the
includes of `Xlib.h` and `keysym.h`.
Jump to: [top](#)
## Winning entry: [2000/natori](2000/natori/index.html)
### Winning entry source code: [natori.c](%%REPO_URL%%/2000/natori//natori.c)
[Cody](#cody) fixed this for modern compilers. Depending on the compiler it would either
segfault when run or not compile at all (`gcc` and `clang` respectively). The
compiler fix is due to `clang` being more strict about arg types to `main()`.
Cody also provided [alternate code](2000/natori/index.html#alternate-code) that
supports the southern hemisphere, based on the author's remarks.
Cody also provided the [try.sh](%%REPO_URL%%/2000/natori/try.sh) and
[try.alt.sh](%%REPO_URL%%/2000/natori/try.alt.sh) scripts that show the Moon phase in
artistic ways. It is recommended one try both a number of times in a row on
different days (that is run `./try.sh` several times in a row a few days apart,
until you see all the Moon phases, and run `./try.alt.sh` a few times in a row a
few days apart, until you see all the Moon phases).
Later on Cody restored the `#include`s in the source code which had been changed
by us to make it a one-liner again but this was an error as it was not a
one-liner but rather a small program. At the same point Cody made the code
itself a one-line like the code is in the original entry. Now it looks much more
like the original entry but with the two fixes.
Finally Cody fixed the `Makefile` that had the `-Wno-foo` options in the `CDEFINE`
variable which although works it is incongruent with the other Makefiles and is
more confusing (though not really).
Jump to: [top](#)
[Cody](#cody) made this more portable by changing the `void main` to `int main`.
Cody also added the [try.sh](%%REPO_URL%%/2000/primenum/try.sh) script.
Jump to: [top](#)
## Winning entry: [2000/rince](2000/rince/index.html)
### Winning entry source code: [rince.c](%%REPO_URL%%/2000/rince//rince.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2000/rince/try.sh) script.
Jump to: [top](#)
## Winning entry: [2000/robison](2000/robison/index.html)
### Winning entry source code: [robison.c](%%REPO_URL%%/2000/robison//robison.c)
[Cody](#cody) fixed an infinite loop that occurred if invalid input was entered, flooding
the screen with:
> Black position and direction: illegal
This was fixed by having the `scanf(3)` read in a string and then use `atoi(3)`
on it to assign to the `int`s, much like with [1987/lievaart](#1987_lievaart).
The strings are `char[5]` and the `%` specifier is `%4s` which is enough for the
game.
Jump to: [top](#)
## Winning entry: [2000/schneiderwent](2000/schneiderwent/index.html)
### Winning entry source code: [schneiderwent.c](%%REPO_URL%%/2000/schneiderwent//schneiderwent.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2000/schneiderwent/try.sh) script.
Jump to: [top](#)
## Winning entry: [2000/thadgavin](2000/thadgavin/index.html)
### Winning entry source code: [thadgavin.c](%%REPO_URL%%/2000/thadgavin//thadgavin.c)
[Cody](#cody) fixed the code and added an appropriate make rule so that the
[SDL](https://www.libsdl.org) version works independent from the curses version
(using the same code). See below for an interesting problem that occurred that
had to be resolved for SDL1.
Cody also added [alternate code](%%REPO_URL%%/2000/thadgavin/thadgavin.alt.c) to allow
one to slow down the code to get a better idea of what the program looked like
back in 2000, with modern systems. This code also, at least for the curses mode, allows
one to quit at any time by pressing 'q'. Note that this alternate version only
will impact the curses and the SDL versions as Cody does not have a DOS system
to test the other version in.
Due to a terrible design choice of the SDL1 developers something had to be
changed. As was noted in the log at the time:
> The SDL version did not work for a number of reasons. First of all the
> code requires that SDL is defined. Second the path[sic] wrong header file was
> included. Third the SDL1 developers thought it would be a great idea
> (but obviously it's a terrible idea) to redefine main() (!!) so that any
> program that uses SDL1 has to have the same args as their definition.
> This program had 'main()' so the error message was:
```
thadgavin.c:60:1: error: conflicting types for 'SDL_main'
main()
^
/opt/local/include/SDL/SDL_main.h:34:14: note: expanded from macro 'main'
#define main SDL_main
^
/opt/local/include/SDL/SDL_main.h:35:12: note: previous declaration is here
extern int SDL_main(int argc, char *argv[]);
^
1 warning and 1 error generated.
make: *** [thadgavin_sdl] Error 1
```
>
> Thus `main()` was changed to `int main(int argc, char **argv)`.
Jump to: [top](#)
## Winning entry: [2000/tomx](2000/tomx/index.html)
### Winning entry source code: [tomx.c](%%REPO_URL%%/2000/tomx//tomx.c)
[Cody](#cody) added the [alternate code](2000/tomx/index.html#alternate-code) based on the
author's remarks with a fix for modern systems, and he also added the two
scripts, [try.sh](%%REPO_URL%%/2000/tomx/try.sh) and [try.alt.sh](%%REPO_URL%%/2000/tomx/try.alt.sh) for
the main code and the alternate code respectively.
And although the scripts do `chmod +x` on the source code (see the index.html for
details) the source code is now executable by default.
Jump to: [top](#)
# [2001 - The 16th IOCCC](2001/index.html)
Jump to: [top](#)
## Winning entry: [2001/anonymous](2001/anonymous/index.html)
### Winning entry source code: [anonymous.c](%%REPO_URL%%/2001/anonymous//anonymous.c)
[Cody](#cody) fixed both the supplementary program and the program itself (both of which
segfaulted and once that was fixed only the binary was modified; it was not run
but according to the author's remarks it should be executed). He managed to do
this with Linux but it will not work with any system that does not allow one to
compile 32-bit ELF binaries. See [2001/anonymous in bugs.html](bugs.html#2001_anonymous) for
why this is; _this is **not** a bug, it's a feature_ inherent in what it does!
The following had to be done to fix this:
- `#include ` for `mmap()` and `munmap()`.
- have `main()` call another function which is no longer a recursive function;
this prevented `main()` from entering an infinite recursive loop.
Without these it would crash and prevent modification of the 32-bit
[ELF](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format) (not elf :-) )
binary. But again see [2001/anonymous in bugs.html](bugs.html#2001_anonymous)
for this.
These also had to be done:
- when `open()`ing the file the file descriptor had to be saved so it could be
closed prior to executing the program. This is the `f` variable which an `int`.
- `munmap()` also had to be called prior to executing the program. This involved
a new `off_t N` which was added in the `mmap()` call which was then used in
the `munmap()` call.
Without those changes the program was not executed after modification which it
was supposed to do; instead it reported text file busy error.
Notice that the location of `munmap()` and `close()` followed by `execv()` _does
matter_!
To get this to compile with `clang`, `main()` had to change from:
```
main (char *ck, char **k)
```
to:
```
main (int cka, char **k) { char *ck = (char *)cka; /* ... */ }
```
The following was also done to be more portable, in case the constants
`PROT_READ` and/or `PROT_WRITE` are not standardised or some platform does not
follow it: change `3` in the call to `mmap()` to be `PROT_READ|PROT_WRITE`: just in case
`PROT_READ|PROT_WRITE` does not equal `3` (though it seems to be equal in both
macOS and Linux).
**NOTE**: there might be educational value to see the progress of this fix; if you
wish to see, try the following commands from the `2001/anonymous` directory:
```
git diff d2a42f42e8f477f29e9d5ed09ce2bb349eaf7397..93aa8d79f208dcccc3c5a2370a727b5cf64e9c53 anonymous.c
git diff 93aa8d79f208dcccc3c5a2370a727b5cf64e9c53..c48629017117379a52b1a512ef8f2593ca9569c8 anonymous.c
git diff c48629017117379a52b1a512ef8f2593ca9569c8..efdee208a2bc650256637b9357ddfd0de82d2f41 anonymous.c
git diff efdee208a2bc650256637b9357ddfd0de82d2f41..e9a3f77ea3b209e63ac3f9c06bb84ad86e5ea706 anonymous.c
git diff d2a42f42e8f477f29e9d5ed09ce2bb349eaf7397..2159caec4677e0f25ad704a74e04c8196fd6c343 anonymous.c
git diff 2159caec4677e0f25ad704a74e04c8196fd6c343..4bc03de321612869aebf855850c6500df95cb6ef anonymous.c
```
Finally to see from start to finish:
```
git diff d2a42f42e8f477f29e9d5ed09ce2bb349eaf7397..4bc03de321612869aebf855850c6500df95cb6ef anonymous.c
```
or to not use `git`:
```
make diff_orig_prog
```
Cody also added a [supplementary program](%%REPO_URL%%/2001/anonymous/anonymous.bed.c) like
[anonymous.ten.c](%%REPO_URL%%/2001/anonymous/anonymous.ten.c) (which 'sings' the
lyrics to [Ten Green Bottles](https://en.wikipedia.org/wiki/Ten_Green_Bottles))
but which sings [Ten in the Bed](https://allnurseryrhymes.com/ten-in-the-bed/)
instead (the way it's implemented is different and this allows showing more of
what the entry supports).
As well he added the [try.sh](%%REPO_URL%%/2001/anonymous/try.sh) script so that one can
attempt to use the program as it was designed but if compiling as 32-bit fails
it will at least run the supplementary program as a 64-bit program directly.
Jump to: [top](#)
## Winning entry: [2001/bellard](2001/bellard/index.html)
### Winning entry source code: [bellard.c](%%REPO_URL%%/2001/bellard//bellard.c)
[Cody](#cody) fixed this to compile with `clang` but according to the author this will not
work without i386 Linux. It generates i386 32-bit code (not bytecode) but
unfortunately it will not work without i386 Linux. See [2001/bellard in
bugs.html](bugs.html#2001_bellard).
Cody fixed an earlier segfault so that it can at least now open the file should
you have an i386 Linux machine (it can open it in other platforms too, of
course, but it won't work). This involved pointer updates and also changing an
`int` to a `FILE *`. Where possible he left the macros as the same but in the
case of `main()` this was not possible.
[Yusuke](#yusuke) added another change (see below) to make it even more portable across
compilers besides what Cody did.
Cody entirely fixed the [supplementary
bellard.otccex.c](%%REPO_URL%%/2001/bellard/bellard.otccex.c) so it does not segfault and
works as well (it did not work at all though it is possible it would work in
older systems). The main problem was that some `int`s were
being used as pointers. This includes, for example, an `int` used as a `char *`,
an `int` used as a function pointer and an `int` to access `argv` as well as there
being invalid access to `argv`. He updated the `Makefile` so that this program
will compile by default.
Also the Fibonacci sequence (`fib()`) will overflow at `n > 48` so this is
checked prior to running the function just like the author did for the factorial
(overflowing at `>12`). Either way unfortunately this entry seems to not work in
64-bit Linux or macOS. See below portability notes as well as another fix in
this entry by Yusuke.
Jump to: [top](#)
## Portability notes:
With a tip from Yusuke we rediscovered the author's [web page for this
program](https://bellard.org/otcc/) where it is stated that this will only work
in i386 Linux. The author also stated in the remarks in this document that they
used `gcc 2.95.2` but we do not know if that's relevant or not.
Yusuke offered a modification which is not needed with `gcc` but with some
versions of `clang` it is. With `gcc` we can get away with `-rdynamic -fno-pie
-Wl,-z,execstack` which solves the problem of execution in memory but any
compiler that does not support this would not work. Thus we use the modification
by Yusuke.
Jump to: [top](#)
## Winning entry: [2001/cheong](2001/cheong/index.html)
### Winning entry source code: [cheong.c](%%REPO_URL%%/2001/cheong//cheong.c)
[Cody](#cody) fixed this to compile with `clang` by adding another function that is allowed to
have a third arg as an `int`, not a `char **`. He chose `pain()` because it's a four
letter word that would match the format and because it's pain that `clang` forces
this. :-) This fix makes a point of the author's notes on portability no longer
valid, BTW.
Cody also added the [try.sh](%%REPO_URL%%/2001/cheong/try.sh) script.
Jump to: [top](#)
## Winning entry: [2001/coupard](2001/coupard/index.html)
### Winning entry source code: [coupard.c](%%REPO_URL%%/2001/coupard//coupard.c)
[Cody](#cody) added a value to `return` in `main()` to make it more portable.
Cody fixed this to compile with `clang` in Linux. The problem was C99 does not
support implicit int:
```
coupard.c:31:10: error: parameter 'h' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int [-Wimplicit-int]
void e(n,h){
^
coupard.c:31:8: error: parameter 'n' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int [-Wimplicit-int]
void e(n,h){
^
```
and for some reason it was being reported as an error.
Cody also added the [try.sh](%%REPO_URL%%/2001/coupard/try.sh) script.
[Yusuke](#yusuke) provided a proper command line for those without `/dev/audio`
or `/dev/sound/dsp` (which is most everyone nowadays, it seems, and especially
those with macOS) (to do with sound; see his
[2013/endoh3/index.html](2013/endoh3/index.html) entry where he also refers to
sound devices in macOS as well as our
FAQ on "[sound](faq.html#sound)").
Jump to: [top](#)
## Winning entry: [2001/ctk](2001/ctk/index.html)
### Winning entry source code: [ctk.c](%%REPO_URL%%/2001/ctk//ctk.c)
The ANSI escape codes were no longer valid but [Yusuke](#yusuke) provided a patch to fix
the ANSI escape codes. This works with both Linux and macOS.
[Cody](#cody) fixed this so that it should always restore terminal sanity (echo enabled
etc.) after exiting even if you don't press 'q', if you crash or if you kill the
program prematurely. This was done by adding an explicit call to `e()` at the
end of `main()`.
Cody also added the [alternate
code](2001/ctk/index.html#alternate-code) that adds
vi(m) movement keys. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Jump to: [top](#)
## Winning entry: [2001/dgbeards](2001/dgbeards/index.html)
### Winning entry source code: [dgbeards.c](%%REPO_URL%%/2001/dgbeards//dgbeards.c)
The author provided two changes: one to speed it up and one to make it not crash
on losing. [Cody](#cody) provided an [alternate
version](2001/dgbeards/index.html#alternate-code) which does the former but
not the latter as he he felt that the idea of crashing on losing (see the
index.html for details on why that might be) too good to get rid. The author
explains how to make this change, however.
Cody also points out that there is a way to get the computer to automatically lose
very quickly. Do you know what it is?
Jump to: [top](#)
## Winning entry: [2001/herrmann1](2001/herrmann1/index.html)
### Winning entry source code: [herrmann1.c](%%REPO_URL%%/2001/herrmann1//herrmann1.c)
[Cody](#cody) fixed this so that the when compiling the code the program is not executed
itself by itself which just showed the usage string and exited. The [script
herrmann1.sh](%%REPO_URL%%/2001/herrmann1/herrmann1.sh) is how one should compile the program but
it's also how you invoke the program.
Cody provided the file [plus1.turing](%%REPO_URL%%/2001/herrmann1/plus1.turing) based on the
author's remarks.
He also fixed the [script herrmann1.sh](%%REPO_URL%%/2001/herrmann1/herrmann1.sh) for
shellcheck. In particular there were quite a few:
> SC2086 (info): Double quote to prevent globbing and word splitting.
> SC2248 (style): Prefer double quoting even when variables don't contain special characters.
... errors/warnings.
Cody also added the [try.sh](%%REPO_URL%%/2001/herrmann1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2001/herrmann2](2001/herrmann2/index.html)
### Winning entry source code: [herrmann2.c](%%REPO_URL%%/2001/herrmann2//herrmann2.c)
[Cody](#cody) fixed this to work with both 64-bit and 32-bit compilers by changing most
of the `int`s (all but that in `main(int ...)`) to `long`s. He also fixed it to
compile with `clang` by changing the args of `main` to be `int` and `char **`,
respectively, and changing specific references to the `argv` arg, casting to
`long` (was `int` but the 64-bit fix requires `long`) which was its old type.
Cody also added the [try.sh](%%REPO_URL%%/2001/herrmann2/try.sh) script which might be more
useful than any other place as the command to try is quite long with C code.
For some reason the original code was missing (presumingly because it had been
added to `.gitignore` by accident) but Cody restored it from the archive.
Jump to: [top](#)
## Winning entry: [2001/kev](2001/kev/index.html)
### Winning entry source code: [kev.c](%%REPO_URL%%/2001/kev//kev.c)
[Cody](#cody) improved the `Makefile` to allow one to more easily set up the port,
speed and `socket(2)` call that the author had set up.
Cody also slowed down the ball just a tad (it was already a `-D` macro that was used
in the code) as it went too fast for the speed at which the paddles move even
when holding down the movement keys (but see below).
Cody also provided an [alternate version](2001/kev/index.html#alternate-code) which lets you use
the arrow keys on your keyboard instead of the more awkward '`,`' and '`.`'. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Cody updated both versions to have `#ifndef..#endif` pairs for the macros so one
can more easily configure different settings without having to specify all of
them (though this change became unnecessary with an improvement on how it was
done). The speed, `SPEED`, will be set to `50` if it's not defined at the compiler
line as `50` is what it used to be set to. This way it's more to the original but
without having to sacrifice playability by running `make`.
Jump to: [top](#)
## Winning entry: [2001/ollinger](2001/ollinger/index.html)
### Winning entry source code: [ollinger.c](%%REPO_URL%%/2001/ollinger//ollinger.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2001/ollinger/try.sh) script.
Jump to: [top](#)
## Winning entry: [2001/schweikh](2001/schweikh/index.html)
### Winning entry source code: [schweikh.c](%%REPO_URL%%/2001/schweikh//schweikh.c)
[Cody](#cody) fixed this to not crash if not enough args as this was not documented by
the author. The other problems are documented so were not fixed. See the
index.html for details.
Cody also added the [try.sh](%%REPO_URL%%/2001/schweikh/try.sh) script.
Jump to: [top](#)
## Winning entry: [2001/westley](2001/westley/index.html)
### Winning entry source code: [westley.c](%%REPO_URL%%/2001/westley//westley.c)
[Cody](#cody) added the script [try.sh](%%REPO_URL%%/2001/westley/try.sh) to
automate a heap of commands that we, the IOCCC judges, suggested, as well as
some additional ones that he thought would be fun. He also provided the sort
and punch card versions, described in the index.html, based on the author's
remarks, through `Makefile` rules that generate the files by default with `make
all`.
Jump to: [top](#)
# [2004 - The 17th IOCCC](2004/index.html)
Jump to: [top](#)
## Winning entry: [2004/anonymous](2004/anonymous/index.html)
### Winning entry source code: [anonymous.c](%%REPO_URL%%/2004/anonymous//anonymous.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2004/anonymous/try.sh) script.
Jump to: [top](#)
## Winning entry: [2004/arachnid](2004/arachnid/index.html)
### Winning entry source code: [arachnid.c](%%REPO_URL%%/2004/arachnid//arachnid.c)
[Cody](#cody) added an [alternate
version](2004/arachnid/index.html#alternate-code) which
allows those like himself used to `h`, `j`, `k` and `l` movement keys to not get
lost. Non rogue players, vi users and Dvorak typists are invited to get lost (or
use the original version)! :-) See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Jump to: [top](#)
## Winning entry: [2004/burley](2004/burley/index.html)
### Winning entry source code: [burley.c](%%REPO_URL%%/2004/burley//burley.c)
[Cody](#cody) fixed this to compile with `clang` and to work with both `gcc` and
`clang` (even after fixing it to compile with `clang` it did not work properly).
For `clang` the problem was that `main()` had one arg, a `char *` and this is not
allowed in any version of `clang`. In some versions it is allowed if the arg is an
`int` but never if it's anything else. To get it to work took numerous changes.
First the inclusion of `setjmp.h` was necessary. Without this `longjmp(3)`
implicitly returned `int` which was used for the purpose of binary expression but
this no longer appeared to work (though it might be that if the extra function
was added earlier on it would but this is unknown and the way it was changed is
safer for the future).
But by including `setjmp.h` it naturally made the binary expressions invalid (as
it returns `void` which is not allowed in binary expressions) so the comma
operator with `0` (`,0`) had to be used (`,1` was tried first but this did not
work right so you can see that it had to be false in those places, though it is
unknown by Cody if this is because it used to be allowed to have binary
expression with `void` or if it is for some other reason).
`longjmp(3)` was being called with one arg which was an element
of an `int[4][1000]` which had to be changed to a `jmp_buf p[4]` (this due to
the addition of `#include `).
Finally the optimiser cannot be enabled so the compiler flags were changed for
this, forcing `-O0`.
Jump to: [top](#)
## Winning entry: [2004/gavare](2004/gavare/index.html)
### Winning entry source code: [gavare.c](%%REPO_URL%%/2004/gavare//gavare.c)
[Cody](#cody) added three different [alternate
versions](2004/gavare/index.html#alternate-code):
- [gavare.alt.c](%%REPO_URL%%/2004/gavare/gavare.alt.c) allows you to change the image size
and anti-alias setting at compile time. This is based on the author's remarks.
- [gavare.alt2.c](%%REPO_URL%%/2004/gavare/gavare.alt2.c) is like
[gavare.alt.c](%%REPO_URL%%/2004/gavare/gavare.alt.c) but it should work for Windows as well
(it sets binary mode on `stdout`). This is also based on the author's remarks.
- [gavare.r3.c](%%REPO_URL%%/2004/gavare/gavare.r3.c) is the author's unobfuscated version
that was used during development, found on their [website about the
entry](https://gavare.se/ioccc/ioccc_gavare.c.html).
See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
## Winning entry: [2004/gavin](2004/gavin/index.html)
### Winning entry source code: [gavin.c](%%REPO_URL%%/2004/gavin//gavin.c)
[Cody](#cody) provided the [alternate code](2004/gavin/index.html#alternate-code) for
those who want to use QEMU. The most important part of this is the macro `K` has
to be defined as `1`, not `0`.
[Yusuke](#yusuke) provided the `kernel` and `fs.tar` files which can be used if
you cannot normally use this entry. Instead of generating the files just use the
files provided, found under the [img/](%%REPO_URL%%/2004/gavin/img/) directory. Note that
the `img/fs.tar` extracts into `fs/` so you will have to fix the tarball; this
is done this way to prevent extraction from the entry directory overwriting the
files and causing `make clobber` to wipe some of them out.
Jump to: [top](#)
## Winning entry: [2004/hibachi](2004/hibachi/index.html)
### Winning entry source code: [hibachi.c](%%REPO_URL%%/2004/hibachi//hibachi.c)
[Cody](#cody) fixed a bunch of links in the index.html provided with the entry
(the web server's index.html) that no longer exist or have changed in some other way (`https`
instead of `http` for instance). In most cases a new link or change to https was
all that was necessary but at least one or two URLs required the Internet
Wayback Machine.
It is believed that a slight fix in the code had to be done too, possibly an
inclusion of `ctype.h`.
The author, [Anthony C Howe](authors.html#Anthony_C_Howe), provided an
unobfuscated version that Cody added in, with thanks to Anthony! This also
required a minor fix in the inclusion of `ctype.h` and various other fixes as
well, namely to get the program to work as `alt` rather than `-spoiler` (it is
not even known if it would work otherwise).
Jump to: [top](#)
## Winning entry: [2004/hoyle](2004/hoyle/index.html)
### Winning entry source code: [hoyle.c](%%REPO_URL%%/2004/hoyle//hoyle.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2004/hoyle/try.sh) script.
Jump to: [top](#)
## Winning entry: [2004/jdalbec](2004/jdalbec/index.html)
### Winning entry source code: [jdalbec.c](%%REPO_URL%%/2004/jdalbec//jdalbec.c)
[Cody](#cody) fixed this to compile with `gcc` (it worked with `clang`). The problem was the
cpp being unable to parse the generated code (see the index.html for details) and
this ended up with a number of errors like:
```
jdalbec.c:64:5: error: stray '##' in program
64 | B N##B (I) ; \
| ^~
..
jdalbec.c:65:5: error: stray '##' in program
65 | V F##B (B) ; \
| ^~
jdalbec.c:65:5: error: expected ';' before 'B'
65 | V F##B (B) ; \
| ^ ~
| ;
```
and various other problems. However there does seem to be a problem at least
with some `gcc` versions in macOS but this appears to be due to errors in
`/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk/usr/include/sys/cdefs.h`.
Cody also added [alternate code](2004/jdalbec/index.html#alternate-code) which allows
one to control how many numbers after the `:` to print before printing a
newline, so that one can see the output a bit better (though for lines that have
a lot of numbers this will be harder to see). See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Finally Cody added [try.sh](%%REPO_URL%%/2004/jdalbec/try.sh) and
[try.alt.sh](%%REPO_URL%%/2004/jdalbec/try.alt.sh) to demonstrate both versions.
Jump to: [top](#)
## Winning entry: [2004/kopczynski](2004/kopczynski/index.html)
### Winning entry source code: [kopczynski.c](%%REPO_URL%%/2004/kopczynski//kopczynski.c)
[Cody](#cody) force disabled the optimiser in the `Makefile` with `-O0` as he
discovered it will not work otherwise.
Cody, out of an abundance of caution for `clang`, added a second arg to `main()`
as some versions complain about the number of args and although they accept 1 it
is entirely possible it will eventually be that they don't. See the FAQ on
"[main function args](faq.html#arg_count)" for more details.
Cody also added the [try.sh](%%REPO_URL%%/2004/kopczynski/try.sh) script and various data
files: [kopczynski-a](%%REPO_URL%%/2004/kopczynski/kopczynski-a) to demonstrate what happens when art more
like a letter is fed to the program, and the `kopczynski*-rev` files which are
the data files reversed with `rev(1)`. One had to be modified additionally to
get it to work, that being `kopczynski-10-rev`.
Jump to: [top](#)
## Winning entry: [2004/newbern](2004/newbern/index.html)
### Winning entry source code: [newbern.c](%%REPO_URL%%/2004/newbern//newbern.c)
[Cody](#cody) and Landon individually fixed this to work with `clang`.
Cody also added the [try.sh](%%REPO_URL%%/2004/newbern/try.sh) script (with a hidden feature
that the author referred to and was documented by [Yusuke](#yusuke) though Cody
chose the word `IOCCC` instead of `AAA`).
Jump to: [top](#)
## Winning entry: [2004/omoikane](2004/omoikane/index.html)
### Winning entry source code: [omoikane.c](%%REPO_URL%%/2004/omoikane//omoikane.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2004/omoikane/try.sh) script.
Jump to: [top](#)
## Winning entry: [2004/schnitzi](2004/schnitzi/index.html)
### Winning entry source code: [schnitzi.c](%%REPO_URL%%/2004/schnitzi//schnitzi.c)
[Cody](#cody) made this use `fgets(3)`. See the
FAQ on "[gets and fgets](faq.html#gets)"
for why this was done.
He also changed the time factor in the data files as the animations went too
fast in modern systems, especially the scrolling text of
[schnitzi.inp1](%%REPO_URL%%/2004/schnitzi/schnitzi.inp1).
Cody also added the [try.sh](%%REPO_URL%%/2004/schnitzi/try.sh) script.
Jump to: [top](#)
## Winning entry: [2004/sds](2004/sds/index.html)
### Winning entry source code: [sds.c](%%REPO_URL%%/2004/sds//sds.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2004/sds/try.sh) script.
Also, after the `README.md` file had copyright changes, it broke the script so
Cody made a copy of the older `README.md` file into `README_sds.txt` and added that
to the repo for the script instead.
Jump to: [top](#)
## Winning entry: [2004/vik2](2004/vik2/index.html)
### Winning entry source code: [vik2.c](%%REPO_URL%%/2004/vik2//vik2.c)
[Cody](#cody) fixed this to compile in Linux. Although it compiled cleanly in macOS (and
BSD?) the code failed to compile at all in Linux due to:
```
cc -E vik2_1.c > vik2_2.c
In file included from vik2.c:945,
from vik2.c:959,
from vik2.c:972,
from vik2.c:1025:
vik2.c:383:8: error: no macro name given in #ifdef directive
383 | O \
| ^
In file included from vik2.c:946:
vik2.c:383:8: error: no macro name given in #ifdef directive
383 | O \
| ^
In file included from vik2.c:947:
vik2.c:383:8: error: no macro name given in #ifdef directive
383 | O \
| ^
In file included from vik2.c:948:
vik2.c:383:8: error: no macro name given in #ifdef directive
383 | O \
| ^
...
In file included from vik2.c:182:
vik2.c:992:85: error: #include nested depth 201 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
992 | I
| ^
vik2.c:1497:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
vik2.c:1498:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
vik2.c:1499:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
vik2.c:1500:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
vik2.c:1501:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
vik2.c:1504:21: error: #include nested depth 200 exceeds maximum of 200 (use -fmax-include-depth=DEPTH to increase the maximum)
make: *** [Makefile:133: vik2] Error 1
```
Unfortunately the fix required heavy modification to the original file (see
below) and also inclusion of what used to be generated by the
[Makefile](%%REPO_URL%%/2004/vik2/Makefile) but now it at least works for both Linux and
macOS.
As for the fix itself it required changing the C pre-processor macros that
resulted in macros themselves like `#ifdef`, `#else` etc. to be `#ifdef`,
`#else` etc. and also the inclusion of the file [vik2_1.c](%%REPO_URL%%/2004/vik2/vik2_1.c)
(which actually includes itself, once directly and now by `__FILE__`)
which used to be generated by the `Makefile` via `cc -E`.
Cody also made it so that the `FNAME` is (for the entry file itself and
`vik2_1.c` - there are other places it should not be done) `__FILE__`
just to make it a bit easier to compile.
Jump to: [top](#)
# [2005 - The 18th IOCCC](2005/index.html)
Jump to: [top](#)
## Winning entry: [2005/aidan](2005/aidan/index.html)
### Winning entry source code: [aidan.c](%%REPO_URL%%/2005/aidan//aidan.c)
[Cody](#cody) fixed the test script, described by the author in their remarks, to refer
to the proper compiled program (it's hardcoded). This had never been done and so
the script did not even work (at least modernly?).
He also added the [alternate code](2005/aidan/index.html#alternate-code) based on the
author's remarks which is a different approach than the one used and which
(according to the author):
> ... is slower (particularly in worst-case or nearly so
scenarios), inelegant, and not a good starting place for sudoku generation.
Cody added the [try.sh](%%REPO_URL%%/2005/aidan/try.sh) and
[try.alt.sh](%%REPO_URL%%/2005/aidan/try.alt.sh) scripts that correspond to the entry and
alternate code respectively.
Cody added the `make test` and `make test-n0` rules for easier use of the test
suite.
Jump to: [top](#)
## Winning entry: [2005/anon](2005/anon/index.html)
### Winning entry source code: [anon.c](%%REPO_URL%%/2005/anon//anon.c)
[Cody](#cody) fixed a problem where in some systems (like macOS) the `stty sane` would
not work and end up causing a bus error. Instead of `stty sane` it uses `stty
echo` which is what it was trying to accomplish.
The author noted that one can define `NO_STTY` to not use `stty(1)` at all
(either to prevent having to hit enter or to turn echo off/on) and this is
explained in the index.html.
Cody added the [alternate code](2005/anon/index.html#alternate-code) with vi(m) like
movements. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Jump to: [top](#)
## Winning entry: [2005/boutines](2005/boutines/index.html)
### Winning entry source code: [boutines.c](%%REPO_URL%%/2005/boutines//boutines.c)
[Cody](#cody) added the [input.txt](2005/boutines/input.txt) data file based on suggested
input from the author, adapting it to a command to try out.
Cody also added the [try.sh](%%REPO_URL%%/2005/boutines/try.sh) script.
Jump to: [top](#)
## Winning entry: [2005/giljade](2005/giljade/index.html)
### Winning entry source code: [giljade.c](%%REPO_URL%%/2005/giljade//giljade.c)
After Landon fixed the entry to compile with `clang` [Cody](#cody) noticed this
does not work at all in modern systems (see below). He fixed this to work and
then he later fixed the self-test feature.
The problem that was showing up is that with either optimising or if anything
but 32-bit (as in `-m32`) was used it would not work (at least in 64-bit
systems?). The optimising cannot be used still but it now works with both 32-bit
and 64-bit. The solution has to do with the size difference between `int` and
`long` so that the `long*E` is now `int*E`. This solves a specific problem for
Linux (32-bit, 64-bit) and macOS (arm64).
To get the self-test feature to work it was required to remove from the code:
```
O-b-f-u -s-c-a-t-e;
```
as it caused a compilation error in some of the generated code but served no
purpose, didn't affect the output of the puzzle and since the 'string' is
already in the code there is no problem omitting it.
The most complicated fix was for, as might be expected, `clang`: it (at least
some systems?) has `-Werror` by default so the program was changed to use `make`
and then `rm -f` on the output of the compiled binary instead. This change might
also not have been necessary if using different flags to `cc` but this is less
portable and caused other problems. This was a complicated fix as it's in the
comments but in a funny way; the final result to get the test feature to work
is:
```
;; /*echo/Line/%d;sed/-n/-e/ %d,%dp/%s/|sed*/
/*-e/'s,intZ,int/ Z,g'>c.c;make/c;/ rm/-f/c*/
;;
```
changed from:
```
;; /*echo/Line/%d;sed/-n/-e/ %d,%dp/%s>*/
/*c.c;cc/c.c /-c*/;;
```
or as a diff:
```
-(t(m),(0));; /*echo/Line/%d;sed/-n/-e/ %d,%dp/%s>*/
-/*c.c;cc/c.c /-c*/;;char*A=0,*_,*R,*Q, D[9999],*r,l
-[9999],T=42, M,V=32;long*E,k[9999],B[1 <<+21],*N=B+
+(t(m),(0));; /*echo/Line/%d;sed/-n/-e/ %d,%dp/%s/|sed*/
+/*-e/'s,intZ,int/ Z,g'>c.c;make/c;/ rm/-f/c*/
+;;char*A=0,*_,*R,*Q, D[9999],*r,l[9999],T=42, M,V=32;int *E,k[9999],B[1 <<+21],*N=B+
```
Cody also added the [try.sh](%%REPO_URL%%/2005/giljade/try.sh) script which also lets one see
the beauty of the entry without having to use vi(m), should they be afraid of
getting stuck in it (and for ease of use). :-)
Finally, to improve upon the test-suite provided by the program, Cody added the
`make test` rule which only shows lines matching `'^Line'` but writing to a
temporary file the compilation including the 'Line' lines. After that is done it
uses `grep -c` on the file to show that there are indeed as many versions the
program generates as the author states, 180. If it does not find 180 it is an
error; otherwise it is success. See [test.sh](%%REPO_URL%%/2005/giljade/test.sh).
Jump to: [top](#)
## Winning entry: [2005/jetro](2005/jetro/index.html)
### Winning entry source code: [jetro.c](%%REPO_URL%%/2005/jetro//jetro.c)
[Cody](#cody) added explicit linking of libm (`-lm`) for systems like Linux that seem to
not do it implicitly (like macOS does).
Jump to: [top](#)
## Winning entry: [2005/klausler](2005/klausler/index.html)
### Winning entry source code: [klausler.c](%%REPO_URL%%/2005/klausler//klausler.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2005/klausler/try.sh) script.
Jump to: [top](#)
## Winning entry: [2005/mikeash](2005/mikeash/index.html)
### Winning entry source code: [mikeash.c](%%REPO_URL%%/2005/mikeash//mikeash.c)
[Cody](#cody) fixed this to work in some versions of linux. The problem was an
unknown escape sequence, `\N`, which caused a funny compiler error:
```
};n b[2048];int i
mikeash.c: In function 'R':
mikeash.c:7:1: error: '\N' not followed by '{'
7 | ;C!='\n';A()
| ^
mikeash.c:7:1: error: incomplete universal character name \Ne
```
The problem was that in the string above there was a `\Newline` but this is
invalid C. This was changed to be `\nNewline` and then, because the code is
supposed to output itself when fed itself, the reference to `'N'` had to be
updated in both the string and the code to be `'n'`.
The array size of `c` was updated by 1 out of caution just in case as the array
is used to store at least part of the string.
It might be worth noting that the author stated that the reason for the `\N` is
due to LISP having different escape sequences. The code was modified so that
feeding the program itself will print itself, showing no difference, which is
what is supposed to happen. It is not known, however, if having to change the
`\N` to `\n` ended up breaking any LISP. The other examples given by the author
also show correct output though.
Cody also added the [try.sh](%%REPO_URL%%/2005/mikeash/try.sh) script.
Jump to: [top](#)
## Winning entry: [2005/mynx](2005/mynx/index.html)
### Winning entry source code: [mynx.c](%%REPO_URL%%/2005/mynx//mynx.c)
[Cody](#cody) fixed this so that the
[configure](%%REPO_URL%%/2005/mynx/source/configure) script (which is not needed
but part of the entry) would work with compilers that have by default `-Werror`
like `clang` in macOS.
The author, [Anthony C Howe](authors.html#Anthony_C_Howe), provided an
unobfuscated version that Cody added in, with thanks to Anthony!
Cody also added the [second alternate code](%%REPO_URL%%/2005/mynx/mynx.alt2.c) which
does scan for `https`. Futile, maybe, based on how `https` is set up, in which
case just enjoy it for what it was, without it working with websites that do not
support `http`. But there might be some command line that will let it work that
way or perhaps someone wants to add the necessary code, updating the file.
Jump to: [top](#)
## Winning entry: [2005/persano](2005/persano/index.html)
### Winning entry source code: [persano.c](%%REPO_URL%%/2005/persano//persano.c)
[Cody](#cody) added the (untested) [alternate
code](2005/persano/index.html#alternate-code) which should work for Windows as
it sets binary mode on `stdout`. This was based on the author's remarks but it
is untested as Cody has no Windows system to test it on.
Cody also added the [try.sh](%%REPO_URL%%/2005/persano/try.sh) script.
Jump to: [top](#)
## Winning entry: [2005/sykes](2005/sykes/index.html)
### Winning entry source code: [sykes.c](%%REPO_URL%%/2005/sykes//sykes.c)
[Cody](#cody) added the saved (with the `SAVE` command) BASIC program `PET` which was:
```
10 PRINT "2005'S IOCCC BEST EMULATOR"
20 PRINT "BY STEPHEN SYKES!"
```
followed by the commands:
```
SAVE "PET"
READY.
NEW
READY.
LOAD "PET"
READY.
RUN
2005'S IOCCC BEST EMULATOR
BY STEPHEN SYKES!
```
to both save and test run it.
Cody added the [try.sh](%%REPO_URL%%/2005/sykes/try.sh) script which runs in a loop with a
menu of things one might wish to try, asking if they wish to continue when done.
Cody added the script [test.sh](%%REPO_URL%%/2005/sykes/test.sh) and the make rule `test` to
run the test suite. The program will enter an infinite loop after it runs so you
have to hit ctrl-c to end it which the script tells you.
The scripts note every time that one will have to send ctrl-c or whatever their
interrupt is set to in order to exit the program.
Jump to: [top](#)
## Winning entry: [2005/timwi](2005/timwi/index.html)
### Winning entry source code: [timwi.c](%%REPO_URL%%/2005/timwi//timwi.c)
[Cody](#cody) added [try.sh](%%REPO_URL%%/2005/timwi/try.sh). It only has one command as he doesn't
want to knacker his brain any more than it might or might not already be :-) and
he doesn't want to damage anyone else's brain either. :-)
Jump to: [top](#)
## Winning entry: [2005/toledo](2005/toledo/index.html)
### Winning entry source code: [toledo.c](%%REPO_URL%%/2005/toledo//toledo.c)
[Cody](#cody) fixed this to compile with some versions of `clang` which have an additional
defect where `main()` can only have 0, 2 or 3 args (it was 4). It now calls
another function that takes 4 args and which is what used to be `main()`.
The [alternate versions](2005/toledo/index.html#alternate-code) that the author
provided were also fixed.
Jump to: [top](#)
## Winning entry: [2005/vince](2005/vince/index.html)
### Winning entry source code: [vince.c](%%REPO_URL%%/2005/vince//vince.c)
[Cody](#cody) fixed this in the case that the program is compiled or linked/copied to
another file name: the code constructed the source code file name in a clever
and more obscure way by copying to the buffer `*argv` and then using `strcat(3)`
to concatenate to it `.c`. But this assumes that the executable is the same name
as the source file which isn't always true. The author even stated: '`as long
as the source is in the same directory as the executable it should be able to
find it`' but the source code file name is not always the same as the executable
with the appropriate extension so this might be called a bug fix as well though
if one runs it from another directory, specifying the directory, it'll not catch it.
Jump to: [top](#)
# [2006 - The 19th IOCCC](2006/index.html)
Jump to: [top](#)
## Winning entry: [2006/birken](2006/birken/index.html)
### Winning entry source code: [birken.c](%%REPO_URL%%/2006/birken//birken.c)
[Cody](#cody) fixed a segfault that prevented this entry from working in macOS.
The problem was a missing `+1` for `strlen(3)` with `malloc(3)`. This prevented
it from working.
Cody also added the [try.sh](%%REPO_URL%%/2006/birken/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/borsanyi](2006/borsanyi/index.html)
### Winning entry source code: [borsanyi.c](%%REPO_URL%%/2006/borsanyi//borsanyi.c)
[Cody](#cody) fixed the `Makefile` to work in systems where the `lpthread` is not
implicitly linked in.
Cody also added the [try.sh](%%REPO_URL%%/2006/borsanyi/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/grothe](2006/grothe/index.html)
### Winning entry source code: [grothe.c](%%REPO_URL%%/2006/grothe//grothe.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2006/grothe/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/hamre](2006/hamre/index.html)
### Winning entry source code: [hamre.c](%%REPO_URL%%/2006/hamre//hamre.c)
Cody added the [try.sh](%%REPO_URL%%/2006/hamre/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/monge](2006/monge/index.html)
### Winning entry source code: [monge.c](%%REPO_URL%%/2006/monge//monge.c)
[Cody](#cody) added the [alternate code](2006/monge/index.html#alternate-code) that lets
one resize the image and redefine the number of iterations. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Cody also added the [try.sh](%%REPO_URL%%/2006/monge/try.sh) and
[try.alt.sh](%%REPO_URL%%/2006/monge/try.alt.sh) scripts.
Cody also fixed the `Makefile` to use `sdl-config`, not `sdl2-config`, as two
functions that are used were removed from [SDL2](https://www.libsdl.org), thus
making it not link.
Nevertheless this entry does require x86/x86_64 CPUS (this is a documented
feature).
Jump to: [top](#)
## Winning entry: [2006/night](2006/night/index.html)
### Winning entry source code: [night.c](%%REPO_URL%%/2006/night//night.c)
As [Cody](#cody) is a lost :-) `vim` user he took the author's remarks to add support
back for arrow keys in the [alternate
version](2006/night/index.html#alternate-code). See the
FAQ on "[alternate code](faq.html#alt_code)" for more details.
Jump to: [top](#)
## Winning entry: [2006/sloane](2006/sloane/index.html)
### Winning entry source code: [sloane.c](%%REPO_URL%%/2006/sloane//sloane.c)
[Cody](#cody) fixed this entry to work with `clang` which has a defect with the args to
`main()`: it requires specific types: `int` and `char **` for the first and
latter args.
Cody also provided the [alternate version](%%REPO_URL%%/2006/sloane/sloane.alt.c), which
allows one to see what it looked like back in 2006, and which we recommend one
use _first_.
Curiously, although `clang` requires the types of args to be strictly correct,
some versions do allow only one arg. This was done at first because it's not
used but Cody discovered that later versions of `clang` have an additional defect
where it does not allow only one arg so the second arg to `main()` was added
back.
Cody also made sure that the `Makefile` links in `libm` as not all systems do this
by default.
Since the author suggested that the lack of certain `#include`s might break the
program in some systems he also added `-include ...` to the `Makefile` as well.
## Winning entry: [2006/stewart](2006/stewart/index.html)
### Winning entry source code: [stewart.c](%%REPO_URL%%/2006/stewart//stewart.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2006/stewart/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/sykes1](2006/sykes1/index.html)
### Winning entry source code: [sykes1.c](%%REPO_URL%%/2006/sykes1//sykes1.c)
[Cody](#cody) provided the [alternate
code](2006/sykes1/index.html#alternate-code) based on the
author's remarks.
Cody also added the [try.sh](%%REPO_URL%%/2006/sykes1/try.sh) script.
Cody also provided the [bedlam-cubes.pdf](2006/sykes1/bedlam-cubes.pdf) file,
obtained from the Internet Wayback Machine, as the file was no longer available.
Jump to: [top](#)
## Winning entry: [2006/sykes2](2006/sykes2/index.html)
### Winning entry source code: [sykes2.c](%%REPO_URL%%/2006/sykes2//sykes2.c)
[Cody](#cody), out of an abundance of caution for `clang`'s defects, made `main()` have
2 args instead of 1 as some versions report that `main()` must have 0, 2 or 3
args, even though at least one of those versions allows 1 arg only. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody also added the [try.sh](%%REPO_URL%%/2006/sykes2/try.sh) script for easier
use of the entry to show the clock update in real time.
Jump to: [top](#)
## Winning entry: [2006/toledo1](2006/toledo1/index.html)
### Winning entry source code: [toledo1.c](%%REPO_URL%%/2006/toledo1//toledo1.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2006/toledo1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2006/toledo2](2006/toledo2/index.html)
### Winning entry source code: [toledo2.c](%%REPO_URL%%/2006/toledo2//toledo2.c)
[Cody](#cody) fixed a segfault in this program which was making it fail to work under
macOS - it did not seem to be a problem under Linux, at least not fedora. The
problem was wrong variable types - implicit `int`s instead of `FILE *`s. It now
works with both macOS and Linux.
Cody also added the (untested) [alternate
code](2006/toledo2/index.html#alternate-code) that is based on the author's remarks to
port this to systems that have the non-standard `kbhit()` and `getch()` (not the
one from curses) which is typically (always?) in `conio.h`.
The author, [Oscar Toledo G.](authors.html#Oscar_Toledo), later went back over
the program and modified the `fread(3)`/`fwrite(3)` section to use the variable
`FILE *e` (that Cody changed) instead of `int y`, making it to work on x86_64
(perhaps Cody's fix was for arm64 only?). Also, he added a note to clarify from
where appears the `IMPORT.COM` and `HALT.COM` files.
Jump to: [top](#)
## Winning entry: [2006/toledo3](2006/toledo3/index.html)
### Winning entry source code: [toledo3.c](%%REPO_URL%%/2006/toledo3//toledo3.c)
[Cody](#cody) fixed a crash and a display problem in this entry so that it now works in
modern (64-bit) systems. The crash appears to only occur in macOS but the fix
lets it work in both Linux and macOS. The problem was that it relied on 32-bits
so some `int`s were changed to `long`s. The display problem might or might not
have been a problem in Linux with the old `int`s but this is no longer known.
Cody also added the code that should work for Windows (it was tested by the
author), [toledo3.alt.c](%%REPO_URL%%/2006/toledo3/toledo3.alt.c), based on the
author's remarks; see [Alternate code in
2006/toledo3/index.html](2006/toledo3/index.html#alternate-code).
Jump to: [top](#)
# [2011 - The 20th IOCCC](2011/index.html)
Jump to: [top](#)
## Winning entry: [2011/akari](2011/akari/index.html)
### Winning entry source code: [akari.c](%%REPO_URL%%/2011/akari//akari.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/akari/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/blakely](2011/blakely/index.html)
### Winning entry source code: [blakely.c](%%REPO_URL%%/2011/blakely//blakely.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/blakely/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/borsanyi](2011/borsanyi/index.html)
### Winning entry source code: [borsanyi.c](%%REPO_URL%%/2011/borsanyi//borsanyi.c)
[Cody](#cody), out of an abundance of caution, added a second arg to `main()` as some
versions of `clang` complain about not only the type of each arg to `main()` but
the number of args as well. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody also added the [try.sh](%%REPO_URL%%/2011/borsanyi/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/dlowe](2011/dlowe/index.html)
### Winning entry source code: [dlowe.c](%%REPO_URL%%/2011/dlowe//dlowe.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/dlowe/try.sh) script.
Cody also fixed a problem in the manifest, caused by a file name that would be
interpreted as something else in web servers and would thus be a 404 error even
though the file appears to exist on disk. In particular the file
`2011/dlowe/dlowe-aux-data/english-0/CIR_APE_08_doc%5B1%5D.txt` had to be
renamed to `CIR_APE_08_doc.txt` because web servers would parse it as
`CIR_APE_08_doc[1].txt` which obviously does not exist as on disk the file name had
the html encoding literally for the characters, not the characters they
translate to themselves (which was in the manifest).
The file could have been named to that but it is not POSIX safe so the `[]`s
were removed. At the same time, for the same reason (though the link worked),
the file `2011/dlowe/dlowe-aux-data/png-1/image_thumb[40].png` was renamed to
`image_thumb.png`.
Jump to: [top](#)
## Winning entry: [2011/fredriksson](2011/fredriksson/index.html)
### Winning entry source code: [fredriksson.c](%%REPO_URL%%/2011/fredriksson//fredriksson.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/fredriksson/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/goren](2011/goren/index.html)
### Winning entry source code: [goren.c](%%REPO_URL%%/2011/goren//goren.c)
[Cody](#cody) fixed this for macOS. Before the fix it segfaulted. It worked fine under
Linux. After fixing it it was noticed that the author stated it does not work
for 64-bit so it was then tested as a 32-bit binary (Linux) and 64-bit binary
(Linux, macOS) and both work. It was fixed by changing some `int`s to `long`s
and now it does work with 64-bit systems as well as 32-bit systems.
Cody also added the [try.sh](%%REPO_URL%%/2011/goren/try.sh) script.
Cody added the following words of wisdom:
> "this" is not a pipe but "|" is
:-).
Jump to: [top](#)
## Winning entry: [2011/hamaji](2011/hamaji/index.html)
### Winning entry source code: [hamaji.c](%%REPO_URL%%/2011/hamaji//hamaji.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/hamaji/try.sh) script and the `.nono` files
[conway-game-of-life.nono](%%REPO_URL%%/2011/hamaji/conway-game-of-life.nono),
[multi-solutions.nono](%%REPO_URL%%/2011/hamaji/multi-solutions.nono),
[no-solution.nono](%%REPO_URL%%/2011/hamaji/no-solution.nono),
[plus.nono](%%REPO_URL%%/2011/hamaji/plus.nono) and [smiley.nono](%%REPO_URL%%/2011/hamaji/smiley.nono).
The latter two `.nono` files were taken from
and the others were from the authors' remarks.
Jump to: [top](#)
## Winning entry: [2011/hou](2011/hou/index.html)
### Winning entry source code: [hou.c](%%REPO_URL%%/2011/hou//hou.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/hou/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/konno](2011/konno/index.html)
### Winning entry source code: [konno.c](%%REPO_URL%%/2011/konno//konno.c)
Cody added the [try.sh](%%REPO_URL%%/2011/konno/try.sh) script.
Jump to: [top](#)
## Winning entry: [2011/richards](2011/richards/index.html)
### Winning entry source code: [richards.c](%%REPO_URL%%/2011/richards//richards.c)
[Cody](#cody) fixed a minor problem that showed up in both Linux and macOS. He notes
however that as of this time this entry does not work properly with macOS at
least with the silicon chip (Intel has not been tested) and it is quite possibly
an inherent problem in macOS to do with executing code in in memory/JIT and in
particular with the silicon chip. See [2011/richards in
bugs.html](bugs.html#2011_richards) for more details and a
document from Apple about how it might be fixed if anyone is brave enough to
try. If they do they might want to look also at
[richards.alt.c](%%REPO_URL%%/2011/richards/richards.alt.c), for whatever it might or might
not be worth, as it is a possible starting point that Cody added.
Cody also added the [try.sh](%%REPO_URL%%/2011/richards/try.sh) and the
[try.alt.sh](%%REPO_URL%%/2011/richards/try.alt.sh) scripts. The `try.alt.sh` script will be
helpful to test any fixes for Apple silicon chips (see [2011/richards in
bugs.html](bugs.html#2011_richards) for more details).
Jump to: [top](#)
## Winning entry: [2011/toledo](2011/toledo/index.html)
### Winning entry source code: [toledo.c](%%REPO_URL%%/2011/toledo//toledo.c)
[Cody](#cody) added two [alternate versions](2011/toledo/index.html#alternate-code): one that
lets one reconfigure the controls and also the size of the game and another
version that should work in Windows, based on the author's remarks and support
file, `layer.c`.
The `Makefile` was also modified by Cody to make it simpler to redefine the
controls, width and height.
Jump to: [top](#)
## Winning entry: [2011/vik](2011/vik/index.html)
### Winning entry source code: [vik.c](%%REPO_URL%%/2011/vik//vik.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/vik/try.sh) script.
Cody also added an [alternate version](2011/vik/index.html#alternate-code) for Windows
based on the author's comments (along with looking up the function for the right
header files). To build try the `alt` rule of the `Makefile`.
Jump to: [top](#)
## Winning entry: [2011/zucker](2011/zucker/index.html)
### Winning entry source code: [zucker.c](%%REPO_URL%%/2011/zucker//zucker.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2011/zucker/try.sh) script.
Cody also added [alternate
code](2011/zucker/index.html#alternate-code) that should work on
Windows, based on the author's remarks that if the system distinguishes binary
and text then `stdout` needs to be set to binary mode.
Cody also added the PDF file
[sphere-tracing.pdf](2011/zucker/sphere-tracing.pdf) in case the link
eventually dies.
Jump to: [top](#)
# [2012 - The 21st IOCCC](2012/index.html)
Jump to: [top](#)
## Winning entry: [2012/blakely](2012/blakely/index.html)
### Winning entry source code: [blakely.c](%%REPO_URL%%/2012/blakely//blakely.c)
[Cody](#cody) added explicit linking of libm (`-lm`) as not all systems do this
implicitly (Linux doesn't seem to but macOS does).
Cody also added the [try.sh](%%REPO_URL%%/2012/blakely/try.sh) script.
Jump to: [top](#)
## Winning entry: [2012/deckmyn](2012/deckmyn/index.html)
### Winning entry source code: [deckmyn.c](%%REPO_URL%%/2012/deckmyn//deckmyn.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/deckmyn/try.sh) script.
Jump to: [top](#)
## Winning entry: [2012/endoh1](2012/endoh1/index.html)
### Winning entry source code: [endoh1.c](%%REPO_URL%%/2012/endoh1//endoh1.c)
[Cody](#cody) added explicit linking of libm (`-lm`) as not all systems do this
implicitly (Linux doesn't seem to but macOS does).
Cody also added two [alt versions](2012/endoh1/index.html#alternate-code) that
let one control how fast the fluid moves (how long to sleep in between writes)
and also the gravity factor, the pressure factor and the viscosity factor as
well as an alarm that lets one run it in a loop without having to hit
ctrl-c/intr in between (the alarm can be disabled, however). The `Makefile` allows
one to easily do this with variable names rather than redefining `CDEFINE`. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
The two different alt versions is because there are two versions: the original
and the colour version added by the author, [Yusuke](#yusuke), at the request of
the judges.
Cody also added the [try.alt.sh](%%REPO_URL%%/2012/endoh1/try.alt.sh) script that compiles
the alternate code in two ways, one with setting the gravity factor to `I` and another
with the default, and which is run on the source file and each of the text files
supplied by the author. This code has an alarm set at 10 seconds so that one
need not hit ctrl-c/intr in between .. say to make it more fluid :-) See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Cody also added the [try.alt.bw.sh](%%REPO_URL%%/2012/endoh1/try.alt.bw.sh) which is the
same as the `try.alt.sh` except it does not use the coloured version.
Finally Cody added the [try.sh](%%REPO_URL%%/2012/endoh1/try.sh) and
[try.bw.sh](%%REPO_URL%%/2012/endoh1/try.bw.sh) which correspond to the coloured version
[endoh1_color.c](%%REPO_URL%%/2012/endoh1/endoh1_color.c) and the original submitted
version without colour, [endoh1.c](%%REPO_URL%%/2012/endoh1/endoh1.c).
The [endoh1.alt2.c](%%REPO_URL%%/2012/endoh1/endoh1.alt2.c) was provided by the author,
[Yusuke](#yusuke), at the time of the contest as a de-obfuscated version.
Jump to: [top](#)
## Winning entry: [2012/endoh2](2012/endoh2/index.html)
### Winning entry source code: [endoh2.c](%%REPO_URL%%/2012/endoh2//endoh2.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/endoh2/try.sh) script that runs
everything, filtered through less.
Cody also fixed a typo in the ruby script
[find-font-table.rb](%%REPO_URL%%/2012/endoh2/find-font-table.rb).
Jump to: [top](#)
## Winning entry: [2012/grothe](2012/grothe/index.html)
### Winning entry source code: [grothe.c](%%REPO_URL%%/2012/grothe//grothe.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/grothe/try.sh) script.
Cody also changed `argv` to be not `const char **` but `char **`, mostly out of an
abundance of caution in case `clang`, which already imposes restrictions on the
types of args to `main()` including to do with `char **`, decides to further
restrict them. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody also restored the original code from the archive.
And although the URL works for now (via redirect), Cody changed the website
linked to in the recipe file to the domain that the old one currently redirects
to, in case the other domain ends up expiring or stops redirecting to the more
recent domain. For historical purposes the old link was
`http://recipes.stevex.net/` but it redirects to `https://www.mealsteps.com`
which the recipe file now links to.
Jump to: [top](#)
## Winning entry: [2012/hamano](2012/hamano/index.html)
### Winning entry source code: [hamano.c](%%REPO_URL%%/2012/hamano//hamano.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/hamano/try.sh) script and the helper
Makefile rules `hint.pdf`, `hint`, `hello.pdf` and `hello` to simplify the
procedure for both `hint.pdf` and `hello.pdf` as well as compiling them as C.
Jump to: [top](#)
## Winning entry: [2012/hou](2012/hou/index.html)
### Winning entry source code: [hou.c](%%REPO_URL%%/2012/hou//hou.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/hou/try.sh) script and restored the original [hint
markdown file](%%REPO_URL%%/2012/hou/hint.md) as the changes made when converting to a GitHub
index.html made the generated html not look correct; it did not have a title, a
stylesheet etc. due to the fact that there is no `#` header (which specified
title and stylesheet) and other formatting changes.
Jump to: [top](#)
## Winning entry: [2012/kang](2012/kang/index.html)
### Winning entry source code: [kang.c](%%REPO_URL%%/2012/kang//kang.c)
[Cody](#cody) added the scripts
[en.sh](%%REPO_URL%%/2012/kang/en.sh), [de.sh](%%REPO_URL%%/2012/kang/de.sh) and
[try.sh](%%REPO_URL%%/2012/kang/try.sh).
In the German script it uses the umlaut for five (`fünf`) and also does it
without the umlaut (add an 'e' i.e. `fuenf`). Notice how the program picks up on
this!
Jump to: [top](#)
## Winning entry: [2012/konno](2012/konno/index.html)
### Winning entry source code: [konno.c](%%REPO_URL%%/2012/konno//konno.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/konno/try.sh) script.
Jump to: [top](#)
## Winning entry: [2012/tromp](2012/tromp/index.html)
### Winning entry source code: [tromp.c](%%REPO_URL%%/2012/tromp//tromp.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/tromp/try.sh) script.
Jump to: [top](#)
## Winning entry: [2012/vik](2012/vik/index.html)
### Winning entry source code: [vik.c](%%REPO_URL%%/2012/vik//vik.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/vik/try.sh) script.
Based on the author's description it should be possible to get this entry to work
for Windows. With his instructions Cody also added the [alternate
version](2012/vik/index.html#alternate-code) that does this.
Jump to: [top](#)
## Winning entry: [2012/zeitak](2012/zeitak/index.html)
### Winning entry source code: [zeitak.c](%%REPO_URL%%/2012/zeitak//zeitak.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2012/zeitak/try.sh) script and the
`make test` rule that uses the script along with a number of files that will
correctly be flagged as incorrect (including a text file and a Java file, with a
joke, to show that it's not that it parses C but rather just matching pairs
though that's probably obvious) and some correctly nested files were also added
including [1984/anonymous](1984/anonymous/index.html) (as the
author explicitly mentioned it), both the [original
version](%%REPO_URL%%/2012/zeitak/anonymous.alt.c) (.alt.c) and the
[modified version](%%REPO_URL%%/2012/zeitak/anonymous.c) that works with macOS
as well, and a Java file as well with another joke. Those C files had to be
added because each entry has its own tarball and without the files it would
break the script.
A problem was later fixed in the `Makefile` by Cody, a typo in the `CSILENCE`
variable that prevented compilation.
A minor point is that the author noted that one should
look at the program source with tab space of 4 characters so Cody added the
command to do this in vim for those who use it, in the judges' remarks, to make
it easier for those who do not know how, and to make it more obvious to try it.
Jump to: [top](#)
# [2013 - The 22nd IOCCC](2013/index.html)
## Winning entry: [2013/birken](2013/birken/index.html)
### Winning entry source code: [birken.c](%%REPO_URL%%/2013/birken//birken.c)
[Cody](#cody) changed the `return 0;` at the end of the program to be `return
system("reset");` (via redefining `exit(3)` so that the column ending would be
the same) so that as long as it runs to completion the terminal will be sane and
the cursor will be visible. Using `atexit(3)` will not work if the program is
killed, signals are ugly and these would be messing with the entry too much so
these were not done.
Cody also added the [alternate version](%%REPO_URL%%/2013/birken/birken.alt.c)
that lets one control how fast the painting is done, based on the author's
recommendations, except that Cody made it configurable at compile time. The
`Makefile` was modified in such a way as to make it very easy to redefine it at
compile time.
Cody also added the [try.sh](%%REPO_URL%%/2013/birken/try.sh) script for the entry and the
[try.alt.sh](%%REPO_URL%%/2013/birken/try.alt.sh) script for the alternate code.
Jump to: [top](#)
## Winning entry: [2013/cable1](2013/cable1/index.html)
### Winning entry source code: [cable1.c](%%REPO_URL%%/2013/cable1//cable1.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/cable1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/cable2](2013/cable2/index.html)
### Winning entry source code: [cable2.c](%%REPO_URL%%/2013/cable2//cable2.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/cable2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/cable3](2013/cable3/index.html)
### Winning entry source code: [cable3.c](%%REPO_URL%%/2013/cable3//cable3.c)
[Cody](#cody) fixed this to compile with modern systems. The problems were that
`localtime()` is used differently and with `time.h` being included (with
[SDL2](https://www.libsdl.org) in macOS - but see below) there was a conflicting
function type. This appeared to be a problem with macOS and only when SDL2 was
included (but which as noted next it cannot be).
The other problem is that this entry uses SDL functions that were
removed from SDL2 so the `Makefile` has to use `sdl-config` and not `sdl2-config`.
This meant that at one point to be strictly technical, the removal of
`localtime()` wasn't necessary but this change was left in place anyway (but see
below again).
Later on in an updated macOS (problem discovered in macOS Sonoma) the entry
failed to compile again also due to `localtime()` so he removed the prototype
entirely to solve the problem.
Cody also slightly improved the `runme` script (renamed to
[cable3.sh](%%REPO_URL%%/2013/cable3/cable3.sh) for consistency with other entries that have
wrapper scripts) to not assume that the program has been compiled by running
`make clobber all || exit 1` and he also made it pass `shellcheck` (using `[[ ..
]]` over `[ .. ]`).
As well, based on the author's remarks, Cody added the [alternate
code](2013/cable3/index.html#alternate-code) which should be compilable for Windows/MS Visual
Studio. This is done by in the compile line undefining `KB` (`-UKB`) and then in
the source code defining `KB` to what the author suggested,
`(kb=H(8),kbhit())&&(r[1190]=getch(),H(7))`. It need hardly be mentioned that
this will not link in Unix systems (including macOS).
Finally Cody provided the [bios.asm](%%REPO_URL%%/2013/cable3/bios.asm) that the author
referred to, found at the [GitHub repo for the
entry](https://github.com/adriancable/8086tiny/tree/master), and the `ready-made
40MB hard disk image containing a whole bunch of software` in `hd.img` that the
author linked to at `https://bitly.com/1bU8URK`.
Jump to: [top](#)
## Winning entry: [2013/dlowe](2013/dlowe/index.html)
### Winning entry source code: [dlowe.c](%%REPO_URL%%/2013/dlowe//dlowe.c)
[Cody](#cody) added the source code that we suggested one should compile and run with
different compilers as [fun.c](%%REPO_URL%%/2013/dlowe/fun.c). He modified the `Makefile` so
that running `make all` will compile it, saving you the effort.
He also provided the script [slflen.sh](%%REPO_URL%%/2013/dlowe/slflen.sh) which is based on
the author's remarks, fixing it for shellcheck and improving upon it (show what
files will be processed). This script shows the sparkline of the file lengths
(as in `wc -c`). The fixes (but not the improvements) were added to the author's
remarks.
Since the author called the program `sparkl` Cody modified the `Makefile` so that
running `make all` will create a symlink to `dlowe` as `sparkl`. Running `make
clobber` will delete both and running `make clobber all` will ensure that the
symlink is created. The `slflen.sh` script also explicitly makes sure to create
the symlink as it uses it, even though it runs `make clobber all`.
Cody also added the [try.sh](%%REPO_URL%%/2013/dlowe/try.sh) script to more easily try the
program.
He also added the [diff.sh](%%REPO_URL%%/2013/dlowe/diff.sh) script which is based on some
commands to try that he suggested to see how different lengths look.
Jump to: [top](#)
## Winning entry: [2013/endoh1](2013/endoh1/index.html)
### Winning entry source code: [endoh1.c](%%REPO_URL%%/2013/endoh1//endoh1.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/endoh1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/endoh2](2013/endoh2/index.html)
### Winning entry source code: [endoh2.c](%%REPO_URL%%/2013/endoh2//endoh2.c)
[Cody](#cody) fixed the `Makefile` `check` rule so that it `checks` :-) that both
[Ruby](https://www.ruby-lang.org) and [ImageMagick](https://imagemagick.org) are
installed before trying to run the ruby script. To be more technically correct:
it checks that the `convert` tool of ImageMagick is available (via `type -P`)
because `convert` is part of the ImageMagick suite. The rule will report the
tools not installed and where to find them, if they are not installed, and after
checking these requirements it will exit if either is not found.
The checks are useful because the Ruby script tries to run (via `IO.popen()`) the
`convert` tool but without ImageMagick being installed, if one is unaware of
where it comes from it will appear to be an error in the Ruby script (it might
also appear to be an issue with the script even if you know of `convert`).
The entry can still be enjoyed if you do not have these tools, however.
Jump to: [top](#)
## Winning entry: [2013/endoh3](2013/endoh3/index.html)
### Winning entry source code: [endoh3.c](%%REPO_URL%%/2013/endoh3//endoh3.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/endoh3/try.sh) script.
Cody also (out of an abundance of caution for `clang(1)` which is strict with
arg type and count to `main()`) added a second (unused) arg to `main()`. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Jump to: [top](#)
## Winning entry: [2013/endoh4](2013/endoh4/index.html)
### Winning entry source code: [endoh4.c](%%REPO_URL%%/2013/endoh4//endoh4.c)
[Cody](#cody) added the [endoh4.sh](%%REPO_URL%%/2013/endoh4/endoh4.sh) script which temporarily
turns off the cursor as suggested by the author, with the addition that if no
file is specified it will feed the source code [endoh4.c](%%REPO_URL%%/2013/endoh4/endoh4.c)
to the program rather than the file specified. It does not try and detect if the
file exists or can be read as that will be handled by the shell/program. One may
pass more than one file to the script.
Cody also made it easier to redefine the size at compilation time (see the
author's remarks for more details on what this means). The `endoh4.sh` script
allows one to redefine it as well.
Jump to: [top](#)
## Winning entry: [2013/hou](2013/hou/index.html)
### Winning entry source code: [hou.c](%%REPO_URL%%/2013/hou//hou.c)
[Cody](#cody) fixed the `Makefile` so that this would work properly. Before this
the use of the program just did what the judges' remarks said as far as how it
might violate rule 2: the program is really just a decompressor to generate the
real source of the program. So the source of the entry has to be compiled and
then run, and the output has to be compiled to be `hou`. This allows the real
program to be used. Thus the `Makefile` rule looks like:
```
${PROG}: ${PROG}.c
${CC} ${CFLAGS} $< -o $@ ${LDFLAGS}
./${PROG} | ${CC} ${CFLAGS} -xc - -o $@ ${LDFLAGS}
```
which then compiles like:
```
cc -std=gnu11 -Wall -Wextra -pedantic -Wno-sign-compare -Wno-strict-prototypes -O3 hou.c -o hou -lm
./hou | cc -std=gnu11 -Wall -Wextra -pedantic -Wno-sign-compare -Wno-strict-prototypes -O3 -xc - -o hou -lm
```
The `LDFLAGS` were updated to have `-lm` as the author suggested it uses the
`math.h` library which not all systems link in by default (Linux for instance
does not).
The author noted that one can build `a.c` and refers to it in documentation. The
rule in the `Makefile` was originally removed as part of the above but it was
restored so that one can see what the author is talking about.
Further, after the file `2013/hou/doc/example.markdown` was moved to
[2013/hou/doc/example.md](%%REPO_URL%%/2013/hou/doc/example.md) by us, to match
the rest of the repo, `make` was broken, which Cody fixed.
Cody also added the [try.sh](%%REPO_URL%%/2013/hou/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/mills](2013/mills/index.html)
## Source code: [mills.c](%%REPO_URL%%/2013/mills/mills.c)
[Cody](#cody) fixed this so that the server would not refuse the connection
after the first call to `close(2)`. The problem was that because the backlog to
`listen(2)` was `1`, once the connection closed the server was essentially 'dead'.
The backlog was changed to `10` and this solves the problem. It is not known if
this was specific to macOS but it was not specific to a browser as Safari and
Firefox both had the problem.
Jump to: [top](#)
## Winning entry: [2013/misaka](2013/misaka/index.html)
### Winning entry source code: [misaka.c](%%REPO_URL%%/2013/misaka//misaka.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/misaka/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/morgan1](2013/morgan1/index.html)
### Winning entry source code: [morgan1.c](%%REPO_URL%%/2013/morgan1//morgan1.c)
[Cody](#cody) added explicit linking of libm (`-lm`) as not all systems do this
implicitly (Linux doesn't seem to but macOS does).
Cody also added the [try.sh](%%REPO_URL%%/2013/morgan1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2013/robison](2013/robison/index.html)
### Winning entry source code: [robison.c](%%REPO_URL%%/2013/robison//robison.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2013/robison/try.sh) script.
Jump to: [top](#)
# [2014 - The 23rd IOCCC](2014/index.html)
[Yusuke](#yusuke) added the missing `rules.txt`, `iocccsize.c` and `
iocccsize.mk` files.
Jump to: [top](#)
## Winning entry: [2014/birken](2014/birken/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/birken//prog.c)
[Cody](#cody) provided the [alternate
code](2014/birken/index.html#alternate-code) that lets one redefine the port to
bind to in case there is a firewall issue or there is some other reason to not
have the default port. Remember that ports < 1024 are privileged. It also lets
you redefine the timing constant `STARDATE` (see the author's remarks for more
details on this macro). The `Makefile` was made to use variables so it's easier to
redefine the port and timing constant.
Jump to: [top](#)
## Winning entry: [2014/deak](2014/deak/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/deak//prog.c)
[Cody](#cody) added [alternate code](2014/deak/index.html#alternate-code) that lets
one (via the `Makefile`) reconfigure the coordinates but instead of being a
modified version of the entry it is the version the author provided which would
be what the program would look like if, as the author put it:
> The usage of recognizable elements from the C programming language in the
application source code is intentionally kept to a bare minimum.
.. was not true. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
This alternate version did not originally compile because a value was left off the
`return` statement (this might have been fixed in the index.html file too) so
that was fixed and it also has `#include ` for `putchar(3)`. The
`#ifndef..#define..#endif` was not part of the original alternate code, of course.
Cody also added the [try.alt.sh](%%REPO_URL%%/2014/deak/try.alt.sh) script.
Jump to: [top](#)
## Winning entry: [2014/endoh1](2014/endoh1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/endoh1//prog.c)
[Cody](#cody) added the [rake.sh](%%REPO_URL%%/2014/endoh1/rake.sh) script and `make rake`
rule that runs the script. This script will check that `rake` is installed and
if it is not it will report this and then check that `gem` is installed. It
checks that `gem` is installed in this case because `gem` is how you install
`rake`. If `gem` is not installed it tells you to get it along with how to
install `gem`. Then it tells you how to install `rake`. If `rake` fails to run
then it tells you to install a specific gem and then to try again. Finally if
`rake` succeeds it will verify that `prog` is executable and if it is it will
run it.
Cody also added the [try.sh](%%REPO_URL%%/2014/endoh1/try.sh) script.
To silence the annoying misleading indentation warning and to prevent debug
symbols from being built with `rake` Cody also updated the
[Rakefile](%%REPO_URL%%/2014/endoh1/Rakefile) slightly.
Jump to: [top](#)
## Winning entry: [2014/endoh2](2014/endoh2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/endoh2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2014/endoh2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2014/maffiodo1](2014/maffiodo1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/maffiodo1//prog.c)
[Cody](#cody) fixed the `Makefile` for this entry: it does not require
`SDL2` but `SDL1` so there were linking errors.
Cody also added the [mario.sh](%%REPO_URL%%/2014/maffiodo1/mario.sh) and
[giana.sh](%%REPO_URL%%/2014/maffiodo1/giana.sh) scripts which play, respectively, [Super
Mario Bros](http://en.wikipedia.org/wiki/Super_Mario_Bros.) and one of [The
Great Giana Sisters](http://en.wikipedia.org/wiki/The_Great_Giana_Sisters), but
which let one configure the width and height of the game.
Jump to: [top](#)
## Winning entry: [2014/maffiodo2](2014/maffiodo2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/maffiodo2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2014/maffiodo2/try.sh) script.
Cody also added the [alternate code](2014/maffiodo2/index.html#alternate-code)
provided by the author.
Jump to: [top](#)
## Winning entry: [2014/morgan](2014/morgan/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/morgan//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2014/morgan/try.sh) script.
Jump to: [top](#)
## Winning entry: [2014/sinon](2014/sinon/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/sinon//prog.c)
[Cody](#cody) fixed the code so that the game can play automatically like it
once did. The problem is that it expects a certain file name which was
`sinon.c`. The code now refers to `prog.c` (it cannot as easily use `__FILE__`).
Cody also fixed the scripts [glock.sh](%%REPO_URL%%/2014/sinon/glock.sh) and
[hecate.sh](%%REPO_URL%%/2014/sinon/hecate.sh) which did not work after running
either of them once as they compile `run.c` and then do `./run | tee run.c`
which overwrites it with output that is not code.
Cody also added the [try.sh](%%REPO_URL%%/2014/sinon/try.sh) script that will first (if perl
is installed) run the demo mode and then after that it will run the above noted
scripts in a loop until the user says they do not want to try again (or they
kill it). This is done this way in case it jams (see index.html for details).
Jump to: [top](#)
## Winning entry: [2014/skeggs](2014/skeggs/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/skeggs//prog.c)
[Cody](#cody) fixed the `Makefile` to compile this entry in modern systems. The problem was
that the `CDEFINE` variable in the `Makefile` was missing `'`s: the `#define CC`
is an actual string that is, in the Makefile, `"${CC} -fPIC"`, which
translates to whatever the compiler is followed by a space followed by `-fPIC`
but without the `'`s it was incomplete and so would not compile. Cody didn't
have a chance to really look at the compiler error.
[Yusuke](#yusuke) suggested that one should use `-ldl` in the Makefile. This was not
originally done because it seemed to work but since it uses `dlsym()` it was
added later to make it more portable.
The program creates files in the working directory as part of how it works (see
the index.html file for details) so Cody made sure that `make clobber` (via `make
clean`) removes those files and so that they are ignored by `.gitignore`.
Jump to: [top](#)
## Winning entry: [2014/vik](2014/vik/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/vik//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2014/vik/try.sh) script. Cody notes that there
is a bug that will show itself as one of the features does not work right. The
translation of the raw audio to text is buggy in some cases.
Cody also added an alternate version that is based on the author's remarks that will
theoretically work for Microsoft Windows compilers (if anything works in Windows
:-) ). We have no way of testing this and if anything has changed since 2014
that would break it we do not know.
Jump to: [top](#)
## Winning entry: [2014/wiedijk](2014/wiedijk/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2014/wiedijk//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2014/wiedijk/try.sh) script which is based on
the command to try in the 'try' section but improved so one can more easily
specify what `indent` tool they want to use and also change which `sed(1)` to use,
should they want to. It also checks that both of these two tools exist and are
executable and it pipes it through `less(1)` as it's longer than a page worth of
output.
Jump to: [top](#)
# [2015 - The 24th IOCCC](2015/index.html)
Jump to: [top](#)
## Winning entry: [2015/burton](2015/burton/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/burton//prog.c)
[Cody](#cody) fixed the code so one can make use of the echo feature, where the
first character of the filename starts with `e`. The only way it would work
before that is if one did something like:
```
ln -sf prog eprog
PATH=$PATH:. ; eprog '...'
```
since otherwise the first character would not be `e` but rather a dot
(`./eprog`). This was done by adding to the `Makefile` `-include libgen.h` and
adding to `main()` after the variable declaration (`V*A;`) the code:
```
*K=basename(*K);
```
This was done for both the [prog.c](%%REPO_URL%%/2015/burton/prog.c) and
[prog.alt.c](%%REPO_URL%%/2015/burton/prog.alt.c). The `Makefile` was also updated to build
`eprog` and `eprog.alt` to make use of the feature more easily. Each is a new
target (first in `TARGET` and second in `ALT_TARGET`) which have a prerequisite
of `${PROG}` and `${PROG}.alt` respectively both of which also copy the `prog`
(`prog` or `eprog`) to the respective `eprog` (`eprog` or `eprog.alt`). With
these changes now one can easily use the echo feature the author implemented.
Cody also added the [try.sh](%%REPO_URL%%/2015/burton/try.sh) script. This involved
adding a text file, [try.this.txt](2015/burton/try.this.txt).
Cody also added [calc.1](%%REPO_URL%%/2015/burton/calc.1) in place of `calc.man` to have
proper formatting (in the style of `man(1)`). The `calc.man` was removed so as
to not have to maintain two copies of the same text.
Cody updated the `Makefile` to copy the `prog` to `calc` and `prog.alt` to
`calc.alt`. `ecalc` and `ecalc.alt` also work. This is because the program is
called `calc` and is in documentation including the man page. Thus one only need
add a `./` to the commands in the man page/index.html.
Jump to: [top](#)
## Winning entry: [2015/dogon](2015/dogon/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/dogon//prog.c)
[Cody](#cody) improved the `Makefile` so that one can easily change the dimensions
at compilation time via `make(1)`.
Cody also added [alternate code](2015/dogon/index.html#alternate-code) that is
based on the author's remarks, suggesting that one change the value of `q` to a
different number, in order to see a bug that they avoided.
Jump to: [top](#)
## Winning entry: [2015/duble](2015/duble/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/duble//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/duble/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/endoh2](2015/endoh2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/endoh2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/endoh2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/endoh3](2015/endoh3/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/endoh3//prog.c)
[Cody](#cody) fixed this to compile with Linux which was having a problem with duplicate
symbols of `main()`. The fix is through the compiler option `-fcommon` which
will let it compile like it does with macOS.
Cody also added the [try.sh](%%REPO_URL%%/2015/endoh3/try.sh) script which makes
use of the make rule he added (to enjoy the theme of the entry, [Back to the
Future](https://en.wikipedia.org/wiki/Back_to_the_Future) using this entry by
simply typing `make back_to`, `make future` or `make mullender`) and then runs
the famous [1984/mullender.c](%%REPO_URL%%/1984/mullender/mullender.c).
Jump to: [top](#)
## Winning entry: [2015/endoh4](2015/endoh4/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/endoh4//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/endoh4/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/hou](2015/hou/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/hou//prog.c)
[Cody](#cody) added explicit linking of libm (`-lm`) for systems that do not do this
(Linux doesn't seem to but macOS does).
Cody also added the [try.sh](%%REPO_URL%%/2015/hou/try.sh) script and the large file `large`
which the `try.sh` script uses.
Cody also added the RFC 1321 text file, [rfc1321.txt](2015/hou/rfc1321.txt) to
the directory, to make it so one need not download it, and which the index.html
file now links to.
Jump to: [top](#)
## Winning entry: [2015/howe](2015/howe/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/howe//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/howe/try.sh) script, downloaded the War
and Peace text file, fixed the [avgtime.sh](%%REPO_URL%%/2015/howe/avgtime.sh) script (it
resulted in standard input errors in piping to `bc(1)`) and added the
[cc.1](%%REPO_URL%%/2015/howe/cc.1) man page as not all systems have it (in fact it's
`gcc(1)` from Rocky Linux).
The author, [Anthony C Howe](authors.html#Anthony_C_Howe), provided an
unobfuscated version that Cody added in, with thanks to Anthony! As the author
had already provided an alternate version (which was actually the original
entry), this was put in [prog.alt2.c](%%REPO_URL%%/2015/howe/prog.alt2.c). This
addition prompted the [try.alt.sh](%%REPO_URL%%/2015/howe/try.alt.sh) script.
The fact there are alternate versions necessitated the
[prog.alt-test.sh](%%REPO_URL%%/2015/howe/prog.alt-test.sh) which Cody added as
well.
Jump to: [top](#)
## Winning entry: [2015/mills1](2015/mills1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/mills1//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/mills1/try.sh) script which changes the
parameters to what we had in the judges' remarks to make it easier.
Jump to: [top](#)
## Winning entry: [2015/mills2](2015/mills2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/mills2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/mills2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/muth](2015/muth/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/muth//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2015/muth/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/schweikhardt](2015/schweikhardt/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/schweikhardt//prog.c)
[Cody](#cody) fixed the build so that `EOF` will be `-1` as the program assumes
this. It was decided by Cody to do `-UEOF -DEOF=-1` so as to not have to modify
the code any with C preprocessor directives (the preferred way) or changing
`EOF` to `-1`.
Cody also added the [try.sh](%%REPO_URL%%/2015/schweikhardt/try.sh) script.
Jump to: [top](#)
## Winning entry: [2015/yang](2015/yang/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2015/yang//prog.c)
[Cody](#cody) fixed an unfortunate typo in the `Makefile` that was preventing some of the
files from compiling properly, trying instead to compile already compiled code.
He also added explicit linking of libm (`-lm`) for systems that do not do this
(Linux seems to not but macOS does).
He also added the [try.sh](%%REPO_URL%%/2015/yang/try.sh) script.
Jump to: [top](#)
# [2018 - The 25th IOCCC](2018/index.html)
[Cody](#cody) added the missing `README.md` file from the winner archive back to
the repo.
Jump to: [top](#)
## Winning entry: [2018/anderson](2018/anderson/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/anderson//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/anderson/try.sh) and
[try.alt.sh](%%REPO_URL%%/2018/anderson/try.alt.sh) scripts.
Jump to: [top](#)
## Winning entry: [2018/algmyr](2018/algmyr/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/algmyr//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/algmyr/try.sh) script.
Jump to: [top](#)
## Winning entry: [2018/bellard](2018/bellard/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/bellard//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/bellard/try.sh) script.
Cody also, out of abundance of caution, added a second arg to `main()` because
some versions of `clang` object to the number of args of `main()`, saying that it
must be 0, 2 or 3. The version this has been observed in does not actually
object to 1 arg but it is entirely possible that this changes so a second arg
(that's not needed and is unused) has been added just in case. See the
FAQ on "[main function args](faq.html#arg_count)"
for more details.
Cody also added explicit linking of libm (`-lm`) for systems that do not do this
(Linux doesn't seem to but macOS does).
Cody also added [alternate code](2018/bellard/index.html#alternate-code) that should
work for Windows, based on the author's remarks. The same thing with the number
of args to `main()` that was done in the original entry was done with this
version as well.
Jump to: [top](#)
## Winning entry: [2018/burton1](2018/burton1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/burton1//prog.c)
[Cody](#cody) fixed the [scripthd.sh](%%REPO_URL%%/2018/burton1/scripthd.sh)
script (it referred to `prog` not `./prog`).
Cody also added the [try.sh](%%REPO_URL%%/2018/burton1/try.sh) script which also uses
`scripthd.sh` to show how it differs from `prog` itself.
Jump to: [top](#)
## Winning entry: [2018/burton2](2018/burton2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/burton2//prog.c)
[Cody](#cody) fixed the `make test` rule: it tried to run `tac(1)` (in systems
that have that command) rather than the entry itself which is called `tac`. Also
the [runtest.sh](%%REPO_URL%%/2018/burton2/runtest.sh) script was not executable.
Cody also made the man page properly formatted for `man(1)` and renamed it the
file `tac.1`.
Cody also added the [tokcount.sh](%%REPO_URL%%/2018/burton2/tokcount.sh) script which was
included in the remarks of the author but not an included file.
Finally Cody added the [try.sh](%%REPO_URL%%/2018/burton2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2018/ciura](2018/ciura/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/ciura//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/ciura/try.sh) and
[try.alt.sh](%%REPO_URL%%/2018/ciura/try.alt.sh) scripts and the PDF file,
[lexicon.pdf](2018/ciura/lexicon.pdf), that was a dead link, restored from the
Internet Wayback Machine.
Jump to: [top](#)
## Winning entry: [2018/endoh1](2018/endoh1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/endoh1//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/endoh1/try.sh) script which shows the
input files one at a time and after each one is shown, it feeds it to the
program, redirecting the output to the respective GIF file. It then will inform
the user they should open it in a GIF viewer that can show animation in animated
GIF files. It offers an example command for macOS like the judges did in their
remarks. The input files offered includes the `prog.c` as the author,
[Yusuke](#yusuke), suggested that it too has a secret.
Jump to: [top](#)
## Winning entry: [2018/endoh2](2018/endoh2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/endoh2//prog.c)
[Cody](#cody) fixed the [run.sh](%%REPO_URL%%/2018/endoh2/run.sh) script (had commands that didn't
exist and also didn't work even after that was addressed) and added the
[try.sh](%%REPO_URL%%/2018/endoh2/try.sh), [python.sh](%%REPO_URL%%/2018/endoh2/python.sh) and
[python3.sh](%%REPO_URL%%/2018/endoh2/python3.sh) scripts. The `try.sh` script runs all
three of the other scripts but each allows one to send an interrupt in the loops
and still continue to the next script (if one does it when not in a loop it will
exit the script). The `make python` and `make python3` rules in the `Makefile` now
run the respective scripts.
Jump to: [top](#)
## Winning entry: [2018/hou](2018/hou/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/hou//prog.c)
[Cody](#cody) added explicit linking of libm (`-lm`) for systems that do not do this
(Linux doesn't seem to but macOS does).
Cody also added the [try.sh](%%REPO_URL%%/2018/hou/try.sh) script.
Jump to: [top](#)
## Winning entry: [2018/mills](2018/mills/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/mills//prog.c)
[Cody](#cody), based on the author's remarks, made it possible to save state
between runs of the program so that one can resume where they left off. It
should be noted that there is a bug in the entry (irrespective of save state
option) where running `./prog` twice in a row involves having to hit (the second
run) enter and then exit and then start the program again. Also if you do add a
file you should run `sync` prior to exiting or else the file might not exist or
it might be corrupt. See [2018/mills in bugs.html](bugs.html#2018_mills) for more
details on the bug.
Jump to: [top](#)
## Winning entry: [2018/poikola](2018/poikola/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/poikola//prog.c)
[Cody](#cody) added the missing `docs` rule to the `Makefile` that forms a PDF
file. The rule requires the tool `pdflatex`.
Cody also added the [try.sh](%%REPO_URL%%/2018/poikola/try.sh) script.
[Dave Burton](authors.html#Dave_Burton), during the preview period, noticed a
problem where the macOS `Terminal.app` does not work properly for this program.
We added some additional notes on what might happen (it varies depending on
configuration).
Jump to: [top](#)
## Winning entry: [2018/vokes](2018/vokes/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/vokes//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/vokes/try.sh) script.
Jump to: [top](#)
## Winning entry: [2018/yang](2018/yang/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2018/yang//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2018/yang/try.sh) script. This script will ask
if the user wants to see some of the deobfuscation information and only show them if they type
`y` or `Y`.
Jump to: [top](#)
# [2019 - The 26th IOCCC](2019/index.html)
Jump to: [top](#)
## Winning entry: [2019/adamovsky](2019/adamovsky/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/adamovsky//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/adamovsky/try.sh) script and the Unlambda
file [crash.unl](%%REPO_URL%%/2019/adamovsky/crash.unl) which is in the judges' remarks as
to what can crash it - but it's not a bug, it's a feature.
Jump to: [top](#)
## Winning entry: [2019/burton](2019/burton/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/burton//prog.c)
[Cody](#cody) fixed the `Makefile` which had a bad character, a `%` instead of a `$` which
caused a rule to fail.
Cody also added the [try.sh](%%REPO_URL%%/2019/burton/try.sh) script which shows a
side-by-side comparison on several files of the entry and `wc(1)` as well as
running `make test`.
Cody also fixed the script [check.sh](%%REPO_URL%%/2019/burton/check.sh) in case
`x` is specified and is not executable and also made it satisfy ShellCheck.
ShellCheck was fixed to not be a [cow](https://en.wikipedia.org/wiki/Cattle)
and/or (to use [Bart Simpson](https://simpsons.fandom.com/wiki/Bart_Simpson)'s
advice :-) ) '[not have a
cow](https://en.wikipedia.org/wiki/Don%27t_have_a_cow)' about certain things
(including one thing it was wrong about) in
[cow.sh](%%REPO_URL%%/2019/burton/cow.sh) mootoo.
Jump to: [top](#)
## Winning entry: [2019/ciura](2019/ciura/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/ciura//prog.c)
[Cody](#cody) fixed an invalid bytes error in `tr` in the scripts. This does not
mean that they will produce any output, though, as they expect all
letters and that makes it harder to form perfect pangrams. On the subject of
German umlauts and Eszett (ß) see the [2019/ciura in bugs.html](bugs.html#2019_ciura).
Cody also fixed the `Makefile` so that the alternate code would be built when running
`make alt`.
Cody converted the PS file linked to by the author to a PDF,
[fasc5c.pdf](2019/ciura/fasc5c.pdf), and added it to the
website.
Cody also added the [try.sh](%%REPO_URL%%/2019/ciura/try.sh) and
[try.alt.sh](%%REPO_URL%%/2019/ciura/try.alt.sh) scripts.
Finally he added the scripts for the different languages that use the alternate
version but with the caveat that only English appears to work. Again, see [2019/ciura in
bugs.html](bugs.html#2019_ciura) for more details.
Jump to: [top](#)
## Winning entry: [2019/diels-grabsch1](2019/diels-grabsch1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/diels-grabsch1//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/diels-grabsch1/try.sh) script.
Cody also added the file [Shakespeare.txt](2019/diels-grabsch1/Shakespeare.txt)
from [2019/mills](2019/mills/index.html) (after running `make`) so that one can
not worry about having the entire IOCCC winning entry tree (or at least the 2019
tree). This was important as we now have tarballs for each entry by themselves.
Jump to: [top](#)
## Winning entry: [2019/diels-grabsch2](2019/diels-grabsch2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/diels-grabsch2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/diels-grabsch2/try.sh)
script. This script will try and show the difference (i.e. the same output)
between the program and the result of `sha512sum` or `shasum -a 512`, if these
tools can be found, or otherwise just run the program itself, showing its own
[sha512](https://en.wikipedia.org/wiki/SHA-2) value.
Jump to: [top](#)
## Winning entry: [2019/dogon](2019/dogon/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/dogon//prog.c)
[Cody](#cody) added explicit linking of libm (`-lm`) for systems that do not do this
(Linux does not seem to but macOS does).
He also fixed the `Makefile` so that it compiles with `clang` in Linux.
He also added the [try.sh](%%REPO_URL%%/2019/dogon/try.sh) script.
He also made it possible to easily redefine the memory macro `Z` at compilation
time by improving the `Makefile`.
He fixed a link in the deobfuscation source code. It felt more important
that this was done (some typos were fixed as well but only some - the purpose
was to only correct spelling and only some, not to change wording or anything
else).
Jump to: [top](#)
## Winning entry: [2019/duble](2019/duble/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/duble//prog.c)
[Cody](#cody) made the `make fullscreen` more portable by not relying on
`stty(1)` and `sed(1)` but rather it just uses `tput(1)`. He also made it so
that if `tput(1)` is not found it tells the user an easier way to compile the full
screen size rather than having to modify the `Makefile`. This is done with a script,
[fullscreen.sh](%%REPO_URL%%/2019/duble/fullscreen.sh), to simplify the `Makefile` and provide
an easy way to tell the user how to compile it, assuming that the environmental
variables `LINES` and `COLUMNS` are set. But even if they're not set it explains
how to easily compile the program to a specific size. Note that `LINES` and
`COLUMNS` is not available to scripts so it can't make use of them that way.
Jump to: [top](#)
## Winning entry: [2019/endoh](2019/endoh/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/endoh//prog.c)
As this is a backtrace quine having the optimiser enabled is not a good idea so
[Cody](#cody) disabled it. For this same reason he also added the `-g` flag to the
compilation as debugging symbols might just be useful for an entry that's
supposed to segfault (and which you're supposed to inspect the core file) :-)
Cody also added the simple [ascii.c](%%REPO_URL%%/2019/endoh/ascii.c) that (while it has an
arg) prints out the character of the ASCII value (uses `isascii(3)` first). This
combined with the [try.sh](%%REPO_URL%%/2019/endoh/try.sh) script that he added allows one
to easily reconstruct the source code through GDB by the fact it's a backtrace
quine.
Jump to: [top](#)
## Winning entry: [2019/giles](2019/giles/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/giles//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/giles/try.sh) script.
Jump to: [top](#)
## Winning entry: [2019/karns](2019/karns/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/karns//prog.c)
[Cody](#cody) forced the `Makefile` to use `-O0` as he discovered that an
optimiser level > 0 causes a segfault (sometimes?). (Perhaps this is the problem
that the author reported where it sometimes segfaults but Cody did not try
debugging it since it works with `-O0`.)
He also added the script [try.sh](%%REPO_URL%%/2019/karns/try.sh) to showcase the entry a
bit more easily.
Jump to: [top](#)
## Winning entry: [2019/lynn](2019/lynn/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/lynn//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/lynn/try.sh) script.
Cody also added the [example-1.txt](2019/lynn/example-1.txt) and
[example-2.txt](2019/lynn/example-2.txt) text files from
[2018/vokes](2018/vokes/index.html) so that the entry does not rely on any other
entry existing.
Jump to: [top](#)
## Winning entry: [2019/mills](2019/mills/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/mills//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/mills/try.sh) script.
Jump to: [top](#)
## Winning entry: [2019/poikola](2019/poikola/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/poikola//prog.c)
[Cody](#cody) added the missing `docs` rule to the `Makefile` that forms a PDF
file. The rule requires the tool
[pdflatex](https://tug.org/applications/pdftex/index.html).
Cody also added the [alternate code](2019/poikola/index.html#alternate-code) which
adds a newline after each number for parsing in additional ways. See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Cody also added the [try.sh](%%REPO_URL%%/2019/poikola/try.sh) and
[try.alt.sh](%%REPO_URL%%/2019/poikola/try.alt.sh) scripts.
Cody also disabled the optimiser because the author stated that for `clang` the
levels `[0123s]` work okay but with `GCC` version 6 they only said level 0 works,
suggesting that with some versions of `GCC` it might not be correct with levels !=
0 and since 0 works with `clang` that's okay. Similarly, the same for C standards
tested: `gnu17` was not tested but `gnu11` was so the standard was set to
`gnu11`.
Jump to: [top](#)
## Winning entry: [2019/yang](2019/yang/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2019/yang//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2019/yang/try.sh) script which also involved
slightly updating the [sample_input.txt](2019/yang/sample_input.txt) file
(removed trailing newlines as it resulted in `diff` showing differences when it
shouldn't) and adding the [ioccc.txt](2019/yang/ioccc.txt) file.
Jump to: [top](#)
# [2020 - The 27th IOCCC](2020/index.html)
Jump to: [top](#)
## Winning entry: [2020/burton](2020/burton/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/burton//prog.c)
[Cody](#cody) fixed the script [check_be.sh](%%REPO_URL%%/2020/burton/check_be.sh): it
assumed that `prog_be` was in `PATH` which is unlikely so it was changed to
`./prog_be`.
Cody also improved the `make test` rule (which uses `check_be.sh` and the Little
Endian counterpart) so that it shows that the files are identical rather than
showing nothing at all.
Cody also added the [try.sh](%%REPO_URL%%/2020/burton/try.sh) script.
Jump to: [top](#)
## Winning entry: [2020/carlini](2020/carlini/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/carlini//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/carlini/try.sh) script which although at
first glance might not appear to have a point, it actually does, namely showing
how you can automate play and then reminding you to actually play for real, with
a friend, whether that's real or imagined.
Jump to: [top](#)
## Winning entry: [2020/endoh2](2020/endoh2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/endoh2//prog.c)
[Cody](#cody) copied the files from the `spoiler.zip` file (from his copy during
the preview period) that was password protected with a password that was no
longer known (but fortunately was already extracted). These files, originally
put in `spoiler/` were moved to
[obfuscation/](2020/endoh2/obfuscation/index.html).
He also added the [try.sh](%%REPO_URL%%/2020/endoh2/try.sh) script.
Jump to: [top](#)
## Winning entry: [2020/endoh3](2020/endoh3/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/endoh3//prog.c)
[Cody](#cody) fixed the script [run_clock.sh](%%REPO_URL%%/2020/endoh3/run_clock.sh) which gave a
funny error when running it:
```
$ ./run_clock.sh
-bash: ./run_clock.sh: cannot execute: required file not found
```
If run from within vim a different error message occurred:
```
/bin/bash: ./run_clock.sh: /usr/bin/end: bad interpreter: No such file or directory
```
though this was only noticed later on after it was fixed.
What was wrong? A typo in the shebang which had `/usr/bin/end` instead of
`/usr/bin/env`.
Also if `clock` did not exist and one tried to run the script it would make an
invalid `clock.c` which meant it could not compile so it now runs `make clock`
first.
Cody also reported (during the preview period of 2020) for some systems (at some
point?) like macOS the use of `make clock` would not work due possibly to a
timing issue so [Yusuke](#yusuke) changed it to compile `clock.c`
file directly (this might have been fixed in the
`Makefile` later on but it doesn't hurt to keep it in and this way it isn't a
problem in any system).
Cody also added the [run_clock.alt.sh](%%REPO_URL%%/2020/endoh3/run_clock.alt.sh) script
which is analogous to the [run_clock.sh](%%REPO_URL%%/2020/endoh3/run_clock.sh) but for the
alternate code provided by the author, Yusuke.
Jump to: [top](#)
## Winning entry: [2020/giles](2020/giles/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/giles//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/giles/try.sh) script. This script does
the conversion of `pi.wav` (showing the digits) and also converts the number for
`jenny.wav` and a number Cody 'came up with': one that resembles `IOCCC 28`:
`10666-28`. The `6` is the closest to `C` in his head even though it's not
perfect.
If `play(1)` from SoX is not installed the script checks for `aplay(1)`. If
neither are installed it warns the user about this, linking to the FAQ about it,
and tells them they will have to play the WAV files manually. Otherwise it'll
use the program to play the WAV files (and in one case `stdout`).
Jump to: [top](#)
## Winning entry: [2020/kurdyukov1](2020/kurdyukov1/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/kurdyukov1//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/kurdyukov1/try.sh) script.
Jump to: [top](#)
## Winning entry: [2020/kurdyukov2](2020/kurdyukov2/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/kurdyukov2//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/kurdyukov2/try.sh) script.
Cody also added `-L`/`-I` paths to the `Makefile` to let this compile more easily if
the user has installed the appropriate library with
[MacPorts](https://www.macports.org) (with the default MacPorts prefix
`/opt/local`).
Cody also fixed the script [makegif.sh](%%REPO_URL%%/2020/kurdyukov2/makegif.sh) in a variety
of ways: `shellcheck(1)`, make sure the program is compiled first (allowing one to
specify which compiler to use with `CC=foo ./makegif.sh ...`), checking that
`convert(1)` is found and that it worked properly (linking to the proper FAQ
entry if not installed or it fails).
Jump to: [top](#)
## Winning entry: [2020/kurdyukov3](2020/kurdyukov3/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/kurdyukov3//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/kurdyukov3/try.sh) script.
He also added a link that has much more details about this phenomenon to the
index.html.
Jump to: [top](#)
## Winning entry: [2020/kurdyukov4](2020/kurdyukov4/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/kurdyukov4//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/kurdyukov4/try.sh) script.
Cody also added from [2019/mills](2019/mills/index.html) the text file
[Shakespeare.txt](2020/kurdyukov4/Shakespeare.txt) as we now provide a tarball
of each entry by itself.
Also, as a fellow Tolkienist, to explain the confusing (to most people) award
title, Cody gave a quick translation of `lámatyávë`, which comes from [Morgoth's
Ring](https://en.wikipedia.org/wiki/Morgoth%27s_Ring), volume X of the 12
volume [History of
Middle-earth](https://en.wikipedia.org/wiki/The_History_of_Middle-earth) (known
to us Tolkienists as `HoMe`), which he naturally :-) has, by the late and great
[Christopher Tolkien](https://en.wikipedia.org/wiki/Christopher_Tolkien), son
and literary executor and heir to [J.R.R.
Tolkien](https://www.tolkienestate.com/life/biography/).
Jump to: [top](#)
## Winning entry: [2020/otterness](2020/otterness/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/otterness//prog.c)
[Cody](#cody) added the MIDI files [cvikl.mid](2020/otterness/cvikl.mid) and
[entertainer.mid](2020/otterness/entertainer.mid) from the URLs we suggested so
that one need not download them and to make sure they can always be obtained
even if the domain or link goes dead.
Cody also added the [try.sh](%%REPO_URL%%/2020/otterness/try.sh) script and the
[try.alt.sh](%%REPO_URL%%/2020/otterness/try.alt.sh) script for the author's
unobfuscated version that Cody added as
[prog.alt.c](%%REPO_URL%%/2020/otterness/prog.alt.c).
Jump to: [top](#)
## Winning entry: [2020/tsoj](2020/tsoj/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/tsoj//prog.c)
[Cody](#cody) added [alternate code](2020/tsoj/index.html#alternate-code) that will feel
more at home for vi users. One might still end up cursing (see the index.html
file) but probably a lot less :-) See the
FAQ on "[alternate code](faq.html#alt_code)"
for more details.
Jump to: [top](#)
## Winning entry: [2020/yang](2020/yang/index.html)
### Winning entry source code: [prog.c](%%REPO_URL%%/2020/yang//prog.c)
[Cody](#cody) added the [try.sh](%%REPO_URL%%/2020/yang/try.sh) script.
Cody also added a make rule (`make cppp`) for the author's provided C++ code
that can pre-process the generated output to make them more acceptable to typical
compilers. See the index.html for more details.
Jump to: [top](#)
# [2020 - The 28th IOCCC](2024/index.html)
Jump to: [top](#)
# General thanks
Jump to: [top](#)
## Makefiles fixes and improvements
[Cody](#cody) fixed the top level `Makefile` `all` rule which had a stray `fi;`
without an `if` so the rule failed entirely.
Cody also made a variety of other changes in all the Makefiles, sometimes to get
an entry to work, all noted above, but he also **improved them all** in at least
one or two ways. Some of the changes made are below.
Cody changed the `LIBS` variable to `LDFLAGS` as that is the standard
variable. This simplifies compiling without having to modify the `Makefile` which
can be useful if something changes or if someone is trying to fix an entry but
forgets to change the `Makefile` or even if they don't want to make a change due
to a temporary test. These would of course depend on the compiler invocation but
since `LDFLAGS` is standard it is more likely to be used by default so no need
to check the Makefiles.
Sometimes there were bad characters or rules that caused the entry to fail to
compile or not work in some way. These are noted above as well.
Where useful he added some notes to the Makefiles during compilation to let one
know of certain problems or features that matter for instance having to disable
the optimiser or in one case enabling `-g`.
Also, rather than check `${CC}` for exact matches of `gcc` or `clang` it now is
that if `${CC}` contains `gcc` or contains `clang` then the specific actions
related to the specific compiler will be done (priority is `gcc` then `clang`). This
is useful because it's not guaranteed that the compiler names for `gcc` or
`clang` will be exactly that; in macOS for instance it can happen that they are
in fact different names especially if one installs them from something like
[MacPorts](https://www.macports.org) or possibly [Homebrew](https://brew.sh).
There were some other fixes as well including mass typo fixes in the Makefiles
(though that usually does not mean it is worth a thank you note it might be
worth noting in this case). Other times it was enabling or disabling the
optimiser to fix an entry, sometimes causing other problems that also had to be
fixed, a good example being [1986/marshall](#1986_marshall) (see the
[compilers.html](1986/marshall/compilers.html) for the amusing details and all that
had to be done to fix it).
Some comments were fixed or added where it was deemed useful.
Jump to: [top](#)
## Consistency improvements
[Cody](#cody), being the IOCCC's resident corrections officer :-) (and a fine one at
that, we think :-) ), made many, many typo fixes throughout the
README.md files, scripts, other data files, Makefiles (see above) etc.
He also updated the formatting of the README.md files, used to generate the
index.html files, after renaming the old files to README.md, as well as changing
some other files to markdown as well as format fixing them.
Where possible he made the presentation of the entries much more consistent
across the entries of all the years as well as other files. This is not possible
for everything (the remarks of authors, for instance, cannot be and should not
be made consistent but adding markdown where necessary in the remarks is).
Jump to: [top](#)
## Try script system
[Cody](#cody) devised the `try` script system (which we now use as part of
judging) and added the many `try.sh`, `try.alt.sh` and various other forms, as
well as a number of wrapper scripts to more easily run programs. It is not
always useful but these scripts do a variety of things to really show off the
entries, so this really helps with the presentation of the winning entries.
Cody also added the example scripts for future submitters,
[try.sh](%%REPO_URL%%/next/try.sh) and
[try.alt.sh](%%REPO_URL%%/next/try.alt.sh).
Jump to: [top](#)
## Website and manifest improvements
[Cody](#cody) helped in many ways to make the website much more presentable by:
- converting old hints files to README.md files (fixing problems in the process)
- converting other files to markdown
- extending / improving the stylesheet
- fixing many different kinds of problems in many files
- writing a few [website scripts](bin/index.html), improving a few others,
identifying bugs in some and fixing bugs in others
- co-developing the JSON parser [jparse](https://github.com/xexyl/jparse) and
tools (that the [mkiocccentry repo](https://github.com/ioccc-src/mkiocccentry) clones)
with us, as we now make extensive use of JSON for the website
- greatly improving the manifest of the winning entries so that the links to the
files in the index.html files make more sense and are consistent (although it
might be said that some of them will not make sense if you don't understand the
entry or at least do not read the index.html file)
Jump to: [top](#)
## FAQ improvements
[Cody](#cody) greatly extended the FAQ to include much more information and he
helped reorganise it as well, from the new `faq.md` file that he started.
Jump to: [top](#)
## Thank you honor roll
There are a number of people who have contributed to **many many
changes**, fixes and **many important improvements** that we
wish to **especially thank**.
Jump to: [top](#)
### Authors
A good number of the [winning authors of the
IOCCC](authors.html) tested, identified and helped correct
and/or improve the write-ups of fellow IOCCC entries for the year that they won.
The list of those entries is too long to mention: nevertheless the [IOCCC
judges](judges.html) **VERY MUCH APPRECIATE** those who
helped improve the presentation of their fellow IOCCC entries.
Jump to: [top](#)
### John Dalbec
[John Dalbec](authors.html#John_Dalbec) supplied a fix to
[2000/dlowe](thanks-for-help.html#2000_dlowe).
[John Dalbec's patch of 2000/dlowe](%%REPO_TOP_URL%%/pull/134)
is a good example of [applying a minimal patch](bugs.html#general-request-on-original-code)
to the [original 2000/dlowe](%%REPO_URL%%/2000/dlowe/dlowe.orig.c) source code.
Jump to: [top](#)
### Yusuke Endoh
[Yusuke Endoh](authors.html#Yusuke_Endoh) supplied a
number of important bug fixes to a number of past IOCCC entries, including
**fixing _numerous entries_ that no longer worked**. Some of those
fixes were **EXTREMELY TECHNICALLY CHALLENGING**, like
[1989/robison](thanks-for-help.html#1989_robison),
[1990/cmills](thanks-for-help.html#1990_cmills),
[1992/lush](thanks-for-help.html#1992_lush) and
[2001/ctk](thanks-for-help.html#2001_ctk). **THANK YOU VERY MUCH** for
your help!
Jump to: [top](#)
### Cody Boone Ferguson
We call out the extensive contributions of [Cody Boone
Ferguson](authors.html#Cody_Boone_Ferguson) who is responsible for many
improvements and fixes, including fixing many [entries that no longer
worked](faq.html#unsupported),
often **EXTREMELY HARD** (for certain
definitions of '`HARD`' :-) ), such as
[1988/phillipps](thanks-for-help.html#1988_phillipps),
[2001/anonymous](thanks-for-help.html#2001_anonymous) and
[2004/burley](thanks-for-help.html#2004_burley); fixing entries like
[1985/sicherman](thanks-for-help.html#1985_sicherman) to
not need `-traditional-cpp`; fixing
entries like [1991/dds](thanks-for-help.html#1991_dds) to work with
[clang](faq.html#clang) (or, as in the case of
[1989/westley](thanks-for-help.html#1989_westley), a true masterpiece in
obfuscation, as much as possible); porting entries like
[1998/schweikh1](thanks-for-help.html#1998_schweikh1) to
[macOS](faq.html#macos_compile); fixing entries like
[2001/herrmann2](thanks-for-help.html#2001_herrmann2) to work with [32 and 64-bit](faq.html#32bit); providing [alt code](faq.html#alt_code) where useful/needed; improving all [Makefiles](#makefiles); devising the [try scripts](#try) which we now use as part of judging; and other important fixes.
Cody Boone Ferguson also used one of his own tools to detect many dead links.
While the tool was not perfect it went a long way to uncover a good number of
bad, broken or otherwise invalid links. It was a very laborious task to copy and
paste problematic links into the [Internet Wayback
Machine](https://web.archive.org) in an effort to try and find otherwise lost
content. A good number of links that now refer to something in the [Internet
Wayback Machine](https://web.archive.org) replace bad, broken, or otherwise
invalid links are thanks to Cody's efforts! Another tool he wrote detected
inconsistent award titles in the `README.md` files (that we use to generate
`index.html` files) and the CSV file that he generated from our SQL file.
He also wrote the feature-rich [sgit](https://github.com/xexyl/sgit) to easily
run `sed(1)` on specified files under git that we sometimes use to edit the
website, greatly improved the manifests and checked that the generated html
files look good and are presentable, suggested CSS rules for
image responsiveness (and made other CSS improvements) and he greatly improved the FAQ.
Cody also wrote some [website scripts](bin/index.html), improved and
fixed others, co-developed the [JSON parser and tools](https://github.com/xexyl/jparse) with
us, as we now make extensive use of JSON, and helped test/fix the submit
server and mailing list for IOCCC28 and beyond.
**THANK YOU VERY MUCH** for your extensive efforts in helping improve the IOCCC
presentation of past IOCCC entries, fixing many entries that no
longer worked and getting the IOCCC where it is today!
Jump to: [top](#)
### Anthony C Howe
[Anthony C Howe](authors.html#Anthony_C_Howe) is the author of the
[original iocccsize(1) tool](https://github.com/SirWumpus/iocccsize) and its
revisions (which he's constantly reminding everyone like he made
some Earth shattering invention on par with toilet paper 🧻 - silly `git(1)` 🤓).
Anthony likes to troll 👹 here and there, finding ~~obsecure~~
obfuscated bugs, and making crazy suggestions that we sometimes
accept. As an advocate for BSD style Unix platforms, we owe
him a **THANK YOU** for helping maintain BSD portability
of the [mkiocccentry toolkit](https://github.com/ioccc-src/mkiocccentry).
As an [IOCCC winning author](authors.html#Anthony_C_Howe) from [Canada](location.html#CA),
he enjoys the privilege of not being required to add, ™ Canada 🇨🇦, when he says "Sorry" 😉.
And if all that is not enough, Anthony has supplied fixes for:
* [1989/tromp](thanks-for-help.html#1989_tromp)
Despite all that, we still welcome him as an IOCCC Helper!
Jump to: [top](#)
### Joel Yliluoma
**Joel Yliluoma** rendered a [pointillism image](2024/endoh1/index.html#larger) of
[1024x1024 size](2024/endoh1/endoh1-1024.png), and of a
[2048x2048 size](2024/endoh1/endoh1-2048.png).
We thank **Joel Yliluoma** of **Finland** for making the effort to render these images!
- Github: [http://github.com/bisqwit](http://github.com/bisqwit)
- Home Page: [https://iki.fi/bisqwit/](https://iki.fi/bisqwit/)
- YouTube: [https://youtube.com/c/Bisqwit](https://youtube.com/c/Bisqwit)
Jump to: [top](#)
## Did we neglect to credit you?
If you submitted a fix to an entry for which you are not the author,
and your fix is accepted (in part or as a whole), we would be happy
to add you to this [thanks for the help](thanks-for-help.html) file.
If you believe we incorporated one of your fixes to an IOCCC winning entry (that you
are not the author of) for which we neglected to mention in this file, please
[contact the IOCCC](contact.html) so that we may correct the record.
Jump to: [top](#)
The tattoo was done in 2005 by [Thomas
Scovell](https://web.archive.org/web/20070120220721/https://thomasscovell.com/tattoo.php).
Jump to: [top](#)