silentbob/src/main.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <head.h>
   8 #include <wit.h>
   9 #include <the_tt.h>
  10 #include <mod.h>
  11 #include <dbg.h>
  12
  13 extern "C" struct env_t *ENV;
  14
  15 /* MAIN */
  16 int main (int argc, char ** argv)
  17 {
  18         char * opt;
  19         int n_files = 0;
  20         DArray * d_opts;
  21         int i;
  22
  23         sb_init ();
  24         ENV->sb_cmd = sb_prname (argv[0]);
  25
  26         if (argc == 1 && !ENV->sb_cmd) {
  27                 usage ();
  28                 exit (0);
  29         }
  30
  31         ENV->d_files = new EArray (128);
  32         ENV->language = "C";
  33         d_opts = new EArray (argc);
  34         ENV->d_opts = d_opts;
  35         for (i = 0; i < argc; i++)
  36                 d_opts->add (argv[i]);
  37
  38         for (i = 1; i < d_opts->get_size (); i++) {
  39                 opt = d_opts->get (i);
  40                 if (opt[0] != '-' && index (opt, '=')) {
  41                         setParam (opt);
  42                         continue;
  43                 }
  44
  45                 if (opt[0] != '-') {
  46                         ENV->d_files->add (strdup (d_opts->get (i)));
  47                         continue;
  48                 }
  49
  50                 if (! opts_funcs (d_opts, i))
  51                         continue;
  52
  53                 if (! opts_settings (d_opts, i))
  54                         continue;
  55
  56                 if (! opts_kinds (d_opts, i))
  57                         continue;
  58
  59                 if (d_opts->get (i)[0] == '-' && !validOption (d_opts->get(i))) {
  60                         fprintf (stderr, "unknown option : %s\n", d_opts->get (i));
  61                         exit (1);
  62                 }
  63
  64                 modding_optparse (&i, 1);
  65         } // for (i = 1; i < argc; i++)
  66
  67         n_files = ENV->d_files->get_size ();
  68
  69         for (i = 0; i < argc; i++)
  70                 modding_optparse (&i, 2);
  71
  72         if (NE (ENV->language, "C") && NE (ENV->language, "C++")) {
  73                 i = modding_start (ENV->sb_cmd);
  74                 exit (i);
  75         }
  76
  77         if (SB_FLGET (SB_FLCPP))
  78                 ENV->d_kinds &= OT::Class | OT::Struct | OT::Function
  79                         | OT::Namespace | OT::Define;
  80
  81         switch (ENV->sb_cmd) {
  82                 case cmd_makectags:
  83                         make_ctags (ENV->d_files);
  84                         break;
  85                 case cmd_indent:
  86                         nogui_indent ();
  87                         break;
  88                 case cmd_cgrep:
  89                         cgrep::cgrep (ENV->d_files);
  90                         break;
  91                 case cmd_call_tags:
  92                         call_tags (ENV->d_files);
  93                         goto out;
  94                 case cmd_tags:
  95                         tags (ENV->d_files, NULL);
  96                         goto out;
  97         }
  98
  99         if (ENV->sb_cmd == cmd_makectags ||
 100             ENV->sb_cmd == cmd_indent ||
 101             ENV->sb_cmd == cmd_cgrep) {
 102                 print_the_time (NULL);
 103                 exit (0);
 104         }
 105
 106         for (i = 0; i < n_files; i++) {
 107                 switch (ENV->sb_cmd) {
 108                         case cmd_file:
 109                                 flist_main (ENV->d_files->get (i));
 110                                 break;
 111                         case cmd_the_tt:
 112                                 THE_TT::the_tt_main (ENV->d_files->get(i));
 113                                 break;
 114                         case cmd_give_structs:
 115                                 got_structs (ENV->d_files->get (i));
 116                                 break;
 117                         case cmd_kinds:
 118                                 kindsFile (ENV->d_files->get(i), ENV->d_kinds);
 119                                 break;
 120                 }
 121         }
 122
 123         if (ENV->sb_cmd == cmd_file ||
 124                         ENV->sb_cmd == cmd_the_tt ||
 125                         ENV->sb_cmd == cmd_give_structs ||
 126                         ENV->sb_cmd == cmd_kinds)
 127                 goto out;
 128
 129
 130         ENV->sb_cmd = ENV->sb_cmd;
 131
 132         if (ENV->sb_cmd == cmd_the_tt && !n_files) // THE_TT for stdin
 133                 THE_TT::the_tt_main ("-");
 134         else if (ENV->sb_cmd == cmd_give_structs && !n_files) {
 135                 got_structs ("-");
 136                 print_the_time (NULL);
 137                 exit (0);
 138         }
 139
 140         if ((ENV->sb_cmd == cmd_kinds || ENV->sb_cmd == cmd_file) && !n_files) {
 141                 char d_buf[1024];
 142
 143                 while (fgets (d_buf, 1023, stdin)) {
 144                         chomp (d_buf);
 145                         switch (ENV->sb_cmd) {
 146                                 case cmd_kinds:
 147                                         kindsFile (d_buf, ENV->d_kinds);
 148                                         break;
 149                                 case cmd_file:
 150                                         flist_main (d_buf);
 151                                         break;
 152                         }
 153                 }
 154         }
 155
 156         if (!SB_FLGET (SB_FLRTREE))
 157                 call_tree (ENV->d_files->get (0), 0);
 158         else
 159                 reverse_calltree (ENV->d_files->get (0));
 160
 161 out:
 162         print_the_time (NULL);
 163
 164         if (ENV->immune_list)
 165                 delete ENV->immune_list;
 166
 167         ENV->d_files->foreach (free);
 168         delete ENV->d_files;
 169         fflush (stdout);
 170
 171         return EXIT_SUCCESS;
 172 }
 173