/**********************************************************************
 * subset of POSIX regcomp() implemented on re_comp()
 *
 * $Author: cfields $
 * $Source: /mit/slw/src/RCS/regcomp.c,v $
 * $Header: /mit/slw/src/RCS/regcomp.c,v 1.1 1995/01/18 05:19:10 cfields Exp cfields $
 *
 * Copyright 1994 by the Massachusetts Institute of Technology.
 *
 * For copying and distribution information, please see the file
 * <mit-copyright.h>.
 **********************************************************************/

#include <sys/types.h>
#include "regex.h"

/* global variables used by re_comp */
extern char *braelist[], *braslist[], expbuf[], circf;

/* POSIX IEEE Std 1003.2-1992 B.5.1 */

/* For compatibility, always set cflags = REG_NOSUB|REG_NEWLINE
   when calling regcomp().  This will assure the same behavior
   between this version and the POSIX version. */

int regcomp(regex_t *preg, char *pattern, int cflags)
{
  char *retval;

  retval = (char *) re_comp(pattern);

  if (retval)
    {
      /* copy error message */
      strncpy(preg->re_errstr, retval, REG_MAX_ERRLEN);
      preg->re_errstr[REG_MAX_ERRLEN] = '\0';
      return(REG_BADPAT);
    }

  /* copy globally compiled RE into preg */
  memcpy(preg->re_expbuf, expbuf, 512);
  memcpy(preg->re_braelist, braelist, 9);
  memcpy(preg->re_braslist, braslist, 9);
  preg->re_circf = circf;

  preg->re_nsub = 1; /* Don't know number of parenthesized subexpressions, */
		     /* so just set it to some reasonable number. */

  preg->re_errstr[0] = '\0';	/* no error */

  return(0);
}

/* assumes RE was compiled with REG_NOSUB flag */

int regexec(regex_t *preg, char *string,
	    size_t nmatch, regmatch_t pmatch[], int eflags)
{
  /* copy compiled RE into global variables */
  memcpy(expbuf, preg->re_expbuf, 512);
  memcpy(braelist, preg->re_braelist, 9);
  memcpy(braslist, preg->re_braslist, 9);
  circf = preg->re_circf;

  switch(re_exec(string))
    {
    case 0:      /* does not match */
      strcpy(preg->re_errstr, "pattern not found");
      return(REG_NOMATCH);
    case 1:      /* does match */
      return(0);
    default:     /* re_exec internal error */
      strcpy(preg->re_errstr, "invalid pattern");
      return(REG_BADPAT);
    }
}

size_t regerror(int errcode, regex_t *preg,
		char *errbuf, size_t errbuf_size)
{
  char *retstr = "error from regcomp() or regexec()";

  if (preg) retstr = preg->re_errstr;

  if (errbuf_size)
    {
      strncpy(errbuf, retstr, errbuf_size-1);
      errbuf[errbuf_size]='\0';
    }

  return(strlen(retstr));
}

void regfree(regex_t *preg) {}	/* do nothing */