COMMON: mid and replace performance

Author: chrisws

src/common/blib_func.c

@@ -397,8 +397,9 @@ void date_fmt(char *fmt, char *buf, long d, long m, long y) {
               // full name
               strcat(buf, date_mN_table[m - 1]);
             }
-          } else
+          } else {
             strcat(buf, "***");
+          }
         }
 
         mc = 0;
@@ -1300,7 +1301,9 @@ void cmd_str0(long funcCode, var_t *r) {
 // str <- FUNC (...)
 //
 void cmd_strN(long funcCode, var_t *r) {
-  var_t arg1;
+  var_t arg1, arg2;
+  var_t *var_p1 = NULL;
+  var_t *var_p2 = NULL;
   var_int_t i, count, lsrc, len, start, pc;
   char tmp[2], *tmp_p;
   char *s1 = NULL, *s2 = NULL, *s3 = NULL;
@@ -1334,8 +1337,9 @@ void cmd_strN(long funcCode, var_t *r) {
         r->v.p.ptr[strlen(r->v.p.ptr) - 1] = '\0';
         r->type = V_STR;
         r->v.p.size = strlen(r->v.p.ptr) + 1;
-      } else
+      } else {
         v_zerostr(r);
+      }
     }
     break;
   case kwSTRING:
@@ -1497,8 +1501,9 @@ void cmd_strN(long funcCode, var_t *r) {
         strcpy(r->v.p.ptr, s1);
         r->v.p.size = l;
         *p = lc;
-      } else
+      } else {
         v_zerostr(r);
+      }
     }
     break;
 
@@ -1612,13 +1617,15 @@ void cmd_strN(long funcCode, var_t *r) {
     //
     // str <- REPLACE$ ( source, pos, str [, len] )
     //
-    count = -1;
-    par_massget("SISi", &s1, &start, &s2, &count);
-    if (!prog_error) {
-      int ls1, ls2;
+    v_init(&arg2);
 
-      ls1 = strlen(s1);
-      ls2 = strlen(s2);
+    var_p1 = par_next_str(&arg1, 1);
+    start = par_next_int(1);
+    var_p2 = par_next_str(&arg2, 0);
+    count = par_getval(-1);
+    if (!prog_error) {
+      int ls1 = v_strlen(var_p1);
+      int ls2 = v_strlen(var_p2);
 
       start--;
       if (start < 0 || start > ls1) {
@@ -1630,50 +1637,51 @@ void cmd_strN(long funcCode, var_t *r) {
 
       // copy the left-part
       if (start > 0) {
-        memcpy(r->v.p.ptr, s1, start);
+        memcpy(r->v.p.ptr, var_p1->v.p.ptr, start);
         r->v.p.ptr[start] = '\0';
-      } else
+      } else {
         *r->v.p.ptr = '\0';
-
+      }
       // insert the string
-      strcat(r->v.p.ptr, s2);
+      strcat(r->v.p.ptr, var_p2->v.p.ptr);
 
       // add the right-part
       if (count == -1) {
         count = ls2;
       }
       if (start + count < ls1) {
-        strcat(r->v.p.ptr, (s1 + start + count));
+        strcat(r->v.p.ptr, (var_p1->v.p.ptr + start + count));
       }
       r->v.p.ptr[ls1 + ls2] = '\0';
       r->v.p.size = ls1 + ls2 + 1;
     }
-
+    v_free(&arg2);
     break;
 
   case kwMID:
     //
     // str <- MID$ ( str, start [, len] )
     //
-    len = -1;
-    par_massget("SIi", &s1, &start, &len);
+    var_p1 = par_next_str(&arg1, 1);
+    start = par_next_int(0);
+    len = par_getval(-1);
     if (!prog_error) {
-      lsrc = strlen(s1);
-      if (start <= 0 || start > (int) strlen(s1)) {
+      lsrc = v_strlen(var_p1);
+      if (start <= 0 || start > lsrc) {
         err_stridx(start);
       } else {
         start--;
         if (len < 0 || len + start >= lsrc) {
           len = lsrc - start;
         }
         r->v.p.ptr = malloc(len + 1);
-        memcpy(r->v.p.ptr, s1 + start, len);
+        memcpy(r->v.p.ptr, var_p1->v.p.ptr + start, len);
         r->v.p.ptr[len] = '\0';
         r->v.p.size = len + 1;
       }
     }
-
     break;
+
   default:
     rt_raise("Unsupported built-in function call %ld, please report this bug (7)", funcCode);
   }
@@ -1873,7 +1881,6 @@ void cmd_intN(long funcCode, var_t *r) {
       code_skipnext();
       var_p = tvar[code_getaddr()];
       if (var_p->type == V_ARRAY) {
-
         l = 1;
         if (code_peek() == kwTYPE_SEP) {
           par_getcomma();
@@ -2471,10 +2478,11 @@ void cmd_genfunc(long funcCode, var_t *r) {
 
     r->type = V_NUM;
 
-    if (funcCode == kwPTDISTLN)
+    if (funcCode == kwPTDISTLN) {
       r->v.n = geo_distfromline(B.x, B.y, C.x, C.y, A.x, A.y);
-    else
+    } else {
       r->v.n = geo_distfromseg(B.x, B.y, C.x, C.y, A.x, A.y);
+    }
   }
     break;
     //
@@ -2554,12 +2562,13 @@ void cmd_genfunc(long funcCode, var_t *r) {
                 if (first) {
                   dar_first(funcCode, r, elem_p);
                   first = 0;
-                } else
+                } else {
                   dar_next(funcCode, r, elem_p);
-
+                }
                 tcount++;
-              } else
+              } else {
                 return;
+              }
             }
             break;
           }
@@ -2573,12 +2582,13 @@ void cmd_genfunc(long funcCode, var_t *r) {
           if (first) {
             dar_first(funcCode, r, &arg);
             first = 0;
-          } else
+          } else {
             dar_next(funcCode, r, &arg);
-
+          }
           tcount++;
-        } else
+        } else {
           return;
+        }
         v_free(&arg);
       }
 

src/common/pproc.h

@@ -196,6 +196,24 @@ var_num_t par_getnum(void);
 
 #define par_getreal()   par_getnum()
 
+/**
+ * @ingroup par
+ *
+ * get next parameter as integer
+ *
+ * @return the integer
+ */
+var_int_t par_next_int(int sep);
+
+/**
+ * @ingroup par
+ *
+ * get next parameter as string
+ *
+ * @return the string var
+ */
+var_t *par_next_str(var_t *arg, int sep);
+
 /**
  * @ingroup par
  *

src/common/proc.c

@@ -471,19 +471,67 @@ var_num_t par_getnum() {
   return f;
 }
 
-var_int_t par_getval(var_int_t def) {
+var_int_t par_next_int(int sep) {
   var_int_t result;
-  byte code = code_peek();
-  if (code == kwTYPE_VAR) {
+  if (prog_error) {
+    result = 0;
+  } else {
     result = par_getint();
-  } else if (code == kwTYPE_INT) {
-    code_skipnext();
-    result = code_getint();
-  } else if (code == kwTYPE_NUM) {
-    code_skipnext();
-    result = code_getreal();
+  }
+  if (!prog_error && (sep || code_peek() == kwTYPE_SEP)) {
+    par_getcomma();
+  }
+  return result;
+}
+
+var_t *par_next_str(var_t *arg, int sep) {
+  var_t *result;
+  if (prog_error) {
+    result = NULL;
+  } else if (code_isvar()) {
+    result = code_getvarptr();
   } else {
+    eval(arg);
+    result = arg;
+  }
+  if (result && result->type != V_STR) {
+    err_syntax(-1, "%S");
+  }
+  if (!prog_error && (sep || code_peek() == kwTYPE_SEP)) {
+    par_getcomma();
+  }
+  return result;
+}
+
+var_int_t par_getval(var_int_t def) {
+  var_int_t result;
+  if (prog_error) {
     result = def;
+  } else {
+    var_t var;
+    switch (code_peek()) {
+    case kwTYPE_INT:
+      code_skipnext();
+      result = code_getint();
+      break;
+    case kwTYPE_NUM:
+      code_skipnext();
+      result = code_getreal();
+      break;
+    case kwTYPE_LINE:
+    case kwTYPE_EOC:
+    case kwTYPE_SEP:
+    case kwTYPE_LEVEL_END:
+      result = def;
+      break;
+    default:
+      eval(&var);
+      if (!prog_error) {
+        result = v_getint(&var);
+      }
+      v_free(&var);
+      break;
+    }
   }
   return result;
 }

src/common/scan.c

@@ -244,18 +244,20 @@ int comp_is_external_func(const char *name) {
  * error messages
  */
 void sc_raise(const char *fmt, ...) {
-  char *buff;
-  va_list ap;
+  if (!prog_error) {
+    char *buff;
+    va_list ap;
 
-  va_start(ap, fmt);
-  comp_error = 1;
+    va_start(ap, fmt);
+    comp_error = 1;
 
-  buff = malloc(SB_SOURCELINE_SIZE + 1);
-  vsnprintf(buff, SB_SOURCELINE_SIZE, fmt, ap);
-  va_end(ap);
+    buff = malloc(SB_SOURCELINE_SIZE + 1);
+    vsnprintf(buff, SB_SOURCELINE_SIZE, fmt, ap);
+    va_end(ap);
 
-  sc_raise2(comp_bc_sec, comp_line, buff);  // sberr.h
-  free(buff);
+    sc_raise2(comp_bc_sec, comp_line, buff);  // sberr.h
+    free(buff);
+  }
 }
 
 /*

src/common/var.c

@@ -32,7 +32,7 @@ var_t *v_new() {
 int v_isempty(var_t *var) {
   switch (var->type) {
   case V_STR:
-    return (strlen(var->v.p.ptr) == 0);
+    return (v_strlen(var) == 0);
   case V_INT:
     return (var->v.i == 0);
   case V_MAP:
@@ -50,6 +50,19 @@ int v_isempty(var_t *var) {
   return 1;
 }
 
+int v_strlen(var_t *v) {
+  int result;
+  if (v->type == V_STR) {
+    result = v->v.p.size;
+    if (result && v->v.p.ptr[result - 1] == '\0') {
+      result--;
+    }
+  } else {
+    result = 0;
+  }
+  return result;
+}
+
 /*
  * returns the length of the variable
  */
@@ -58,7 +71,7 @@ int v_length(var_t *var) {
 
   switch (var->type) {
   case V_STR:
-    return strlen(var->v.p.ptr);
+    return v_strlen(var);
   case V_MAP:
     return map_length(var);
   case V_PTR:

src/common/var.h

@@ -651,6 +651,16 @@ void v_input2var(const char *str, var_t *var);
  */
 char *v_getstr(var_t *v);
 
+/**
+ * @ingroup var
+ *
+ * returns the length of the var string
+ *
+ * @param v is the variable
+ * @return the string length
+ */
+int v_strlen(var_t *v);
+
 /**
  * @ingroup var
  *