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

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8      * Redistributions of source code must retain the above copyright notice,
   9        this list of conditions and the following disclaimer.
  10      * Redistributions in binary form must reproduce the above copyright
  11        notice, this list of conditions and the following disclaimer in the
  12        documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24 *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27
  28 #include "token.h"
  29 #include "parser.h"
  30
  31 size_t psi_token_alloc_size(size_t token_len, size_t fname_len) {
  32         return sizeof(struct psi_token) + token_len + fname_len + 2;
  33 }
  34
  35 struct psi_token *psi_token_alloc(struct psi_parser *P) {
  36         struct psi_token *T;
  37         size_t token_len, fname_len;
  38         token_t token_typ;
  39
  40         if (P->cur < P->tok) {
  41                 return NULL;
  42         }
  43
  44         token_typ = P->num;
  45         token_len = P->cur - P->tok;
  46         fname_len = strlen(P->file.fn);
  47
  48         T = calloc(1, psi_token_alloc_size(token_len, fname_len));
  49         T->type = token_typ;
  50         T->size = token_len;
  51         T->text = &T->buf[0];
  52         T->file = &T->buf[token_len + 1];
  53         T->line = P->line;
  54         T->col = P->col;
  55
  56         memcpy(T->text, P->tok, token_len);
  57         memcpy(T->file, P->file.fn, fname_len);
  58
  59         return T;
  60 }
  61
  62 struct psi_token *psi_token_copy(struct psi_token *src) {
  63         size_t strct_len = psi_token_alloc_size(src->size, strlen(src->file));
  64         struct psi_token *ptr = malloc(strct_len);
  65
  66         memcpy(ptr, src, strct_len);
  67
  68         ptr->text = &ptr->buf[0];
  69         ptr->file = &ptr->buf[ptr->size + 1];
  70
  71         return ptr;
  72 }
  73
  74 struct psi_token *psi_token_cat(unsigned argc, ...) {
  75         va_list argv;
  76         unsigned i;
  77         struct psi_token *T = NULL;
  78
  79         va_start(argv, argc);
  80         for (i = 0; i < argc; ++i) {
  81                 struct psi_token *arg = va_arg(argv, struct psi_token *);
  82
  83                 if (T) {
  84                         size_t token_len = T->size, fname_len = strlen(T->file);
  85                         struct psi_token *tmp = realloc(T, psi_token_alloc_size(T->size += arg->size + 1, fname_len));
  86
  87                         if (tmp) {
  88                                 T = tmp;
  89                         } else {
  90                                 free(T);
  91                                 va_end(argv);
  92                                 return NULL;
  93                         }
  94
  95                         T->text = &T->buf[0];
  96                         T->file = &T->buf[T->size + 1];
  97                         T->buf[token_len] = ' ';
  98                         memmove(&T->buf[T->size + 1], &T->buf[token_len + 1], fname_len + 1);
  99                         memcpy(&T->buf[token_len + 1], arg->text, arg->size + 1);
 100                 } else {
 101                         T = psi_token_copy(arg);
 102                         T->type = PSI_T_NAME;
 103                 }
 104         }
 105         va_end(argv);
 106
 107         return T;
 108 }
 109
 110 struct psi_token *psi_token_append(struct psi_token *T, unsigned argc, ...) {
 111         va_list argv;
 112         unsigned i;
 113
 114         va_start(argv, argc);
 115         for (i = 0; i < argc; ++i) {
 116                 char *str = va_arg(argv, char *);
 117                 size_t str_len = strlen(str), token_len = T->size, fname_len = strlen(T->file);
 118
 119                 T = realloc(T, psi_token_alloc_size(T->size += str_len + 1, fname_len));
 120                 T->text = &T->buf[0];
 121                 T->file = &T->buf[T->size + 1];
 122                 T->buf[token_len] = ' ';
 123                 memmove(&T->buf[T->size + 1], &T->buf[token_len + 1], fname_len + 1);
 124                 memcpy(&T->buf[token_len + 1], str, str_len + 1);
 125         }
 126         va_end(argv);
 127
 128         return T;
 129 }
 130
 131 char *php_strtr(char *str, size_t len, char *str_from, char *str_to, size_t trlen);
 132 struct psi_token *psi_token_translit(struct psi_token *T, char *from, char *to) {
 133         php_strtr(T->text, T->size, from, to, MIN(strlen(from), strlen(to)));
 134         return T;
 135 }
 136
 137 static inline uint64_t psi_hash(char *digest_buf, ...)
 138 {
 139         uint64_t hash = 5381;
 140         uint8_t c;
 141         const uint8_t *ptr;
 142         va_list argv;
 143
 144         va_start(argv, digest_buf);
 145         while ((ptr = va_arg(argv, const uint8_t *))) {
 146                 while ((c = *ptr++)) {
 147                         hash = ((hash << 5) + hash) + c;
 148                 }
 149         }
 150         va_end(argv);
 151
 152         if (digest_buf) {
 153                 sprintf(digest_buf, "%" PRIx64, hash);
 154         }
 155
 156         return hash;
 157 }
 158
 159 uint64_t psi_token_hash(struct psi_token *t, char *digest_buf) {
 160         char loc_buf[48];
 161
 162         sprintf(loc_buf, "%u%u", t->line, t->col);
 163         return psi_hash(digest_buf, t->file, loc_buf, (char *) NULL);
 164 }