fix Makefile, README.md, .gitignore and code for 2004/jdalbec

This commit is contained in:
Landon Curt Noll committed 2023-03-21 21:28:30 -07:00
1 parent 107dda6c85
commit f4449fbe07
4 files changed
+408 -432

No files matched your search

+2
View File
@@ -1 +1,3 @@
jdalbec
jdalbec2.c
jdalbec3.c
+270 -300
View File
@@ -1,362 +1,332 @@
#!/bin/make
#!/usr/bin/env make
#
# 2004 makefile
# IOCCC 2004 winning entry - jdalbec
################################################################################
#
# Copyright (C) 2004, Landon Curt Noll, Simon Cooper, Peter Seebach
# and Leonid A. Broukhis. All Rights Reserved. Permission for personal,
# educational or non-profit use is granted provided this copyright and
# notice are included in its entirety and remains unaltered. All other
# uses must receive prior permission from the contest judges.
# Regarding individual entries:
#
# IOCCC winning entry code may not work on your system. Even with standards,
# conditions and build environments change, especially when it comes to more
# extreme code such you might find in an IOCCC winner. Moreover, what was
# allowed and liked in one IOCCC contest may no longer be liked/allowed in
# later IOCCC years.
#
# Corrections on winning author and fixing typos in remarks are VERY WELCOME.
#
# GitHub pull requests are welcome:
#
# If you have a patch that might make running an entry work in modern Unix-like
# environments, please create a GitHub pull request for the IOCCC judges to
# consider.
#
# Suggestions and corrections regarding Makefiles, winning author information,
# fixing typos in remarks, and code patches are welcome via opening a GitHub
# issue or better yet, by creating a GitHub pull request for the IOCCC judges
# to consider. To form a GitHub issue or GitHub pull, please visit:
#
# https://github.com/ioccc-src/winner
#
################################################################################
# This work by Landon Curt Noll and Leonid A. Broukhis is licensed under:
#
# Creative Commons Attribution-ShareAlike 3.0 Unported License.
#
# See: http://creativecommons.org/licenses/by-sa/3.0/
# tool locations
#############################
# shell used by this Makefile
#############################
#
SHELL= /bin/sh
CP= cp
CPP= cpp
GUNZIP= gunzip
LD= ld
MAKE= make
RM= rm
SED= sed
TAR= tar
TRUE= true
SHELL= bash
# Special flags for the gavin entry
#######################
# common tool locations
#######################
#
# FYI: Older versions of GCC have a bug in -O2 optimization, hence -O1
#
GAVIN_OPT= -O1
GAVIN_FLAGS=\
'-DY(m)=*((int*)(m))'\
'-DE(f,a,b,c)=((G((*)))(f))(a,b,c)'\
'-DM=for(D=0;D<786432;D++)'\
'-DZ=int i=0,j=0,h,n,p=393728,s=26739,C,D'\
'-DV=0x90200'\
'-DK=0'\
'-DR=while((C=E(V-8,100,0,0))&3&&(D=E(V-8,96,0,0))|3){'\
'-DL(c,d)=E(V+8,100,c,0);R}E(V+8,96,d,0);R}'
include ../../var.mk
# Set X11_LIBDIR to the directory where the X11 library resides
#
X11_LIBDIR= /usr/X11R6/lib
#X11_LIBDIR= /usr/X11R6/lib
#X11_LIBDIR= /usr/X11/lib
X11_LIBDIR= /opt/X11/lib
#CINCLUDE= -I ${HOMEBREW_PREFIX}/include/SDL2
# Set X11_INCLUDEDIR to the directory where the X11 include files reside
#
#X11_INCDIR= /usr/X11R6/include
#X11_INCDIR= /usr/X11/include
X11_INCDIR= /opt/X11/include
# optimization
# Common C compiler warnings to silence
#
#CSILENCE=
CSILENCE= -Wno-int-to-pointer-cast -Wno-int-to-void-pointer-cast -Wno-trigraphs \
-Wno-unused-value
# Common C compiler warning flags
#
#CWARN= ${CSILENCE}
#CWARN= -Wall ${CSILENCE}
#CWARN= -Wall -Wextra ${CSILENCE}
CWARN= -Wall -Wextra -pedantic ${CSILENCE}
# Compiler standard
#
#CSTD=
CSTD= -ansi
#CSTD= -std=gnu99
# Compiler bit architecture
#
# Some entries require 32-bitness:
# ARCH= -m32
#
# Some entries require 64-bitness:
# ARCH= -m64
#
# By default we assume nothing:
#
ARCH=
# Defines that are needed to compile
#
CDEFINE=
#CDEFINE= -DIOCCC
# Include files that are needed to compile
#
#CINCLUDE=
#CINCLUDE= -include stdlib.h
#CINCLUDE= -include stdio.h
CINCLUDE= -include stddef.h -include stdlib.h -include stdio.h
#CINCLUDE= -I ${X11_INCDIR} -I ${X11_INCDIR}/X11
#CINCLUDE= `${SDL2_CONFIG} --cflags`
# Optimization
#
# Most compiles will safely use -O2. Some can use only -O1 or -O.
# A few compilers have broken optimizers and thus you may
# not want anything.
# A few compilers have broken optimizers or this entry make break
# under those buggy optimizers and thus you may not want anything.
# Reasonable compilers will allow for -O3.
#
#OPT=
#OPT= -O
#OPT= -O1
OPT= -O2
#OPT= -O2
OPT= -O3
# Default flags for ANSI C compilation
#
CFLAGS= ${CSTD} ${CWARN} ${ARCH} ${CDEFINE} ${CINCLUDE} ${OPT}
# flags for ANSI compiles
# Libraries needed to build
#
# NOTE: Some ANSI compilers make use of -Xa to turn on ANSI mode,
# others such as gcc may want -ansi, others (Compaq Tru64 Unix)
# want -std1, and others may want nothing at all.
# Adjust the CFLAGS line as needed.
#
# NOTE: Some compilers cannot optimize, or optimize some entries
# incorrectly. You might want to turn on -O to see if your
# compiler can handle them.
#
#
#CFLAGS= -Xa ${OPT}
#CFLAGS= -std1 $(OPT)
CFLAGS= -ansi ${OPT}
LIBS=
#LIBS= -lm
#LIBS= -L ${X11_LIBDIR} -lX11
#LIBS= `${SDL2_CONFIG} --libs`
# ANSI compiler
#
# Set CC to the name of your ANSI compiler.
#
# Some entries seem to need gcc. If you have gcc, set
# both CC and MAY_NEED_GCC to gcc.
#
# If you do not have gcc, set CC to the name of your ANSI compiler, and
# set MAY_NEED_GCC to either ${CC} (and hope for the best) or to just :
# to disable such programs.
# C compiler to use
#
CC= cc
MAY_NEED_GCC= gcc
#CC=clang
#CC=gcc
# 2004 winners
# Compiler add-ons or replacements for clang only
#
WINNERS= anonymous arachnid burley gavare gavin hibachi hoyle jdalbec \
kopczynski newbern omoikane schnitzi sds vik1 vik2
CLEAN= anonymous_clean arachnid_clean burley_clean gavare_clean gavin_clean \
hibachi_clean hoyle_clean jdalbec_clean kopczynski_clean \
newbern_clean omoikane_clean schnitzi_clean sds_clean vik1_clean \
vik2_clean
CLOBBER= anonymous_clobber arachnid_clobber burley_clobber gavare_clobber \
gavin_clobber hibachi_clobber hoyle_clobber jdalbec_clobber \
kopczynski_clobber newbern_clobber omoikane_clobber schnitzi_clobber \
sds_clobber vik1_clobber vik2_clobber
ALT_NAMES= hoyle.orig kopczynski.orig
DATA_FILES= arachnid_files gavin_files hibachi_files kopczynski_files \
newbern_files omoikane_files schnitzi_files
# default build
ifeq ($(CC),clang)
#
all: ${WINNERS}
# Best use of "Precious" Lines
CSILENCE+= -Wno-comma -Wno-missing-variable-declarations -Wno-padded \
-Wno-poison-system-directories -Wno-sign-conversion -Wno-trigraphs
#
anonymous: anonymous.c
${CC} anonymous.c -o anonymous
anonymous_clean:
${RM} -f anonymous.o
anonymous_clobber: anonymous_clean
${RM} -f anonymous
# Best use of Vision
CWARN+= -Weverything
#
arachnid: arachnid.c
${CC} -o arachnid -DL=LINES -DS=COLS \
-DW=mvwaddch\(w,v,u,acs_map\[l\[m\[u arachnid.c -lncurses
endif
arachnid_clean:
${RM} -f arachnid.o
arachnid_clobber: arachnid_clean
${RM} -f arachnid
arachnid_files: arachnid.info
# Best Calculated Risk
# Specific add-ons or replacements for gcc only
#
burley: burley.c
${CC} -ansi burley.c -o burley
burley_clean:
${RM} -f burley.o
burley_clobber: burley_clean
${RM} -f burley
# Best Use of Light and Spheres
ifeq ($(CC),gcc)
#
gavare: gavare.c
${CC} -O3 gavare.c -o gavare
gavare_clean:
${RM} -f gavare.o
gavare_clobber: gavare_clean
${RM} -f gavare
# Best of Show
#CSILENCE+=
#
gavin: gavin.c
${CC} ${GAVIN_OPT} -o gavin ${GAVIN_FLAGS} gavin.c
${RM} -f kernel
./gavin > kernel
${CC} ${GAVIN_OPT} -c ${GAVIN_FLAGS} -DB=_start '-Dputchar(a)=' gavin.c
${RM} -f sh
${LD} -s -o sh gavin.o
${RM} -f vi
${CP} sh vi
${RM} -f fs.tar
${TAR} -cvf fs.tar sh vi gavin.c gavin.hint prim
gavin_clean:
${RM} -f sh vi kernel gavin.o
gavin_clobber: gavin_clean
${RM} -f gavin fs.tar
gavin_files: boot.b lilo.conf prim gavin_install.txt
# Best Abuse of the Guidelines
#CWARN+=
#
hibachi: hibachi.tar.gz
${RM} -f hibachi.tar
${GUNZIP} < hibachi.tar.gz > hibachi.tar
${TAR} -xvf hibachi.tar
${RM} -f hibachi.tar
(cd hibachi && ${SHELL} ./configure)
([ -f hibachi/makefile ] && cd hibachi && $(MAKE) -f makefile || true)
hibachi_clean:
${RM} -f hibachi/hibachi.o hibachi.tar
hibachi_clobber: hibachi_clean
${RM} -rf hibachi
hibachi_files: hibachi.tar.gz
endif
# Most Functional Output
##############################
# Special flags for this entry
##############################
#
hoyle: hoyle.c
${CC} hoyle.c -o hoyle -lm
hoyle.orig: hoyle.orig.c
${CC} hoyle.orig.c -o hoyle.orig -lm
hoyle_clean:
${RM} -f hoyle.o hoyle.orig.o
hoyle_clobber: hoyle_clean
${RM} -f hoyle hoyle.orig
# Best Abuse of the Periodic Table
ENTRY= jdalbec
PROG= ${ENTRY}
#
jdalbec: jdalbec.c
@${RM} -f jdalbec2.c
-${CC} -E jdalbec.c > jdalbec2.c
@${RM} -f jdalbec3.c
${SED} -e 's/ (/(/g' < jdalbec2.c > jdalbec3.c
${CC} -ansi jdalbec3.c -o jdalbec
jdalbec_clean:
${RM} -f jdalbec2.c jdalbec3.c jdalbec.o
jdalbec_clobber: jdalbec_clean
${RM} -f jdalbec
# Best one-liner
OBJ= ${PROG}.o
DATA=
TARGET= ${PROG}
#
kopczynski: kopczynski.c
${CC} -Dif=while kopczynski.c -o kopczynski
kopczynski.orig: kopczynski.orig.c
${CC} -Dif=while kopczynski.orig.c -o kopczynski.orig
kopczynski_clean:
${RM} -f kopczynski.o kopczynski.orig.o
kopczynski_clobber: kopczynski_clean
${RM} -f kopczynski kopczynski.orig
kopczynski_files: kopczynski-10 kopczynski-11 kopczynski-8a kopczynski-8b \
kopczynski-8c kopczynski-9
ALT_OBJ=
ALT_TARGET=
# Best Font Engine
#################
# build the entry
#################
#
newbern: newbern.c
${CC} newbern.c -o newbern
all: data ${TARGET}
@${TRUE}
newbern_clean:
${RM} -f newbern.o
.PHONY: all alt data everything clean clobber install \
love haste waste maker easter_egg sandwich \
supernova deep_magic magic charon pluto
newbern_clobber: newbern_clean
${RM} -f newbern
${PROG}: ${PROG}.c
@${RM} -f ${PROG}2.c $@
-${CC} ${CSILENCE} -E ${PROG}.c > ${PROG}2.c
@${RM} -f ${PROG}3.c
${SED} -e 's/ (/(/g' < ${PROG}2.c > ${PROG}3.c
${CC} ${CFLAGS} ${PROG}3.c -o $@ ${LIBS}
newbern_files: newbern.dat
# Best Utility
# alternative executable
#
omoikane: omoikane.c
${CC} -O omoikane.c -o omoikane
alt: data ${ALT_TARGET}
@${TRUE}
omoikane_clean:
${RM} -f omoikane.o
omoikane_clobber: omoikane_clean
${RM} -f omoikane
omoikane_files: omoikane.info
# Best Non-Use of Curses
# data files
#
schnitzi: schnitzi.c
${CC} schnitzi.c -o schnitzi
data: ${DATA}
@${TRUE}
schnitzi_clean:
${RM} -f schnitzi.o
schnitzi_clobber: schnitzi_clean
${RM} -f schnitzi
schnitzi_files: schnitzi.inp0 schnitzi.inp1
# Best Abuse of Indentation
# both all and alt
#
sds: sds.c
${CC} -o sds sds.c
sds_clean:
${RM} -f sds_encoder.c sds_encoder.o sds.o
sds_clobber: sds_clean
${RM} -f sds sds_encoder
# Best X11 Game
#
vik1: vik1.c
${CC} -ansi -O2 -o vik1 vik1.c -L${X11_LIBDIR} -lX11
vik1_clean:
${RM} -f vik1.o
vik1_clobber: vik1_clean
${RM} -f vik1
# Best Abuse of CPP
#
vik2: vik2.c
@${RM} -f vik2_1.c
${CC} -E '-DSTOP=_5' '-DFNAME="vik2_1.c"' vik2.c > vik2_1.c
@${RM} -f vik2_2.c
${CC} -E vik2_1.c > vik2_2.c
${CC} -O vik2_2.c -o vik2
vik2_clean:
${RM} -f vik2_1.c vik2_2.c vik2.o
vik2_clobber: vik2_clean
${RM} -f vik2
everything: all alt
###############
# utility rules
###############
#
everything: ${WINNERS} ${ALT_NAMES} ${DATA_FILES}
clean:
${RM} -f ${OBJ} ${ALT_OBJ}
@-if [ -f indent.c ]; then \
echo ${RM} -f indent.c; \
${RM} -f indent.c; \
fi
clobber: clean
${RM} -f ${TARGET} ${ALT_TARGET}
${RM} -f ${PROG}2.c ${PROG}3.c
@-if [ -e sandwich ]; then \
${RM} -f sandwich; \
echo 'ate sandwich'; \
fi
install:
@echo "Dr. Spock says that is not logical!"
@${TRUE}
# you may be able to misunderstand the source by reading indent.c
#
indent.c: ${PROG}.c
@if which "${GINDENT}" >/dev/null 2>&1; then \
echo ${RM} -f $@; \
${RM} -f $@; \
echo "${GINDENT} < $< > $@"; \
${GINDENT} < $< > $@; \
elif which "${INDENT}" >/dev/null 2>&1; then \
echo ${RM} -f $@; \
${RM} -f $@; \
echo "${INDENT} < $< > $@"; \
${INDENT} < $< > $@; \
else \
echo "no intent tool found, ident $< yourself, sorry"; \
echo "exit 1"; \
exit 1; \
fi
##################
# 133t hacker rulz
##################
#
love:
@echo 'not war?'
@${TRUE}
haste:
$(MAKE) waste
waste:
@echo 'waste'
clean: ${CLEAN}
${RM} -f a.out core
clobber: ${CLOBBER}
${RM} -f ${WINNERS}
${RM} -f ${ALT_NAMES}
nuke: clobber
@${TRUE}
install: all
${CAT} ${WINNERS} ${ALT_NAMES} > /dev/null
waste:
@echo 'haste'
@${TRUE}
maker:
@echo 'Participate in a maker faire'
@${TRUE}
easter_egg:
@echo "you expected to often misunderstand this $${RANDOM} magic"
@echo "chongo '<was here>' /\\oo/\\"
@echo "Eggy"
sandwich: easter_egg
@if [ `id -u` -eq 0 ]; then \
echo 'Okay.'; \
echo "$${RANDOM}`date +%s`$${RANDOM}" > $@; \
else \
echo 'What? Make it yourself.'; \
exit 1; \
fi
# Understand the history of the Homebrew Computer Club
# as well as the West Coast Computer Faire and
# you might be confused different. :-)
#
supernova: sandwich
@-if [ -r .code_anal ]; then \
${RM} -f .code_anal_v6; \
else \
echo "planet deniers, like some members of the IAU, are so cute when they try to defend their logic"; \
fi
@echo "A $@ helps ${MAKE} the elements that help form planets"
@${TRUE}
deep_magic: supernova
@-if [ -r .code_anal ]; then \
ccode_analysis --deep_magic 7889066cdbdf09b0408021754586e895be641cc9be29e7eafd3ca65359541f17 \
--FNV1a_hash_512_bit -v2 "${PROG}" "${PROG}.c"; \
else \
echo "Wrong! Do it again!"; \
sleep 2; \
echo "Wrong! Do it again!"; \
sleep 2; \
echo "Wrong! Do it again!"; \
fi
@${TRUE}
magic: deep_magic
@-if [ -r .code_anal ]; then \
ccode_analysis --level 20003 --mode 5717175 --FNV1a_hash_512_bit -v2 "${PROG}" "${PROG}.c"; \
else \
echo "If you don't eat yer meat, you can't have any pudding!"; \
echo "How can you have any pudding if you don't eat yer meat?!"; \
fi
@${TRUE}
# The IOCCC resident astronomer states
#
charon: magic
@echo "$@ is a dwarf planet"
@echo "dwarf is a type of planet"
@echo "therefore IAU, $@ is a planet"
pluto: charon
${MAKE} charon
@echo "$@ is a dwarf planet"
@echo "dwarf is a type of planet"
@echo "therefore, $@ is a planet"
@echo "having lots of planets is good feature because supernovae can help ${MAKE} a lot of them"
+136 -127
View File
@@ -1,4 +1,4 @@
Best Abuse of the Periodic Table:
# Best Abuse of the Periodic Table:
John Dalbec
20 Squire's Ct.
@@ -7,157 +7,166 @@ Best Abuse of the Periodic Table:
http://cc.ysu.edu/~jpdalbec/
# To build:
Judges' Comments:
```sh
make
```
To build:
### To run:
make jdalbec
```sh
./jdalbec number ...
```
Try:
### Try:
./jdalbec 1
./jdalbec 11
./jdalbec 1 1
```sh
./jdalbec 1
./jdalbec 11
./jdalbec 1 1
We still aren't sure whether or not this is a useful program, but
it's the first atomic fission we've seen in the IOCCC.
```
## Judges' comments:
Selected Author's Comments:
We still aren't sure whether or not this is a useful program, but
it's the first atomic fission we've seen in the IOCCC.
It's elementary!
## Author's comments:
See http://mathworld.wolfram.com/LookandSaySequence.html,
http://mathworld.wolfram.com/CosmologicalTheorem.html,
and the references listed there.
It's elementary!
Go read the web pages and come back.
See http://mathworld.wolfram.com/LookandSaySequence.html,
http://mathworld.wolfram.com/CosmologicalTheorem.html,
and the references listed there.
This program implements the look-and-say sequence with the
added feature that each "decay product" is automatically split
into its constituent "elements" separated by spaces. Furthermore,
arguments passed to the program are treated as separate elements
for the purpose of computing further decay products. (Compare
the output of "prog 1", "prog 11", and "prog 1 1".) This
allows output lines from the program to be passed back to the
program as input (minus the initial generation number).
Go read the web pages and come back.
The common elements are listed in CosmologicalTheorem.html.
The non-primordial transuranic elements are the isotopes of
Neptunium and Plutonium. Isotopes of a given element differ
only in the last digit. Four common elements could also be
written as isotopes of these two elements: He=Np(2), Li=Pu(2),
Ta=Np(3), W=Pu(3). To get other isotopes, just change the
last digit to a number greater than 3.
This program implements the look-and-say sequence with the
added feature that each "decay product" is automatically split
into its constituent "elements" separated by spaces. Furthermore,
arguments passed to the program are treated as separate elements
for the purpose of computing further decay products. (Compare
the output of "prog 1", "prog 11", and "prog 1 1".) This
allows output lines from the program to be passed back to the
program as input (minus the initial generation number).
The build file runs prog.c through the C preprocessor to
generate prog2.c which is edited with ed to correct spacing
problems caused by some preprocessors. (I know you dislike
Perl, but hopefully ed is more common on POSIX systems than
Perl.) The build file then compiles prog2.c and removes the
prog2.c file.
The common elements are listed in CosmologicalTheorem.html.
The non-primordial transuranic elements are the isotopes of
Neptunium and Plutonium. Isotopes of a given element differ
only in the last digit. Four common elements could also be
written as isotopes of these two elements: He=Np(2), Li=Pu(2),
Ta=Np(3), W=Pu(3). To get other isotopes, just change the
last digit to a number greater than 3.
I don't think I'm abusing the build file since I'm only using
147 characters including white space and the #! line and the
commented-out "-Wall -pedantic" options. The rules for the
16th IOCCC rules specifically allowed build files up to 521
characters long so my build file would have been well within
those limits. (What typo?)
The build file runs prog.c through the C preprocessor to
generate prog2.c which is edited with ed to correct spacing
problems caused by some preprocessors. (I know you dislike
Perl, but hopefully ed is more common on POSIX systems than
Perl.) The build file then compiles prog2.c and removes the
prog2.c file.
gcc -E -Wall -pedantic complains that trigraphs are present and that
"pasting ... does not yield a valid processing token".
I don't think I'm abusing the build file since I'm only using
147 characters including white space and the #! line and the
commented-out "-Wall -pedantic" options. The rules for the
16th IOCCC rules specifically allowed build files up to 521
characters long so my build file would have been well within
those limits. (What typo?)
gcc -ansi -Wall -pedantic complains about #line directives,
trigraphs, and expressions and statements that have no effect.
The last complaint is false in all but one case. Removing
the offending expressions causes some compilers to report
syntax errors because they can't determine whether a name
refers to a variable or a type.
gcc -E -Wall -pedantic complains that trigraphs are present and that
"pasting ... does not yield a valid processing token".
Since buffer overflows are a common security problem these
days I have stolen the idea of using a "safe" buffer API from
vsftpd. This means the program should never crash, right?
gcc -ansi -Wall -pedantic complains about #line directives,
trigraphs, and expressions and statements that have no effect.
The last complaint is false in all but one case. Removing
the offending expressions causes some compilers to report
syntax errors because they can't determine whether a name
refers to a variable or a type.
The program was tested on:
AMD K6/MMX 266MHz, Debian GNU/Linux testing "Sarge", gcc 3.3.2
Intel 486DX 33MHz, Red Hat Linux 7.3, gcc 2.96
PowerPC Macintosh G4 Quicksilver, Mac OS X 10.3.2, gcc 3.3
PowerPC Macintosh G4 Quicksilver, Mac OS X 10.1.5, cc 2.95.2
PowerPC Macintosh Performa 5200CD, Mac OS 8.6, CodeWarrior 11
Sun SPARC Ultra 10, Solaris 8, gcc 3.2
Since buffer overflows are a common security problem these
days I have stolen the idea of using a "safe" buffer API from
vsftpd. This means the program should never crash, right?
Compiling on Mac OS 8.6 requires some degree of manual
intervention because Mac OS 8.6 doesn't have shell scripting
or even a normal command prompt. The CodeWarrior 11 compiler
is the reason I had to use trigraphs. I have to preprocess
prog.c without trigraphs, save the result as prog2.c, then
compile prog2.c with trigraphs to get the program to work.
I also have to add an include file and a function call to the
program to get a pseudo command line so I can pass arguments.
The compiler also requires function prototypes by default,
which is why I have prototypes for all my functions.
The program was tested on:
AMD K6/MMX 266MHz, Debian GNU/Linux testing "Sarge", gcc 3.3.2
Intel 486DX 33MHz, Red Hat Linux 7.3, gcc 2.96
PowerPC Macintosh G4 Quicksilver, Mac OS X 10.3.2, gcc 3.3
PowerPC Macintosh G4 Quicksilver, Mac OS X 10.1.5, cc 2.95.2
PowerPC Macintosh Performa 5200CD, Mac OS 8.6, CodeWarrior 11
Sun SPARC Ultra 10, Solaris 8, gcc 3.2
Compiling on Mac OS X 10.1.5 requires changing ??= to \# on
line 3 because the compiler doesn't recognize ??= as a trigraph
(which I consider a compiler bug). The initial preprocessing
step on Mac OS X 10.1.5 generates lots of errors in "smart
mode" because the "smart" preprocessor expects a valid C
program as input. The preprocessor then falls back to "basic
mode" and preprocesses prog.c successfully without warnings,
even when I give it the "-Wall -pedantic" options. It inserts
a lot of extra spaces into the preprocessed output which is
why I had to add the "ed" step to the build file so that my
macro #defines would work. The compile step gives the usual
messages with "-Wall -pedantic". The link step generates a
warning about a name conflict between my BC() and a BC() from
curses in the main system library.
Compiling on Mac OS 8.6 requires some degree of manual
intervention because Mac OS 8.6 doesn't have shell scripting
or even a normal command prompt. The CodeWarrior 11 compiler
is the reason I had to use trigraphs. I have to preprocess
prog.c without trigraphs, save the result as prog2.c, then
compile prog2.c with trigraphs to get the program to work.
I also have to add an include file and a function call to the
program to get a pseudo command line so I can pass arguments.
The compiler also requires function prototypes by default,
which is why I have prototypes for all my functions.
BUGS, I mean FEATURES:
Arguments matching /[^2]22$/ cause the program to segfault
after rapidly exhausting the available stack space. I could
probably fix this by adding some special cases to the code,
but [Blaine the Mono] it's quite a bit more exciting this way,
don't you think?[/Blaine] Since the trailing "22" will be
its own atom anyway, you can just insert a space in front of
it if you run into this feature (e.g. "1 22" instead of "122").
Compiling on Mac OS X 10.1.5 requires changing ??= to \# on
line 3 because the compiler doesn't recognize ??= as a trigraph
(which I consider a compiler bug). The initial preprocessing
step on Mac OS X 10.1.5 generates lots of errors in "smart
mode" because the "smart" preprocessor expects a valid C
program as input. The preprocessor then falls back to "basic
mode" and preprocesses prog.c successfully without warnings,
even when I give it the "-Wall -pedantic" options. It inserts
a lot of extra spaces into the preprocessed output which is
why I had to add the "ed" step to the build file so that my
macro #defines would work. The compile step gives the usual
messages with "-Wall -pedantic". The link step generates a
warning about a name conflict between my BC() and a BC() from
curses in the main system library.
Note: you may want to be sure you have a limit on stack size
before trying this. I ran it on Debian GNU/Linux and discovered
that I did not have a limit on stack size. Fortunately the
OS killed the process after a while. This is consistent with
the output of 1996/schweikh3 which reports "malloc lied!
Killed by SIGKILL".
BUGS, I mean FEATURES:
Arguments matching /[^2]22$/ cause the program to segfault
after rapidly exhausting the available stack space. I could
probably fix this by adding some special cases to the code,
but [Blaine the Mono] it's quite a bit more exciting this way,
don't you think?[/Blaine] Since the trailing "22" will be
its own atom anyway, you can just insert a space in front of
it if you run into this feature (e.g. "1 22" instead of "122").
Arguments matching /(?:.){10,}/ will produce visually incorrect
results (e.g., generation 1 starting from 1111111111 will
print as ": 1"), but there's nothing interesting about these
arguments that can't be modeled using shorter runs of the same
symbol.
Note: you may want to be sure you have a limit on stack size
before trying this. I ran it on Debian GNU/Linux and discovered
that I did not have a limit on stack size. Fortunately the
OS killed the process after a while. This is consistent with
the output of 1996/schweikh3 which reports "malloc lied!
Killed by SIGKILL".
Arguments matching /(?:.){257,}/ may produce mathematically
incorrect results (e.g., generation 1 starting from a string
of 257 1's will be calculated as "11"); the remark from the
previous paragraph applies here also.
Arguments matching /(?:.){10,}/ will produce visually incorrect
results (e.g., generation 1 starting from 1111111111 will
print as ": 1"), but there's nothing interesting about these
arguments that can't be modeled using shorter runs of the same
symbol.
The program has exactly 2004 IOCCC countable bytes. It's
tailor-made for this competition!
Arguments matching /(?:.){257,}/ may produce mathematically
incorrect results (e.g., generation 1 starting from a string
of 257 1's will be calculated as "11"); the remark from the
previous paragraph applies here also.
Although there are no comments, the program still manages to
be self- documenting in an obscure fashion (periodic table of
the (non-primordial) elements, "OBFUSCATED C").
The program has exactly 2004 IOCCC countable bytes. It's
tailor-made for this competition!
The program is obfuscated:
By invoking cpp twice
By the use of #defines
By the use of typedefs
By the use of global constants
By the use of global functions that replace the standard ones (I
particularly like substituting At (Astatine, highly unstable) for abort.)
By overloading symbols (For example, B is a type, a structure, a structure
member, a macro parameter, and a variable.)
By standard tricks like writing '\0' as 1["3"] or 2["22"]
By using ternary operators to avoid "else"
By using the Sb function to create subbuffers from either end
By naming everything after chemical elements or pairs of elements
Because it says so in the source. ;)
Although there are no comments, the program still manages to
be self- documenting in an obscure fashion (periodic table of
the (non-primordial) elements, "OBFUSCATED C").
The program is obfuscated:
By invoking cpp twice
By the use of #defines
By the use of typedefs
By the use of global constants
By the use of global functions that replace the standard ones (I
particularly like substituting At (Astatine, highly unstable) for abort.)
By overloading symbols (For example, B is a type, a structure, a structure
member, a macro parameter, and a variable.)
By standard tricks like writing '\0' as 1["3"] or 2["22"]
By using ternary operators to avoid "else"
By using the Sb function to create subbuffers from either end
By naming everything after chemical elements or pairs of elements
Because it says so in the source. ;)
-5
View File
@@ -1,11 +1,6 @@
#define Nd Np define
#define Ni(N) Np include <std##N##.h>
#define Np ??=
Ni(def)
Ni(io)
Ni(lib)
Nd Ba BC(B, I)
Nd Be BC(Br, I)
Nd Ca(C, Ca) CB(B, In C, Ca)