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

   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 #ifndef PSI_TOKEN_H
  27 #define PSI_TOKEN_H
  28
  29 #include <stddef.h>
  30 #include <stdarg.h>
  31 #include <stdint.h>
  32 #include <assert.h>
  33 #include <sys/param.h>
  34
  35 static inline size_t psi_align(size_t s, size_t a) {
  36         return ((s - 1) | (a - 1)) + 1;
  37 }
  38
  39 static inline size_t psi_offset_padding(size_t diff, size_t alignment) {
  40         if (diff && diff <= psi_align(diff, alignment)) {
  41                 diff = 0;
  42         }
  43
  44         return diff;
  45 }
  46
  47 #include "parser_proc.h"
  48 #undef YYDEBUG
  49
  50 #define PSI_T_CAST                      PSI_T_EQUALS
  51 #define PSI_T_POINTER           PSI_T_ASTERISK
  52
  53 #define PSI_T_WHITESPACE        -PSI_T_NO_WHITESPACE
  54 #define PSI_T_BSLASH            -PSI_T_SLASH
  55 #define PSI_T_LONG_DOUBLE       -PSI_T_DOUBLE
  56
  57 #if SIZEOF_CHAR == SIZEOF_INT8_T
  58 # define PSI_T_INT8 PSI_T_CHAR
  59 # define PSI_T_UINT8 -PSI_T_CHAR
  60 # define ALIGNOF_INT8_T ALIGNOF_CHAR
  61 # define ALIGNOF_UINT8_T ALIGNOF_CHAR
  62 #else
  63 # error SIZEOF_CHAR != 8
  64 #endif
  65 #if SIZEOF_SHORT == SIZEOF_INT16_T
  66 # define PSI_T_INT16 PSI_T_SHORT
  67 # define PSI_T_UINT16 -PSI_T_SHORT
  68 # define ALIGNOF_INT16_T ALIGNOF_SHORT
  69 # define ALIGNOF_UINT16_T ALIGNOF_SHORT
  70 #else
  71 # error SIZEOF_SHORT != 16
  72 #endif
  73 #if SIZEOF_INT == SIZEOF_INT32_T
  74 # define PSI_T_INT32 PSI_T_INT
  75 # define PSI_T_UINT32 -PSI_T_INT
  76 # define ALIGNOF_INT32_T ALIGNOF_INT
  77 # define ALIGNOF_UINT32_T ALIGNOF_INT
  78 #elif SIZEOF_LONG == SIZEOF_INT32_T
  79 # define PSI_T_INT32 PSI_T_LONG
  80 # define PSI_T_UINT32 -PSI_T_LONG
  81 # define ALIGNOF_INT32_T ALIGNOF_LONG
  82 # define ALIGNOF_UINT32_T ALIGNOF_LONG
  83 #else
  84 # error SIZEOF_INT != 32 and SIZEOF_LONG != 32
  85 #endif
  86 #if SIZEOF_LONG == SIZEOF_INT64_T
  87 # define PSI_T_INT64 PSI_T_LONG
  88 # define PSI_T_UINT64 -PSI_T_LONG
  89 # define ALIGNOF_INT64_T ALIGNOF_LONG
  90 # define ALIGNOF_UINT64_T ALIGNOF_LONG
  91 # elif HAVE_LONG_LONG_INT && SIZEOF_LONG_LONG_INT == SIZEOF_INT64_T
  92 # define PSI_T_INT64 (PSI_T_LONG << 16)
  93 # define PSI_T_UINT64 -(PSI_T_LONG << 16)
  94 # define ALIGNOF_INT64_T ALIGNOF_LONG_LONG
  95 # define ALIGNOF_UINT64_T ALIGNOF_LONG_LONG
  96 #else
  97 # error SIZEOF_LONG != 64 and SIZEOF_LONG_LONG != 64
  98 #endif
  99
 100 typedef int token_t;
 101
 102 static inline size_t psi_t_alignment(token_t t)
 103 {
 104 #define PSI_ALIGNOF(T) case PSI_T_## T: return ALIGNOF_## T ##_T;
 105         switch (t) {
 106         PSI_ALIGNOF(INT8);
 107         PSI_ALIGNOF(UINT8);
 108         PSI_ALIGNOF(INT16);
 109         PSI_ALIGNOF(UINT16);
 110         PSI_ALIGNOF(INT32);
 111         PSI_ALIGNOF(UINT32);
 112         PSI_ALIGNOF(INT64);
 113         PSI_ALIGNOF(UINT64);
 114         case PSI_T_FLOAT:
 115                 return ALIGNOF_FLOAT;
 116         case PSI_T_DOUBLE:
 117                 return ALIGNOF_DOUBLE;
 118         case PSI_T_POINTER:
 119         case PSI_T_FUNCTION:
 120                 return ALIGNOF_VOID_P;
 121         case PSI_T_ENUM:
 122                 return ALIGNOF_INT;
 123 #ifdef HAVE_LONG_DOUBLE
 124         case PSI_T_LONG_DOUBLE:
 125                 return ALIGNOF_LONG_DOUBLE;
 126 #endif
 127         default:
 128                 assert(0);
 129         }
 130         return 0;
 131 }
 132
 133 static inline size_t psi_t_size(token_t t)
 134 {
 135 #define PSI_SIZEOF(T) case PSI_T_## T : return SIZEOF_## T ##_T;
 136         switch (t) {
 137         PSI_SIZEOF(INT8);
 138         PSI_SIZEOF(UINT8);
 139         PSI_SIZEOF(INT16);
 140         PSI_SIZEOF(UINT16);
 141         PSI_SIZEOF(INT32);
 142         PSI_SIZEOF(UINT32);
 143         PSI_SIZEOF(INT64);
 144         PSI_SIZEOF(UINT64);
 145         case PSI_T_FLOAT:
 146                 return SIZEOF_FLOAT;
 147         case PSI_T_DOUBLE:
 148                 return SIZEOF_DOUBLE;
 149         case PSI_T_VOID:
 150         case PSI_T_POINTER:
 151         case PSI_T_FUNCTION:
 152                 return SIZEOF_VOID_P;
 153         case PSI_T_ENUM:
 154                 return SIZEOF_INT;
 155 #ifdef HAVE_LONG_DOUBLE
 156         case PSI_T_LONG_DOUBLE:
 157                 return SIZEOF_LONG_DOUBLE;
 158 #endif
 159         default:
 160                 assert(!t);
 161         }
 162         return 0;
 163 }
 164
 165 static inline const char *psi_t_indent(unsigned level) {
 166         static const char indent[] =
 167                         "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
 168         return &indent[32 - MIN(32, level)];
 169 }
 170
 171 static inline const char *psi_t_indirection(unsigned pointer_level) {
 172         static const char indir[] = "********************************";
 173         return &indir[32 - MIN(32, pointer_level)];
 174 }
 175
 176 struct psi_token {
 177         token_t type;
 178         unsigned size, line, col, flags;
 179         char *text, *file;
 180         char buf[1];
 181 };
 182
 183 struct psi_parser;
 184
 185 struct psi_token *psi_token_init(token_t token_typ, const char *token_txt,
 186                 size_t token_len, unsigned col, unsigned line, const char *file);
 187 size_t psi_token_alloc_size(size_t token_len, size_t fname_len);
 188 struct psi_token *psi_token_copy(struct psi_token *src);
 189 void psi_token_copy_ctor(struct psi_token **src);
 190 struct psi_token *psi_token_cat(const char *sep, unsigned argc, ...);
 191 struct psi_token *psi_token_prepend(const char *sep, struct psi_token *T, unsigned argc, ...);
 192 struct psi_token *psi_token_append(const char *sep, struct psi_token *T, unsigned argc, ...);
 193 struct psi_token *psi_token_translit(struct psi_token *T, char *from, char *to);
 194 uint64_t psi_token_hash(struct psi_token *t, char *digest_buf);
 195 void psi_token_dump(int fd, struct psi_token *t);
 196 void psi_token_free(struct psi_token **token);
 197
 198 #endif