VirtualBox

Changeset 1827 in kBuild for trunk/src/kmk


Ignore:
Timestamp:
Oct 11, 2008 7:12:10 AM (16 years ago)
Author:
bird
Message:

kmk: more length optimizations.

Location:
trunk/src/kmk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kmk/dep.h

    r1797 r1827  
    7676void free_ns_chain (struct nameseq *n);
    7777struct dep *read_all_makefiles (const char **makefiles);
     78#ifndef CONFIG_WITH_VALUE_LENGTH
    7879int eval_buffer (char *buffer);
     80#else
     81int eval_buffer (char *buffer, char *eos);
     82#endif
    7983int update_goal_chain (struct dep *goals);
    8084void uniquize_deps (struct dep *);

  • trunk/src/kmk/expand.c

    r1819 r1827  
    108108
    109109char *
     110#ifndef CONFIG_WITH_VALUE_LENGTH
    110111recursively_expand_for_file (struct variable *v, struct file *file)
     112#else
     113recursively_expand_for_file (struct variable *v, struct file *file,
     114                             unsigned int *value_lenp)
     115#endif
    111116{
    112117  char *value;
    … …  
    149154
    150155  v->expanding = 1;
     156#ifndef CONFIG_WITH_VALUE_LENGTH
    151157  if (v->append)
    152158    value = allocated_variable_append (v);
    153159  else
    154160    value = allocated_variable_expand (v->value);
     161#else  /* CONFIG_WITH_VALUE_LENGTH */
     162  if (!v->append)
     163    value = allocated_variable_expand_2 (v->value, v->value_length, value_lenp);
     164  else
     165    {
     166      value = allocated_variable_append (v);
     167      if (value_lenp)
     168        *value_lenp = strlen (value);
     169    }
     170#endif /* CONFIG_WITH_VALUE_LENGTH */
    155171  v->expanding = 0;
    156172
    … …  
    187203
    188204#ifdef CONFIG_WITH_VALUE_LENGTH
     205  assert ((unsigned int)v->value_length == strlen (v->value));
    189206  if (!v->recursive)
    190     {
    191       assert (v->value_length == strlen (v->value));
    192       o = variable_buffer_output (o, v->value, v->value_length);
    193     }
     207    o = variable_buffer_output (o, v->value, v->value_length);
    194208  else
    195209   {
    196      value = recursively_expand (v);
    197      o = variable_buffer_output (o, value, strlen (value));
     210     unsigned int value_len;
     211
     212     value = recursively_expand_for_file (v, NULL, &value_len);
     213     o = variable_buffer_output (o, value, value_len);
    198214     free (value);
    199215   }
    … …  
    211227
    212228
     229#ifndef CONFIG_WITH_VALUE_LENGTH /* Only using variable_expand_string_2! */
    213230/* Scan STRING for variable references and expansion-function calls.  Only
    214231   LENGTH bytes of STRING are actually scanned.  If LENGTH is -1, scan until
    … …  
    228245  char *o;
    229246  unsigned int line_offset;
    230 #ifdef CONFIG_WITH_VALUE_LENGTH
    231   const char *eos;
    232 #endif
    233247
    234248  if (!line)
    … …  
    239253  if (length == 0)
    240254    {
    241 #ifdef KMK /* this is a bug fix. The 2 vs 1 thing is the strlen + 1 in the loop below. */
    242       variable_buffer_output (o, "\0", 2);
    243       return (variable_buffer + line_offset);
    244 #else
    245255      variable_buffer_output (o, "", 1);
    246256      return (variable_buffer);
    247 #endif
    248     }
    249 
    250 #ifdef CONFIG_WITH_VALUE_LENGTH
    251   /* Simple first, 50% of the kBuild calls to this function does
    252      not need any expansion at all. Should be worth a special case. */
    253   if (length < 0)
    254     length = strlen (string);
    255   p1 = (const char *)memchr (string, '$', length);
    256   if (p1 == 0)
    257     {
    258       o = variable_buffer_output (o, string, length);
    259       variable_buffer_output (o, "\0", 2);
    260       return (variable_buffer + line_offset);
    261     }
    262   eos = string + length;
    263 #endif /* CONFIG_WITH_VALUE_LENGTH */
     257    }
    264258
    265259  /* If we want a subset of the string, allocate a temporary buffer for it.
    … …  
    270264      memcpy(abuf, string, length);
    271265      abuf[length] = '\0';
    272 #ifdef CONFIG_WITH_VALUE_LENGTH
    273       p1 += abuf - string;
    274       eos += abuf - string;
    275 #endif /* CONFIG_WITH_VALUE_LENGTH */
    276266      string = abuf;
    277267    }
    … …  
    284274         at the next $ or the end of the input.  */
    285275
    286 #ifndef CONFIG_WITH_VALUE_LENGTH
    287276      p1 = strchr (p, '$');
    288 #endif
    289277
    290278      o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1);
    … …  
    327315               If so, expand it before expanding the entire reference.  */
    328316
    329 #ifndef CONFIG_WITH_VALUE_LENGTH
    330317            end = strchr (beg, closeparen);
    331 #else
    332             end = memchr (beg, closeparen, eos - beg);
    333 #endif
    334318            if (end == 0)
    335319              /* Unterminated variable reference.  */
    … …  
    470454      else
    471455        ++p;
    472 #ifdef CONFIG_WITH_VALUE_LENGTH
    473       p1 = memchr (p, '$', eos - p);
    474 #endif
    475456    }
    476457
    … …  
    481462  return (variable_buffer + line_offset);
    482463}
    483 #ifdef CONFIG_WITH_VALUE_LENGTH
    484 
    485 
    486 /* Same as variable_expand_string except that the pointer at EOL will
    487    point to the end of the returned string. */
     464
     465#else /* CONFIG_WITH_VALUE_LENGTH */
     466/* Scan STRING for variable references and expansion-function calls.  Only
     467   LENGTH bytes of STRING are actually scanned.  If LENGTH is -1, scan until
     468   a null byte is found.
     469
     470   Write the results to LINE, which must point into `variable_buffer'.  If
     471   LINE is NULL, start at the beginning of the buffer.
     472   Return a pointer to LINE, or to the beginning of the buffer if LINE is
     473   NULL. Set EOLP to point to the string terminator.
     474 */
    488475char *
    489 variable_expand_string_2 (char *line, const char *string, long length, char **eol)
     476variable_expand_string_2 (char *line, const char *string, long length, char **eolp)
    490477{
    491478  struct variable *v;
    492   const char *p, *p1;
    493   char *abuf = NULL;
     479  const char *p, *p1, *eos;
    494480  char *o;
    495481  unsigned int line_offset;
    496 #ifdef CONFIG_WITH_VALUE_LENGTH
    497   const char *eos;
    498 #endif
    499482
    500483  if (!line)
    … …  
    503486  line_offset = line - variable_buffer;
    504487
    505   if (length == 0)
    506     {
    507       o = variable_buffer_output (o, "\0", 2);
    508       *eol = o - 2;
    509 #ifdef KMK /* this is a bug fix. */
    510       return (variable_buffer + line_offset);
    511 #else
    512       return (variable_buffer);
    513 #endif
    514     }
    515 
    516 #ifdef CONFIG_WITH_VALUE_LENGTH
    517   /* Simple first, 50% of the kBuild calls to this function does
    518      not need any expansion at all. Should be worth a special case. */
    519488  if (length < 0)
    520489    length = strlen (string);
     490
     491  /* Simple 1: Emptry string. */
     492
     493  if (length == 0)
     494    {
     495      o = variable_buffer_output (o, "\0", 2);
     496      *eolp = o - 2;
     497      return (variable_buffer + line_offset);
     498    }
     499
     500  /* Simple 2: Nothing to expand. ~50% if the kBuild calls. */
     501
    521502  p1 = (const char *)memchr (string, '$', length);
    522503  if (p1 == 0)
    … …  
    524505      o = variable_buffer_output (o, string, length);
    525506      o = variable_buffer_output (o, "\0", 2);
    526       *eol = o - 2;
     507      *eolp = o - 2;
    527508      return (variable_buffer + line_offset);
    528509    }
    529   eos = string + length;
    530 #endif /* CONFIG_WITH_VALUE_LENGTH */
    531 
    532   /* If we want a subset of the string, allocate a temporary buffer for it.
    533      Most of the functions we use here don't work with length limits.  */
    534   if (length > 0 && string[length] != '\0')
    535     {
    536       abuf = xmalloc(length+1);
    537       memcpy(abuf, string, length);
    538       abuf[length] = '\0';
    539 #ifdef CONFIG_WITH_VALUE_LENGTH
    540       p1 += abuf - string;
    541       eos += abuf - string;
    542 #endif
    543       string = abuf;
    544     }
     510
    545511  p = string;
     512  eos = p + length;
    546513
    547514  while (1)
    … …  
    551518         at the next $ or the end of the input.  */
    552519
    553 #ifndef CONFIG_WITH_VALUE_LENGTH
    554       p1 = strchr (p, '$');
    555 #endif
    556 
    557       /*o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1); - why +1 ? */
    558       o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p));
     520      o = variable_buffer_output (o, p, p1 != 0 ? (p1 - p) : (eos - p));
    559521
    560522      if (p1 == 0)
    … …  
    585547            op = o;
    586548            begp = p;
    587             if (handle_function (&op, &begp))
     549            if (handle_function (&op, &begp, eos))
    588550              {
    589551                o = op;
    … …  
    595557               If so, expand it before expanding the entire reference.  */
    596558
    597 #ifndef CONFIG_WITH_VALUE_LENGTH
    598             end = strchr (beg, closeparen);
    599 #else
    600559            end = memchr (beg, closeparen, eos - beg);
    601 #endif
    602560            if (end == 0)
    603561              /* Unterminated variable reference.  */
    … …  
    609567                   Count parens or braces until it is matched.  */
    610568                int count = 0;
    611                 for (p = beg; *p != '\0'; ++p)
     569                for (p = beg; p < eos; ++p)
    612570                  {
    613571                    if (*p == openparen)
    … …  
    621579                if (count < 0)
    622580                  {
    623                     abeg = expand_argument (beg, p); /* Expand the name.  */
    624                     beg = abeg;
    625                     end = strchr (beg, '\0');
     581                    unsigned int len;
     582                    char saved;
     583
     584                     /* Expand the name.  */
     585                    saved = *p;
     586                    *(char *)p = '\0'; /* XXX: proove that this is safe! */
     587                    abeg = allocated_variable_expand_2 (beg, p - beg, &len);
     588                    beg = abeg;
     589                    end = beg + len;
     590                    *(char *)p = saved;
    626591                  }
    627592              }
    … …  
    721686
    722687        case '\0':
    723           break;
     688          assert (p == eos);
     689          break;
    724690
    725691        default:
    726           if (isblank ((unsigned char)p[-1]))
     692          if (isblank ((unsigned char)p[-1])) /* XXX: This looks incorrect, previous is '$' */
    727693            break;
    728694
    … …  
    734700        }
    735701
    736       if (*p == '\0')
     702      if (++p >= eos)
    737703        break;
    738       else
    739         ++p;
    740 #ifdef CONFIG_WITH_VALUE_LENGTH
    741704      p1 = memchr (p, '$', eos - p);
    742 #endif
    743     }
    744 
    745   if (abuf)
    746     free (abuf);
     705    }
    747706
    748707  o = variable_buffer_output (o, "\0", 2); /* KMK: compensate for the strlen + 1 that was removed above. */
    749   *eol = o - 2;
     708  *eolp = o - 2;
    750709  return (variable_buffer + line_offset);
    751710}
    … …  
    761720variable_expand (const char *line)
    762721{
     722#ifndef CONFIG_WITH_VALUE_LENGTH
    763723  return variable_expand_string(NULL, line, (long)-1);
     724#else
     725  char *s;
     726
     727  /* this function is abused a lot like this: variable_expand(""). */
     728  if (!*line)
     729    {
     730      s = variable_buffer_output (initialize_variable_output (), "\0", 2);
     731      return s - 2;
     732    }
     733  return variable_expand_string_2 (NULL, line, (long)-1, &s);
     734#endif
    764735}
    765736
    … …  
    779750    return xstrdup("");
    780751
     752#ifndef CONFIG_WITH_VALUE_LENGTH
    781753  if (!end || *end == '\0')
    782754    return allocated_variable_expand (str);
     755#else
     756  if (!end)
     757      return allocated_variable_expand_2 (str, ~0U, NULL);
     758  if (*end == '\0')
     759    return allocated_variable_expand_2 (str, end - str, NULL);
     760#endif
    783761
    784762#ifdef CONFIG_WITH_OPTIMIZATION_HACKS
    … …  
    786764    const char saved_char = *end;
    787765    *(char *)end = '\0';
     766# ifndef CONFIG_WITH_VALUE_LENGTH
    788767    tmp = allocated_variable_expand ((char *)str);
     768# else
     769    tmp = allocated_variable_expand_2 ((char *)str, end - str, NULL);
     770# endif
    789771    *(char *)end = saved_char;
    790772    return tmp;
    … …  
    795777  tmp[end - str] = '\0';
    796778
     779# ifndef CONFIG_WITH_VALUE_LENGTH
    797780  return allocated_variable_expand (tmp);
     781# else
     782  return allocated_variable_expand_2 (tmp, end - str, NULL);
     783# endif
    798784#endif
    799785}
    … …  
    839825  struct variable_set_list *save;
    840826  const struct floc *reading_file_saved;
     827  char *eol;
    841828
    842829  if (file == 0)
    843     return variable_expand_string (o, line, (long)-1);
     830    return variable_expand_string_2 (o, line, (long)-1, &eol);
    844831
    845832  save = current_variable_set_list;
    … …  
    850837  else
    851838    reading_file = 0;
    852   result = variable_expand_string (o, line, (long)-1);
     839  result = variable_expand_string_2 (o, line, (long)-1, &eol);
    853840  current_variable_set_list = save;
    854841  reading_file = reading_file_saved;
    … …  
    893880    buf = variable_buffer_output (buf, " ", 1);
    894881#ifdef CONFIG_WITH_VALUE_LENGTH
    895   assert (v->value_length == strlen (v->value));
     882  assert ((unsigned int)v->value_length == strlen (v->value)); /* FIXME */
    896883#endif
    897884
    … …  
    10261013char *
    10271014allocated_variable_expand_2 (const char *line, unsigned int length,
    1028                              unsigned int *value_len)
     1015                             unsigned int *value_lenp)
    10291016{
    10301017  char *value;
    … …  
    10321019  unsigned int olen = variable_buffer_length;
    10331020  long len = length == ~0U ? -1L : (long)length;
     1021  char *eol;
    10341022
    10351023  variable_buffer = 0;
    10361024
    1037   if (!value_len)
    1038     value = variable_expand_string (NULL, line, len);
    1039   else
    1040     {
    1041       char *eol;
    1042       value = variable_expand_string_2 (NULL, line, len, &eol);
    1043       *value_len = eol - value;
    1044     }
     1025  value = variable_expand_string_2 (NULL, line, len, &eol);
     1026  if (value_lenp)
     1027    *value_lenp = eol - value;
    10451028
    10461029  variable_buffer = obuf;

  • trunk/src/kmk/function.c

    r1809 r1827  
    323323
    324324
    325 #ifdef CONFIG_WITH_OPTIMIZATION_HACKS
     325#if defined (CONFIG_WITH_OPTIMIZATION_HACKS) || defined (CONFIG_WITH_VALUE_LENGTH)
    326326/* The maximum length of a function, once reached there is
    327327   it can't be function and we can skip the hash lookup drop out. */
    328328
    329 # ifdef KMK
    330 #  define MAX_FUNCTION_LENGTH 12
    331 # else
    332 #  define MAX_FUNCTION_LENGTH 10
    333 # endif
    334 #endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
     329# define MAX_FUNCTION_LENGTH 12
     330# define MIN_FUNCTION_LENGTH 2
     331
     332/* char map containing the valid function name characters. */
     333static char func_char_map[256];
     334
     335/* Do the hash table lookup. */
     336
     337__inline static const struct function_table_entry *
     338lookup_function_in_hash_tab (const char *s, unsigned char len)
     339{
     340    struct function_table_entry function_table_entry_key;
     341    function_table_entry_key.name = s;
     342    function_table_entry_key.len = len;
     343
     344    return hash_find_item (&function_table, &function_table_entry_key);
     345}
    335346
    336347/* Look up a function by name.  */
    337348
    338 #ifdef CONFIG_WITH_OPTIMIZATION_HACKS
    339 __inline
    340 #endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
     349__inline static const struct function_table_entry *
     350lookup_function (const char *s, unsigned int len)
     351{
     352  unsigned char ch;
     353# if 0 /* insane loop unroll */
     354
     355  if (len > MAX_FUNCTION_LENGTH)
     356      len = MAX_FUNCTION_LENGTH + 1;
     357
     358#  define X(idx) \
     359        if (!func_char_map[ch = s[idx]]) \
     360          { \
     361            if (isblank (ch)) \
     362              return lookup_function_in_hash_tab (s, idx); \
     363            return 0; \
     364          }
     365#  define Z(idx) \
     366        return lookup_function_in_hash_tab (s, idx);
     367
     368  switch (len)
     369    {
     370      default:
     371        assert (0);
     372      case  0: return 0;
     373      case  1: return 0;
     374      case  2: X(0); X(1); Z(2);
     375      case  3: X(0); X(1); X(2); Z(3);
     376      case  4: X(0); X(1); X(2); X(3); Z(4);
     377      case  5: X(0); X(1); X(2); X(3); X(4); Z(5);
     378      case  6: X(0); X(1); X(2); X(3); X(4); X(5); Z(6);
     379      case  7: X(0); X(1); X(2); X(3); X(4); X(5); X(6); Z(7);
     380      case  8: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); Z(8);
     381      case  9: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); X(8); Z(9);
     382      case 10: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); X(8); X(9); Z(10);
     383      case 11: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); X(8); X(9); X(10); Z(11);
     384      case 12: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); X(8); X(9); X(10); X(11); Z(12);
     385      case 13: X(0); X(1); X(2); X(3); X(4); X(5); X(6); X(7); X(8); X(9); X(10); X(11); X(12);
     386        if ((ch = s[12]) == '\0' || isblank (ch))
     387          return lookup_function_in_hash_tab (s, 12);
     388        return 0;
     389    }
     390#  undef Z
     391#  undef X
     392
     393# else   /* normal loop */
     394  const char *e = s;
     395  if (len > MAX_FUNCTION_LENGTH)
     396      len = MAX_FUNCTION_LENGTH;
     397  while (func_char_map[ch = *e])
     398    {
     399      if (!len--)
     400        return 0;
     401      e++;
     402    }
     403  if (ch == '\0' || isblank ((unsigned char) ch))
     404    return lookup_function_in_hash_tab (s, e - s);
     405  return 0;
     406# endif /* normal loop */
     407}
     408
     409#else  /* original code */
     410/* Look up a function by name.  */
     411
    341412static const struct function_table_entry *
    342413lookup_function (const char *s)
    343414{
    344415  const char *e = s;
    345 #ifdef CONFIG_WITH_OPTIMIZATION_HACKS
    346   int left = MAX_FUNCTION_LENGTH;
    347   int ch;
    348   while (((ch = *e) >= 'a' && ch <='z') || ch == '-')
    349     {
    350       if (!left--)
    351         return 0;
    352       e++;
    353     }
    354 #else
    355416  while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-'))
    356417    e++;
    357 #endif
    358418  if (*e == '\0' || isblank ((unsigned char) *e))
    359419    {
    … …  
    366426  return 0;
    367427}
     428#endif /* original code */
    368429
    369430
    … …  
    15121573  install_variable_buffer (&buf, &len);
    15131574
     1575#ifndef CONFIG_WITH_VALUE_LENGTH
    15141576  eval_buffer (argv[0]);
     1577#else
     1578  eval_buffer (argv[0], strchr (argv[0], '\0'));
     1579#endif
    15151580
    15161581  restore_variable_buffer (buf, len);
    … …  
    15361601  push_new_variable_scope ();
    15371602
    1538   eval_buffer (argv[0]);
     1603  eval_buffer (argv[0], strchr (argv[0], '\0'));
    15391604
    15401605  pop_variable_scope ();
    … …  
    15651630
    15661631      off = o - variable_buffer;
    1567       o = variable_buffer_output (o, v->value, v->value_length + 1);
     1632      variable_buffer_output (o, v->value, v->value_length + 1);
    15681633      o = variable_buffer + off;
    1569       assert (!o[v->value_length]);
    15701634
    15711635      /* Eval the value.  Pop the current variable buffer setting so that the
    … …  
    15791643        reading_file = &v->fileinfo;
    15801644
    1581       eval_buffer (o);
     1645      assert (!o[v->value_length]);
     1646      eval_buffer (o, o + v->value_length);
    15821647
    15831648      reading_file = reading_file_saved;
    … …  
    16011666#ifdef CONFIG_WITH_VALUE_LENGTH
    16021667    o = variable_buffer_output (o, v->value,
    1603                                 v->value_length >= 0 ? v->value_length : strlen(v->value));
     1668                                v->value_length >= 0
     1669                                ? (unsigned int)v->value_length /* FIXME */
     1670                                : strlen(v->value));
    16041671#else
    16051672    o = variable_buffer_output (o, v->value, strlen(v->value));
    … …  
    30613128                  const char *src = comp;
    30623129                  const char *end = strchr (comp, PATH_SEPARATOR_CHAR);
    3063                   size_t comp_len = end ? end - comp : strlen (comp);
     3130                  size_t comp_len = end ? (size_t)(end - comp) : strlen (comp);
    30643131                  if (!comp_len)
    30653132                    {
    … …  
    41974264}
    41984265
    4199 int
    4200 handle_function (char **op, const char **stringp) /* bird split it up */
     4266
     4267int  /* bird split it up */
     4268#ifndef CONFIG_WITH_VALUE_LENGTH
     4269handle_function (char **op, const char **stringp)
    42014270{
    42024271  const struct function_table_entry *entry_p = lookup_function (*stringp + 1);
    … …  
    42054274  return handle_function2 (entry_p, op, stringp);
    42064275}
     4276#else  /* CONFIG_WITH_VALUE_LENGTH */
     4277handle_function (char **op, const char **stringp, const char *eol)
     4278{
     4279  const char *fname = *stringp + 1;
     4280  const struct function_table_entry *entry_p = lookup_function (fname, eol - fname);
     4281  if (!entry_p)
     4282    return 0;
     4283  return handle_function2 (entry_p, op, stringp);
     4284}
     4285#endif /* CONFIG_WITH_VALUE_LENGTH */
    42074286
    42084287
    … …  
    42464325  /* Are we invoking a builtin function?  */
    42474326
     4327#ifndef CONFIG_WITH_VALUE_LENGTH
    42484328  entry_p = lookup_function (fname);
     4329#else
     4330  entry_p = lookup_function (fname, cp - fname + 1);
     4331#endif
    42494332  if (entry_p)
    42504333    {
    … …  
    42954378      char num[11];
    42964379
     4380#ifndef CONFIG_WITH_VALUE_LENGTH
    42974381      sprintf (num, "%d", i);
    42984382      define_variable (num, strlen (num), "", o_automatic, 0);
     4383#else
     4384      define_variable (num, sprintf (num, "%d", i), "", o_automatic, 0);
     4385#endif
    42994386    }
    43004387
    … …  
    43244411    {
    43254412      const struct floc *reading_file_saved = reading_file;
     4413      char *eos;
    43264414
    43274415      if (!strcmp (funcname, "evalcall"))
    … …  
    43314419
    43324420          size_t off = o - variable_buffer;
    4333           o = variable_buffer_output (o, v->value, v->value_length + 1);
     4421          eos = variable_buffer_output (o, v->value, v->value_length + 1) - 1;
    43344422          o = variable_buffer + off;
    43354423          if (v->fileinfo.filenm)
    … …  
    43414429
    43424430          v->exp_count = EXP_COUNT_MAX;
    4343           o = variable_expand_string (o, body, flen+3);
     4431          o = variable_expand_string_2 (o, body, flen+3, &eos);
    43444432          v->exp_count = 0;
    43454433        }
    43464434
    43474435      install_variable_buffer (&buf, &len);
    4348       eval_buffer (o);
     4436      eval_buffer (o, eos);
    43494437      restore_variable_buffer (buf, len);
    43504438      reading_file = reading_file_saved;
    … …  
    43674455  hash_load (&function_table, function_table_init,
    43684456             FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
    4369 #ifdef CONFIG_WITH_OPTIMIZATION_HACKS
     4457#if defined (CONFIG_WITH_OPTIMIZATION_HACKS) || defined (CONFIG_WITH_VALUE_LENGTH)
    43704458  {
    4371     unsigned i;
     4459    unsigned int i;
     4460    for (i = 'a'; i <= 'z'; i++)
     4461      func_char_map[i] = 1;
     4462    func_char_map[(unsigned int)'-'] = 1;
     4463
    43724464    for (i = 0; i < FUNCTION_TABLE_ENTRIES; i++)
     4465      {
    43734466        assert (function_table_init[i].len <= MAX_FUNCTION_LENGTH);
     4467        assert (function_table_init[i].len >= MIN_FUNCTION_LENGTH);
     4468      }
    43744469  }
    43754470#endif

  • trunk/src/kmk/kbuild.c

    r1818 r1827  
    17141714    char *pszDstVar, *pszDst, *pszSrcVar, *pszSrc, *pszVal, *psz;
    17151715    char *pszSavedVarBuf;
    1716     unsigned cchSavedVarBuf;
     1716    unsigned cchSavedVarBuf, cchVal;
    17171717    size_t cch;
    17181718    struct kbuild_sdks Sdks;
    … …  
    18931893    */
    18941894    pVar = kbuild_get_recursive_variable("def_target_source_rule");
    1895     pszVal = allocated_variable_expand_2(pVar->value, pVar->value_length, NULL);
     1895    pszVal = allocated_variable_expand_2(pVar->value, pVar->value_length, &cchVal); /** @todo we can use the variable buffer here. */
    18961896
    18971897    install_variable_buffer(&pszSavedVarBuf, &cchSavedVarBuf);
    1898     eval_buffer(pszVal);
     1898    eval_buffer(pszVal, pszVal + cchVal);
    18991899    restore_variable_buffer(pszSavedVarBuf, cchSavedVarBuf);
    19001900
    … …  
    19031903    kbuild_put_sdks(&Sdks);
    19041904    (void)pszFuncName;
    1905     return variable_buffer_output(o, "", 1);
     1905    return variable_buffer_output(o, "", 1); /** @todo not right. */
    19061906}
    19071907

  • trunk/src/kmk/make.h

    r1811 r1827  
    287287#define strneq(a, b, l) (strncmp ((a), (b), (l)) == 0)
    288288
    289 #if defined(__GNUC__) || defined(ENUM_BITFIELDS)
     289#if (defined(__GNUC__) || defined(ENUM_BITFIELDS)) && !defined(NO_ENUM_BITFIELDS)
    290290# define ENUM_BITFIELD(bits)    :bits
    291291#else

  • trunk/src/kmk/read.c

    r1821 r1827  
    469469
    470470int
     471#ifndef CONFIG_WITH_VALUE_LENGTH
    471472eval_buffer (char *buffer)
     473#else
     474eval_buffer (char *buffer, char *eos)
     475#endif
    472476{
    473477  struct ebuffer ebuf;
    … …  
    479483  /* Evaluate the buffer */
    480484
     485#ifndef CONFIG_WITH_VALUE_LENGTH
    481486  ebuf.size = strlen (buffer);
     487#else
     488  ebuf.size = eos - buffer;
     489  ebuf.eol = eos;
     490  assert(strchr(buffer, '\0') == eos);
     491#endif
    482492  ebuf.buffer = ebuf.bufnext = ebuf.bufstart = buffer;
    483493  ebuf.fp = NULL;
    484 #ifdef CONFIG_WITH_VALUE_LENGTH
    485   ebuf.eol = ebuf.buffer + ebuf.size;
    486 #endif
    487494
    488495  ebuf.floc = *reading_file;
    … …  
    19541961      if ((size_t)buf_pos & 7)
    19551962        buf_pos = variable_buffer_output (buf_pos, "\0\0\0\0\0\0\0\0",
    1956                                           8 - (size_t)buf_pos & 7);
    1957       s2 = variable_expand_string (buf_pos, s2, l);
     1963                                          8 - ((size_t)buf_pos & 7));
     1964      s2 = variable_expand_string_2 (buf_pos, s2, l, &buf_pos);
    19581965#endif
    19591966#ifdef CONFIG_WITH_SET_CONDITIONALS

  • trunk/src/kmk/variable.c

    r1811 r1827  
    132132    {
    133133        default:
    134         case 32: //UPDATE_HASH(uvar_end[-16]);
     134        case 32: /*UPDATE_HASH(uvar_end[-16]);*/
    135135        case 31: UPDATE_HASH(uvar_end[-15]);
    136         case 30: //UPDATE_HASH(uvar_end[-14]);
     136        case 30: /*UPDATE_HASH(uvar_end[-14]);*/
    137137        case 29: UPDATE_HASH(uvar_end[-13]);
    138         case 28: //UPDATE_HASH(uvar_end[-12]);
     138        case 28: /*UPDATE_HASH(uvar_end[-12]);*/
    139139        case 27: UPDATE_HASH(uvar_end[-11]);
    140         case 26: //UPDATE_HASH(uvar_end[-10]);
     140        case 26: /*UPDATE_HASH(uvar_end[-10]);*/
    141141        case 25: UPDATE_HASH(uvar_end[-9]);
    142         case 24: //UPDATE_HASH(uvar[15]);
     142        case 24: /*UPDATE_HASH(uvar[15]);*/
    143143        case 23: UPDATE_HASH(uvar[14]);
    144         case 22: //UPDATE_HASH(uvar[13]);
     144        case 22: /*UPDATE_HASH(uvar[13]);*/
    145145        case 21: UPDATE_HASH(uvar[12]);
    146         case 20: //UPDATE_HASH(uvar[11]);
     146        case 20: /*UPDATE_HASH(uvar[11]);*/
    147147        case 19: UPDATE_HASH(uvar[10]);
    148         case 18: //UPDATE_HASH(uvar[9]);
     148        case 18: /*UPDATE_HASH(uvar[9]);*/
    149149        case 17: UPDATE_HASH(uvar[8]);
    150         case 16: //UPDATE_HASH(uvar_end[-8]);
     150        case 16: /*UPDATE_HASH(uvar_end[-8]);*/
    151151        case 15: UPDATE_HASH(uvar_end[-7]);
    152         case 14: //UPDATE_HASH(uvar_end[-6]);
     152        case 14: /*UPDATE_HASH(uvar_end[-6]);*/
    153153        case 13: UPDATE_HASH(uvar_end[-5]);
    154         case 12: //UPDATE_HASH(uvar_end[-4]);
     154        case 12: /*UPDATE_HASH(uvar_end[-4]);*/
    155155        case 11: UPDATE_HASH(uvar_end[-3]);
    156         case 10: //UPDATE_HASH(uvar_end[-2]);
     156        case 10: /*UPDATE_HASH(uvar_end[-2]);*/
    157157        case 9:  UPDATE_HASH(uvar_end[-1]);
    158         case 8:  //UPDATE_HASH(uvar[7]);
     158        case 8:  /*UPDATE_HASH(uvar[7]);*/
    159159        case 7:  UPDATE_HASH(uvar[6]);
    160         case 6:  //UPDATE_HASH(uvar[5]);
     160        case 6:  /*UPDATE_HASH(uvar[5]);*/
    161161        case 5:  UPDATE_HASH(uvar[4]);
    162         case 4:  //UPDATE_HASH(uvar[3]);
     162        case 4:  /*UPDATE_HASH(uvar[3]);*/
    163163        case 3:  UPDATE_HASH(uvar[2]);
    164         case 2:  //UPDATE_HASH(uvar[1]);
     164        case 2:  /*UPDATE_HASH(uvar[1]);*/
    165165        case 1:  UPDATE_HASH(uvar[0]);
    166166        case 0:
    … …  
    193193#if 0 /* seems to be a waste of time. */
    194194        case 97: UPDATE_HASH(uvar_end[-77]);
    195         case 96: //UPDATE_HASH(uvar_end[-76]);
    196         case 95: //UPDATE_HASH(uvar_end[-75]);
    197         case 94: //UPDATE_HASH(uvar_end[-74]);
     195        case 96: /*UPDATE_HASH(uvar_end[-76]);*/
     196        case 95: /*UPDATE_HASH(uvar_end[-75]);*/
     197        case 94: /*UPDATE_HASH(uvar_end[-74]);*/
    198198        case 93: UPDATE_HASH(uvar_end[-73]);
    199         case 92: //UPDATE_HASH(uvar_end[-72]);
    200         case 91: //UPDATE_HASH(uvar_end[-71]);
    201         case 90: //UPDATE_HASH(uvar_end[-70]);
     199        case 92: /*UPDATE_HASH(uvar_end[-72]);*/
     200        case 91: /*UPDATE_HASH(uvar_end[-71]);*/
     201        case 90: /*UPDATE_HASH(uvar_end[-70]);*/
    202202        case 89: UPDATE_HASH(uvar_end[-69]);
    203         case 88: //UPDATE_HASH(uvar_end[-68]);
    204         case 87: //UPDATE_HASH(uvar_end[-67]);
    205         case 86: //UPDATE_HASH(uvar_end[-66]);
     203        case 88: /*UPDATE_HASH(uvar_end[-68]);*/
     204        case 87: /*UPDATE_HASH(uvar_end[-67]);*/
     205        case 86: /*UPDATE_HASH(uvar_end[-66]);*/
    206206        case 85: UPDATE_HASH(uvar_end[-65]);
    207         case 84: //UPDATE_HASH(uvar_end[-64]);
    208         case 83: //UPDATE_HASH(uvar_end[-63]);
    209         case 82: //UPDATE_HASH(uvar_end[-62]);
     207        case 84: /*UPDATE_HASH(uvar_end[-64]);*/
     208        case 83: /*UPDATE_HASH(uvar_end[-63]);*/
     209        case 82: /*UPDATE_HASH(uvar_end[-62]);*/
    210210        case 81: UPDATE_HASH(uvar_end[-61]);
    211         case 80: //UPDATE_HASH(uvar_end[-60]);
    212         case 79: //UPDATE_HASH(uvar_end[-59]);
    213         case 78: //UPDATE_HASH(uvar_end[-58]);
     211        case 80: /*UPDATE_HASH(uvar_end[-60]);*/
     212        case 79: /*UPDATE_HASH(uvar_end[-59]);*/
     213        case 78: /*UPDATE_HASH(uvar_end[-58]);*/
    214214        case 77: UPDATE_HASH(uvar_end[-57]);
    215         case 76: //UPDATE_HASH(uvar_end[-56]);
    216         case 75: //UPDATE_HASH(uvar_end[-55]);
    217         case 74: //UPDATE_HASH(uvar_end[-54]);
     215        case 76: /*UPDATE_HASH(uvar_end[-56]);*/
     216        case 75: /*UPDATE_HASH(uvar_end[-55]);*/
     217        case 74: /*UPDATE_HASH(uvar_end[-54]);*/
    218218        case 73: UPDATE_HASH(uvar_end[-53]);
    219         case 72: //UPDATE_HASH(uvar_end[-52]);
    220         case 71: //UPDATE_HASH(uvar_end[-51]);
    221         case 70: //UPDATE_HASH(uvar_end[-50]);
     219        case 72: /*UPDATE_HASH(uvar_end[-52]);*/
     220        case 71: /*UPDATE_HASH(uvar_end[-51]);*/
     221        case 70: /*UPDATE_HASH(uvar_end[-50]);*/
    222222        case 69: UPDATE_HASH(uvar_end[-49]);
    223         case 68: //UPDATE_HASH(uvar_end[-48]);
    224         case 67: //UPDATE_HASH(uvar_end[-47]);
    225         case 66: //UPDATE_HASH(uvar_end[-46]);
     223        case 68: /*UPDATE_HASH(uvar_end[-48]);*/
     224        case 67: /*UPDATE_HASH(uvar_end[-47]);*/
     225        case 66: /*UPDATE_HASH(uvar_end[-46]);*/
    226226        case 65: UPDATE_HASH(uvar_end[-49]);
    227         case 64: //UPDATE_HASH(uvar_end[-48]);
    228         case 63: //UPDATE_HASH(uvar_end[-47]);
    229         case 62: //UPDATE_HASH(uvar_end[-46]);
     227        case 64: /*UPDATE_HASH(uvar_end[-48]);*/
     228        case 63: /*UPDATE_HASH(uvar_end[-47]);*/
     229        case 62: /*UPDATE_HASH(uvar_end[-46]);*/
    230230        case 61: UPDATE_HASH(uvar_end[-45]);
    231         case 60: //UPDATE_HASH(uvar_end[-44]);
    232         case 59: //UPDATE_HASH(uvar_end[-43]);
    233         case 58: //UPDATE_HASH(uvar_end[-42]);
     231        case 60: /*UPDATE_HASH(uvar_end[-44]);*/
     232        case 59: /*UPDATE_HASH(uvar_end[-43]);*/
     233        case 58: /*UPDATE_HASH(uvar_end[-42]);*/
    234234        case 57: UPDATE_HASH(uvar_end[-41]);
    235         case 56: //UPDATE_HASH(uvar_end[-40]);
    236         case 55: //UPDATE_HASH(uvar_end[-39]);
    237         case 54: //UPDATE_HASH(uvar_end[-38]);
     235        case 56: /*UPDATE_HASH(uvar_end[-40]);*/
     236        case 55: /*UPDATE_HASH(uvar_end[-39]);*/
     237        case 54: /*UPDATE_HASH(uvar_end[-38]);*/
    238238        case 53: UPDATE_HASH(uvar_end[-37]);
    239         case 52: //UPDATE_HASH(uvar_end[-36]);
     239        case 52: /*UPDATE_HASH(uvar_end[-36]);*/
    240240        case 51: UPDATE_HASH(uvar_end[-35]);
    241         case 50: //UPDATE_HASH(uvar_end[-34]);
     241        case 50: /*UPDATE_HASH(uvar_end[-34]);*/
    242242        case 49: UPDATE_HASH(uvar_end[-33]);
    243243#endif
    244         case 48: //UPDATE_HASH(uvar_end[-32]);
     244        case 48: /*UPDATE_HASH(uvar_end[-32]);*/
    245245        case 47: UPDATE_HASH(uvar_end[-31]);
    246         case 46: //UPDATE_HASH(uvar_end[-30]);
     246        case 46: /*UPDATE_HASH(uvar_end[-30]);*/
    247247        case 45: UPDATE_HASH(uvar_end[-29]);
    248         case 44: //UPDATE_HASH(uvar_end[-28]);
     248        case 44: /*UPDATE_HASH(uvar_end[-28]);*/
    249249        case 43: UPDATE_HASH(uvar_end[-27]);
    250         case 42: //UPDATE_HASH(uvar_end[-26]);
     250        case 42: /*UPDATE_HASH(uvar_end[-26]);*/
    251251        case 41: UPDATE_HASH(uvar_end[-25]);
    252         case 40: //UPDATE_HASH(uvar_end[-24]);
     252        case 40: /*UPDATE_HASH(uvar_end[-24]);*/
    253253        case 39: UPDATE_HASH(uvar_end[-23]);
    254         case 38: //UPDATE_HASH(uvar_end[-22]);
     254        case 38: /*UPDATE_HASH(uvar_end[-22]);*/
    255255        case 37: UPDATE_HASH(uvar_end[-21]);
    256         case 36: //UPDATE_HASH(uvar_end[-20]);
     256        case 36: /*UPDATE_HASH(uvar_end[-20]);*/
    257257        case 35: UPDATE_HASH(uvar_end[-19]);
    258         case 34: //UPDATE_HASH(uvar_end[-18]);
     258        case 34: /*UPDATE_HASH(uvar_end[-18]);*/
    259259        case 33: UPDATE_HASH(uvar_end[-17]);
    260260
    … …  
    15771577            && v->origin != o_env && v->origin != o_env_override)
    15781578          {
     1579#ifndef CONFIG_WITH_VALUE_LENGTH
    15791580            char *value = recursively_expand_for_file (v, file);
     1581#else
     1582            char *value = recursively_expand_for_file (v, file, NULL);
     1583#endif
    15801584#ifdef WINDOWS32
    15811585            if (strcmp(v->name, "Path") == 0 ||
    … …  
    21932197
    21942198  vp = do_variable_definition_2 (flocp, v.name, v.value,
    2195                                  v.value_length != -1 ? v.value_length : ~0U,
     2199                                 v.value_length != -1 ? (unsigned int)v.value_length : ~0U, /* FIXME */
    21962200                                 0, NULL, origin, v.flavor, target_var);
    21972201#endif

  • trunk/src/kmk/variable.h

    r1811 r1827  
    142142# define allocated_variable_expand(line) \
    143143  allocated_variable_expand_2 (line, -1, NULL)
    144 char *allocated_variable_expand_2(const char *line, unsigned int length, unsigned int *value_len);
     144char *allocated_variable_expand_2(const char *line, unsigned int length, unsigned int *value_lenp);
    145145#endif /* CONFIG_WITH_VALUE_LENGTH */
    146146char *expand_argument (const char *str, const char *end);
     147#ifndef CONFIG_WITH_VALUE_LENGTH
    147148char *variable_expand_string (char *line, const char *string, long length);
    148 #ifdef CONFIG_WITH_VALUE_LENGTH
     149#else  /* CONFIG_WITH_VALUE_LENGTH */
    149150char *variable_expand_string_2 (char *line, const char *string, long length, char **eol);
    150 #endif
     151__inline static char *
     152variable_expand_string (char *line, const char *string, long length)
     153{
     154    char *ignored;
     155    return variable_expand_string_2 (line, string, length, &ignored);
     156}
     157#endif /* CONFIG_WITH_VALUE_LENGTH */
    151158void install_variable_buffer (char **bufp, unsigned int *lenp);
    152159void restore_variable_buffer (char *buf, unsigned int len);
    … …  
    157164
    158165/* function.c */
     166#ifndef CONFIG_WITH_VALUE_LENGTH
    159167int handle_function (char **op, const char **stringp);
     168#else
     169int handle_function (char **op, const char **stringp, const char *eol);
     170#endif
    160171int pattern_matches (const char *pattern, const char *percent, const char *str);
    161172char *subst_expand (char *o, const char *text, const char *subst,
    … …  
    171182
    172183/* expand.c */
     184#ifndef CONFIG_WITH_VALUE_LENGTH
    173185char *recursively_expand_for_file (struct variable *v, struct file *file);
    174186#define recursively_expand(v)   recursively_expand_for_file (v, NULL)
     187#else
     188char *recursively_expand_for_file (struct variable *v, struct file *file,
     189                                   unsigned int *value_lenp);
     190#define recursively_expand(v)   recursively_expand_for_file (v, NULL, NULL)
     191#endif
    175192
    176193/* variable.c */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette