The Great Upheaval -- step 1.

[quine] / qqlib.c

/* -*-c-*-
 *
 * $Id$
 *
 * Useful library of tools for quines
 *
 * (c) 1999 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Quine
 *
 * Quine is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Quine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Quine; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * However, when this source text is embedded in a file by the Quine
 * program, you may do anything you like with the resulting text;
 * distribution and modification are not limited by the General Public
 * License.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: qqlib.c,v $
 * Revision 1.2  2000/08/01 17:41:39  mdw
 * Remove unnecessary <ctype.h> header.
 *
 * Revision 1.1.1.1  1999/04/28 19:58:07  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

/* --- ANSI headers --- */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* --- POSIX headers --- */

#ifndef QUINE_PORTABLE
#  include <sys/types.h>
#  include <sys/fcntl.h>
#  include <sys/stat.h>
#  include <unistd.h>
#endif

/* --- Local headers --- */

#include "quine.h"

/*----- Macro hacking -----------------------------------------------------*/

#ifdef QUINE_PORTABLE
#  define PORT(x) x
#  define NPORT(x)
#else
#  define PORT(x)
#  define NPORT(x) x
#endif

/*----- Main code ---------------------------------------------------------*/

/* --- @qq_xlate@ --- *
 *
 * Arguments:	@FILE *fp@ = output file handle
 *		@const char *p@ = pointer to encoded text
 *
 * Returns:	---
 *
 * Use:		Writes the decoded string to the given file handle.
 */

void qq_xlate(FILE *fp, const char *p)
{
  while (*p) {
    if (*p == '%') {
      p++;
      switch (*p) {
	case 'q': fputc('\"', fp); break;
	case 'b': fputc('\\', fp); break;
	case 't': fputc('\t', fp); break;
	case 'n': fputc('\n', fp); break;
	case 'a': fputc('\a', fp); break;
	case 'r': fputc('\r', fp); break;
	case '0': fputc('\0', fp); break;
	case '%': fputc('%', fp);  break;
	case 'x': {
	  unsigned char ch = 0;
	  p++;
	  while (*p != '%') {
	    unsigned int x = *p++;
	    x -= '0';
	    if (x >= 10) x -= 'a' - '0' - 10;
	    if (x >= 16) x -= 'A' - 'a';
	    ch = (ch << 4) + x;
	  }
	  fputc(ch, fp);
	} break;
	default:
	  p--;
	  break;
      }
    } else
      fputc(*p, fp);
    p++;
  }
}

/* --- @qq_file@ --- *
 *
 * Arguments:	@FILE *fp@ = output file handle
 *		@const char **p@ = pointer to the output array
 *
 * Returns:	---
 *
 * Use:		Writes the contents of a file to the output.
 */

void qq_file(FILE *fp, const char **p)
{
  while (*p)
    qq_xlate(fp, *p++);
}

/* --- @qq_head@ --- *
 *
 * Arguments:	@FILE *fp@ = output file handle
 *
 * Returns:	---
 *
 * Use:		Writes the head of a `qqout.c' file.
 */

void qq_head(FILE *fp)
{
  fputs("/* quine output file */\n\n", fp);
}

/* --- @qq_body@ --- *
 *
 * Arguments:	@FILE *fp@ = output file handle
 *		@const char ***p@ = pointer to main table
 *
 * Returns:	---
 *
 * Use:		Writes the body table of a `qqout.c' file.
 */

void qq_body(FILE *fp, const char ***p)
{
  size_t fno = 0;
  const char **q;

  fputs("/* --- file contents tables --- */\n\n", fp);
  while (*p) {
    q = *p;
    fprintf(fp, "static const char *qq__c_%lx[] = {\n", (unsigned long)fno);
    fprintf(fp, "/* Filename: */ \"%s\",\n", *q++);
    if (strncmp(*q, "%!", 2) == 0)
      fprintf(fp, "/* Mode: */ \"%s\",\n", *q++);
    while (*q)
      fprintf(fp, "\"%s\",\n", *q++);
    fputs("0\n};\n\n", fp);
    p++;
    fno++;
  }
}
    
/* --- @qq_tail@ --- *
 *
 * Arguments:	@FILE *fp@ = output file handle
 *		@const char **qql@ = pointer to qqlib file array
 *		@size_t fno@ = number of files written
 *		@const char *fn@ = name of `qqout.c' file
 *
 * Returns:	---
 *
 * Use:		Writes the head of a `qqout.c' file.
 */

void qq_tail(FILE *fp, const char **qql, size_t fno, const char *fn)
{
  const char **p;
  size_t i;

  /* --- Write out the qqlib array --- */

  fputs("/* --- qqlib code --- */\n\n"
	"const char *qq_qqlib[] = {\n", fp);
  for (p = qql; *p; p++)
    fprintf(fp, "\"%s\",\n", *p);
  fputs("0\n};\n\n", fp);

  /* --- Build the main array --- */

  fputs("/* --- table of files to output --- */\n\n"
	"const char **qq_table[] = {\n", fp);
  for (i = 0; i < fno; i++)
    fprintf(fp, "  qq__c_%lx,\n", (unsigned long)i);
  fputs("  0\n};\n\n", fp);

  /* --- Now output the qqlib code --- */

  fputs("#define QQ_OUT\n\n", fp);
  qq_file(fp, qql);

  /* --- Finally write the code to write everything out --- */

  fprintf(fp,
	  "/* --- quine output routines --- */\n\n"
	  "void qq_dump(FILE *fp) {\n"
	  "  qq__dump(fp, qq_table, qq_qqlib, \"%s\", %lu);\n"
	  "}\n"
	  "int qq_create(void) {\n"
	  "  return (qq__create(qq_table, qq_qqlib, \"%s\", %lu));\n"
	  "}\n\n",
	  fn, (unsigned long)fno, fn, (unsigned long)fno);
}

/* --- @qq_mkfile@ --- *
 *
 * Arguments:	@const char *fn@ = pointer to a filename
 *		@int mode@ = file mode to use (only in Unix-specific version)
 *
 * Returns:	A handle for the created file.
 *
 * Use:		Creates a file, and leading directories and stuff.
 */

#ifdef QUINE_PORTABLE
FILE *qq_mkfile(const char *fn)
{
  return (fopen(fn, "w"));
}
#else
FILE *qq_mkfile(const char *fn, int mode)
{
  char buf[FILENAME_MAX];
  char *p;
  int fd;

  strcpy(buf, fn);
  p = strchr(buf, '/');
  for (;;) {
    if (!p)
      break;
    *p = 0;
    mkdir(buf, 0777);
    *p = '/';
    p = strchr(p + 1, '/');
  }

  fd = open(fn, O_WRONLY|O_CREAT|O_TRUNC, mode);
  return (fd >=0 ? fdopen(fd, "w") : 0);
}
#endif

#ifdef QQ_OUT

/* --- @qq__dump@ --- *
 *
 * Arguments:	@FILE *fp@ = file to dump on
 *		@const char ***p@ = pointer to main table
 *		@const char **qql@ = pointer to qqlib code
 *		@const char *fn@ = name of `qqout.c' file
 *		@size_t fno@ = number of files to be output
 *
 * Returns:	---
 *
 * Use:		Outputs the entire source code to a given file.
 */

static void qq__dump(FILE *fp, const char ***p, const char **qql,
		     const char *fn, size_t fno)
{
  const char ***q = p;

  while (*q) {
    fprintf(fp, "******** %s\n\n", **q);
    qq_file(fp, *q + 1);
    q++;
  }
  fprintf(fp, "******** %s\n\n", fn);
  qq_head(fp);
  qq_body(fp, p);
  qq_tail(fp, qql, fno, fn);
}

/* --- @qq__create@ --- *
 *
 * Arguments:	@const char ***p@ = pointer to main table
 *		@const char **qql@ = pointer to qqlib code
 *		@const char *fn@ = name of `qqout.c' file
 *		@size_t fno@ = number of files to be output
 *
 * Returns:	Zero if all went well, else nonzero.
 *
 * Use:		Rebuilds the original source distribution.
 */

static int qq__create(const char ***p, const char **qql,
		      const char *fn, size_t fno)
{
  FILE *fp;
  const char ***q = p;
  
  while (*q) {
    const char **qq = *q + 1;

#ifdef QUINE_PORTABLE
    if (strncmp(*qq, "%!", 2) == 0)
      qq++;
    fp = qq_mkfile(*qq);
#else
    if (strncmp(*qq, "%!", 2) == 0) {
      fp = qq_mkfile(**q, (int)strtol(*qq + 2, 0, 8));
      qq++;
    } else
      fp = qq_mkfile(**q, 0666);
#endif
      
    if (!fp)
      return (-1);
    qq_file(fp, qq);
    if (fclose(fp))
      return (-1);
    q++;
  }
  fp = qq_mkfile(fn, 0666);
  if (!fp)
    return (-1);
  qq_head(fp);
  qq_body(fp, p);
  qq_tail(fp, qql, fno, fn);
  if (fclose(fp))
    return (-1);
  return (0);
}

#endif

/*----- That's all, folks -------------------------------------------------*/