553 lines
27 KiB
C
553 lines
27 KiB
C
/*
|
|
File: ATSUnicodeFlattening.h
|
|
|
|
Contains: Public interfaces for Apple Type Services for Unicode Imaging
|
|
|
|
Version: QuickTime 7.3
|
|
|
|
Copyright: (c) 2007 (c) 2002 by Apple Computer, Inc., all rights reserved.
|
|
|
|
Bugs?: For bug reports, consult the following page on
|
|
the World Wide Web:
|
|
|
|
http://developer.apple.com/bugreporter/
|
|
|
|
*/
|
|
#ifndef __ATSUNICODEFLATTENING__
|
|
#define __ATSUNICODEFLATTENING__
|
|
|
|
#ifndef __ATSUNICODE__
|
|
#include <ATSUnicode.h>
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if PRAGMA_ONCE
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if PRAGMA_IMPORT
|
|
#pragma import on
|
|
#endif
|
|
|
|
#if PRAGMA_STRUCT_ALIGN
|
|
#pragma options align=mac68k
|
|
#elif PRAGMA_STRUCT_PACKPUSH
|
|
#pragma pack(push, 2)
|
|
#elif PRAGMA_STRUCT_PACK
|
|
#pragma pack(2)
|
|
#endif
|
|
|
|
/* ---------------------------------------------------------------------------- */
|
|
/* Constants */
|
|
/* ---------------------------------------------------------------------------- */
|
|
/*
|
|
ATSUFlattenedDataStreamFormat is used to inform the APIs which flatten and
|
|
unflatten style runs exactly what type of data that they should be generating
|
|
or parsing.
|
|
*/
|
|
typedef UInt32 ATSUFlattenedDataStreamFormat;
|
|
enum {
|
|
kATSUDataStreamUnicodeStyledText = FOUR_CHAR_CODE('ustl')
|
|
};
|
|
|
|
|
|
/*
|
|
ATSUFlattenStyleRunOptions is a bitfield list of options that can be passed
|
|
into the ATSUFlattenStyleRunsToStream API. Currently, there are no options.
|
|
This is here for future expansion.
|
|
*/
|
|
typedef UInt32 ATSUFlattenStyleRunOptions;
|
|
enum {
|
|
kATSUFlattenOptionNoOptionsMask = 0x00000000
|
|
};
|
|
|
|
/*
|
|
ATSUUnFlattenStyleRunOptions is a bitfield list of options that can be passed
|
|
into the ATSUUnFlattenStyleRunsToStream API. Currently, there are no options.
|
|
This is here for future expansion.
|
|
*/
|
|
typedef UInt32 ATSUUnFlattenStyleRunOptions;
|
|
enum {
|
|
kATSUUnFlattenOptionNoOptionsMask = 0x00000000
|
|
};
|
|
|
|
|
|
/* ---------------------------------------------------------------------------- */
|
|
/* Data Types */
|
|
/* ---------------------------------------------------------------------------- */
|
|
|
|
/*
|
|
ATSUStyleRunInfo is a structure that contrains an index into an array of
|
|
unique ATSUStyle objects as well as the length of the run that the style run
|
|
object covers. This structure is utilized by ATSUUnflattenStyleRunsFromStream()
|
|
to return the style run info to the caller.
|
|
*/
|
|
struct ATSUStyleRunInfo {
|
|
UniCharCount runLength;
|
|
ItemCount styleObjectIndex;
|
|
};
|
|
typedef struct ATSUStyleRunInfo ATSUStyleRunInfo;
|
|
/* ---------------------------------------------------------------------------- */
|
|
/* 'ustl' structure data structures and definitions */
|
|
/* ---------------------------------------------------------------------------- */
|
|
/*
|
|
The 'ustl' data structure follows this format:
|
|
1. Main Data Structure Block Header
|
|
2. Flattened Text Layout Data
|
|
3. Flattened Style Run Data
|
|
4. Flattened Style Data
|
|
Per the 'ustl' spec, these structures should maintain four-byte alignment.
|
|
For things that are variable width (such as font names), padding bytes must
|
|
be added to ensure that this alignment is always kept.
|
|
*/
|
|
|
|
/*
|
|
structure versioning - the version of the 'ustl' that the ATSUI parsing
|
|
and generating functions will handle is version 2 or greater. Earlier
|
|
versions were not completly specified and have been obsoleted.
|
|
*/
|
|
enum {
|
|
kATSFlatDataUstlVersion0 = 0,
|
|
kATSFlatDataUstlVersion1 = 1,
|
|
kATSFlatDataUstlVersion2 = 2,
|
|
kATSFlatDataUstlCurrentVersion = kATSFlatDataUstlVersion2
|
|
};
|
|
|
|
/* ------------------ */
|
|
/* Block 1 Structures */
|
|
/* ------------------ */
|
|
|
|
/*
|
|
This is the main data structure block header. It describes the rest
|
|
of the data and how it is structured.
|
|
*/
|
|
struct ATSFlatDataMainHeaderBlock {
|
|
|
|
/* the 'ustl' version number. This needs to be the first item in the*/
|
|
/* data block do as not to confuse parsers of earlier (and possibly*/
|
|
/* later) versions of the spec *|*/
|
|
UInt32 version;
|
|
|
|
/* the total size of the stream in bytes, including the four bytes in*/
|
|
/* the version above*/
|
|
ByteCount sizeOfDataBlock;
|
|
|
|
/* offset from the beginning of the stream to the flattened text layout data.*/
|
|
/* This can be set to 0 if there are no text layouts stored in the stream.*/
|
|
ByteCount offsetToTextLayouts;
|
|
|
|
/* offset from the beginning of the stream to the flattened style run data. */
|
|
/* This can be set to 0 if there is no flattened style run data in the stream*/
|
|
ByteCount offsetToStyleRuns;
|
|
|
|
/* offset to the flattened style list data. This can be set to 0 if there*/
|
|
/* is no flattened style list data*/
|
|
ByteCount offsetToStyleList;
|
|
};
|
|
typedef struct ATSFlatDataMainHeaderBlock ATSFlatDataMainHeaderBlock;
|
|
/* ------------------ */
|
|
/* Block 2 Structures */
|
|
/* ------------------ */
|
|
/*
|
|
The Block 2 Structures are not currently used by any of ATSUI's internal parsing
|
|
or packing routines. They are, however, part of the 'ustl' standard and are put
|
|
here for developer conveniance, as well as to properly define the standard.
|
|
*/
|
|
|
|
/*
|
|
This is the the main header for block 2. If there is a block 2, then there
|
|
needs to be one of these. This structure is what the offsetToTextLayouts
|
|
points to in block 1.
|
|
*/
|
|
struct ATSFlatDataTextLayoutDataHeader {
|
|
|
|
/* the total size of this particular flattened text layout, including any*/
|
|
/* padding bytes and such. */
|
|
ByteCount sizeOfLayoutData;
|
|
|
|
/* the number of characters covered by this flattened text layout*/
|
|
ByteCount textLayoutLength;
|
|
|
|
/* the byte offset relative to the start of this structure to the flattened*/
|
|
/* layout control data. This can be set to zero if there are no layout*/
|
|
/* controls.*/
|
|
ByteCount offsetToLayoutControls;
|
|
|
|
/* the byte offset, relative to the start of this structure to the*/
|
|
/* flattened line info. This can be set to zero if there is no line info */
|
|
/* in this layout.*/
|
|
ByteCount offsetToLineInfo;
|
|
|
|
/* if the offsetToLayoutControls is non-zero, then following this block*/
|
|
/* there will be a ATSFlattenedLayoutDataFlattenedLayoutControlsHeader*/
|
|
/* followed by an array of ATSFlattenedLayoutDataFlattenedLayoutControls*/
|
|
/* structures. If the offsetToLineInfo is non-zero, then following the*/
|
|
/* flattened layout controls will be a ATSFlatDataLineInfoHeader*/
|
|
/* structure.*/
|
|
};
|
|
typedef struct ATSFlatDataTextLayoutDataHeader ATSFlatDataTextLayoutDataHeader;
|
|
/*
|
|
This is the header for the flattened layout controls structure. This is
|
|
the structure that a non-zero offsetToLayoutControls points to in the
|
|
ATSFlatDataTextLayoutDataHeader
|
|
*/
|
|
struct ATSFlatDataLayoutControlsDataHeader {
|
|
|
|
/* the number of flattened layout controls. It is suggested that there be*/
|
|
/* at least one layout control to output the line direction for the layout*/
|
|
ItemCount numberOfLayoutControls;
|
|
|
|
/* first of possibly many flattened layout controls. There should be one */
|
|
/* of these for each layout control as determined by the*/
|
|
/* numberOfLayoutControls above. Of course, if there are no layout controls,*/
|
|
/* then this structure shouldn't even exist. Each attribute info structure*/
|
|
/* in the array could be followed by additional padding bytes in order*/
|
|
/* to maintain four-byte alignment. These padding bytes are not to be*/
|
|
/* included in the fValueSize member of each structure. */
|
|
ATSUAttributeInfo controlArray[1];
|
|
};
|
|
typedef struct ATSFlatDataLayoutControlsDataHeader ATSFlatDataLayoutControlsDataHeader;
|
|
struct ATSFlatDataLineInfoData {
|
|
|
|
/* the length of this particular line in UniChars*/
|
|
UniCharCount lineLength;
|
|
|
|
/* the number of line controls applied to this line. This can be set*/
|
|
/* to zero if there are no special line controls applied to this line.*/
|
|
ItemCount numberOfLineControls;
|
|
|
|
/* the numberOfLineControls is non-zero, then following this structure*/
|
|
/* must be an array of ATSUAttributeInfo structures. There must be one*/
|
|
/* ATSUAttributeInfo structure for each numberOfLineControls above.*/
|
|
};
|
|
typedef struct ATSFlatDataLineInfoData ATSFlatDataLineInfoData;
|
|
/*
|
|
This structure is the main data header for the flattened line info data. This
|
|
is what a non-zero offsetToLineInfo points to in the
|
|
ATSFlatDataTextLayoutDataHeader structure above.
|
|
*/
|
|
struct ATSFlatDataLineInfoHeader {
|
|
|
|
/* the number of flattened line info structures that are stored in this*/
|
|
/* block. This value should really be equal to the number of soft line*/
|
|
/* breaks in the layout + 1. Of course if numberOfLines is zero, then*/
|
|
/* this structure shouldn't even be used.*/
|
|
ItemCount numberOfLines;
|
|
|
|
/* the first in a array of ATSFlatDataLineInfoData structures. There*/
|
|
/* needs to be a ATSFlatDataLineInfoData for each numberOfLines*/
|
|
/* specified above.*/
|
|
ATSFlatDataLineInfoData lineInfoArray[1];
|
|
};
|
|
typedef struct ATSFlatDataLineInfoHeader ATSFlatDataLineInfoHeader;
|
|
/* ------------------ */
|
|
/* Block 3 Structures */
|
|
/* ------------------ */
|
|
/*
|
|
The block 3 structures are used by ATSUI style run flattening and parsing
|
|
functions, ATSUFlattenStyleRunsToStream and ATSUUnflattenStyleRunsFromStream
|
|
to represent flattened style run information. These structures go hand and
|
|
hand with the block 4 structures.
|
|
*/
|
|
|
|
/*
|
|
This is the data header that appears before the style run data structures.
|
|
This structure is what a non-zero offsetToStyleRuns in the
|
|
ATSFlatDataMainHeaderBlock points to in block 1.
|
|
*/
|
|
struct ATSFlatDataStyleRunDataHeader {
|
|
|
|
/* the number of style run data structures stored in this block*/
|
|
ItemCount numberOfStyleRuns;
|
|
|
|
/* the first in an array of ATSUStyleRunInfo structures. There needs to*/
|
|
/* be a ATSUStyleRunInfo structure for each numberOfStyleRuns specified*/
|
|
/* above. This structure is defined in ATSUnicode.h*/
|
|
ATSUStyleRunInfo styleRunArray[1];
|
|
};
|
|
typedef struct ATSFlatDataStyleRunDataHeader ATSFlatDataStyleRunDataHeader;
|
|
/* ------------------ */
|
|
/* Block 4 Structures */
|
|
/* ------------------ */
|
|
/*
|
|
The block 4 structures store flattened ATSUStyle objects. This too, is
|
|
currently used by the ATSUI style run flattening and parsing functions,
|
|
ATSUFlattenStyleRunsToStream and ATSUUnflattenStyleRunsFromStream.
|
|
*/
|
|
|
|
/*
|
|
this structure forms the beginning of an individually flattened ATSUStyle
|
|
object.
|
|
*/
|
|
struct ATSFlatDataStyleListStyleDataHeader {
|
|
|
|
/* the size of this flattened style object, including these four bytes and*/
|
|
/* any padding bytes at the end of the structure. Basically, this can be*/
|
|
/* used to determine where the next structure in the array begins.*/
|
|
ByteCount sizeOfStyleInfo;
|
|
|
|
/* the number of attributes set in this flattened style object. This should */
|
|
/* be at least one for the font data, although it can be 0 if this is to be*/
|
|
/* unspecfied.*/
|
|
ItemCount numberOfSetAttributes;
|
|
|
|
/* the number of font features set in the flattened style object. This can*/
|
|
/* be set to 0 if there are no font features set in the style object. */
|
|
ItemCount numberOfSetFeatures;
|
|
|
|
/* the number of font variations set in the flattened style object. This*/
|
|
/* can be set to 0 if there are no font variations set in the style object.*/
|
|
ItemCount numberOfSetVariations;
|
|
|
|
/* after this structure header, there is the following data in this block:*/
|
|
|
|
/* 1. if the numberOfSetAttributes is non-zero, then there will be an*/
|
|
/* array of ATSUAttributeInfo structures immediately following the*/
|
|
/* above header data to store the style attributes. This is a variable*/
|
|
/* structure array. There must be one ATSUAttributeInfo for*/
|
|
/* for each numberOfSetAttributes. If numberOfSetAttributes is zero,*/
|
|
/* then skip to the next data section 2.*/
|
|
|
|
/* 2. if the numberOfSetFeatures is non-zero, then there will be an array*/
|
|
/* of ATSFlatDataStyleListFeatureData structures immediately after*/
|
|
/* the ATSUAttributeInfo array above (if any). There must be one*/
|
|
/* ATSFlatDataStyleListFeatureData structure for each */
|
|
/* numberOfSetFeatures set in the header above. If numberOfSetFeatures*/
|
|
/* is zero, then skip to the next data section 3.*/
|
|
|
|
/* 3. if the numberOfSetVariations is non-zero, then there will be an*/
|
|
/* array of ATSFlatDataStyleListVariationData immediately after the*/
|
|
/* ATSFlatDataStyleListFeatureData array above (if any). There must be*/
|
|
/* one ATSFlatDataStyleListVariationData structure for each */
|
|
/* numberOfSetVariations set in the header above.*/
|
|
};
|
|
typedef struct ATSFlatDataStyleListStyleDataHeader ATSFlatDataStyleListStyleDataHeader;
|
|
/*
|
|
this structure is the main header for this block. This structure is what a
|
|
non-zero offsetToStyleList in the ATSFlatDataMainHeaderBlock points to in
|
|
block 1.
|
|
*/
|
|
struct ATSFlatDataStyleListHeader {
|
|
|
|
/* the total number of flattened style objects stored in this block*/
|
|
ItemCount numberOfStyles;
|
|
|
|
/* the first in an array of flattned style entries. The data stored*/
|
|
/* in them is variably sized, so a simply array access won't do for*/
|
|
/* iterating through these. However, there must be one of these*/
|
|
/* ATSFlatDataStyleListStyleDataHeader structures for each */
|
|
/* numberOfStyles above.*/
|
|
ATSFlatDataStyleListStyleDataHeader styleDataArray[1];
|
|
|
|
};
|
|
typedef struct ATSFlatDataStyleListHeader ATSFlatDataStyleListHeader;
|
|
/*
|
|
this structure stores flattened font feature data. An array of these comes
|
|
after the array of font data attributes (if any) if the numberOfSetFeatures is
|
|
non-zero. There must be one of these structures for each numberOfSetFeatures.
|
|
*/
|
|
struct ATSFlatDataStyleListFeatureData {
|
|
|
|
/* the font feature type*/
|
|
ATSUFontFeatureType theFeatureType;
|
|
|
|
/* the font feature selector*/
|
|
ATSUFontFeatureSelector theFeatureSelector;
|
|
};
|
|
typedef struct ATSFlatDataStyleListFeatureData ATSFlatDataStyleListFeatureData;
|
|
/*
|
|
this structure stores the flattened font variation data. An array of these
|
|
comes after the array of ATSFlatDataStyleListFeatureData structures (if any)
|
|
if the numberOfSetVariations is non-zero. There must be one of these
|
|
structures for each numberOfSetFeatures.
|
|
*/
|
|
struct ATSFlatDataStyleListVariationData {
|
|
|
|
/* the variation axis*/
|
|
ATSUFontVariationAxis theVariationAxis;
|
|
|
|
/* the variation value*/
|
|
ATSUFontVariationValue theVariationValue;
|
|
};
|
|
typedef struct ATSFlatDataStyleListVariationData ATSFlatDataStyleListVariationData;
|
|
/* ------------------------ */
|
|
/* Flattened Font Data Info */
|
|
/* ------------------------ */
|
|
/*
|
|
This is somewhat of an addendum to the 'ustl' structure above. These flattened
|
|
data structures are stored in block 4 as a font attribute with the attribute
|
|
tag of kATSUFontTag. They can store font data in a few different ways, such as
|
|
by a FontSync reference or by simple raw font name data. Just as with the
|
|
'ustl' above, this structure must maintain four byte alignment.
|
|
*/
|
|
|
|
|
|
/* these are the currenly supported font specifiers. */
|
|
typedef UInt32 ATSFlatDataFontSpeciferType;
|
|
enum {
|
|
/* this specifier allows the storage of font data based on name data. This*/
|
|
/* uses the stuctures below to store the actual data itself.*/
|
|
kATSFlattenedFontSpecifierRawNameData = FOUR_CHAR_CODE('namd')
|
|
};
|
|
|
|
/*
|
|
this is the main header for the font data. It dictates what type of data
|
|
is stored. The actual data stored must match the type specified by the
|
|
nameSpecType.
|
|
*/
|
|
struct ATSFlatDataFontNameDataHeader {
|
|
|
|
/* the type of data that is flattened in this structure*/
|
|
ATSFlatDataFontSpeciferType nameSpecifierType;
|
|
|
|
/* the size of the data that is flattened in this structre, not including */
|
|
/* any padding bytes that may be necessary to achive the four byte */
|
|
/* alignment of the data, unless they are specified as part of structure, */
|
|
/* such as with the ATSFlatDataFontSpecRawNameData structure.*/
|
|
ByteCount nameSpecifierSize;
|
|
|
|
/* after this header comes the flattened font name data which matches*/
|
|
/* the type specified by the nameSpecifierType above. For instance, if */
|
|
/* the nameSpecType is kATSFlattenedFontNameSpecifierRawNameData, the*/
|
|
/* structure that immediately follows this would be a*/
|
|
/* ATSFlatDataFontNameRawNameDataHeader structure. */
|
|
|
|
};
|
|
typedef struct ATSFlatDataFontNameDataHeader ATSFlatDataFontNameDataHeader;
|
|
/*
|
|
the next two structures are only used when the nameSpecType is set to
|
|
kATSFlattenedFontSpecifierRawNameData. They are setup to store multiple
|
|
font name table entries for the purposes of reconstructing an ATSUFontID
|
|
for (hopefully) the same font some time in the future.
|
|
*/
|
|
/* this is the structure in which raw font name data is actually stored. */
|
|
struct ATSFlatDataFontSpecRawNameData {
|
|
|
|
/* the type of name being specified*/
|
|
FontNameCode fontNameType;
|
|
|
|
/* the platform type of the font name, whether it be Unicode, Mac, etc. */
|
|
/* This should be specified if known. If not known, then specify*/
|
|
/* kFontNoPlatform, but then all matching will be done based on the first*/
|
|
/* font in the name table matching the other parameters.*/
|
|
FontPlatformCode fontNamePlatform;
|
|
|
|
/* the script code of the font's name based on the platform that was passed*/
|
|
/* in above. If set to kFontNoScript, then the name will be matched based*/
|
|
/* on the first font in the name table matching the other font name*/
|
|
/* parameters.*/
|
|
FontScriptCode fontNameScript;
|
|
|
|
/* the language of the font name. If set to kFontNoLanguage, then the name */
|
|
/* will be matched based on the first font in the name table matching the*/
|
|
/* other font name parameters.*/
|
|
FontLanguageCode fontNameLanguage;
|
|
|
|
/* the length of the font name in bytes, not including any padding bytes*/
|
|
/* added to maintain the four byte alignment*/
|
|
ByteCount fontNameLength;
|
|
|
|
/* after the name length comes the actual font name data itself, plus any*/
|
|
/* padding bytes needed to maintain the four byte alignment.*/
|
|
|
|
};
|
|
typedef struct ATSFlatDataFontSpecRawNameData ATSFlatDataFontSpecRawNameData;
|
|
/*
|
|
this is a header structure that defines some things constant throughout
|
|
the entire search for the font name, as well as the array of
|
|
ATSFlatDataFontNameData structures. In order to gaurantee that the same font
|
|
will be used, more than one name specifer should be stored. The standard ATSUI
|
|
style run flattening and parsing functions, ATSUFlattenStyleRunsToStream and
|
|
ATSUUnflattenStyleRunsFromStream. These will store both the font's full name
|
|
(kFontFullName) as well as the font's manufacturer name (kFontManufacturerName)
|
|
and match fonts based on both of
|
|
these.
|
|
*/
|
|
struct ATSFlatDataFontSpecRawNameDataHeader {
|
|
|
|
/* the number of flattened font names. There must be at least one flattened */
|
|
/* font name, otherwise the structure is malformed.*/
|
|
ItemCount numberOfFlattenedNames;
|
|
|
|
/* the first in an array of possibly many font name specifiers - depending*/
|
|
/* on how specific the caller wants this. There must be one */
|
|
/* ATSFlatDataFontNameData structure for each numberOfFlattenedNames*/
|
|
/* above.*/
|
|
ATSFlatDataFontSpecRawNameData nameDataArray[1];
|
|
|
|
};
|
|
typedef struct ATSFlatDataFontSpecRawNameDataHeader ATSFlatDataFontSpecRawNameDataHeader;
|
|
/* ---------------------------------------------------------------------------- */
|
|
/* Style Flattening and Parsing Functions */
|
|
/* ---------------------------------------------------------------------------- */
|
|
/*
|
|
* ATSUFlattenStyleRunsToStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
|
|
* Mac OS X: in version 10.2 and later
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
ATSUFlattenStyleRunsToStream(
|
|
ATSUFlattenedDataStreamFormat iStreamFormat,
|
|
ATSUFlattenStyleRunOptions iFlattenOptions,
|
|
ItemCount iNumberOfRunInfo,
|
|
const ATSUStyleRunInfo iRunInfoArray[],
|
|
ItemCount iNumberOfStyleObjects,
|
|
const ATSUStyle iStyleArray[],
|
|
ByteCount iStreamBufferSize,
|
|
void * oStreamBuffer,
|
|
ByteCount * oActualStreamBufferSize);
|
|
|
|
|
|
/*
|
|
* ATSUUnflattenStyleRunsFromStream()
|
|
*
|
|
* Availability:
|
|
* Non-Carbon CFM: not available
|
|
* CarbonLib: not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
|
|
* Mac OS X: in version 10.2 and later
|
|
*/
|
|
EXTERN_API_C( OSStatus )
|
|
ATSUUnflattenStyleRunsFromStream(
|
|
ATSUFlattenedDataStreamFormat iStreamFormat,
|
|
ATSUUnFlattenStyleRunOptions iUnflattenOptions,
|
|
ByteCount iStreamBufferSize,
|
|
const void * iStreamBuffer,
|
|
ItemCount iNumberOfRunInfo,
|
|
ItemCount iNumberOfStyleObjects,
|
|
ATSUStyleRunInfo oRunInfoArray[],
|
|
ATSUStyle oStyleArray[],
|
|
ItemCount * oActualNumberOfRunInfo,
|
|
ItemCount * oActualNumberOfStyleObjects);
|
|
|
|
|
|
|
|
#if PRAGMA_STRUCT_ALIGN
|
|
#pragma options align=reset
|
|
#elif PRAGMA_STRUCT_PACKPUSH
|
|
#pragma pack(pop)
|
|
#elif PRAGMA_STRUCT_PACK
|
|
#pragma pack()
|
|
#endif
|
|
|
|
#ifdef PRAGMA_IMPORT_OFF
|
|
#pragma import off
|
|
#elif PRAGMA_IMPORT
|
|
#pragma import reset
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __ATSUNICODEFLATTENING__ */
|
|
|