Merge pull request #2 from mame/2013-restore-rules.txt
Add 2013/rules.txt, iocccsize.c, and iocccsize.mk
This commit is contained in:
2 files changed
+482
No files matched your search
@@ -0,0 +1,411 @@
|
||||
/*
|
||||
* iocccsize - IOCCC Source Secondary Size
|
||||
*
|
||||
* Public Domain 1992, 2013 by Anthony Howe. All rights released.
|
||||
* With IOCCC mods in 2013 by chongo (Landon Curt Noll) /\oo/\
|
||||
*
|
||||
* This IOCCC size tool source file is version 2013-07-30-v17.
|
||||
*
|
||||
* SYNOPSIS
|
||||
*
|
||||
* ioccc [-ikrs] < input
|
||||
*
|
||||
* -i print official IOCCC size to standard out
|
||||
* NOTE: -i implies -r -s
|
||||
* -k keep comments
|
||||
* -r count C reserved words as 1 byte
|
||||
* -s silence; do not output source code, only final count
|
||||
*
|
||||
* DESCRIPION
|
||||
*
|
||||
* Taking input from standard input, apply the IOCCC Source Size Rule
|
||||
* for 2001. The program's offical length is written to standard error.
|
||||
* Also filter out C comment blocks (-k to keep) sending the modified
|
||||
* source to standard output.
|
||||
*
|
||||
* The 2001 Source Size Rule was:
|
||||
*
|
||||
* Your entry must be <= 4096 bytes in length. The number of octets
|
||||
* excluding whitespace (tab, space, newline, formfeed, return), and
|
||||
* excluding any ';', '{' or '}' followed by whitespace or end of file,
|
||||
* must be <= 2048.
|
||||
*
|
||||
* NOTE: The above descipion is NOT the official IOCCC size tool algorithm!
|
||||
*/
|
||||
|
||||
/*
|
||||
* The official IOCCC rule 2 secondary limit on C code size
|
||||
*
|
||||
* The IOCCC size tool should be compiled as:
|
||||
*
|
||||
* cc -pedantic -Wall -std=c99 iocccsize.c -o iocccsize
|
||||
*
|
||||
* This tool computes a 2nd size C code. To check your program source
|
||||
* against the 2nd limit of rule 2, use the -i command line option.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* ./iocccsize -i < prog.c
|
||||
*
|
||||
* The IOCCC size tool, when using the -i option, may be summarized as:
|
||||
*
|
||||
* The size tool counts C language keywords (primary, secondary, and
|
||||
* selected preprocessor keywords) as 1. The size tool counts all
|
||||
* other octets as 1 excluding ASCII whitespace, and excluding any
|
||||
* ';', '{' or '}' followed by ASCII whitespace, and excluding any
|
||||
* ';', '{' or '}' octet immediately before the end of file.
|
||||
*
|
||||
* ASCII whitespace includes ASCII tab, ASCII space, ASCII newline,
|
||||
* ASCII formfeed, and ASCII carriage return.
|
||||
*
|
||||
* In cases where the above summary and the algorithm implemented by
|
||||
* the IOCCC size tool source code conflict, the algorithm implemented
|
||||
* by the IOCCC size tool source code is preferred by the judges.
|
||||
*
|
||||
* See the current IOCCC rules and guidelines for more information.
|
||||
* In particular, see the current IOCCC size rule for information about
|
||||
* the maximum value that this tool should print for an entry to be valid.
|
||||
*/
|
||||
|
||||
/*
|
||||
* HINT: The algorithm implemented by this code may or not be obfuscated.
|
||||
* The algorithm may not or may appear to be obfuscated.
|
||||
*
|
||||
* In particular:
|
||||
*
|
||||
* We did not invent the algorithm.
|
||||
* The algorithm consistently finds Obfuscation.
|
||||
* The algorithm killed Obfuscation.
|
||||
* The algorithm is banned in C.
|
||||
* The algorithm is from Bell Labs in Jersey.
|
||||
* The algorithm constantly finds Obfuscation.
|
||||
* This is not the algorithm.
|
||||
* This is close.
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#define FLAG_SILENCE 1
|
||||
#define FLAG_KEEP 2
|
||||
#define FLAG_RESERVED 4
|
||||
#define FLAG_IOCCC_SIZE 8
|
||||
|
||||
char usage[] =
|
||||
"usage: ioccc [-ikrs] < prog.c\n"
|
||||
"\n"
|
||||
"-i\t\tprint just the official secondary IOCCC size to stdout\n"
|
||||
"\t\t NOTE: -i implies -r -s\n"
|
||||
"-k\t\tkeep block comments\n"
|
||||
"-r\t\tcount C reserved words as 1 byte\n"
|
||||
"-s\t\tsilence; do not output source code, only final count\n";
|
||||
|
||||
#define STRLEN(s) (sizeof (s)-1)
|
||||
|
||||
typedef struct {
|
||||
size_t length;
|
||||
const char *word;
|
||||
} Word;
|
||||
|
||||
/*
|
||||
* C reserved words, plus a few #preprocessor tokens, that count as 1
|
||||
*
|
||||
* NOTE: For a good list of reserved words in C, see:
|
||||
*
|
||||
* http://www.bezem.de/pdf/ReservedWordsInC.pdf
|
||||
*
|
||||
* by Johan Bezem of JB Enterprises:
|
||||
*
|
||||
* See http://www.bezem.de/en/
|
||||
*/
|
||||
static Word cwords[] = {
|
||||
/* Yes Virginia, we left #define off the list on purpose! */
|
||||
{ STRLEN("#elif"), "#elif" },
|
||||
{ STRLEN("#else"), "#else" },
|
||||
{ STRLEN("#endif"), "#endif" },
|
||||
{ STRLEN("#error"), "#error" },
|
||||
{ STRLEN("#ident"), "#ident" },
|
||||
{ STRLEN("#if"), "#if" },
|
||||
{ STRLEN("#ifdef"), "#ifdef" },
|
||||
{ STRLEN("#include"), "#include" },
|
||||
{ STRLEN("#line"), "#line" },
|
||||
{ STRLEN("#pragma"), "#pragma" },
|
||||
{ STRLEN("#sccs"), "#sccs" },
|
||||
{ STRLEN("#warning"), "#warning" },
|
||||
/**/
|
||||
{ STRLEN("_Alignas"), "_Alignas" },
|
||||
{ STRLEN("_Alignof"), "_Alignof" },
|
||||
{ STRLEN("_Atomic"), "_Atomic" },
|
||||
{ STRLEN("_Bool"), "_Bool" },
|
||||
{ STRLEN("_Complex"), "_Complex" },
|
||||
{ STRLEN("_Generic"), "_Generic" },
|
||||
{ STRLEN("_Imaginary"), "_Imaginary" },
|
||||
{ STRLEN("_Noreturn"), "_Noreturn" },
|
||||
{ STRLEN("_Pragma"), "_Pragma" },
|
||||
{ STRLEN("_Static_assert"), "_Static_assert" },
|
||||
{ STRLEN("_Thread_local"), "_Thread_local" },
|
||||
/**/
|
||||
{ STRLEN("alignas"), "alignas" },
|
||||
{ STRLEN("alignof"), "alignof" },
|
||||
{ STRLEN("and"), "and" },
|
||||
{ STRLEN("and_eq"), "and_eq" },
|
||||
{ STRLEN("auto"), "auto" },
|
||||
{ STRLEN("bitand"), "bitand" },
|
||||
{ STRLEN("bitor"), "bitor" },
|
||||
{ STRLEN("bool"), "bool" },
|
||||
{ STRLEN("break"), "break" },
|
||||
{ STRLEN("case"), "case" },
|
||||
{ STRLEN("char"), "char" },
|
||||
{ STRLEN("compl"), "compl" },
|
||||
{ STRLEN("const"), "const" },
|
||||
{ STRLEN("continue"), "continue" },
|
||||
{ STRLEN("default"), "default" },
|
||||
{ STRLEN("do"), "do" },
|
||||
{ STRLEN("double"), "double" },
|
||||
{ STRLEN("else"), "else" },
|
||||
{ STRLEN("enum"), "enum" },
|
||||
{ STRLEN("extern"), "extern" },
|
||||
{ STRLEN("false"), "false" },
|
||||
{ STRLEN("float"), "float" },
|
||||
{ STRLEN("for"), "for" },
|
||||
{ STRLEN("goto"), "goto" },
|
||||
{ STRLEN("I"), "I" },
|
||||
{ STRLEN("if"), "if" },
|
||||
{ STRLEN("inline"), "inline" },
|
||||
{ STRLEN("int"), "int" },
|
||||
{ STRLEN("long"), "long" },
|
||||
{ STRLEN("noreturn"), "noreturn" },
|
||||
{ STRLEN("not"), "not" },
|
||||
{ STRLEN("not_eq"), "not_eq" },
|
||||
{ STRLEN("or"), "or" },
|
||||
{ STRLEN("or_eq"), "or_eq" },
|
||||
{ STRLEN("register"), "register" },
|
||||
{ STRLEN("restrict"), "restrict" },
|
||||
{ STRLEN("return"), "return" },
|
||||
{ STRLEN("short"), "short" },
|
||||
{ STRLEN("signed"), "signed" },
|
||||
{ STRLEN("sizeof"), "sizeof" },
|
||||
{ STRLEN("static"), "static" },
|
||||
{ STRLEN("static_assert"), "static_assert" },
|
||||
{ STRLEN("struct"), "struct" },
|
||||
{ STRLEN("switch"), "switch" },
|
||||
{ STRLEN("thread_local"), "thread_local" },
|
||||
{ STRLEN("true"), "true" },
|
||||
{ STRLEN("typedef"), "typedef" },
|
||||
{ STRLEN("union"), "union" },
|
||||
{ STRLEN("unsigned"), "unsigned" },
|
||||
{ STRLEN("void"), "void" },
|
||||
{ STRLEN("volatile"), "volatile" },
|
||||
{ STRLEN("while"), "while" },
|
||||
{ STRLEN("xor"), "xor" },
|
||||
{ STRLEN("xor_eq"), "xor_eq" },
|
||||
/**/
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
Word *
|
||||
find_member(Word *table, const char *string)
|
||||
{
|
||||
Word *w;
|
||||
for (w = table; w->length != 0; w++) {
|
||||
if (strncmp(string, w->word, w->length) == 0
|
||||
&& !isalnum(string[w->length]) && string[w->length] != '_')
|
||||
return w;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Count octets and strip comments. The stripped C input is sent to
|
||||
* standard output. If -s is set, then suppress the source output.
|
||||
* The various counters are sent to standard error (see below), unless
|
||||
* -i is given in which case source output is suppressed and only the
|
||||
* IOCCC size rule count is sent to standard out.
|
||||
*
|
||||
* The counter output format is:
|
||||
*
|
||||
* lcount wcount bcount icount isaved rcount rsaved
|
||||
*
|
||||
* where
|
||||
* lcount line count (same as wc)
|
||||
* wcount word count (same as wc)
|
||||
* bcount byte count (same as wc)
|
||||
* icount IOCCC secondary size rule count
|
||||
* isaved bytes saved by secondary size rule (bcount - icount)
|
||||
* rcount number of C reserved words
|
||||
* rsaved number of octets saved with -r
|
||||
*/
|
||||
int
|
||||
count(int flags)
|
||||
{
|
||||
Word *w;
|
||||
int span;
|
||||
char *p, buf[256];
|
||||
int lcount, wcount, bcount;
|
||||
int is_comment, is_word, dquote;
|
||||
int count, keywords, saved, kw_saved;
|
||||
|
||||
/* Start of buffer sentinel. */
|
||||
buf[0] = ' ';
|
||||
|
||||
count = saved = 0;
|
||||
keywords = kw_saved = 0;
|
||||
lcount = wcount = bcount = 0;
|
||||
is_comment = is_word = dquote = 0;
|
||||
|
||||
/*
|
||||
* "no matter how well you may think you understand this code,
|
||||
* you don't, so don't mess with it." :-)
|
||||
*/
|
||||
for ( ; fgets(buf+1, sizeof (buf)-1, stdin) != NULL;) {
|
||||
if (!(flags & FLAG_KEEP)) {
|
||||
/* Leading whitespace before comment block? */
|
||||
span = strspn(buf+1, "\t ");
|
||||
if (buf[1+span] == '/' && buf[2+span] == '*') {
|
||||
/* Strip leading whitespace before comment block. */
|
||||
is_comment = 1;
|
||||
}
|
||||
}
|
||||
|
||||
for (p = buf+1; *p != '\0'; p++) {
|
||||
/* In C comment block? */
|
||||
if (is_comment) {
|
||||
/* End of comment block? */
|
||||
if (*p == '*' && p[1] == '/') {
|
||||
is_comment = 0;
|
||||
|
||||
if (!(flags & FLAG_KEEP)) {
|
||||
/* Strip whitespace and newline
|
||||
* trailing closing comment.
|
||||
*/
|
||||
p += 1 + strspn(p+2, " \t\r\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (!(flags & FLAG_KEEP)) {
|
||||
/* Strip octets in comment block. */
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Start of comment block? */
|
||||
else if (!dquote && *p == '/' && p[1] == '*') {
|
||||
/* Begin comment block. */
|
||||
is_comment = 1;
|
||||
|
||||
if (!(flags & FLAG_KEEP)) {
|
||||
/* Strip comment block. */
|
||||
p++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Toggle start/end of double-quote string. */
|
||||
else if (*p == '"' && p[-1] != '\\' && p[-1] != '\'')
|
||||
dquote = !dquote;
|
||||
|
||||
/* C reserved word? */
|
||||
else if (!dquote
|
||||
&& !isalnum(p[-1]) && p[-1] != '_'
|
||||
&& (w = find_member(cwords, p)) != NULL) {
|
||||
keywords++;
|
||||
if (flags & FLAG_RESERVED) {
|
||||
bcount += w->length;
|
||||
if (!is_word) {
|
||||
is_word = 1;
|
||||
wcount++;
|
||||
}
|
||||
|
||||
if (!(flags & FLAG_SILENCE))
|
||||
fputs(w->word, stdout);
|
||||
|
||||
/* Count reserved word as one. */
|
||||
kw_saved += w->length - 1;
|
||||
p += w->length - 1;
|
||||
count++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Everything above here is stripped from the input. */
|
||||
if (!(flags & FLAG_SILENCE))
|
||||
fputc(*p, stdout);
|
||||
|
||||
bcount++;
|
||||
if (*p == '\n')
|
||||
lcount++;
|
||||
|
||||
/* Ignore all whitespace. */
|
||||
if (isspace(*p)) {
|
||||
is_word = 0;
|
||||
saved++;
|
||||
continue;
|
||||
} else if (!is_word) {
|
||||
is_word = 1;
|
||||
wcount++;
|
||||
}
|
||||
|
||||
/* Ignore curly braces and semicolons when followed
|
||||
* by any whitspace or EOF.
|
||||
*/
|
||||
if (strchr("{;}", *p) != NULL
|
||||
&& (isspace(p[1]) || p[1] == '\0')) {
|
||||
saved++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Count this octet. */
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
/* final count */
|
||||
if (flags & FLAG_IOCCC_SIZE) {
|
||||
/* output the official IOCCC size tool size to standard out */
|
||||
printf("%d\n", count);
|
||||
} else {
|
||||
fprintf(stderr, "%d %d %d %d %d %d %d\n",
|
||||
lcount, wcount, bcount, count, saved,
|
||||
keywords, kw_saved);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
int ch;
|
||||
int flags = 0;
|
||||
|
||||
/* parse args */
|
||||
while ((ch = getopt(argc, argv, "ikrs")) != -1) {
|
||||
switch (ch) {
|
||||
case 'i':
|
||||
/* "You are not expected to understand this" :-) */
|
||||
flags |= (FLAG_RESERVED | FLAG_SILENCE |
|
||||
FLAG_IOCCC_SIZE);
|
||||
break;
|
||||
case 'k':
|
||||
flags |= FLAG_KEEP;
|
||||
break;
|
||||
case 'r':
|
||||
flags |= FLAG_RESERVED;
|
||||
break;
|
||||
case 's':
|
||||
flags |= FLAG_SILENCE;
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s\n", usage);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
/* count as directed by flags */
|
||||
(void) count(flags);
|
||||
|
||||
/* All Done!!! All Done!!! -- Jessical Noll, age 2 */
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
.POSIX :
|
||||
|
||||
#######################################################################
|
||||
|
||||
CFLAGS := -pedantic -Wall -std=c99 -g
|
||||
LDFLAGS :=
|
||||
LIBS :=
|
||||
IT := iocccsize
|
||||
|
||||
#######################################################################
|
||||
|
||||
all: ${IT}$E
|
||||
|
||||
${IT}$E: ${IT}.c
|
||||
${CC} ${CFLAGS} -o ${IT}$E ${IT}.c
|
||||
|
||||
#
|
||||
# Exercise the IOCCC size tool.
|
||||
#
|
||||
test: test-k test-wc test-rcount
|
||||
|
||||
#
|
||||
# -k should pass through the source with block comments intact.
|
||||
#
|
||||
test-k: ${IT}$E
|
||||
@{ t="-k keep comments" ;\
|
||||
if ./${IT} -k <${IT}.c 2>/dev/null | diff - ${IT}.c ; then echo "-OK- $$t" ; else echo "FAIL $$t" ; fi ;\
|
||||
}
|
||||
|
||||
#
|
||||
# First 3 counters should match wc(1)
|
||||
#
|
||||
test-wc: ${IT}$E
|
||||
@{ t="wc counts" ;\
|
||||
a=$$(./${IT} -s -k <${IT}.c 2>&1 | cut -d' ' -f1-3) ;\
|
||||
b=$$(wc ${IT}.c | sed -e's/^ *//; s/ */ /g' | cut -d' ' -f1-3) ;\
|
||||
if [ "$$a" = "$$b" ]; then echo "-OK- $$t"; else echo "FAIL $$t: expected '$$b', got '$$a'"; fi ;\
|
||||
}
|
||||
|
||||
#
|
||||
# Show counters for different option combinations.
|
||||
#
|
||||
test-show: ${IT}$E
|
||||
./${IT} -s <${IT}.c
|
||||
./${IT} -s -r <${IT}.c
|
||||
./${IT} -s -k <${IT}.c
|
||||
./${IT} -s -r -k <${IT}.c
|
||||
|
||||
#
|
||||
# Reserved word counter should be same for all option combinations.
|
||||
#
|
||||
test-rcount: ${IT}$E
|
||||
@{ t="rcount" ;\
|
||||
./${IT} -s <${IT}.c 2>&1 | cut -d" " -f 6 >/tmp/$$$$.tmp ;\
|
||||
./${IT} -s -r <${IT}.c 2>&1 | cut -d" " -f 6 >>/tmp/$$$$.tmp ;\
|
||||
./${IT} -s -k <${IT}.c 2>&1 | cut -d" " -f 6 >>/tmp/$$$$.tmp ;\
|
||||
./${IT} -s -r -k <${IT}.c 2>&1 | cut -d" " -f 6 >>/tmp/$$$$.tmp ;\
|
||||
n=$$(sort -u /tmp/$$$$.tmp | wc -l | sed -e's/^ *//') ;\
|
||||
if [ $$n -eq 1 ]; then echo "-OK- $$t"; else echo "FAIL $$t: expected 1 unique line, got $$n"; echo "see make test-show"; fi ;\
|
||||
rm -f /tmp/$$$$.tmp ;\
|
||||
}
|
||||
|
||||
clean:
|
||||
rm -f iocccsize.o
|
||||
rm -rf iocccsize.dSYM
|
||||
|
||||
clobber: clean
|
||||
rm -f iocccsize
|
||||
|
||||
install:
|
||||
@echo "no thank you on the install :-)"
|
||||
Reference in new issue
Block a user