silentbob/silent_bob/brave.cpp

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include "functions.h"
   8 #include "dbg.h"
   9
  10 char * try_name (char * ptr)
  11 {
  12         int len;
  13         char * end;
  14
  15         if (! abc_test (ptr))
  16                 return NULL;
  17
  18         while (*ptr == '*' || *ptr == '&')
  19                 ptr++;
  20
  21         len = strlen (ptr);
  22         end = &ptr[len-1];
  23
  24         while (end > ptr && (*end == '&' || *end == '*'))
  25            end--;
  26
  27         end++;
  28         *end = 0;
  29         return ptr;
  30 }
  31
  32 struct hash_t * parse_variable (char *OP)
  33 {
  34         hash_t * Ret = NULL;
  35         DArray * words;
  36         char * op;
  37         char * S;
  38         int size;
  39         char * var = NULL;
  40         char * type = NULL;
  41
  42         if (! OP)
  43           return NULL;
  44
  45         op = strdup (OP);
  46         ww_last_word (op);
  47
  48         words = Dsplit (op, " ");
  49         if (! words)
  50           goto tpv_out;
  51
  52         size = words->get_size();
  53         if (size < 2)
  54                 goto tpv_out;
  55
  56         while (size > 0) {
  57                 S = words->get (size-1);
  58
  59                 S = try_name (S);
  60                 if (! S) {
  61                         --size;
  62                         continue;
  63                 }
  64
  65                 if (var == NULL) {
  66                         var = S;
  67                 } else {
  68                         type = S;
  69                         break;
  70                 }
  71
  72                 --size;
  73         }
  74
  75         if (var && type)
  76                 Ret = hash (var, type);
  77
  78 tpv_out:
  79         if (words)
  80           words->foreach (free);
  81         DROP (words);
  82         DROP (op);
  83         return Ret;
  84 }
  85
  86 /*
  87  * RUS, KOI8-r:
  88  * äÏÐÕÓËÁÀ ÞÔÏ × ËÏÄÅ ÚÁÐÉÓÅÊ ×ÉÄÁ
  89  * function (char *S = "HELLO, FILE d = NULL") {
  90  * ÎÅ ÂÕÄÅÔ.
  91  *
  92  */
  93 int fdecl_parse (char * d_out, DArray * d_vars)
  94 {
  95         DArray * words;
  96         DArray * d;
  97         char * ptr;
  98         int i;
  99         int size;
 100         char * var;
 101         char * type;
 102         struct hash_t * one;
 103
 104         /*
 105          * 1. Arguments check.
 106          * 2. Function declaration parse.
 107          * 3. Function arguments parse.
 108          *
 109          */
 110
 111         if (d_out == NULL || d_vars == NULL)
 112                 return -1;
 113
 114         ptr = Dstrmid (d_out, "(", ")");
 115         if (ptr == 0)
 116           return -1;
 117
 118         sstrkill (ptr);
 119
 120         words = Dsplit (ptr, ",");
 121         if (! words)
 122                 return -1;
 123
 124         size = words->get_size ();
 125         if (! size)
 126                 return 0;
 127
 128         for (i = 0; i < size; i++) {
 129                 one = parse_variable (words->get (i));
 130                 if (one)
 131                         d_vars->add (LPCHAR(one));
 132         }
 133
 134         DROP (ptr);
 135         return 0;
 136 }
 137
 138 char * sstrkill (char *OP)
 139 {
 140         char *S;
 141         char *tail;
 142
 143         /*
 144          * Kill all strings. Very special function.
 145          */
 146
 147         if (! OP)
 148                 return NULL;
 149
 150         S = OP;
 151         while (*S) {
 152                 if (*S == '\"' || *S == '\'') {
 153                         tail = sstrend (S);
 154                         if (! tail)
 155                                 break;
 156
 157                         if (*tail == '\0' ||*(++tail) == '\0') {
 158                                 *S = '\0';
 159                                 break;
 160                         }
 161
 162                         strcpy (S, tail);
 163                 }
 164                 S++;
 165         }
 166
 167         return OP;
 168 }
 169