1 /***************************************************************************/ 2 /* */ 3 /* psconv.c */ 4 /* */ 5 /* Some convenience conversions (body). */ 6 /* */ 7 /* Copyright 2006, 2008, 2009, 2012-2013 by */ 8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9 /* */ 10 /* This file is part of the FreeType project, and may only be used, */ 11 /* modified, and distributed under the terms of the FreeType project */ 12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13 /* this file you indicate that you have read the license and */ 14 /* understand and accept it fully. */ 15 /* */ 16 /***************************************************************************/ 17 18 19 #include <ft2build.h> 20 #include FT_INTERNAL_POSTSCRIPT_AUX_H 21 #include FT_INTERNAL_DEBUG_H 22 23 #include "psconv.h" 24 #include "psauxerr.h" 25 26 27 /*************************************************************************/ 28 /* */ 29 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 30 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 31 /* messages during execution. */ 32 /* */ 33 #undef FT_COMPONENT 34 #define FT_COMPONENT trace_psconv 35 36 37 /* The following array is used by various functions to quickly convert */ 38 /* digits (both decimal and non-decimal) into numbers. */ 39 40 #if 'A' == 65 41 /* ASCII */ 42 43 static const FT_Char ft_char_table[128] = 44 { 45 /* 0x00 */ 46 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 48 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 49 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, 50 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 51 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, 52 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 53 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, 54 }; 55 56 /* no character >= 0x80 can represent a valid number */ 57 #define OP >= 58 59 #endif /* 'A' == 65 */ 60 61 #if 'A' == 193 62 /* EBCDIC */ 63 64 static const FT_Char ft_char_table[128] = 65 { 66 /* 0x80 */ 67 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1, 68 -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, 69 -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, 70 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 71 -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, -1, -1, -1, -1, -1, -1, 72 -1, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1, 73 -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, 74 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, 75 }; 76 77 /* no character < 0x80 can represent a valid number */ 78 #define OP < 79 80 #endif /* 'A' == 193 */ 81 82 83 FT_LOCAL_DEF( FT_Long ) 84 PS_Conv_Strtol( FT_Byte** cursor, 85 FT_Byte* limit, 86 FT_Long base ) 87 { 88 FT_Byte* p = *cursor; 89 90 FT_Long num = 0; 91 FT_Bool sign = 0; 92 FT_Bool have_overflow = 0; 93 94 FT_Long num_limit; 95 FT_Char c_limit; 96 97 98 if ( p >= limit ) 99 goto Bad; 100 101 if ( base < 2 || base > 36 ) 102 { 103 FT_TRACE4(( "!!!INVALID BASE:!!!" )); 104 return 0; 105 } 106 107 if ( *p == '-' || *p == '+' ) 108 { 109 sign = FT_BOOL( *p == '-' ); 110 111 p++; 112 if ( p == limit ) 113 goto Bad; 114 } 115 116 num_limit = 0x7FFFFFFFL / base; 117 c_limit = (FT_Char)( 0x7FFFFFFFL % base ); 118 119 for ( ; p < limit; p++ ) 120 { 121 FT_Char c; 122 123 124 if ( IS_PS_SPACE( *p ) || *p OP 0x80 ) 125 break; 126 127 c = ft_char_table[*p & 0x7f]; 128 129 if ( c < 0 || c >= base ) 130 break; 131 132 if ( num > num_limit || ( num == num_limit && c > c_limit ) ) 133 have_overflow = 1; 134 else 135 num = num * base + c; 136 } 137 138 *cursor = p; 139 140 if ( have_overflow ) 141 { 142 num = 0x7FFFFFFFL; 143 FT_TRACE4(( "!!!OVERFLOW:!!!" )); 144 } 145 146 if ( sign ) 147 num = -num; 148 149 return num; 150 151 Bad: 152 FT_TRACE4(( "!!!END OF DATA:!!!" )); 153 return 0; 154 } 155 156 157 FT_LOCAL_DEF( FT_Long ) 158 PS_Conv_ToInt( FT_Byte** cursor, 159 FT_Byte* limit ) 160 161 { 162 FT_Byte* p = *cursor; 163 FT_Byte* curp; 164 165 FT_Long num; 166 167 168 curp = p; 169 num = PS_Conv_Strtol( &p, limit, 10 ); 170 171 if ( p == curp ) 172 return 0; 173 174 if ( p < limit && *p == '#' ) 175 { 176 p++; 177 178 curp = p; 179 num = PS_Conv_Strtol( &p, limit, num ); 180 181 if ( p == curp ) 182 return 0; 183 } 184 185 *cursor = p; 186 187 return num; 188 } 189 190 191 FT_LOCAL_DEF( FT_Fixed ) 192 PS_Conv_ToFixed( FT_Byte** cursor, 193 FT_Byte* limit, 194 FT_Long power_ten ) 195 { 196 FT_Byte* p = *cursor; 197 FT_Byte* curp; 198 199 FT_Fixed integral = 0; 200 FT_Long decimal = 0; 201 FT_Long divider = 1; 202 203 FT_Bool sign = 0; 204 FT_Bool have_overflow = 0; 205 FT_Bool have_underflow = 0; 206 207 208 if ( p >= limit ) 209 goto Bad; 210 211 if ( *p == '-' || *p == '+' ) 212 { 213 sign = FT_BOOL( *p == '-' ); 214 215 p++; 216 if ( p == limit ) 217 goto Bad; 218 } 219 220 /* read the integer part */ 221 if ( *p != '.' ) 222 { 223 curp = p; 224 integral = PS_Conv_ToInt( &p, limit ); 225 226 if ( p == curp ) 227 return 0; 228 229 if ( integral > 0x7FFF ) 230 have_overflow = 1; 231 else 232 integral = (FT_Fixed)( (FT_UInt32)integral << 16 ); 233 } 234 235 /* read the decimal part */ 236 if ( p < limit && *p == '.' ) 237 { 238 p++; 239 240 for ( ; p < limit; p++ ) 241 { 242 FT_Char c; 243 244 245 if ( IS_PS_SPACE( *p ) || *p OP 0x80 ) 246 break; 247 248 c = ft_char_table[*p & 0x7f]; 249 250 if ( c < 0 || c >= 10 ) 251 break; 252 253 if ( decimal < 0xCCCCCCCL ) 254 { 255 decimal = decimal * 10 + c; 256 257 if ( !integral && power_ten > 0 ) 258 power_ten--; 259 else 260 divider *= 10; 261 } 262 } 263 } 264 265 /* read exponent, if any */ 266 if ( p + 1 < limit && ( *p == 'e' || *p == 'E' ) ) 267 { 268 FT_Long exponent; 269 270 271 p++; 272 273 curp = p; 274 exponent = PS_Conv_ToInt( &p, limit ); 275 276 if ( curp == p ) 277 return 0; 278 279 /* arbitrarily limit exponent */ 280 if ( exponent > 1000 ) 281 have_overflow = 1; 282 else if ( exponent < -1000 ) 283 have_underflow = 1; 284 else 285 power_ten += exponent; 286 } 287 288 *cursor = p; 289 290 if ( !integral && !decimal ) 291 return 0; 292 293 if ( have_overflow ) 294 goto Overflow; 295 if ( have_underflow ) 296 goto Underflow; 297 298 while ( power_ten > 0 ) 299 { 300 if ( integral >= 0xCCCCCCCL ) 301 goto Overflow; 302 integral *= 10; 303 304 if ( decimal >= 0xCCCCCCCL ) 305 { 306 if ( divider == 1 ) 307 goto Overflow; 308 divider /= 10; 309 } 310 else 311 decimal *= 10; 312 313 power_ten--; 314 } 315 316 while ( power_ten < 0 ) 317 { 318 integral /= 10; 319 if ( divider < 0xCCCCCCCL ) 320 divider *= 10; 321 else 322 decimal /= 10; 323 324 if ( !integral && !decimal ) 325 goto Underflow; 326 327 power_ten++; 328 } 329 330 if ( decimal ) 331 { 332 decimal = FT_DivFix( decimal, divider ); 333 /* it's not necessary to check this addition for overflow */ 334 /* due to the structure of the real number representation */ 335 integral += decimal; 336 } 337 338 Exit: 339 if ( sign ) 340 integral = -integral; 341 342 return integral; 343 344 Bad: 345 FT_TRACE4(( "!!!END OF DATA:!!!" )); 346 return 0; 347 348 Overflow: 349 integral = 0x7FFFFFFFL; 350 FT_TRACE4(( "!!!OVERFLOW:!!!" )); 351 goto Exit; 352 353 Underflow: 354 FT_TRACE4(( "!!!UNDERFLOW:!!!" )); 355 return 0; 356 } 357 358 359 #if 0 360 FT_LOCAL_DEF( FT_UInt ) 361 PS_Conv_StringDecode( FT_Byte** cursor, 362 FT_Byte* limit, 363 FT_Byte* buffer, 364 FT_Offset n ) 365 { 366 FT_Byte* p; 367 FT_UInt r = 0; 368 369 370 for ( p = *cursor; r < n && p < limit; p++ ) 371 { 372 FT_Byte b; 373 374 375 if ( *p != '\\' ) 376 { 377 buffer[r++] = *p; 378 379 continue; 380 } 381 382 p++; 383 384 switch ( *p ) 385 { 386 case 'n': 387 b = '\n'; 388 break; 389 case 'r': 390 b = '\r'; 391 break; 392 case 't': 393 b = '\t'; 394 break; 395 case 'b': 396 b = '\b'; 397 break; 398 case 'f': 399 b = '\f'; 400 break; 401 case '\r': 402 p++; 403 if ( *p != '\n' ) 404 { 405 b = *p; 406 407 break; 408 } 409 /* no break */ 410 case '\n': 411 continue; 412 break; 413 default: 414 if ( IS_PS_DIGIT( *p ) ) 415 { 416 b = *p - '0'; 417 418 p++; 419 420 if ( IS_PS_DIGIT( *p ) ) 421 { 422 b = b * 8 + *p - '0'; 423 424 p++; 425 426 if ( IS_PS_DIGIT( *p ) ) 427 b = b * 8 + *p - '0'; 428 else 429 { 430 buffer[r++] = b; 431 b = *p; 432 } 433 } 434 else 435 { 436 buffer[r++] = b; 437 b = *p; 438 } 439 } 440 else 441 b = *p; 442 break; 443 } 444 445 buffer[r++] = b; 446 } 447 448 *cursor = p; 449 450 return r; 451 } 452 #endif /* 0 */ 453 454 455 FT_LOCAL_DEF( FT_UInt ) 456 PS_Conv_ASCIIHexDecode( FT_Byte** cursor, 457 FT_Byte* limit, 458 FT_Byte* buffer, 459 FT_Offset n ) 460 { 461 FT_Byte* p; 462 FT_UInt r = 0; 463 FT_UInt w = 0; 464 FT_UInt pad = 0x01; 465 466 467 n *= 2; 468 469 #if 1 470 471 p = *cursor; 472 473 if ( p >= limit ) 474 return 0; 475 476 if ( n > (FT_UInt)( limit - p ) ) 477 n = (FT_UInt)( limit - p ); 478 479 /* we try to process two nibbles at a time to be as fast as possible */ 480 for ( ; r < n; r++ ) 481 { 482 FT_UInt c = p[r]; 483 484 485 if ( IS_PS_SPACE( c ) ) 486 continue; 487 488 if ( c OP 0x80 ) 489 break; 490 491 c = ft_char_table[c & 0x7F]; 492 if ( (unsigned)c >= 16 ) 493 break; 494 495 pad = ( pad << 4 ) | c; 496 if ( pad & 0x100 ) 497 { 498 buffer[w++] = (FT_Byte)pad; 499 pad = 0x01; 500 } 501 } 502 503 if ( pad != 0x01 ) 504 buffer[w++] = (FT_Byte)( pad << 4 ); 505 506 *cursor = p + r; 507 508 return w; 509 510 #else /* 0 */ 511 512 for ( r = 0; r < n; r++ ) 513 { 514 FT_Char c; 515 516 517 if ( IS_PS_SPACE( *p ) ) 518 continue; 519 520 if ( *p OP 0x80 ) 521 break; 522 523 c = ft_char_table[*p & 0x7f]; 524 525 if ( (unsigned)c >= 16 ) 526 break; 527 528 if ( r & 1 ) 529 { 530 *buffer = (FT_Byte)(*buffer + c); 531 buffer++; 532 } 533 else 534 *buffer = (FT_Byte)(c << 4); 535 536 r++; 537 } 538 539 *cursor = p; 540 541 return ( r + 1 ) / 2; 542 543 #endif /* 0 */ 544 545 } 546 547 548 FT_LOCAL_DEF( FT_UInt ) 549 PS_Conv_EexecDecode( FT_Byte** cursor, 550 FT_Byte* limit, 551 FT_Byte* buffer, 552 FT_Offset n, 553 FT_UShort* seed ) 554 { 555 FT_Byte* p; 556 FT_UInt r; 557 FT_UInt s = *seed; 558 559 560 #if 1 561 562 p = *cursor; 563 564 if ( p >= limit ) 565 return 0; 566 567 if ( n > (FT_UInt)(limit - p) ) 568 n = (FT_UInt)(limit - p); 569 570 for ( r = 0; r < n; r++ ) 571 { 572 FT_UInt val = p[r]; 573 FT_UInt b = ( val ^ ( s >> 8 ) ); 574 575 576 s = ( (val + s)*52845U + 22719 ) & 0xFFFFU; 577 buffer[r] = (FT_Byte) b; 578 } 579 580 *cursor = p + n; 581 *seed = (FT_UShort)s; 582 583 #else /* 0 */ 584 585 for ( r = 0, p = *cursor; r < n && p < limit; r++, p++ ) 586 { 587 FT_Byte b = (FT_Byte)( *p ^ ( s >> 8 ) ); 588 589 590 s = (FT_UShort)( ( *p + s ) * 52845U + 22719 ); 591 *buffer++ = b; 592 } 593 *cursor = p; 594 *seed = s; 595 596 #endif /* 0 */ 597 598 return r; 599 } 600 601 602 /* END */ 603
