silentbob/silentbob-1.1/src/plugins/plugin_perl.cpp

   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 <dlib.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                 if (*part2 == ' ')
  57                         ++part2;
  58
  59                 if (*stail (part2) == ' ')
  60                         *stail (part2) = '\0';
  61         }
  62
  63         while (*stail (part1) == ' ')
  64                 *stail (part1) = '\0';
  65
  66         if (part2)
  67                 fprintf (ofile, "%s:%s\t%s\t%i\n", part1, part2, tt->d_file_name, line);
  68         else
  69                 fprintf (ofile, "%s\t%s\t%i\n", part1, tt->d_file_name, line);
  70 }
  71
  72 void pl_package (struct tt_state_t *tt, int line, char * d_out, char ch)
  73 {
  74         char * S;
  75         char * ptr;
  76
  77         S = strchr (d_out, ' ');
  78         if (! S)
  79                 return;
  80
  81         ++S;
  82         while (*stail (d_out) == ' ')
  83                 *stail (d_out) = '\0';
  84
  85         ptr = strchr_r (S, ':');
  86         if (ptr) {
  87                 ++ptr;
  88                 fprintf (ofile, "%s\t%s\t%i\n", ptr, tt->d_file_name, line);
  89         }
  90         fprintf (ofile, "%s\t%s\t%i\n", S, tt->d_file_name, line);
  91 }
  92
  93 void perl_make_tag (struct tt_state_t *tt, char * d_out, char ch)
  94 {
  95         int line;
  96
  97         line = tt->d_attachment[ENV->t_op_no].pair_line+1;
  98         if (*d_out == ' ')
  99                 ++d_out;
 100
 101         if (ch == '{' && (! strncmp (d_out, "sub ", 4))) {
 102                 pl_sub (tt, line, d_out, ch);
 103                 return;
 104         }
 105
 106         if (ch == ';' && (! strncmp (d_out, "package ", 8))) {
 107                 pl_package (tt, line, d_out, ch);
 108                 return;
 109         }
 110 }
 111
 112 void pl_lookup ()
 113 {
 114         int i;
 115         DArray * d_array;
 116
 117         __perl_files (ENV->tmp_files);
 118         d_array = new DArray (32);
 119         d_array->from_file (ENV->tmp_files);
 120         d_array->foreach ((Dfunc_t)chomp);
 121
 122         for (i = 0; i < d_array->get_size (); ++i) {
 123                 if (! d_array->get (i))
 124                         continue;
 125
 126                 perl_make_ctags (d_array->get (i), ofile);
 127         }
 128
 129         unlink (ENV->tmp_files);
 130         d_array->foreach (free);
 131         delete d_array;
 132 }
 133
 134 int perl_make_ctags (char * f_name, FILE * of)
 135 {
 136         char ch;
 137         char *d_ptr,*d_out; // for t_op2
 138         int block_depth = 0;
 139         struct tt_state_t *tt;
 140
 141         ofile = of;
 142         if (f_name == NULL) {
 143                 pl_lookup ();
 144                 return 0;
 145         }
 146
 147         ENV->t_op_no = 0;
 148         PerlPackage = NULL;
 149
 150         tt = CNEW (tt_state_t, 1);
 151         bzero (tt, sizeof (struct tt_state_t));
 152         tt->d_file_name = strdup (f_name);
 153         THE_FLY::fly_for_file (tt);
 154         //write (1, tt->d_output, tt->d_output_size);
 155
 156         d_out = tt->d_output;
 157         d_ptr = d_out;
 158         while (true) {
 159                 ch = t_op2 (&d_ptr, &d_out);
 160                 ENV->t_op_no++;
 161
 162                 if (ch == '\0')
 163                         break;
 164
 165                 if (! block_depth)
 166                         perl_make_tag (tt, d_out, ch);
 167
 168                 if (ch == '{')
 169                         ++block_depth;
 170
 171                 if (ch == '}')
 172                         --block_depth;
 173
 174                 if (block_depth < 0)
 175                         block_depth = 0;
 176         }
 177
 178         free_tt_state (tt);
 179         return 0;
 180 }
 181
 182 int perl_call_tags (char * f_name)
 183 {
 184         printf ("Jay online.\n");
 185         return 0;
 186 }
 187
 188 char perl_opt (DArray * d_opts, int * i)
 189 {
 190         if (! d_opts || ! i)
 191                 return 0;
 192
 193         if (EQ (d_opts->get (*i), "--perl")) {
 194                 ENV->language = "Perl";
 195                 return 1;
 196         }
 197         return 0;
 198 }
 199
 200 void __perl_files (char * f_name)
 201 {
 202         unlink (f_name);
 203         sblib_find ("./", "*.pm", f_name);
 204         sblib_find ("./", "*.pl", f_name);
 205         sblib_find ("./", "*.ph", f_name);
 206 }
 207
 208 char perl_files_opt (DArray * d_opts, int * i)
 209 {
 210         if (! d_opts || ! i)
 211                 return 0;
 212
 213         unlink ("./perl_files");
 214         if (EQ (d_opts->get (*i), "--files") && EQ (ENV->language, "Perl")) {
 215                 __perl_files ("./perl_files");
 216                 return 1;
 217         }
 218
 219         return 0;
 220 }
 221
 222 void perl_plugin_info ()
 223 {
 224         printf ("Perl support.\n");
 225         printf ("Version: 1.0-rc1\n");
 226         printf ("options: --perl --make-ctags\n");
 227 }
 228
 229 void perl_files_info ()
 230 {
 231         printf ("Perl files.\n");
 232         printf ("Version: 1.0\n");
 233         printf ("options: --perl --files\n");
 234 }
 235
 236 DArray * perl_init ()
 237 {
 238         DArray * Ret;
 239         struct mod_feature * pm;
 240         struct mod_feature * mod_perlfiles;
 241         struct mod_language * pm_lang;
 242
 243         Ret = new DArray (2);
 244         pm = CNEW (mod_feature, 1);
 245         pm_lang = CNEW (mod_language, 1);
 246         mod_perlfiles = CNEW (mod_feature, 1);
 247
 248         bzero (pm, sizeof (mod_feature));
 249         bzero (pm_lang, sizeof (mod_language));
 250         bzero (mod_perlfiles, sizeof (mod_feature));
 251
 252         pm->mod.Type = TYPE_FEATURE;
 253         pm->mod.Version = strdup ("0.1");
 254         pm->opt = perl_opt;
 255
 256         mod_perlfiles->mod.Type = TYPE_FEATURE;
 257         mod_perlfiles->mod.Version = strdup ("1.0");
 258         mod_perlfiles->mod.info = perl_files_info;
 259         mod_perlfiles->opt = perl_files_opt;
 260
 261         pm_lang->mod.Type = TYPE_LANGUAGE;
 262         pm_lang->mod.Version = strdup ("1.0-rc1");
 263         pm_lang->mod.info = perl_plugin_info;
 264         pm_lang->language = strdup ("Perl");
 265         pm_lang->the = THE_FLY::fly_for_file;
 266         pm_lang->print_tags = perl_print_tags;
 267         pm_lang->file = perl_file;
 268         pm_lang->make_ctags = perl_make_ctags;
 269
 270         Ret->add (LPCHAR (pm));
 271         Ret->add (LPCHAR (pm_lang));
 272         Ret->add (LPCHAR (mod_perlfiles));
 273
 274         return Ret;
 275 }
 276
 277 DArray * plugin_init (struct env_t *env)
 278 {
 279         ENV = env;
 280 #if 1
 281         return perl_init ();
 282 #else
 283 //      printf ("Perl module under construction.\n");
 284         return NULL;
 285 #endif
 286 }
 287