silentbob/silent_bob/.#tree.cpp.1.5.2.4

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include "functions.h"
   8 #include "dbg.h"
   9 #include <sys/mman.h>
  10
  11 EArray * d_calltags_file;
  12
  13 /*
  14  * "SilentBob -u" functionality.
  15  * KOI8-R, RUS:
  16  *
  17  * òÅËÕÒÓÉ×ÎÏ ÉÓËÁÔØ ÚÁÐÉÓÉ × ÆÁÊÌÅ call_tags.
  18  * æÕÎËÃÉÑ ×ÙÚÙ×ÁÅÔÓÑ ÔÅÍ, ÞÔÏ ÚÎÁÞÉÔÓÑ × ÚÁÐÉÓÉ ÐÏÓÌÅ "by".
  19  *
  20  */
  21
  22 void rctree_iter (char * f_name, int n_trip)
  23 {
  24         EArray * d_virused;
  25         char m_buf[256];
  26         char * S;
  27         int len;
  28         int i;
  29         int a;
  30
  31         n_trip ++;
  32         if (n_trip > d_depth)
  33                 return;
  34
  35         /*
  36          * 1. Find record in d_calltags_file.
  37          * 2. Find _first_ record in d_calltags_file.
  38          * 3. Parse record.
  39          * 4. Check d_virused list.
  40          * 5. If f_name not in full_list :
  41          * 5.1 Add f_name to full_list.
  42          * 5.2 New iteration.
  43          *
  44          */
  45
  46         snprintf (m_buf, 255, "%s\t", f_name);
  47         m_buf[255] = 0;
  48         len = strlen (m_buf);
  49         i = d_calltags_file->snfind_fast (m_buf);
  50         d_virused = new EArray (32);
  51
  52         do {
  53                 i--;
  54                 if (i < 0)
  55                         break;
  56                 S = d_calltags_file->get (i);
  57                 if (! S)
  58                         break;
  59         } while (! strncmp (S, m_buf, len));
  60
  61         do {
  62                 i++;
  63                 S = d_calltags_file->get (i);
  64                 if (! S || strncmp (S, m_buf, len))
  65                         break;
  66
  67                 S = strstr (S, "\tby\t");
  68                 if (S == NULL) {
  69                         fprintf (d_stream_dbg, "\tBUG (no \"by\") : %s\n",
  70                                         d_calltags_file->get (i));
  71                         continue;
  72                 }
  73
  74                 S += 4;
  75                 chomp (S);
  76
  77                 if (d_virused->sfind (S) != -1)
  78                         continue;
  79
  80                 d_virused->add (strdup (S));
  81                 for (a = 0; a < n_trip; a++)
  82                         fputc ('\t', stdout);
  83
  84                 printf ("%i %s\n", n_trip, S);
  85
  86                 if (full_list->sfind (S) == -1) {
  87                         full_list->add (strdup (S));
  88                         rctree_iter (S, n_trip);
  89                 }
  90
  91         } while (true);
  92
  93         d_virused->foreach (free);
  94         delete d_virused;
  95 }
  96
  97 void reverse_calltree (char * f_name)
  98 {
  99         assert (f_name == NULL, "Lena 2");
 100         if (! f_name)
 101                 return;
 102
 103 <<<<<<< tree.cpp
 104         tree_echo (0, f_name);
 105 =======
 106         printf ("%s\n", f_name);
 107 >>>>>>> 1.5.2.4
 108         d_calltags_file = new EArray;
 109         d_calltags_file->from_file ("./call_tags");
 110         if (d_calltags_file->get_size () == 0) {
 111                 bug_nocalltags ();
 112         }
 113
 114         rctree_iter (f_name, 0);
 115
 116         d_calltags_file->foreach (free);
 117         delete d_calltags_file;
 118         fflush (stdout);
 119 }
 120
 121 struct tt_state_t *
 122 get_onett_tag (char * f_name, char ** d_tt_buf)
 123 {
 124         DArray d_array;
 125         tt_state_t * Ret = NULL;
 126         char * S;
 127
 128         if (d_tt_buf)
 129                 *d_tt_buf = NULL;
 130
 131         d_array.add (f_name);
 132         Ret = CNEW (tt_state_t, 1);
 133
 134         unlink ("./silent_bob.tmp");
 135         tags (&d_array, "./silent_bob.tmp");
 136
 137         if (access ("./silent_bob.tmp", R_OK) != 0)
 138                 goto out_err;
 139
 140         Ret->d_file_name = "./silent_bob.tmp";
 141         S = THE_TT::do_tt_file (Ret);
 142
 143         if (S == NULL)
 144                 goto out_err;
 145
 146         if (Ret->b_mmap)
 147                 munmap (Ret->d_file_in, Ret->d_filein_size);
 148
 149         if (Ret->d_fd)
 150                 close (Ret->d_fd);
 151
 152         if (d_tt_buf)
 153                 *d_tt_buf = S;
 154
 155         return Ret;
 156
 157 out_err:
 158         DROP (Ret);
 159         return NULL;
 160 }
 161
 162 void tree_echo (int n_trip, char *S)
 163 {
 164         struct d_tag_t * tag;
 165         EArray * tags;
 166         int i, a;
 167
 168         if (! SB_FLSET (SB_FLFNAMES))
 169                 goto out_min;
 170         else {
 171                 tags = got_tag_ctags (S);
 172                 if (! tags || (tags->get_size () == 0))
 173                         goto out_min;
 174
 175                 tag = (struct d_tag_t *) tags->get (0);
 176                 if (! tag)
 177                         goto out_min;
 178
 179                 printf ("// %i // %s\t%s", n_trip, S, tag->d_file);
 180                 if (tags->get_size () > 1)
 181                         printf (" (more)");
 182                 fputc ('\n', stdout);
 183         }
 184
 185         return;
 186
 187 out_min:
 188         printf ("// %i // %s\n", n_trip, S);
 189 }
 190
 191 /*
 192  * SilentBob call-tree functionality.
 193  *
 194  * KOI8-r, RUS:
 195  * òÅËÕÒÓÉ×ÎÏ ÏÂÒÁÂÏÔÁÔØ ÆÕÎËÃÉÉ. ðÏÌÕÞÉÔØ ÆÕÎËÃÉÀ × ÆÁÊÌ ./silent_bob.tmp,
 196  * ÐÒÏÐÕÓÔÉÔØ ÞÅÒÅÚ THE_TT, ÒÁÚÂÉÔØ ÎÁ ÏÐÅÒÁÔÏÒÙ. äÌÑ ËÁÖÄÏÇÏ ÏÐÅÒÁÔÏÒÁ
 197  * ÓÌÏ×Ï + ÓËÏÂËÁ - ×ÙÚÏ×. éÓËÌÀÞÅÎÉÅ - ÏÂÙÞÎÅ óÉ ÏÐÅÒÁÔÏÒÙ.
 198  *
 199  */
 200
 201 void call_tree (char * f_name, int n_trip)
 202 {
 203         struct tt_state_t * d_tt_state;
 204         struct c_word * d_word;
 205         char * d_ptr, *d_out;
 206         EArray * d_virused;
 207         DArray * d_words;
 208         char * S;
 209         char ch;
 210         int a,i;
 211
 212         if (n_trip > d_depth)
 213                 return;
 214
 215         if (n_trip == 1) {
 216                 tree_echo (0, f_name);
 217                 if (SB_FLGET (SB_FLLINEAR) || SB_FLGET (SB_FLVERBOSE))
 218                         nogui_tagsdump (f_name, 0);
 219         }
 220
 221         d_virused = new EArray(256);
 222
 223         d_tt_state = get_onett_tag (f_name, &d_ptr);
 224         if (! d_tt_state) {
 225                 if (full_list->get_size () == 0)
 226                         bug_nosuch_tag (f_name);
 227
 228                 return;
 229         }
 230
 231         d_out = d_ptr;
 232
 233         ch = t_op (&d_ptr, &d_out);
 234         if (ch == 0)
 235                 return;
 236
 237         fault (! d_out);
 238
 239         while (true) {
 240                 ch = t_op (&d_ptr, &d_out);
 241
 242                 if (ch == 0)
 243                         break;
 244
 245                 d_words = split_to_words (d_out);
 246                 assert (d_words == NULL, "Lena 28");
 247
 248                 for (i = 0; i < d_words->get_size (); i++) {
 249                         d_word = (struct c_word *) d_words->get (i);
 250                         S = cts (d_word);
 251
 252                         if (S == NULL)
 253                                 continue;
 254
 255                         if (d_virused->sfind (S) != -1)
 256                                 continue;
 257
 258                         if (! SB_FLGET (SB_FLLINEAR)) {
 259                                 for (a = 0; a < n_trip; a++)
 260                                         fputc ('\t', stdout);
 261                         }
 262
 263                         d_virused->add (strdup (S));
 264                         tree_echo (n_trip, S);
 265
 266                         if ((SB_FLGET (SB_FLVERBOSE) || SB_FLGET (SB_FLLINEAR)) && !tree_immune (S)) {
 267                                 nogui_tagsdump (S, n_trip);
 268                         }
 269
 270                         if (full_list->sfind (S) == -1) {
 271                                 full_list->add (strdup (S));
 272                                 if (!tree_immune (S))
 273                                         call_tree (S, n_trip+1);
 274                         }
 275
 276                         DROP (d_word->S);
 277                 }
 278
 279                 d_words->foreach ((Dfunc_t) free_cword);
 280                 delete d_words;
 281         }
 282
 283         delete d_virused;
 284 }
 285