silentbob/silentbob-1.4.1/plugins/plugin_perl.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006.
   3  * graycardinalster@gmail.com
   4  *
   5  * 25/06/06 - Perl plugin for SilentBob.
   6  *
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <ctype.h>
  13 #include <gclib/gclib.h>
  14 #include <mod.h>
  15 #include <head.h>
  16 #include <dbg.h>
  17 #include <the_tt.h>
  18 #include <the_fly.hpp>
  19
  20 extern "C" DArray * plugin_init (struct env_t *env);
  21 void __perl_files (char * f_name);
  22 int perl_make_ctags (char * f_name, FILE * of);
  23 char t_op2 (char ** d_in, char ** d_prev);
  24
  25 struct env_t *ENV;
  26 FILE * ofile;
  27 char * PerlPackage;
  28
  29 int perl_print_tags (char * f_name)
  30 {
  31
  32         return 0;
  33 }
  34
  35 void perl_file (DArray * d_array)
  36 {
  37
  38 }
  39
  40 void pl_sub (struct tt_state_t *tt, int line, char * d_out, char ch)
  41 {
  42         char *S;
  43         char *part1, *part2;
  44
  45         S = strchr (d_out, '(');
  46         if (S)
  47                 *S = '\0';
  48
  49         part1 = strchr (d_out, ' ');
  50         ++part1;
  51         part2 = strchr (part1, ':');
  52
  53         if (part2) {
  54                 *part2 = '\0';
  55                 ++part2;
  56                 part2 = strip (part2);
  57                 strip2 (part2);
  58         }
  59
  60         strip2 (part1);
  61         if (part2)
  62                 fprintf (ofile, "%s:%s\t%s\t%i\n", part1, part2, tt->d_file_name, line);
  63         else
  64                 fprintf (ofile, "%s\t%s\t%i\n", part1, tt->d_file_name, line);
  65 }
  66
  67 void pl_package (struct tt_state_t *tt, int line, char * d_out, char ch)
  68 {
  69         char * S;
  70         char * ptr;
  71
  72         S = strchr (d_out, ' ');
  73         if (! S)
  74                 return;
  75
  76         strip2 (S);
  77
  78         ptr = rindex (S, ':');
  79         if (ptr) {
  80                 ++ptr;
  81                 fprintf (ofile, "%s\t%s\t%i\n", ptr, tt->d_file_name, line);
  82         }
  83         fprintf (ofile, "%s\t%s\t%i\n", S, tt->d_file_name, line);
  84 }
  85
  86 void perl_make_tag (struct tt_state_t *tt, char * d_out, char ch)
  87 {
  88         int line;
  89
  90         line = tt->d_attachment[ENV->t_op_no].pair_line+1;
  91         if (*d_out == ' ')
  92                 ++d_out;
  93
  94         if (ch == '{' && (! strncmp (d_out, "sub ", 4))) {
  95                 pl_sub (tt, line, d_out, ch);
  96                 return;
  97         }
  98
  99         if (ch == ';' && (! strncmp (d_out, "package ", 8))) {
 100                 pl_package (tt, line, d_out, ch);
 101                 return;
 102         }
 103 }
 104
 105 void pl_lookup ()
 106 {
 107         int i;
 108         DArray * d_array;
 109
 110         __perl_files (ENV->tmp_files);
 111         d_array = new DArray (32);
 112         d_array->from_file (ENV->tmp_files);
 113         d_array->foreach ((Dfunc_t)chomp);
 114
 115         for (i = 0; i < d_array->get_size (); ++i) {
 116                 if (! d_array->get (i))
 117                         continue;
 118
 119                 perl_make_ctags (d_array->get (i), ofile);
 120         }
 121
 122         unlink (ENV->tmp_files);
 123         d_array->foreach (free);
 124         delete d_array;
 125 }
 126
 127 int perl_make_ctags (char * f_name, FILE * of)
 128 {
 129         char ch;
 130         char *d_ptr,*d_out; // for t_op2
 131         int block_depth = 0;
 132         struct tt_state_t *tt;
 133
 134         ofile = of;
 135         if (f_name == NULL) {
 136                 pl_lookup ();
 137                 return 0;
 138         }
 139
 140         ENV->t_op_no = 0;
 141         PerlPackage = NULL;
 142
 143         tt = CNEW (tt_state_t, 1);
 144         memset (tt, 0, sizeof (struct tt_state_t));
 145         tt->d_file_name = strdup (f_name);
 146         THE_FLY::fly_for_file (tt);
 147         //write (1, tt->d_output, tt->d_output_size);
 148
 149         d_out = tt->d_output;
 150         d_ptr = d_out;
 151         while (true) {
 152                 ch = t_op2 (&d_ptr, &d_out);
 153                 ENV->t_op_no++;
 154
 155                 if (ch == '\0')
 156                         break;
 157
 158                 if (! block_depth)
 159                         perl_make_tag (tt, d_out, ch);
 160
 161                 if (ch == '{')
 162                         ++block_depth;
 163
 164                 if (ch == '}')
 165                         --block_depth;
 166
 167                 if (block_depth < 0)
 168                         block_depth = 0;
 169         }
 170
 171         free_tt_state (tt);
 172         return 0;
 173 }
 174
 175 int perl_call_tags (char * f_name)
 176 {
 177         printf ("Jay online.\n");
 178         return 0;
 179 }
 180
 181 char perl_opt (DArray * d_opts, int * i)
 182 {
 183         if (! d_opts || ! i)
 184                 return 0;
 185
 186         if (EQ (d_opts->get (*i), "--perl")) {
 187                 ENV->language = "Perl";
 188                 return 1;
 189         }
 190         return 0;
 191 }
 192
 193 void __perl_files (char * f_name)
 194 {
 195         unlink (f_name);
 196         sblib_find ("./", "*.pm", f_name);
 197         sblib_find ("./", "*.pl", f_name);
 198         sblib_find ("./", "*.ph", f_name);
 199 }
 200
 201 char perl_files_opt (DArray * d_opts, int * i)
 202 {
 203         if (! d_opts || ! i)
 204                 return 0;
 205
 206         if (EQ (d_opts->get (*i), "--files") && EQ (ENV->language, "Perl")) {
 207                 unlink ("./perl_files");
 208                 __perl_files ("./perl_files");
 209                 return 1;
 210         }
 211
 212         return 0;
 213 }
 214
 215 void perl_plugin_info ()
 216 {
 217         printf ("Perl support.\n");
 218         printf ("Version: 1.0-rc1\n");
 219         printf ("options: --perl --make-ctags\n");
 220 }
 221
 222 void perl_files_info ()
 223 {
 224         printf ("Perl files.\n");
 225         printf ("Version: 1.0\n");
 226         printf ("options: --perl --files\n");
 227 }
 228
 229 DArray * perl_init ()
 230 {
 231         DArray * Ret;
 232         struct mod_feature * pm;
 233         struct mod_feature * mod_perlfiles;
 234         struct mod_language * pm_lang;
 235
 236         Ret = new DArray (2);
 237         pm = CNEW (mod_feature, 1);
 238         pm_lang = CNEW (mod_language, 1);
 239         mod_perlfiles = CNEW (mod_feature, 1);
 240
 241         memset (pm, 0, sizeof (mod_feature));
 242         memset (pm_lang, 0, sizeof (mod_language));
 243         memset (mod_perlfiles, 0, sizeof (mod_feature));
 244
 245         pm->mod.Type = TYPE_FEATURE;
 246         pm->mod.Version = strdup ("0.1");
 247         pm->opt = perl_opt;
 248
 249         mod_perlfiles->mod.Type = TYPE_FEATURE;
 250         mod_perlfiles->mod.Version = strdup ("1.0");
 251         mod_perlfiles->mod.short_info = perl_files_info;
 252         mod_perlfiles->opt = perl_files_opt;
 253
 254         pm_lang->mod.Type = TYPE_LANGUAGE;
 255         pm_lang->mod.Version = strdup ("1.0-rc1");
 256         pm_lang->mod.short_info = perl_plugin_info;
 257         pm_lang->language = strdup ("Perl");
 258         pm_lang->the = THE_FLY::fly_for_file;
 259         pm_lang->print_tags = perl_print_tags;
 260         pm_lang->file = perl_file;
 261         pm_lang->make_ctags = perl_make_ctags;
 262
 263         Ret->add (LPCHAR (pm));
 264         Ret->add (LPCHAR (pm_lang));
 265         Ret->add (LPCHAR (mod_perlfiles));
 266
 267         return Ret;
 268 }
 269
 270 DArray * plugin_init (struct env_t *env)
 271 {
 272         ENV = env;
 273 #if 1
 274         return perl_init ();
 275 #else
 276 //      printf ("Perl module under construction.\n");
 277         return NULL;
 278 #endif
 279 }
 280