backport embryo fix for windows.

git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/branches/embryo-1.7@76492 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/ChangeLog b/ChangeLog
index d1fd423..2611b84 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -44,3 +44,8 @@
 2012-08-30  Carsten Haitzler (The Rasterman)
 
         1.7.0 release
+
+2012-09-12  Carsten Haitzler (The Rasterman)
+
+        * Fix windows utf/whitespace parsing issue in windows
+

diff --git a/NEWS b/NEWS
index 5ad6be7..2954cf1 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,4 +1,11 @@
-Embryo 1.7.0
+Embryo 1.7.1
+
+Changes since Embryo 1.7.0:
+---------------------------
+
+Fixes:
+
+    * Fix windows utf8 shitepsace parse issue.
 
 Changes since Embryo 1.2.0:
 ---------------------------

diff --git a/src/bin/embryo_cc_sc.h b/src/bin/embryo_cc_sc.h
index bedd59e..9eaf6b8 100644 (file)
--- a/src/bin/embryo_cc_sc.h
+++ b/src/bin/embryo_cc_sc.h
@@ -664,4 +664,10 @@ extern FILE      *outf;    /* file written to */
 
 extern jmp_buf    errbuf;      /* target of longjmp() on a fatal error */
 
+#define sc_isspace(x)  isspace ((int)((unsigned char)x))
+#define sc_isalpha(x)  isalpha ((int)((unsigned char)x))
+#define sc_isdigit(x)  isdigit ((int)((unsigned char)x))
+#define sc_isupper(x)  isupper ((int)((unsigned char)x))
+#define sc_isxdigit(x) isxdigit((int)((unsigned char)x))
+
 #endif

diff --git a/src/bin/embryo_cc_sc1.c b/src/bin/embryo_cc_sc1.c
index 3a5b3d9..9ee3ad8 100644 (file)
--- a/src/bin/embryo_cc_sc1.c
+++ b/src/bin/embryo_cc_sc1.c
@@ -489,7 +489,7 @@ sc_addtag(char *name)
 
    /* tagname currently unknown, add it */
    tag = last + 1;             /* guaranteed not to exist already */
-   if (isupper(*name))
+   if (sc_isupper(*name))
       tag |= (int)FIXEDTAG;
    append_constval(&tagname_tab, name, (cell) tag, 0);
    return tag;
@@ -1949,7 +1949,7 @@ tag2str(char *dest, int tag)
    tag &= TAGMASK;
    assert(tag >= 0);
    sprintf(dest, "0%x", tag);
-   return isdigit(dest[1]) ? &dest[1] : dest;
+   return sc_isdigit(dest[1]) ? &dest[1] : dest;
 }
 
 char       *
@@ -1995,7 +1995,7 @@ parse_funcname(char *fname, int *tag1, int *tag2, char *opname)
      }                         /* if */
    assert(!unary || *tag1 == 0);
    assert(*ptr != '\0');
-   for (name = opname; !isdigit(*ptr);)
+   for (name = opname; !sc_isdigit(*ptr);)
       *name++ = *ptr++;
    *name = '\0';
    *tag2 = (int)strtol(ptr, NULL, 16);
@@ -2010,7 +2010,7 @@ funcdisplayname(char *dest, char *funcname)
    constvalue         *tagsym[2];
    int                 unary;
 
-   if (isalpha(*funcname) || *funcname == '_' || *funcname == PUBLIC_CHAR
+   if (sc_isalpha(*funcname) || *funcname == '_' || *funcname == PUBLIC_CHAR
        || *funcname == '\0')
      {
        if (dest != funcname)

diff --git a/src/bin/embryo_cc_sc2.c b/src/bin/embryo_cc_sc2.c
index 04cb537..f72703a 100644 (file)
--- a/src/bin/embryo_cc_sc2.c
+++ b/src/bin/embryo_cc_sc2.c
@@ -443,9 +443,9 @@ dtoi(cell * val, char *curptr)
 
    *val = 0;
    ptr = curptr;
-   if (!isdigit(*ptr))         /* should start with digit */
+   if (!sc_isdigit(*ptr))              /* should start with digit */
       return 0;
-   while (isdigit(*ptr) || *ptr == '_')
+   while (sc_isdigit(*ptr) || *ptr == '_')
      {
        if (*ptr != '_')
           *val = (*val * 10) + (*ptr - '0');
@@ -453,7 +453,7 @@ dtoi(cell * val, char *curptr)
      }                         /* while */
    if (alphanum(*ptr))         /* number must be delimited by non-alphanumerical */
       return 0;
-   if (*ptr == '.' && isdigit(*(ptr + 1)))
+   if (*ptr == '.' && sc_isdigit(*(ptr + 1)))
       return 0;                        /* but a fractional part must not be present */
    return (int)(ptr - curptr);
 }
@@ -471,18 +471,18 @@ htoi(cell * val, char *curptr)
 
    *val = 0;
    ptr = curptr;
-   if (!isdigit(*ptr))         /* should start with digit */
+   if (!sc_isdigit(*ptr))              /* should start with digit */
       return 0;
    if (*ptr == '0' && *(ptr + 1) == 'x')
      {                         /* C style hexadecimal notation */
        ptr += 2;
-       while (isxdigit(*ptr) || *ptr == '_')
+       while (sc_isxdigit(*ptr) || *ptr == '_')
          {
             if (*ptr != '_')
               {
-                 assert(isxdigit(*ptr));
+                 assert(sc_isxdigit(*ptr));
                  *val = *val << 4;
-                 if (isdigit(*ptr))
+                 if (sc_isdigit(*ptr))
                     *val += (*ptr - '0');
                  else
                     *val += (tolower(*ptr) - 'a' + 10);
@@ -554,9 +554,9 @@ ftoi(cell * val, char *curptr)
    fnum = 0.0;
    dnum = 0L;
    ptr = curptr;
-   if (!isdigit(*ptr))         /* should start with digit */
+   if (!sc_isdigit(*ptr))              /* should start with digit */
       return 0;
-   while (isdigit(*ptr) || *ptr == '_')
+   while (sc_isdigit(*ptr) || *ptr == '_')
      {
        if (*ptr != '_')
          {
@@ -568,12 +568,12 @@ ftoi(cell * val, char *curptr)
    if (*ptr != '.')
       return 0;                        /* there must be a period */
    ptr++;
-   if (!isdigit(*ptr))         /* there must be at least one digit after the dot */
+   if (!sc_isdigit(*ptr))              /* there must be at least one digit after the dot */
       return 0;
    ffrac = 0.0;
    fmult = 1.0;
    ignore = FALSE;
-   while (isdigit(*ptr) || *ptr == '_')
+   while (sc_isdigit(*ptr) || *ptr == '_')
      {
        if (*ptr != '_')
          {
@@ -605,10 +605,10 @@ ftoi(cell * val, char *curptr)
          {
             sign = 1;
          }                     /* if */
-       if (!isdigit(*ptr))     /* 'e' should be followed by a digit */
+       if (!sc_isdigit(*ptr))  /* 'e' should be followed by a digit */
           return 0;
        exp = 0;
-       while (isdigit(*ptr))
+       while (sc_isdigit(*ptr))
          {
             exp = (exp * 10) + (*ptr - '0');
             ptr++;
@@ -1109,7 +1109,7 @@ command(void)
                               lptr++;
                            for (i = 0; 
                                  (i < (int)(sizeof(name))) && 
-                                 (isalpha(*lptr));
+                                 (sc_isalpha(*lptr));
                                 i++, lptr++)
                               name[i] = *lptr;
                            name[i] = '\0';
@@ -1171,7 +1171,7 @@ command(void)
 
           while (*lptr <= ' ' && *lptr != '\0')
              lptr++;
-          for (i = 0; i < 40 && (isalpha(*lptr) || *lptr == '.'); i++, lptr++)
+          for (i = 0; i < 40 && (sc_isalpha(*lptr) || *lptr == '.'); i++, lptr++)
              name[i] = (char)tolower(*lptr);
           name[i] = '\0';
           stgwrite("\t");
@@ -1253,7 +1253,7 @@ command(void)
                  }             /* while */
                end = lptr;
                /* check pattern to match */
-               if (!isalpha(*start) && *start != '_')
+               if (!sc_isalpha(*start) && *start != '_')
                  {
                     error(74); /* pattern must start with an alphabetic character */
                     break;
@@ -1272,7 +1272,7 @@ command(void)
                  }             /* while */
                pattern[count] = '\0';
                /* special case, erase trailing variable, because it could match anything */
-               if (count >= 2 && isdigit(pattern[count - 1])
+               if (count >= 2 && sc_isdigit(pattern[count - 1])
                    && pattern[count - 2] == '%')
                   pattern[count - 2] = '\0';
                /* find substitution string */
@@ -1313,7 +1313,7 @@ command(void)
                substitution[count] = '\0';
                /* check whether the definition already exists */
                for (prefixlen = 0, start = pattern;
-                    isalpha(*start) || isdigit(*start) || *start == '_';
+                    sc_isalpha(*start) || sc_isdigit(*start) || *start == '_';
                     prefixlen++, start++)
                   /* nothing */ ;
                assert(prefixlen > 0);
@@ -1484,7 +1484,7 @@ substpattern(char *line, size_t buffersize, char *pattern, char *substitution)
    memset(args, 0, sizeof args);
 
    /* check the length of the prefix */
-   for (prefixlen = 0, s = pattern; isalpha(*s) || isdigit(*s) || *s == '_';
+   for (prefixlen = 0, s = pattern; sc_isalpha(*s) || sc_isdigit(*s) || *s == '_';
        prefixlen++, s++)
       /* nothing */ ;
    assert(prefixlen > 0);
@@ -1501,7 +1501,7 @@ substpattern(char *line, size_t buffersize, char *pattern, char *substitution)
        if (*p == '%')
          {
             p++;               /* skip '%' */
-            if (isdigit(*p))
+            if (sc_isdigit(*p))
               {
                  arg = *p - '0';
                  assert(arg >= 0 && arg <= 9);
@@ -1596,7 +1596,7 @@ substpattern(char *line, size_t buffersize, char *pattern, char *substitution)
        /* calculate the length of the substituted string */
        for (e = substitution, len = 0; *e != '\0'; e++)
          {
-            if (*e == '%' && isdigit(*(e + 1)))
+            if (*e == '%' && sc_isdigit(*(e + 1)))
               {
                  arg = *(e + 1) - '0';
                  assert(arg >= 0 && arg <= 9);
@@ -1620,7 +1620,7 @@ substpattern(char *line, size_t buffersize, char *pattern, char *substitution)
             strdel(line, (int)(s - line));
             for (e = substitution, s = line; *e != '\0'; e++)
               {
-                 if (*e == '%' && isdigit(*(e + 1)))
+                 if (*e == '%' && sc_isdigit(*(e + 1)))
                    {
                       arg = *(e + 1) - '0';
                       assert(arg >= 0 && arg <= 9);
@@ -1660,7 +1660,7 @@ substallpatterns(char *line, int buffersize)
        /* find the start of a prefix (skip all non-alphabetic characters),
         * also skip strings
         */
-       while (!isalpha(*start) && *start != '_' && *start != '\0')
+       while (!sc_isalpha(*start) && *start != '_' && *start != '\0')
          {
             /* skip strings */
             if (is_startstring(start))
@@ -1676,7 +1676,7 @@ substallpatterns(char *line, int buffersize)
        /* get the prefix (length), look for a matching definition */
        prefixlen = 0;
        end = start;
-       while (isalpha(*end) || isdigit(*end) || *end == '_')
+       while (sc_isalpha(*end) || sc_isdigit(*end) || *end == '_')
          {
             prefixlen++;
             end++;
@@ -2318,7 +2318,7 @@ litchar(char **lptr, int rawmode)
                  cptr += 1;
                  break;
               default:
-                 if (isdigit(*cptr))
+                 if (sc_isdigit(*cptr))
                    {           /* \ddd */
                       c = 0;
                       while (*cptr >= '0' && *cptr <= '9')     /* decimal! */
@@ -2346,7 +2346,7 @@ litchar(char **lptr, int rawmode)
 static int
 alpha(char c)
 {
-   return (isalpha(c) || c == '_' || c == PUBLIC_CHAR);
+   return (sc_isalpha(c) || c == '_' || c == PUBLIC_CHAR);
 }
 
 /*  alphanum
@@ -2356,7 +2356,7 @@ alpha(char c)
 int
 alphanum(char c)
 {
-   return (alpha(c) || isdigit(c));
+   return (alpha(c) || sc_isdigit(c));
 }
 
 /* The local variable table must be searched backwards, so that the deepest
@@ -2476,7 +2476,7 @@ delete_symbols(symbol * root, int level, int delete_labels,
             /* for user defined operators, also remove the "prototyped" flag, as
              * user-defined operators *must* be declared before use
              */
-            if (sym->ident == iFUNCTN && !isalpha(*sym->name)
+            if (sym->ident == iFUNCTN && !sc_isalpha(*sym->name)
                 && *sym->name != '_' && *sym->name != PUBLIC_CHAR)
                sym->usage &= ~uPROTOTYPED;
             root = sym;        /* skip the symbol */

diff --git a/src/bin/embryo_cc_sc6.c b/src/bin/embryo_cc_sc6.c
index 417a8a1..3525d27 100644 (file)
--- a/src/bin/embryo_cc_sc6.c
+++ b/src/bin/embryo_cc_sc6.c
@@ -134,7 +134,7 @@ align32(long *v)
 static char        *
 skipwhitespace(char *str)
 {
-   while (isspace(*str))
+   while (sc_isspace(*str))
       str++;
    return str;
 }
@@ -272,7 +272,7 @@ do_dump(FILE * fbin, char *params, cell opcode __UNUSED__)
        if (fbin)
           write_encoded(fbin, &p, 1);
        num++;
-       while (isspace(*params))
+       while (sc_isspace(*params))
           params++;
      }                         /* while */
    return num * sizeof(cell);
@@ -286,7 +286,7 @@ do_call(FILE * fbin, char *params, cell opcode)
    symbol             *sym;
    ucell               p;
 
-   for (i = 0; !isspace(*params); i++, params++)
+   for (i = 0; !sc_isspace(*params); i++, params++)
      {
        assert(*params != '\0');
        assert(i < sNAMEMAX);
@@ -339,10 +339,10 @@ do_file(FILE * fbin, char *params, cell opcode)
    p = hex2long(params, &params);
 
    /* remove leading and trailing white space from the filename */
-   while (isspace(*params))
+   while (sc_isspace(*params))
       params++;
    len = strlen(params);
-   while (len > 0 && isspace(params[len - 1]))
+   while (len > 0 && sc_isspace(params[len - 1]))
       len--;
    params[len++] = '\0';       /* zero-terminate */
    while (len % sizeof(cell) != 0)
@@ -368,7 +368,7 @@ do_symbol(FILE * fbin, char *params, cell opcode)
    int                 len;
    unsigned char       mclass, type;
 
-   for (endptr = params; !isspace(*endptr) && endptr != '\0'; endptr++)
+   for (endptr = params; !sc_isspace(*endptr) && endptr != '\0'; endptr++)
       /* nothing */ ;
    assert(*endptr == ' ');
 
@@ -1003,7 +1003,7 @@ assemble(FILE * fout, FILE * fin)
                  /* get to the end of the instruction (make use of the '\n' that fgets()
                   * added at the end of the line; this way we will *always* drop on a
                   * whitespace character) */
-                 for (params = instr; *params != '\0' && !isspace(*params);
+                 for (params = instr; *params != '\0' && !sc_isspace(*params);
                       params++)
                     /* nothing */ ;
                  assert(params > instr);
@@ -1039,7 +1039,7 @@ assemble(FILE * fout, FILE * fin)
             /* get to the end of the instruction (make use of the '\n' that fgets()
              * added at the end of the line; this way we will *always* drop on a
              * whitespace character) */
-            for (params = instr; *params != '\0' && !isspace(*params);
+            for (params = instr; *params != '\0' && !sc_isspace(*params);
                  params++)
                /* nothing */ ;
             assert(params > instr);

diff --git a/src/bin/embryo_cc_sc7.c b/src/bin/embryo_cc_sc7.c
index 910c522..b51f2ea 100644 (file)
--- a/src/bin/embryo_cc_sc7.c
+++ b/src/bin/embryo_cc_sc7.c
@@ -471,7 +471,7 @@ matchsequence(char *start, char *end, char *pattern,
          {
          case '%':             /* new "symbol" */
             pattern++;
-            assert(isdigit(*pattern));
+            assert(sc_isdigit(*pattern));
             var = atoi(pattern) - 1;
             assert(var >= 0 && var < _maxoptvars);
             assert(alphanum(*start));
@@ -542,7 +542,7 @@ replacesequence(char *pattern, char symbols[_maxoptvars][_aliasmax + 1],
          {
          case '%':
             lptr++;            /* skip '%' */
-            assert(isdigit(*lptr));
+            assert(sc_isdigit(*lptr));
             var = atoi(lptr) - 1;
             assert(var >= 0 && var < _maxoptvars);
             assert(symbols[var][0] != '\0');   /* variable should be defined */
@@ -575,7 +575,7 @@ replacesequence(char *pattern, char symbols[_maxoptvars][_aliasmax + 1],
          case '%':
             /* write out the symbol */
             pattern++;
-            assert(isdigit(*pattern));
+            assert(sc_isdigit(*pattern));
             var = atoi(pattern) - 1;
             assert(var >= 0 && var < _maxoptvars);
             assert(symbols[var][0] != '\0');   /* variable should be defined */