emacs: lib-src/ebrowse.c comparison

comparison lib-src/ebrowse.c @ 42174:e3b97ef49aee

Include stdlib.h and string.h conditionally.

author	Pavel Janík <Pavel@Janik.cz>
date	Wed, 19 Dec 2001 06:03:40 +0000
parents	1ba618f8fdb5
children	20ee6e9752ef

comparison

equal deleted inserted replaced

-:9c9bb29ed93f
+:e3b97ef49aee
 	         2000, 2001
 Free Software Foundation Inc.
 Author: Gerd Moellmann <gerd@gnu.org>
 Maintainer: FSF
 This file is part of GNU Emacs.
 GNU Emacs is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
+#ifdef HAVE_STDLIB_H
 #include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
 #include <string.h>
+#endif
 #include <ctype.h>
 #include <assert.h>
 #include "getopt.h"
 /* The SunOS compiler doesn't have SEEK_END.  */
 /* Return the current buffer position in the input file.  */
 #define BUFFER_POS() (in - inbuffer)
 /* If current lookahead is CSTRING, the following points to the
 first character in the string constant.  Used for recognizing
 extern "C".  */
 char *string_start;
 /* 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)
 	prev->next = lnk;
 switch (sc)
 {
 case SC_FRIEND:
 list = &cls->friends;
 break;
 case SC_TYPE:
 list = &cls->types;
 break;
 case SC_STATIC:
 list = var ? &cls->static_vars : &cls->static_fns;
 break;
 default:
 list = var ? &cls->vars : &cls->fns;
 break;
 }
 specifies the type of member (instance member, static, ...).  VIS
 is the member's visibility (public, protected, private).  FLAGS is
 a bit set giving additional information about the member (see the
 F_* defines).  */
 void
 add_global_decl (name, regexp, pos, hash, var, sc, flags)
 char *name, *regexp;
 int pos;
 unsigned hash;
 int var;
 switch (sc)
 {
 case SC_FRIEND:
 list = &cls->friends;
 break;
 case SC_TYPE:
 list = &cls->types;
 break;
 case SC_STATIC:
 list = var ? &cls->static_vars : &cls->static_fns;
 break;
 default:
 list = var ? &cls->vars : &cls->fns;
 break;
 }
 check_namespace (name, context)
 char *name;
 struct sym *context;
 {
 struct sym *p = NULL;
 for (p = all_namespaces; p; p = p->next)
 {
 if (streq (p->name, name) && (p->namesp == context))
 	    break;
 	}
 if (p == NULL)
 p = make_namespace (name, context);
 return p;
 }
 /* Find namespace alias with name NAME. If not found return NULL. */
 struct link *
 check_namespace_alias (name)
 namespace_stack
 	= (struct sym **) xrealloc ((void *)namespace_stack,
 				    size * sizeof *namespace_stack);
 namespace_stack_size = size;
 }
 namespace_stack[namespace_sp++] = current_namespace;
 current_namespace = p;
 }
 char *
 sym_scope_1 (p)
 struct sym *p;
 {
 int len;
 if (p->namesp)
 sym_scope_1 (p->namesp);
 if (*scope_buffer)
 {
 len = strlen (p->name);
 ensure_scope_buffer_room (len + 1);
 strcat (scope_buffer, p->name);
 scope_buffer_len += len;
 if (HAS_FLAG (p->flags, F_TEMPLATE))
 {
 ensure_scope_buffer_room (3);
 strcat (scope_buffer, "<>");
 scope_buffer_len += 2;
 }
 return scope_buffer;
 }
 /* Return the scope of symbol P in printed representation, i.e.
 if (!scope_buffer)
 {
 scope_buffer_size = 1024;
 scope_buffer = (char *) xmalloc (scope_buffer_size);
 }
 *scope_buffer = '\0';
 scope_buffer_len = 0;
 if (p->namesp)
 sym_scope_1 (p->namesp);
 return scope_buffer;
 }
 FILE *fp;
 struct sym *root;
 {
 fputs (CLASS_STRUCT, fp);
 PUTSTR (root->name, fp);
 /* Print scope, if any.  */
 if (root->namesp)
 PUTSTR (sym_scope (root), fp);
 else
 PUTSTR (NULL, fp);
 /* Print flags.  */
 fprintf (fp, "%u", root->flags);
 PUTSTR (root->filename, fp);
 PUTSTR (root->regexp, fp);
 fprintf (fp, "%u", (unsigned) root->pos);
 	  char *regexp = matching_regexp ();
 	  int pos = BUFFER_POS ();
 	  add_define (yytext, regexp, pos);
 	}
 }
 while (c && (c != '\n' || in_comment || in_string))
 {
 if (c == '\\')
 	GET (c);
 else if (c == '/' && !in_comment)
 	  if (GET (c) == '/')
 	    in_comment = 0;
 	}
 else if (c == '"')
 	in_string = !in_string;
 if (c == '\n')
 	INCREMENT_LINENO;
 GET (c);
 }
 void
 re_init_scanner ()
 {
 in = inbuffer;
 yyline = 1;
 if (yytext == NULL)
 {
 int size = 256;
 yytext = (char *) xmalloc (size * sizeof *yytext);
 yytext_end = yytext + size;
 switch (open = LA1)
 {
 case '{':
 close = '}';
 break;
 case '(':
 close = ')';
 break;
 case '<':
 close = '>';
 break;
 case '[':
 close = ']';
 break;
 default:
 abort ();
 }
 for (n = 0;;)
 case IDENT:
 if (!type_seen)
 {
 	      char *last_id;
 	      unsigned ident_type_hash = 0;
 	      parse_qualified_param_ident_or_type (&last_id);
 	      if (last_id)
 		{
 		  /* LAST_ID null means something like `X::*'.  */
 		  for (; *last_id; ++last_id)
 case BOOL:      case CHAR:      case CLASS:     case CONST:
 case DOUBLE:    case ENUM:      case FLOAT:     case INT:
 case LONG:      case SHORT:     case SIGNED:    case STRUCT:
 case UNION:     case UNSIGNED:  case VOLATILE:  case WCHAR:
 case ELLIPSIS:
 type_seen = 1;
 hash = (hash << 1) ^ LA1;
 MATCH ();
 break;
 }
 if (LOOKING_AT (')'))
 {
 MATCH ();
 if (LOOKING_AT (CONST))
 {
 /* We can overload the same function on `const' */
 hash = (hash << 1) ^ CONST;
 SET_FLAG (*flags, F_CONST);
 break;
 case EXPLICIT:
 SET_FLAG (flags, F_EXPLICIT);
 goto typeseen;
 case MUTABLE:
 SET_FLAG (flags, F_MUTABLE);
 goto typeseen;
 case T_INLINE:
 declaration.  We don't want to add friend classes as members.  */
 if (id && sc != SC_FRIEND && cls)
 {
 regexp = matching_regexp ();
 pos = BUFFER_POS ();
 if (cls != NULL)
 {
 if (type_seen || !paren_seen)
 		add_member_decl (cls, id, regexp, pos, 0, 1, sc, vis, 0);
 else
 		add_member_decl (cls, id, regexp, pos, hash, 0, sc, vis, 0);
 }
 }
 MATCH ();
 print_info ();
 }
 else if (LOOKING_AT ('{'))
 {
 struct sym *
 parse_classname ()
 {
 struct sym *last_class = NULL;
 while (LOOKING_AT (IDENT))
 {
 last_class = add_sym (yytext, last_class);
 MATCH ();
 if (LOOKING_AT ('<'))
 {
 skip_matching ();
 SET_FLAG (last_class->flags, F_TEMPLATE);
 }
 if (!LOOKING_AT (DCOLON))
 break;
 MATCH ();
 }
 return last_class;
 }
 {
 static int id_size = 0;
 static char *id = NULL;
 char *s;
 int len;
 MATCH ();
 if (LOOKING_AT2 (NEW, DELETE))
 {
 /* `new' and `delete' are implicitly static.  */
 if (*sc != SC_FRIEND)
 *sc = SC_STATIC;
 s = token_string (LA1);
 MATCH ();
 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? */
+/* Vector new or delete?  */
 if (LOOKING_AT ('['))
 	{
 	  strcat (id, "[");
 	  MATCH ();
 	  if (LOOKING_AT (']'))
 	    {
 	      strcat (id, "]");
 	      MATCH ();
 	    }
 {
 struct sym *cls = NULL;
 char *id = NULL;
 size_t id_size = 0;
 int enter = 0;
 while (LOOKING_AT (IDENT))
 {
 int len = strlen (yytext) + 1;
 if (len > id_size)
 	{
 case ENUM:
 case TYPEDEF:
 sc = SC_TYPE;
 MATCH ();
 break;
 case STATIC:
 sc = SC_STATIC;
 MATCH ();
 break;
 if (cls)
 	    add_member_defn (cls, id, regexp, pos, 0, 1, SC_UNKNOWN, flags);
 else
 add_global_defn (id, regexp, pos, 0, 1, sc, flags);
 }
 MATCH ();
 print_info ();
 }
 else if (LOOKING_AT ('{'))
 {
 int flags = start_flags;
 for (;;)
 {
 char *prev_in = in;
 switch (LA1)
 {
 case NAMESPACE:
 {
 MATCH ();
 if (LOOKING_AT (IDENT))
 {
 char *namespace_name = xstrdup (yytext);
 MATCH ();
 if (LOOKING_AT ('='))
 {
 		    struct link *qna = match_qualified_namespace_alias ();
 		    if (qna)
 register_namespace_alias (namespace_name, qna);
 if (skip_to (';') == ';')
 MATCH ();
 }
 else if (LOOKING_AT ('{'))
 {
 if (LOOKING_AT (CSTRING) && *string_start == 'C'
 && *(string_start + 1) == '"')
 {
 /* This is `extern "C"'.  */
 MATCH ();
 if (LOOKING_AT ('{'))
 {
 MATCH ();
 globals (F_EXTERNC);
 MATCH_IF ('}');
 }
 else
 SET_FLAG (flags, F_EXTERNC);
 }
 break;
 case TEMPLATE:
 MATCH ();
 SKIP_MATCHING_IF ('<');
 SET_FLAG (flags, F_TEMPLATE);
 break;
 case YYEOF:
 return 1;
 case '}':
 return 0;
 default:
 declaration (flags);
 flags = start_flags;
 break;
 }
 {
 while (*path_list)
 {
 char *start = path_list;
 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;
 FILE *fp = NULL;
 static char *buffer;
 static int buffer_size;
 struct search_path *path;
 int flen = strlen (file) + 1;	/* +1 for the slash */
 filename = xstrdup (file);
 for (path = search_path; path && fp == NULL; path = path->next)
 {
 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);
 fp = fopen (buffer, "r");
 }
 /* Try the original file name.  */
 if (fp == NULL)
 fp = fopen (file, "r");
 if (fp == NULL)
 yyerror ("cannot open", NULL);
 return fp;
 }
 /* Display usage information and exit program.  */
 void
 process_file (file)
 char *file;
 {
 FILE *fp;
 fp = open_file (file);
 if (fp)
 {
 int nread, nbytes;
 /* Give a progress indication if needed.  */
 if (f_very_verbose)
 {
 	  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;
 	  nread += nbytes;
 	}
 	  buffer = (char *) xrealloc (buffer, buffer_size);
 	}
 buffer[i++] = c;
 }
 if (c == EOF && i == 0)
 return NULL;
 if (i == buffer_size)
 {
 buffer_size = max (100, buffer_size * 2);
 buffer = (char *) xrealloc (buffer, buffer_size);
 }
 {
 	  /* Experimental.  */
 	case 'p':
 	  info_position = atoi (optarg);
 	  break;
 case 'n':
 f_nested_classes = 0;
 break;
 case 'x':
 f_regexps = 0;
 break;
 /* 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);
 	  rc = ftell (fp);
 	  if (rc == -1)
 	    yyerror ("error getting size of file `%s'", out_filename);
 	  else if (rc == 0)
 	    yyerror ("file `%s' is empty", out_filename);
 	  fclose (fp);
 	}
 yyout = fopen (out_filename, f_append ? "a" : "w");
 if (yyout == NULL)
 	{
 	  yyerror ("cannot open output file `%s'", out_filename);
 	  exit (1);
 /* Process files from `--files=FILE'.  Every line in FILE names
 	 one input file to process.  */
 for (i = 0; i < n_input_files; ++i)
 {
 FILE *fp = fopen (input_filenames[i], "r");
 if (fp == NULL)
 yyerror ("cannot open input file `%s'", input_filenames[i]);
 else
 {
 	      char *file;

Mercurial > emacs

comparison lib-src/ebrowse.c @ 42174:e3b97ef49aee