silentbob/sblib/the_fly.cxx

   1 /*
   2  * (c) Oleg Puchinin 2006,2007,2008
   3  * graycardinalster@gmail.com
   4  *
   5  * Oleg, "THE FLY", and BUGS.
   6  *
   7  * "THE FLY" - "THE TT" analog for Perl code.
   8  * 1 May 2006 - started.
   9  * 26/06/06 - v1.0-rc1.
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <ctype.h>
  17 #include <gclib/gclib.h>
  18 #include <mod.h>
  19 #include <head.h>
  20 #include <dbg.h>
  21 #include <the_tt.h>
  22 #include "the_fly.hpp"
  23
  24 namespace THE_FLY {
  25
  26 char * t_map;
  27 char * t_new;
  28 char pch;
  29 int i;
  30 int ii;
  31 int t_size;
  32 int spaces;
  33 int nlines;
  34 int t_op_no;
  35 pair_t * d_attachment = NULL;
  36
  37 #define T t_map[i]
  38
  39 inline void t_attach ()
  40 {
  41         t_op_no++;
  42         d_attachment[t_op_no].pair_op = t_op_no;
  43         d_attachment[t_op_no].pair_line = nlines;
  44         d_attachment[t_op_no].offset = i;
  45 }
  46
  47 inline void TN (char ch)
  48 {
  49         t_new[ii] = ch;
  50         ++ii;
  51         if ((i && t_map[i-1] != '\\') && (ch == '{' || ch == '}' || ch == ';'))
  52                 t_attach ();
  53 }
  54
  55 inline char * fly_fw (char * word)
  56 {
  57         char * Ret;
  58         char *S = word;
  59         while (true) {
  60                 if (!if_abc (S) &&
  61                                 !if_digit (S) &&
  62                                 *S != '_' &&
  63                                 *S != '*')
  64                         break;
  65                 ++S;
  66         }
  67         Ret = CNEW (char, S - word + 1);
  68         memcpy (Ret, word, S - word);
  69         Ret[S-word] = '\0';
  70         return Ret;
  71 }
  72
  73 void fly_skip ()
  74 {
  75         char * word = NULL;
  76         char * S = NULL;
  77         char * ptrn = NULL;
  78
  79         word = &t_map[i+2];
  80         if (*word == '\'' || *word == '\"')
  81                 ++word;
  82
  83         word = fly_fw (word);
  84         if (! word)
  85                 return;
  86
  87         ptrn = CNEW (char, strlen (word)+3);
  88         sprintf (ptrn, "\n%s\n", word);
  89         S = (char *) Dmemmem (&t_map[i+2], t_size-i-2, ptrn, strlen (ptrn));
  90         assert (! S, "fly_skip fail !");
  91         if (! S) {
  92                 i = t_size;
  93                 goto out;
  94         }
  95
  96         nlines += Dsyms (&t_map[i+2], S, '\n');
  97         nlines+=2;
  98         i += S - &t_map[i] + strlen (ptrn) + 1;
  99
 100 out:
 101         DROP (ptrn);
 102         DROP (word);
 103 }
 104
 105 void doc_skip ()
 106 {
 107         char *S;
 108         char * ptrn = (char *) "\n=cut\n";
 109
 110         S = (char *) Dmemmem (&t_map[i], t_size-i, ptrn, 6);
 111         if (! S) {
 112                 i = t_size;
 113                 return;
 114         }
 115
 116         nlines += Dsyms (&t_map[i], S, '\n');
 117         ++nlines;
 118         i += S - &t_map[i] + 4;
 119 }
 120
 121 void regexp_skip ()
 122 {
 123         char ss;
 124         int count;
 125         char * ptr;
 126         int old;
 127
 128         count = 1;
 129         old = i;
 130         switch (T) {
 131                 case 't':
 132                         i+=2;
 133                         break;
 134                 case 's':
 135                         ++i;
 136                         count = 2;
 137                         break;
 138                 case 'm':
 139                         ++i;
 140                         break;
 141         }
 142
 143         ss = T;
 144         if (ss == '{')
 145                 ss = '}';
 146         ++i;
 147         ptr = &t_map[i];
 148         while (true) {
 149                 for (; i < t_size; ++i) {
 150                         if (T == '\n')
 151                                 break;
 152
 153                         if (t_map[i] == ss && !(ww_nsyms_r (ptr, &t_map[i-1], '\\') % 2))
 154                                 break;
 155                 }
 156
 157                 if (T == '\n')
 158                         break;
 159
 160                 assert (i >= t_size, "Sibadi 2006.2");
 161                 if (i >= t_size)
 162                         break;
 163
 164                 if (--count == 0)
 165                         break;
 166                 ++i;
 167         }
 168
 169         if (T == '\n') {
 170                 i = old;
 171                 TN(T);
 172         }
 173 }
 174
 175 bool regexp_test ()
 176 {
 177         char * ptr;
 178         char ch = T;
 179         char ss;
 180
 181         if (isalnum (pch) || pch == '_' || pch == ')')
 182                 return false;
 183
 184         if (! (ch == '/' || ch == 's' || ch == 'm' || !strncmp (&t_map[i], "tr", 2)))
 185                 return false;
 186
 187         ptr = &t_map[i];
 188         ++ptr;
 189         switch (ch) {
 190                 case 't':
 191                         ++ptr;
 192                 case 's':
 193                 case 'm':
 194                         ss = *ptr;
 195                         if (! (ss == '/' || ss == '?' || ss == '#'
 196                                 || ss == '!' || ss == '&' || ss == '|' || ss == '{'))
 197                                 return false;
 198                         break;
 199         }
 200
 201         return true;
 202 }
 203
 204 inline void tt_skip ()
 205 {
 206         while (T != '\n' && i < t_size)
 207                 ++i;
 208         --i;
 209 }
 210
 211 int fly_for_buffers (char * d_input, int size, char * d_output)
 212 {
 213         char ch;
 214         char * S;
 215
 216         i = 0;
 217         ii = 0;
 218         t_size = size;
 219         t_map = d_input;
 220         t_new = d_output;
 221         spaces = 0;
 222         nlines = 0;
 223         pch = 'a';
 224         t_op_no = 0;
 225
 226         i = 0;
 227         if (T == '#' || T == '=') {
 228                 tt_skip ();
 229                 ++i;
 230         }
 231
 232         for (; i < size; i++) {
 233                 ch = T;
 234                 if (ch == '\n')
 235                         ++nlines;
 236
 237                 if (regexp_test ()) {
 238                         regexp_skip ();
 239                         continue;
 240                 }
 241
 242                 if (if_digit (&t_map[i]) || if_abc (&t_map[i])) {
 243                         spaces = 0;
 244                         goto abc;
 245                 }
 246
 247                 if ((ch == '\'' || ch == '\"') && t_map[i-1] != '$' && t_map[i-1] != '\\') {
 248                         if (ch == '\'' && (isalnum (t_map[i-1]) || t_map[i-1] == '&'))
 249                                 goto abc;
 250
 251                         S = sstrend (&t_map[i]);
 252                         assert (S == NULL, "\n\nSibadi 2006\n\n");
 253                         nlines += Dsyms (&t_map[i], S, '\n');
 254                         i += S - &t_map[i];
 255                         pch = ch;
 256                         TN (ch);
 257                         TN (ch);
 258                         continue;
 259                 }
 260
 261                 if (ch == '\n' || ch == ' ' || ch == '\t') {
 262                         if (spaces == 0) {
 263                                 TN (' ');
 264                                 spaces++;
 265                                 continue;
 266                         } else
 267                                 continue;
 268                 }
 269
 270                 if (ch == '<' && t_map[i+1] == '<') {
 271                         fly_skip ();
 272                         if (i >= t_size) {
 273                                 TN ('\0');
 274                                 break;
 275                         }
 276                         TN (';');
 277                         TN (' ');
 278                         spaces = 0;
 279                         pch = ch;
 280                         continue;
 281                 }
 282
 283                 if (ch == ';' || ch == '}' || ch == ')' ||
 284                                 ch == '{' || ch == '(') {
 285                         if (! spaces)
 286                                 TN (' ');
 287                         TN (ch);
 288                         TN (' ');
 289                         spaces = 1;
 290                         pch = ch;
 291                         continue;
 292                 }
 293
 294                 if (ch == '=' && t_map[i-1] == '\n') {
 295                         doc_skip ();
 296                         pch = ch;
 297                         continue;
 298                 }
 299
 300                 if (ch == '#' && t_map[i-1] != '$') {
 301                         tt_skip ();
 302                         pch = ch;
 303                         continue;
 304                 }
 305
 306 abc:
 307                 pch = ch;
 308                 TN(T);
 309         }
 310
 311         TN('\0');
 312         return ii;
 313 }
 314
 315 char * fly_for_file (struct tt_state_t * tt)
 316 {
 317         int m_size;
 318
 319         if (! tt)
 320                 return NULL;
 321
 322         if (access (tt->fileName, R_OK) != F_OK) {
 323                 fprintf (stderr, "No such file %s\n", tt->fileName);
 324                 return NULL;
 325         }
 326
 327         tt_map (tt);
 328
 329         m_size = fsize (tt->fileName);
 330         tt->result = CNEW (char, m_size << 2);
 331         tt->result[0] = 0;
 332         d_attachment = (pair_t *) CNEW (char, m_size << 2);
 333         tt->attachment = d_attachment;
 334         tt->resultSize = fly_for_buffers (tt->fileData, tt->fileDataSize, tt->result);
 335
 336         return tt->result;
 337 }
 338
 339 } // namespace THE_FLY
 340