C/C++ dosex (irregular expressions :) for copying, renaming with wildcards

// main.cpp - tester for dosex irregular expressions and filename
// functions to be included in libLQ.

#include <stdio.h>    // printf()
#include <string.h>   // strcpy()
#include <unistd.h>   // sleep()

#include "filename_match.h"

void dbg(){}

char* dosex(const char* inname, const char* findwild, const char* replacewild)
{
  static char outname[FILENAME_MAXSTR];
  int ok = filename_match(inname, findwild);
  if(ok)
    ok = filename_matchNew(outname, FILENAME_MAXSTR, inname, replacewild);
  if(ok)
    return outname;
  else
    return 0;
}

int main(int argc, char** argv)
{
  dbg();
  //  test_init();
  //  match_findstr();
  const char* s;
  const char* findstr, *replacestr, *inputstr;
  char** p;
  const char* default_args[3] =
  {
    // these have been tested against the same strings using cmd.exe
    // in Windows.
    "barkedupon.ayz", "*a*e*p?n.?yz", "???-01.x*" // sb bar-01.xyz
    //    "abc-def", "*-def", "*-xyz" // sb: abc-xyz
    //    "abc-def", "*-*", "test-*" // sb: test-ef
    //    "abc3defg", "*3*", "test4*"  // sb: test4efg
    //    "abc.defg", "*.*", "test4*"  // sb: test.defg
    //    "abc.defg", "*3*", "test4*"  // sb: not a match
  };
  
  if(argc == 4)
    p = argv+1;
  else
  {
    printf("\nYou can input quoted args on the commandline too.\n"
    "We'll use a default test setup this time around.\n\n");
    sleep(1.5);
    p = (char**)default_args;
  }
  
  inputstr = *p++;
  findstr = *p++;
  replacestr = *p;
  printf("Using args\n"
  "   inputstr:   %s\n"
  "   findstr:    %s\n"
  "   replacestr: %s\n",
  inputstr, findstr, replacestr);
  s = dosex(inputstr, findstr, replacestr);
  
  if(s)
    printf("Output -> '%s'\n", s);
  else
    printf("Can't copy/replace input strings\n");
  return 0;
}

// filename_match.cpp - wildcard pattern checking for existing 
// files and for generating new names for renaming, or copying,
// also based on wildcard pattern criteria.

#include <stdio.h>    // fgets
#include <string.h>   // strlen()
#include <malloc.h>   // malloc

#include "filename_match.h"

static const char* pattern_old;
static const char* pattern_new;

// working buffers for matchNew
static char buf_in[FILENAME_MAXSTR];        // input name for matchNew
static char buf_out[FILENAME_MAXSTR];       // output name from matchNew

// returns true if string s matches pattern p which may include 
// wildcard chars '*' and '?'.  Handles escaped chars in pattern
// allowing avoidance of trigraph errors, etc.
static bool _match_existing (const char* s, const char* p)
{
  for (;;)
  {
    switch (*p++)
    {
      case '?':              // matches any character
          if (!*s++)
            return false;
          break;
          
      case '*':              // match 0-n of any characters
          if (!*p)           // end of wildcards?
            return true;     // matches all the rest
            while (!_match_existing(s, p))
              if (!*s++)
                return false;
              return true;
            
      case 0:                 // end of pattern
          return !*s;         // true if also end of s
          
      case '\\':              // next character literal
          if (*p)
            p++;              // falls through to default
      default:
        if (*s++ != *(p - 1)) // do letters match?
          return false;
        break;
    } // switch(*p++)
  }
}

/* based on part of copy300 by Marty Peritsky
 * License: GPL v.2+.
 */

static bool _match_new(const char *f, const char *p)
{
  int i;
  
  for(i = 0; i < FILENAME_MAXSTR; i++)
    buf_out[i] = '\0';
  
  i = 0;
  do{
    switch (*p){
      case '?':
      {
        switch (*f){
          case '.':
          case '\0':
            p++; 
            break;
          default:
            buf_out[i++] = *(f++); p++; 
            break;
        } // switch(*f)
        break;
      } // case '?'
      
          case '*':
          {
            switch (*f) {
              case '.':
              case '\0':
                p++; 
                break;
              default:
                do{ buf_out[i++] = *(f++);
                }while((*f != '.') && (*f != '\0') && (i < FILENAME_MAXSTR));
                do{ p++; 
                }while((*p != '.') && (*p != '\0'));
                break;
            } // switch(*f)
            break;
          } // case '*':
              case '.':
              {
                switch (*f) {
                  case '.':
                    f++;
                    // falls through
                  case '\0':
                    buf_out[i++] = '.'; p++; 
                    break;
                  default:
                    do{ f++; 
                    }while((*f != '.') && (*f != '\0'));
                    break;
                } // switch(*f)
                break;
              } // case '.'
                  case '\0':
                    break;
                  default:
                  {
                    switch (*f)
                    {
                      case '.':
                      case '\0':
                        break;
                      default:
                        f++;
                        break;
                    } // switch(*f)
                    buf_out[i++] = *(p++);
                    break;
                  } // default
    }
  }while(((*p) != '\0') && (i < FILENAME_MAXSTR));
  return *buf_out != 0;
}


int filename_match(const char* name, const char* pattern)
{
  // save old name in case we also want a new name
  strcpy(buf_in, name);
  return _match_existing(name, pattern);
}

// assumes filename_match as been run successfully first.
int filename_matchNew(char* name_out, int outlen, const char* name_in, const char* pattern)
{
  *name_out = 0;
  _match_new(name_in, pattern);
  if((*buf_out) && (strlen(buf_out) < outlen))
  {
    strcpy(name_out, buf_out);
    return 1;
  }
  return 0;
}

// filename_match.h

/* 
 *  Gleaned from several GPL'd sourced including gtk, xcopy300 and fltk v. 2.0
 *  License GPL 2+, -rs
 */

#ifndef filename_match_h
#define filename_match_h

// #include <LQ/cdecls.h>
// -------------------------
#ifdef __cplusplus
#define LQ_BEGIN_CDECLS extern "C" {
#define LQ_END_CDECLS }
#else
#define LQ_BEGIN_CDECLS
#define LQ_END_CDECLS
#endif
// -------------------------

LQ_BEGIN_CDECLS;

/// old and new names and wildcards may include paths
#define FILENAME_MAXSTR 1024

/// returns non-zero if name matches wildcard pattern.
int filename_match(const char *name, const char *pattern);

/// Presumes filename_match() has returned successfuly.
/// Sets new name based on wildcard pattern at user 
/// supplied buffer and returns non-zero if successful.
/// Note: If used to copy or rename files, the user is 
/// responsible for checking if anything could be 
/// overwritten that shouldn't be.
int filename_matchNew(char *name_out, int outlen,
                      const char *name_in, const char *pattern);

LQ_END_CDECLS;

#endif        // filename_match_h

makefile-creator c dosex
make clean; make