silentbob/plugins/plugin_python.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <gclib/gclib.h>
   8 #include <mod.h>
   9 #include <head.h>
  10 #include <dbg.h>
  11 #include <the_tt.h>
  12 #include <wit.h>
  13
  14 extern "C" DArray * plugin_init (struct env_t *env);
  15 int python_ctags (char * f_name, FILE * of);
  16
  17 namespace PYTHON {
  18         char * py_tt_file (struct tt_state_t * tt);
  19         char t_op (char ** d_in, char ** d_prev);
  20 }
  21
  22 char * py_prepare (char *ptr)
  23 {
  24         char *S;
  25
  26         S = strchr (ptr, '(');
  27         if (S)
  28                 *S = '\0';
  29
  30         strip2 (ptr);
  31         S = strchr (ptr, ' ');
  32         return ++S;
  33 }
  34
  35 void python_tag (tt_state_t * tt, char *ptr, char ch, int type, FILE *of)
  36 {
  37         int line = tt->attachment[ENV->t_op_no].pair_line+1;
  38
  39         while (*ptr == ' ' || *ptr == '\t')
  40                 ++ptr;
  41
  42         if (type & OT::Class) {
  43                 if (! strncmp (ptr, "def ", 4)) {
  44                         ptr = py_prepare (ptr);
  45                         goto ttry;
  46                 }
  47         }
  48
  49         if (type & OT::Function) {
  50                 if (! strncmp (ptr, "class ", 6)) {
  51                         ptr = py_prepare (ptr);
  52                         goto ttry;
  53                 }
  54         }
  55
  56         return;
  57 ttry:
  58         fprintf (of, "%s\t%s\t%i\n", ptr, tt->fileName, line);
  59 }
  60
  61 void python_lookup ()
  62 {
  63         DArray * d_array;
  64
  65         unlink (ENV->tmp_files);
  66         sblib_find ("./", "*.py", ENV->tmp_files);
  67         d_array = ENV->d_files;
  68         d_array->from_file (ENV->tmp_files);
  69         unlink (ENV->tmp_files);
  70         d_array->foreach ((Dfunc_t)chomp);
  71 }
  72
  73 void python_ctags_foreach (FILE * of)
  74 {
  75         int i;
  76         DArray * d_array = ENV->d_files;
  77         for (i = 0; i < d_array->get_size (); ++i) {
  78                 if (! d_array->get (i))
  79                         continue;
  80
  81                 python_ctags (d_array->get (i), of);
  82                 free (d_array->get (i));
  83         }
  84 }
  85
  86 int python_ctags (char * f_name, FILE * of)
  87 {
  88         char ch;
  89         char *d_ptr,*d_out; // for t_op2
  90         struct tt_state_t *tt;
  91
  92         if (! f_name) {
  93                 python_lookup ();
  94                 python_ctags_foreach (of);
  95                 return 0;
  96         }
  97
  98         ENV->t_op_no = 0;
  99
 100         tt = CNEW (tt_state_t, 1);
 101         memset (tt, 0, sizeof (struct tt_state_t));
 102         tt->fileName = strdup (f_name);
 103         PYTHON::py_tt_file (tt);
 104
 105         d_out = tt->result;
 106         d_ptr = d_out;
 107         while (true) {
 108                 ch = PYTHON::t_op (&d_ptr, &d_out);
 109                 ++ENV->t_op_no;
 110
 111                 if (ch == '\0')
 112                         break;
 113
 114                 python_tag (tt, d_out, ch, OT::Function | OT::Class, of);
 115         }
 116
 117         free_tt_state (tt);
 118         return 0;
 119 }
 120
 121 void pyc_one (char * f_name)
 122 {
 123         char *S;
 124         char ch;
 125         char *d_ptr,*d_out; // for t_op2
 126         struct tt_state_t *tt;
 127
 128         tt = CNEW (tt_state_t, 1);
 129         memset (tt, 0, sizeof (struct tt_state_t));
 130         tt->fileName = strdup (f_name);
 131         PYTHON::py_tt_file (tt);
 132
 133         d_out = tt->result;
 134         d_ptr = d_out;
 135         while (true) {
 136                 ch = PYTHON::t_op (&d_ptr, &d_out);
 137
 138                 if (ch == '\0')
 139                         break;
 140
 141                 S = d_out;
 142                 while (*S == ' ' || *S == '\t')
 143                         ++S;
 144
 145                 if (! strncmp (S, "class ", 6))
 146                         printf ("%s\n", py_prepare (S));
 147         }
 148
 149         free_tt_state (tt);
 150 }
 151
 152 void py_class ()
 153 {
 154         int i;
 155
 156         if (! ENV->d_files->get_size ())
 157                 python_lookup ();
 158
 159         for (i = 0; i < ENV->d_files->get_size (); ++i)
 160                 pyc_one (ENV->d_files->get (i));
 161
 162         exit (0);
 163 }
 164
 165 char py_opt (DArray * d_opts, int * i)
 166 {
 167         if (! d_opts || ! i)
 168                 return 0;
 169
 170         if (EQ (d_opts->get (*i), "--python")) {
 171                 ENV->language = strdup ("Python");
 172                 return 1;
 173         }
 174
 175         if (EQ (d_opts->get (*i), "--files") && EQ (ENV->language, "Python")) {
 176                 unlink ("./python_files");
 177                 sblib_find ("./", "*.py", "./python_files");
 178                 exit (0);
 179         }
 180
 181         return 0;
 182 }
 183
 184 char py_opt2 (DArray * d_opts, int * i)
 185 {
 186         if (EQ (ENV->language, "Python") && EQ (d_opts->get (*i), "--class")) {
 187                 py_class ();
 188                 return 1;
 189         }
 190         return 0;
 191 }
 192
 193 void py_short_info ()
 194 {
 195         printf ("Python plugin.");
 196 }
 197
 198 void py_long_info ()
 199 {
 200         printf ("Python plugin.\n");
 201         printf ("Version: 1.0\n");
 202         printf ("options: --python [--files | --make-ctags | --class ]\n");
 203 }
 204
 205 DArray * plugin_init (struct env_t *env)
 206 {
 207         struct mod_t * pm;
 208         struct mod_t * pm_lang;
 209         DArray * Ret;
 210
 211         pm = CNEW (mod_t, 1);
 212         pm_lang = CNEW (mod_t, 1);
 213
 214         memset (pm, 0, sizeof (struct mod_t));
 215         memset (pm_lang, 0, sizeof (struct mod_t));
 216
 217         pm_lang->Version = strdup ("1.0");
 218         pm_lang->the = PYTHON::py_tt_file;
 219         pm_lang->make_ctags = python_ctags;
 220         pm_lang->language = strdup ("Python");
 221
 222         pm->Version = strdup ("1.0");
 223         pm->opt = py_opt;
 224         pm->opt2 = py_opt2;
 225         pm->short_info = py_short_info;
 226         pm->long_info = py_long_info;
 227
 228         ENV->listOptions->add ( "--python");
 229         ENV->listOptions->add ( "--files");
 230         ENV->listOptions->add ( "--class");
 231
 232         Ret = new DArray (2);
 233         Ret->add (LPCHAR (pm));
 234         Ret->add (LPCHAR (pm_lang));
 235
 236         return Ret;
 237 }
 238