ReactOS  0.4.14-dev-317-g96040ec
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.

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_Fixed cff_parse_real(FT_Byte *start, FT_Byte *limit, FT_Long power_ten, FT_Long *scaling)
Definition: cffparse.c:179
#define U(x)
Definition: wordpad.c:44
smooth NULL
Definition: ftsmooth.c:416
#define d
Definition: ke_i.h:81
signed short FT_Short
Definition: fttypes.h:198
static FT_Long cff_parse_integer(FT_Byte *start, FT_Byte *limit)
Definition: cffparse.c:92
Definition: import.c:86

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 
86  FT_FREE( parser->stack );
87  }
static char memory[1024 *256]
Definition: process.c:116
#define FT_FREE(ptr)
Definition: ftmemory.h:329
enum parser_state stack[4]
Definition: inffile.c:91
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
Definition: import.c:86

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  {
68  FT_FREE( parser->stack );
69  goto Exit;
70  }
71 
72  parser->stackSize = stackSize;
73  parser->top = parser->stack; /* empty stack */
74 
75  Exit:
76  return error;
77  }
int FT_Error
Definition: fttypes.h:300
FT_Memory memory
Definition: ftobjs.h:918
#define error(str)
Definition: mkdosfs.c:1605
FT_Library library
Definition: cffdrivr.c:654
static char memory[1024 *256]
Definition: process.c:116
#define FT_FREE(ptr)
Definition: ftmemory.h:329
#define FT_ZERO(p)
Definition: ftmemory.h:237
static void Exit(void)
Definition: sock.c:1331
enum parser_state stack[4]
Definition: inffile.c:91
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
int code
Definition: i386-dis.c:3591
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:333
Definition: import.c:86
void * object
Definition: jmemsys.h:48

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 
1535 #ifdef FT_DEBUG_LEVEL_TRACE
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  {
1626  val = ADD_LONG( val, cff_parse_num( parser, data++ ) );
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  }
static FT_Fixed cff_parse_fixed(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:536
int FT_Error
Definition: fttypes.h:300
const CHAR * start
Definition: inffile.c:87
signed long FT_Long
Definition: fttypes.h:242
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Fixed * top
Definition: psaux.h:1108
#define error(str)
Definition: mkdosfs.c:1605
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:300
signed int FT_Int
Definition: fttypes.h:220
#define U(x)
Definition: wordpad.c:44
FT_UShort num_axes
Definition: cfftypes.h:227
FT_UShort num_designs
Definition: cfftypes.h:226
static stack_node_t * stack
Definition: rpn_ieee.c:37
FT_Library library
Definition: cffdrivr.c:654
return FT_Err_Ok
Definition: ftbbox.c:511
GLint limit
Definition: glext.h:10326
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
#define ADD_LONG(a, b)
Definition: ftcalc.h:420
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
#define CFF_FIELD_HANDLERS_GET
Definition: cffpic.h:39
return Found
Definition: dirsup.c:1270
GLuint GLfloat * val
Definition: glext.h:7180
Definition: _stack.h:47
#define FT_ZERO(p)
Definition: ftmemory.h:237
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define FT_DEBUG_LEVEL_TRACE
Definition: ftoption.h:397
Definition: parser.c:43
struct PSAux_ServiceRec_ * PSAux_Service
static void Exit(void)
Definition: sock.c:1331
GLuint GLuint num
Definition: glext.h:9618
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
const CFF_Decoder_FuncsRec * cff_decoder_funcs
Definition: psaux.h:1309
enum parser_state stack[4]
Definition: inffile.c:91
signed short FT_Short
Definition: fttypes.h:198
#define FT_CHAR_BIT
Definition: ftconfig.h:70
int code
Definition: i386-dis.c:3591
CFF_Font cff
Definition: psaux.h:1105
signed long FT_Fixed
Definition: fttypes.h:288
const GLdouble * v
Definition: gl.h:2040
unsigned int FT_UInt
Definition: fttypes.h:231
GLuint start
Definition: gl.h:1545
Definition: import.c:86
FT_Fixed stack[CFF_MAX_OPERANDS+1]
Definition: psaux.h:1107
FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:4865
GLfloat GLfloat p
Definition: glext.h:8902
cff_parse_num(CFF_Parser parser, FT_Byte **d)
Definition: cffparse.c:454
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
static FT_Fixed cff_parse_fixed_scaled(CFF_Parser parser, FT_Byte **d, FT_Long scaling)
Definition: cffparse.c:546
CFF_SubFontRec top_font
Definition: cfftypes.h:373

Referenced by cff_load_private_dict(), and cff_subfont_load().