ReactOS 0.4.16-dev-297-gc569aee
cffparse.h File Reference
#include <ft2build.h>
Include dependency graph for cffparse.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  CFF_ParserRec_
 
struct  CFF_Field_Handler_
 

Macros

#define CFF_MAX_STACK_DEPTH   96
 
#define CFF2_MAX_STACK   513
 
#define CFF2_DEFAULT_STACK   513
 
#define CFF_CODE_TOPDICT   0x1000
 
#define CFF_CODE_PRIVATE   0x2000
 
#define CFF2_CODE_TOPDICT   0x3000
 
#define CFF2_CODE_FONTDICT   0x4000
 
#define CFF2_CODE_PRIVATE   0x5000
 

Typedefs

typedef struct CFF_ParserRec_ CFF_ParserRec
 
typedef struct CFF_ParserRec_CFF_Parser
 
typedef FT_Error(* CFF_Field_Reader) (CFF_Parser parser)
 
typedef struct CFF_Field_Handler_ CFF_Field_Handler
 

Enumerations

enum  {
  cff_kind_none = 0 , cff_kind_num , cff_kind_fixed , cff_kind_fixed_thousand ,
  cff_kind_string , cff_kind_bool , cff_kind_delta , cff_kind_callback ,
  cff_kind_blend , cff_kind_max
}
 

Functions

 cff_parse_num (CFF_Parser parser, FT_Byte **d)
 
 cff_parser_init (CFF_Parser parser, FT_UInt code, void *object, FT_Library library, FT_UInt stackSize, FT_UShort num_designs, FT_UShort num_axes)
 
 cff_parser_done (CFF_Parser parser)
 
 cff_parser_run (CFF_Parser parser, FT_Byte *start, FT_Byte *limit)
 

Macro Definition Documentation

◆ CFF2_CODE_FONTDICT

#define CFF2_CODE_FONTDICT   0x4000

Definition at line 48 of file cffparse.h.

◆ CFF2_CODE_PRIVATE

#define CFF2_CODE_PRIVATE   0x5000

Definition at line 49 of file cffparse.h.

◆ CFF2_CODE_TOPDICT

#define CFF2_CODE_TOPDICT   0x3000

Definition at line 47 of file cffparse.h.

◆ CFF2_DEFAULT_STACK

#define CFF2_DEFAULT_STACK   513

Definition at line 43 of file cffparse.h.

◆ CFF2_MAX_STACK

#define CFF2_MAX_STACK   513

Definition at line 42 of file cffparse.h.

◆ CFF_CODE_PRIVATE

#define CFF_CODE_PRIVATE   0x2000

Definition at line 46 of file cffparse.h.

◆ CFF_CODE_TOPDICT

#define CFF_CODE_TOPDICT   0x1000

Definition at line 45 of file cffparse.h.

◆ CFF_MAX_STACK_DEPTH

#define CFF_MAX_STACK_DEPTH   96

Definition at line 33 of file cffparse.h.

Typedef Documentation

◆ CFF_Field_Handler

◆ CFF_Field_Reader

typedef FT_Error(* CFF_Field_Reader) (CFF_Parser parser)

Definition at line 111 of file cffparse.h.

◆ CFF_Parser

◆ CFF_ParserRec

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
cff_kind_none 
cff_kind_num 
cff_kind_fixed 
cff_kind_fixed_thousand 
cff_kind_string 
cff_kind_bool 
cff_kind_delta 
cff_kind_callback 
cff_kind_blend 
cff_kind_max 

Definition at line 94 of file cffparse.h.

95 {
96 cff_kind_none = 0,
105
106 cff_kind_max /* do not remove */
107 };
@ cff_kind_callback
Definition: cffparse.h:103
@ cff_kind_bool
Definition: cffparse.h:101
@ cff_kind_fixed_thousand
Definition: cffparse.h:99
@ cff_kind_fixed
Definition: cffparse.h:98
@ cff_kind_max
Definition: cffparse.h:106
@ cff_kind_delta
Definition: cffparse.h:102
@ cff_kind_blend
Definition: cffparse.h:104
@ cff_kind_none
Definition: cffparse.h:96
@ cff_kind_string
Definition: cffparse.h:100
@ cff_kind_num
Definition: cffparse.h:97

Function Documentation

◆ cff_parse_num()

cff_parse_num ( CFF_Parser  parser,
FT_Byte **  d 
)

Definition at line 454 of file cffparse.c.

456 {
457 if ( **d == 30 )
458 {
459 /* binary-coded decimal is truncated to integer */
460 return cff_parse_real( *d, parser->limit, 0, NULL ) >> 16;
461 }
462
463 else if ( **d == 255 )
464 {
465 /* 16.16 fixed point is used internally for CFF2 blend results. */
466 /* Since these are trusted values, a limit check is not needed. */
467
468 /* After the 255, 4 bytes give the number. */
469 /* The blend value is converted to integer, with rounding; */
470 /* due to the right-shift we don't need the lowest byte. */
471#if 0
472 return (FT_Short)(
473 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 24 ) |
474 ( (FT_UInt32)*( d[0] + 2 ) << 16 ) |
475 ( (FT_UInt32)*( d[0] + 3 ) << 8 ) |
476 (FT_UInt32)*( d[0] + 4 ) ) + 0x8000U ) >> 16 );
477#else
478 return (FT_Short)(
479 ( ( ( (FT_UInt32)*( d[0] + 1 ) << 16 ) |
480 ( (FT_UInt32)*( d[0] + 2 ) << 8 ) |
481 (FT_UInt32)*( d[0] + 3 ) ) + 0x80U ) >> 8 );
482#endif
483 }
484
485 else
486 return cff_parse_integer( *d, parser->limit );
487 }
static FT_Long cff_parse_integer(FT_Byte *start, FT_Byte *limit)
Definition: cffparse.c:92
static FT_Fixed cff_parse_real(FT_Byte *start, FT_Byte *limit, FT_Long power_ten, FT_Long *scaling)
Definition: cffparse.c:179
#define NULL
Definition: types.h:112
signed short FT_Short
Definition: fttypes.h:198
#define d
Definition: ke_i.h:81
Definition: import.c:81

Referenced by cff_blend_doBlend(), cff_parse_blend(), cff_parse_cid_ros(), cff_parse_maxstack(), cff_parse_multiple_master(), cff_parse_private_dict(), cff_parse_vsindex(), and cff_parser_run().

◆ cff_parser_done()

cff_parser_done ( CFF_Parser  parser)

Definition at line 81 of file cffparse.c.

82 {
83 FT_Memory memory = parser->library->memory; /* for FT_FREE */
84
85
87 }
#define FT_FREE(ptr)
Definition: ftmemory.h:329
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
static char memory[1024 *256]
Definition: process.c:116
enum parser_state stack[4]
Definition: inffile.c:91

Referenced by cff_load_private_dict(), and cff_subfont_load().

◆ cff_parser_init()

cff_parser_init ( CFF_Parser  parser,
FT_UInt  code,
void object,
FT_Library  library,
FT_UInt  stackSize,
FT_UShort  num_designs,
FT_UShort  num_axes 
)

Definition at line 42 of file cffparse.c.

49 {
50 FT_Memory memory = library->memory; /* for FT_NEW_ARRAY */
51 FT_Error error; /* for FT_NEW_ARRAY */
52
53
54 FT_ZERO( parser );
55
56#if 0
57 parser->top = parser->stack;
58#endif
59 parser->object_code = code;
60 parser->object = object;
61 parser->library = library;
62 parser->num_designs = num_designs;
63 parser->num_axes = num_axes;
64
65 /* allocate the stack buffer */
66 if ( FT_NEW_ARRAY( parser->stack, stackSize ) )
67 {
69 goto Exit;
70 }
71
72 parser->stackSize = stackSize;
73 parser->top = parser->stack; /* empty stack */
74
75 Exit:
76 return error;
77 }
FT_Library library
Definition: cffdrivr.c:654
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:333
#define FT_ZERO(p)
Definition: ftmemory.h:237
int FT_Error
Definition: fttypes.h:300
#define error(str)
Definition: mkdosfs.c:1605
static void Exit(void)
Definition: sock.c:1330
FT_Memory memory
Definition: ftobjs.h:918
Definition: inflate.c:139

Referenced by cff_load_private_dict(), and cff_subfont_load().

◆ cff_parser_run()

cff_parser_run ( CFF_Parser  parser,
FT_Byte start,
FT_Byte limit 
)

Definition at line 1300 of file cffparse.c.

1303 {
1304#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1305 PSAux_Service psaux;
1306#endif
1307
1308 FT_Byte* p = start;
1310 FT_Library library = parser->library;
1311
1312 FT_UNUSED( library );
1313
1314
1315 parser->top = parser->stack;
1316 parser->start = start;
1317 parser->limit = limit;
1318 parser->cursor = start;
1319
1320 while ( p < limit )
1321 {
1322 FT_UInt v = *p;
1323
1324 /* Opcode 31 is legacy MM T2 operator, not a number. */
1325 /* Opcode 255 is reserved and should not appear in fonts; */
1326 /* it is used internally for CFF2 blends. */
1327 if ( v >= 27 && v != 31 && v != 255 )
1328 {
1329 /* it's a number; we will push its position on the stack */
1330 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1331 goto Stack_Overflow;
1332
1333 *parser->top++ = p;
1334
1335 /* now, skip it */
1336 if ( v == 30 )
1337 {
1338 /* skip real number */
1339 p++;
1340 for (;;)
1341 {
1342 /* An unterminated floating point number at the */
1343 /* end of a dictionary is invalid but harmless. */
1344 if ( p >= limit )
1345 goto Exit;
1346 v = p[0] >> 4;
1347 if ( v == 15 )
1348 break;
1349 v = p[0] & 0xF;
1350 if ( v == 15 )
1351 break;
1352 p++;
1353 }
1354 }
1355 else if ( v == 28 )
1356 p += 2;
1357 else if ( v == 29 )
1358 p += 4;
1359 else if ( v > 246 )
1360 p += 1;
1361 }
1362#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
1363 else if ( v == 31 )
1364 {
1365 /* a Type 2 charstring */
1366
1367 CFF_Decoder decoder;
1368 CFF_FontRec cff_rec;
1369 FT_Byte* charstring_base;
1370 FT_ULong charstring_len;
1371
1372 FT_Fixed* stack;
1373 FT_Byte* q;
1374
1375
1376 charstring_base = ++p;
1377
1378 /* search `endchar' operator */
1379 for (;;)
1380 {
1381 if ( p >= limit )
1382 goto Exit;
1383 if ( *p == 14 )
1384 break;
1385 p++;
1386 }
1387
1388 charstring_len = (FT_ULong)( p - charstring_base ) + 1;
1389
1390 /* construct CFF_Decoder object */
1391 FT_ZERO( &decoder );
1392 FT_ZERO( &cff_rec );
1393
1394 cff_rec.top_font.font_dict.num_designs = parser->num_designs;
1395 cff_rec.top_font.font_dict.num_axes = parser->num_axes;
1396 decoder.cff = &cff_rec;
1397
1398 psaux = (PSAux_Service)FT_Get_Module_Interface( library, "psaux" );
1399 if ( !psaux )
1400 {
1401 FT_ERROR(( "cff_parser_run: cannot access `psaux' module\n" ));
1402 error = FT_THROW( Missing_Module );
1403 goto Exit;
1404 }
1405
1406 error = psaux->cff_decoder_funcs->parse_charstrings_old(
1407 &decoder, charstring_base, charstring_len, 1 );
1408
1409 /* Now copy the stack data in the temporary decoder object, */
1410 /* converting it back to charstring number representations */
1411 /* (this is ugly, I know). */
1412 /* */
1413 /* We overwrite the original top DICT charstring under the */
1414 /* assumption that the charstring representation of the result */
1415 /* of `cff_decoder_parse_charstrings' is shorter, which should */
1416 /* be always true. */
1417
1418 q = charstring_base - 1;
1419 stack = decoder.stack;
1420
1421 while ( stack < decoder.top )
1422 {
1423 FT_ULong num;
1424 FT_Bool neg;
1425
1426
1427 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1428 goto Stack_Overflow;
1429
1430 *parser->top++ = q;
1431
1432 if ( *stack < 0 )
1433 {
1434 num = (FT_ULong)-*stack;
1435 neg = 1;
1436 }
1437 else
1438 {
1439 num = (FT_ULong)*stack;
1440 neg = 0;
1441 }
1442
1443 if ( num & 0xFFFFU )
1444 {
1445 if ( neg )
1446 num = (FT_ULong)-num;
1447
1448 *q++ = 255;
1449 *q++ = ( num & 0xFF000000U ) >> 24;
1450 *q++ = ( num & 0x00FF0000U ) >> 16;
1451 *q++ = ( num & 0x0000FF00U ) >> 8;
1452 *q++ = num & 0x000000FFU;
1453 }
1454 else
1455 {
1456 num >>= 16;
1457
1458 if ( neg )
1459 {
1460 if ( num <= 107 )
1461 *q++ = (FT_Byte)( 139 - num );
1462 else if ( num <= 1131 )
1463 {
1464 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 );
1465 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1466 }
1467 else
1468 {
1469 num = (FT_ULong)-num;
1470
1471 *q++ = 28;
1472 *q++ = (FT_Byte)( num >> 8 );
1473 *q++ = (FT_Byte)( num & 0xFF );
1474 }
1475 }
1476 else
1477 {
1478 if ( num <= 107 )
1479 *q++ = (FT_Byte)( num + 139 );
1480 else if ( num <= 1131 )
1481 {
1482 *q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
1483 *q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
1484 }
1485 else
1486 {
1487 *q++ = 28;
1488 *q++ = (FT_Byte)( num >> 8 );
1489 *q++ = (FT_Byte)( num & 0xFF );
1490 }
1491 }
1492 }
1493
1494 stack++;
1495 }
1496 }
1497#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
1498 else
1499 {
1500 /* This is not a number, hence it's an operator. Compute its code */
1501 /* and look for it in our current list. */
1502
1503 FT_UInt code;
1504 FT_UInt num_args;
1505 const CFF_Field_Handler* field;
1506
1507
1508 if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
1509 goto Stack_Overflow;
1510
1511 num_args = (FT_UInt)( parser->top - parser->stack );
1512 *parser->top = p;
1513 code = v;
1514
1515 if ( v == 12 )
1516 {
1517 /* two byte operator */
1518 p++;
1519 if ( p >= limit )
1520 goto Syntax_Error;
1521
1522 code = 0x100 | p[0];
1523 }
1524 code = code | parser->object_code;
1525
1526 for ( field = CFF_FIELD_HANDLERS_GET; field->kind; field++ )
1527 {
1528 if ( field->code == (FT_Int)code )
1529 {
1530 /* we found our field's handler; read it */
1531 FT_Long val;
1532 FT_Byte* q = (FT_Byte*)parser->object + field->offset;
1533
1534
1536 FT_TRACE4(( " %s", field->id ));
1537#endif
1538
1539 /* check that we have enough arguments -- except for */
1540 /* delta encoded arrays, which can be empty */
1541 if ( field->kind != cff_kind_delta && num_args < 1 )
1542 goto Stack_Underflow;
1543
1544 switch ( field->kind )
1545 {
1546 case cff_kind_bool:
1547 case cff_kind_string:
1548 case cff_kind_num:
1550 goto Store_Number;
1551
1552 case cff_kind_fixed:
1554 goto Store_Number;
1555
1558
1559 Store_Number:
1560 switch ( field->size )
1561 {
1562 case (8 / FT_CHAR_BIT):
1563 *(FT_Byte*)q = (FT_Byte)val;
1564 break;
1565
1566 case (16 / FT_CHAR_BIT):
1567 *(FT_Short*)q = (FT_Short)val;
1568 break;
1569
1570 case (32 / FT_CHAR_BIT):
1571 *(FT_Int32*)q = (FT_Int)val;
1572 break;
1573
1574 default: /* for 64-bit systems */
1575 *(FT_Long*)q = val;
1576 }
1577
1578#ifdef FT_DEBUG_LEVEL_TRACE
1579 switch ( field->kind )
1580 {
1581 case cff_kind_bool:
1582 FT_TRACE4(( " %s\n", val ? "true" : "false" ));
1583 break;
1584
1585 case cff_kind_string:
1586 FT_TRACE4(( " %ld (SID)\n", val ));
1587 break;
1588
1589 case cff_kind_num:
1590 FT_TRACE4(( " %ld\n", val ));
1591 break;
1592
1593 case cff_kind_fixed:
1594 FT_TRACE4(( " %f\n", (double)val / 65536 ));
1595 break;
1596
1598 FT_TRACE4(( " %f\n", (double)val / 65536 / 1000 ));
1599
1600 default:
1601 ; /* never reached */
1602 }
1603#endif
1604
1605 break;
1606
1607 case cff_kind_delta:
1608 {
1609 FT_Byte* qcount = (FT_Byte*)parser->object +
1610 field->count_offset;
1611
1612 FT_Byte** data = parser->stack;
1613
1614
1615 if ( num_args > field->array_max )
1616 num_args = field->array_max;
1617
1618 FT_TRACE4(( " [" ));
1619
1620 /* store count */
1621 *qcount = (FT_Byte)num_args;
1622
1623 val = 0;
1624 while ( num_args > 0 )
1625 {
1627 switch ( field->size )
1628 {
1629 case (8 / FT_CHAR_BIT):
1630 *(FT_Byte*)q = (FT_Byte)val;
1631 break;
1632
1633 case (16 / FT_CHAR_BIT):
1634 *(FT_Short*)q = (FT_Short)val;
1635 break;
1636
1637 case (32 / FT_CHAR_BIT):
1638 *(FT_Int32*)q = (FT_Int)val;
1639 break;
1640
1641 default: /* for 64-bit systems */
1642 *(FT_Long*)q = val;
1643 }
1644
1645 FT_TRACE4(( " %ld", val ));
1646
1647 q += field->size;
1648 num_args--;
1649 }
1650
1651 FT_TRACE4(( "]\n" ));
1652 }
1653 break;
1654
1655 default: /* callback or blend */
1656 error = field->reader( parser );
1657 if ( error )
1658 goto Exit;
1659 }
1660 goto Found;
1661 }
1662 }
1663
1664 /* this is an unknown operator, or it is unsupported; */
1665 /* we will ignore it for now. */
1666
1667 Found:
1668 /* clear stack */
1669 /* TODO: could clear blend stack here, */
1670 /* but we don't have access to subFont */
1671 if ( field->kind != cff_kind_blend )
1672 parser->top = parser->stack;
1673 }
1674 p++;
1675 }
1676
1677 Exit:
1678 return error;
1679
1680 Stack_Overflow:
1681 error = FT_THROW( Invalid_Argument );
1682 goto Exit;
1683
1684 Stack_Underflow:
1685 error = FT_THROW( Invalid_Argument );
1686 goto Exit;
1687
1688 Syntax_Error:
1689 error = FT_THROW( Invalid_Argument );
1690 goto Exit;
1691 }
return Found
Definition: dirsup.c:1270
static FT_Fixed cff_parse_fixed(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:536
cff_parse_num(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:454
static FT_Fixed cff_parse_fixed_scaled(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:546
#define CFF_FIELD_HANDLERS_GET
Definition: cffpic.h:39
#define FT_DEBUG_LEVEL_TRACE
Definition: ftoption.h:397
return FT_Err_Ok
Definition: ftbbox.c:511
#define ADD_LONG(a, b)
Definition: ftcalc.h:420
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
#define FT_CHAR_BIT
Definition: ftconfig.h:70
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:4865
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
signed long FT_Fixed
Definition: fttypes.h:288
signed long FT_Long
Definition: fttypes.h:242
unsigned int FT_UInt
Definition: fttypes.h:231
signed int FT_Int
Definition: fttypes.h:220
GLuint start
Definition: gl.h:1545
const GLdouble * v
Definition: gl.h:2040
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLint limit
Definition: glext.h:10326
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLuint GLuint num
Definition: glext.h:9618
if(dx< 0)
Definition: linetemp.h:194
struct PSAux_ServiceRec_ * PSAux_Service
FT_Fixed * top
Definition: psaux.h:1108
CFF_Font cff
Definition: psaux.h:1105
FT_Fixed stack[CFF_MAX_OPERANDS+1]
Definition: psaux.h:1107
FT_UShort num_designs
Definition: cfftypes.h:226
FT_UShort num_axes
Definition: cfftypes.h:227
CFF_SubFontRec top_font
Definition: cfftypes.h:373
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:300
const CFF_Decoder_FuncsRec * cff_decoder_funcs
Definition: psaux.h:1309
Definition: parser.c:44
const CHAR * start
Definition: inffile.c:87
Definition: format.c:80

Referenced by cff_load_private_dict(), and cff_subfont_load().