src/editor/etags.c

   1 /*
   2    Editor C-code navigation via tags.
   3    make TAGS file via command:
   4    $ find . -type f -name "*.[ch]" | etags -l c --declarations -
   5
   6    or, if etags utility not installed:
   7    $ find . -type f -name "*.[ch]" | ctags --c-kinds=+p --fields=+iaS --extra=+q -e -L-
   8
   9    Copyright (C) 2009, 2011
  10    The Free Software Foundation, Inc.
  11
  12    Written by:
  13    Ilia Maslakov <il.smind@gmail.com>, 2009
  14    Slava Zanko <slavazanko@gmail.com>, 2009
  15
  16    This file is part of the Midnight Commander.
  17
  18    The Midnight Commander is free software: you can redistribute it
  19    and/or modify it under the terms of the GNU General Public License as
  20    published by the Free Software Foundation, either version 3 of the License,
  21    or (at your option) any later version.
  22
  23    The Midnight Commander is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26    GNU General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  30  */
  31
  32 #include <config.h>
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <inttypes.h>
  37 #include <string.h>
  38 #include <ctype.h>
  39
  40 #include "lib/global.h"
  41 #include "lib/util.h"           /* canonicalize_pathname() */
  42
  43 #include "etags.h"
  44
  45 /*** global variables ****************************************************************************/
  46
  47 /*** file scope macro definitions ****************************************************************/
  48
  49 /*** file scope type declarations ****************************************************************/
  50
  51 /*** file scope variables ************************************************************************/
  52
  53 /*** file scope functions ************************************************************************/
  54 /* --------------------------------------------------------------------------------------------- */
  55
  56 static gboolean
  57 parse_define (char *buf, char **long_name, char **short_name, long *line)
  58 {
  59     /* *INDENT-OFF* */
  60     enum
  61     {
  62         in_longname,
  63         in_shortname,
  64         in_shortname_first_char,
  65         in_line, finish
  66     } def_state = in_longname;
  67     /* *INDENT-ON* */
  68
  69     static char longdef[LONG_DEF_LEN];
  70     static char shortdef[SHORT_DEF_LEN];
  71     static char linedef[LINE_DEF_LEN];
  72     int nlong = 0;
  73     int nshort = 0;
  74     int nline = 0;
  75     char c = *buf;
  76
  77     while (!(c == '\0' || c == '\n'))
  78     {
  79         switch (def_state)
  80         {
  81         case in_longname:
  82             if (c == 0x01)
  83             {
  84                 def_state = in_line;
  85             }
  86             else if (c == 0x7F)
  87             {
  88                 def_state = in_shortname;
  89             }
  90             else
  91             {
  92                 if (nlong < LONG_DEF_LEN - 1)
  93                 {
  94                     longdef[nlong++] = c;
  95                 }
  96             }
  97             break;
  98         case in_shortname_first_char:
  99             if (isdigit (c))
 100             {
 101                 nshort = 0;
 102                 buf--;
 103                 def_state = in_line;
 104             }
 105             else if (c == 0x01)
 106             {
 107                 def_state = in_line;
 108             }
 109             else
 110             {
 111                 if (nshort < SHORT_DEF_LEN - 1)
 112                 {
 113                     shortdef[nshort++] = c;
 114                     def_state = in_shortname;
 115                 }
 116             }
 117             break;
 118         case in_shortname:
 119             if (c == 0x01)
 120             {
 121                 def_state = in_line;
 122             }
 123             else if (c == '\n')
 124             {
 125                 def_state = finish;
 126             }
 127             else
 128             {
 129                 if (nshort < SHORT_DEF_LEN - 1)
 130                 {
 131                     shortdef[nshort++] = c;
 132                 }
 133             }
 134             break;
 135         case in_line:
 136             if (c == ',' || c == '\n')
 137             {
 138                 def_state = finish;
 139             }
 140             else if (isdigit (c))
 141             {
 142                 if (nline < LINE_DEF_LEN - 1)
 143                 {
 144                     linedef[nline++] = c;
 145                 }
 146             }
 147             break;
 148         case finish:
 149             longdef[nlong] = '\0';
 150             shortdef[nshort] = '\0';
 151             linedef[nline] = '\0';
 152             *long_name = longdef;
 153             *short_name = shortdef;
 154             *line = atol (linedef);
 155             return TRUE;
 156         }
 157         buf++;
 158         c = *buf;
 159     }
 160     *long_name = NULL;
 161     *short_name = NULL;
 162     *line = 0;
 163     return FALSE;
 164 }
 165
 166 /* --------------------------------------------------------------------------------------------- */
 167 /*** public functions ****************************************************************************/
 168 /* --------------------------------------------------------------------------------------------- */
 169
 170 int
 171 etags_set_definition_hash (const char *tagfile, const char *start_path,
 172                            const char *match_func, etags_hash_t * def_hash)
 173 {
 174     /* *INDENT-OFF* */
 175     enum
 176     {
 177         start,
 178         in_filename,
 179         in_define
 180     } state = start;
 181     /* *INDENT-ON* */
 182
 183     FILE *f;
 184     static char buf[BUF_LARGE];
 185
 186     char *chekedstr = NULL;
 187
 188     int num = 0;                /* returned value */
 189     int pos;
 190     char *filename = NULL;
 191
 192     if (!match_func || !tagfile)
 193         return 0;
 194
 195     /* open file with positions */
 196     f = fopen (tagfile, "r");
 197     if (f == NULL)
 198         return 0;
 199
 200     while (fgets (buf, sizeof (buf), f))
 201     {
 202         switch (state)
 203         {
 204         case start:
 205             if (buf[0] == 0x0C)
 206             {
 207                 state = in_filename;
 208             }
 209             break;
 210         case in_filename:
 211             pos = strcspn (buf, ",");
 212             g_free (filename);
 213             filename = g_malloc (pos + 2);
 214             g_strlcpy (filename, (char *) buf, pos + 1);
 215             state = in_define;
 216             break;
 217         case in_define:
 218             if (buf[0] == 0x0C)
 219             {
 220                 state = in_filename;
 221                 break;
 222             }
 223             /* check if the filename matches the define pos */
 224             chekedstr = strstr (buf, match_func);
 225             if (chekedstr)
 226             {
 227                 char *longname = NULL;
 228                 char *shortname = NULL;
 229                 long line = 0;
 230
 231                 parse_define (chekedstr, &longname, &shortname, &line);
 232                 if (num < MAX_DEFINITIONS - 1)
 233                 {
 234                     def_hash[num].filename_len = strlen (filename);
 235                     def_hash[num].fullpath =
 236                         mc_build_filename (start_path, filename, (char *) NULL);
 237
 238                     canonicalize_pathname (def_hash[num].fullpath);
 239                     def_hash[num].filename = g_strdup (filename);
 240                     if (shortname)
 241                     {
 242                         def_hash[num].short_define = g_strdup (shortname);
 243                     }
 244                     else
 245                     {
 246                         def_hash[num].short_define = g_strdup (longname);
 247                     }
 248                     def_hash[num].line = line;
 249                     num++;
 250                 }
 251             }
 252             break;
 253         }
 254     }
 255
 256     g_free (filename);
 257     fclose (f);
 258     return num;
 259 }
 260
 261 /* --------------------------------------------------------------------------------------------- */