Shamusworld >> Repos - architektonas/blob - fparser/fp_identifier_parser.inc

   1 /* NOTE:
   2   Do not include this file in your project. The fparser.cc file #includes
   3 this file internally and thus you don't need to do anything (other than keep
   4 this file in the same directory as fparser.cc).
   5
   6   Part of this file is generated code (by using the make_function_name_parser
   7 utility, found in the development version of this library). It's not intended
   8 to be modified by hand.
   9 */
  10
  11         unsigned nameLength = 0;
  12         const unsigned maximumNameLength = 0x80000000U-8;
  13         /*
  14         Due to the manner the identifier lengths are returned from
  15         the readOpcode() function, the maximum supported length for
  16         identifiers is 0x7FFFFFFF bytes. We minus 8 here to add some
  17         buffer, because of the multibyteness of UTF-8.
  18         Function names are limited to 0xFFFF bytes instead, but because
  19         function names that long just are not defined, the point is moot.
  20         */
  21         const unsigned char* const uptr = (const unsigned char*) input;
  22         typedef signed char schar;
  23         while(likely(nameLength < maximumNameLength))
  24         {
  25             unsigned char byte = uptr[nameLength+0];
  26             /* Handle the common case of A-Za-z first */
  27             if(byte >= 0x40)
  28             {
  29                 if(byte < 0x80) // 0x40..0x7F - most common case
  30                 {
  31                     // Valid characters in 40..7F: A-Za-z_
  32                     // Valid bitmask for 40..5F: 01111111111111111111111111100001
  33                     // Valid bitmask for 60..7F: 01111111111111111111111111100000
  34                     if(sizeof(unsigned long) == 8)
  35                     {
  36                         const unsigned n = sizeof(unsigned long)*8-32;
  37                         // ^ avoids compiler warning when not 64-bit
  38                         unsigned long masklow6bits = 1UL << (byte & 0x3F);
  39                         if(masklow6bits & ~((1UL << 0) | (0x0FUL << (0x1B  ))
  40                                           | (1UL << n) | (0x1FUL << (0x1B+n))))
  41                             { ++nameLength; continue; }
  42                     }
  43                     else
  44                     {
  45                         unsigned masklow5bits = 1 << (byte & 0x1F);
  46                         if((masklow5bits & ~(1 | (0x1F << 0x1B))) || byte == '_')
  47                             { ++nameLength; continue; }
  48                     }
  49                     break;
  50                 }
  51                 if(byte < 0xF0)
  52                 {
  53                     if(byte < 0xE0)
  54                     {
  55                         if(byte < 0xC2) break; // 0x80..0xC1
  56                         if(byte == 0xC2 && uptr[nameLength+1]==0xA0) break; // skip nbsp
  57                         // C2-DF - next common case when >= 0x40
  58                         // Valid sequence: C2-DF 80-BF
  59                         if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
  60                         nameLength += 2;
  61                         continue;
  62                     }
  63                     if(byte == 0xE0) // E0
  64                     {
  65                         // Valid sequence: E0 A0-BF 80-BF
  66                         if((unsigned char)(uptr[nameLength+1] - 0xA0) > (0xBF-0xA0)) break;
  67                     }
  68                     else
  69                     {
  70                         if(byte == 0xED) break; // ED is invalid
  71                         // Valid sequence: E1-EC 80-BF 80-BF
  72                         //            And: EE-EF 80-BF 80-BF
  73                         if(byte == 0xE2)
  74                         {
  75                             // break on various space characters
  76                             if(uptr[nameLength+1] == 0x80
  77                             && (schar(uptr[nameLength+2]) <= schar(0x8B)
  78                             || (uptr[nameLength+2] == 0xAF))) break;
  79                             if(uptr[nameLength+1] == 0x81
  80                             && uptr[nameLength+2] == 0x9F) break;
  81                         } else
  82                         if(byte == 0xE3 && uptr[nameLength+1] == 0x80
  83                         && uptr[nameLength+2] == 0x80) break; // this too
  84
  85                         if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
  86                     }
  87                     if(schar(uptr[nameLength+2]) > schar(0xBF)) break;
  88                     nameLength += 3;
  89                     continue;
  90                 }
  91                 if(byte == 0xF0) // F0
  92                 {
  93                     // Valid sequence: F0 90-BF 80-BF 80-BF
  94                     if((unsigned char)(uptr[nameLength+1] - 0x90) > (0xBF-0x90)) break;
  95                 }
  96                 else
  97                 {
  98                     if(byte > 0xF4) break; // F5-FF are invalid
  99                     if(byte == 0xF4) // F4
 100                     {
 101                         // Valid sequence: F4 80-8F
 102                         if(schar(uptr[nameLength+1]) > schar(0x8F)) break;
 103                     }
 104                     else
 105                     {
 106                         // F1-F3
 107                         // Valid sequence: F1-F3 80-BF 80-BF 80-BF
 108                         if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
 109                     }
 110                 }
 111                 if(schar(uptr[nameLength+2]) > schar(0xBF)) break;
 112                 if(schar(uptr[nameLength+3]) > schar(0xBF)) break;
 113                 nameLength += 4;
 114                 continue;
 115             }
 116             if(nameLength > 0)
 117             {
 118                 if(sizeof(unsigned long) == 8)
 119                 {
 120                     // Valid bitmask for 00..1F: 00000000000000000000000000000000
 121                     // Valid bitmask for 20..3F: 00000000000000001111111111000000
 122                     const unsigned n = sizeof(unsigned long)*8-32;
 123                     // ^ avoids compiler warning when not 64-bit
 124                     unsigned long masklow6bits = 1UL << byte;
 125                     if(masklow6bits & (((1UL << 10)-1UL) << (16+n)))
 126                         { ++nameLength; continue; }
 127                 }
 128                 else
 129                 {
 130                     if(byte >= '0' && byte <= '9')
 131                         { ++nameLength; continue; }
 132                 }
 133             }
 134             break;
 135         }
 136
 137         /* This function generated with make_function_name_parser.cc */
 138 #define lN l7 lB
 139 #define lM l2 lB
 140 #define lL l3 lB
 141 #define lK if('i'l4
 142 #define lJ uptr
 143 #define lI l5 3]={
 144 #define lH 'n'l4
 145 #define lG l6 3;}lB
 146 #define lF return
 147 #define lE 0x80000003U:3;
 148 #define lD 0x80000005U:5;
 149 #define lC std::memcmp(lJ+
 150 #define lB case
 151 #define lA switch(
 152 #define l9 <<16)|
 153 #define l8 lC 1,tmp,
 154 #define l7 lD lF 5;}
 155 #define l6 default:lF
 156 #define l5 static const char tmp[
 157 #define l4 ==lJ[
 158 #define l3 lE lF 3;
 159 #define l2 0x80000004U:4;lF 4;
 160 #define l1 .enabled()?(
 161 #define l0 lF Functions[
 162 lA
 163 nameLength){lB
 164 2:lK
 165 0]&&'f'l4
 166 1])l0
 167 cIf]l1
 168 cIf
 169 l9
 170 0x80000002U:2;lF
 171 2;lB
 172 3:lA
 173 lJ[0]){lB'a':if('b'l4
 174 1]&&'s'l4
 175 2])l0
 176 cAbs]l1
 177 cAbs
 178 l9
 179 lL'c':lA
 180 lJ[1]){lB'o':lA
 181 lJ[2]){lB's':l0
 182 cCos]l1
 183 cCos
 184 l9
 185 lE
 186 lB't':l0
 187 cCot]l1
 188 cCot
 189 l9
 190 lE
 191 lG's':if('c'l4
 192 2])l0
 193 cCsc]l1
 194 cCsc
 195 l9
 196 l3
 197 lG'e':if('x'l4
 198 1]&&'p'l4
 199 2])l0
 200 cExp]l1
 201 cExp
 202 l9
 203 lL'i':if(lH
 204 1]&&'t'l4
 205 2])l0
 206 cInt]l1
 207 cInt
 208 l9
 209 lL'l':if('o'l4
 210 1]&&'g'l4
 211 2])l0
 212 cLog]l1
 213 cLog
 214 l9
 215 lL'm':lA
 216 lJ[1]){lB'a':if('x'l4
 217 2])l0
 218 cMax]l1
 219 cMax
 220 l9
 221 lL'i':if(lH
 222 2])l0
 223 cMin]l1
 224 cMin
 225 l9
 226 l3
 227 lG'p':if('o'l4
 228 1]&&'w'l4
 229 2])l0
 230 cPow]l1
 231 cPow
 232 l9
 233 lL's':lA
 234 lJ[1]){lB'e':if('c'l4
 235 2])l0
 236 cSec]l1
 237 cSec
 238 l9
 239 lL'i':if(lH
 240 2])l0
 241 cSin]l1
 242 cSin
 243 l9
 244 l3
 245 lG't':if('a'l4
 246 1]&&lH
 247 2])l0
 248 cTan]l1
 249 cTan
 250 l9
 251 l3
 252 lG
 253 4:lA
 254 lJ[0]){lB'a':lA
 255 lJ[1]){lB'c':if('o'l4
 256 2]&&'s'l4
 257 3])l0
 258 cAcos]l1
 259 cAcos
 260 l9
 261 lM's':lK
 262 2]&&lH
 263 3])l0
 264 cAsin]l1
 265 cAsin
 266 l9
 267 lM't':if('a'l4
 268 2]&&lH
 269 3])l0
 270 cAtan]l1
 271 cAtan
 272 l9
 273 l2
 274 l6
 275 4;}
 276 lB'c':lA
 277 lJ[1]){lB'b':if('r'l4
 278 2]&&'t'l4
 279 3])l0
 280 cCbrt]l1
 281 cCbrt
 282 l9
 283 lM'e':lK
 284 2]&&'l'l4
 285 3])l0
 286 cCeil]l1
 287 cCeil
 288 l9
 289 lM'o':if('s'l4
 290 2]&&'h'l4
 291 3])l0
 292 cCosh]l1
 293 cCosh
 294 l9
 295 l2
 296 l6
 297 4;}
 298 lB'e':lA
 299 lJ[1]){lB'v':if('a'l4
 300 2]&&'l'l4
 301 3])l0
 302 cEval]l1
 303 cEval
 304 l9
 305 lM'x':if('p'l4
 306 2]&&'2'l4
 307 3])l0
 308 cExp2]l1
 309 cExp2
 310 l9
 311 l2
 312 l6
 313 4;}
 314 lB'l':{lI'o','g','2'}
 315 ;if(l8
 316 3)==0)l0
 317 cLog2]l1
 318 cLog2
 319 l9
 320 l2}
 321 lB's':lA
 322 lJ[1]){lB'i':if(lH
 323 2]&&'h'l4
 324 3])l0
 325 cSinh]l1
 326 cSinh
 327 l9
 328 lM'q':if('r'l4
 329 2]&&'t'l4
 330 3])l0
 331 cSqrt]l1
 332 cSqrt
 333 l9
 334 l2
 335 l6
 336 4;}
 337 lB't':{lI'a','n','h'}
 338 ;if(l8
 339 3)==0)l0
 340 cTanh]l1
 341 cTanh
 342 l9
 343 l2}
 344 l6
 345 4;}
 346 lB
 347 5:lA
 348 lJ[0]){lB'a':lA
 349 lJ[1]){lB'c':{lI'o','s','h'}
 350 ;if(lC
 351 2,tmp,3)==0)l0
 352 cAcosh]l1
 353 cAcosh
 354 l9
 355 lN's':{lI'i','n','h'}
 356 ;if(lC
 357 2,tmp,3)==0)l0
 358 cAsinh]l1
 359 cAsinh
 360 l9
 361 lN't':if('a'l4
 362 2]){if(lH
 363 3]){lA
 364 lJ[4]){lB'2':l0
 365 cAtan2]l1
 366 cAtan2
 367 l9
 368 lD
 369 lB'h':l0
 370 cAtanh]l1
 371 cAtanh
 372 l9
 373 lD
 374 l6
 375 5;}
 376 }
 377 lF
 378 5;}
 379 lF
 380 5;l6
 381 5;}
 382 lB'f':{l5
 383 4]={'l','o','o','r'}
 384 ;if(l8
 385 4)==0)l0
 386 cFloor]l1
 387 cFloor
 388 l9
 389 lN'h':{l5
 390 4]={'y','p','o','t'}
 391 ;if(l8
 392 4)==0)l0
 393 cHypot]l1
 394 cHypot
 395 l9
 396 lN'l':{l5
 397 4]={'o','g','1','0'}
 398 ;if(l8
 399 4)==0)l0
 400 cLog10]l1
 401 cLog10
 402 l9
 403 lN't':{l5
 404 4]={'r','u','n','c'}
 405 ;if(l8
 406 4)==0)l0
 407 cTrunc]l1
 408 cTrunc
 409 l9
 410 l7
 411 l6
 412 5;}
 413 default:break;}
 414 lF
 415 nameLength;