furnace-xray 1.0.0

data/lib/furnace-xray/app/assets/javascripts/lib/drawer.js.coffee

@@ -0,0 +1,206 @@
+#
+# Graph drawing routines.
+# Drawer manages SVG canvas exclusively – avoid interferention
+#
+class @Drawer
+
+  @canvasPadding = 20
+
+  @attach: (selector) ->
+    @svg   = d3.select(selector)
+    @group = @svg.append("g").attr("class", "container")
+    @zoom  = d3.behavior.zoom()
+
+    @zoom.on "zoom", =>
+      @group.attr("transform", "translate(#{d3.event.translate}) scale(#{d3.event.scale})")
+
+    @svg.call(@zoom).on("dblclick.zoom", null)
+
+  @zoomTo: (t, s) ->
+    @zoom.translate(t)
+    @zoom.scale(s) if s
+    @group.attr("transform", "translate(#{t}) scale(#{s || @zoom.scale()})")
+
+  @clear: ->
+    @group?.select("g").remove()
+
+  @reset: ->
+    @zoomTo [@canvasPadding, @canvasPadding]
+
+  constructor: (@graph, padding=10) ->
+    @padding = padding
+
+    @setupEntities()
+    @draw()
+
+  repaint: ->
+    @container.attr("transform", "translate(0,1)")
+    @container.attr("transform", "translate(0,0)")
+
+  fit: (width, height) ->
+    @zoomValue = [@constructor.zoom.translate(), @constructor.zoom.scale()]
+
+    width  = (width-@constructor.canvasPadding*2) / @width()
+    height = (height-@constructor.canvasPadding*2) / @height()
+    ratio  = [width, height].min()
+
+    @constructor.zoomTo([@constructor.canvasPadding,@constructor.canvasPadding], ratio)
+
+  unfit: ->
+    @constructor.zoomTo @zoomValue...
+
+  zoomNode: (width, height, name) ->
+    node = @container.select("#node-#{name}")
+    return if node.empty()
+
+    padding = @constructor.canvasPadding
+    width   = width-padding*2
+    height  = height-padding*2
+
+    zoom = @constructor.zoom.scale()
+    bbox = node[0][0].getBBox()
+
+    if width < bbox.width*zoom || height < bbox.height*zoom
+      zoomTo = zoom = [width/bbox.width, height/bbox.height].min()
+
+    x = (-node.attr("x").toNumber()*zoom+width/2-bbox.width*zoom/2)+padding
+    y = (-node.attr("y").toNumber()*zoom+height/2-bbox.height*zoom/2)+padding
+
+    @constructor.zoomTo [x, y], zoomTo
+
+  setupEntities: ->
+    @container = @constructor.group.append("g")
+
+    # `nodes` is center positioned for easy layout later
+    @nodes = @container.selectAll("g .node")
+      .data(@graph.nodes)
+      .enter()
+      .append("g")
+      .attr("class", "node")
+      .attr("id", (d) -> "node-" + d.label)
+
+    @edges = @container.selectAll("g .edge")
+      .data(@graph.edges)
+      .enter()
+      .append("g")
+      .attr("class", "edge")
+
+    @edges
+      .append("path")
+      .attr("marker-end", "url(#arrowhead)")
+
+    @assignHtmlLabels(@nodes)
+    @assignTextLabels(@edges, 1) 
+
+  assignTextLabels: (items, padding) ->
+    groups = items.append("g").attr("class", "label")
+    rects  = groups.append("rect")
+    labels = groups.append("text")
+
+    labels.attr("text-anchor", "left")
+      .append("tspan")
+      .attr("dy", "1em")
+      .text((d) -> d.data)
+
+    @setupEntitiesSizes(rects, labels, padding)
+
+  assignHtmlLabels: (items, padding) ->
+    groups = items.append("g").attr("class", "label")
+    rects  = groups.append("rect")
+    labels = groups.append("foreignObject")
+    texts = labels.append("xhtml:div").style
+      "float": "left"
+      "white-space": "nowrap"
+
+    texts.html((d) -> d.data).each (d) ->
+      if @clientWidth > 900
+        d3.select(@).style
+          "white-space": "normal"
+          "width": '900px'
+
+    texts
+      .each (d) ->
+        d.width = @clientWidth
+        d.height = @clientHeight
+        d.nodePadding = 0
+
+    labels
+      .attr("width", (d) -> d.width)
+      .attr("height", (d) -> d.height)
+
+    @setupEntitiesSizes(rects, labels, padding)
+
+  setupEntitiesSizes: (rects, labels, padding) ->
+    padding = @padding unless padding
+
+    # We need width and height for layout.
+    labels.each (d) ->
+      bbox = @getBBox()
+      d.bbox = bbox
+      d.width = bbox.width + 2 * padding
+      d.height = bbox.height + 2 * padding
+
+    rects
+      .attr("width", (d) -> d.width)
+      .attr("height", (d) -> d.height)
+
+    labels
+      .attr("x", (d) -> padding)
+      .attr("y", (d) -> padding)
+
+  width: -> @container[0][0].getBBox().width
+  height: -> @container[0][0].getBBox().height
+
+  draw: ->
+    dagre.layout().nodeSep(50).edgeSep(50).rankSep(50)
+      .nodes(@graph.nodes)
+      .edges(@graph.edges)
+      .run()
+
+    # Positioning nodes
+    @nodes.attr "transform", (d, i) =>
+      x = d.dagre.x - d.width/2
+      y = d.dagre.y - d.height/2
+
+      @nodes[0][i].setAttribute 'x', x
+      @nodes[0][i].setAttribute 'y', y
+
+      "translate(#{x},#{y})"
+
+    # Ensure that we have at least two points between source and target
+    @edges.each (d) ->
+      points = d.dagre.points
+      unless points.length
+        s = d.source.dagre
+        t = d.target.dagre
+        points.push
+          x: (s.x + t.x) / 2
+          y: (s.y + t.y) / 2
+
+      if points.length is 1
+        points.push
+          x: points[0].x
+          y: points[0].y
+
+    # Setting correct path coordinates
+    @edges.selectAll("path").attr "d", (e) ->
+      points = e.dagre.points.slice(0)
+      source = dagre.util.intersectRect(e.source.dagre, points[0])
+      target = dagre.util.intersectRect(e.target.dagre, points[points.length - 1])
+
+      points.unshift source
+      points.push target
+
+      d3.svg.line()
+        .x((d) -> d.x)
+        .y((d) -> d.y)
+        .interpolate("linear")(points)
+
+    # Positioning edges labels
+    @edges.selectAll("g.label")
+      .attr("transform", (d) ->
+        points = d.dagre.points;
+        x = (points[0].x + points[1].x) / 2;
+        y = (points[0].y + points[1].y) / 2;
+        return "translate(" + (-d.bbox.width / 2 + x) + "," + (-d.bbox.height / 2 + y) + ")";
+      )

data/lib/furnace-xray/app/assets/javascripts/lib/graph.js.coffee

@@ -0,0 +1,26 @@
+#
+# Maps internal JSON representation to a flat
+# graph structure consumable by `Drawer`
+#
+class @Graph
+  constructor: (@input) ->
+
+    @edges     = []
+    blockNodes = Object.extended()
+
+    @input.blocks.each (i, b) =>
+      blockNodes[b.name] =
+        edges: b.references()
+        label: b.name
+        data: b.title(@input.previousState?.blocks[b.name])
+
+    blockNodes.each (i, n) =>
+      edges = []
+
+      n.edges.each (x) =>
+        edges.add {source: n, target: blockNodes[x], data: blockNodes[x].label}
+        @edges.add edges.last()
+
+      n.edges = edges
+
+    @nodes = blockNodes.values()

data/lib/furnace-xray/app/assets/javascripts/lib/input.js.coffee

@@ -0,0 +1,134 @@
+#
+# Internal representation of input JSON
+#
+class @Input
+  @normalize: (data) ->
+    data.map (x) -> new Input(x)
+
+  constructor: (@source) ->
+    @source.events.each (x) -> x.event = x.event.camelize(false)
+
+    # Scan for effective events
+    @events = []
+    reducer = []
+    transforms = Object.extended()
+
+    @source.events.each (x, i) =>
+      switch x.event 
+        when 'addInstruction'
+          reducer.add x.name
+          @events.add i
+        when 'removeInstruction'
+          reducer.exclude x.name
+          @events.add i
+        when 'updateInstruction'
+          @events.add i if reducer.any(x.name)
+        when 'type', 'transformStart'
+        else
+          @events.add i
+
+      if x.event == 'transformStart'
+        id = @events.length-1
+        transforms[id] = {id: id, label: x.name}
+
+    @transforms = transforms.values()
+    @transforms = @transforms.filter (x, i) => 
+      x.length = (@transforms[i+1]?.id || @events.length) - x.id
+      x.id < @events.length-1
+
+    @reset()
+
+  reset: ->
+    @types           = Object.extended()
+    @blocks          = Object.extended()
+    @instructions    = Object.extended()
+    @blocksMap       = new Map 'blocks'
+    @instructionsMap = new Map 'instructions'
+
+    @function = new FunctionNode(@source.name, @source.present)
+    @cursor   = 0
+
+    # run first step at initialization
+    i = -1; @run(i) while (i+=1) <= (@events[1] || @source.events.length-1)
+
+  rewind: (to) ->
+    return if to == @cursor
+
+    if to < @cursor
+      delete @previousState
+      @reset()
+    else
+      @previousState = new InputState(@)
+
+    @reset() 
+    @increment(to)
+
+  increment: (to) ->
+    to   = @events.length-1 unless to?
+    stop = [to, @events.length-1].min()
+    stop = 0 if stop < 0
+
+    i = @events[@cursor]; @run(i) while (i+=1) <= @events[stop]
+    @cursor = stop
+
+  run: (step) ->
+    event = @source.events[step]
+
+    if event.event == 'type'
+      @types[event.id] = new TypeNode(event.kind, event.name, event.parameters)
+    else
+      @[event.event]?(event)
+      console.log "UNKNOWN EVENT: #{event.event}" unless @[event.event]?
+
+  type: (id) ->
+    return undefined unless id?
+
+    if type = @types[id]
+      return type
+    else
+      @reset()
+      throw "Type #{id} not found in #{@types.keys().join(',')}"
+
+  setReturnType: (event) ->
+    @function.setReturnType @type(event.return_type)
+
+  setArguments: (event) ->
+    @function.setArguments(event.arguments.map (x) =>
+      new ArgumentNode(x.name, @type(x.type)))
+
+  addBasicBlock: (event) ->
+    @blocksMap.add event.name, (id) =>
+      @blocks[id] = new BlockNode(event.name)
+
+  removeBasicBlock: (event) ->
+    @blocksMap.remove event.name, (id) =>
+      delete @blocks[id]
+
+  renameBasicBlock: (event) ->
+    @blocksMap.rename event.name, event.new_name, (id) =>
+      @blocks[id].setName(event.new_name)
+
+  updateInstruction: (event) ->
+    id = @instructionsMap.add event.name, (id) =>
+      @instructions[id] = new InstructionNode
+
+    if Object.isArray(event.operands)
+      operands = event.operands.map (x) =>
+        new OperandNode x.kind, @type(x.type), x.name, x.value
+    else
+      operands = []
+      Object.each event.operands, (key, x) =>
+        operands.push [key, new OperandNode(x.kind, @type(x.type), x.name, x.value)]
+
+    @instructions[id].update event.opcode, event.name, event.parameters, operands, @type(event.type)
+
+  addInstruction: (event) ->
+    @instructionsMap.locate event.name, (i) =>
+      @blocksMap.locate event.basic_block, (b) =>
+        @instructions[i].link @blocks[b], event.index
+
+  removeInstruction: (event) ->
+    @instructionsMap.locate event.name, (i) =>
+      @instructions[i].unlink()
+
+  transformStart: (event) ->

data/lib/furnace-xray/app/assets/javascripts/lib/input_state.js.coffee

@@ -0,0 +1,8 @@
+class @InputState
+  constructor: (input) ->
+    @blocks = Object.extended()
+    @cursor = input.cursor
+
+    input.blocksMap.each (bname, id) =>
+      @blocks[bname] = input.blocks[id].instructions.map (x) ->
+        {title: x.title(), name: x.name}

data/lib/furnace-xray/app/assets/javascripts/lib/map.js.coffee

@@ -0,0 +1,45 @@
+#
+# Failsafe Map container
+#
+class @Map
+  constructor: (@title) ->
+    @data = []
+    @map  = Object.extended()
+
+  each: (block) -> @map.each block
+
+  add: (name, block) ->
+    id = @data.findIndex(name)
+
+    if id < 0
+      @data.add name
+      id = @data.length-1
+      block(id) if block
+      @map[name] = id
+    
+    id
+
+  find: (name) ->
+    id = @map[name]
+
+    if id < 0 
+      error = "Map '#{@title}': '#{name}' element not found"
+      throw error
+
+    id
+
+  remove: (name, block) ->
+    id = @find(name)
+    @data.splice id, 1
+    block(id) if block
+    delete @map[name]
+
+  rename: (name, newName, block) ->
+    id = @find(name)
+    @data[id] = newName
+    block(id) if block
+    delete @map[name]
+    @map[newName] = id
+
+  locate: (name, block) ->
+    block(@find(name))

data/lib/furnace-xray/app/assets/javascripts/lib/nodes/argument.js.coffee

@@ -0,0 +1,7 @@
+class @ArgumentNode
+  constructor: (@name, @type) ->
+
+  title: ->
+    JST['nodes/argument']
+      type: @type.title()
+      name: @name

data/lib/furnace-xray/app/assets/javascripts/lib/nodes/block.js.coffee

@@ -0,0 +1,76 @@
+class @BlockNode
+  constructor: (@name, @instructions) ->
+    @instructions ||= []
+
+  title: (previousState) ->
+    JST['nodes/block']
+      name: @name
+      instructions: @titleizeInstructions(previousState)
+
+  titleizeInstructions: (previousState) ->
+    unless previousState
+      result = ""
+      result += JST['nodes/diff/unchanged_line'] line: x.title() for x in @instructions 
+      result
+    else
+      result    = ""
+      removed   = Object.extended()
+      added     = Object.extended()
+      changed   = Object.extended()
+      unchanged = Object.extended()
+
+      for cs, i in @instructions
+        previous = previousState.find (ps) -> ps.name == cs.name
+        currentTitle = cs.title()
+
+        if previous && previous.title == currentTitle
+          unchanged[i] = previous.title
+          previous.newPosition = i
+        else if previous
+          changed[i] = [previous.title, currentTitle]
+          previous.newPosition = i
+        else
+          added[i] = currentTitle
+
+      for ps, i in previousState
+        if !ps.newPosition?
+          position = 0
+
+          while --i >= 0
+            if previousState[i].newPosition?
+              position = previousState[i].newPosition+1
+              break
+
+          removed[position] ||= []
+          removed[position].push ps.title
+
+      [@instructions.length, previousState.length].max().times (i) ->
+        if removed[i]
+          result += JST['nodes/diff/removed_line'](line: l) for l in removed[i]
+
+        result += JST['nodes/diff/added_line'](line: added[i]) if added[i]
+        result += JST['nodes/diff/changed_line'](before: changed[i][0], after:changed[i][1]) if changed[i]
+        result += JST['nodes/diff/unchanged_line'](line: unchanged[i]) if unchanged[i]
+
+      result
+
+  previous: ->
+    try
+      previous = @input.previous.blocks[@input.previous.blocksMap.find(@name)]
+    catch error
+      console.log error
+
+    previous
+
+  setName: (name) ->
+    @name = name
+
+  addInstruction: (instruction, index) ->
+    @instructions.splice index, 0, instruction
+
+  removeInstruction: (instruction) ->
+    index = @instructions.findIndex(instruction)
+    @instructions.splice index, 1 unless index < 0
+
+  references: ->
+    @instructions.last()?.operands.findAll((x) -> x.kind == "basic_block").map((x) -> x.name) || []