comparison lib-src/ebrowse.c @ 30232:ad501fc526c2

(xrealloc, xmalloc): Renamed from yrealloc and ymalloc.

30231:5b3608e3adaf

void add_member_defn P_ ((struct sym *, char *, char *,
			  int, unsigned, int, int, int));
void add_member_decl P_ ((struct sym *, char *, char *, int,
			  unsigned, int, int, int, int));
void dump_roots P_ ((FILE *));
void *ymalloc P_ ((int));
void add_global_defn P_ ((char *, char *, int, unsigned, int, int, int));
void add_global_decl P_ ((char *, char *, int, unsigned, int, int, int));
void add_define P_ ((char *, char *, int));
void mark_inherited_virtual P_ ((void));
void leave_namespace P_ ((void));

   available.  This isn't called `xmalloc' because src/m/alpha.h,
   and maybe others, contain an incompatible prototype for xmalloc
   and xrealloc.  */

void *
ymalloc (nbytes)
     int nbytes;
{
  void *p = malloc (nbytes);
  if (p == NULL)
    {

/* Like realloc but print an error and exit if out of memory.  */

void *
yrealloc (p, sz)
     void *p;
     int sz;
{
  p = realloc (p, sz);
  if (p == NULL)

char *
xstrdup (s)
     char *s;
{
  if (s)
    s = strcpy (ymalloc (strlen (s) + 1), s);
  return s;
}




	{
	  putchar ('\t');
	  puts (name);
	}

      sym = (struct sym *) ymalloc (sizeof *sym + strlen (name));
      bzero (sym, sizeof *sym);
      strcpy (sym->name, name);
      sym->namesp = scope;
      sym->next = class_table[h];
      class_table[h] = sym;

    ;

  /* Avoid duplicates.  */
  if (p == NULL || p->sym != sub)
    {
      lnk = (struct link *) ymalloc (sizeof *lnk);
      lnk2 = (struct link *) ymalloc (sizeof *lnk2);
  
      lnk->sym = sub;
      lnk->next = p;

      if (prev)

     char *name;
     int var;
     int sc;
     unsigned hash;
{
  struct member *m = (struct member *) ymalloc (sizeof *m + strlen (name));
  struct member **list;
  struct member *p;
  struct member *prev;
  unsigned name_hash = 0;
  int i;

struct sym *
make_namespace (name)
     char *name;
{
  struct sym *s = (struct sym *) ymalloc (sizeof *s + strlen (name));
  bzero (s, sizeof *s);
  strcpy (s->name, name);
  s->next = all_namespaces;
  s->namesp = current_namespace;
  all_namespaces = s;

  /* Is it already in the list of aliases?  */
  for (al = p->namesp_aliases; al; al = al->next)
    if (streq (new_name, p->name))
      return;

  al = (struct alias *) ymalloc (sizeof *al + strlen (new_name));
  strcpy (al->name, new_name);
  al->next = p->namesp_aliases;
  p->namesp_aliases = al;
}

  struct sym *p = find_namespace (name);

  if (namespace_sp == namespace_stack_size)
    {
      int size = max (10, 2 * namespace_stack_size);
      namespace_stack = (struct sym **) yrealloc (namespace_stack, size);
      namespace_stack_size = size;
    }
  
  namespace_stack[namespace_sp++] = current_namespace;
  current_namespace = p;

     int len;
{
  if (scope_buffer_len + len >= scope_buffer_size)
    {
      int new_size = max (2 * scope_buffer_size, scope_buffer_len + len);
      scope_buffer = (char *) yrealloc (new_size);
      scope_buffer_size = new_size;
    }
}

     struct sym *p;
{
  if (!scope_buffer)
    {
      scope_buffer_size = 1024;
      scope_buffer = (char *) ymalloc (scope_buffer_size);
    }
  
  *scope_buffer = '\0';
  scope_buffer_len = 0;
  

	      {
		hash = (hash << 1) ^ *p++;
		if (p == yytext_end - 1)
		  {
		    int size = yytext_end - yytext;
		    yytext = (char *) yrealloc (yytext, 2 * size);
		    yytext_end = yytext + 2 * size;
		    p = yytext + size - 1;
		  }
	      }

  if (!f_regexps)
    return NULL;

  if (buffer == NULL)
    {
      buffer = (char *) ymalloc (max_regexp);
      end_buf = &buffer[max_regexp] - 1;
    }

  /* Scan back to previous newline of buffer start.  */
  for (p = in - 1; p > inbuffer && *p != '\n'; --p)

  yyline = 1;
  
  if (yytext == NULL)
    {
      int size = 256;
      yytext = (char *) ymalloc (size * sizeof *yytext);
      yytext_end = yytext + size;
    }
}

     char *name;
     int tk;
{
  char *s;
  unsigned h = 0;
  struct kw *k = (struct kw *) ymalloc (sizeof *k);

  for (s = name; *s; ++s)
    h = (h << 1) ^ *s;

  h %= KEYWORD_TABLE_SIZE;

{
  int i;

  /* Allocate the input buffer */
  inbuffer_size = READ_CHUNK_SIZE + 1;
  inbuffer = in = (char *) ymalloc (inbuffer_size);
  yyline = 1;

  /* Set up character class vectors.  */
  for (i = 0; i < sizeof is_ident; ++i)
    {

      
      len = strlen (s) + 10;
      if (len > id_size)
	{
	  int new_size = max (len, 2 * id_size);
	  id = (char *) yrealloc (id, new_size);
	  id_size = new_size;
	}
      strcpy (id, s);

      /* Vector new or delete? */

      len = 20;
      if (len > id_size)
	{
	  int new_size = max (len, 2 * id_size);
	  id = (char *) yrealloc (id, new_size);
	  id_size = new_size;
	}
      strcpy (id, "operator");

      /* Beware access declarations of the form "X::f;" Beware of

	  s = token_string (LA1);
	  len += strlen (s) + 2;
	  if (len > id_size)
	    {
	      int new_size = max (len, 2 * id_size);
	      id = (char *) yrealloc (id, new_size);
	      id_size = new_size;
	    }

	  if (*s != ')' && *s != ']')
	    strcat (id, " ");

  while (LOOKING_AT (IDENT))
    {
      int len = strlen (yytext) + 1;
      if (len > id_size)
	{
	  id = (char *) yrealloc (id, len);
	  id_size = len;
	}
      strcpy (id, yytext);
      *last_id = id;
      MATCH ();

  while (LOOKING_AT (IDENT))
    {
      int len = strlen (yytext) + 1;
      if (len > id_size)
	{
	  id = (char *) yrealloc (id, len);
	  id_size = len;
	}
      strcpy (id, yytext);
      *last_id = id;
      MATCH ();

      struct search_path *p;
      
      while (*path_list && *path_list != PATH_LIST_SEPARATOR)
        ++path_list;
      
      p = (struct search_path *) ymalloc (sizeof *p);
      p->path = (char *) ymalloc (path_list - start + 1);
      memcpy (p->path, start, path_list - start);
      p->path[path_list - start] = '\0';
      p->next = NULL;

      if (search_path_tail)

      int len = strlen (path->path) + flen;

      if (len + 1 >= buffer_size)
	{
	  buffer_size = max (len + 1, 2 * buffer_size);
	  buffer = (char *) yrealloc (buffer, buffer_size);
	}
	
      strcpy (buffer, path->path);
      strcat (buffer, "/");
      strcat (buffer, file);

      for (nread = 0;;)
	{
	  if (nread + READ_CHUNK_SIZE >= inbuffer_size)
	    {
	      inbuffer_size = nread + READ_CHUNK_SIZE + 1;
	      inbuffer = (char *) yrealloc (inbuffer, inbuffer_size);
	    }
	  
	  nbytes = fread (inbuffer + nread, 1, READ_CHUNK_SIZE, fp);
	  if (nbytes <= 0)
	    break;

  while ((c = getc (fp)) != EOF && c != '\n')
    {
      if (i >= buffer_size)
	{
	  buffer_size = max (100, buffer_size * 2);
	  buffer = (char *) yrealloc (buffer, buffer_size);
	}

      buffer[i++] = c;
    }
  

    return NULL;
  
  if (i == buffer_size)
    {
      buffer_size = max (100, buffer_size * 2);
      buffer = (char *) yrealloc (buffer, buffer_size);
    }

  buffer[i] = '\0';
  return buffer;
}

          /* Add the name of a file containing more input files.  */
        case 'f':
	  if (n_input_files == input_filenames_size)
	    {
	      input_filenames_size = max (10, 2 * input_filenames_size);
	      input_filenames = (char **) yrealloc (input_filenames,
						    input_filenames_size);
	    }
          input_filenames[n_input_files++] = xstrdup (optarg);
          break;

30232:ad501fc526c2

void add_member_defn P_ ((struct sym *, char *, char *,
			  int, unsigned, int, int, int));
void add_member_decl P_ ((struct sym *, char *, char *, int,
			  unsigned, int, int, int, int));
void dump_roots P_ ((FILE *));
void *xmalloc P_ ((int));
void add_global_defn P_ ((char *, char *, int, unsigned, int, int, int));
void add_global_decl P_ ((char *, char *, int, unsigned, int, int, int));
void add_define P_ ((char *, char *, int));
void mark_inherited_virtual P_ ((void));
void leave_namespace P_ ((void));

   available.  This isn't called `xmalloc' because src/m/alpha.h,
   and maybe others, contain an incompatible prototype for xmalloc
   and xrealloc.  */

void *
xmalloc (nbytes)
     int nbytes;
{
  void *p = malloc (nbytes);
  if (p == NULL)
    {

/* Like realloc but print an error and exit if out of memory.  */

void *
xrealloc (p, sz)
     void *p;
     int sz;
{
  p = realloc (p, sz);
  if (p == NULL)

char *
xstrdup (s)
     char *s;
{
  if (s)
    s = strcpy (xmalloc (strlen (s) + 1), s);
  return s;
}




	{
	  putchar ('\t');
	  puts (name);
	}

      sym = (struct sym *) xmalloc (sizeof *sym + strlen (name));
      bzero (sym, sizeof *sym);
      strcpy (sym->name, name);
      sym->namesp = scope;
      sym->next = class_table[h];
      class_table[h] = sym;

    ;

  /* Avoid duplicates.  */
  if (p == NULL || p->sym != sub)
    {
      lnk = (struct link *) xmalloc (sizeof *lnk);
      lnk2 = (struct link *) xmalloc (sizeof *lnk2);
  
      lnk->sym = sub;
      lnk->next = p;

      if (prev)

     char *name;
     int var;
     int sc;
     unsigned hash;
{
  struct member *m = (struct member *) xmalloc (sizeof *m + strlen (name));
  struct member **list;
  struct member *p;
  struct member *prev;
  unsigned name_hash = 0;
  int i;

struct sym *
make_namespace (name)
     char *name;
{
  struct sym *s = (struct sym *) xmalloc (sizeof *s + strlen (name));
  bzero (s, sizeof *s);
  strcpy (s->name, name);
  s->next = all_namespaces;
  s->namesp = current_namespace;
  all_namespaces = s;

  /* Is it already in the list of aliases?  */
  for (al = p->namesp_aliases; al; al = al->next)
    if (streq (new_name, p->name))
      return;

  al = (struct alias *) xmalloc (sizeof *al + strlen (new_name));
  strcpy (al->name, new_name);
  al->next = p->namesp_aliases;
  p->namesp_aliases = al;
}

  struct sym *p = find_namespace (name);

  if (namespace_sp == namespace_stack_size)
    {
      int size = max (10, 2 * namespace_stack_size);
      namespace_stack = (struct sym **) xrealloc (namespace_stack, size);
      namespace_stack_size = size;
    }
  
  namespace_stack[namespace_sp++] = current_namespace;
  current_namespace = p;

     int len;
{
  if (scope_buffer_len + len >= scope_buffer_size)
    {
      int new_size = max (2 * scope_buffer_size, scope_buffer_len + len);
      scope_buffer = (char *) xrealloc (new_size);
      scope_buffer_size = new_size;
    }
}

     struct sym *p;
{
  if (!scope_buffer)
    {
      scope_buffer_size = 1024;
      scope_buffer = (char *) xmalloc (scope_buffer_size);
    }
  
  *scope_buffer = '\0';
  scope_buffer_len = 0;
  

	      {
		hash = (hash << 1) ^ *p++;
		if (p == yytext_end - 1)
		  {
		    int size = yytext_end - yytext;
		    yytext = (char *) xrealloc (yytext, 2 * size);
		    yytext_end = yytext + 2 * size;
		    p = yytext + size - 1;
		  }
	      }

  if (!f_regexps)
    return NULL;

  if (buffer == NULL)
    {
      buffer = (char *) xmalloc (max_regexp);
      end_buf = &buffer[max_regexp] - 1;
    }

  /* Scan back to previous newline of buffer start.  */
  for (p = in - 1; p > inbuffer && *p != '\n'; --p)

  yyline = 1;
  
  if (yytext == NULL)
    {
      int size = 256;
      yytext = (char *) xmalloc (size * sizeof *yytext);
      yytext_end = yytext + size;
    }
}

     char *name;
     int tk;
{
  char *s;
  unsigned h = 0;
  struct kw *k = (struct kw *) xmalloc (sizeof *k);

  for (s = name; *s; ++s)
    h = (h << 1) ^ *s;

  h %= KEYWORD_TABLE_SIZE;

{
  int i;

  /* Allocate the input buffer */
  inbuffer_size = READ_CHUNK_SIZE + 1;
  inbuffer = in = (char *) xmalloc (inbuffer_size);
  yyline = 1;

  /* Set up character class vectors.  */
  for (i = 0; i < sizeof is_ident; ++i)
    {

      
      len = strlen (s) + 10;
      if (len > id_size)
	{
	  int new_size = max (len, 2 * id_size);
	  id = (char *) xrealloc (id, new_size);
	  id_size = new_size;
	}
      strcpy (id, s);

      /* Vector new or delete? */

      len = 20;
      if (len > id_size)
	{
	  int new_size = max (len, 2 * id_size);
	  id = (char *) xrealloc (id, new_size);
	  id_size = new_size;
	}
      strcpy (id, "operator");

      /* Beware access declarations of the form "X::f;" Beware of

	  s = token_string (LA1);
	  len += strlen (s) + 2;
	  if (len > id_size)
	    {
	      int new_size = max (len, 2 * id_size);
	      id = (char *) xrealloc (id, new_size);
	      id_size = new_size;
	    }

	  if (*s != ')' && *s != ']')
	    strcat (id, " ");

  while (LOOKING_AT (IDENT))
    {
      int len = strlen (yytext) + 1;
      if (len > id_size)
	{
	  id = (char *) xrealloc (id, len);
	  id_size = len;
	}
      strcpy (id, yytext);
      *last_id = id;
      MATCH ();

  while (LOOKING_AT (IDENT))
    {
      int len = strlen (yytext) + 1;
      if (len > id_size)
	{
	  id = (char *) xrealloc (id, len);
	  id_size = len;
	}
      strcpy (id, yytext);
      *last_id = id;
      MATCH ();

      struct search_path *p;
      
      while (*path_list && *path_list != PATH_LIST_SEPARATOR)
        ++path_list;
      
      p = (struct search_path *) xmalloc (sizeof *p);
      p->path = (char *) xmalloc (path_list - start + 1);
      memcpy (p->path, start, path_list - start);
      p->path[path_list - start] = '\0';
      p->next = NULL;

      if (search_path_tail)

      int len = strlen (path->path) + flen;

      if (len + 1 >= buffer_size)
	{
	  buffer_size = max (len + 1, 2 * buffer_size);
	  buffer = (char *) xrealloc (buffer, buffer_size);
	}
	
      strcpy (buffer, path->path);
      strcat (buffer, "/");
      strcat (buffer, file);

      for (nread = 0;;)
	{
	  if (nread + READ_CHUNK_SIZE >= inbuffer_size)
	    {
	      inbuffer_size = nread + READ_CHUNK_SIZE + 1;
	      inbuffer = (char *) xrealloc (inbuffer, inbuffer_size);
	    }
	  
	  nbytes = fread (inbuffer + nread, 1, READ_CHUNK_SIZE, fp);
	  if (nbytes <= 0)
	    break;

  while ((c = getc (fp)) != EOF && c != '\n')
    {
      if (i >= buffer_size)
	{
	  buffer_size = max (100, buffer_size * 2);
	  buffer = (char *) xrealloc (buffer, buffer_size);
	}

      buffer[i++] = c;
    }
  

    return NULL;
  
  if (i == buffer_size)
    {
      buffer_size = max (100, buffer_size * 2);
      buffer = (char *) xrealloc (buffer, buffer_size);
    }

  buffer[i] = '\0';
  return buffer;
}

          /* Add the name of a file containing more input files.  */
        case 'f':
	  if (n_input_files == input_filenames_size)
	    {
	      input_filenames_size = max (10, 2 * input_filenames_size);
	      input_filenames = (char **) xrealloc (input_filenames,
						    input_filenames_size);
	    }
          input_filenames[n_input_files++] = xstrdup (optarg);
          break;