98aa95938f3af948c60e20044318595f10fee780
braney
  Thu May 13 15:22:00 2021 -0700
ongoing work on cart rewrite system

diff --git src/hg/testRewrite/testRewrite.c src/hg/testRewrite/testRewrite.c
index 1467751..9231041 100644
--- src/hg/testRewrite/testRewrite.c
+++ src/hg/testRewrite/testRewrite.c
@@ -1,224 +1,241 @@
 /* testRewrite - Test harness for cart rewrite tool. */
 #include "common.h"
 #include "linefile.h"
 #include "hash.h"
 #include "options.h"
-#include <regex.h>
+#include "cartRewrite.h"
 
 void usage()
 /* Explain usage and exit. */
 {
 errAbort(
   "testRewrite - Test harness for cart rewrite tool\n"
   "usage:\n"
-  "   testRewrite script input output\n"
+  "   testRewrite input output\n"
   "options:\n"
-  "   -xxx=XXX\n"
+  "   -script=sed-like script\n"
   );
 }
 
 /* Command line validation table. */
 static struct optionSpec options[] = {
+   {"script", OPTION_STRING},
    {NULL, 0},
 };
 
+char *script;
+
+#ifdef NOTNOW
 struct snippet
 {
 struct snippet *next;
 int num;
 char *precursor;
 int precursorLen;
 };
 
 struct edit
 {
 struct edit *next;
 regex_t *compiledExp;
 struct snippet *snippets;
 };
 
 struct snippet *parseSnippets(char *input)
 {
 char *in = input;
 struct snippet *out = NULL;
 
 char *prev = input;
 for(;;)
     {
     if ((*in == 0) || ((*in == '\\') && isdigit(in[1])))
         {
         struct snippet *snippet;
         AllocVar(snippet);
 
         int size = in - prev;
         if (size)
             {
             char buffer[size + 1];
             strncpy(buffer, prev, size);
             buffer[size] = 0;
             snippet->precursor = cloneString(buffer);
             snippet->precursorLen = size;
             prev = in;
             }
 
         if (*in)
             {
             in++;
             snippet->num = atoi(in);
             while (isdigit(*in))
                 in++;
             }
 
         slAddHead(&out, snippet);
         if (*in == 0)
             break;
         }
     else
         in++;
     }
 
 slReverse(&out);
 
 return out;
 }
 
 struct edit *parseEdit(char *line, char *file, int lineNum)
 {
 char *strings[3];
 
 int count =  chopString(line, "\t", strings, 3);
 
 if (count != 2)
     errAbort("Line %d of %s doesn't have exactly two tab separated fields.\n", lineNum, file);
 
 regex_t *compiledExp = NULL;
 int errNum = 0;
 int compileFlags = 0;
 
 AllocVar(compiledExp);
 errNum = regcomp(compiledExp, strings[0], compileFlags);
 
 if (errNum != 0)
     {
     char errBuf[4096];
     regerror(errNum, compiledExp, errBuf, sizeof(errBuf));
     errAbort("got regular expression compilation error %d: %s on line %d of %s", errNum, errBuf, lineNum, file);
     }
 
 struct edit *edit;
 AllocVar(edit);
 edit->compiledExp = compiledExp;
 edit->snippets = parseSnippets(strings[1]);
 
 return edit;
 }
 
 char *doSubEdits(struct snippet *snippets, regmatch_t *matches, char *source, int *plength)
 {
 char output[40 * 1024], *out = output;
 *out = 0;
 //for(; matches->rm_so != -1;matches++, snippets = snippets->next) 
 for(; snippets ; matches++, snippets = snippets->next)
     {
     // copy the part before the match
     strncpy(out, snippets->precursor, snippets->precursorLen);
     out += snippets->precursorLen;
     *plength += snippets->precursorLen;
 
     if (matches->rm_so == -1)
         break;
 
     // copy in the part that matches the regular expression
     int size = matches->rm_eo - matches->rm_so;
     strncpy(out, &source[matches->rm_so], size);
     *plength += size;
     out += size;
     }
 *out = 0;
 return cloneString(output);
 }
 
 char *doOneEdit(struct edit *edit, char *inputString)
 {
 char buffer[40 * 1024];
 char *source = inputString;
 regmatch_t matches[1024];
 int lastSrc = 0;
 int offset = 0;
 int inputLen = strlen(inputString);
 
 for(;;)
     {
     if (regexec(edit->compiledExp, source, ArraySize(matches), matches, 0))
         break;
 
     int size =  matches->rm_so;
     strncpy(&buffer[lastSrc], source, size);
     lastSrc += size;
 
     int subSize = 0;
     char *subEdit = doSubEdits(edit->snippets, matches+1, source, &subSize);
     strncpy(&buffer[lastSrc], subEdit, subSize);
 
     lastSrc += subSize;
     offset += matches->rm_eo;
     if (offset >= inputLen)
         printf("foo");
     source = &inputString[offset];
     }
 
 strcpy(&buffer[lastSrc], source);
 
 return cloneString(buffer);
 }
 
 void doEdits(struct edit *edits, char *input, char *outputFile)
 {
 FILE *f = mustOpen(outputFile, "w");
 
 char *outString = input;
 
 for(; edits; edits = edits->next)
     outString = doOneEdit(edits, outString);
 fputs(outString, f);
 fclose(f);
 }
+#endif
 
-void testRewrite(char *script, char *inputFile, char *outputFile)
+void testRewrite(char *inputFile, char *outputFile)
 /* testRewrite - Test harness for cart rewrite tool. */
 {
+/*
+if (script)
+    {
     struct lineFile *lf = lineFileOpen(script, TRUE);
     char *start;
     int size;
     struct edit *edits = NULL;
 
     while (lineFileNext(lf, &start, &size))
         {
         slAddHead(&edits, parseEdit(start, script, lf->lineIx));
         }
-
     slReverse(&edits);
-
     lineFileClose(&lf);
+    }
+else
+*/
+
 
 int count = 0;
-lf = lineFileOpen(inputFile, TRUE);
+    char *start;
+    int size;
+FILE *f = mustOpen(outputFile, "w");
+struct lineFile * lf = lineFileOpen(inputFile, TRUE);
 while (lineFileNext(lf, &start, &size))
     {
     if (count)
         errAbort("input should have only one line with name=value pairs separated by ampersands.");
 
-    doEdits(edits, start, outputFile);
+//    doEdits(edits, start, outputFile);
+    char *output = regexEdit(cartRewrites[0].editArray,cartRewrites[0].numEdits , start, FALSE);
+    fputs(output, f);
+    
     count++;
     }
 }
 
 int main(int argc, char *argv[])
 /* Process command line. */
 {
 optionInit(&argc, argv, options);
-if (argc != 4)
+if (argc != 3)
     usage();
-testRewrite(argv[1], argv[2], argv[3]);
+script = optionVal("script", NULL);
+testRewrite(argv[1], argv[2]);
 return 0;
 }