/*++

Copyright (c) 1996-1997  Microsoft Corporation

Module Name:

    pclxl.c

Abstract:

    PCL XL dump tool

Environment:

    Windows NT PostScript driver

Revision History:

--*/

#include        "precomp.h"

//
// Macros
//

#define FILENAME_SIZE       256

#define OUTPUT_VERBOSE      0x01

//
// Error messages
//

#define ERROR_INVALID_ARGUMENT      -1
#define ERROR_OPENFILE              -2
#define ERROR_HEAP_CREATE           -3
#define ERROR_PARSE_XL_DATA         -4
#define ERROR_HEAP_ALLOC            -5

#define ARGUMENT_ERR_MSG_LINE        1

const BYTE *gcstrArgumentError[ARGUMENT_ERR_MSG_LINE] = {
    "Usage: pclxl [output data]\n"
};


const BYTE gcstrOpenFileFailure[]   = "Cannot open file \"%ws\".\n";
const BYTE gcstrHeapCreateFailure[] = "Failed to Create Heap.\a";
const BYTE gcstrHeapAlloc[]         = "Failed to allocate memory.\n";
const BYTE gcstrParseError[]        = "Failed to parse data.\n";

//
// Globals
//

DWORD gdwOutputFlags;
DWORD gdwStatusFlags;

#define STATUS_ARRAY             0x01
#define STATUS_EMBEDED_DATA      0x02
#define STATUS_EMBEDED_DATA_BYTE 0x03

#if 0
//
// Binary Stream Tag Values
//

//
const BYTE gcstrNULL[] = "NULL"; // 0x00         White Space  NULL

//
// 0x01 - 0x08  Not Used
//
const BYTE gcstrHT[] = "HT"; // 0x09
const BYTE gcstrLF[] = "LF"; // 0x0a
const BYTE gcstrVT[] = "VT"; // 0x0b
const BYTE gcstrFF[] = "FF"; // 0x0c
const BYTE gcstrCR[] = "CR"; // 0x0d
// 0x09 - 0x0d  White Space  HT, LF, VT, FF, CR
//
// 0x0e - 0x1f  Not Used
//
const BYTE gcstrSP[] = "SP"; // 0x20
// 0x20         White Space  Space
//
// 0x21 - 0x26  Not Used
//
// 0x27         Reserved for Beginning of ASCII binding.
// 0x28         Reserved for Beginning of binary binding - high byte first.
// 0x29         Reserved for Beginning of binary binding - low byte first.
//
// 0x41 - 0xb9  Operators
//
const BYTE gcstrBeginSession[] = "BeginSession";
const BYTE gcstrEndSession[] = "EndSession";
const BYTE gcstrBeginPage[] = "BeginPage";
const BYTE gcstrEndPage[] = "EndPage";
// 0x45
// 0x46
const BYTE gcstrComment[] = "Comment";
const BYTE gcstrOpenDataSource[] = "OpenDataSource";
const BYTE gcstrCloseDataSource[] = "ClosedataSource";
// 0x4a
// 0x4b
// 0x4c
// 0x4d
// 0x4e
const BYTE gcstrBeginFontHeader[] = "BeginFontHeader";
const BYTE gcstrReadFontHeader[] = "ReadFontHeader";
const BYTE gcstrEndFontHeader[] = "EndFontHeader";
const BYTE gcstrBeginChar[] = "BeginChar";
const BYTE gcstrReadChar[] = "ReadChar";
const BYTE gcstrEndChar[] = "EndChar";
const BYTE gcstrRemoveFont[] = "RemoveFont";
// 0x56
// 0x57
// 0x58
// 0x59
// 0x5a
const BYTE gcstrBeginStream[] = "BeginStream";
const BYTE gcstrReadStream[] = "ReadStream";
const BYTE gcstrEndStream[] = "EndStream";
const BYTE gcstrExecStream[] = "ExecStresm";
// 0x5f
const BYTE gcstrPopGS[] = "PopGS";
const BYTE gcstrPushGS[] = "PushGS";
const BYTE gcstrSetClipReplace[] = "SetClipReplace";
const BYTE gcstrSetBrushSource[] = "SetBrushSource";
const BYTE gcstrSetCharAngle[] = "SetCharAngle";
const BYTE gcstrSetCharScale[] = "SetCharScale";
const BYTE gcstrSetCharShear[] = "SetCharShear";
const BYTE gcstrSetClipIntersect[] = "SetClipIntersect";
const BYTE gcstrSetClipRectangle[] = "SetClipRectangle";
const BYTE gcstrSetClipToPage[] = "SetClipToPage";
const BYTE gcstrSetColorSpace[] = "SetColorSpace";
const BYTE gcstrSetCursor[] = "SetCursor";
const BYTE gcstrSetCursorRel[] = "SetCursorRel";
const BYTE gcstrSetHalftoneMethod[] = "SetHalftoneMethod";
const BYTE gcstrSetFillMode[] = "SetFillMode";
const BYTE gcstrSetFont[] = "SetFont";
const BYTE gcstrSetLineDash[] = "SetLineDash";
const BYTE gcstrSetLineCap[] = "SetLineCap";
const BYTE gcstrSetLineJoin[] = "SetLineJoin";
const BYTE gcstrSetMiterLimit[] = "SetMitterLimit";
const BYTE gcstrSetPageDefaultCTM[] = "SetPageDefaultCTM";
const BYTE gcstrSetPageOrigin[] = "SetPageOrigin";
const BYTE gcstrSetPageRotation[] = "SetPageRotation";
const BYTE gcstrSetPageScale[] = "SetPageScale";
const BYTE gcstrSetPatternTxMode[] = "SetPatternTxMode";
const BYTE gcstrSetPenSource[] = "SetPenSource";
const BYTE gcstrSetPenWidth[] = "SetPenWidth";
const BYTE gcstrSetROP[] = "SetROP";
const BYTE gcstrSetSourceTxMode[] = "SetSourceTxMode";
const BYTE gcstrSetCharBoldValue[] = "SetCharBoldValue";
// 0x7e
const BYTE gcstrSetClipMode[] = "SetClipMode";
const BYTE gcstrSetPathToClip[] = "SetPathToClip";
const BYTE gcstrSetCharSubMode[] = "SetCharSubMode";
// 0x82
// 0x83
const BYTE gcstrCloseSubPath[] = "CloseSubPath";
const BYTE gcstrNewPath[] = "NewPath";
const BYTE gcstrPaintPath[] = "PaintPath";
// 0x87
// 0x88
// 0x89
// 0x8a
// 0x8b
// 0x8c
// 0x8d
// 0x8e
// 0x8f
// 0x90
const BYTE gcstrArcPath[] = "ArcPath";
// 0x92
const BYTE gcstrBezierPath[] = "BezierPath";
// 0x94
const BYTE gcstrBezierRelPath[] = "BezierRelPath";
const BYTE gcstrChord[] = "Chord";
const BYTE gcstrChordPath[] = "ChordPath";
const BYTE gcstrEllipse[] = "Ellipse";
const BYTE gcstrEllipsePath[] = "EliipsePath";
// 0x9a
const BYTE gcstrLinePath[] = "LinePath";
// 0x9c
const BYTE gcstrLineRelPath[] = "LineRelPath";
const BYTE gcstrPie[] = "Pie";
const BYTE gcstrPiePath[] = "PiePath";
const BYTE gcstrRectangle[] = "Rectangle";
const BYTE gcstrRectanglePath[] = "RectanglePath";
const BYTE gcstrRoundRectangle[] = "RoundRectangle";
const BYTE gcstrRoundRectanglePath[] = "RoudnRectanglePath";
// 0xa4
// 0xa5
// 0xa6
// 0xa7
const BYTE gcstrText[] = "Text";
const BYTE gcstrTextPath[] = "TextPath";
// 0xa8
// 0xa9
// 0xaa
// 0xab
// 0xac
// 0xad
// 0xae
// 0xaf
const BYTE gcstrBeginImage[] = "BeginImage";
const BYTE gcstrReadImage[] = "ReadImage";
const BYTE gcstrEndImage[] = "EndImage";
const BYTE gcstrBeginRestPattern[] = "BeginRestPattern";
const BYTE gcstrReadRastPattern[] = "ReadRastPattern";
const BYTE gcstrEndRastPattern[] = "EndRastPattern";
const BYTE gcstrBeginScan[] = "BeginScan";
// 0xb7
const BYTE gcstrEndScan[] = "EndScan";
const BYTE gcstrScanLineRel[] = "ScanLineRel";

// 0xba - 0xbf  Reserved for future use.
// 0xc0         ubyte
// 0xc1         uint16
// 0xc2         uint32
// 0xc3         sint16
// 0xc4         sint32
// 0xc5         real32
// 0xc6
// 0xc7
// 0xc8         ubyte_array
// 0xc9         uint16_array
// 0xca         uint32_array
// 0xcb         sint16_array
// 0xcc         sint32_array
// 0xcd         real32_array
// 0xce
// 0xcf
// 0xd0         ubyte_xy
// 0xd1         uint16_xy
// 0xd2         uint32_xy
// 0xd3         sint16_xy
// 0xd4         sint32_xy
// 0xd5         real32_xy
// 0xd6
// 0xd7
// 0xd8
// 0xd9
// 0xda
// 0xdb
// 0xdc
// 0xdd
// 0xde
// 0xdf
// 0xe0         ubyte_box
// 0xe1         uint16_box
// 0xe2         uint32_box
// 0xe3         sint16_box
// 0xe4         sint32_box
// 0xe5         real32_box
//
// 0xe6 - 0xef  Reserved form future use.
//
// 0xf0 - 0xf7  Reserved form future use.
//
// 0xf8         attr_ubyte
// 0xf9         attr_uint16
//
// 0xfa         dataLength  Embedded Data Follows
//
// 0xfb         dataLengthByte Emmedded Data Follows (0-255 bytes)
//
// 0xfc - 0xff  Reserved for future use.
//
//
#endif

typedef enum _TAG_TYPE { NotUsed, WhiteSpace, Operator, DataType, Attribute, EmbedData, Binding, Reserved} TAG_TYPE;

typedef struct _BINARY_TAG {
    TAG_TYPE TagType;
    PBYTE pubTagName;
} BINARY_TAG, *PBINARY_TAG;

const BINARY_TAG
BinaryTagArray[256] = {
    {WhiteSpace, "NULL"  },// 0x00
    {NotUsed,  NULL         },// 0x01
    {NotUsed,  NULL         },// 0x02
    {NotUsed,  NULL         },// 0x03
    {NotUsed,  NULL         },// 0x04
    {NotUsed,  NULL         },// 0x05
    {NotUsed,  NULL         },// 0x06
    {NotUsed,  NULL         },// 0x07
    {NotUsed,  NULL         },// 0x08
    {WhiteSpace, "HT"    },// 0x09
    {WhiteSpace, "LF"    },// 0x0a
    {WhiteSpace, "VT"    },// 0x0b
    {WhiteSpace, "FF"    },// 0x0c
    {WhiteSpace, "CR"    },// 0x0d
    {NotUsed,  NULL         },// 0x0e
    {NotUsed,  NULL         },// 0x0f

    {NotUsed,  NULL         },// 0x10
    {NotUsed,  NULL         },// 0x11
    {NotUsed,  NULL         },// 0x12
    {NotUsed,  NULL         },// 0x13
    {NotUsed,  NULL         },// 0x14
    {NotUsed,  NULL         },// 0x15
    {NotUsed,  NULL         },// 0x16
    {NotUsed,  NULL         },// 0x17
    {NotUsed,  NULL         },// 0x18
    {NotUsed,  NULL         },// 0x19
    {NotUsed,  NULL         },// 0x1a
    {NotUsed,  NULL         },// 0x1b
    {NotUsed,  NULL         },// 0x1c
    {NotUsed,  NULL         },// 0x1d
    {NotUsed,  NULL         },// 0x1e
    {NotUsed,  NULL         },// 0x1f

    {WhiteSpace, "SP"    },// 0x20
    {NotUsed,  NULL         },// 0x21
    {NotUsed,  NULL         },// 0x22
    {NotUsed,  NULL         },// 0x23
    {NotUsed,  NULL         },// 0x24
    {NotUsed,  NULL         },// 0x25
    {NotUsed,  NULL         },// 0x26
    {Binding,  NULL         },// 0x27
    {Binding,  NULL         },// 0x28
    {Binding,  NULL         },// 0x29
    {NotUsed,  NULL         },// 0x2a
    {NotUsed,  NULL         },// 0x2b
    {NotUsed,  NULL         },// 0x2c
    {NotUsed,  NULL         },// 0x2d
    {NotUsed,  NULL         },// 0x2e
    {NotUsed,  NULL         },// 0x2f

    {NotUsed,  NULL         },// 0x30
    {NotUsed,  NULL         },// 0x31
    {NotUsed,  NULL         },// 0x32
    {NotUsed,  NULL         },// 0x33
    {NotUsed,  NULL         },// 0x34
    {NotUsed,  NULL         },// 0x35
    {NotUsed,  NULL         },// 0x36
    {NotUsed,  NULL         },// 0x37
    {NotUsed,  NULL         },// 0x38
    {NotUsed,  NULL         },// 0x39
    {NotUsed,  NULL         },// 0x3a
    {NotUsed,  NULL         },// 0x3b
    {NotUsed,  NULL         },// 0x3c
    {NotUsed,  NULL         },// 0x3d
    {NotUsed,  NULL         },// 0x3e
    {NotUsed,  NULL         },// 0x3f

    {NotUsed,  NULL         },// 0x40
    {Operator, "BeginSession"        },// 0x41
    {Operator, "EndSession"          },// 0x42
    {Operator, "BeginPage"         },// 0x43
    {Operator, "EndPage"         },// 0x44
    {Operator, NULL         },// 0x45
    {Operator, NULL         },// 0x46
    {Operator, "Comment"         },// 0x47
    {Operator, "OpenDataSource"         },// 0x48
    {Operator, "CloseDataSource" },// 0x49
    {Operator, NULL         },// 0x4a
    {Operator, NULL         },// 0x4b
    {Operator, NULL         },// 0x4c
    {Operator, NULL         },// 0x4d
    {Operator, NULL         },// 0x4e
    {Operator, "BeginFontHeader"         },// 0x4f

    {Operator, "ReadFontHeader"         },// 0x50
    {Operator, "EndFontHeader"         },// 0x51
    {Operator, "BeginChar"         },// 0x52
    {Operator, "ReadChar"         },// 0x53
    {Operator, "EndChar"         },// 0x54
    {Operator, "RemoveFont"         },// 0x55
    {Operator, NULL         },// 0x56
    {Operator, NULL         },// 0x57
    {Operator, NULL         },// 0x58
    {Operator, NULL         },// 0x59
    {Operator, NULL         },// 0x5a
    {Operator, "BeginStream"         },// 0x5b
    {Operator, "ReadStream"         },// 0x5c
    {Operator, "EndStream"         },// 0x5d
    {Operator, "ExecStream"         },// 0x5e
    {Operator, NULL         },// 0x5f

    {Operator, "PopGS"         },// 0x60
    {Operator, "PushGS"         },// 0x61
    {Operator, "SetClipReplace"         },// 0x62
    {Operator, "SetBrushSource"         },// 0x63
    {Operator, "SetCharAngle"         },// 0x64
    {Operator, "SetCharScale"         },// 0x65
    {Operator, "SetCharShear"         },// 0x66
    {Operator, "SetClipIntersect"         },// 0x67
    {Operator, "SetClipRectangle"         },// 0x68
    {Operator, "SetClipToPage"         },// 0x69
    {Operator, "SetColorSpace"         },// 0x6a
    {Operator, "SetCursor"         },// 0x6b
    {Operator, "SetCursorRel"         },// 0x6c
    {Operator, "SetHalftoneMethod"         },// 0x6d
    {Operator, "SetFillMode"         },// 0x6e
    {Operator, "SetFont"        },// 0x6f

    {Operator, "SetLineDash"        },// 0x70
    {Operator, "SetLineCap"        },// 0x71
    {Operator, "SetLineJoin"        },// 0x72
    {Operator, "SetMiterLimit"        },// 0x73
    {Operator, "SetPageDefaultCTM"        },// 0x74
    {Operator, "SetPageOrigin"        },// 0x75
    {Operator, "SetPageRotation"        },// 0x76
    {Operator, "SetPageScale"        },// 0x77
    {Operator, "SetPatternTxMode"        },// 0x78
    {Operator, "SetPenSource"        },// 0x79
    {Operator, "SetPenWidth"        },// 0x7a
    {Operator, "SetROP"        },// 0x7b
    {Operator, "SetSourceTxMode"        },// 0x7c
    {Operator, "SetCharBoldValue"        },// 0x7d
    {Operator, NULL        },// 0x7e
    {Operator, "SetClipMode"        },// 0x7f

    {Operator, "SetPathToClip"        },// 0x80
    {Operator, "SetCharSubMode"        },// 0x81
    {Operator, NULL        },// 0x82
    {Operator, NULL        },// 0x83
    {Operator, "CloseSubPath"        },// 0x84
    {Operator, "NewPath"        },// 0x85
    {Operator, "PaintPath"        },// 0x86
    {Operator, NULL         },// 0x87
    {Operator, NULL         },// 0x88
    {Operator, NULL         },// 0x89
    {Operator, NULL         },// 0x8a
    {Operator, NULL         },// 0x8b
    {Operator, NULL         },// 0x8c
    {Operator, NULL         },// 0x8d
    {Operator, NULL         },// 0x8e
    {Operator, NULL         },// 0x8f

    {Operator, NULL         },// 0x90
    {Operator, "ArcPath"         },// 0x91
    {Operator, NULL         },// 0x92
    {Operator, "BezierPath"        },// 0x93
    {Operator, NULL         },// 0x94
    {Operator, "BezierRelPath"        },// 0x95
    {Operator, "Chord"        },// 0x96
    {Operator, "ChordPath"        },// 0x97
    {Operator, "Ellipse"        },// 0x98
    {Operator, "EllipsePath"        },// 0x99
    {Operator, NULL         },// 0x9a
    {Operator, "LinePath"        },// 0x9b
    {Operator, "Pie"        },// 0x9c
    {Operator, "PiePath"        },// 0x9d
    {Operator, "Rectangle"        },// 0x9e
    {Operator, "RectanglePath"        },// 0x9f

    {Operator, "RoundRectangle"        },// 0xa0
    {Operator, "RoundRectanglePath"        },// 0xa1
    {Operator, NULL         },// 0xa2
    {Operator, NULL         },// 0xa3
    {Operator, NULL         },// 0xa4
    {Operator, NULL         },// 0xa5
    {Operator, NULL         },// 0xa6
    {Operator, NULL         },// 0xa7
    {Operator, "Text"        },// 0xa8
    {Operator, "TextPath"        },// 0xa9
    {Operator, NULL         },// 0xaa
    {Operator, NULL         },// 0xab
    {Operator, NULL         },// 0xac
    {Operator, NULL         },// 0xad
    {Operator, NULL         },// 0xae
    {Operator, NULL         },// 0xaf

    {Operator, "BeginImage"        },// 0xb0
    {Operator, "ReadImage"        },// 0xb1
    {Operator, "EndImage"        },// 0xb2
    {Operator, "BeginRestPattern"        },// 0xb3
    {Operator, "ReadRastPattern"        },// 0xb4
    {Operator, "EndRastPattern"        },// 0xb5
    {Operator, "BeginScan"        },// 0xb6
    {Operator, NULL         },// 0xb7
    {Operator, "EndScan"        },// 0xb8
    {Operator, "ScanLineRel"        },// 0xb9
    {Operator, NULL         },// 0xba
    {Reserved, NULL         },// 0xbb
    {Reserved, NULL         },// 0xbc
    {Reserved, NULL         },// 0xbd
    {Reserved, NULL         },// 0xbe
    {Reserved, NULL         },// 0xbf

    {DataType,"ubyte"          },// 0xc0
    {DataType,"uint16"      },// 0xc1
    {DataType,"uint32"      },// 0xc2
    {DataType,"sint16"      },// 0xc3
    {DataType,"sint32"      },// 0xc4
    {DataType,"real32"      },// 0xc5
    {DataType,NULL        },// 0xc6
    {DataType,NULL        },// 0xc7
    {DataType, "ubyte_array"         },// 0xc8
    {DataType, "uint16_array"        },// 0xc9
    {DataType, "uint32_array"        },// 0xca
    {DataType, "sint16_array"        },// 0xcb
    {DataType, "sint32_array"        },// 0xcc
    {DataType, "real32_array"        },// 0xcd
    {DataType,NULL        },// 0xce
    {DataType,NULL        },// 0xcf

    {DataType,"ubyte_xy"        },// 0xd0
    {DataType,"uint16_xy"        },// 0xd1
    {DataType, "uint32_xy"        },// 0xd2
    {DataType, "sint16_xy"        },// 0xd3
    {DataType, "sint32_xy"        },// 0xd4
    {DataType, "real32_xy"        },// 0xd5
    {DataType,NULL        },// 0xd6
    {DataType,NULL        },// 0xd7
    {DataType,NULL        },// 0xd8
    {DataType,NULL        },// 0xd9
    {DataType,NULL        },// 0xda
    {DataType,NULL        },// 0xdb
    {DataType,NULL        },// 0xdc
    {DataType,NULL        },// 0xdd
    {DataType,NULL        },// 0xde
    {DataType,NULL        },// 0xdf

    {DataType,"ubyte_box"        },// 0xe0
    {DataType,"uint16_box"       },// 0xe1
    {DataType,"uint32_box"       },// 0xe2
    {DataType,"sint16_box"       },// 0xe3
    {DataType,"sint32_box"       },// 0xe4
    {DataType,"real32_box"       },// 0xe5
    {DataType,NULL        },// 0xe6
    {DataType,NULL        },// 0xe7
    {DataType,NULL        },// 0xe8
    {DataType,NULL        },// 0xe9
    {DataType,NULL        },// 0xea
    {DataType,NULL        },// 0xeb
    {DataType,NULL        },// 0xec
    {DataType,NULL        },// 0xed
    {DataType,NULL        },// 0xee
    {DataType,NULL        },// 0xef

    {Reserved,NULL        },// 0xf0
    {Reserved,NULL        },// 0xf1
    {Reserved,NULL        },// 0xf2
    {Reserved,NULL        },// 0xf3
    {Reserved,NULL        },// 0xf4
    {Reserved,NULL        },// 0xf5
    {Reserved,NULL        },// 0xf6
    {Reserved,NULL        },// 0xf7
    {Attribute,"attr_ubyte"        },// 0xf8
    {Attribute,"attr_uint16"        },// 0xf9
    {EmbedData,"dataLength"    },// 0xfa
    {EmbedData,"dataLengthByte"    },// 0xfb
    {Reserved, NULL }, //0xfc
    {Reserved, NULL }, //0xfd
    {Reserved, NULL }, //0xfe
    {Reserved, NULL }  //0xff

    
};

//
// Attribute IDs
//
const PBYTE pubAttributeID[180] = {
    NULL, // 0
    NULL,
    "PaletteDepth",
    "ColorSpace",
    "NullBrush",
    "NullPen",
    "PaleteData",
    NULL,
    "PatternSelectID",
    "GrayLevel",
    NULL,
    "RGBColor",
    "PatternOrigin",
    "NewDestinationSize",
    NULL,
    NULL,
    NULL,

    NULL, // 17
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,

    "DeviceMatrix", // 33
    "DitherMatrixDataType",
    "DitherOrigin",
    "MediaDestination",
    "MediaSize",
    "MediaSource",
    "MediaType",
    "Orientation",
    "PageAngle",
    "PageOrigin",
    "PageScale",
    "ROP3",
    "TxMode",
    NULL,
    "CustomMediaSize",
    "CustomMediaSizeUnits", // 48

    "PageCopies", // 49
    "DitherMatrixSize",
    "DithermatrixDepth",
    "SimplexPageMode",
    "DuplexPageMode",
    "DuplexPageSize",
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL, // 64

    "ArgDirection",
    "BoundingBox",
    "DashOffset",
    "EllipseDimension",
    "EndPoint",
    "FillMode",
    "LineCapStyle",
    "LineJointStyle",
    "MiterLength",
    "PenDashStyle",
    "PenWidth",
    "Point",
    "NumberOfPoints",
    "SolidLine",
    "StartPoint",
    "PointType", // 80

    "ControlPoint1", // 81
    "ControlPoint2",
    "ClipRegion",
    "ClipMode",
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL, // 96

    NULL, // 97
    "ColorDepth",
    "BlockHeight",
    "ColorMapping",
    "CompressMode",
    "DestinationBox",
    "DestinationSize",
    "PatternPersistence",
    "PatternDefineID",
    NULL,
    "SourceHeight",
    "SourceWidth",
    "StartLine",
    "XPairType",
    "NumberOfXPairs",
    NULL, // 112

    "XStart", // 113
    "XEnd",
    "NumberOfScanLines",
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL, // 128

    "CommentData", // 129
    "DataOrg",
    NULL,
    NULL,
    NULL,
    "Measure",
    NULL,
    "SourceType",
    "UnitsPerMeasure",
    NULL,
    "StreamName",
    "StreamDataLength",
    NULL,
    NULL,
    "ErrorReport",
    NULL, // 144

    NULL, // 145
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL, // 160

    "CharAngle", // 161
    "CharCode",
    "CharDataSize",
    "CharScale",
    "CharShear",
    "CharSize",
    "FontHeaderLength",
    "FontName",
    "FontFormat",
    "SymbolSet",
    "TextData",
    "CharSubModeArray",
    NULL,
    NULL,
    "XSpacingData",
    "YSpacingData",
    "CharBoldValue",
    NULL,
    NULL
};









//
// PJL strings
//
const BYTE gcstrPJL[] = "PJL";
const BYTE gcstrJOB[] = "JOB";
const BYTE gcstrSET[] = "SET";
const BYTE gcstrCOMMENT[] = "COMMENT";
const BYTE gcstrENTER[] = "ENTER";
const BYTE gcstrLANGUAGE[] = "LANGUAGE";
const BYTE gcstrPCLXL[] = "PCLXL";

#define NU 0x0
#define ESC 0x1b
#define SP  0x20
#define HT  0x09
#define LF  0x0a
#define VT  0x0b
#define FF  0x0c
#define CR  0x0d

//
// Internal function prototype
//

BOOL
BArgCheck(
    IN  INT,
    IN  CHAR **,
    OUT PWSTR);

VOID
VArgumentError();

BOOL
BParseXLData(PVOID pXLFile);

PBYTE
PRemovePJL(PBYTE pXLFile);

PBYTE PDecodeXL(PBYTE pData);

PBYTE
PSkipSpace(PBYTE pData);

PBYTE
PSkipLine(PBYTE pData);

PBYTE
PSkipWord(PBYTE pData);

//
//
// Functions
//
//

int  __cdecl
main(
    IN int     argc,
    IN char  **argv)
/*++

Routine Description:

    main

Arguments:

    argc - Number of parameters in the following
    argv - The parameters, starting with our name

Return Value:

    Return error code 

Note:


--*/
{
    WCHAR awchXLFileName[FILENAME_SIZE];
    DWORD dwXLFileSize;
    PVOID pXLFile;
    HANDLE hXLFile;

    //
    // Argument check 
    // pclxl [Output data]
    //

    gdwStatusFlags = 0;

    if (!BArgCheck(argc,
                   argv,
                   awchXLFileName))
    {
        VArgumentError();
        return ERROR_INVALID_ARGUMENT;
    }

    //
    // Open *.RC file.
    //
    if (gdwOutputFlags & OUTPUT_VERBOSE)
    {
        printf("***********************************************************\n");
        printf("FILE: %ws\n", awchXLFileName);
        printf("***********************************************************\n");
    }

    if (!(hXLFile = MapFileIntoMemory( (PTSTR)awchXLFileName,
                                       (PVOID)&pXLFile,
                                       (PDWORD)&dwXLFileSize )))
    {
        fprintf( stderr, gcstrOpenFileFailure, awchXLFileName);
        return ERROR_OPENFILE;
    }

    if (!BParseXLData(pXLFile))
    {
        fprintf( stderr, gcstrParseError);
        return ERROR_PARSE_XL_DATA;
    }

#if 0
    //
    // Heap Creation
    //

    if (!(hHeap = HeapCreate( HEAP_NO_SERIALIZE, 0x10000, 0x10000)))
    {
        fprintf( stderr, gcstrHeapCreateFailure);
        ERR(("CreateHeap failed: %d\n", GetLastError()));
        return ERROR_HEAP_CREATE;
    }
#endif

    UnmapFileFromMemory(hXLFile);

    return 0;
}

BOOL
BArgCheck(
        INT argc,
        CHAR **argv,
        PWSTR pwstrFileName)
{

   if (argc != 2)
       return FALSE;

   argv++;
   MultiByteToWideChar(CP_ACP,
                       0,
                       *argv,
                       strlen(*argv)+1,
                       pwstrFileName,
                       FILENAME_SIZE);

   return TRUE; 
}

VOID
VArgumentError()
{
    SHORT sI;
    for (sI = 0; sI < ARGUMENT_ERR_MSG_LINE; sI++)
    {
        fprintf( stderr, gcstrArgumentError[sI]);
    }
}

BOOL
BParseXLData(
        PBYTE pXLFile)
{
    PBYTE pubFile;

    //
    // Remove PJL command
    //
    pubFile =  PRemovePJL(pXLFile);

    //
    //
    //
    while (*pubFile != ESC)
        pubFile = PDecodeXL(pubFile);

    return TRUE;
}

PBYTE
PRemovePJL(
        PBYTE pXLFile)
{
    BOOL bBreak = FALSE;

    if ((*pXLFile++ != ESC) ||
        (*pXLFile++ != '%')   ||
        (*pXLFile++ != '-')   ||
        (*pXLFile++ != '1')   ||
        (*pXLFile++ != '2')   ||
        (*pXLFile++ != '3')   ||
        (*pXLFile++ != '4')   ||
        (*pXLFile++ != '5')   ||
        (*pXLFile++ != 'X')    )
        return NULL;

    while (*pXLFile == '@' && !bBreak)
    {
        //
        // Broken PJL command. Return FALSE.
        //
        if (*pXLFile == '@')
            pXLFile ++;

        if (strncmp(pXLFile, gcstrPJL, 3))
            return NULL;

        pXLFile = PSkipWord(pXLFile);

        switch (*pXLFile)
        {
        case 'C':
            if (!strncmp(pXLFile, gcstrCOMMENT, 7))
            {
                pXLFile = PSkipLine(pXLFile);

            }
            break;

        case 'E':
            if (!strncmp(pXLFile, gcstrENTER, 5))
            {
                pXLFile = PSkipWord(pXLFile);
                if (!strncmp(pXLFile, gcstrLANGUAGE, 8))
                {
                    pXLFile += 9;
                    if (!strncmp(pXLFile, gcstrPCLXL, 5))
                    {
                        bBreak = TRUE;
                        pXLFile = PSkipLine(pXLFile);
                    }
                }
            }
            break;

        case 'J':
            if (!strncmp(pXLFile, gcstrJOB, 3))
            {
                pXLFile = PSkipLine(pXLFile);

            }
            break;


        case 'S':
            if (!strncmp(pXLFile, gcstrSET, 3))
            {
                pXLFile = PSkipLine(pXLFile);

            }
            break;

        default:
            return NULL;
        }
    }

    return pXLFile;
}

PBYTE
PSkipWord(
        PBYTE pData)
{
    while (*pData != SP)
        pData++;

    while (*pData == SP)
        pData++;

    return pData;
}

PBYTE
PSkipLine(
        PBYTE pData)
{
    while (*pData != LF)
        pData ++;

    pData ++;

    return pData;
}

PBYTE
PSkipSpace(
        PBYTE pData)
{
    while (*pData == SP)
        pData ++;

    return pData;
}
PBYTE
PSkipWhiteSpace(
        PBYTE pData)
{
    while (*pData == NU ||
           *pData == SP ||
           *pData == HT ||
           *pData == LF ||
           *pData == VT ||
           *pData == HT ||
           *pData == CR)
    {
        pData++;
    }

    return pData;
}

PBYTE
PDecodeXL(
        PBYTE pData)
{
    SHORT sNumOfData, sI;
    DWORD dwI, dwNumOfData;
    BYTE ubType;

    switch(BinaryTagArray[*pData].TagType)
    {
        case NotUsed:
            printf("NotUsed(0x%x)\n\n",*pData);
            pData++;
            break;

        case WhiteSpace:
            pData = PSkipWhiteSpace(pData);
            break;

        case Operator:
            printf("%s\n\n",BinaryTagArray[*pData].pubTagName,*pData);
            pData++;
            break;

        case DataType:
            ubType = *pData;
            pData++;

            sNumOfData = 0;

            if (0xc0 <= ubType && ubType <= 0xc5)
            {
                //
                // One value
                //
                sNumOfData = 1;
            }
            else if (0xc8 <= ubType && ubType <= 0xcd)
            {
                //
                // Array
                //
                sNumOfData = 0;
            }
            else if (0xd0 <= ubType && ubType <= 0xd5)
            {
                //
                // Two values
                //
                sNumOfData = 2;
            }
            else if (0xe0 <= ubType && ubType <= 0xe5)
            {
                //
                // Four values
                //
                sNumOfData = 4;
            }

            printf("    (");

            if (sNumOfData)
            {
                while (sNumOfData-- > 0)
                {
                    switch(ubType%8)
                    {
                        case 0:
                            printf("%d", (BYTE)*pData);
                            pData++;
                            break;
                        case 1:
                            printf("%d", *(PUSHORT)pData);
                            pData+=2;
                            break;
                        case 2:
                            printf("%d", *(PULONG)pData);
                            pData+=4;
                            break;
                        case 3:
                            printf("%d", *(PSHORT)pData);
                            pData+=2;
                            break;
                        case 4:
                            printf("%d", *(PLONG)pData);
                            pData+=4;
                            break;
                        case 5:
                            printf("0x%x", *(PDWORD)pData);
                            pData+=4;
                            break;
                    }
                    if (sNumOfData >= 1)
                        printf(", ");
                }
            }
            else
            {
                if (*pData == 0xc0)
                {
                    pData++;
                    sNumOfData = *pData;
                    pData ++;
                }
                else if (*pData == 0xc1)
                {
                    pData++;
                    sNumOfData = *(PUSHORT)pData;
                    pData += 2;
                }

                switch(ubType%8)
                {
                    case 0:
                        for (sI = 0; sI < sNumOfData; sI ++, pData++)
                            printf("%c", *pData);
                        break;
                    case 1:
                        for (sI = 0; sI < sNumOfData; sI ++, pData+=2)
                            printf("%d", *(PUSHORT)pData);
                        break;
                    case 2:
                        for (sI = 0; sI < sNumOfData; sI ++, pData+=4)
                            printf("%d", *(PULONG)pData);
                        break;
                    case 3:
                        for (sI = 0; sI < sNumOfData; sI ++, pData+=2)
                            printf("%d", *(PSHORT)pData);
                        break;
                    case 4:
                        for (sI = 0; sI < sNumOfData; sI ++, pData+=4)
                            printf("%d", *(PLONG)pData);
                        break;
                    case 5:
                        for (sI = 0; sI < sNumOfData; sI ++, pData+=4)
                            printf("0x%x", *(PDWORD)pData);
                        break;
                }

            }

            printf(")");
            break;

        case Attribute:
            if (*pData == 0xf8)
            {
                printf(":%s\n",pubAttributeID[*(PBYTE)(pData+1)]);
                pData += 2;
            }
            else if (*pData == 0xf9)
            {
                printf(":%s\n",pubAttributeID[*(PDWORD)(pData+1)]);
                pData+=2;
            }
            break;
                        
        case EmbedData:
            printf("Hex(");
            if (*pData == 0xfa)
            {
                pData++;
                dwNumOfData = *(PDWORD)pData;
                pData +=4;
                for (dwI = 0; dwI < dwNumOfData; dwI ++, pData++)
                {
                    printf("%x",*pData);
                }
            }
            else if (*pData == 0xfb)
            {
                pData++;
                sNumOfData = *(PBYTE)pData;
                pData++;
                for (sI = 0; sI < sNumOfData; sI ++, pData++)
                {
                    printf("%x",*pData);
                }
            }
            printf(")");
            break;

        case Binding:
            printf("Binding: ");
            if (*pData == 0x27)
                printf("ASCII\n");
            else if (*pData == 0x28)
                printf("binary - high byte first\n");
            else if (*pData == 0x29)
                printf("binary - low byte first\n");

            pData ++;
            printf("Comment:");
            while (*pData != LF)
            {
                printf("%c", *pData);
                pData++;
            }
            printf("\n");
            break;

        case Reserved:
            printf("Reserved\n");
            pData ++;
            break;
    }

    return pData;
}