[fwd] / scan.c

/* -*-c-*-
 *
 * Character scanners
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the `fw' port forwarder.
 *
 * `fw' 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.
 *
 * `fw' 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 `fw'; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

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

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

#include <mLib/dstr.h>
#include <mLib/sub.h>

#include "scan.h"

/*----- File scanner source -----------------------------------------------*/

/* --- File scanner block --- */

typedef struct fscan {
  scansrc ss;
  FILE *fp;
  unsigned f;
} fscan;

/* --- @scan@ --- */

static int fscan_scan(scansrc *ss)
{
  fscan *fs = (fscan *)ss;
  int ch = getc(fs->fp);
  if (ch == '\n')
    fs->ss.line++;
  return (ch);
}

/* --- @destroy@ --- */

static void fscan_destroy(scansrc *ss)
{
  fscan *fs = (fscan *)ss;
  if (!(fs->f & SCF_NOCLOSE))
    fclose(fs->fp);
  xfree(fs->ss.src);
  DESTROY(fs);
}

/* --- File scanner operations --- */

static scansrc_ops fscan_ops = { fscan_scan, fscan_destroy };

/* --- @scan_file@ --- *
 *
 * Arguments:   @FILE *fp@ = pointer to file descriptor
 *              @const char *name@ = pointer to source file name
 *              @unsigned f@ = flags
 *
 * Returns:     A scanner source.
 *
 * Use:         Creates a new scanner source for reading from a file.
 */

scansrc *scan_file(FILE *fp, const char *name, unsigned f)
{
  fscan *fs = CREATE(fscan);
  fs->ss.ops = &fscan_ops;
  fs->ss.src = xstrdup(name);
  fs->ss.line = 1;
  fs->fp = fp;
  fs->f = f;
  return (&fs->ss);
}

/*---- Argv scanner source ------------------------------------------------*/

/* --- Argv scanner block --- */

typedef struct avscan {
  scansrc ss;
  char **av;
  char *p;
} avscan;

/* --- @scan@ --- */

static int avscan_scan(scansrc *ss)
{
  avscan *as = (avscan *)ss;
  int ch;
  if (!as->p)
    ch = EOF;
  else if ((ch = (unsigned char)*as->p++) == 0) {
    as->ss.line++;
    as->p = *as->av++;
    ch = '\n';
  }
  return (ch);
}

/* --- @destroy@ --- */

static void avscan_destroy(scansrc *ss)
{
  avscan *as = (avscan *)ss;
  DESTROY(as);
}

/* --- Argv scanner operations --- */

static scansrc_ops avscan_ops = { avscan_scan, avscan_destroy };

/* --- @scan_argv@ --- *
 *
 * Arguments:   @char **av@ = pointer to argument array (null terminated)
 *
 * Returns:     A scanner source.
 *
 * Use:         Creates a new scanner source for reading from an @argv@
 *              array.
 */

scansrc *scan_argv(char **av)
{
  avscan *as = CREATE(avscan);
  as->ss.ops = &avscan_ops;
  as->ss.src = "<argv>";
  as->ss.line = 1;
  as->p = *av++;
  as->av = av;
  return (&as->ss);
}

/*----- End-of-file sentinel block ----------------------------------------*/

/* --- @scan@ --- */

static int eof_scan(scansrc *ss)
{
  return (EOF);
}

/* --- @destroy@ --- */

static void eof_destroy(scansrc *ss)
{
  ;
}

/* --- Eof scanner operations --- */

static scansrc_ops eof_ops = { eof_scan, eof_destroy };

/* --- The end of file marker --- */

static scansrc scan_eof = { &scan_eof, &eof_ops, "<eof>", 0, DSTR_INIT };

/*----- General scanner handling ------------------------------------------*/

/* --- @scan@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to main scanner context
 *
 * Returns:     Character read, or end-of-file.
 *
 * Use:         Scans a character from a source of characters.
 */

int scan(scanner *sc)
{
  int ch;
  if (sc->head->pushback.len)
    ch = sc->head->pushback.buf[--sc->head->pushback.len];
  else {
    scansrc *ss = sc->head;
    if (ss == &scan_eof)
      ch = EOF;
    else if ((ch = ss->ops->scan(ss)) == EOF) {
      sc->head = ss->next;
      if (sc->head == &scan_eof)
        sc->tail = &sc->head;
      ss->ops->destroy(ss);
      ch = '\n';
    }
  }
  return (ch);
}

/* --- @unscan@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to main scanner context
 *              @int ch@ = character to unscan
 *
 * Returns:     ---
 *
 * Use:         Scans a character from a source of characters.
 */

void unscan(scanner *sc, int ch)
{
  DPUTC(&sc->head->pushback, ch);
}

/* --- @scan_push@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to main scanner context
 *              @scansrc *ss@ = souorce to push
 *
 * Returns:     ---
 *
 * Use:         Pushes a scanner source onto the front of the queue.
 */

void scan_push(scanner *sc, scansrc *ss)
{
  ss->next = sc->head;
  if (sc->head == &scan_eof)
    sc->tail = &ss->next;
  sc->head = ss;
  dstr_create(&ss->pushback);
  ss->tok = 0;
  ss->t = 0;
}

/* --- @scan_add@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to main scanner context
 *              @scansrc *ss@ = souorce to push
 *
 * Returns:     ---
 *
 * Use:         Adds a scanner source onto the end of the queue.
 */

void scan_add(scanner *sc, scansrc *ss)
{
  ss->next = &scan_eof;
  *sc->tail = ss;
  sc->tail = &ss->next;
  dstr_create(&ss->pushback);
  ss->tok = 0;
  ss->t = 0;
}

/* --- @scan_create@ --- *
 *
 * Arguments:   @scanner *sc@ = scanner context to initialize
 *
 * Returns:     ---
 *
 * Use:         Initializes a scanner block ready for use.
 */

void scan_create(scanner *sc)
{
  sc->head = &scan_eof;
  sc->tail = &sc->head;
  dstr_create(&sc->d);
  sc->wbegin = sc->wcont = 0;
}

/* --- @scan_destroy@ --- *
 *
 * Arguments:   @scanner *sc@ = pointer to scanner context
 *
 * Returns:     ---
 *
 * Use:         Destroys a scanner and all the sources attached to it.
 */

void scan_destroy(scanner *sc)
{
  scansrc *ss = sc->head;
  while (ss != &scan_eof) {
    scansrc *sss = ss;
    ss = ss->next;
    if (sss->tok)
      xfree(sss->tok);
    dstr_destroy(&sss->pushback);
    sss->ops->destroy(sss);
  }
  dstr_destroy(&sc->d);
  if (scan_eof.tok)
    xfree(scan_eof.tok);
  scan_eof.tok = 0;
  sc->head = &scan_eof;
  sc->tail = &sc->head;
}

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