progs/gallium/python/retrace/interpreter.py

   1 #!/usr/bin/env python
   2 ##########################################################################
   3 #
   4 # Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   5 # All Rights Reserved.
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining a
   8 # copy of this software and associated documentation files (the
   9 # "Software"), to deal in the Software without restriction, including
  10 # without limitation the rights to use, copy, modify, merge, publish,
  11 # distribute, sub license, and/or sell copies of the Software, and to
  12 # permit persons to whom the Software is furnished to do so, subject to
  13 # the following conditions:
  14 #
  15 # The above copyright notice and this permission notice (including the
  16 # next paragraph) shall be included in all copies or substantial portions
  17 # of the Software.
  18 #
  19 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22 # IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23 # ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26 #
  27 ##########################################################################
  28
  29
  30 import sys
  31 import struct
  32
  33 import gallium
  34 import model
  35 import parse as parser
  36
  37
  38 try:
  39     from struct import unpack_from
  40 except ImportError:
  41     def unpack_from(fmt, buf, offset=0):
  42         size = struct.calcsize(fmt)
  43         return struct.unpack(fmt, buf[offset:offset + size])
  44
  45
  46 def make_image(surface, x=None, y=None, w=None, h=None):
  47     if x is None:
  48         x = 0
  49     if y is None:
  50         y = 0
  51     if w is None:
  52         w = surface.width - x
  53     if h is None:
  54         h = surface.height - y
  55     data = surface.get_tile_rgba8(x, y, surface.width, surface.height)
  56
  57     import Image
  58     outimage = Image.fromstring('RGBA', (w, h), data, "raw", 'RGBA', 0, 1)
  59     return outimage
  60
  61 def save_image(filename, surface, x=None, y=None, w=None, h=None):
  62     outimage = make_image(surface, x, y, w, h)
  63     outimage.save(filename, "PNG")
  64
  65 def show_image(surface, title, x=None, y=None, w=None, h=None):
  66     outimage = make_image(surface, x, y, w, h)
  67
  68     import Tkinter as tk
  69     from PIL import Image, ImageTk
  70     root = tk.Tk()
  71
  72     root.title(title)
  73
  74     image1 = ImageTk.PhotoImage(outimage)
  75     w = image1.width()
  76     h = image1.height()
  77     x = 100
  78     y = 100
  79     root.geometry("%dx%d+%d+%d" % (w, h, x, y))
  80     panel1 = tk.Label(root, image=image1)
  81     panel1.pack(side='top', fill='both', expand='yes')
  82     panel1.image = image1
  83     root.mainloop()
  84
  85
  86 class Struct:
  87     """C-like struct"""
  88
  89     # A basic Python class can pass as a C-like structure
  90     pass
  91
  92
  93 struct_factories = {
  94     "pipe_blend_color": gallium.BlendColor,
  95     "pipe_blend_state": gallium.Blend,
  96     #"pipe_clip_state": gallium.Clip,
  97     #"pipe_buffer": gallium.Buffer,
  98     "pipe_depth_state": gallium.Depth,
  99     "pipe_stencil_state": gallium.Stencil,
 100     "pipe_alpha_state": gallium.Alpha,
 101     "pipe_depth_stencil_alpha_state": gallium.DepthStencilAlpha,
 102     #"pipe_framebuffer_state": gallium.Framebuffer,
 103     "pipe_poly_stipple": gallium.PolyStipple,
 104     "pipe_rasterizer_state": gallium.Rasterizer,
 105     "pipe_sampler_state": gallium.Sampler,
 106     "pipe_scissor_state": gallium.Scissor,
 107     #"pipe_shader_state": gallium.Shader,
 108     #"pipe_vertex_buffer": gallium.VertexBuffer,
 109     "pipe_vertex_element": gallium.VertexElement,
 110     "pipe_viewport_state": gallium.Viewport,
 111     #"pipe_texture": gallium.Texture,
 112 }
 113
 114
 115 member_array_factories = {
 116     #"pipe_rasterizer_state": {"sprite_coord_mode": gallium.ByteArray},
 117     "pipe_poly_stipple": {"stipple": gallium.UnsignedArray},
 118     "pipe_viewport_state": {"scale": gallium.FloatArray, "translate": gallium.FloatArray},
 119     #"pipe_clip_state": {"ucp": gallium.FloatArray},
 120     "pipe_depth_stencil_alpha_state": {"stencil": gallium.StencilArray},
 121     "pipe_blend_color": {"color": gallium.FloatArray},
 122     "pipe_sampler_state": {"border_color": gallium.FloatArray},
 123 }
 124
 125
 126 class Translator(model.Visitor):
 127     """Translate model arguments into regular Python objects"""
 128
 129     def __init__(self, interpreter):
 130         self.interpreter = interpreter
 131         self.result = None
 132
 133     def visit(self, node):
 134         self.result = None
 135         node.visit(self)
 136         return self.result
 137
 138     def visit_literal(self, node):
 139         self.result = node.value
 140
 141     def visit_named_constant(self, node):
 142         # lookup the named constant in the gallium module
 143         self.result = getattr(gallium, node.name)
 144
 145     def visit_array(self, node):
 146         array = []
 147         for element in node.elements:
 148             array.append(self.visit(element))
 149         self.result = array
 150
 151     def visit_struct(self, node):
 152         struct_factory = struct_factories.get(node.name, Struct)
 153         struct = struct_factory()
 154         for member_name, member_node in node.members:
 155             member_value = self.visit(member_node)
 156             try:
 157                 array_factory = member_array_factories[node.name][member_name]
 158             except KeyError:
 159                 pass
 160             else:
 161                 assert isinstance(member_value, list)
 162                 array = array_factory(len(member_value))
 163                 for i in range(len(member_value)):
 164                     array[i] = member_value[i]
 165                 member_value = array
 166             #print node.name, member_name, member_value
 167             assert isinstance(struct, Struct) or hasattr(struct, member_name)
 168             setattr(struct, member_name, member_value)
 169         self.result = struct
 170
 171     def visit_pointer(self, node):
 172         self.result = self.interpreter.lookup_object(node.address)
 173
 174
 175 class Object:
 176
 177     def __init__(self, interpreter, real):
 178         self.interpreter = interpreter
 179         self.real = real
 180
 181
 182 class Global(Object):
 183
 184     def __init__(self, interpreter, real):
 185         self.interpreter = interpreter
 186         self.real = real
 187
 188     def pipe_winsys_create(self):
 189         return Winsys(self.interpreter, gallium.Device())
 190
 191     def pipe_screen_create(self, winsys=None):
 192         if winsys is None:
 193             real = gallium.Device()
 194         else:
 195             real = winsys.real
 196         return Screen(self.interpreter, real)
 197
 198     def pipe_context_create(self, screen):
 199         context = screen.real.context_create()
 200         return Context(self.interpreter, context)
 201
 202
 203 class Winsys(Object):
 204
 205     def __init__(self, interpreter, real):
 206         self.interpreter = interpreter
 207         self.real = real
 208
 209     def get_name(self):
 210         pass
 211
 212     def user_buffer_create(self, data, size):
 213         # We don't really care to distinguish between user and regular buffers
 214         buffer = self.real.buffer_create(size,
 215                                          4,
 216                                          gallium.PIPE_BUFFER_USAGE_CPU_READ |
 217                                          gallium.PIPE_BUFFER_USAGE_CPU_WRITE )
 218         assert size == len(data)
 219         buffer.write(data)
 220         return buffer
 221
 222     def buffer_create(self, alignment, usage, size):
 223         return self.real.buffer_create(size, alignment, usage)
 224
 225     def buffer_destroy(self, buffer):
 226         pass
 227
 228     def buffer_write(self, buffer, data, size):
 229         assert size == len(data)
 230         buffer.write(data)
 231
 232     def fence_finish(self, fence, flags):
 233         pass
 234
 235     def fence_reference(self, dst, src):
 236         pass
 237
 238     def flush_frontbuffer(self, surface):
 239         pass
 240
 241     def surface_alloc(self):
 242         return None
 243
 244     def surface_release(self, surface):
 245         pass
 246
 247
 248 class Transfer:
 249
 250     def __init__(self, surface, x, y, w, h):
 251         self.surface = surface
 252         self.x = x
 253         self.y = y
 254         self.w = w
 255         self.h = h
 256
 257
 258 class Screen(Object):
 259
 260     def destroy(self):
 261         pass
 262
 263     def get_name(self):
 264         pass
 265
 266     def get_vendor(self):
 267         pass
 268
 269     def get_param(self, param):
 270         pass
 271
 272     def get_paramf(self, param):
 273         pass
 274
 275     def context_create(self):
 276         context = self.real.context_create()
 277         return Context(self.interpreter, context)
 278
 279     def is_format_supported(self, format, target, tex_usage, geom_flags):
 280         return self.real.is_format_supported(format, target, tex_usage, geom_flags)
 281
 282     def texture_create(self, templat):
 283         return self.real.texture_create(
 284             format = templat.format,
 285             width = templat.width,
 286             height = templat.height,
 287             depth = templat.depth,
 288             last_level = templat.last_level,
 289             target = templat.target,
 290             tex_usage = templat.tex_usage,
 291         )
 292
 293     def texture_destroy(self, texture):
 294         self.interpreter.unregister_object(texture)
 295
 296     def texture_release(self, surface):
 297         pass
 298
 299     def get_tex_surface(self, texture, face, level, zslice, usage):
 300         if texture is None:
 301             return None
 302         return texture.get_surface(face, level, zslice)
 303
 304     def tex_surface_destroy(self, surface):
 305         self.interpreter.unregister_object(surface)
 306
 307     def tex_surface_release(self, surface):
 308         pass
 309
 310     def surface_write(self, surface, data, stride, size):
 311         if surface is None:
 312             return
 313 #        assert surface.nblocksy * stride == size
 314         surface.put_tile_raw(0, 0, surface.width, surface.height, data, stride)
 315
 316     def get_tex_transfer(self, texture, face, level, zslice, usage, x, y, w, h):
 317         if texture is None:
 318             return None
 319         transfer = Transfer(texture.get_surface(face, level, zslice), x, y, w, h)
 320         if transfer and usage & gallium.PIPE_TRANSFER_READ:
 321             if self.interpreter.options.all:
 322                 self.interpreter.present(transfer.surface, 'transf_read', x, y, w, h)
 323         return transfer
 324
 325     def tex_transfer_destroy(self, transfer):
 326         self.interpreter.unregister_object(transfer)
 327
 328     def transfer_write(self, transfer, stride, data, size):
 329         if transfer is None:
 330             return
 331         transfer.surface.put_tile_raw(transfer.x, transfer.y, transfer.w, transfer.h, data, stride)
 332         if self.interpreter.options.all:
 333             self.interpreter.present(transfer.surface, 'transf_write', transfer.x, transfer.y, transfer.w, transfer.h)
 334
 335     def user_buffer_create(self, data, size):
 336         # We don't really care to distinguish between user and regular buffers
 337         buffer = self.real.buffer_create(size,
 338                                          4,
 339                                          gallium.PIPE_BUFFER_USAGE_CPU_READ |
 340                                          gallium.PIPE_BUFFER_USAGE_CPU_WRITE )
 341         assert size == len(data)
 342         buffer.write(data)
 343         return buffer
 344
 345     def buffer_create(self, alignment, usage, size):
 346         return self.real.buffer_create(size, alignment, usage)
 347
 348     def buffer_destroy(self, buffer):
 349         pass
 350
 351     def buffer_write(self, buffer, data, size, offset=0):
 352         assert size == len(data)
 353         buffer.write(data)
 354
 355     def fence_finish(self, fence, flags):
 356         pass
 357
 358     def fence_reference(self, dst, src):
 359         pass
 360
 361     def flush_frontbuffer(self, surface):
 362         pass
 363
 364
 365 class Context(Object):
 366
 367     def __init__(self, interpreter, real):
 368         Object.__init__(self, interpreter, real)
 369         self.cbufs = []
 370         self.zsbuf = None
 371         self.vbufs = []
 372         self.velems = []
 373         self.dirty = False
 374
 375     def destroy(self):
 376         pass
 377
 378     def create_blend_state(self, state):
 379         if isinstance(state, str):
 380             state = gallium.Blend(state)
 381             sys.stdout.write('\t%s\n' % state)
 382         return state
 383
 384     def bind_blend_state(self, state):
 385         if state is not None:
 386             self.real.set_blend(state)
 387
 388     def delete_blend_state(self, state):
 389         pass
 390
 391     def create_sampler_state(self, state):
 392         return state
 393
 394     def delete_sampler_state(self, state):
 395         pass
 396
 397     def bind_vertex_sampler_states(self, num_states, states):
 398         for i in range(num_states):
 399             self.real.set_vertex_sampler(i, states[i])
 400
 401     def bind_fragment_sampler_states(self, num_states, states):
 402         for i in range(num_states):
 403             self.real.set_fragment_sampler(i, states[i])
 404
 405     def create_rasterizer_state(self, state):
 406         return state
 407
 408     def bind_rasterizer_state(self, state):
 409         if state is not None:
 410             self.real.set_rasterizer(state)
 411
 412     def delete_rasterizer_state(self, state):
 413         pass
 414
 415     def create_depth_stencil_alpha_state(self, state):
 416         return state
 417
 418     def bind_depth_stencil_alpha_state(self, state):
 419         if state is not None:
 420             self.real.set_depth_stencil_alpha(state)
 421
 422     def delete_depth_stencil_alpha_state(self, state):
 423         pass
 424
 425     def create_fs_state(self, state):
 426         tokens = str(state.tokens)
 427         shader = gallium.Shader(tokens)
 428         return shader
 429
 430     create_vs_state = create_fs_state
 431
 432     def bind_fs_state(self, state):
 433         self.real.set_fragment_shader(state)
 434
 435     def bind_vs_state(self, state):
 436         self.real.set_vertex_shader(state)
 437
 438     def delete_fs_state(self, state):
 439         pass
 440
 441     delete_vs_state = delete_fs_state
 442
 443     def set_blend_color(self, state):
 444         self.real.set_blend_color(state)
 445
 446     def set_stencil_ref(self, state):
 447         self.real.set_stencil_ref(state)
 448
 449     def set_clip_state(self, state):
 450         _state = gallium.Clip()
 451         _state.nr = state.nr
 452         if state.nr:
 453             # FIXME
 454             ucp = gallium.FloatArray(gallium.PIPE_MAX_CLIP_PLANES*4)
 455             for i in range(len(state.ucp)):
 456                 for j in range(len(state.ucp[i])):
 457                     ucp[i*4 + j] = state.ucp[i][j]
 458             _state.ucp = ucp
 459         self.real.set_clip(_state)
 460
 461     def dump_constant_buffer(self, buffer):
 462         if not self.interpreter.verbosity(2):
 463             return
 464
 465         data = buffer.read()
 466         format = '4f'
 467         index = 0
 468         for offset in range(0, len(data), struct.calcsize(format)):
 469             x, y, z, w = unpack_from(format, data, offset)
 470             sys.stdout.write('\tCONST[%2u] = {%10.4f, %10.4f, %10.4f, %10.4f}\n' % (index, x, y, z, w))
 471             index += 1
 472         sys.stdout.flush()
 473
 474     def set_constant_buffer(self, shader, index, buffer):
 475         if buffer is not None:
 476             self.real.set_constant_buffer(shader, index, buffer)
 477
 478             self.dump_constant_buffer(buffer)
 479
 480     def set_framebuffer_state(self, state):
 481         _state = gallium.Framebuffer()
 482         _state.width = state.width
 483         _state.height = state.height
 484         _state.nr_cbufs = state.nr_cbufs
 485         for i in range(len(state.cbufs)):
 486             _state.set_cbuf(i, state.cbufs[i])
 487         _state.set_zsbuf(state.zsbuf)
 488         self.real.set_framebuffer(_state)
 489
 490         self.cbufs = state.cbufs
 491         self.zsbuf = state.zsbuf
 492
 493     def set_polygon_stipple(self, state):
 494         self.real.set_polygon_stipple(state)
 495
 496     def set_scissor_state(self, state):
 497         self.real.set_scissor(state)
 498
 499     def set_viewport_state(self, state):
 500         self.real.set_viewport(state)
 501
 502     def set_fragment_sampler_textures(self, num_textures, textures):
 503         for i in range(num_textures):
 504             self.real.set_fragment_sampler_texture(i, textures[i])
 505
 506     def set_vertex_sampler_textures(self, num_textures, textures):
 507         for i in range(num_textures):
 508             self.real.set_vertex_sampler_texture(i, textures[i])
 509
 510     def set_vertex_buffers(self, num_buffers, buffers):
 511         self.vbufs = buffers[0:num_buffers]
 512         for i in range(num_buffers):
 513             vbuf = buffers[i]
 514             self.real.set_vertex_buffer(
 515                 i,
 516                 stride = vbuf.stride,
 517                 max_index = vbuf.max_index,
 518                 buffer_offset = vbuf.buffer_offset,
 519                 buffer = vbuf.buffer,
 520             )
 521
 522     def set_vertex_elements(self, num_elements, elements):
 523         self.velems = elements[0:num_elements]
 524         for i in range(num_elements):
 525             self.real.set_vertex_element(i, elements[i])
 526         self.real.set_vertex_elements(num_elements)
 527
 528     def dump_vertices(self, start, count):
 529         if not self.interpreter.verbosity(2):
 530             return
 531
 532         for index in range(start, start + count):
 533             if index >= start + 16:
 534                 sys.stdout.write('\t...\n')
 535                 break
 536             sys.stdout.write('\t{\n')
 537             for velem in self.velems:
 538                 vbuf = self.vbufs[velem.vertex_buffer_index]
 539
 540                 offset = vbuf.buffer_offset + velem.src_offset + vbuf.stride*index
 541                 format = {
 542                     gallium.PIPE_FORMAT_R32_FLOAT: 'f',
 543                     gallium.PIPE_FORMAT_R32G32_FLOAT: '2f',
 544                     gallium.PIPE_FORMAT_R32G32B32_FLOAT: '3f',
 545                     gallium.PIPE_FORMAT_R32G32B32A32_FLOAT: '4f',
 546                     gallium.PIPE_FORMAT_A8R8G8B8_UNORM: '4B',
 547                     gallium.PIPE_FORMAT_R8G8B8A8_UNORM: '4B',
 548                     gallium.PIPE_FORMAT_R16G16B16_SNORM: '3h',
 549                 }[velem.src_format]
 550
 551                 data = vbuf.buffer.read()
 552                 values = unpack_from(format, data, offset)
 553                 sys.stdout.write('\t\t{' + ', '.join(map(str, values)) + '},\n')
 554                 assert len(values) == velem.nr_components
 555             sys.stdout.write('\t},\n')
 556         sys.stdout.flush()
 557
 558     def dump_indices(self, ibuf, isize, start, count):
 559         if not self.interpreter.verbosity(2):
 560             return
 561
 562         format = {
 563             1: 'B',
 564             2: 'H',
 565             4: 'I',
 566         }[isize]
 567
 568         assert struct.calcsize(format) == isize
 569
 570         data = ibuf.read()
 571         maxindex, minindex = 0, 0xffffffff
 572
 573         sys.stdout.write('\t{\n')
 574         for i in range(start, start + count):
 575             if i >= start + 16 and not self.interpreter.verbosity(3):
 576                 sys.stdout.write('\t...\n')
 577                 break
 578             offset = i*isize
 579             index, = unpack_from(format, data, offset)
 580             sys.stdout.write('\t\t%u,\n' % index)
 581             minindex = min(minindex, index)
 582             maxindex = max(maxindex, index)
 583         sys.stdout.write('\t},\n')
 584         sys.stdout.flush()
 585
 586         return minindex, maxindex
 587
 588     def draw_arrays(self, mode, start, count):
 589         self.dump_vertices(start, count)
 590
 591         self.real.draw_arrays(mode, start, count)
 592         self._set_dirty()
 593
 594     def draw_elements(self, indexBuffer, indexSize, mode, start, count):
 595         if self.interpreter.verbosity(2):
 596             minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
 597             self.dump_vertices(minindex, maxindex - minindex)
 598
 599         self.real.draw_elements(indexBuffer, indexSize, mode, start, count)
 600         self._set_dirty()
 601
 602     def draw_range_elements(self, indexBuffer, indexSize, minIndex, maxIndex, mode, start, count):
 603         if self.interpreter.verbosity(2):
 604             minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
 605             minindex = min(minindex, minIndex)
 606             maxindex = min(maxindex, maxIndex)
 607             self.dump_vertices(minindex, maxindex - minindex)
 608
 609         self.real.draw_range_elements(indexBuffer, indexSize, minIndex, maxIndex, mode, start, count)
 610         self._set_dirty()
 611
 612     def surface_copy(self, dest, destx, desty, src, srcx, srcy, width, height):
 613         if dest is not None and src is not None:
 614             if self.interpreter.options.all:
 615                 self.interpreter.present(src, 'surface_copy_src', srcx, srcy, width, height)
 616             self.real.surface_copy(dest, destx, desty, src, srcx, srcy, width, height)
 617             if dest in self.cbufs:
 618                 self._set_dirty()
 619                 flags = gallium.PIPE_FLUSH_FRAME
 620             else:
 621                 flags = 0
 622             self.flush(flags)
 623             if self.interpreter.options.all:
 624                 self.interpreter.present(dest, 'surface_copy_dest', destx, desty, width, height)
 625
 626     def is_texture_referenced(self, texture, face, level):
 627         #return self.real.is_texture_referenced(format, texture, face, level)
 628         pass
 629
 630     def is_buffer_referenced(self, buf):
 631         #return self.real.is_buffer_referenced(format, buf)
 632         pass
 633
 634     def _set_dirty(self):
 635         if self.interpreter.options.step:
 636             self._present()
 637         else:
 638             self.dirty = True
 639
 640     def flush(self, flags):
 641         self.real.flush(flags)
 642         if self.dirty:
 643             if flags & gallium.PIPE_FLUSH_FRAME:
 644                 self._present()
 645             self.dirty = False
 646         return None
 647
 648     def clear(self, buffers, rgba, depth, stencil):
 649         _rgba = gallium.FloatArray(4)
 650         for i in range(4):
 651             _rgba[i] = rgba[i]
 652         self.real.clear(buffers, _rgba, depth, stencil)
 653
 654     def _present(self):
 655         self.real.flush()
 656
 657         if self.cbufs and self.cbufs[0]:
 658             self.interpreter.present(self.cbufs[0], "cbuf")
 659         if self.zsbuf:
 660             if self.interpreter.options.all:
 661                 self.interpreter.present(self.zsbuf, "zsbuf")
 662
 663
 664 class Interpreter(parser.TraceDumper):
 665
 666     ignore_calls = set((
 667             ('pipe_screen', 'is_format_supported'),
 668             ('pipe_screen', 'get_param'),
 669             ('pipe_screen', 'get_paramf'),
 670     ))
 671
 672     def __init__(self, stream, options):
 673         parser.TraceDumper.__init__(self, stream)
 674         self.options = options
 675         self.objects = {}
 676         self.result = None
 677         self.globl = Global(self, None)
 678         self.call_no = None
 679
 680     def register_object(self, address, object):
 681         self.objects[address] = object
 682
 683     def unregister_object(self, object):
 684         # FIXME:
 685         pass
 686
 687     def lookup_object(self, address):
 688         return self.objects[address]
 689
 690     def interpret(self, trace):
 691         for call in trace.calls:
 692             self.interpret_call(call)
 693
 694     def handle_call(self, call):
 695         if self.options.stop and call.no > self.options.stop:
 696             sys.exit(0)
 697
 698         if (call.klass, call.method) in self.ignore_calls:
 699             return
 700
 701         self.call_no = call.no
 702
 703         if self.verbosity(1):
 704             parser.TraceDumper.handle_call(self, call)
 705             sys.stdout.flush()
 706
 707         args = [(str(name), self.interpret_arg(arg)) for name, arg in call.args]
 708
 709         if call.klass:
 710             name, obj = args[0]
 711             args = args[1:]
 712         else:
 713             obj = self.globl
 714
 715         method = getattr(obj, call.method)
 716         ret = method(**dict(args))
 717
 718         if call.ret and isinstance(call.ret, model.Pointer):
 719             if ret is None:
 720                 sys.stderr.write('warning: NULL returned\n')
 721             self.register_object(call.ret.address, ret)
 722
 723         self.call_no = None
 724
 725     def interpret_arg(self, node):
 726         translator = Translator(self)
 727         return translator.visit(node)
 728
 729     def verbosity(self, level):
 730         return self.options.verbosity >= level
 731
 732     def present(self, surface, description, x=None, y=None, w=None, h=None):
 733         if self.call_no < self.options.start:
 734             return
 735
 736         if self.options.images:
 737             filename = '%04u_%s.png' % (self.call_no, description)
 738             save_image(filename, surface, x, y, w, h)
 739         else:
 740             title = '%u. %s' % (self.call_no, description)
 741             show_image(surface, title, x, y, w, h)
 742
 743
 744 class Main(parser.Main):
 745
 746     def get_optparser(self):
 747         optparser = parser.Main.get_optparser(self)
 748         optparser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbosity", help="no messages")
 749         optparser.add_option("-v", "--verbose", action="count", dest="verbosity", default=1, help="increase verbosity level")
 750         optparser.add_option("-i", "--images", action="store_true", dest="images", default=False, help="save images instead of showing them")
 751         optparser.add_option("-a", "--all", action="store_true", dest="all", default=False, help="show depth, stencil, and transfers")
 752         optparser.add_option("-s", "--step", action="store_true", dest="step", default=False, help="step trhough every draw")
 753         optparser.add_option("-f", "--from", action="store", type="int", dest="start", default=0, help="from call no")
 754         optparser.add_option("-t", "--to", action="store", type="int", dest="stop", default=0, help="until call no")
 755         return optparser
 756
 757     def process_arg(self, stream, options):
 758         parser = Interpreter(stream, options)
 759         parser.parse()
 760
 761
 762 if __name__ == '__main__':
 763     Main().main()