git.m6w6.name Git - m6w6/ext-psi/blob - src/context.c

   1 #include <sys/param.h>
   2 #include <dirent.h>
   3 #include <fnmatch.h>
   4 #include <errno.h>
   5
   6 #include "php.h"
   7 #include "php_scandir.h"
   8 #include "context.h"
   9 #include "parser.h"
  10 #include "validator.h"
  11
  12 PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error)
  13 {
  14         if (!C) {
  15                 C = malloc(sizeof(*C));
  16         }
  17         memset(C, 0, sizeof(*C));
  18
  19         C->error = error;
  20         C->ops = ops;
  21         ops->init(C);
  22
  23         return C;
  24 }
  25
  26 static int psi_select_dirent(const struct dirent *entry)
  27 {
  28 #ifndef FNM_CASEFOLD
  29 #define FNM_CASEFOLD 0
  30 #endif
  31         return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD);
  32 }
  33
  34
  35 void PSI_ContextBuild(PSI_Context *C, const char *path)
  36 {
  37         int i, n;
  38         struct dirent **entries = NULL;
  39
  40         n = php_scandir(path, &entries, psi_select_dirent, alphasort);
  41
  42         if (n < 0) {
  43                 return;
  44         } else for (i = 0; i < n; ++i) {
  45                 char psi[MAXPATHLEN];
  46                 PSI_Parser P;
  47                 PSI_Validator V;
  48
  49                 if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", path, entries[i]->d_name)) {
  50                         C->error(PSI_WARNING, "Path to PSI file too long: %s/%s",
  51                                 path, entries[i]->d_name);
  52                 }
  53                 if (!PSI_ParserInit(&P, psi, C->error, 0)) {
  54                         C->error(PSI_WARNING, "Failed to init PSI parser (%s): %s",
  55                                 psi, strerror(errno));
  56                         continue;
  57                 }
  58
  59                 while (-1 != PSI_ParserScan(&P)) {
  60                         PSI_ParserParse(&P, PSI_TokenAlloc(&P));
  61                 };
  62                 PSI_ParserParse(&P, NULL);
  63
  64                 if (!PSI_ValidatorInit(&V, &P)) {
  65                         C->error(PSI_WARNING, "Failed to init PSI validator");
  66                         break;
  67                 }
  68                 PSI_ParserDtor(&P);
  69
  70                 if (PSI_ValidatorValidate(&V)) {
  71                         zend_function_entry *closures;
  72
  73                         closures = PSI_ContextCompile(C, (PSI_Data *) &V);
  74                         if (closures && SUCCESS != zend_register_functions(NULL, closures, NULL, MODULE_PERSISTENT)) {
  75                                 C->error(PSI_WARNING, "Failed to register functions!");
  76                         }
  77                 }
  78                 PSI_ValidatorDtor(&V);
  79         }
  80         if (entries) {
  81                 for (i = 0; i < n; ++i) {
  82                         free(entries[i]);
  83                 }
  84                 free(entries);
  85         }
  86
  87 }
  88
  89 zend_function_entry *PSI_ContextCompile(PSI_Context *C, PSI_Data *D)
  90 {
  91         size_t i, count = C->count++;
  92         zend_function_entry *zfe;
  93
  94         if (D->consts) {
  95                 zend_constant zc;
  96
  97                 zc.flags = CONST_PERSISTENT|CONST_CS;
  98                 zc.module_number = EG(current_module)->module_number;
  99
 100                 for (i = 0; i < D->consts->count; ++i) {
 101                         constant *c = D->consts->list[i];
 102
 103                         zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1);
 104                         ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1));
 105
 106                         switch (c->type->type) {
 107                         case PSI_T_BOOL:
 108                                 convert_to_boolean(&zc.value);
 109                                 break;
 110                         case PSI_T_INT:
 111                                 convert_to_long(&zc.value);
 112                                 break;
 113                         case PSI_T_FLOAT:
 114                                 convert_to_double(&zc.value);
 115                                 break;
 116                         }
 117                         zend_register_constant(&zc);
 118                 }
 119         }
 120
 121         C->data = realloc(C->data, C->count * sizeof(*C->data));
 122         PSI_DataExchange(&C->data[count], D);
 123
 124         zfe = C->ops->compile(C, &C->data[count]);
 125
 126         C->closures = realloc(C->closures, C->count * sizeof(*C->closures));
 127         C->closures[count] = zfe;
 128
 129         return zfe;
 130 }
 131
 132 void PSI_ContextDtor(PSI_Context *C)
 133 {
 134         size_t i;
 135
 136         C->ops->dtor(C);
 137
 138         for (i = 0; i < C->count; ++i) {
 139                 PSI_DataDtor(&C->data[i]);
 140                 if (C->closures[i]){
 141                         free(C->closures[i]);
 142                 }
 143         }
 144         free(C->data);
 145         free(C->closures);
 146
 147         memset(C, 0, sizeof(*C));
 148 }
 149
 150 void PSI_ContextFree(PSI_Context **C)
 151 {
 152         if (*C) {
 153                 PSI_ContextDtor(*C);
 154                 free(*C);
 155                 *C = NULL;
 156         }
 157 }
 158