Merge branch 'topic/sync-to-go-2'

[s-roff.git] / src / lib-driver / input.cpp

/*@ This file implements the parser for the intermediate roff output, see
 *@ XYroff_out(5), and does the printout for the given device.
 *@ All parsed information is processed within the function do_file().
 *@ A device postprocessor just needs to fill in the methods for the class
 *@ `printer' (or rather a derived class) without having to worry about the
 *@ syntax of the intermediate output format.  Consequently, the programming of
 *@ roff postprocessors is similar to the development of device drivers.
 *
 * Copyright (c) 2014 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
 *
 * Copyright (C) 1989 - 1992, 2001 - 2006, 2008
 *    Free Software Foundation, Inc.
 *
 *    Written by James Clark (jjc@jclark.com)
 *    Major rewrite 2001 by Bernd Warken (bwarken@mayn.de)
 *
 *    This 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, or (at your option)
 *    any later version.
 *
 *    This 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 groff; see the file COPYING.  If not, write to the Free
 *    Software Foundation, 51 Franklin St - Fifth Floor, Boston, MA
 *    02110-1301, USA.
 */

#include "config.h"

/*
 * Discussion of the positioning by drawing commands
 *
 * There was some confusion about the positioning of the graphical
 * pointer at the printout after having executed a `D' command.
 * The classical troff manual of Ossanna & Kernighan specified,
 *
 *   `The position after a graphical object has been drawn is
 *    at its end; for circles and ellipses, the "end" is at the
 *    right side.'
 *
 * From this, it follows that
 * - all open figures (args, splines, and lines) should position at their
 *   final point.
 * - all circles and ellipses should position at their right-most point
 *   (as if 2 halves had been drawn).
 * - all closed figures apart from circles and ellipses shouldn't change
 *   the position because they return to their origin.
 * - all setting commands should not change position because they do not
 *   draw any graphical object.
 *
 * In the case of the open figures, this means that the horizontal
 * displacement is the sum of all odd arguments and the vertical offset
 * the sum of all even arguments, called the alternate arguments sum
 * displacement in the following.
 *
 * Unfortunately, groff did not implement this simple rule.  The former
 * documentation in groff_out(5) differed from the source code, and
 * neither of them is compatible with the classical rule.
 *
 * The former groff_out(5) specified to use the alternative arguments
 * sum displacement for calculating the drawing positioning of
 * non-classical commands, including the `Dt' command (setting-only)
 * and closed polygons.  Applying this to the new groff color commands
 * will lead to disaster.  For their arguments can take large values (>
 * 65000).  On low resolution devices, the displacement of such large
 * values will corrupt the display or kill the printer.  So the
 * nonsense specification has come to a natural end anyway.
 *
 * The groff source code, however, had no positioning for the
 * setting-only commands (esp. `Dt'), the right-end positioning for
 * outlined circles and ellipses, and the alternative argument sum
 * displacement for all other commands (including filled circles and
 * ellipses).
 *
 * The reason why no one seems to have suffered from this mayhem so
 * far is that the graphical objects are usually generated by
 * preprocessors like pic that do not depend on the automatic
 * positioning.  When using the low level `\D' escape sequences or `D'
 * output commands, the strange positionings can be circumvented by
 * absolute positionings or by tricks like `\Z'.
 *
 * So doing an exorcism on the strange, incompatible displacements might
 * not harm any existing documents, but will make the usage of the
 * graphical escape sequences and commands natural.
 *
 * That's why the rewrite of this file returned to the reasonable,
 * classical specification with its clear end-of-drawing rule that is
 * suitable for all cases.  But a macro STUPID_DRAWING_POSITIONING is
 * provided for testing the funny former behavior.
 *
 * The new rule implies the following behavior.
 * - Setting commands (`Dt', `Df', `DF') and polygons (`Dp' and `DP')
 *   do not change position now.
 * - Filled circles and ellipses (`DC' and `DE') position at their
 *   most right point (outlined ones `Dc' and `De' did this anyway).
 * - As before, all open graphical objects position to their final
 *   drawing point (alternate sum of the command arguments).
 */

#ifndef STUPID_DRAWING_POSITIONING
// uncomment next line if all non-classical D commands shall position
// to the strange alternate sum of args displacement
#define STUPID_DRAWING_POSITIONING
#endif

// Decide whether the commands `{' and `}' for different environments
// should be used.
#undef USE_ENV_STACK

#include "driver.h"
#include "device.h"

#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdlib.h>

/**********************************************************************
                           local types
 **********************************************************************/

// integer type used in the fields of struct environment (see printer.h)
typedef int EnvInt;

// integer arguments of groff_out commands, must be >= 32 bits
typedef int IntArg;

// color components of groff_out color commands, must be >= 32 bits
typedef unsigned int ColorArg;

// Array for IntArg values.
class IntArray
{
  size_t num_allocated;
  size_t num_stored;
  IntArg *data;

public:
  IntArray(void);
  IntArray(const size_t);
  ~IntArray(void);
  IntArg operator[](const size_t i) const
  {
    if (i >= num_stored)
      fatal("index out of range");
    return (IntArg) data[i];
  }
  void append(IntArg);
  IntArg *get_data(void) const { return (IntArg *)data; }
  size_t len(void) const { return num_stored; }
};

// Characters read from the input queue.
class Char
{
  int data;

public:
  Char(void) : data('\0') {}
  Char(const int c) : data(c) {}
  bool operator==(char c) const { return (data == c) ? true : false; }
  bool operator==(int c) const { return (data == c) ? true : false; }
  bool operator==(const Char c) const
                  { return (data == c.data) ? true : false; }
  bool operator!=(char c) const { return !(*this == c); }
  bool operator!=(int c) const { return !(*this == c); }
  bool operator!=(const Char c) const { return !(*this == c); }
  operator int() const { return (int) data; }
  operator unsigned char() const { return (unsigned char) data; }
  operator char() const { return (char) data; }
};

// Buffer for string arguments (Char, not char).
class StringBuf
{
  size_t num_allocated;
  size_t num_stored;
  Char *data;                   // not terminated by '\0'

public:
  StringBuf(void);              // allocate without storing
  ~StringBuf(void);
  void append(const Char);      // append character to `data'
  char *make_string(void);      // return new copy of `data' with '\0'
  bool is_empty(void) {         // true if none stored
    return (num_stored > 0) ? false : true;
  }
  void reset(void);             // set `num_stored' to 0
};

#ifdef USE_ENV_STACK
class EnvStack
{
  environment **data;
  size_t num_allocated;
  size_t num_stored;

public:
  EnvStack(void);
  ~EnvStack(void);
  environment *pop(void);
  void push(environment *e);
};
#endif // USE_ENV_STACK


/**********************************************************************
                          external variables
 **********************************************************************/

// exported as extern by error.h (called from driver.h)
// needed for error messages (see ../lib-roff/error.cpp)
const char *current_filename = 0; // printable name of the current file
                                  // printable name of current source file
const char *current_source_filename = 0;
int current_lineno = 0;           // current line number of printout

// exported as extern by device.h;
const char *device = 0;           // cancel former init with literal

printer *pr;

// Note:
//
//   We rely on an implementation of the `new' operator which aborts
//   gracefully if it can't allocate memory (e.g. from lib-roff/new.cpp).

/**********************************************************************
                        static local variables
 **********************************************************************/

FILE *current_file = 0;         // current input stream for parser

// npages: number of pages processed so far (including current page),
//         _not_ the page number in the printout (can be set with `p').
int npages = 0;

const ColorArg
COLORARG_MAX = (ColorArg) 65536U; // == 0xFFFF + 1 == 0x10000

const IntArg
INTARG_MAX = (IntArg) 0x7FFFFFFF; // maximal signed 32 bits number

// parser environment, created and deleted by each run of do_file()
environment *current_env = 0;

#ifdef USE_ENV_STACK
const size_t
envp_size = sizeof(environment *);
#endif // USE_ENV_STACK

/**********************************************************************
                        function declarations
 **********************************************************************/

// utility functions
ColorArg color_from_Df_command(IntArg);
                                // transform old color into new
void delete_current_env(void);  // delete global var current_env
void fatal_command(char);       // abort for invalid command
inline Char get_char(void);     // read next character from input stream
ColorArg get_color_arg(void);   // read in argument for new color cmds
IntArray *get_D_fixed_args(const size_t);
                                // read in fixed number of integer
                                // arguments
IntArray *get_D_fixed_args_odd_dummy(const size_t);
                                // read in a fixed number of integer
                                // arguments plus optional dummy
IntArray *get_D_variable_args(void);
                                // variable, even number of int args
char *get_extended_arg(void);   // argument for `x X' (several lines)
IntArg get_integer_arg(void);   // read in next integer argument
IntArray *get_possibly_integer_args();
                                // 0 or more integer arguments
char *get_string_arg(void);     // read in next string arg, ended by WS
inline bool is_space_or_tab(const Char);
                                // test on space/tab char
Char next_arg_begin(void);      // skip white space on current line
Char next_command(void);        // go to next command, evt. diff. line
inline bool odd(const int);     // test if integer is odd
void position_to_end_of_args(const IntArray * const);
                                // positioning after drawing
void remember_filename(const char *);
                                // set global current_filename
void remember_source_filename(const char *);
                                // set global current_source_filename
void send_draw(const Char, const IntArray * const);
                                // call pr->draw
void skip_line(void);           // unconditionally skip to next line
bool skip_line_checked(void);   // skip line, false if args are left
void skip_line_fatal(void);     // skip line, fatal if args are left
void skip_line_warn(void);      // skip line, warn if args are left
void skip_line_D(void);         // skip line in D commands
void skip_line_x(void);         // skip line in x commands
void skip_to_end_of_line(void); // skip to the end of the current line
inline void unget_char(const Char);
                                // restore character onto input

// parser subcommands
void parse_color_command(color *);
                                // color sub(sub)commands m and DF
void parse_D_command(void);     // graphical subcommands
bool parse_x_command(void);     // device controller subcommands

/**********************************************************************
                         class methods
 **********************************************************************/

#ifdef USE_ENV_STACK
EnvStack::EnvStack(void)
{
  num_allocated = 4;
  // allocate pointer to array of num_allocated pointers to environment
  data = (environment **)malloc(envp_size * num_allocated);
  if (data == 0)
    fatal("could not allocate environment data");
  num_stored = 0;
}

EnvStack::~EnvStack(void)
{
  for (size_t i = 0; i < num_stored; i++)
    delete data[i];
  free(data);
}

// return top element from stack and decrease stack pointer
//
// the calling function must take care of properly deleting the result
environment *
EnvStack::pop(void)
{
  num_stored--;
  environment *result = data[num_stored];
  data[num_stored] = 0;
  return result;
}

// copy argument and push this onto the stack
void
EnvStack::push(environment *e)
{
  environment *e_copy = new environment;
  if (num_stored >= num_allocated) {
    environment **old_data = data;
    num_allocated *= 2;
    data = (environment **)malloc(envp_size * num_allocated);
    if (data == 0)
      fatal("could not allocate data");
    for (size_t i = 0; i < num_stored; i++)
      data[i] = old_data[i];
    free(old_data);
  }
  e_copy->col = new color;
  e_copy->fill = new color;
  *e_copy->col = *e->col;
  *e_copy->fill = *e->fill;
  e_copy->fontno = e->fontno;
  e_copy->height = e->height;
  e_copy->hpos = e->hpos;
  e_copy->size = e->size;
  e_copy->slant = e->slant;
  e_copy->vpos = e->vpos;
  data[num_stored] = e_copy;
  num_stored++;
}
#endif // USE_ENV_STACK

IntArray::IntArray(void)
{
  num_allocated = 4;
  data = new IntArg[num_allocated];
  num_stored = 0;
}

IntArray::IntArray(const size_t n)
{
  if (n <= 0)
    fatal("number of integers to be allocated must be > 0");
  num_allocated = n;
  data = new IntArg[num_allocated];
  num_stored = 0;
}

IntArray::~IntArray(void)
{
  a_delete data;
}

void
IntArray::append(IntArg x)
{
  if (num_stored >= num_allocated) {
    IntArg *old_data = data;
    num_allocated *= 2;
    data = new IntArg[num_allocated];
    for (size_t i = 0; i < num_stored; i++)
      data[i] = old_data[i];
    a_delete old_data;
  }
  data[num_stored] = x;
  num_stored++;
}

StringBuf::StringBuf(void)
{
  num_stored = 0;
  num_allocated = 128;
  data = new Char[num_allocated];
}

StringBuf::~StringBuf(void)
{
  a_delete data;
}

void
StringBuf::append(const Char c)
{
  if (num_stored >= num_allocated) {
    Char *old_data = data;
    num_allocated *= 2;
    data = new Char[num_allocated];
    for (size_t i = 0; i < num_stored; i++)
      data[i] = old_data[i];
    a_delete old_data;
  }
  data[num_stored] = c;
  num_stored++;
}

char *
StringBuf::make_string(void)
{
  char *result = new char[num_stored + 1];
  for (size_t i = 0; i < num_stored; i++)
    result[i] = (char) data[i];
  result[num_stored] = '\0';
  return result;
}

void
StringBuf::reset(void)
{
  num_stored = 0;
}

/**********************************************************************
                        utility functions
 **********************************************************************/

/* color_from_Df_command:
   Process the gray shade setting command Df.

   Transform Df style color into DF style color.
   Df color: 0-1000, 0 is white
   DF color: 0-65536, 0 is black

   The Df command is obsoleted by command DFg, but kept for
   compatibility.
*/
ColorArg
color_from_Df_command(IntArg Df_gray)
{
  return ColorArg((1000-Df_gray) * COLORARG_MAX / 1000); // scaling
}

/* delete_current_env():
   Delete global variable current_env and its pointer members.

   This should be a class method of environment.
*/
void delete_current_env(void)
{
  delete current_env->col;
  delete current_env->fill;
  delete current_env;
  current_env = 0;
}

/* fatal_command():
   Emit error message about invalid command and abort.
*/
void
fatal_command(char command)
{
  fatal("`%1' command invalid before first `p' command", command);
}

/* get_char():
   Retrieve the next character from the input queue.

   Return: The retrieved character (incl. EOF), converted to Char.
*/
inline Char
get_char(void)
{
  return (Char) getc(current_file);
}

/* get_color_arg():
   Retrieve an argument suitable for the color commands m and DF.

   Return: The retrieved color argument.
*/
ColorArg
get_color_arg(void)
{
  IntArg x = get_integer_arg();
  if (x < 0 || x > (IntArg)COLORARG_MAX) {
    error("color component argument out of range");
    x = 0;
  }
  return (ColorArg) x;
}

/* get_D_fixed_args():
   Get a fixed number of integer arguments for D commands.

   Fatal if wrong number of arguments.
   Too many arguments on the line raise a warning.
   A line skip is done.

   number: In-parameter, the number of arguments to be retrieved.
   ignore: In-parameter, ignore next argument -- GNU troff always emits
           pairs of parameters for `D' extensions added by groff.
           Default is `false'.

   Return: New IntArray containing the arguments.
*/
IntArray *
get_D_fixed_args(const size_t number)
{
  if (number <= 0)
    fatal("requested number of arguments must be > 0");
  IntArray *args = new IntArray(number);
  for (size_t i = 0; i < number; i++)
    args->append(get_integer_arg());
  skip_line_D();
  return args;
}

/* get_D_fixed_args_odd_dummy():
   Get a fixed number of integer arguments for D commands and optionally
   ignore a dummy integer argument if the requested number is odd.

   The gtroff program adds a dummy argument to some commands to get
   an even number of arguments.
   Error if the number of arguments differs from the scheme above.
   A line skip is done.

   number: In-parameter, the number of arguments to be retrieved.

   Return: New IntArray containing the arguments.
*/
IntArray *
get_D_fixed_args_odd_dummy(const size_t number)
{
  if (number <= 0)
    fatal("requested number of arguments must be > 0");
  IntArray *args = new IntArray(number);
  for (size_t i = 0; i < number; i++)
    args->append(get_integer_arg());
  if (odd(number)) {
    IntArray *a = get_possibly_integer_args();
    if (a->len() > 1)
      error("too many arguments");
    delete a;
  }
  skip_line_D();
  return args;
}

/* get_D_variable_args():
   Get a variable even number of integer arguments for D commands.

   Get as many integer arguments as possible from the rest of the
   current line.
   - The arguments are separated by an arbitrary sequence of space or
     tab characters.
   - A comment, a newline, or EOF indicates the end of processing.
   - Error on non-digit characters different from these.
   - A final line skip is performed (except for EOF).

   Return: New IntArray of the retrieved arguments.
*/
IntArray *
get_D_variable_args()
{
  IntArray *args = get_possibly_integer_args();
  size_t n = args->len();
  if (n <= 0)
    error("no arguments found");
  if (odd(n))
    error("even number of arguments expected");
  skip_line_D();
  return args;
}

/* get_extended_arg():
   Retrieve extended arg for `x X' command.

   - Skip leading spaces and tabs, error on EOL or newline.
   - Return everything before the next NL or EOF ('#' is not a comment);
     as long as the following line starts with '+' this is returned
     as well, with the '+' replaced by a newline.
   - Final line skip is always performed.

   Return: Allocated (new) string of retrieved text argument.
*/
char *
get_extended_arg(void)
{
  StringBuf buf = StringBuf();
  Char c = next_arg_begin();
  while ((int) c != EOF) {
    if ((int) c == '\n') {
      current_lineno++;
      c = get_char();
      if ((int) c == '+')
        buf.append((Char) '\n');
      else {
        unget_char(c);          // first character of next line
        break;
      }
    }
    else
      buf.append(c);
    c = get_char();
  }
  return buf.make_string();
}

/* get_integer_arg(): Retrieve integer argument.

   Skip leading spaces and tabs, collect an optional '-' and all
   following decimal digits (at least one) up to the next non-digit,
   which is restored onto the input queue.

   Fatal error on all other situations.

   Return: Retrieved integer.
*/
IntArg
get_integer_arg(void)
{
  StringBuf buf = StringBuf();
  Char c = next_arg_begin();
  if ((int) c == '-') {
    buf.append(c);
    c = get_char();
  }
  if (!isdigit((int) c))
    error("integer argument expected");
  while (isdigit((int) c)) {
    buf.append(c);
    c = get_char();
  }
  // c is not a digit
  unget_char(c);
  char *s = buf.make_string();
  errno = 0;
  long int number = strtol(s, 0, 10);
  if (errno != 0
      || number > INTARG_MAX || number < -INTARG_MAX) {
    error("integer argument too large");
    number = 0;
  }
  a_delete s;
  return (IntArg) number;
}

/* get_possibly_integer_args():
   Parse the rest of the input line as a list of integer arguments.

   Get as many integer arguments as possible from the rest of the
   current line, even none.
   - The arguments are separated by an arbitrary sequence of space or
     tab characters.
   - A comment, a newline, or EOF indicates the end of processing.
   - Error on non-digit characters different from these.
   - No line skip is performed.

   Return: New IntArray of the retrieved arguments.
*/
IntArray *
get_possibly_integer_args()
{
  bool done = false;
  StringBuf buf = StringBuf();
  Char c = get_char();
  IntArray *args = new IntArray();
  while (!done) {
    buf.reset();
    while (is_space_or_tab(c))
      c = get_char();
    if (c == '-') {
      Char c1 = get_char();
      if (isdigit((int) c1)) {
        buf.append(c);
        c = c1;
      }
      else
        unget_char(c1);
    }
    while (isdigit((int) c)) {
      buf.append(c);
      c = get_char();
    }
    if (!buf.is_empty()) {
      char *s = buf.make_string();
      errno = 0;
      long int x = strtol(s, 0, 10);
      if (errno
          || x > INTARG_MAX || x < -INTARG_MAX) {
        error("invalid integer argument, set to 0");
        x = 0;
      }
      args->append((IntArg) x);
      a_delete s;
    }
    // Here, c is not a digit.
    // Terminate on comment, end of line, or end of file, while
    // space or tab indicate continuation; otherwise error.
    switch((int) c) {
    case '#':
      skip_to_end_of_line();
      done = true;
      break;
    case '\n':
      done = true;
      unget_char(c);
      break;
    case EOF:
      done = true;
      break;
    case ' ':
    case '\t':
      break;
    default:
      error("integer argument expected");
      break;
    }
  }
  return args;
}

/* get_string_arg():
   Retrieve string arg.

   - Skip leading spaces and tabs; error on EOL or newline.
   - Return all following characters before the next space, tab,
     newline, or EOF character (in-word '#' is not a comment character).
   - The terminating space, tab, newline, or EOF character is restored
     onto the input queue, so no line skip.

   Return: Retrieved string as char *, allocated by 'new'.
*/
char *
get_string_arg(void)
{
  StringBuf buf = StringBuf();
  Char c = next_arg_begin();
  while (!is_space_or_tab(c)
         && c != Char('\n') && c != Char(EOF)) {
    buf.append(c);
    c = get_char();
  }
  unget_char(c);                // restore white space
  return buf.make_string();
}

/* is_space_or_tab():
   Test a character if it is a space or tab.

   c: In-parameter, character to be tested.

   Return: True, if c is a space or tab character, false otherwise.
*/
inline bool
is_space_or_tab(const Char c)
{
  return (c == Char(' ') || c == Char('\t')) ? true : false;
}

/* next_arg_begin():
   Return first character of next argument.

   Skip space and tab characters; error on newline or EOF.

   Return: The first character different from these (including '#').
*/
Char
next_arg_begin(void)
{
  Char c;
  while (1) {
    c = get_char();
    switch ((int) c) {
    case ' ':
    case '\t':
      break;
    case '\n':
    case EOF:
      error("missing argument");
      break;
    default:                    // first essential character
      return c;
    }
  }
}

/* next_command():
   Find the first character of the next command.

   Skip spaces, tabs, comments (introduced by #), and newlines.

   Return: The first character different from these (including EOF).
*/
Char
next_command(void)
{
  Char c;
  while (1) {
    c = get_char();
    switch ((int) c) {
    case ' ':
    case '\t':
      break;
    case '\n':
      current_lineno++;
      break;
    case '#':                   // comment
      skip_line();
      break;
    default:                    // EOF or first essential character
      return c;
    }
  }
}

/* odd():
   Test whether argument is an odd number.

   n: In-parameter, the integer to be tested.

   Return: True if odd, false otherwise.
*/
inline bool
odd(const int n)
{
  return (n & 1) ? true : false;
}

/* position_to_end_of_args():
   Move graphical pointer to end of drawn figure.

   This is used by the D commands that draw open geometrical figures.
   The algorithm simply sums up all horizontal displacements (arguments
   with even number) for the horizontal component.  Similarly, the
   vertical component is the sum of the odd arguments.

   args: In-parameter, the arguments of a former drawing command.
*/
void
position_to_end_of_args(const IntArray * const args)
{
  size_t i;
  const size_t n = args->len();
  for (i = 0; i < n; i += 2)
    current_env->hpos += (*args)[i];
  for (i = 1; i < n; i += 2)
    current_env->vpos += (*args)[i];
}

/* remember_filename():
   Set global variable current_filename.

   The actual filename is stored in current_filename.  This is used by
   the postprocessors, expecting the name "<standard input>" for stdin.

   filename: In-out-parameter; is changed to the new value also.
*/
void
remember_filename(const char *filename)
{
  char *fname;
  if (strcmp(filename, "-") == 0)
    fname = (char *)"<standard input>";
  else
    fname = (char *)filename;
  size_t len = strlen(fname) + 1;
  if (current_filename != 0)
    free((char *)current_filename);
  current_filename = (const char *)malloc(len);
  if (current_filename == 0)
    fatal("can't malloc space for filename");
  strncpy((char *)current_filename, (char *)fname, len);
}

/* remember_source_filename():
   Set global variable current_source_filename.

   The actual filename is stored in current_filename.  This is used by
   the postprocessors, expecting the name "<standard input>" for stdin.

   filename: In-out-parameter; is changed to the new value also.
*/
void
remember_source_filename(const char *filename)
{
  char *fname;
  if (strcmp(filename, "-") == 0)
    fname = (char *)"<standard input>";
  else
    fname = (char *)filename;
  size_t len = strlen(fname) + 1;
  if (current_source_filename != 0)
    free((char *)current_source_filename);
  current_source_filename = (const char *)malloc(len);
  if (current_source_filename == 0)
    fatal("can't malloc space for filename");
  strncpy((char *)current_source_filename, (char *)fname, len);
}

/* send_draw():
   Call draw method of printer class.

   subcmd: Letter of actual D subcommand.
   args: Array of integer arguments of actual D subcommand.
*/
void
send_draw(const Char subcmd, const IntArray * const args)
{
  EnvInt n = (EnvInt) args->len();
  pr->draw((int) subcmd, (IntArg *)args->get_data(), n, current_env);
}

/* skip_line():
   Go to next line within the input queue.

   Skip the rest of the current line, including the newline character.
   The global variable current_lineno is adjusted.
   No errors are raised.
*/
void
skip_line(void)
{
  Char c = get_char();
  while (1) {
    if (c == '\n') {
      current_lineno++;
      break;
    }
    if (c == EOF)
      break;
    c = get_char();
  }
}

/* skip_line_checked ():
   Check that there aren't any arguments left on the rest of the line,
   then skip line.

   Spaces, tabs, and a comment are allowed before newline or EOF.
   All other characters raise an error.
*/
bool
skip_line_checked(void)
{
  bool ok = true;
  Char c = get_char();
  while (is_space_or_tab(c))
    c = get_char();
  switch((int) c) {
  case '#':                     // comment
    skip_line();
    break;
  case '\n':
    current_lineno++;
    break;
  case EOF:
    break;
  default:
    ok = false;
    skip_line();
    break;
  }
  return ok;
}

/* skip_line_fatal ():
   Fatal error if arguments left, otherwise skip line.

   Spaces, tabs, and a comment are allowed before newline or EOF.
   All other characters trigger the error.
*/
void
skip_line_fatal(void)
{
  bool ok = skip_line_checked();
  if (!ok) {
    current_lineno--;
    error("too many arguments");
    current_lineno++;
  }
}

/* skip_line_warn ():
   Skip line, but warn if arguments are left on actual line.

   Spaces, tabs, and a comment are allowed before newline or EOF.
   All other characters raise a warning
*/
void
skip_line_warn(void)
{
  bool ok = skip_line_checked();
  if (!ok) {
    current_lineno--;
    warning("too many arguments on current line");
    current_lineno++;
  }
}

/* skip_line_D ():
   Skip line in `D' commands.

   Decide whether in case of an additional argument a fatal error is
   raised (the documented classical behavior), only a warning is
   issued, or the line is just skipped (former groff behavior).
   Actually decided for the warning.
*/
void
skip_line_D(void)
{
  skip_line_warn();
  // or: skip_line_fatal();
  // or: skip_line();
}

/* skip_line_x ():
   Skip line in `x' commands.

   Decide whether in case of an additional argument a fatal error is
   raised (the documented classical behavior), only a warning is
   issued, or the line is just skipped (former groff behavior).
   Actually decided for the warning.
*/
void
skip_line_x(void)
{
  skip_line_warn();
  // or: skip_line_fatal();
  // or: skip_line();
}

/* skip_to_end_of_line():
   Go to the end of the current line.

   Skip the rest of the current line, excluding the newline character.
   The global variable current_lineno is not changed.
   No errors are raised.
*/
void
skip_to_end_of_line(void)
{
  Char c = get_char();
  while (1) {
    if (c == '\n') {
      unget_char(c);
      return;
    }
    if (c == EOF)
      return;
    c = get_char();
  }
}

/* unget_char(c):
   Restore character c onto input queue.

   Write a character back onto the input stream.
   EOF is gracefully handled.

   c: In-parameter; character to be pushed onto the input queue.
*/
inline void
unget_char(const Char c)
{
  if (c != EOF) {
    int ch = (int) c;
    if (ungetc(ch, current_file) == EOF)
      fatal("could not unget character");
  }
}

/**********************************************************************
                       parser subcommands
 **********************************************************************/

/* parse_color_command:
   Process the commands m and DF, but not Df.

   col: In-out-parameter; the color object to be set, must have
        been initialized before.
*/
void
parse_color_command(color *col)
{
  ColorArg gray = 0;
  ColorArg red = 0, green = 0, blue = 0;
  ColorArg cyan = 0, magenta = 0, yellow = 0, black = 0;
  Char subcmd = next_arg_begin();
  switch((int) subcmd) {
  case 'c':                     // DFc or mc: CMY
    cyan = get_color_arg();
    magenta = get_color_arg();
    yellow = get_color_arg();
    col->set_cmy(cyan, magenta, yellow);
    break;
  case 'd':                     // DFd or md: set default color
    col->set_default();
    break;
  case 'g':                     // DFg or mg: gray
    gray = get_color_arg();
    col->set_gray(gray);
    break;
  case 'k':                     // DFk or mk: CMYK
    cyan = get_color_arg();
    magenta = get_color_arg();
    yellow = get_color_arg();
    black = get_color_arg();
    col->set_cmyk(cyan, magenta, yellow, black);
    break;
  case 'r':                     // DFr or mr: RGB
    red = get_color_arg();
    green = get_color_arg();
    blue = get_color_arg();
    col->set_rgb(red, green, blue);
    break;
  default:
    error("invalid color scheme `%1'", (int) subcmd);
    break;
  } // end of color subcommands
}

/* parse_D_command():
   Parse the subcommands of graphical command D.

   This is the part of the do_file() parser that scans the graphical
   subcommands.
   - Error on lacking or wrong arguments.
   - Warning on too many arguments.
   - Line is always skipped.
*/
void
parse_D_command()
{
  Char subcmd = next_arg_begin();
  switch((int) subcmd) {
  case '~':                     // D~: draw B-spline
    // actually, this isn't available for some postprocessors
    // fall through
  default:                      // unknown options are passed to device
    {
      IntArray *args = get_D_variable_args();
      send_draw(subcmd, args);
      position_to_end_of_args(args);
      delete args;
      break;
    }
  case 'a':                     // Da: draw arc
    {
      IntArray *args = get_D_fixed_args(4);
      send_draw(subcmd, args);
      position_to_end_of_args(args);
      delete args;
      break;
    }
  case 'c':                     // Dc: draw circle line
    {
      IntArray *args = get_D_fixed_args(1);
      send_draw(subcmd, args);
      // move to right end
      current_env->hpos += (*args)[0];
      delete args;
      break;
    }
  case 'C':                     // DC: draw solid circle
    {
      IntArray *args = get_D_fixed_args_odd_dummy(1);
      send_draw(subcmd, args);
      // move to right end
      current_env->hpos += (*args)[0];
      delete args;
      break;
    }
  case 'e':                     // De: draw ellipse line
  case 'E':                     // DE: draw solid ellipse
    {
      IntArray *args = get_D_fixed_args(2);
      send_draw(subcmd, args);
      // move to right end
      current_env->hpos += (*args)[0];
      delete args;
      break;
    }
  case 'f':                     // Df: set fill gray; obsoleted by DFg
    {
      IntArg arg = get_integer_arg();
      if ((arg >= 0) && (arg <= 1000)) {
        // convert arg and treat it like DFg
        ColorArg gray = color_from_Df_command(arg);
        current_env->fill->set_gray(gray);
      }
      else {
        // set fill color to the same value as the current outline color
        delete current_env->fill;
        current_env->fill = new color(current_env->col);
      }
      pr->change_fill_color(current_env);
      // skip unused `vertical' component (\D'...' always emits pairs)
      (void) get_integer_arg();
#   ifdef STUPID_DRAWING_POSITIONING
      current_env->hpos += arg;
#   endif
      skip_line_x();
      break;
    }
  case 'F':                     // DF: set fill color, several formats
    parse_color_command(current_env->fill);
    pr->change_fill_color(current_env);
    // no positioning (setting-only command)
    skip_line_x();
    break;
  case 'l':                     // Dl: draw line
    {
      IntArray *args = get_D_fixed_args(2);
      send_draw(subcmd, args);
      position_to_end_of_args(args);
      delete args;
      break;
    }
  case 'p':                     // Dp: draw closed polygon line
  case 'P':                     // DP: draw solid closed polygon
    {
      IntArray *args = get_D_variable_args();
      send_draw(subcmd, args);
#   ifdef STUPID_DRAWING_POSITIONING
      // final args positioning
      position_to_end_of_args(args);
#   endif
      delete args;
      break;
    }
  case 't':                     // Dt: set line thickness
    {
      IntArray *args = get_D_fixed_args_odd_dummy(1);
      send_draw(subcmd, args);
#   ifdef STUPID_DRAWING_POSITIONING
      // final args positioning
      position_to_end_of_args(args);
#   endif
      delete args;
      break;
    }
  } // end of D subcommands
}

/* parse_x_command():
   Parse subcommands of the device control command x.

   This is the part of the do_file() parser that scans the device
   controlling commands.
   - Error on duplicate prologue commands.
   - Error on wrong or lacking arguments.
   - Warning on too many arguments.
   - Line is always skipped.

   Globals:
   - current_env: is set by many subcommands.
   - npages: page counting variable

   Return: boolean in the meaning of `stopped'
           - true if parsing should be stopped (`x stop').
           - false if parsing should continue.
*/
bool
parse_x_command(void)
{
  bool stopped = false;
  char *subcmd_str = get_string_arg();
  char subcmd = subcmd_str[0];
  switch (subcmd) {
  case 'f':                     // x font: mount font
    {
      IntArg n = get_integer_arg();
      char *name = get_string_arg();
      pr->load_font(n, name);
      a_delete name;
      skip_line_x();
      break;
    }
  case 'F':                     // x Filename: set filename for errors
    {
      char *str_arg = get_extended_arg();
      if (str_arg == 0)
        warning("empty argument for `x F' command");
      else {
        remember_source_filename(str_arg);
        a_delete str_arg;
      }
      break;
    }
  case 'H':                     // x Height: set character height
    current_env->height = get_integer_arg();
    if (current_env->height == current_env->size)
      current_env->height = 0;
    skip_line_x();
    break;
  case 'i':                     // x init: initialize device
    error("duplicate `x init' command");
    skip_line_x();
    break;
  case 'p':                     // x pause: pause device
    skip_line_x();
    break;
  case 'r':                     // x res: set resolution
    error("duplicate `x res' command");
    skip_line_x();
    break;
  case 's':                     // x stop: stop device
    stopped = true;
    skip_line_x();
    break;
  case 'S':                     // x Slant: set slant
    current_env->slant = get_integer_arg();
    skip_line_x();
    break;
  case 't':                     // x trailer: generate trailer info
    skip_line_x();
    break;
  case 'T':                     // x Typesetter: set typesetter
    error("duplicate `x T' command");
    skip_line();
    break;
  case 'u':                     // x underline: from .cu
    {
      char *str_arg = get_string_arg();
      pr->special(str_arg, current_env, 'u');
      a_delete str_arg;
      skip_line_x();
      break;
    }
  case 'X':                     // x X: send uninterpretedly to device
    {
      char *str_arg = get_extended_arg(); // includes line skip
      if (npages <= 0)
        error("`x X' command invalid before first `p' command");
      else if (str_arg && (strncmp(str_arg, "devtag:",
                                   strlen("devtag:")) == 0))
        pr->devtag(str_arg, current_env);
      else
        pr->special(str_arg, current_env);
      a_delete str_arg;
      break;
    }
  default:                      // ignore unknown x commands, but warn
    warning("unknown command `x %1'", subcmd);
    skip_line();
  }
  a_delete subcmd_str;
  return stopped;
}

/**********************************************************************
                     exported part (by driver.h)
 **********************************************************************/

/* do_file():
   Parse and postprocess groff intermediate output.

   filename: "-" for standard input, normal file name otherwise
*/
void
do_file(const char *filename)
{
  Char command;
  bool stopped = false;         // terminating condition

#ifdef USE_ENV_STACK
  EnvStack env_stack = EnvStack();
#endif // USE_ENV_STACK

  // setup of global variables
  npages = 0;
  current_lineno = 1;
  // `pr' is initialized after the prologue.
  // `device' is set by the 1st prologue command.

  if (filename[0] == '-' && filename[1] == '\0')
    current_file = stdin;
  else {
    errno = 0;
    current_file = fopen(filename, "r");
    if (errno != 0 || current_file == 0) {
      error("can't open file `%1'", filename);
      return;
    }
  }
  remember_filename(filename);

  if (current_env != 0)
    delete_current_env();
  current_env = new environment;
  current_env->col = new color;
  current_env->fill = new color;
  current_env->fontno = -1;
  current_env->height = 0;
  current_env->hpos = -1;
  current_env->slant = 0;
  current_env->size = 0;
  current_env->vpos = -1;

  // parsing of prologue (first 3 commands)
  {
    char *str_arg;
    IntArg int_arg;

    // 1st command `x T'
    command = next_command();
    if ((int) command == EOF)
      return;
    if ((int) command != 'x')
      fatal("the first command must be `x T'");
    str_arg = get_string_arg();
    if (str_arg[0] != 'T')
      fatal("the first command must be `x T'");
    a_delete str_arg;
    char *tmp_dev = get_string_arg();
    if (pr == 0) {              // note: `pr' initialized after prologue
      device = tmp_dev;
      if (!font::load_desc())
        fatal("couldn't load DESC file, can't continue");
    }
    else {
      if (device == 0 || strcmp(device, tmp_dev) != 0)
        fatal("all files must use the same device");
      a_delete tmp_dev;
    }
    skip_line_x();              // ignore further arguments
    current_env->size = 10 * font::sizescale;

    // 2nd command `x res'
    command = next_command();
    if ((int) command != 'x')
      fatal("the second command must be `x res'");
    str_arg = get_string_arg();
    if (str_arg[0] != 'r')
      fatal("the second command must be `x res'");
    a_delete str_arg;
    int_arg = get_integer_arg();
    EnvInt font_res = font::res;
    if (int_arg != font_res)
      fatal("resolution does not match");
    int_arg = get_integer_arg();
    if (int_arg != font::hor)
      fatal("minimum horizontal motion does not match");
    int_arg = get_integer_arg();
    if (int_arg != font::vert)
      fatal("minimum vertical motion does not match");
    skip_line_x();              // ignore further arguments

    // 3rd command `x init'
    command = next_command();
    if (command != 'x')
      fatal("the third command must be `x init'");
    str_arg = get_string_arg();
    if (str_arg[0] != 'i')
      fatal("the third command must be `x init'");
    a_delete str_arg;
    skip_line_x();
  }

  // parsing of body
  if (pr == 0)
    pr = make_printer();
  while (!stopped) {
    command = next_command();
    if (command == EOF)
      break;
    // spaces, tabs, comments, and newlines are skipped here
    switch ((int) command) {
    case '#':                   // #: comment, ignore up to end of line
      skip_line();
      break;
#ifdef USE_ENV_STACK
    case '{':                   // {: start a new environment (a copy)
      env_stack.push(current_env);
      break;
    case '}':                   // }: pop previous env from stack
      delete_current_env();
      current_env = env_stack.pop();
      break;
#endif // USE_ENV_STACK
    case '0':                   // ddc: obsolete jump and print command
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      {                         // expect 2 digits and a character
        char s[3];
        Char c = next_arg_begin();
        if (npages <= 0)
          fatal_command(command);
        if (!isdigit((int) c)) {
          error("digit expected");
          c = 0;
        }
        s[0] = (char) command;
        s[1] = (char) c;
        s[2] = '\0';
        errno = 0;
        long int x = strtol(s, 0, 10);
        if (errno != 0)
          error("couldn't convert 2 digits");
        EnvInt hor_pos = (EnvInt) x;
        current_env->hpos += hor_pos;
        c = next_arg_begin();
        if ((int) c == '\n' || (int) c == EOF)
          error("character argument expected");
        else
          pr->set_ascii_char((unsigned char) c, current_env);
        break;
      }
    case 'c':                   // c: print ascii char without moving
      {
        if (npages <= 0)
          fatal_command(command);
        Char c = next_arg_begin();
        if (c == '\n' || c == EOF)
          error("missing argument to `c' command");
        else
          pr->set_ascii_char((unsigned char) c, current_env);
        break;
      }
    case 'C':                   // C: print named special character
      {
        if (npages <= 0)
          fatal_command(command);
        char *str_arg = get_string_arg();
        pr->set_special_char(str_arg, current_env);
        a_delete str_arg;
        break;
      }
    case 'D':                   // drawing commands
      if (npages <= 0)
        fatal_command(command);
      parse_D_command();
      break;
    case 'f':                   // f: set font to number
      current_env->fontno = get_integer_arg();
      break;
    case 'F':                   // F: obsolete, replaced by `x F'
      {
        char *str_arg = get_extended_arg();
        remember_source_filename(str_arg);
        a_delete str_arg;
        break;
      }
    case 'h':                   // h: relative horizontal move
      current_env->hpos += (EnvInt) get_integer_arg();
      break;
    case 'H':                   // H: absolute horizontal positioning
      current_env->hpos = (EnvInt) get_integer_arg();
      break;
    case 'm':                   // m: glyph color
      parse_color_command(current_env->col);
      pr->change_color(current_env);
      break;
    case 'n':                   // n: print end of line
                                // ignore two arguments (historically)
      if (npages <= 0)
        fatal_command(command);
      pr->end_of_line();
      (void) get_integer_arg();
      (void) get_integer_arg();
      break;
    case 'N':                   // N: print char with given int code
      if (npages <= 0)
        fatal_command(command);
      pr->set_numbered_char(get_integer_arg(), current_env);
      break;
    case 'p':                   // p: start new page with given number
      if (npages > 0)
        pr->end_page(current_env->vpos);
      npages++;                 // increment # of processed pages
      pr->begin_page(get_integer_arg());
      current_env->vpos = 0;
      break;
    case 's':                   // s: set point size
      current_env->size = get_integer_arg();
      if (current_env->height == current_env->size)
        current_env->height = 0;
      break;
    case 't':                   // t: print a text word
      {
        char c;
        if (npages <= 0)
          fatal_command(command);
        char *str_arg = get_string_arg();
        size_t i = 0;
        while ((c = str_arg[i++]) != '\0') {
          EnvInt w;
          pr->set_ascii_char((unsigned char) c, current_env, &w);
          current_env->hpos += w;
        }
        a_delete str_arg;
        break;
      }
    case 'u':                   // u: print spaced word
      {
        char c;
        if (npages <= 0)
          fatal_command(command);
        EnvInt kern = (EnvInt) get_integer_arg();
        char *str_arg = get_string_arg();
        size_t i = 0;
        while ((c = str_arg[i++]) != '\0') {
          EnvInt w;
          pr->set_ascii_char((unsigned char) c, current_env, &w);
          current_env->hpos += w + kern;
        }
        a_delete str_arg;
        break;
      }
    case 'v':                   // v: relative vertical move
      current_env->vpos += (EnvInt) get_integer_arg();
      break;
    case 'V':                   // V: absolute vertical positioning
      current_env->vpos = (EnvInt) get_integer_arg();
      break;
    case 'w':                   // w: inform about paddable space
      break;
    case 'x':                   // device controlling commands
      stopped = parse_x_command();
      break;
    default:
      warning("unrecognized command `%1'", (unsigned char) command);
      skip_line();
      break;
    } // end of switch
  } // end of while

  // end of file reached
  if (npages > 0)
    pr->end_page(current_env->vpos);
  delete pr;
  pr = 0;
  fclose(current_file);
  // If `stopped' is not `true' here then there wasn't any `x stop'.
  if (!stopped)
    warning("no final `x stop' command");
  delete_current_env();
}

// s-it2-mode