~ubuntu-branches/ubuntu/feisty/fonttools/feisty

« back to all changes in this revision

Viewing changes to Lib/fontTools/ttLib/tables/ttProgram.py

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Fok
  • Date: 2003-11-18 00:53:59 UTC
  • Revision ID: james.westby@ubuntu.com-20031118005359-pqirsxbgdz0f0xmx
Tags: upstream-1.99+2.0b1+cvs20031014
ImportĀ upstreamĀ versionĀ 1.99+2.0b1+cvs20031014

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
"""ttLib.tables.ttProgram.py -- Assembler/disassembler for TrueType bytecode programs."""
 
2
 
 
3
import array
 
4
import re, string
 
5
from fontTools.misc.textTools import num2binary, binary2num, readHex
 
6
 
 
7
# first, the list of instructions that eat bytes or words from the instruction stream
 
8
 
 
9
streamInstructions = [
 
10
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
11
#       opcode     mnemonic argBits         descriptive name pops pushes        eats from instruction stream          pushes
 
12
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
13
        (0x40,    'NPUSHB',     0,             'PushNBytes',  0, -1), #                      n, b1, b2,...bn      b1,b2...bn
 
14
        (0x41,    'NPUSHW',     0,             'PushNWords',  0, -1), #                       n, w1, w2,...w      w1,w2...wn
 
15
        (0xb0,     'PUSHB',     3,              'PushBytes',  0, -1), #                          b0, b1,..bn  b0, b1, ...,bn
 
16
        (0xb8,     'PUSHW',     3,              'PushWords',  0, -1), #                           w0,w1,..wn   w0 ,w1, ...wn
 
17
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
18
]
 
19
 
 
20
 
 
21
# next, the list of "normal" instructions
 
22
 
 
23
instructions = [
 
24
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
25
#       opcode     mnemonic  argBits        descriptive name pops pushes                                pops          pushes
 
26
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
27
        (0x7f,        'AA',     0,            'AdjustAngle',  1,  0), #                                    p               -
 
28
        (0x64,       'ABS',     0,               'Absolute',  1,  1), #                                    n             |n|
 
29
        (0x60,       'ADD',     0,                    'Add',  2,  1), #                               n2, n1       (n1 + n2)
 
30
        (0x27,  'ALIGNPTS',     0,               'AlignPts',  2,  0), #                               p2, p1               -
 
31
        (0x3c,   'ALIGNRP',     0,        'AlignRelativePt', -1,  0), #             p1, p2, ... , ploopvalue               -
 
32
        (0x5a,       'AND',     0,             'LogicalAnd',  2,  1), #                               e2, e1               b
 
33
        (0x2b,      'CALL',     0,           'CallFunction',  1,  0), #                                    f               -
 
34
        (0x67,   'CEILING',     0,                'Ceiling',  1,  1), #                                    n         ceil(n)
 
35
        (0x25,    'CINDEX',     0,        'CopyXToTopStack',  1,  1), #                                    k              ek
 
36
        (0x22,     'CLEAR',     0,             'ClearStack', -1,  0), #               all items on the stack               -
 
37
        (0x4f,     'DEBUG',     0,              'DebugCall',  1,  0), #                                    n               -
 
38
        (0x73,   'DELTAC1',     0,       'DeltaExceptionC1', -1,  0), #    argn, cn, argn-1,cn-1, , arg1, c1               -
 
39
        (0x74,   'DELTAC2',     0,       'DeltaExceptionC2', -1,  0), #    argn, cn, argn-1,cn-1, , arg1, c1               -
 
40
        (0x75,   'DELTAC3',     0,       'DeltaExceptionC3', -1,  0), #    argn, cn, argn-1,cn-1, , arg1, c1               -
 
41
        (0x5d,   'DELTAP1',     0,       'DeltaExceptionP1', -1,  0), #   argn, pn, argn-1, pn-1, , arg1, p1               -
 
42
        (0x71,   'DELTAP2',     0,       'DeltaExceptionP2', -1,  0), #   argn, pn, argn-1, pn-1, , arg1, p1               -
 
43
        (0x72,   'DELTAP3',     0,       'DeltaExceptionP3', -1,  0), #   argn, pn, argn-1, pn-1, , arg1, p1               -
 
44
        (0x24,     'DEPTH',     0,          'GetDepthStack',  0,  1), #                                    -               n
 
45
        (0x62,       'DIV',     0,                 'Divide',  2,  1), #                               n2, n1   (n1 * 64)/ n2
 
46
        (0x20,       'DUP',     0,      'DuplicateTopStack',  1,  2), #                                    e            e, e
 
47
        (0x59,       'EIF',     0,                  'EndIf',  0,  0), #                                    -               -
 
48
        (0x1b,      'ELSE',     0,                   'Else',  0,  0), #                                    -               -
 
49
        (0x2d,      'ENDF',     0,  'EndFunctionDefinition',  0,  0), #                                    -               -
 
50
        (0x54,        'EQ',     0,                  'Equal',  2,  1), #                               e2, e1               b
 
51
        (0x57,      'EVEN',     0,                   'Even',  1,  1), #                                    e               b
 
52
        (0x2c,      'FDEF',     0,     'FunctionDefinition',  1,  0), #                                    f               -
 
53
        (0x4e,   'FLIPOFF',     0,         'SetAutoFlipOff',  0,  0), #                                    -               -
 
54
        (0x4d,    'FLIPON',     0,          'SetAutoFlipOn',  0,  0), #                                    -               -
 
55
        (0x80,    'FLIPPT',     0,              'FlipPoint', -1,  0), #              p1, p2, ..., ploopvalue               -
 
56
        (0x82, 'FLIPRGOFF',     0,           'FlipRangeOff',  2,  0), #                                 h, l               -
 
57
        (0x81,  'FLIPRGON',     0,            'FlipRangeOn',  2,  0), #                                 h, l               -
 
58
        (0x66,     'FLOOR',     0,                  'Floor',  1,  1), #                                    n        floor(n)
 
59
        (0x46,        'GC',     1,      'GetCoordOnPVector',  1,  1), #                                    p               c
 
60
        (0x88,   'GETINFO',     0,                'GetInfo',  1,  1), #                             selector          result
 
61
        (0x0d,       'GFV',     0,             'GetFVector',  0,  2), #                                    -          px, py
 
62
        (0x0c,       'GPV',     0,             'GetPVector',  0,  2), #                                    -          px, py
 
63
        (0x52,        'GT',     0,            'GreaterThan',  2,  1), #                               e2, e1               b
 
64
        (0x53,      'GTEQ',     0,     'GreaterThanOrEqual',  2,  1), #                               e2, e1               b
 
65
        (0x89,      'IDEF',     0,  'InstructionDefinition',  1,  0), #                                    f               -
 
66
        (0x58,        'IF',     0,                     'If',  1,  0), #                                    e               -
 
67
        (0x8e,  'INSTCTRL',     0,    'SetInstrExecControl',  2,  0), #                                 s, v               -
 
68
        (0x39,        'IP',     0,         'InterpolatePts', -1,  0), #             p1, p2, ... , ploopvalue               -
 
69
        (0x0f,     'ISECT',     0,      'MovePtToIntersect',  5,  0), #                    a1, a0, b1, b0, p               -
 
70
        (0x30,       'IUP',     1,      'InterpolateUntPts',  0,  0), #                                    -               -
 
71
        (0x1c,      'JMPR',     0,                   'Jump',  1,  0), #                               offset               -
 
72
        (0x79,      'JROF',     0,    'JumpRelativeOnFalse',  2,  0), #                            e, offset               -
 
73
        (0x78,      'JROT',     0,     'JumpRelativeOnTrue',  2,  0), #                            e, offset               -
 
74
        (0x2a,  'LOOPCALL',     0,    'LoopAndCallFunction',  2,  0), #                             f, count               -
 
75
        (0x50,        'LT',     0,               'LessThan',  2,  1), #                               e2, e1               b
 
76
        (0x51,      'LTEQ',     0,        'LessThenOrEqual',  2,  1), #                               e2, e1               b
 
77
        (0x8b,       'MAX',     0,                'Maximum',  2,  1), #                               e2, e1     max(e1, e2)
 
78
        (0x49,        'MD',     1,        'MeasureDistance',  2,  1), #                                p2,p1               d
 
79
        (0x2e,      'MDAP',     1,        'MoveDirectAbsPt',  1,  0), #                                    p               -
 
80
        (0xc0,      'MDRP',     5,        'MoveDirectRelPt',  1,  0), #                                    p               -
 
81
        (0x3e,      'MIAP',     1,      'MoveIndirectAbsPt',  2,  0), #                                 n, p               -
 
82
        (0x8c,       'MIN',     0,                'Minimum',  2,  1), #                               e2, e1     min(e1, e2)
 
83
        (0x26,    'MINDEX',     0,        'MoveXToTopStack',  1,  1), #                                    k              ek
 
84
        (0xe0,      'MIRP',     5,      'MoveIndirectRelPt',  2,  0), #                                 n, p               -
 
85
        (0x4b,     'MPPEM',     0,      'MeasurePixelPerEm',  0,  1), #                                    -            ppem
 
86
        (0x4c,       'MPS',     0,       'MeasurePointSize',  0,  1), #                                    -       pointSize
 
87
        (0x3a,     'MSIRP',     1,    'MoveStackIndirRelPt',  2,  0), #                                 d, p               -
 
88
        (0x63,       'MUL',     0,               'Multiply',  2,  1), #                               n2, n1    (n1 * n2)/64
 
89
        (0x65,       'NEG',     0,                 'Negate',  1,  1), #                                    n              -n
 
90
        (0x55,       'NEQ',     0,               'NotEqual',  2,  1), #                               e2, e1               b
 
91
        (0x5c,       'NOT',     0,             'LogicalNot',  1,  1), #                                    e       ( not e )
 
92
        (0x6c,    'NROUND',     2,                'NoRound',  1,  1), #                                   n1              n2
 
93
        (0x56,       'ODD',     0,                    'Odd',  1,  1), #                                    e               b
 
94
        (0x5b,        'OR',     0,              'LogicalOr',  2,  1), #                               e2, e1               b
 
95
        (0x21,       'POP',     0,            'PopTopStack',  1,  0), #                                    e               -
 
96
        (0x45,      'RCVT',     0,                'ReadCVT',  1,  1), #                             location           value
 
97
        (0x7d,      'RDTG',     0,        'RoundDownToGrid',  0,  0), #                                    -               -
 
98
        (0x7a,      'ROFF',     0,               'RoundOff',  0,  0), #                                    -               -
 
99
        (0x8a,      'ROLL',     0,      'RollTopThreeStack',  3,  3), #                                a,b,c           b,a,c
 
100
        (0x68,     'ROUND',     2,                  'Round',  1,  1), #                                   n1              n2
 
101
        (0x43,        'RS',     0,              'ReadStore',  1,  1), #                                    n               v
 
102
        (0x3d,      'RTDG',     0,      'RoundToDoubleGrid',  0,  0), #                                    -               -
 
103
        (0x18,       'RTG',     0,            'RoundToGrid',  0,  0), #                                    -               -
 
104
        (0x19,      'RTHG',     0,        'RoundToHalfGrid',  0,  0), #                                    -               -
 
105
        (0x7c,      'RUTG',     0,          'RoundUpToGrid',  0,  0), #                                    -               -
 
106
        (0x77,  'S45ROUND',     0,    'SuperRound45Degrees',  1,  0), #                                    n               -
 
107
        (0x7e,     'SANGW',     0,         'SetAngleWeight',  1,  0), #                               weight               -
 
108
        (0x85,  'SCANCTRL',     0,  'ScanConversionControl',  1,  0), #                                    n               -
 
109
        (0x8d,  'SCANTYPE',     0,               'ScanType',  1,  0), #                                    n               -
 
110
        (0x48,      'SCFS',     0,    'SetCoordFromStackFP',  2,  0), #                                 c, p               -
 
111
        (0x1d,    'SCVTCI',     0,            'SetCVTCutIn',  1,  0), #                                    n               -
 
112
        (0x5e,       'SDB',     0,   'SetDeltaBaseInGState',  1,  0), #                                    n               -
 
113
        (0x86,    'SDPVTL',     1,   'SetDualPVectorToLine',  2,  0), #                               p2, p1               -
 
114
        (0x5f,       'SDS',     0,  'SetDeltaShiftInGState',  1,  0), #                                    n               -
 
115
        (0x0b,     'SFVFS',     0,    'SetFVectorFromStack',  2,  0), #                                 y, x               -
 
116
        (0x04,    'SFVTCA',     1,       'SetFVectorToAxis',  0,  0), #                                    -               -
 
117
        (0x08,     'SFVTL',     1,       'SetFVectorToLine',  2,  0), #                               p2, p1               -
 
118
        (0x0e,    'SFVTPV',     0,    'SetFVectorToPVector',  0,  0), #                                    -               -
 
119
        (0x34,       'SHC',     1,   'ShiftContourByLastPt',  1,  0), #                                    c               -
 
120
        (0x32,       'SHP',     1,  'ShiftPointByLastPoint', -1,  0), #              p1, p2, ..., ploopvalue               -
 
121
        (0x38,     'SHPIX',     0,       'ShiftZoneByPixel', -1,  0), #           d, p1, p2, ..., ploopvalue               -
 
122
        (0x36,       'SHZ',     1,   'ShiftZoneByLastPoint',  1,  0), #                                    e               -
 
123
        (0x17,     'SLOOP',     0,        'SetLoopVariable',  1,  0), #                                    n               -
 
124
        (0x1a,       'SMD',     0,     'SetMinimumDistance',  1,  0), #                             distance               -
 
125
        (0x0a,     'SPVFS',     0,    'SetPVectorFromStack',  2,  0), #                                 y, x               -
 
126
        (0x02,    'SPVTCA',     1,       'SetPVectorToAxis',  0,  0), #                                    -               -
 
127
        (0x06,     'SPVTL',     1,       'SetPVectorToLine',  2,  0), #                               p2, p1               -
 
128
        (0x76,    'SROUND',     0,             'SuperRound',  1,  0), #                                    n               -
 
129
        (0x10,      'SRP0',     0,           'SetRefPoint0',  1,  0), #                                    p               -
 
130
        (0x11,      'SRP1',     0,           'SetRefPoint1',  1,  0), #                                    p               -
 
131
        (0x12,      'SRP2',     0,           'SetRefPoint2',  1,  0), #                                    p               -
 
132
        (0x1f,       'SSW',     0,         'SetSingleWidth',  1,  0), #                                    n               -
 
133
        (0x1e,     'SSWCI',     0,    'SetSingleWidthCutIn',  1,  0), #                                    n               -
 
134
        (0x61,       'SUB',     0,               'Subtract',  2,  1), #                               n2, n1       (n1 - n2)
 
135
        (0x00,     'SVTCA',     1,      'SetFPVectorToAxis',  0,  0), #                                    -               -
 
136
        (0x23,      'SWAP',     0,           'SwapTopStack',  2,  2), #                               e2, e1          e1, e2
 
137
        (0x13,      'SZP0',     0,        'SetZonePointer0',  1,  0), #                                    n               -
 
138
        (0x14,      'SZP1',     0,        'SetZonePointer1',  1,  0), #                                    n               -
 
139
        (0x15,      'SZP2',     0,        'SetZonePointer2',  1,  0), #                                    n               -
 
140
        (0x16,      'SZPS',     0,        'SetZonePointerS',  1,  0), #                                    n               -
 
141
        (0x29,       'UTP',     0,              'UnTouchPt',  1,  0), #                                    p               -
 
142
        (0x70,     'WCVTF',     0,       'WriteCVTInFUnits',  2,  0), #                                 n, l               -
 
143
        (0x44,     'WCVTP',     0,       'WriteCVTInPixels',  2,  0), #                                 v, l               -
 
144
        (0x42,        'WS',     0,             'WriteStore',  2,  0), #                                 v, l               -
 
145
#       ------  -----------  -----  ------------------------ ---  ------  ----------------------------------  --------------
 
146
]
 
147
 
 
148
 
 
149
def bitRepr(value, bits):
 
150
        s = ""
 
151
        for i in range(bits):
 
152
                s = "01"[value & 0x1] + s
 
153
                value = value >> 1
 
154
        return s
 
155
 
 
156
 
 
157
_mnemonicPat = re.compile("[A-Z][A-Z0-9]*$")
 
158
 
 
159
def _makeDict(instructionList):
 
160
        opcodeDict = {}
 
161
        mnemonicDict = {}
 
162
        for op, mnemonic, argBits, name, pops, pushes in instructionList:
 
163
                assert _mnemonicPat.match(mnemonic)
 
164
                mnemonicDict[mnemonic] = op, argBits, name
 
165
                if argBits:
 
166
                        argoffset = op
 
167
                        for i in range(1 << argBits):
 
168
                                opcodeDict[op+i] = mnemonic, argBits, argoffset, name
 
169
                else:
 
170
                                opcodeDict[op] = mnemonic, 0, 0, name
 
171
        return opcodeDict, mnemonicDict
 
172
 
 
173
streamOpcodeDict, streamMnemonicDict = _makeDict(streamInstructions)
 
174
opcodeDict, mnemonicDict = _makeDict(instructions)
 
175
 
 
176
tt_instructions_error = "TT instructions error"
 
177
 
 
178
 
 
179
_comment = r"/\*.*?\*/"
 
180
_instruction = r"([A-Z][A-Z0-9]*)\s*\[(.*?)\]"
 
181
_number = r"-?[0-9]+"
 
182
_token = "(%s)|(%s)|(%s)" % (_instruction, _number, _comment)
 
183
 
 
184
_tokenRE = re.compile(_token)
 
185
_whiteRE = re.compile(r"\s*")
 
186
 
 
187
_pushCountPat = re.compile(r"[A-Z][A-Z0-9]*\s*\[.*?\]\s*/\* ([0-9]*).*?\*/")
 
188
 
 
189
 
 
190
def _skipWhite(data, pos, _whiteRE=_whiteRE):
 
191
        m = _whiteRE.match(data, pos)
 
192
        newPos = m.regs[0][1]
 
193
        assert newPos >= pos
 
194
        return newPos
 
195
 
 
196
 
 
197
class Program:
 
198
        
 
199
        def __init__(self):
 
200
                pass
 
201
        
 
202
        def fromBytecode(self, bytecode):
 
203
                self.bytecode = array.array("B", bytecode)
 
204
                if hasattr(self, "assembly"):
 
205
                        del self.assembly
 
206
        
 
207
        def fromAssembly(self, assembly):
 
208
                self.assembly = assembly
 
209
                if hasattr(self, "bytecode"):
 
210
                        del self.bytecode
 
211
        
 
212
        def getBytecode(self):
 
213
                if not hasattr(self, "bytecode"):
 
214
                        self._assemble()
 
215
                return self.bytecode.tostring()
 
216
        
 
217
        def getAssembly(self):
 
218
                if not hasattr(self, "assembly"):
 
219
                        self._disassemble()
 
220
                return self.assembly
 
221
        
 
222
        def toXML(self, writer, ttFont):
 
223
                if ttFont.disassembleInstructions:
 
224
                        assembly = self.getAssembly()
 
225
                        writer.begintag("assembly")
 
226
                        writer.newline()
 
227
                        i = 0
 
228
                        nInstr = len(assembly)
 
229
                        while i < nInstr:
 
230
                                instr = assembly[i]
 
231
                                writer.write(instr)
 
232
                                writer.newline()
 
233
                                m = _pushCountPat.match(instr)
 
234
                                i = i + 1
 
235
                                if m:
 
236
                                        nValues = int(m.group(1))
 
237
                                        line = []
 
238
                                        j = 0
 
239
                                        for j in range(nValues):
 
240
                                                if j and not (j % 25):
 
241
                                                        writer.write(string.join(line, " "))
 
242
                                                        writer.newline()
 
243
                                                        line = []
 
244
                                                line.append(assembly[i+j])
 
245
                                        writer.write(string.join(line, " "))
 
246
                                        writer.newline()
 
247
                                        i = i + j + 1
 
248
                        writer.endtag("assembly")
 
249
                else:
 
250
                        writer.begintag("bytecode")
 
251
                        writer.newline()
 
252
                        writer.dumphex(self.getBytecode())
 
253
                        writer.endtag("bytecode")
 
254
        
 
255
        def fromXML(self, (name, attrs, content), ttFont):
 
256
                if name == "assembly":
 
257
                        self.fromAssembly(content)
 
258
                        self._assemble()
 
259
                        del self.assembly
 
260
                else:
 
261
                        assert name == "bytecode"
 
262
                        self.fromBytecode(readHex(content))
 
263
        
 
264
        def _assemble(self, 
 
265
                        skipWhite=_skipWhite, mnemonicDict=mnemonicDict, strip=string.strip,
 
266
                        binary2num=binary2num):
 
267
                assembly = self.assembly
 
268
                if type(assembly) == type([]):
 
269
                        assembly = string.join(assembly, "")
 
270
                bytecode = []
 
271
                push = bytecode.append
 
272
                lenAssembly = len(assembly)
 
273
                pos = skipWhite(assembly, 0)
 
274
                while pos < lenAssembly:
 
275
                        m = _tokenRE.match(assembly, pos)
 
276
                        if m is None:
 
277
                                raise tt_instructions_error, "Syntax error in TT program (%s)" % assembly[pos-5:pos+15]
 
278
                        dummy, mnemonic, arg, number, comment = m.groups()
 
279
                        pos = m.regs[0][1]
 
280
                        if comment:
 
281
                                continue
 
282
                        
 
283
                        arg = strip(arg)
 
284
                        if mnemonic not in ("NPUSHB", "NPUSHW", "PUSHB", "PUSHW"):
 
285
                                op, argBits, name = mnemonicDict[mnemonic]
 
286
                                if len(arg) <> argBits:
 
287
                                        raise tt_instructions_error, "Incorrect number of argument bits (%s[%s])" % (mnemonic, arg)
 
288
                                if arg:
 
289
                                        arg = binary2num(arg)
 
290
                                        push(op + arg)
 
291
                                else:
 
292
                                        push(op)
 
293
                        else:
 
294
                                args = []
 
295
                                while pos < lenAssembly:
 
296
                                        pos = skipWhite(assembly, pos)
 
297
                                        m = _tokenRE.match(assembly, pos)
 
298
                                        if m is None:
 
299
                                                raise tt_instructions_error, "Syntax error in TT program (%s)" % assembly[pos:pos+15]
 
300
                                        dummy, mnemonic, arg, number, comment = m.groups()
 
301
                                        if number is None and comment is None:
 
302
                                                break
 
303
                                        pos = m.regs[0][1]
 
304
                                        if comment is not None:
 
305
                                                continue
 
306
                                        args.append(int(number))
 
307
                                if max(args) > 255 or min(args) < 0:
 
308
                                        words = 1
 
309
                                        mnemonic = "PUSHW"
 
310
                                else:
 
311
                                        words = 0
 
312
                                        mnemonic = "PUSHB"
 
313
                                nArgs = len(args)
 
314
                                if nArgs <= 8:
 
315
                                        op, argBits, name = streamMnemonicDict[mnemonic]
 
316
                                        op = op + nArgs - 1
 
317
                                        push(op)
 
318
                                elif nArgs < 256:
 
319
                                        mnemonic = "N" + mnemonic
 
320
                                        op, argBits, name = streamMnemonicDict[mnemonic]
 
321
                                        push(op)
 
322
                                        push(nArgs)
 
323
                                else:
 
324
                                        raise tt_instructions_error, "More than 255 push arguments (%s)" % nArgs
 
325
                                if words:
 
326
                                        for value in args:
 
327
                                                push((value >> 8) & 0xff)
 
328
                                                push(value & 0xff)
 
329
                                else:
 
330
                                        for value in args:
 
331
                                                push(value)
 
332
                        pos = skipWhite(assembly, pos)
 
333
                
 
334
                if bytecode:
 
335
                        assert max(bytecode) < 256 and min(bytecode) >= 0
 
336
                self.bytecode = array.array("B", bytecode)
 
337
        
 
338
        def _disassemble(self):
 
339
                assembly = []
 
340
                i = 0
 
341
                bytecode = self.bytecode
 
342
                numBytecode = len(bytecode)
 
343
                while i < numBytecode:
 
344
                        op = bytecode[i]
 
345
                        arg = 0
 
346
                        try:
 
347
                                mnemonic, argBits, argoffset, name = opcodeDict[op]
 
348
                        except KeyError:
 
349
                                try:
 
350
                                        mnemonic, argBits, argoffset, name = streamOpcodeDict[op]
 
351
                                except KeyError:
 
352
                                        raise tt_instructions_error, "illegal opcode: 0x%.2x" % op
 
353
                                pushBytes = pushWords = 0
 
354
                                if argBits:
 
355
                                        if mnemonic == "PUSHB":
 
356
                                                pushBytes = op - argoffset + 1
 
357
                                        else:
 
358
                                                pushWords = op - argoffset + 1
 
359
                                else:
 
360
                                        i = i + 1
 
361
                                        if mnemonic == "NPUSHB":
 
362
                                                pushBytes = bytecode[i]
 
363
                                        else:
 
364
                                                pushWords = bytecode[i]
 
365
                                i = i + 1
 
366
                                nValues = pushBytes or pushWords
 
367
                                assert nValues > 0
 
368
                                if nValues == 1:
 
369
                                        assembly.append("%s[ ]  /* %s value pushed */" % (mnemonic, nValues))
 
370
                                else:
 
371
                                        assembly.append("%s[ ]  /* %s values pushed */" % (mnemonic, nValues))
 
372
                                for j in range(pushBytes):
 
373
                                        value = bytecode[i]
 
374
                                        assembly.append(`value`)
 
375
                                        i = i + 1
 
376
                                for j in range(pushWords):
 
377
                                        # cast to signed int16
 
378
                                        value = (bytecode[i] << 8) | bytecode[i+1]
 
379
                                        if value >= 0x8000:
 
380
                                                value = value - 0x10000
 
381
                                        assembly.append(`value`)
 
382
                                        i = i + 2
 
383
                        else:
 
384
                                if argBits:
 
385
                                        assembly.append(mnemonic + "[%s]" % num2binary(op - argoffset, argBits))
 
386
                                else:
 
387
                                        assembly.append(mnemonic + "[ ]")
 
388
                                i = i + 1
 
389
                self.assembly = assembly
 
390
 
 
391
 
 
392
if __name__ == "__main__":
 
393
        bc = """@;:9876543210/.-,+*)(\'&%$#"! \037\036\035\034\033\032\031\030\027\026\025\024\023\022\021\020\017\016\015\014\013\012\011\010\007\006\005\004\003\002\001\000,\001\260\030CXEj\260\031C`\260F#D#\020 \260FN\360M/\260\000\022\033!#\0213Y-,\001\260\030CX\260\005+\260\000\023K\260\024PX\261\000@8Y\260\006+\033!#\0213Y-,\001\260\030CXN\260\003%\020\362!\260\000\022M\033 E\260\004%\260\004%#Jad\260(RX!#\020\326\033\260\003%\020\362!\260\000\022YY-,\260\032CX!!\033\260\002%\260\002%I\260\003%\260\003%Ja d\260\020PX!!!\033\260\003%\260\003%I\260\000PX\260\000PX\270\377\3428!\033\260\0208!Y\033\260\000RX\260\0368!\033\270\377\3608!YYYY-,\001\260\030CX\260\005+\260\000\023K\260\024PX\271\000\000\377\3008Y\260\006+\033!#\0213Y-,N\001\212\020\261F\031CD\260\000\024\261\000F\342\260\000\025\271\000\000\377\3608\000\260\000<\260(+\260\002%\020\260\000<-,\001\030\260\000/\260\001\024\362\260\001\023\260\001\025M\260\000\022-,\001\260\030CX\260\005+\260\000\023\271\000\000\377\3408\260\006+\033!#\0213Y-,\001\260\030CXEdj#Edi\260\031Cd``\260F#D#\020 \260F\360/\260\000\022\033!! \212 \212RX\0213\033!!YY-,\001\261\013\012C#Ce\012-,\000\261\012\013C#C\013-,\000\260F#p\261\001F>\001\260F#p\261\002FE:\261\002\000\010\015-,\260\022+\260\002%E\260\002%Ej\260@\213`\260\002%#D!!!-,\260\023+\260\002%E\260\002%Ej\270\377\300\214`\260\002%#D!!!-,\260\000\260\022+!!!-,\260\000\260\023+!!!-,\001\260\006C\260\007Ce\012-, i\260@a\260\000\213 \261,\300\212\214\270\020\000b`+\014d#da\\X\260\003aY-,\261\000\003%EhT\260\034KPZX\260\003%E\260\003%E`h \260\004%#D\260\004%#D\033\260\003% Eh \212#D\260\003%Eh`\260\003%#DY-,\260\003% Eh \212#D\260\003%Edhe`\260\004%\260\001`#D-,\260\011CX\207!\300\033\260\022CX\207E\260\021+\260G#D\260Gz\344\033\003\212E\030i \260G#D\212\212\207 \260\240QX\260\021+\260G#D\260Gz\344\033!\260Gz\344YYY\030-, \212E#Eh`D-,EjB-,\001\030/-,\001\260\030CX\260\004%\260\004%Id#Edi\260@\213a \260\200bj\260\002%\260\002%a\214\260\031C`\260F#D!\212\020\260F\366!\033!!!!Y-,\001\260\030CX\260\002%E\260\002%Ed`j\260\003%Eja \260\004%Ej \212\213e\260\004%#D\214\260\003%#D!!\033 EjD EjDY-,\001 E\260\000U\260\030CZXEh#Ei\260@\213a \260\200bj \212#a \260\003%\213e\260\004%#D\214\260\003%#D!!\033!!\260\031+Y-,\001\212\212Ed#EdadB-,\260\004%\260\004%\260\031+\260\030CX\260\004%\260\004%\260\003%\260\033+\001\260\002%C\260@T\260\002%C\260\000TZX\260\003% E\260@aDY\260\002%C\260\000T\260\002%C\260@TZX\260\004% E\260@`DYY!!!!-,\001KRXC\260\002%E#aD\033!!Y-,\001KRXC\260\002%E#`D\033!!Y-,KRXED\033!!Y-,\001 \260\003%#I\260@`\260 c \260\000RX#\260\002%8#\260\002%e8\000\212c8\033!!!!!Y\001-,KPXED\033!!Y-,\001\260\005%\020# \212\365\000\260\001`#\355\354-,\001\260\005%\020# \212\365\000\260\001a#\355\354-,\001\260\006%\020\365\000\355\354-,F#F`\212\212F# F\212`\212a\270\377\200b# \020#\212\261KK\212pE` \260\000PX\260\001a\270\377\272\213\033\260F\214Y\260\020`h\001:-, E\260\003%FRX\260\002%F ha\260\003%\260\003%?#!8\033!\021Y-, E\260\003%FPX\260\002%F ha\260\003%\260\003%?#!8\033!\021Y-,\000\260\007C\260\006C\013-,\212\020\354-,\260\014CX!\033 F\260\000RX\270\377\3608\033\260\0208YY-, \260\000UX\270\020\000c\260\003%Ed\260\003%Eda\260\000SX\260\002\033\260@a\260\003Y%EiSXED\033!!Y\033!\260\002%E\260\002%Ead\260(QXED\033!!YY-,!!\014d#d\213\270@\000b-,!\260\200QX\014d#d\213\270 \000b\033\262\000@/+Y\260\002`-,!\260\300QX\014d#d\213\270\025Ub\033\262\000\200/+Y\260\002`-,\014d#d\213\270@\000b`#!-,KSX\260\004%\260\004%Id#Edi\260@\213a \260\200bj\260\002%\260\002%a\214\260F#D!\212\020\260F\366!\033!\212\021#\022 9/Y-,\260\002%\260\002%Id\260\300TX\270\377\3708\260\0108\033!!Y-,\260\023CX\003\033\002Y-,\260\023CX\002\033\003Y-,\260\012+#\020 <\260\027+-,\260\002%\270\377\3608\260(+\212\020# \320#\260\020+\260\005CX\300\033<Y \020\021\260\000\022\001-,KS#KQZX8\033!!Y-,\001\260\002%\020\320#\311\001\260\001\023\260\000\024\020\260\001<\260\001\026-,\001\260\000\023\260\001\260\003%I\260\003\0278\260\001\023-,KS#KQZX E\212`D\033!!Y-, 9/-"""
 
394
        
 
395
        p = Program()
 
396
        p.fromBytecode(bc)
 
397
        as = p.getAssembly()
 
398
        p.fromAssembly(as)
 
399
        print bc == p.getBytecode()
 
400