WIP: refactoring of DRC Ruby code

src/db/db/dbCompoundOperation.cc

@@ -397,6 +397,12 @@ CompoundRegionLogicalBoolOperationNode::CompoundRegionLogicalBoolOperationNode (
   //  .. nothing yet ..
 }
 
+CompoundRegionLogicalBoolOperationNode::ResultType
+CompoundRegionLogicalBoolOperationNode::result_type () const
+{
+  return Region;
+}
+
 std::string CompoundRegionLogicalBoolOperationNode::generated_description () const
 {
   std::string r;

src/db/db/dbCompoundOperation.h

@@ -409,14 +409,14 @@ class DB_PUBLIC CompoundRegionLogicalBoolOperationNode
   : public CompoundRegionMultiInputOperationNode
 {
 public:
-  enum  LogicalOp { And, Or };
+  enum LogicalOp { And, Or };
 
   CompoundRegionLogicalBoolOperationNode (LogicalOp op, bool invert, const std::vector<CompoundRegionOperationNode *> &inputs);
 
   virtual std::string generated_description () const;
 
   //  specifies the result type
-  virtual ResultType result_type () const { return Region; }
+  virtual ResultType result_type () const;
 
   //  the different computation slots
   virtual void do_compute_local (db::Layout *layout, const shape_interactions<db::Polygon, db::Polygon> &interactions, std::vector<std::unordered_set<db::Polygon> > &results, size_t max_vertex_count, double area_ratio) const

src/drc/drc/built-in-macros/_drc_complex_ops.rb

@@ -0,0 +1,947 @@
+# $autorun-early
+
+module DRC
+
+class DRCOpNode
+
+  attr_accessor :description
+  attr_accessor :engine
+  
+  def initialize(engine, node = nil)
+    @node = node
+    self.engine = engine
+    self.description = "Basic"
+  end
+  
+  def create_node(cache)
+    n = cache[self.object_id]
+    if !n
+      n = self.do_create_node(cache)
+      cache[self.object_id] = n
+    end
+    n
+  end
+  
+  def do_create_node(cache)
+    @node
+  end
+  
+  def dump(indent)
+    return indent + self.description
+  end
+  
+  def _build_geo_bool_node(other, op)
+    if ! other.is_a?(DRCOpNode)
+      raise("Second argument to #{op.to_s} must be a DRC expression")
+    end
+    DRCOpNodeBool::new(@engine, op, self, other)
+  end
+  
+  %w(& - ^ | +).each do |f|
+    eval <<"CODE"
+      def #{f}(other)
+        self.engine._context("#{f}") do
+          self._build_geo_bool_node(other, :#{f})
+        end
+      end
+CODE
+  end
+  
+  def !()
+    self.engine._context("!") do
+      if self.respond_to?(:inverted)
+        return self.inverted
+      else
+        empty = RBA::CompoundRegionOperationNode::new_empty(RBA::CompoundRegionOperationNode::ResultType::Region)
+        DRCOpNodeCase::new(@engine, [ self, DRCOpNode::new(@engine, empty), @engine.primary ])
+      end
+    end
+  end
+
+  def _check_numeric(v, symbol)
+    if ! v.is_a?(Float) && ! v.is_a?(1.class)
+      if symbol
+        raise("Argument '#{symbol}' (#{v.inspect}) isn't numeric in operation '#{self.description}'")
+      else
+        raise("Argument (#{v.inspect}) isn't numeric in operation '#{self.description}'")
+      end
+    end
+  end
+  
+  def _make_value(v, symbol)
+    self._check_numeric(v, symbol)
+    @engine._prep_value(v)
+  end
+  
+  def _make_area_value(v, symbol)
+    self._check_numeric(v, symbol)
+    @engine._prep_area_value(v)
+  end
+  
+  def area
+    DRCOpNodeAreaFilter::new(@engine, self)
+  end
+  
+  def perimeter
+    DRCOpNodePerimeterFilter::new(@engine, self)
+  end
+  
+  def bbox_min
+    DRCOpNodeBBoxParameterFilter::new(@engine, RBA::CompoundRegionOperationNode::BoxMinDim, self)
+  end
+  
+  def bbox_max
+    DRCOpNodeBBoxParameterFilter::new(@engine, RBA::CompoundRegionOperationNode::BoxMaxDim, self)
+  end
+  
+  def bbox_width
+    DRCOpNodeBBoxParameterFilter::new(@engine, RBA::CompoundRegionOperationNode::BoxWidth, self)
+  end
+  
+  def bbox_height
+    DRCOpNodeBBoxParameterFilter::new(@engine, RBA::CompoundRegionOperationNode::BoxHeight, self)
+  end
+  
+  def length
+    DRCOpNodeEdgeLengthFilter::new(@engine, self)
+  end
+  
+  def angle
+    DRCOpNodeEdgeOrientationFilter::new(@engine, self)
+  end
+  
+  def rounded_corners(inner, outer, n)
+    self.engine._context("rounded_corners") do
+      self._check_numeric(n, :n)
+      DRCOpNodeFilter::new(@engine, self, :new_rounded_corners, "rounded_corners", self.make_value(inner, :inner), self.make_value(outer, :outer), n)
+    end
+  end
+  
+  def smoothed(d)
+    self.engine._context("smoothed") do
+      DRCOpNodeFilter::new(@engine, self, :new_smoothed, "smoothed", self.make_value(d, :d))
+    end
+  end
+  
+  def corners(as_dots = DRCAsDots::new(false))
+    self.engine._context("corners") do
+      if as_dots.is_a?(DRCAsDots)
+        as_dots = as_dots.value
+      else
+        raise("Invalid argument (#{as_dots.inspect}) for 'corners' method")
+      end
+      DRCOpNodeCornersFilter::new(@engine, self, as_dots)
+    end
+  end
+  
+  %w(middle extent_refs).each do |f| 
+    eval <<"CODE"
+    def #{f}(*args)
+
+      self.engine._context("#{f}") do
+
+        f = []
+        as_edges = false
+
+        @@std_refs ||= { 
+          :center => [0.5] * 4,
+          :c => [0.5] * 4,
+          :bottom_center => [ 0.5, 0.0, 0.5, 0.0 ],
+          :bc => [ 0.5, 0.0, 0.5, 0.0 ],
+          :bottom_left => [ 0.0, 0.0, 0.0, 0.0 ],
+          :bl => [ 0.0, 0.0, 0.0, 0.0 ],
+          :bottom_right => [ 1.0, 0.0, 1.0, 0.0 ],
+          :br => [ 1.0, 0.0, 1.0, 0.0 ],
+          :top_center => [ 0.5, 1.0, 0.5, 1.0 ],
+          :tc => [ 0.5, 1.0, 0.5, 1.0 ],
+          :top_left => [ 0.0, 1.0, 0.0, 1.0 ],
+          :tl => [ 0.0, 1.0, 0.0, 1.0 ],
+          :top_right => [ 1.0, 1.0, 1.0, 1.0 ],
+          :tr => [ 1.0, 1.0, 1.0, 1.0 ],
+          :left_center => [ 0.0, 0.5, 0.0, 0.5 ],
+          :lc => [ 0.0, 0.5, 0.0, 0.5 ],
+          :right_center => [ 1.0, 0.5, 1.0, 0.5 ],
+          :rc => [ 1.0, 0.5, 1.0, 0.5 ],
+          :south => [ 0.5, 0.0, 0.5, 0.0 ],
+          :s => [ 0.5, 0.0, 0.5, 0.0 ],
+          :left => [ 0.0, 0.0, 0.0, 1.0 ],
+          :l => [ 0.0, 0.0, 0.0, 1.0 ],
+          :bottom => [ 1.0, 0.0, 0.0, 0.0 ],
+          :b => [ 1.0, 0.0, 0.0, 0.0 ],
+          :right => [ 1.0, 1.0, 1.0, 0.0 ],
+          :r => [ 1.0, 1.0, 1.0, 0.0 ],
+          :top => [ 0.0, 1.0, 1.0, 1.0 ],
+          :t => [ 0.0, 1.0, 1.0, 1.0 ]
+        }
+
+        args.each_with_index do |a,ia|
+          if a.is_a?(1.0.class) && :#{f} != :middle
+            f << a 
+          elsif a.is_a?(DRCAsDots)
+            as_edges = a.value
+          elsif @@std_refs[a] && :#{f} != :middle
+            f = @@std_refs[a]
+          else
+            raise("Invalid argument #" + (ia + 1).to_s + " (" + a.inspect + ") for '#{f}' method on operation '" + self.description + "' - needs to be numeric or 'as_dots/as_edges'")
+          end
+        end
+
+        if f.size == 2
+          f = f + f
+        else
+          f = (f + [0.5] * 4)[0..3]
+        end
+            
+        if as_edges
+          return DRCOpNodeRelativeExtents::new(self, true, *f)
+        else
+          # add oversize for point- and edge-like regions
+          zero_area = (f[0] - f[2]).abs < 1e-7 || (f[1] - f[3]).abs < 1e-7
+          f += [ zero_area ? 1 : 0 ] * 2
+          return DRCOpNodeRelativeExtents::new(self, false, *f)
+        end
+
+      end
+
+    end
+CODE
+  end
+  
+  def odd_polygons
+    return DRCOpNodeFilter::new(@engine, self, :new_strange_polygons_filter, "odd_polygon")
+  end
+  
+  def rectangles
+    return DRCOpNodeFilter::new(@engine, self, :new_rectangle_filter, "rectangle")
+  end
+  
+  def rectilinear
+    return DRCOpNodeFilter::new(@engine, self, :new_rectilinear_filter, "rectilinear")
+  end
+  
+  def holes
+    return DRCOpNodeFilter::new(@engine, self, :new_holes, "holes")
+  end
+  
+  def hulls
+    return DRCOpNodeFilter::new(@engine, self, :new_hulls, "hull")
+  end
+  
+  def edges
+    return DRCOpNodeFilter::new(@engine, self, :new_edges, "edges")
+  end
+  
+  def sized(*args)
+
+    self.engine._context("sized") do
+
+      dist = 0
+      
+      mode = 2
+      values = []
+      args.each_with_index do |a,ia|
+        if a.is_a?(1.class) || a.is_a?(Float)
+          v = self._make_value(a, "argument ##{ia + 1}")
+          v.abs > dist && dist = v.abs 
+          values.push(v)
+        elsif a.is_a?(DRCSizingMode)
+          mode = a.value
+        end
+      end
+      
+      args = []
+      if values.size < 1
+        raise("sized: Method requires one or two sizing values")
+      elsif values.size > 2
+        raise("sized: Method must not have more than two values")
+      else
+        args << values[0]
+        args << values[-1]
+      end
+      args << mode
+      
+      DRCOpNodeFilter::new(@engine, self, :new_sized, "sized", *args)
+
+    end
+
+  end
+  
+  def extents(e = 0)
+    self.engine._context("extents") do
+      DRCOpNodeFilter::new(@engine, self, :new_extents, "extents", self._make_value(e, :e))
+    end
+  end
+  
+  def first_edges
+    DRCOpNodeFilter::new(@engine, self, :new_edge_pair_to_first_edges, "first_edges")
+  end
+  
+  def second_edges
+    DRCOpNodeFilter::new(@engine, self, :new_edge_pair_to_second_edges, "second_edges")
+  end
+
+  def end_segments(length, fraction = 0.0)
+    self.engine._context("end_segments") do
+      self._check_numeric(fraction, :fraction)
+      DRCOpNodeFilter::new(@engine, self, :new_end_segments, "end_segments", self._make_value(length, :length), fraction)
+    end
+  end
+  
+  def start_segments(length, fraction = 0.0)
+    self.engine._context("start_segments") do
+      self._check_numeric(fraction, :fraction)
+      DRCOpNodeFilter::new(@engine, self, :new_start_segments, "start_segments", self._make_value(length, :length), fraction)
+    end
+  end
+  
+  def centers(length, fraction = 0.0)
+    self.engine._context("centers") do
+      self._check_numeric(fraction, :fraction)
+      DRCOpNodeFilter::new(@engine, self, :new_centers, "centers", self._make_value(length, :length), fraction)
+    end
+  end
+  
+  def extended(*args)
+  
+    self.engine._context("extended") do
+
+      av = [ 0, 0, 0, 0 ]
+      args.each_with_index do |a,i|
+        if a.is_a?(Hash)
+          a[:begin]  && av[0] = self._make_value(a[:begin], :begin)
+          a[:end]    && av[1] = self._make_value(a[:end], :end)
+          a[:out]    && av[2] = self._make_value(a[:out], :out)
+          a[:in]     && av[3] = self._make_value(a[:in], :in)
+          a[:joined] && av[4] = true
+        elsif i < 4
+          av[i] = self._make_value(a, "argument " + (i+1).to_s)
+        else
+          raise("Too many arguments for method '#{f}' (1 to 5 expected)")
+        end
+      end
+
+      DRCOpNodeFilter::new(@engine, self, :new_extended, "extended", *args)
+
+    end
+    
+  end
+  
+  def extended_in(e)
+    self.engine._context("extended_in") do
+      DRCOpNodeFilter::new(@engine, self, :new_extended_in, "extended_in", self._make_value(e))
+    end
+  end
+  
+  def extended_out(e)
+    self.engine._context("extended_out") do
+      DRCOpNodeFilter::new(@engine, self, :new_extended_out, "extended_out", self._make_value(e))
+    end
+  end
+  
+  def polygons
+    self.engine._context("polygons") do
+      DRCOpNodeFilter::new(@engine, self, :new_polygons, "polygons")
+    end
+  end
+  
+end
+
+class DRCOpNodeLogicalBool < DRCOpNode
+
+  attr_accessor :children
+  attr_accessor :op
+  
+  def initialize(engine, op)
+    super(engine)
+    self.children = []
+    self.op = op
+    self.description = op.to_s
+  end
+
+  def dump(indent)
+    return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
+  end
+
+  def do_create_node(cache)
+    log_op = { 
+      :if_all => RBA::CompoundRegionOperationNode::LogicalOp::LogAnd, 
+      :if_any => RBA::CompoundRegionOperationNode::LogicalOp::LogOr,
+      :if_none => RBA::CompoundRegionOperationNode::LogicalOp::LogOr 
+    } [self.op]
+    invert = { 
+      :if_all => false,
+      :if_any => false,
+      :if_none => true
+    } [self.op]
+    RBA::CompoundRegionOperationNode::new_logical_boolean(log_op, invert, self.children.collect { |c| c.create_node(cache) })
+  end
+  
+end
+
+class DRCOpNodeBool < DRCOpNode
+
+  attr_accessor :children
+  attr_accessor :op
+  
+  def initialize(engine, op, a, b)
+    super(engine)
+    self.children = [a, b]
+    self.op = op
+    self.description = "Geometrical #{op.to_s}"
+  end
+
+  def dump(indent)
+    return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
+  end
+
+  def do_create_node(cache)
+    bool_op = { :& => RBA::CompoundRegionOperationNode::GeometricalOp::And, 
+                :+ => RBA::CompoundRegionOperationNode::GeometricalOp::Or,
+                :| => RBA::CompoundRegionOperationNode::GeometricalOp::Or,
+                :- => RBA::CompoundRegionOperationNode::GeometricalOp::Not,
+                :^ => RBA::CompoundRegionOperationNode::GeometricalOp::Xor }[self.op]
+    nodes = self.children.collect do |c| 
+      n = c.create_node(cache)
+      if n.result_type == RBA::CompoundRegionOperationNode::ResultType::EdgePairs
+        n = RBA::CompoundRegionOperationNode::new_edge_pair_to_first_edges(n)
+      end
+      n
+    end
+    RBA::CompoundRegionOperationNode::new_geometrical_boolean(bool_op, *nodes)
+  end
+  
+end
+
+class DRCOpNodeCase < DRCOpNode
+
+  attr_accessor :children
+  
+  def initialize(engine, children)
+    super(engine)
+    self.children = children
+    self.description = "switch"
+  end
+
+  def dump(indent)
+    return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
+  end
+  
+  def do_create_node(cache)
+    RBA::CompoundRegionOperationNode::new_case(self.children.collect { |c| c.create_node(cache) })
+  end
+
+end
+
+class DRCOpNodeWithCompare < DRCOpNode
+  
+  attr_accessor :reverse
+  attr_accessor :original
+  attr_accessor :lt, :le, :gt, :ge, :arg
+  
+  def initialize(engine, original = nil, reverse = false)
+    super(engine)
+    self.reverse = reverse
+    self.original = original
+    self.description = original ? original.description : "BasicWithCompare"
+  end
+  
+  def _description_for_dump
+    self.description
+  end
+  
+  def dump(indent = "")
+    if self.original
+      return "@temp (should not happen)"
+    else
+      cmp = []
+      self.lt && (cmp << ("<%.12g" % self.lt))
+      self.le && (cmp << ("<=%.12g" % self.le))
+      self.gt && (cmp << (">%.12g" % self.gt))
+      self.ge && (cmp << (">=%.12g" % self.ge))
+      return indent + self.description + " " + cmp.join(" ")
+    end
+  end
+
+  def _check_bounds
+    if (self.lt || self.le) && (self.gt || self.ge)
+      epsilon = 1e-10
+      lower = self.ge ? self.ge - epsilon : self.gt + epsilon
+      upper = self.le ? self.le + epsilon : self.lt - epsilon
+      if lower > upper - epsilon
+        raise("Lower bound is larger than upper bound")
+      end 
+    end  
+  end
+    
+  def set_lt(value)
+    (self.lt || self.le) && raise("'" + self.description + "' already has an upper bound of " + ("%.12g" % (self.lt || self.le)))
+    self.lt = value
+    self._check_bounds
+  end    
+
+  def set_le(value)
+    (self.lt || self.le) && raise("'" + self.description + "' already has an upper bound of " + ("%.12g" % (self.lt || self.le)))
+    self.le = value
+    self._check_bounds
+  end    
+      
+  def set_gt(value)
+    (self.gt || self.ge) && raise("'" + self.description + "' already has an lower bound of " + ("%.12g" % (self.gt || self.ge)))
+    self.gt = value
+    self._check_bounds
+  end    
+
+  def set_ge(value)
+    (self.gt || self.ge) && raise("'" + self.description + "' already has an lower bound of " + ("%.12g" % (self.gt || self.ge)))
+    self.ge = value
+    self._check_bounds
+  end
+  
+  def coerce(something)
+    [ DRCOpNodeWithCompare::new(self.engine, self, true), something ]
+  end
+  
+  def _self_or_original
+    return self.original || self
+  end
+  
+  def ==(other)
+    if !(other.is_a?(Float) || other.is_a?(Integer))
+      raise("== operator needs a numerical argument for '" + self.description + "' argument")
+    end
+    res = self._self_or_original
+    res.set_le(other)
+    res.set_ge(other)
+    return res
+  end
+  
+  def <(other)
+    if !(other.is_a?(Float) || other.is_a?(Integer))
+      raise("< operator needs a numerical argument for '" + self.description + "' argument")
+    end
+    res = self._self_or_original
+    if reverse
+      res.set_gt(other)
+    else
+      res.set_lt(other)
+    end
+    return res
+  end
+  
+  def <=(other)
+    if !(other.is_a?(Float) || other.is_a?(Integer))
+      raise("<= operator needs a numerical argument for '" + self.description + "' argument")
+    end
+    res = self._self_or_original
+    if reverse
+      res.set_ge(other)
+    else
+      res.set_le(other)
+    end
+    return res
+  end
+
+  def >(other)
+    if !(other.is_a?(Float) || other.is_a?(Integer))
+      raise("> operator needs a numerical argument for '" + self.description + "' argument")
+    end
+    res = self._self_or_original
+    if reverse
+      res.set_lt(other)
+    else
+      res.set_gt(other)
+    end
+    return res
+  end
+  
+  def >=(other)
+    if !(other.is_a?(Float) || other.is_a?(Integer))
+      raise(">= operator needs a numerical argument for '" + self.description + "' argument")
+    end
+    res = self._self_or_original
+    if reverse
+      res.set_le(other)
+    else
+      res.set_ge(other)
+    end
+    return res
+  end
+  
+end
+
+class DRCOpNodeAreaFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :inverted
+  
+  def initialize(engine, input)
+    super(engine)
+    self.input = input
+    self.inverted = false
+    self.description = "area"
+  end
+
+  def _description_for_dump
+    self.inverted ? "area" : "not_area"
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache), self.inverse ]
+    args << (self.gt ? make_area_value(self.gt) + 1 : (self.ge ? make_area_value(self.ge) : 0))
+    if self.lt || self.le
+      args << self.lt ? make_area_value(self.lt) : make_area_value(self.le) - 1
+    end
+    RBA::CompoundRegionOperationNode::new_area_filter(*args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeEdgeLengthFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :inverted
+  
+  def initialize(engine, input)
+    super(engine)
+    self.input = input
+    self.inverted = false
+    self.description = "length"
+  end
+  
+  def _description_for_dump
+    self.inverted ? "length" : "not_length"
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache), self.inverse ]
+    args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
+    if self.lt || self.le
+      args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
+    end
+    RBA::CompoundRegionOperationNode::new_edge_length_filter(*args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeEdgeOrientationFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :inverted
+  
+  def initialize(engine, input)
+    super(engine)
+    self.input = input
+    self.inverted = false
+    self.description = "angle"
+  end
+  
+  def _description_for_dump
+    self.inverted ? "angle" : "not_angle"
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache), self.inverse ]
+    angle_delta = 1e-6
+    args << (self.gt ? self.gt + angle_delta : (self.ge ? self.ge : -180.0))
+    args << (self.lt ? self.lt : (self.le ? self.le - angle_delta : 180.0))
+    RBA::CompoundRegionOperationNode::new_edge_orientation_filter(*args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodePerimeterFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :inverted
+  
+  def initialize(engine, input)
+    super(engine)
+    self.input = input
+    self.inverted = false
+    self.description = "perimeter"
+  end
+
+  def _description_for_dump
+    self.inverted ? "perimeter" : "not_perimeter"
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache), self.inverse ]
+    args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
+    if self.lt || self.le
+      args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
+    end
+    RBA::CompoundRegionOperationNode::new_perimeter_filter(*args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeInteractingWithCount < DRCOpNodeWithCompare
+
+  attr_accessor :a, :b
+  attr_accessor :inverted
+  attr_accessor :op
+  
+  def initialize(engine, a, b, op)
+    super(engine)
+    self.a = a
+    self.b = b
+    self.op = op
+    self.inverted = false
+    self.description = (self.inverted ? "" : "not_") + self.op.to_s
+  end
+  
+  def do_create_node(cache)
+    args = [ self.a.create_node(cache), self.b.create_node(cache), self.inverse ]
+    args << (self.gt ? self.gt + 1 : (self.ge ? self.ge : 0))
+    if self.lt || self.le
+      args << self.lt ? self.lt : self.le - 1
+    end
+    factory = { :covering => :new_enclosing,
+                :overlapping => :new_overlapping,
+                :interacting => :new_interacting }[self.op]
+    RBA::CompoundRegionOperationNode::send(factory, *args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeInteracting < DRCOpNode
+
+  attr_accessor :a, :b
+  attr_accessor :inverted
+  attr_accessor :op
+  
+  def initialize(engine, a, b, op)
+    super(engine)
+    self.a = a
+    self.b = b
+    self.op = op
+    self.inverted = false
+    self.description = (self.inverted ? "" : "not_") + self.op.to_s
+  end
+  
+  def do_create_node(cache)
+    factory = { :inside => :new_inside,
+                :outside => :new_outside }[self.op]
+    RBA::CompoundRegionOperationNode::send(factory, self.a.create_node(cache), self.b.create_node(cache), self.inverse)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeFilter < DRCOpNode
+
+  attr_accessor :input
+  attr_accessor :factory
+  attr_accessor :args
+  
+  def initialize(engine, input, factory, description, *args)
+    super(engine)
+    self.input = input
+    self.factory = factory
+    self.args = args
+    self.description = description
+  end
+  
+  def dump(indent)
+    if self.args.size > 0
+      return self.description + "(" + self.args.collect { |a| a.inspect }.join(",") + ")\n" + input.dump("  " + indent)
+    else
+      return self.description + "\n" + input.dump("  " + indent)
+    end
+  end
+  
+  def do_create_node(cache)
+    RBA::CompoundRegionOperationNode::send(self.factory, self.input.create_node(cache), *args)
+  end
+  
+end
+
+class DRCOpNodeCheck < DRCOpNodeWithCompare
+
+  attr_accessor :other
+  attr_accessor :check
+  attr_accessor :args
+  
+  def initialize(engine, check, other, *args)
+    super(engine)
+    self.check = check
+    self.other = other
+    self.args = args
+    self.description = check.to_s
+  end
+
+  def _description_for_dump
+    if self.args.size > 0
+      return self.description + "(" + self.args.collect { |a| a.inspect }.join(",") + ")"
+    else
+      return self.description
+    end
+  end
+  
+  def do_create_node(cache)
+  
+    if !(self.lt || self.le) && !(self.gt || self.ge)
+      raise("No value given for check #{self.check}")
+    end
+    
+    factory = { :width => :new_width_check, :space => :new_space_check,
+                :notch => :new_notch_check, :separation => :new_separation_check,
+                :isolated => :new_isolated_check, :overlap => :new_overlap_check, 
+                :enclosing => :new_inside_check }[self.check]
+
+    if self.lt || self.le
+      dmin = self.le ? self._make_value(self.le, :le) + 1 : self._make_value(self.lt, :lt)
+      res = RBA::CompoundRegionOperationNode::send(factory, dmin, *self.args)
+    else
+      res = nil
+    end
+      
+    if self.gt || self.ge
+      dmax = self.ge ? self._make_value(self.ge, :ge) : self._make_value(self.gt, :gt) + 1
+      max_check = RBA::CompoundRegionOperationNode::send(factory, dmax, *self.args + [ true ])
+      res_max = RBA::CompoundRegionOperationNode::new_edge_pair_to_first_edges(max_check)
+      if res
+        if self.check == :width || self.check == :notch
+          # Same polygon check - we need to take both edges of the result
+          and_with = RBA::CompoundRegionOperationNode::new_edges(res)
+        else
+          and_with = RBA::CompoundRegionOperationNode::new_edge_pair_to_first_edges(res)
+        end
+        res = RBA::CompoundRegionOperationNode::new_geometrical_boolean(RBA::CompoundRegionOperationNode::GeometricalOp::And, and_with, res_max)
+      else
+        res = res_max
+      end
+    end
+    
+    return res
+
+  end
+
+end
+
+class DRCOpNodeBBoxParameterFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :parameter
+  attr_accessor :inverted
+  
+  def initialize(engine, parameter, input, description)
+    super(engine)
+    self.parameter = parameter
+    self.input = input
+    self.inverted = false
+    self.description = description
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache), self.inverse ]
+    args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
+    if self.lt || self.le
+      args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
+    end
+    RBA::CompoundRegionOperationNode::new_perimeter_filter(*args)
+  end
+
+  def inverted
+    res = self.dup
+    res.inverted = !res.inverted
+    return res
+  end
+  
+end
+
+class DRCOpNodeCornersFilter < DRCOpNodeWithCompare
+
+  attr_accessor :input
+  attr_accessor :parameter
+  attr_accessor :inverted
+  
+  def initialize(engine, as_dots, input)
+    super(engine)
+    self.as_dots = as_dots
+    self.input = input
+    self.description = "corners"
+  end
+  
+  def do_create_node(cache)
+    args = [ self.input.create_node(cache) ]
+    angle_delta = 1e-6
+    args << (self.gt ? self.gt + angle_delta : (self.ge ? self.ge : -180.0))
+    args << (self.lt ? self.lt : (self.le ? self.le - angle_delta : 180.0))
+    if self.as_dots
+      RBA::CompoundRegionOperationNode::new_corners_as_dots_node(*args)
+    else
+      args << 2 # dimension is 2x2 DBU
+      RBA::CompoundRegionOperationNode::new_corners_as_rectangles_node(*args)
+    end
+  end
+
+end
+
+class DRCOpNodeRelativeExtents < DRCOpNode
+
+  attr_accessor :input
+  attr_accessor :as_edges, :fx1, :fx2, :fy1, :fy2, :dx, :dy
+  
+  def initialize(engine, input, as_edges, fx1, fx2, fy1, fy2, dx = 0, dy = 0)
+    super(engine)
+    self.input = input
+    self.as_edges = as_edges
+    self.description = "extents"
+  end
+  
+  def dump(indent)
+    if !self.as_edges
+      return "extents(%.12g,%.12g,%.12g,%.12g,%12g,%.12g)" % [self.fx1, self.fx2, self.fy1, self.fy2, self.dx, self.dy]
+    else
+      return "extents_as_edges(%.12g,%.12g,%.12g,%.12g)" % [self.fx1, self.fx2, self.fy1, self.fy2]
+    end
+  end
+      
+  def do_create_node(cache)
+    if !self.as_edges
+      RBA::CompoundRegionOperationNode::new_relative_extents_as_edges(self.input, self.fx1, self.fx2, self.fy1, self.fy2, self.dx, self.dy)
+    else
+      RBA::CompoundRegionOperationNode::new_relative_extents_as_edges(self.input, self.fx1, self.fx2, self.fy1, self.fy2)
+    end
+  end
+
+end
+
+end

src/drc/drc/built-in-macros/_drc_cop_integration.rb

@@ -0,0 +1,372 @@
+# $autorun-early
+
+module DRC
+
+  class DRCLayer
+
+    # %DRC%
+    # @name drc
+    # @brief Universal DRC function
+    # @synopsis drc(...)
+    #
+    # TODO: add doc
+
+    def drc(op)
+      @engine._context("drc") do
+        requires_region
+        return DRCLayer::new(@engine, self.data.complex_op(op.create_node({})))
+      end
+    end
+    
+  end
+
+  class DRCEngine
+
+    # %DRC%
+    # @name case
+    # @brief A conditional selector for the "drc" universal DRC function
+    # @synopsis case(...)
+    #
+    # This function provides a conditional selector for the "drc" function.
+    # It is used this way:
+    #
+    # @code
+    #   out = in.drc(case(c1, r1, c2, r2, ..., cn, rn)
+    #   out = in.drc(case(c1, r1, c2, r2, ..., cn, rn, rdef)
+    # @/code
+    # 
+    # This function will evaluate c1 which is a universal DRC expression (see \drc).
+    # If the result is not empty, "case" will evaluate and return r1. Otherwise it
+    # will continue with c2 and the result of this expression is not empty it will
+    # return r2. Otherwise it will continue with c3/r3 etc. 
+    #
+    # If an odd number of arguments is given, the last expression is evaluated if
+    # none of the conditions c1..cn gives a non-empty result.
+    #
+    # As a requirement, the result types of all r1..rn expressions and the rdef
+    # needs to be the same - i.e. all need to render polygons or edges or edge pairs.
+
+    def case(*args)
+
+      self._context("case") do
+
+        anum = 1
+
+        types = []
+        args.each do |a|
+          if !a.is_a?(DRCOpNode)
+            raise("All inputs need to be valid compound operation expressions (argument ##{anum} isn't)")
+          end
+          if a % 2 == 0
+            types << a.result_type
+          end
+          anum += 1
+        end
+
+        if types.sort.uniq.size > 1
+          raise("All result arguments need to have the same type (we got '" + types.collect(:to_s).join(",") + "')")
+        end
+
+        DRCOpNodeCase::new(self, args)
+
+      end
+
+    end
+    
+    # %DRC%
+    # @name secondary
+    # @brief Provides secondary input for the "drc" universal DRC function
+    # @synopsis secondary(layer)
+    #
+    # To supply additional input for the universal DRC expressions (see \drc), use
+    # "secondary" with a layer argument. This example provides a boolean AND
+    # between l1 and l2:
+    #
+    # @code
+    #   l1 = layer(1, 0)
+    #   l2 = layer(2, 0)
+    #   out = l1.drc(primary & secondary(l2))
+    # @/code
+     
+    def secondary(layer)
+
+      self._context("secondary") do
+
+        layer.requires_region
+
+        res = DRCOpNode::new(self, RBA::CompoundRegionOperationNode::new_secondary(layer.data))
+        res.description = "secondary"
+        return res
+
+      end
+
+    end
+    
+    # %DRC%
+    # @name primary
+    # @brief Represents the primary input of the universal DRC function
+    # @synopsis primary
+    #
+    # The primary input of the universal DRC function is the layer the \drc function
+    # is called on.
+    
+    def primary
+      res = DRCOpNode::new(self, RBA::CompoundRegionOperationNode::new_primary)
+      res.description = "primary"
+      return res
+    end
+    
+    # %DRC%
+    # @name if_all
+    # @brief Evaluates to the primary shape when all condition expression results are non-empty
+    # @synopsis if_all(c1, ... cn)
+    #
+    # This function will evaluate the conditions c1 to cn and return the 
+    # current primary shape if all conditions render a non-empty result.
+    # The following example selects all shapes which are rectangles and 
+    # whose area is larger than 0.5 square micrometers:
+    # 
+    # @code
+    # out = in.drc(if_all(area > 0.5, rectangle))
+    # @/code
+    #
+    # The condition expressions can be of any type (edges, edge pairs and polygons).
+     
+    # %DRC%
+    # @name if_any
+    # @brief Evaluates to the primary shape when any condition expression results is non-empty
+    # @synopsis if_any(c1, ... cn)
+    # 
+    # This function will evaluate the conditions c1 to cn and return the 
+    # current primary shape if at least one condition renders a non-empty result.
+    # See \if_all for an example how to use the if_... functions.
+      
+    # %DRC%
+    # @name if_none
+    # @brief Evaluates to the primary shape when all of the condition expression results are empty
+    # @synopsis if_none(c1, ... cn)
+    # 
+    # This function will evaluate the conditions c1 to cn and return the 
+    # current primary shape if all conditions renders an empty result.
+    # See \if_all for an example how to use the if_... functions.
+
+    %w(
+      if_all 
+      if_any
+      if_none
+    ).each do |f|
+      eval <<"CODE"
+        def #{f}(*args)
+
+          self._context("#{f}") do
+
+            args.each_with_index do |a,ia|
+              if ! a.is_a?(DRCOpNode)
+                raise("Argument #" + (ia + 1).to_s + " to #{f} must be a DRC expression")
+              end
+            end
+            res = DRCOpNodeLogicalBool::new(self, :#{f})
+            res.children = args
+            res
+
+          end
+
+        end
+CODE
+    end
+    
+    # %DRC%
+    # @name bbox_height
+    # @brief Selects primary shapes based on their bounding box height
+    # @synopsis bbox_height (in condition)
+    #
+    # This method creates a universal DRC expression (see \drc) to select primary shapes whose
+    # bounding box height satisfies the condition. Conditions can be written as arithmetic comparisons
+    # against numeric values. For example, "bbox_height < 2.0" will select all primary shapes whose
+    # bounding box height is less than 2 micrometers. See \drc for more details about comparison 
+    # specs.
+    
+    # %DRC%
+    # @name bbox_width
+    # @brief Selects primary shapes based on their bounding box width
+    # @synopsis bbox_max (in condition)
+    #
+    # See \bbox_height for more details.
+    
+    # %DRC%
+    # @name bbox_max
+    # @brief Selects primary shapes based on their bounding box height or width, whichever is larger
+    # @synopsis bbox_max (in condition)
+    #
+    # See \bbox_height for more details.
+    
+    # %DRC%
+    # @name bbox_min
+    # @brief Selects primary shapes based on their bounding box height or width, whichever is smaller
+    # @synopsis bbox_max (in condition)
+    #
+    # See \bbox_height for more details.
+    
+    %w(
+      bbox_height
+      bbox_max
+      bbox_min
+      bbox_width
+    ).each do |f|
+      eval <<"CODE"
+        def #{f}
+          self._context("#{f}") do
+            primary.#{f}
+          end
+        end
+CODE
+    end
+    
+    %w(
+      area
+      holes
+      hulls
+      odd_polygons
+      perimeter
+      rectangles
+      rectilinear
+    ).each do |f|
+      # NOTE: these methods are fallback for the respective global ones which route to DRCLayer or here.
+      eval <<"CODE"
+        def _cop_#{f}
+          primary.#{f}
+        end
+CODE
+    end
+    
+    def _cop_corners(as_dots = DRCAsDots::new(false))
+      # NOTE: this method is a fallback for the respective global ones which route to DRCLayer or here.
+      return primary.corners(as_dots)
+    end
+    
+    %w(
+      extent_refs
+      extents
+      middle
+      rounded_corners
+      sized
+      smoothed
+    ).each do |f|
+      # NOTE: these methods are fallback for the respective global ones which route to DRCLayer or here.
+      eval <<"CODE"
+        def _cop_#{f}(*args)
+          primary.#{f}(*args)
+        end
+CODE
+    end
+    
+    %w(
+      covering
+      inside
+      interacting
+      outside
+      overlapping
+    ).each do |f|
+      # NOTE: these methods are fallback for the respective global ones which route to DRCLayer or here.
+      eval <<"CODE"
+        def _cop_#{f}(other)
+          primary.#{f}(other)
+        end
+CODE
+    end
+    
+    %w(
+      enclosing
+      isolated
+      notch
+      overlap
+      separation
+      space
+      width
+    ).each do |f|
+      # NOTE: these methods are fallback for the respective global ones which route to DRCLayer or here.
+      eval <<"CODE"
+      def _cop_#{f}(*args)
+    
+        metrics = RBA::Region::Euclidian
+        minp = nil
+        maxp = nil
+        alim = nil
+        whole_edges = false
+        other = nil
+        shielded = nil
+        opposite_filter = RBA::Region::NoOppositeFilter
+        rect_filter = RBA::Region::NoRectFilter
+    
+        n = 1
+        args.each do |a|
+          if a.is_a?(DRCMetrics)
+            metrics = a.value
+          elsif a.is_a?(DRCWholeEdges)
+            whole_edges = a.value
+          elsif a.is_a?(DRCOppositeErrorFilter)
+            opposite_filter = a.value
+          elsif a.is_a?(DRCRectangleErrorFilter)
+            rect_filter = RBA::Region::RectFilter::new(a.value.to_i | rect_filter.to_i)
+          elsif a.is_a?(DRCAngleLimit)
+            alim = a.value
+          elsif a.is_a?(DRCOpNode)
+            other = a
+          elsif a.is_a?(DRCProjectionLimits)
+            minp = self._prep_value(a.min)
+            maxp = self._prep_value(a.max)
+          elsif a.is_a?(DRCShielded)
+            shielded = a.value
+          else
+            raise("Parameter #" + n.to_s + " does not have an expected type (is " + a.inspect + ")")
+          end
+          n += 1
+        end
+    
+        args = [ whole_edges, metrics, alim, minp, maxp ]
+    
+        args << (shielded == nil ? true : shielded)
+        if :#{f} != :width && :#{f} != :notch
+          args << opposite_filter
+          args << rect_filter
+        elsif opposite_filter != RBA::Region::NoOppositeFilter
+          raise("An opposite error filter cannot be used with this check")
+        elsif rect_filter != RBA::Region::NoRectFilter
+          raise("A rectangle error filter cannot be used with this check")
+        end
+        
+        if :#{f} == :width || :#{f} == :space || :#{f} == :notch || :#{f} == :isolated
+          if other
+            raise("No other layer must be specified for a single-layer check")
+          end
+        else
+          if !other
+            raise("The other layer must be specified for a two-layer check")
+          end
+        end
+        
+        DRCOpNodeCheck::new(self, :#{f}, other, *args)
+        
+      end  
+CODE
+    end
+    
+    def _cop_iso(*args)
+      # NOTE: this method is a fallback for the respective global ones which route to DRCLayer or here.
+      _cop_isolated(*args)
+    end
+    
+    def _cop_sep(*args)
+      # NOTE: this method is a fallback for the respective global ones which route to DRCLayer or here.
+      _cop_separation(*args)
+    end
+    
+    def _cop_enc(*args)
+      # NOTE: this method is a fallback for the respective global ones which route to DRCLayer or here.
+      _cop_separation(*args)
+    end
+
+  end
+
+end
+

src/drc/drc/built-in-macros/_drc_netter.rb

@@ -98,16 +98,20 @@ module DRC
 
     def connect(a, b)
 
-      a.is_a?(DRC::DRCLayer) || raise("First argument of Netter#connect must be a layer")
+      @engine._context("connect") do
-      b.is_a?(DRC::DRCLayer) || raise("Second argument of Netter#connect must be a layer")
-      a.requires_texts_or_region("Netter#connect (first argument)")
-      b.requires_texts_or_region("Netter#connect (second argument)")
 
-      register_layer(a.data)
+        a.is_a?(DRC::DRCLayer) || raise("First argument must be a layer")
-      register_layer(b.data)
+        b.is_a?(DRC::DRCLayer) || raise("Second argument must be a layer")
-      a.data.is_a?(RBA::Region) && @l2n.connect(a.data)
+        a.requires_texts_or_region
-      b.data.is_a?(RBA::Region) && @l2n.connect(b.data)
+        b.requires_texts_or_region
-      @l2n.connect(a.data, b.data)
+
+        register_layer(a.data)
+        register_layer(b.data)
+        a.data.is_a?(RBA::Region) && @l2n.connect(a.data)
+        b.data.is_a?(RBA::Region) && @l2n.connect(b.data)
+        @l2n.connect(a.data, b.data)
+
+      end
 
     end
 
@@ -122,12 +126,16 @@ module DRC
     
     def connect_global(l, name)
 
-      l.is_a?(DRC::DRCLayer) || raise("Layer argument of Netter#connect_global must be a layer")
+      @engine._context("connect_global") do
-      l.requires_texts_or_region("Netter#connect_global (layer argument)")
 
-      register_layer(l.data)
+        l.is_a?(DRC::DRCLayer) || raise("Layer argument must be a layer")
-      l.data.is_a?(RBA::Region) && @l2n.connect(l.data)
+        l.requires_texts_or_region
-      @l2n.connect_global(l.data, name)
+
+        register_layer(l.data)
+        l.data.is_a?(RBA::Region) && @l2n.connect(l.data)
+        @l2n.connect_global(l.data, name)
+
+      end
 
     end
     
@@ -186,22 +194,26 @@ module DRC
     
     def extract_devices(devex, layer_selection)
     
-      ensure_data
+      @engine._context("extract_devices") do
 
-      devex.is_a?(RBA::DeviceExtractorBase) || raise("First argument of Netter#extract_devices must be a device extractor instance in the two-arguments form")
+        ensure_data
 
-      layer_selection.is_a?(Hash) || raise("Second argument of Netter#extract_devices must be a hash")
+        devex.is_a?(RBA::DeviceExtractorBase) || raise("First argument of must be a device extractor instance in the two-arguments form")
+
+        layer_selection.is_a?(Hash) || raise("Second argument must be a hash")
+
+        ls = {}
+        layer_selection.keys.sort.each do |n|
+          l = layer_selection[n]
+          l.requires_texts_or_region
+          register_layer(l.data)
+          ls[n.to_s] = l.data
+        end
+
+        @engine._cmd(@l2n, :extract_devices, devex, ls) 
 
-      ls = {}
-      layer_selection.keys.sort.each do |n|
-        l = layer_selection[n]
-        l.requires_texts_or_region("Netter#extract_devices (#{n} layer)")
-        register_layer(l.data)
-        ls[n.to_s] = l.data
       end
 
-      @engine._cmd(@l2n, :extract_devices, devex, ls) 
-
     end
 
     # %DRC%
@@ -213,8 +225,10 @@ module DRC
     # does not correspond to the physical dimensions.
     
     def device_scaling(factor)
-      @device_scaling = factor
+      @engine._context("device_scaling") do
-      @l2n && @l2n.device_scaling = factor
+        @device_scaling = factor
+        @l2n && @l2n.device_scaling = factor
+      end
     end
     
     # %DRC%
@@ -254,16 +268,22 @@ module DRC
     # on "clear_connections".
 
     def connect_implicit(arg1, arg2 = nil)
-      cleanup
+
-      if arg2
+      @engine._context("connect_implicit") do
-        (arg2.is_a?(String) && arg2 != "") || raise("The second argument of 'connect_implicit' has to be a non-empty string")
+
-        arg1.is_a?(String) || raise("The first argument of 'connect_implicit' has to be a string")
+        cleanup
-        @connect_implicit_per_cell[arg1] ||= []
+        if arg2
-        @connect_implicit_per_cell[arg1] << arg2
+          (arg2.is_a?(String) && arg2 != "") || raise("The second argument has to be a non-empty string")
-      else
+          arg1.is_a?(String) || raise("The first argument has to be a string")
-        arg1.is_a?(String) || raise("The argument of 'connect_implicit' has to be a string")
+          @connect_implicit_per_cell[arg1] ||= []
-        @connect_implicit << arg1
+          @connect_implicit_per_cell[arg1] << arg2
+        else
+          arg1.is_a?(String) || raise("The argument has to be a string")
+          @connect_implicit << arg1
+        end
+
       end
+
     end
 
     # %DRC%
@@ -388,56 +408,60 @@ module DRC
 
     def antenna_check(agate, ametal, ratio, *diodes)
 
-      gate_perimeter_factor = 0.0
+      @engine._context("antenna_check") do
-      gate_area_factor = 1.0
+
-      if agate.is_a?(DRC::DRCLayer)
+        gate_perimeter_factor = 0.0
-        gate = agate
+        gate_area_factor = 1.0
-      elsif agate.is_a?(DRC::DRCAreaAndPerimeter)
+        if agate.is_a?(DRC::DRCLayer)
-        gate = agate.region
+          gate = agate
-        gate_perimeter_factor = agate.perimeter_factor
+        elsif agate.is_a?(DRC::DRCAreaAndPerimeter)
-        gate_area_factor = agate.area_factor
+          gate = agate.region
-        if ! gate.is_a?(DRC::DRCLayer)
+          gate_perimeter_factor = agate.perimeter_factor
-          raise("gate with area or area_and_perimeter: input argument must be a layer")
+          gate_area_factor = agate.area_factor
+          if ! gate.is_a?(DRC::DRCLayer)
+            raise("Gate with area or area_and_perimeter: input argument must be a layer")
+          end
+        else
+          raise("Gate argument must be a layer ")
         end
-      else
-        raise("gate argument of Netter#antenna_check must be a layer ")
-      end
 
-      gate.requires_region("Netter#antenna_check (gate argument)")
+        gate.requires_region
 
-      metal_perimeter_factor = 0.0
+        metal_perimeter_factor = 0.0
-      metal_area_factor = 1.0
+        metal_area_factor = 1.0
-      if ametal.is_a?(DRC::DRCLayer)
+        if ametal.is_a?(DRC::DRCLayer)
-        metal = ametal
+          metal = ametal
-      elsif ametal.is_a?(DRC::DRCAreaAndPerimeter)
+        elsif ametal.is_a?(DRC::DRCAreaAndPerimeter)
-        metal = ametal.region
+          metal = ametal.region
-        metal_perimeter_factor = ametal.perimeter_factor
+          metal_perimeter_factor = ametal.perimeter_factor
-        metal_area_factor = ametal.area_factor
+          metal_area_factor = ametal.area_factor
-        if ! metal.is_a?(DRC::DRCLayer)
+          if ! metal.is_a?(DRC::DRCLayer)
-          raise("metal with area or area_and_perimeter: input argument must be a layer")
+            raise("Metal with area or area_and_perimeter: input argument must be a layer")
+          end
+        else
+          raise("Metal argument must be a layer")
         end
-      else
-        raise("metal argument of Netter#antenna_check must be a layer")
-      end
 
-      metal.requires_region("Netter#antenna_check (metal argument)")
+        metal.requires_region
 
-      if !ratio.is_a?(1.class) && !ratio.is_a?(Float)
+        if !ratio.is_a?(1.class) && !ratio.is_a?(Float)
-        raise("ratio argument Netter#antenna_check is not a number")
+          raise("Ratio argument is not a number")
-      end
-
-      dl = diodes.collect do |d|
-        if d.is_a?(Array)
-          d.size == 2 || raise("diode specification pair expects two elements")
-          d[0].requires_region("Netter#antenna_check (diode layer)")
-          [ d[0].data, d[1].to_f ]
-        else 
-          d.requires_region("Netter#antenna_check (diode layer)")
-          [ d.data, 0.0 ]
         end
-      end
 
-      DRC::DRCLayer::new(@engine, @engine._cmd(l2n_data, :antenna_check, gate.data, gate_area_factor, gate_perimeter_factor, metal.data, metal_area_factor, metal_perimeter_factor, ratio, dl))
+        dl = diodes.collect do |d|
+          if d.is_a?(Array)
+            d.size == 2 || raise("Diode specification pair expects two elements")
+            d[0].requires_region
+            [ d[0].data, d[1].to_f ]
+          else 
+            d.requires_region
+            [ d.data, 0.0 ]
+          end
+        end
+
+        DRC::DRCLayer::new(@engine, @engine._cmd(l2n_data, :antenna_check, gate.data, gate_area_factor, gate_perimeter_factor, metal.data, metal_area_factor, metal_perimeter_factor, ratio, dl))
+
+      end
 
     end
 
@@ -450,27 +474,31 @@ module DRC
 
     def l2n_data
 
-      ensure_data
+      @engine._context("l2n_data") do
 
-      # run extraction in a timed environment
+        ensure_data
-      if ! @netlisted
 
-        # build a glob expression from the parts
+        # run extraction in a timed environment
-        expr = _join_glob_pattern(@connect_implicit)
+        if ! @netlisted
+
+          # build a glob expression from the parts
+          expr = _join_glob_pattern(@connect_implicit)
+
+          # build cell-pattern specific glob expressions from the parts
+          per_cell_expr = {}
+          @connect_implicit_per_cell.each do |cell_pattern,label_pattern|
+            per_cell_expr[cell_pattern] = _join_glob_pattern(label_pattern)
+          end
+
+          @engine._cmd(@l2n, :extract_netlist, expr, per_cell_expr)
+          @netlisted = true
 
-        # build cell-pattern specific glob expressions from the parts
-        per_cell_expr = {}
-        @connect_implicit_per_cell.each do |cell_pattern,label_pattern|
-          per_cell_expr[cell_pattern] = _join_glob_pattern(label_pattern)
         end
 
-        @engine._cmd(@l2n, :extract_netlist, expr, per_cell_expr)
+        @l2n
-        @netlisted = true
 
       end
 
-      @l2n
-
     end
 
     # %DRC%
@@ -482,7 +510,9 @@ module DRC
     # calls must have been made before this method is used. Further \connect
     # statements will clear the netlist and re-extract it again.
     def netlist
-      l2n_data && @l2n.netlist
+      @engine._context("netlist") do
+        l2n_data && @l2n.netlist
+      end
     end
     
     def _finish

src/drc/drc/built-in-macros/_drc_source.rb

@@ -78,20 +78,27 @@ module DRC
     end
 
     def set_box(method, *args)
-      box = nil
+
-      if args.size == 1
+      @engine._context(method) do
-        box = args[0]
+
-        box.is_a?(RBA::DBox) || raise("'#{method}' method requires a box specification")
+        box = nil
-      elsif args.size == 2
+        if args.size == 1
-        (args[0].is_a?(RBA::DPoint) && args[1].is_a?(RBA::DPoint)) || raise("'#{method}' method requires a box specification with two points")
+          box = args[0]
-        box = RBA::DBox::new(args[0], args[1])
+          box.is_a?(RBA::DBox) || raise("Method requires a box specification")
-      elsif args.size == 4
+        elsif args.size == 2
-        box = RBA::DBox::new(*args)
+          (args[0].is_a?(RBA::DPoint) && args[1].is_a?(RBA::DPoint)) || raise("Method requires a box specification with two points")
-      else 
+          box = RBA::DBox::new(args[0], args[1])
-        raise("Invalid number of arguments for '#{method}' method")
+        elsif args.size == 4
+          box = RBA::DBox::new(*args)
+        else 
+          raise("Invalid number of arguments (1, 2 or 4 expected)")
+        end
+        @box = RBA::Box::from_dbox(box * (1.0 / @layout.dbu))
+
+        self
+
       end
-      @box = RBA::Box::from_dbox(box * (1.0 / @layout.dbu))
+
-      self
     end
     
     def inplace_clip(*args)
@@ -113,17 +120,21 @@ module DRC
     end
     
     def inplace_cell(arg)
-      @cell = layout.cell(arg)
+      @engine._context("inplace_cell") do
-      @cell ||= layout.create_cell(arg)
+        @cell = layout.cell(arg)
-      self  
+        @cell ||= layout.create_cell(arg)
+        self  
+      end
     end
     
     def inplace_select(*args)
-      args.each do |a|
+      @engine._context("inplace_select") do
-        a.is_a?(String) || raise("Invalid arguments to 'select' method - must be strings")
+        args.each do |a|
-        @sel.push(a)
+          a.is_a?(String) || raise("Invalid arguments - must be strings")
+          @sel.push(a)
+        end
+        self
       end
-      self
     end
     
     # %DRC%
@@ -238,9 +249,11 @@ module DRC
     %w(select cell clip touching overlapping).each do |f|
       eval <<"CODE"
         def #{f}(*args)
-          s = self.dup
+          @engine._context("#{f}") do
-          s.inplace_#{f}(*args)
+            s = self.dup
-          s
+            s.inplace_#{f}(*args)
+            s
+          end
         end
 CODE
     end
@@ -256,13 +269,15 @@ CODE
     # @/code
     
     def extent
-      layer = input
+      @engine._context("extent") do
-      if @box
+        layer = input
-        layer.insert(RBA::DBox::from_ibox(@box) * @layout.dbu)
+        if @box
-      else
+          layer.insert(RBA::DBox::from_ibox(@box) * @layout.dbu)
-        layer.insert(RBA::DBox::from_ibox(@cell.bbox) * @layout.dbu)
+        else
+          layer.insert(RBA::DBox::from_ibox(@cell.bbox) * @layout.dbu)
+        end
+        layer
       end
-      layer
     end
           
     # %DRC%
@@ -309,8 +324,10 @@ CODE
     # Use the global version of "input" without a source object to address the default source.
     
     def input(*args)
-      layers = parse_input_layers(*args)
+      @engine._context("input") do
-      DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SAll, RBA::Region))
+        layers = parse_input_layers(*args)
+        DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SAll, RBA::Region))
+      end
     end
 
     # %DRC%
@@ -331,8 +348,10 @@ CODE
     # Use the global version of "labels" without a source object to address the default source.
     
     def labels(*args)
-      layers = parse_input_layers(*args)
+      @engine._context("labels") do
-      DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::STexts, RBA::Texts))
+        layers = parse_input_layers(*args)
+        DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::STexts, RBA::Texts))
+      end
     end
 
     # %DRC%
@@ -352,8 +371,10 @@ CODE
     # Use the global version of "polygons" without a source object to address the default source.
     
     def polygons(*args)
-      layers = parse_input_layers(*args)
+      @engine._context("polygons") do
-      DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SBoxes | RBA::Shapes::SPaths | RBA::Shapes::SPolygons | RBA::Shapes::SEdgePairs, RBA::Region))
+        layers = parse_input_layers(*args)
+        DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SBoxes | RBA::Shapes::SPaths | RBA::Shapes::SPolygons | RBA::Shapes::SEdgePairs, RBA::Region))
+      end
     end
 
     # %DRC%
@@ -376,8 +397,10 @@ CODE
     # This method has been introduced in version 0.27.
     
     def edges(*args)
-      layers = parse_input_layers(*args)
+      @engine._context("edges") do
-      DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SBoxes | RBA::Shapes::SPaths | RBA::Shapes::SPolygons | RBA::Shapes::SEdgePairs | RBA::Shapes::SEdges, RBA::Edges))
+        layers = parse_input_layers(*args)
+        DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SBoxes | RBA::Shapes::SPaths | RBA::Shapes::SPolygons | RBA::Shapes::SEdgePairs | RBA::Shapes::SEdges, RBA::Edges))
+      end
     end
 
     # %DRC%
@@ -400,8 +423,10 @@ CODE
     # This method has been introduced in version 0.27.
     
     def edge_pairs(*args)
-      layers = parse_input_layers(*args)
+      @engine._context("edge_pairs") do
-      DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SEdgePairs, RBA::EdgePairs))
+        layers = parse_input_layers(*args)
+        DRCLayer::new(@engine, @engine._cmd(@engine, :_input, @layout_var, @cell.cell_index, layers, @sel, @box, @clip, @overlapping, RBA::Shapes::SEdgePairs, RBA::EdgePairs))
+      end
     end
 
     # %DRC%

src/drc/drc/drcResources.qrc

@@ -6,6 +6,8 @@
         <file alias="_drc_patch.rb">built-in-macros/_drc_patch.rb</file>
         <file alias="_drc_source.rb">built-in-macros/_drc_source.rb</file>
         <file alias="_drc_tags.rb">built-in-macros/_drc_tags.rb</file>
+        <file alias="_drc_complex_ops.rb">built-in-macros/_drc_complex_ops.rb</file>
+        <file alias="_drc_cop_integration.rb">built-in-macros/_drc_cop_integration.rb</file>
         <file alias="drc_interpreters.lym">built-in-macros/drc_interpreters.lym</file>
         <file alias="drc_install.lym">built-in-macros/drc_install.lym</file>
     </qresource>

tmp_devel/complex_drc_devel.lym

@@ -21,10 +21,10 @@ class DRCLayer
 
   def drc(op)
     requires_region("drc")
-    return DRCLayer::new(@engine, self.data.complex_op(op.create_node))
+    return DRCLayer::new(@engine, self.data.complex_op(op.create_node({})))
   end
   
-end  
+end
 
 class DRCOpNode
 
@@ -37,7 +37,16 @@ class DRCOpNode
     self.description = "Basic"
   end
   
-  def create_node
+  def create_node(cache)
+    n = cache[self.object_id]
+    if !n
+      n = self.do_create_node(cache)
+      cache[self.object_id] = n
+    end
+    n
+  end
+  
+  def do_create_node(cache)
     @node
   end
   
@@ -342,9 +351,9 @@ class DRCOpNodeLogicalBool < DRCOpNode
     return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
   end
 
-  def create_node
+  def do_create_node(cache)
     log_op = { :land => RBA::CompoundRegionOperationNode::LogicalOp::LogAnd, :lor => RBA::CompoundRegionOperationNode::LogicalOp::LogOr }[self.op]
-    RBA::CompoundRegionOperationNode::new_logical_boolean(log_op, false, self.children.collect { |c| c.create_node })
+    RBA::CompoundRegionOperationNode::new_logical_boolean(log_op, false, self.children.collect { |c| c.create_node(cache) })
   end
   
 end
@@ -365,14 +374,14 @@ class DRCOpNodeBool < DRCOpNode
     return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
   end
 
-  def create_node
+  def do_create_node(cache)
     bool_op = { :& => RBA::CompoundRegionOperationNode::GeometricalOp::And, 
                 :+ => RBA::CompoundRegionOperationNode::GeometricalOp::Or,
                 :| => RBA::CompoundRegionOperationNode::GeometricalOp::Or,
                 :- => RBA::CompoundRegionOperationNode::GeometricalOp::Not,
                 :^ => RBA::CompoundRegionOperationNode::GeometricalOp::Xor }[self.op]
     nodes = self.children.collect do |c| 
-      n = c.create_node
+      n = c.create_node(cache)
       if n.result_type == RBA::CompoundRegionOperationNode::ResultType::EdgePairs
         n = RBA::CompoundRegionOperationNode::new_edge_pair_to_first_edges(n)
       end
@@ -397,8 +406,8 @@ class DRCOpNodeCase < DRCOpNode
     return indent + self.description + "\n" + self.children.collect { |c| c.dump("  " + indent) }.join("\n")
   end
   
-  def create_node
+  def do_create_node(cache)
-    RBA::CompoundRegionOperationNode::new_case(self.children.collect { |c| c.create_node })
+    RBA::CompoundRegionOperationNode::new_case(self.children.collect { |c| c.create_node(cache) })
   end
 
 end
@@ -556,8 +565,8 @@ class DRCOpNodeAreaFilter < DRCOpNodeWithCompare
     self.inverted ? "area" : "not_area"
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node, self.inverse ]
+    args = [ self.input.create_node(cache), self.inverse ]
     args << (self.gt ? make_area_value(self.gt) + 1 : (self.ge ? make_area_value(self.ge) : 0))
     if self.lt || self.le
       args << self.lt ? make_area_value(self.lt) : make_area_value(self.le) - 1
@@ -589,8 +598,8 @@ class DRCOpNodeEdgeLengthFilter < DRCOpNodeWithCompare
     self.inverted ? "length" : "not_length"
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node, self.inverse ]
+    args = [ self.input.create_node(cache), self.inverse ]
     args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
     if self.lt || self.le
       args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
@@ -622,8 +631,8 @@ class DRCOpNodeEdgeOrientationFilter < DRCOpNodeWithCompare
     self.inverted ? "angle" : "not_angle"
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node, self.inverse ]
+    args = [ self.input.create_node(cache), self.inverse ]
     angle_delta = 1e-6
     args << (self.gt ? self.gt + angle_delta : (self.ge ? self.ge : -180.0))
     args << (self.lt ? self.lt : (self.le ? self.le - angle_delta : 180.0))
@@ -654,8 +663,8 @@ class DRCOpNodePerimeterFilter < DRCOpNodeWithCompare
     self.inverted ? "perimeter" : "not_perimeter"
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node, self.inverse ]
+    args = [ self.input.create_node(cache), self.inverse ]
     args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
     if self.lt || self.le
       args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
@@ -686,8 +695,8 @@ class DRCOpNodeInteractingWithCount < DRCOpNodeWithCompare
     self.description = (self.inverted ? "" : "not_") + self.op.to_s
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.a.create_node, self.b.create_node, self.inverse ]
+    args = [ self.a.create_node(cache), self.b.create_node(cache), self.inverse ]
     args << (self.gt ? self.gt + 1 : (self.ge ? self.ge : 0))
     if self.lt || self.le
       args << self.lt ? self.lt : self.le - 1
@@ -721,10 +730,10 @@ class DRCOpNodeInteracting < DRCOpNode
     self.description = (self.inverted ? "" : "not_") + self.op.to_s
   end
   
-  def create_node
+  def do_create_node(cache)
     factory = { :inside => :new_inside,
                 :outside => :new_outside }[self.op]
-    RBA::CompoundRegionOperationNode::send(factory, self.a.create_node, self.b.create_node, self.inverse)
+    RBA::CompoundRegionOperationNode::send(factory, self.a.create_node(cache), self.b.create_node(cache), self.inverse)
   end
 
   def inverted
@@ -741,7 +750,7 @@ class DRCOpNodeFilter < DRCOpNode
   attr_accessor :factory
   attr_accessor :args
   
-  def initialize(engine, input, factory, description, args = [])
+  def initialize(engine, input, factory, description, *args)
     super(engine)
     self.input = input
     self.factory = factory
@@ -757,8 +766,8 @@ class DRCOpNodeFilter < DRCOpNode
     end
   end
   
-  def create_node
+  def do_create_node(cache)
-    RBA::CompoundRegionOperationNode::send(self.factory, self.input.create_node, *args)
+    RBA::CompoundRegionOperationNode::send(self.factory, self.input.create_node(cache), *args)
   end
   
 end
@@ -785,7 +794,7 @@ class DRCOpNodeCheck < DRCOpNodeWithCompare
     end
   end
   
-  def create_node
+  def do_create_node(cache)
   
     if !(self.lt || self.le) && !(self.gt || self.ge)
       raise("No value given for check #{self.check}")
@@ -840,8 +849,8 @@ class DRCOpNodeBBoxParameterFilter < DRCOpNodeWithCompare
     self.description = description
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node, self.inverse ]
+    args = [ self.input.create_node(cache), self.inverse ]
     args << (self.gt ? self._make_value(self.gt, :gt) + 1 : (self.ge ? self._make_value(self.ge, :ge) : 0))
     if self.lt || self.le
       args << self.lt ? self._make_value(self.lt, :lt) : self._make_value(self.le, :le) - 1
@@ -870,8 +879,8 @@ class DRCOpNodeCornersFilter < DRCOpNodeWithCompare
     self.description = "corners"
   end
   
-  def create_node
+  def do_create_node(cache)
-    args = [ self.input.create_node ]
+    args = [ self.input.create_node(cache) ]
     angle_delta = 1e-6
     args << (self.gt ? self.gt + angle_delta : (self.ge ? self.ge : -180.0))
     args << (self.lt ? self.lt : (self.le ? self.le - angle_delta : 180.0))
@@ -905,7 +914,7 @@ class DRCOpNodeRelativeExtents < DRCOpNode
     end
   end
       
-  def create_node
+  def do_create_node(cache)
     if !self.as_edges
       RBA::CompoundRegionOperationNode::new_relative_extents_as_edges(self.input, self.fx1, self.fx2, self.fy1, self.fy2, self.dx, self.dy)
     else
@@ -929,7 +938,7 @@ class DRCEngine
   end
   
   def secondary(layer)
-    layer.requires_region
+    layer.requires_region("secondary")
     res = DRCOpNode::new(self, RBA::CompoundRegionOperationNode::new_secondary(layer.data))
     res.description = "secondary"
     return res