silentbob/silent_bob/.#tree.cpp.1.5.2.5

   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                 tree_echo (n_trip, S);
  85 //              printf ("%i %s\n", n_trip, S);
  86
  87                 if (full_list->sfind (S) == -1) {
  88                         full_list->add (strdup (S));
  89                         rctree_iter (S, n_trip);
  90                 }
  91
  92         } while (true);
  93
  94         d_virused->foreach (free);
  95         delete d_virused;
  96 }
  97
  98 void reverse_calltree (char * f_name)
  99 {
 100         assert (f_name == NULL, "Lena 2");
 101         if (! f_name)
 102                 return;
 103
 104         tree_echo (0, f_name);
 105         d_calltags_file = new EArray;
 106         d_calltags_file->from_file ("./call_tags");
 107         if (d_calltags_file->get_size () == 0) {
 108                 bug_nocalltags ();
 109         }
 110
 111         rctree_iter (f_name, 0);
 112
 113         d_calltags_file->foreach (free);
 114         delete d_calltags_file;
 115         fflush (stdout);
 116 }
 117
 118 void tree_echo (int n_trip, char *S)
 119 {
 120         struct d_tag_t * tag;
 121         EArray * tags;
 122         int i, a;
 123
 124         if (! SB_FLGET (SB_FLFNAMES))
 125                 goto out_min;
 126         else {
 127                 tags = got_tag_ctags (S);
 128                 if (! tags || (tags->get_size () == 0))
 129                         goto out_min;
 130
 131                 tag = (struct d_tag_t *) tags->get (0);
 132                 if (! tag)
 133                         goto out_min;
 134
 135                 printf ("// %i // %s\t%s", n_trip, S, tag->d_file);
 136                 if (tags->get_size () > 1)
 137                         printf (" (more)");
 138                 fputc ('\n', stdout);
 139         }
 140
 141         return;
 142
 143 out_min:
 144         printf ("// %i // %s\n", n_trip, S);
 145 }
 146
 147 /*
 148  * SilentBob call-tree functionality.
 149  *
 150  * KOI8-r, RUS:
 151  * òÅËÕÒÓÉ×ÎÏ ÏÂÒÁÂÏÔÁÔØ ÆÕÎËÃÉÉ. ðÏÌÕÞÉÔØ ÆÕÎËÃÉÀ × ÆÁÊÌ ./silent_bob.tmp,
 152  * ÐÒÏÐÕÓÔÉÔØ ÞÅÒÅÚ THE_TT, ÒÁÚÂÉÔØ ÎÁ ÏÐÅÒÁÔÏÒÙ. äÌÑ ËÁÖÄÏÇÏ ÏÐÅÒÁÔÏÒÁ
 153  * ÓÌÏ×Ï + ÓËÏÂËÁ - ×ÙÚÏ×. éÓËÌÀÞÅÎÉÅ - ÏÂÙÞÎÅ óÉ ÏÐÅÒÁÔÏÒÙ.
 154  *
 155  */
 156
 157 void call_tree (char * f_name, int n_trip)
 158 {
 159         struct tt_state_t * d_tt_state;
 160         struct c_word * d_word;
 161         char * d_ptr, *d_out;
 162         EArray * d_virused;
 163         DArray * d_words;
 164         char * S;
 165         char ch;
 166         int a,i;
 167
 168         if (n_trip > d_depth)
 169                 return;
 170
 171         if (n_trip == 1) {
 172                 tree_echo (0, f_name);
 173                 if (SB_FLGET (SB_FLLINEAR) || SB_FLGET (SB_FLVERBOSE))
 174                         nogui_tagsdump (f_name, 0);
 175         }
 176
 177         d_virused = new EArray(256);
 178
 179         d_tt_state = get_onett_tag (f_name, &d_ptr);
 180         if (! d_tt_state) {
 181                 if (full_list->get_size () == 0)
 182                         bug_nosuch_tag (f_name);
 183
 184                 return;
 185         }
 186
 187         d_out = d_ptr;
 188
 189         ch = t_op (&d_ptr, &d_out);
 190         if (ch == 0)
 191                 return;
 192
 193         fault (! d_out);
 194
 195         while (true) {
 196                 ch = t_op (&d_ptr, &d_out);
 197
 198                 if (ch == 0)
 199                         break;
 200
 201                 d_words = split_to_words (d_out);
 202                 assert (d_words == NULL, "Lena 28");
 203
 204                 for (i = 0; i < d_words->get_size (); i++) {
 205                         d_word = (struct c_word *) d_words->get (i);
 206                         S = cts (d_word);
 207
 208                         if (S == NULL)
 209                                 continue;
 210
 211                         if (d_virused->sfind (S) != -1)
 212                                 continue;
 213
 214                         if (! SB_FLGET (SB_FLLINEAR)) {
 215                                 for (a = 0; a < n_trip; a++)
 216                                         fputc ('\t', stdout);
 217                         }
 218
 219                         d_virused->add (strdup (S));
 220                         tree_echo (n_trip, S);
 221
 222                         if ((SB_FLGET (SB_FLVERBOSE) || SB_FLGET (SB_FLLINEAR)) && !tree_immune (S)) {
 223                                 nogui_tagsdump (S, n_trip);
 224                         }
 225
 226                         if (full_list->sfind (S) == -1) {
 227                                 full_list->add (strdup (S));
 228                                 if (!tree_immune (S))
 229                                         call_tree (S, n_trip+1);
 230                         }
 231
 232                         DROP (d_word->S);
 233                 }
 234
 235                 d_words->foreach ((Dfunc_t) free_cword);
 236                 delete d_words;
 237         }
 238
 239         delete d_virused;
 240 }
 241