CMUNGE

A tool for encrypting and compacting C source code

1. Recursively in-lining `user-defined' #include files. (#include files that are located in the directory "/usr/include", or whose names are enclosed in <...>, are taken to be `system-defined' files and are not in-lined, to preserve portability.)

2. Renaming C identifiers, except those in the C Standard Library, with names like l1 (i.e. letter-l one), l2, l3, etc.

3. Removing comments and blank lines, converting multiple consecutive whitespace characters (including `\n') into single blanks, removing all unnecessary whitespace between tokens (i.e. only putting a single blank as a separator between tokens where it is really required), and then outputting the transformed code in lines of least N characters long, where N is a user-specified minimum line length (with a default value of 90).

4. Renaming the generated output files, e.g. "f1.c", "f2.c", etc.

For example, CMUNGE converts the following C source code:

        /*------------------------------------------------------*/
        /* dos2unix:  Converts DOS text files to Unix ones by   */
        /* removing the `^M' character at the end of each line. */
        /*------------------------------------------------------*/
        #include <stdio.h>
        main ()
        {
                int c;

                while ((c = getchar()) != EOF)
                        if (c != '\015')        /* ^M */
                                putchar (c);
        }

        #include <stdio.h>
        main(){int l1;while((l1=getchar())!=EOF)if(l1!='\015')putchar(l1);}

CMUNGE provides facilities for protecting parts of the source code from translation, for preventing the in-lining of selected #include files, and for preventing the renaming of selected identifiers. It creates dictionaries that translate the original identifiers and filenames into the new ones and vice versa, by means of which the user can relate the output code to the original if necessary (albeit not easily!).

The purpose of CMUNGE is to allow C source code to be distributed in a form that is unsuitable for modification or further development while still preserving its portability, with the benefit of making it much more compact (e.g. for my C source code I typically obtain compression factors of 4 - 5 as a result of munging it).

The CMUNGE software comprises 2 C programs and a `csh' (`C shell') driver script. Therefore installation is simply a matter of compiling 2 C programs, which can be done with an ANSI or K & R C compiler. Since the driver program is a `csh' script, it assumes a Unix-like operating system.

  cmunge [options] files...

  Options:
    -I include-dir      -- Search directory `include-dir' for #include files.
    -d output-dir       -- Write the output file(s) to directory
                             `output-dir'.  (Default: current directory.)
    -f output-file-rootname
                        -- Output files have names starting with the
                             string `output-file-rootname' followed by ".c"
                             if there is one output file, or "1.c", "2.c",
                             etc, if there is more than one.  E.g. `-f f'
                             causes the output files to be named "f.c"
                             or "f1.c", "f2.c", etc.  (Default: f).
    -l min-output-linelen
                        -- Make lines of the output file(s) at least
                             `min-output-linelen' characters long.
                             (Default: 90.)
    -p prefix-letter    -- Give the translated C identifiers names
                             consisting of the letter `prefix-letter'
                             followed by a number.  E.g. `-p l' causes
                             the translated identifiers to be called
                             l1, l2, etc.  (Default: l).
    -v version-string   -- Insert string `version-string' as a C comment
                             in the first line of each output file.
                             (Default: no comment is written.)
    -<anything else>    -- Other arguments are passed directly to the
                             C pre-processor, `cpp'.  E.g. argument
                             `-Dname=def' is passed directly to `cpp'.
    files...            -- The input C source file(s) to be `munged'.
  
  Spaces are optional between option letters and their accompanying arguments.