Fix handling of multi-line strings per #66

2 files changed, 928 insertions, 890 deletions

diff --git a/gerber/excellon.py b/gerber/excellon.py
index c3de948..5ab062a 100755
--- a/gerber/excellon.py
+++ b/gerber/excellon.py
@@ -1,887 +1,904 @@
-#!/usr/bin/env python

-# -*- coding: utf-8 -*-

-

-# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>

-

-# Licensed under the Apache License, Version 2.0 (the "License");

-# you may not use this file except in compliance with the License.

-# You may obtain a copy of the License at

-

-#     http://www.apache.org/licenses/LICENSE-2.0

-

-# Unless required by applicable law or agreed to in writing, software

-# distributed under the License is distributed on an "AS IS" BASIS,

-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

-# See the License for the specific language governing permissions and

-# limitations under the License.

-

-"""

-Excellon File module

-====================

-**Excellon file classes**

-

-This module provides Excellon file classes and parsing utilities

-"""

-

-import math

-import operator

-

-from .cam import CamFile, FileSettings

-from .excellon_statements import *

-from .excellon_tool import ExcellonToolDefinitionParser

-from .primitives import Drill, Slot

-from .utils import inch, metric

-

-

-try:

-    from cStringIO import StringIO

-except(ImportError):

-    from io import StringIO

-

-

-

-def read(filename):

-    """ Read data from filename and return an ExcellonFile

-    Parameters

-        ----------

-    filename : string

-        Filename of file to parse

-

-    Returns

-    -------

-    file : :class:`gerber.excellon.ExcellonFile`

-        An ExcellonFile created from the specified file.

-

-    """

-    # File object should use settings from source file by default.

-    with open(filename, 'rU') as f:

-        data = f.read()

-    settings = FileSettings(**detect_excellon_format(data))

-    return ExcellonParser(settings).parse(filename)

-

-def loads(data, filename=None, settings=None, tools=None):

-    """ Read data from string and return an ExcellonFile

-    Parameters

-    ----------

-    data : string

-        string containing Excellon file contents

-

-    filename : string, optional

-        string containing the filename of the data source

-

-    tools: dict (optional)

-        externally defined tools

-

-    Returns

-    -------

-    file : :class:`gerber.excellon.ExcellonFile`

-        An ExcellonFile created from the specified file.

-

-    """

-    # File object should use settings from source file by default.

-    if not settings:

-        settings = FileSettings(**detect_excellon_format(data))

-    return ExcellonParser(settings, tools).parse_raw(data, filename)

-

-

-class DrillHit(object):

-    """Drill feature that is a single drill hole.

-

-    Attributes

-    ----------

-    tool : ExcellonTool

-        Tool to drill the hole. Defines the size of the hole that is generated.

-    position : tuple(float, float)

-        Center position of the drill.

-

-    """

-    def __init__(self, tool, position):

-        self.tool = tool

-        self.position = position

-

-    def to_inch(self):

-        if self.tool.settings.units == 'metric':

-            self.tool.to_inch()

-            self.position = tuple(map(inch, self.position))

-

-    def to_metric(self):

-        if self.tool.settings.units == 'inch':

-            self.tool.to_metric()

-            self.position = tuple(map(metric, self.position))

-

-    @property

-    def bounding_box(self):

-        position = self.position

-        radius = self.tool.diameter / 2.

-

-        min_x = position[0] - radius

-        max_x = position[0] + radius

-        min_y = position[1] - radius

-        max_y = position[1] + radius

-        return ((min_x, max_x), (min_y, max_y))

-

-    def offset(self, x_offset=0, y_offset=0):

-        self.position = tuple(map(operator.add, self.position, (x_offset, y_offset)))

-

-    def __str__(self):

-        return 'Hit (%f, %f) {%s}' % (self.position[0], self.position[1], self.tool)

-

-class DrillSlot(object):

-    """

-    A slot is created between two points. The way the slot is created depends on the statement used to create it

-    """

-

-    TYPE_ROUT = 1

-    TYPE_G85 = 2

-

-    def __init__(self, tool, start, end, slot_type):

-        self.tool = tool

-        self.start = start

-        self.end = end

-        self.slot_type = slot_type

-

-    def to_inch(self):

-        if self.tool.settings.units == 'metric':

-            self.tool.to_inch()

-            self.start = tuple(map(inch, self.start))

-            self.end = tuple(map(inch, self.end))

-

-    def to_metric(self):

-        if self.tool.settings.units == 'inch':

-            self.tool.to_metric()

-            self.start = tuple(map(metric, self.start))

-            self.end = tuple(map(metric, self.end))

-

-    @property

-    def bounding_box(self):

-        start = self.start

-        end = self.end

-        radius = self.tool.diameter / 2.

-        min_x = min(start[0], end[0]) - radius

-        max_x = max(start[0], end[0]) + radius

-        min_y = min(start[1], end[1]) - radius

-        max_y = max(start[1], end[1]) + radius

-        return ((min_x, max_x), (min_y, max_y))

-

-    def offset(self, x_offset=0, y_offset=0):

-        self.start = tuple(map(operator.add, self.start, (x_offset, y_offset)))

-        self.end = tuple(map(operator.add, self.end, (x_offset, y_offset)))

-

-

-class ExcellonFile(CamFile):

-    """ A class representing a single excellon file

-

-    The ExcellonFile class represents a single excellon file.

-

-    http://www.excellon.com/manuals/program.htm

-    (archived version at https://web.archive.org/web/20150920001043/http://www.excellon.com/manuals/program.htm)

-

-    Parameters

-    ----------

-    tools : list

-        list of gerber file statements

-

-    hits : list of tuples

-        list of drill hits as (<Tool>, (x, y))

-

-    settings : dict

-        Dictionary of gerber file settings

-

-    filename : string

-        Filename of the source gerber file

-

-    Attributes

-    ----------

-    units : string

-        either 'inch' or 'metric'.

-

-    """

-

-    def __init__(self, statements, tools, hits, settings, filename=None):

-        super(ExcellonFile, self).__init__(statements=statements,

-                                           settings=settings,

-                                           filename=filename)

-        self.tools = tools

-        self.hits = hits

-

-    @property

-    def primitives(self):

-        """

-        Gets the primitives. Note that unlike Gerber, this generates new objects

-        """

-        primitives = []

-        for hit in self.hits:

-            if isinstance(hit, DrillHit):

-                primitives.append(Drill(hit.position, hit.tool.diameter,

-                                        units=self.settings.units))

-            elif isinstance(hit, DrillSlot):

-                primitives.append(Slot(hit.start, hit.end, hit.tool.diameter,

-                                       units=self.settings.units))

-            else:

-                raise ValueError('Unknown hit type')

-        return primitives

-

-    @property

-    def bounding_box(self):

-        xmin = ymin = 100000000000

-        xmax = ymax = -100000000000

-        for hit in self.hits:

-            bbox = hit.bounding_box

-            xmin = min(bbox[0][0], xmin)

-            xmax = max(bbox[0][1], xmax)

-            ymin = min(bbox[1][0], ymin)

-            ymax = max(bbox[1][1], ymax)

-        return ((xmin, xmax), (ymin, ymax))

-

-    def report(self, filename=None):

-        """ Print or save drill report

-        """

-        if self.settings.units == 'inch':

-            toolfmt = '  T{:0>2d}      {:%d.%df}     {: >3d}     {:f}in.\n' % self.settings.format

-        else:

-            toolfmt = '  T{:0>2d}      {:%d.%df}     {: >3d}     {:f}mm\n' % self.settings.format

-        rprt = '=====================\nExcellon Drill Report\n=====================\n'

-        if self.filename is not None:

-            rprt += 'NC Drill File: %s\n\n' % self.filename

-        rprt += 'Drill File Info:\n----------------\n'

-        rprt += ('  Data Mode         %s\n' % 'Absolute'

-                 if self.settings.notation == 'absolute' else 'Incremental')

-        rprt += ('  Units             %s\n' % 'Inches'

-                 if self.settings.units == 'inch' else 'Millimeters')

-        rprt += '\nTool List:\n----------\n\n'

-        rprt += '  Code      Size     Hits    Path Length\n'

-        rprt += '  --------------------------------------\n'

-        for tool in iter(self.tools.values()):

-            rprt += toolfmt.format(tool.number, tool.diameter,

-                                   tool.hit_count, self.path_length(tool.number))

-        if filename is not None:

-            with open(filename, 'w') as f:

-                f.write(rprt)

-        return rprt

-

-    def write(self, filename=None):

-        filename = filename if filename is not None else self.filename

-        with open(filename, 'w') as f:

-

-            # Copy the header verbatim

-            for statement in self.statements:

-                if not isinstance(statement, ToolSelectionStmt):

-                    f.write(statement.to_excellon(self.settings) + '\n')

-                else:

-                    break

-

-            # Write out coordinates for drill hits by tool

-            for tool in iter(self.tools.values()):

-                f.write(ToolSelectionStmt(tool.number).to_excellon(self.settings) + '\n')

-                for hit in self.hits:

-                    if hit.tool.number == tool.number:

-                        f.write(CoordinateStmt(

-                            *hit.position).to_excellon(self.settings) + '\n')

-            f.write(EndOfProgramStmt().to_excellon() + '\n')

-

-    def to_inch(self):

-        """

-        Convert units to inches

-        """

-        if self.units != 'inch':

-            for statement in self.statements:

-                statement.to_inch()

-            for tool in iter(self.tools.values()):

-                tool.to_inch()

-            #for primitive in self.primitives:

-            #    primitive.to_inch()

-            #for hit in self.hits:

-            #    hit.to_inch()

-            self.units = 'inch'

-

-    def to_metric(self):

-        """  Convert units to metric

-        """

-        if self.units != 'metric':

-            for statement in self.statements:

-                statement.to_metric()

-            for tool in iter(self.tools.values()):

-                tool.to_metric()

-            #for primitive in self.primitives:

-            #    print("Converting to metric: {}".format(primitive))

-            #    primitive.to_metric()

-            #    print(primitive)

-            for hit in self.hits:

-                hit.to_metric()

-            self.units = 'metric'

-

-    def offset(self, x_offset=0, y_offset=0):

-        for statement in self.statements:

-            statement.offset(x_offset, y_offset)

-        for primitive in self.primitives:

-            primitive.offset(x_offset, y_offset)

-        for hit in self. hits:

-            hit.offset(x_offset, y_offset)

-

-    def path_length(self, tool_number=None):

-        """ Return the path length for a given tool

-        """

-        lengths = {}

-        positions = {}

-        for hit in self.hits:

-            tool = hit.tool

-            num = tool.number

-            positions[num] = ((0, 0) if positions.get(num) is None

-                              else positions[num])

-            lengths[num] = 0.0 if lengths.get(num) is None else lengths[num]

-            lengths[num] = lengths[

-                num] + math.hypot(*tuple(map(operator.sub, positions[num], hit.position)))

-            positions[num] = hit.position

-

-        if tool_number is None:

-            return lengths

-        else:

-            return lengths.get(tool_number)

-

-    def hit_count(self, tool_number=None):

-        counts = {}

-        for tool in iter(self.tools.values()):

-            counts[tool.number] = tool.hit_count

-        if tool_number is None:

-            return counts

-        else:

-            return counts.get(tool_number)

-

-    def update_tool(self, tool_number, **kwargs):

-        """ Change parameters of a tool

-        """

-        if kwargs.get('feed_rate') is not None:

-            self.tools[tool_number].feed_rate = kwargs.get('feed_rate')

-        if kwargs.get('retract_rate') is not None:

-            self.tools[tool_number].retract_rate = kwargs.get('retract_rate')

-        if kwargs.get('rpm') is not None:

-            self.tools[tool_number].rpm = kwargs.get('rpm')

-        if kwargs.get('diameter') is not None:

-            self.tools[tool_number].diameter = kwargs.get('diameter')

-        if kwargs.get('max_hit_count') is not None:

-            self.tools[tool_number].max_hit_count = kwargs.get('max_hit_count')

-        if kwargs.get('depth_offset') is not None:

-            self.tools[tool_number].depth_offset = kwargs.get('depth_offset')

-        # Update drill hits

-        newtool = self.tools[tool_number]

-        for hit in self.hits:

-            if hit.tool.number == newtool.number:

-                hit.tool = newtool

-

-

-class ExcellonParser(object):

-    """ Excellon File Parser

-

-    Parameters

-    ----------

-    settings : FileSettings or dict-like

-        Excellon file settings to use when interpreting the excellon file.

-    """

-    def __init__(self, settings=None, ext_tools=None):

-        self.notation = 'absolute'

-        self.units = 'inch'

-        self.zeros = 'leading'

-        self.format = (2, 4)

-        self.state = 'INIT'

-        self.statements = []

-        self.tools = {}

-        self.ext_tools = ext_tools or {}

-        self.comment_tools = {}

-        self.hits = []

-        self.active_tool = None

-        self.pos = [0., 0.]

-        self.drill_down = False

-        # Default for plated is None, which means we don't know

-        self.plated = ExcellonTool.PLATED_UNKNOWN

-        if settings is not None:

-            self.units = settings.units

-            self.zeros = settings.zeros

-            self.notation = settings.notation

-            self.format = settings.format

-

-    @property

-    def coordinates(self):

-        return [(stmt.x, stmt.y) for stmt in self.statements if isinstance(stmt, CoordinateStmt)]

-

-    @property

-    def bounds(self):

-        xmin = ymin = 100000000000

-        xmax = ymax = -100000000000

-        for x, y in self.coordinates:

-            if x is not None:

-                xmin = x if x < xmin else xmin

-                xmax = x if x > xmax else xmax

-            if y is not None:

-                ymin = y if y < ymin else ymin

-                ymax = y if y > ymax else ymax

-        return ((xmin, xmax), (ymin, ymax))

-

-    @property

-    def hole_sizes(self):

-        return [stmt.diameter for stmt in self.statements if isinstance(stmt, ExcellonTool)]

-

-    @property

-    def hole_count(self):

-        return len(self.hits)

-

-    def parse(self, filename):

-        with open(filename, 'rU') as f:

-            data = f.read()

-        return self.parse_raw(data, filename)

-

-    def parse_raw(self, data, filename=None):

-        for line in StringIO(data):

-            self._parse_line(line.strip())

-        for stmt in self.statements:

-            stmt.units = self.units

-        return ExcellonFile(self.statements, self.tools, self.hits,

-                            self._settings(), filename)

-

-    def _parse_line(self, line):

-        # skip empty lines

-        if not line.strip():

-            return

-

-        if line[0] == ';':

-            comment_stmt = CommentStmt.from_excellon(line)

-            self.statements.append(comment_stmt)

-

-            # get format from altium comment

-            if "FILE_FORMAT" in comment_stmt.comment:

-                detected_format = tuple(

-                    [int(x) for x in comment_stmt.comment.split('=')[1].split(":")])

-                if detected_format:

-                    self.format = detected_format

-

-            if "TYPE=PLATED" in comment_stmt.comment:

-                self.plated = ExcellonTool.PLATED_YES

-

-            if "TYPE=NON_PLATED" in comment_stmt.comment:

-                self.plated = ExcellonTool.PLATED_NO

-

-            if "HEADER:" in comment_stmt.comment:

-                self.state = "HEADER"

-

-            if " Holesize " in comment_stmt.comment:

-                self.state = "HEADER"

-

-                # Parse this as a hole definition

-                tools = ExcellonToolDefinitionParser(self._settings()).parse_raw(comment_stmt.comment)

-                if len(tools) == 1:

-                    tool = tools[tools.keys()[0]]

-                    self._add_comment_tool(tool)

-

-        elif line[:3] == 'M48':

-            self.statements.append(HeaderBeginStmt())

-            self.state = 'HEADER'

-

-        elif line[0] == '%':

-            self.statements.append(RewindStopStmt())

-            if self.state == 'HEADER':

-                self.state = 'DRILL'

-            elif self.state == 'INIT':

-                self.state = 'HEADER'

-

-        elif line[:3] == 'M00' and self.state == 'DRILL':

-            if self.active_tool:

-                cur_tool_number = self.active_tool.number

-                next_tool = self._get_tool(cur_tool_number + 1)

-

-                self.statements.append(NextToolSelectionStmt(self.active_tool, next_tool))

-                self.active_tool = next_tool

-            else:

-                raise Exception('Invalid state exception')

-

-        elif line[:3] == 'M95':

-            self.statements.append(HeaderEndStmt())

-            if self.state == 'HEADER':

-                self.state = 'DRILL'

-

-        elif line[:3] == 'M15':

-            self.statements.append(ZAxisRoutPositionStmt())

-            self.drill_down = True

-

-        elif line[:3] == 'M16':

-            self.statements.append(RetractWithClampingStmt())

-            self.drill_down = False

-

-        elif line[:3] == 'M17':

-            self.statements.append(RetractWithoutClampingStmt())

-            self.drill_down = False

-

-        elif line[:3] == 'M30':

-            stmt = EndOfProgramStmt.from_excellon(line, self._settings())

-            self.statements.append(stmt)

-

-        elif line[:3] == 'G00':

-            self.statements.append(RouteModeStmt())

-            self.state = 'ROUT'

-

-            stmt = CoordinateStmt.from_excellon(line[3:], self._settings())

-            stmt.mode = self.state

-

-            x = stmt.x

-            y = stmt.y

-            self.statements.append(stmt)

-            if self.notation == 'absolute':

-                if x is not None:

-                    self.pos[0] = x

-                if y is not None:

-                    self.pos[1] = y

-            else:

-                if x is not None:

-                    self.pos[0] += x

-                if y is not None:

-                    self.pos[1] += y

-

-        elif line[:3] == 'G01':

-            self.statements.append(RouteModeStmt())

-            self.state = 'LINEAR'

-

-            stmt = CoordinateStmt.from_excellon(line[3:], self._settings())

-            stmt.mode = self.state

-

-            # The start position is where we were before the rout command

-            start = (self.pos[0], self.pos[1])

-

-            x = stmt.x

-            y = stmt.y

-            self.statements.append(stmt)

-            if self.notation == 'absolute':

-                if x is not None:

-                    self.pos[0] = x

-                if y is not None:

-                    self.pos[1] = y

-            else:

-                if x is not None:

-                    self.pos[0] += x

-                if y is not None:

-                    self.pos[1] += y

-

-            # Our ending position

-            end = (self.pos[0], self.pos[1])

-

-            if self.drill_down:

-                if not self.active_tool:

-                    self.active_tool = self._get_tool(1)

-

-                self.hits.append(DrillSlot(self.active_tool, start, end, DrillSlot.TYPE_ROUT))

-                self.active_tool._hit()

-

-        elif line[:3] == 'G05':

-            self.statements.append(DrillModeStmt())

-            self.drill_down = False

-            self.state = 'DRILL'

-

-        elif 'INCH' in line or 'METRIC' in line:

-            stmt = UnitStmt.from_excellon(line)

-            self.units = stmt.units

-            self.zeros = stmt.zeros

-            if stmt.format:

-                self.format = stmt.format

-            self.statements.append(stmt)

-

-        elif line[:3] == 'M71' or line[:3] == 'M72':

-            stmt = MeasuringModeStmt.from_excellon(line)

-            self.units = stmt.units

-            self.statements.append(stmt)

-

-        elif line[:3] == 'ICI':

-            stmt = IncrementalModeStmt.from_excellon(line)

-            self.notation = 'incremental' if stmt.mode == 'on' else 'absolute'

-            self.statements.append(stmt)

-

-        elif line[:3] == 'VER':

-            stmt = VersionStmt.from_excellon(line)

-            self.statements.append(stmt)

-

-        elif line[:4] == 'FMAT':

-            stmt = FormatStmt.from_excellon(line)

-            self.statements.append(stmt)

-            self.format = stmt.format_tuple

-

-        elif line[:3] == 'G40':

-            self.statements.append(CutterCompensationOffStmt())

-

-        elif line[:3] == 'G41':

-            self.statements.append(CutterCompensationLeftStmt())

-

-        elif line[:3] == 'G42':

-            self.statements.append(CutterCompensationRightStmt())

-

-        elif line[:3] == 'G90':

-            self.statements.append(AbsoluteModeStmt())

-            self.notation = 'absolute'

-

-        elif line[0] == 'F':

-            infeed_rate_stmt = ZAxisInfeedRateStmt.from_excellon(line)

-            self.statements.append(infeed_rate_stmt)

-

-        elif line[0] == 'T' and self.state == 'HEADER':

-            if not ',OFF' in line and not ',ON' in line:

-                tool = ExcellonTool.from_excellon(line, self._settings(), None, self.plated)

-                self._merge_properties(tool)

-                self.tools[tool.number] = tool

-                self.statements.append(tool)

-            else:

-                self.statements.append(UnknownStmt.from_excellon(line))

-

-        elif line[0] == 'T' and self.state != 'HEADER':

-            stmt = ToolSelectionStmt.from_excellon(line)

-            self.statements.append(stmt)

-

-            # T0 is used as END marker, just ignore

-            if stmt.tool != 0:

-                tool = self._get_tool(stmt.tool)

-

-                if not tool:

-                    # FIXME: for weird files with no tools defined, original calc from gerb

-                    if self._settings().units == "inch":

-                        diameter = (16 + 8 * stmt.tool) / 1000.0

-                    else:

-                        diameter = metric((16 + 8 * stmt.tool) / 1000.0)

-

-                    tool = ExcellonTool(

-                        self._settings(), number=stmt.tool, diameter=diameter)

-                    self.tools[tool.number] = tool

-

-                    # FIXME: need to add this tool definition inside header to

-                    # make sure it is properly written

-                    for i, s in enumerate(self.statements):

-                        if isinstance(s, ToolSelectionStmt) or isinstance(s, ExcellonTool):

-                            self.statements.insert(i, tool)

-                            break

-

-                self.active_tool = tool

-

-        elif line[0] == 'R' and self.state != 'HEADER':

-            stmt = RepeatHoleStmt.from_excellon(line, self._settings())

-            self.statements.append(stmt)

-            for i in range(stmt.count):

-                self.pos[0] += stmt.xdelta if stmt.xdelta is not None else 0

-                self.pos[1] += stmt.ydelta if stmt.ydelta is not None else 0

-                self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))

-                self.active_tool._hit()

-

-        elif line[0] in ['X', 'Y']:

-            if 'G85' in line:

-                stmt = SlotStmt.from_excellon(line, self._settings())

-

-                # I don't know if this is actually correct, but it makes sense

-                # that this is where the tool would end

-                x = stmt.x_end

-                y = stmt.y_end

-

-                self.statements.append(stmt)

-

-                if self.notation == 'absolute':

-                    if x is not None:

-                        self.pos[0] = x

-                    if y is not None:

-                        self.pos[1] = y

-                else:

-                    if x is not None:

-                        self.pos[0] += x

-                    if y is not None:

-                        self.pos[1] += y

-

-                if self.state == 'DRILL' or self.state == 'HEADER':

-                    if not self.active_tool:

-                        self.active_tool = self._get_tool(1)

-

-                    self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end), DrillSlot.TYPE_G85))

-                    self.active_tool._hit()

-            else:

-                stmt = CoordinateStmt.from_excellon(line, self._settings())

-

-                # We need this in case we are in rout mode

-                start = (self.pos[0], self.pos[1])

-

-                x = stmt.x

-                y = stmt.y

-                self.statements.append(stmt)

-                if self.notation == 'absolute':

-                    if x is not None:

-                        self.pos[0] = x

-                    if y is not None:

-                        self.pos[1] = y

-                else:

-                    if x is not None:

-                        self.pos[0] += x

-                    if y is not None:

-                        self.pos[1] += y

-

-                if self.state == 'LINEAR' and self.drill_down:

-                    if not self.active_tool:

-                        self.active_tool = self._get_tool(1)

-

-                    self.hits.append(DrillSlot(self.active_tool, start, tuple(self.pos), DrillSlot.TYPE_ROUT))

-

-                elif self.state == 'DRILL' or self.state == 'HEADER':

-                    # Yes, drills in the header doesn't follow the specification, but it there are many

-                    # files like this

-                    if not self.active_tool:

-                        self.active_tool = self._get_tool(1)

-

-                    self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))

-                    self.active_tool._hit()

-

-        else:

-            self.statements.append(UnknownStmt.from_excellon(line))

-

-    def _settings(self):

-        return FileSettings(units=self.units, format=self.format,

-                            zeros=self.zeros, notation=self.notation)

-

-    def _add_comment_tool(self, tool):

-        """

-        Add a tool that was defined in the comments to this file.

-

-        If we have already found this tool, then we will merge this comment tool definition into

-        the information for the tool

-        """

-

-        existing = self.tools.get(tool.number)

-        if existing and existing.plated == None:

-            existing.plated = tool.plated

-

-        self.comment_tools[tool.number] = tool

-

-    def _merge_properties(self, tool):

-        """

-        When we have externally defined tools, merge the properties of that tool into this one

-

-        For now, this is only plated

-        """

-

-        if tool.plated == ExcellonTool.PLATED_UNKNOWN:

-            ext_tool = self.ext_tools.get(tool.number)

-

-            if ext_tool:

-                tool.plated = ext_tool.plated

-

-    def _get_tool(self, toolid):

-

-        tool = self.tools.get(toolid)

-        if not tool:

-            tool = self.comment_tools.get(toolid)

-            if tool:

-                tool.settings = self._settings()

-                self.tools[toolid] = tool

-

-        if not tool:

-            tool = self.ext_tools.get(toolid)

-            if tool:

-                tool.settings = self._settings()

-                self.tools[toolid] = tool

-

-        return tool

-

-def detect_excellon_format(data=None, filename=None):

-    """ Detect excellon file decimal format and zero-suppression settings.

-

-    Parameters

-    ----------

-    data : string

-        String containing contents of Excellon file.

-

-    Returns

-    -------

-    settings : dict

-        Detected excellon file settings. Keys are

-            - `format`: decimal format as tuple (<int part>, <decimal part>)

-            - `zero_suppression`: zero suppression, 'leading' or 'trailing'

-    """

-    results = {}

-    detected_zeros = None

-    detected_format = None

-    zeros_options = ('leading', 'trailing', )

-    format_options = ((2, 4), (2, 5), (3, 3),)

-

-    if data is None and filename is None:

-        raise ValueError('Either data or filename arguments must be provided')

-    if data is None:

-        with open(filename, 'rU') as f:

-            data = f.read()

-

-    # Check for obvious clues:

-    p = ExcellonParser()

-    p.parse_raw(data)

-

-    # Get zero_suppression from a unit statement

-    zero_statements = [stmt.zeros for stmt in p.statements

-                       if isinstance(stmt, UnitStmt)]

-

-    # get format from altium comment

-    format_comment = [stmt.comment for stmt in p.statements

-                      if isinstance(stmt, CommentStmt)

-                      and 'FILE_FORMAT' in stmt.comment]

-

-    detected_format = (tuple([int(val) for val in

-                              format_comment[0].split('=')[1].split(':')])

-                       if len(format_comment) == 1 else None)

-    detected_zeros = zero_statements[0] if len(zero_statements) == 1 else None

-

-    # Bail out here if possible

-    if detected_format is not None and detected_zeros is not None:

-        return {'format': detected_format, 'zeros': detected_zeros}

-

-    # Only look at remaining options

-    if detected_format is not None:

-        format_options = (detected_format,)

-    if detected_zeros is not None:

-        zeros_options = (detected_zeros,)

-

-    # Brute force all remaining options, and pick the best looking one...

-    for zeros in zeros_options:

-        for fmt in format_options:

-            key = (fmt, zeros)

-            settings = FileSettings(zeros=zeros, format=fmt)

-            try:

-                p = ExcellonParser(settings)

-                ef = p.parse_raw(data)

-                size = tuple([t[0] - t[1] for t in ef.bounding_box])

-                hole_area = 0.0

-                for hit in p.hits:

-                    tool = hit.tool

-                    hole_area += math.pow(math.pi * tool.diameter / 2., 2)

-                results[key] = (size, p.hole_count, hole_area)

-            except:

-                pass

-

-    # See if any of the dimensions are left with only a single option

-    formats = set(key[0] for key in iter(results.keys()))

-    zeros = set(key[1] for key in iter(results.keys()))

-    if len(formats) == 1:

-        detected_format = formats.pop()

-    if len(zeros) == 1:

-        detected_zeros = zeros.pop()

-

-    # Bail out here if we got everything....

-    if detected_format is not None and detected_zeros is not None:

-        return {'format': detected_format, 'zeros': detected_zeros}

-

-    # Otherwise score each option and pick the best candidate

-    else:

-        scores = {}

-        for key in results.keys():

-            size, count, diameter = results[key]

-            scores[key] = _layer_size_score(size, count, diameter)

-        minscore = min(scores.values())

-        for key in iter(scores.keys()):

-            if scores[key] == minscore:

-                return {'format': key[0], 'zeros': key[1]}

-

-

-def _layer_size_score(size, hole_count, hole_area):

-    """ Heuristic used for determining the correct file number interpretation.

-    Lower is better.

-    """

-    board_area = size[0] * size[1]

-    if board_area == 0:

-        return 0

-

-    hole_percentage = hole_area / board_area

-    hole_score = (hole_percentage - 0.25) ** 2

-    size_score = (board_area - 8) ** 2

-    return hole_score * size_score

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Excellon File module
+====================
+**Excellon file classes**
+
+This module provides Excellon file classes and parsing utilities
+"""
+
+import math
+import operator
+
+from .cam import CamFile, FileSettings
+from .excellon_statements import *
+from .excellon_tool import ExcellonToolDefinitionParser
+from .primitives import Drill, Slot
+from .utils import inch, metric
+
+
+try:
+    from cStringIO import StringIO
+except(ImportError):
+    from io import StringIO
+
+
+
+def read(filename):
+    """ Read data from filename and return an ExcellonFile
+    Parameters
+        ----------
+    filename : string
+        Filename of file to parse
+
+    Returns
+    -------
+    file : :class:`gerber.excellon.ExcellonFile`
+        An ExcellonFile created from the specified file.
+
+    """
+    # File object should use settings from source file by default.
+    with open(filename, 'rU') as f:
+        data = f.read()
+    settings = FileSettings(**detect_excellon_format(data))
+    return ExcellonParser(settings).parse(filename)
+
+def loads(data, filename=None, settings=None, tools=None):
+    """ Read data from string and return an ExcellonFile
+    Parameters
+    ----------
+    data : string
+        string containing Excellon file contents
+
+    filename : string, optional
+        string containing the filename of the data source
+
+    tools: dict (optional)
+        externally defined tools
+
+    Returns
+    -------
+    file : :class:`gerber.excellon.ExcellonFile`
+        An ExcellonFile created from the specified file.
+
+    """
+    # File object should use settings from source file by default.
+    if not settings:
+        settings = FileSettings(**detect_excellon_format(data))
+    return ExcellonParser(settings, tools).parse_raw(data, filename)
+
+
+class DrillHit(object):
+    """Drill feature that is a single drill hole.
+
+    Attributes
+    ----------
+    tool : ExcellonTool
+        Tool to drill the hole. Defines the size of the hole that is generated.
+    position : tuple(float, float)
+        Center position of the drill.
+
+    """
+    def __init__(self, tool, position):
+        self.tool = tool
+        self.position = position
+
+    def to_inch(self):
+        if self.tool.settings.units == 'metric':
+            self.tool.to_inch()
+            self.position = tuple(map(inch, self.position))
+
+    def to_metric(self):
+        if self.tool.settings.units == 'inch':
+            self.tool.to_metric()
+            self.position = tuple(map(metric, self.position))
+
+    @property
+    def bounding_box(self):
+        position = self.position
+        radius = self.tool.diameter / 2.
+
+        min_x = position[0] - radius
+        max_x = position[0] + radius
+        min_y = position[1] - radius
+        max_y = position[1] + radius
+        return ((min_x, max_x), (min_y, max_y))
+
+    def offset(self, x_offset=0, y_offset=0):
+        self.position = tuple(map(operator.add, self.position, (x_offset, y_offset)))
+
+    def __str__(self):
+        return 'Hit (%f, %f) {%s}' % (self.position[0], self.position[1], self.tool)
+
+class DrillSlot(object):
+    """
+    A slot is created between two points. The way the slot is created depends on the statement used to create it
+    """
+
+    TYPE_ROUT = 1
+    TYPE_G85 = 2
+
+    def __init__(self, tool, start, end, slot_type):
+        self.tool = tool
+        self.start = start
+        self.end = end
+        self.slot_type = slot_type
+
+    def to_inch(self):
+        if self.tool.settings.units == 'metric':
+            self.tool.to_inch()
+            self.start = tuple(map(inch, self.start))
+            self.end = tuple(map(inch, self.end))
+
+    def to_metric(self):
+        if self.tool.settings.units == 'inch':
+            self.tool.to_metric()
+            self.start = tuple(map(metric, self.start))
+            self.end = tuple(map(metric, self.end))
+
+    @property
+    def bounding_box(self):
+        start = self.start
+        end = self.end
+        radius = self.tool.diameter / 2.
+        min_x = min(start[0], end[0]) - radius
+        max_x = max(start[0], end[0]) + radius
+        min_y = min(start[1], end[1]) - radius
+        max_y = max(start[1], end[1]) + radius
+        return ((min_x, max_x), (min_y, max_y))
+
+    def offset(self, x_offset=0, y_offset=0):
+        self.start = tuple(map(operator.add, self.start, (x_offset, y_offset)))
+        self.end = tuple(map(operator.add, self.end, (x_offset, y_offset)))
+
+
+class ExcellonFile(CamFile):
+    """ A class representing a single excellon file
+
+    The ExcellonFile class represents a single excellon file.
+
+    http://www.excellon.com/manuals/program.htm
+    (archived version at https://web.archive.org/web/20150920001043/http://www.excellon.com/manuals/program.htm)
+
+    Parameters
+    ----------
+    tools : list
+        list of gerber file statements
+
+    hits : list of tuples
+        list of drill hits as (<Tool>, (x, y))
+
+    settings : dict
+        Dictionary of gerber file settings
+
+    filename : string
+        Filename of the source gerber file
+
+    Attributes
+    ----------
+    units : string
+        either 'inch' or 'metric'.
+
+    """
+
+    def __init__(self, statements, tools, hits, settings, filename=None):
+        super(ExcellonFile, self).__init__(statements=statements,
+                                           settings=settings,
+                                           filename=filename)
+        self.tools = tools
+        self.hits = hits
+
+    @property
+    def primitives(self):
+        """
+        Gets the primitives. Note that unlike Gerber, this generates new objects
+        """
+        primitives = []
+        for hit in self.hits:
+            if isinstance(hit, DrillHit):
+                primitives.append(Drill(hit.position, hit.tool.diameter,
+                                        units=self.settings.units))
+            elif isinstance(hit, DrillSlot):
+                primitives.append(Slot(hit.start, hit.end, hit.tool.diameter,
+                                       units=self.settings.units))
+            else:
+                raise ValueError('Unknown hit type')
+        return primitives
+
+    @property
+    def bounding_box(self):
+        xmin = ymin = 100000000000
+        xmax = ymax = -100000000000
+        for hit in self.hits:
+            bbox = hit.bounding_box
+            xmin = min(bbox[0][0], xmin)
+            xmax = max(bbox[0][1], xmax)
+            ymin = min(bbox[1][0], ymin)
+            ymax = max(bbox[1][1], ymax)
+        return ((xmin, xmax), (ymin, ymax))
+
+    def report(self, filename=None):
+        """ Print or save drill report
+        """
+        if self.settings.units == 'inch':
+            toolfmt = '  T{:0>2d}      {:%d.%df}     {: >3d}     {:f}in.\n' % self.settings.format
+        else:
+            toolfmt = '  T{:0>2d}      {:%d.%df}     {: >3d}     {:f}mm\n' % self.settings.format
+        rprt = '=====================\nExcellon Drill Report\n=====================\n'
+        if self.filename is not None:
+            rprt += 'NC Drill File: %s\n\n' % self.filename
+        rprt += 'Drill File Info:\n----------------\n'
+        rprt += ('  Data Mode         %s\n' % 'Absolute'
+                 if self.settings.notation == 'absolute' else 'Incremental')
+        rprt += ('  Units             %s\n' % 'Inches'
+                 if self.settings.units == 'inch' else 'Millimeters')
+        rprt += '\nTool List:\n----------\n\n'
+        rprt += '  Code      Size     Hits    Path Length\n'
+        rprt += '  --------------------------------------\n'
+        for tool in iter(self.tools.values()):
+            rprt += toolfmt.format(tool.number, tool.diameter,
+                                   tool.hit_count, self.path_length(tool.number))
+        if filename is not None:
+            with open(filename, 'w') as f:
+                f.write(rprt)
+        return rprt
+
+    def write(self, filename=None):
+        filename = filename if filename is not None else self.filename
+        with open(filename, 'w') as f:
+
+            # Copy the header verbatim
+            for statement in self.statements:
+                if not isinstance(statement, ToolSelectionStmt):
+                    f.write(statement.to_excellon(self.settings) + '\n')
+                else:
+                    break
+
+            # Write out coordinates for drill hits by tool
+            for tool in iter(self.tools.values()):
+                f.write(ToolSelectionStmt(tool.number).to_excellon(self.settings) + '\n')
+                for hit in self.hits:
+                    if hit.tool.number == tool.number:
+                        f.write(CoordinateStmt(
+                            *hit.position).to_excellon(self.settings) + '\n')
+            f.write(EndOfProgramStmt().to_excellon() + '\n')
+
+    def to_inch(self):
+        """
+        Convert units to inches
+        """
+        if self.units != 'inch':
+            for statement in self.statements:
+                statement.to_inch()
+            for tool in iter(self.tools.values()):
+                tool.to_inch()
+            #for primitive in self.primitives:
+            #    primitive.to_inch()
+            #for hit in self.hits:
+            #    hit.to_inch()
+            self.units = 'inch'
+
+    def to_metric(self):
+        """  Convert units to metric
+        """
+        if self.units != 'metric':
+            for statement in self.statements:
+                statement.to_metric()
+            for tool in iter(self.tools.values()):
+                tool.to_metric()
+            #for primitive in self.primitives:
+            #    print("Converting to metric: {}".format(primitive))
+            #    primitive.to_metric()
+            #    print(primitive)
+            for hit in self.hits:
+                hit.to_metric()
+            self.units = 'metric'
+
+    def offset(self, x_offset=0, y_offset=0):
+        for statement in self.statements:
+            statement.offset(x_offset, y_offset)
+        for primitive in self.primitives:
+            primitive.offset(x_offset, y_offset)
+        for hit in self. hits:
+            hit.offset(x_offset, y_offset)
+
+    def path_length(self, tool_number=None):
+        """ Return the path length for a given tool
+        """
+        lengths = {}
+        positions = {}
+        for hit in self.hits:
+            tool = hit.tool
+            num = tool.number
+            positions[num] = ((0, 0) if positions.get(num) is None
+                              else positions[num])
+            lengths[num] = 0.0 if lengths.get(num) is None else lengths[num]
+            lengths[num] = lengths[
+                num] + math.hypot(*tuple(map(operator.sub, positions[num], hit.position)))
+            positions[num] = hit.position
+
+        if tool_number is None:
+            return lengths
+        else:
+            return lengths.get(tool_number)
+
+    def hit_count(self, tool_number=None):
+        counts = {}
+        for tool in iter(self.tools.values()):
+            counts[tool.number] = tool.hit_count
+        if tool_number is None:
+            return counts
+        else:
+            return counts.get(tool_number)
+
+    def update_tool(self, tool_number, **kwargs):
+        """ Change parameters of a tool
+        """
+        if kwargs.get('feed_rate') is not None:
+            self.tools[tool_number].feed_rate = kwargs.get('feed_rate')
+        if kwargs.get('retract_rate') is not None:
+            self.tools[tool_number].retract_rate = kwargs.get('retract_rate')
+        if kwargs.get('rpm') is not None:
+            self.tools[tool_number].rpm = kwargs.get('rpm')
+        if kwargs.get('diameter') is not None:
+            self.tools[tool_number].diameter = kwargs.get('diameter')
+        if kwargs.get('max_hit_count') is not None:
+            self.tools[tool_number].max_hit_count = kwargs.get('max_hit_count')
+        if kwargs.get('depth_offset') is not None:
+            self.tools[tool_number].depth_offset = kwargs.get('depth_offset')
+        # Update drill hits
+        newtool = self.tools[tool_number]
+        for hit in self.hits:
+            if hit.tool.number == newtool.number:
+                hit.tool = newtool
+
+
+class ExcellonParser(object):
+    """ Excellon File Parser
+
+    Parameters
+    ----------
+    settings : FileSettings or dict-like
+        Excellon file settings to use when interpreting the excellon file.
+    """
+    def __init__(self, settings=None, ext_tools=None):
+        self.notation = 'absolute'
+        self.units = 'inch'
+        self.zeros = 'leading'
+        self.format = (2, 4)
+        self.state = 'INIT'
+        self.statements = []
+        self.tools = {}
+        self.ext_tools = ext_tools or {}
+        self.comment_tools = {}
+        self.hits = []
+        self.active_tool = None
+        self.pos = [0., 0.]
+        self.drill_down = False
+        self._previous_line = ''
+        # Default for plated is None, which means we don't know
+        self.plated = ExcellonTool.PLATED_UNKNOWN
+        if settings is not None:
+            self.units = settings.units
+            self.zeros = settings.zeros
+            self.notation = settings.notation
+            self.format = settings.format
+
+    @property
+    def coordinates(self):
+        return [(stmt.x, stmt.y) for stmt in self.statements if isinstance(stmt, CoordinateStmt)]
+
+    @property
+    def bounds(self):
+        xmin = ymin = 100000000000
+        xmax = ymax = -100000000000
+        for x, y in self.coordinates:
+            if x is not None:
+                xmin = x if x < xmin else xmin
+                xmax = x if x > xmax else xmax
+            if y is not None:
+                ymin = y if y < ymin else ymin
+                ymax = y if y > ymax else ymax
+        return ((xmin, xmax), (ymin, ymax))
+
+    @property
+    def hole_sizes(self):
+        return [stmt.diameter for stmt in self.statements if isinstance(stmt, ExcellonTool)]
+
+    @property
+    def hole_count(self):
+        return len(self.hits)
+
+    def parse(self, filename):
+        with open(filename, 'rU') as f:
+            data = f.read()
+        return self.parse_raw(data, filename)
+
+    def parse_raw(self, data, filename=None):
+        for line in StringIO(data):
+            self._parse_line(line.strip())
+        for stmt in self.statements:
+            stmt.units = self.units
+        return ExcellonFile(self.statements, self.tools, self.hits,
+                            self._settings(), filename)
+
+    def _parse_line(self, line):
+        # skip empty lines
+        # Prepend previous line's data...
+        line = '{}{}'.format(self._previous_line, line)
+        self._previous_line = ''
+
+        # Skip empty lines
+        if not line.strip():
+            return
+
+        if line[0] == ';':
+            comment_stmt = CommentStmt.from_excellon(line)
+            self.statements.append(comment_stmt)
+
+            # get format from altium comment
+            if "FILE_FORMAT" in comment_stmt.comment:
+                detected_format = tuple(
+                    [int(x) for x in comment_stmt.comment.split('=')[1].split(":")])
+                if detected_format:
+                    self.format = detected_format
+
+            if "TYPE=PLATED" in comment_stmt.comment:
+                self.plated = ExcellonTool.PLATED_YES
+
+            if "TYPE=NON_PLATED" in comment_stmt.comment:
+                self.plated = ExcellonTool.PLATED_NO
+
+            if "HEADER:" in comment_stmt.comment:
+                self.state = "HEADER"
+
+            if " Holesize " in comment_stmt.comment:
+                self.state = "HEADER"
+
+                # Parse this as a hole definition
+                tools = ExcellonToolDefinitionParser(self._settings()).parse_raw(comment_stmt.comment)
+                if len(tools) == 1:
+                    tool = tools[tools.keys()[0]]
+                    self._add_comment_tool(tool)
+
+        elif line[:3] == 'M48':
+            self.statements.append(HeaderBeginStmt())
+            self.state = 'HEADER'
+
+        elif line[0] == '%':
+            self.statements.append(RewindStopStmt())
+            if self.state == 'HEADER':
+                self.state = 'DRILL'
+            elif self.state == 'INIT':
+                self.state = 'HEADER'
+
+        elif line[:3] == 'M00' and self.state == 'DRILL':
+            if self.active_tool:
+                cur_tool_number = self.active_tool.number
+                next_tool = self._get_tool(cur_tool_number + 1)
+
+                self.statements.append(NextToolSelectionStmt(self.active_tool, next_tool))
+                self.active_tool = next_tool
+            else:
+                raise Exception('Invalid state exception')
+
+        elif line[:3] == 'M95':
+            self.statements.append(HeaderEndStmt())
+            if self.state == 'HEADER':
+                self.state = 'DRILL'
+
+        elif line[:3] == 'M15':
+            self.statements.append(ZAxisRoutPositionStmt())
+            self.drill_down = True
+
+        elif line[:3] == 'M16':
+            self.statements.append(RetractWithClampingStmt())
+            self.drill_down = False
+
+        elif line[:3] == 'M17':
+            self.statements.append(RetractWithoutClampingStmt())
+            self.drill_down = False
+
+        elif line[:3] == 'M30':
+            stmt = EndOfProgramStmt.from_excellon(line, self._settings())
+            self.statements.append(stmt)
+
+        elif line[:3] == 'G00':
+            # Coordinates may be on the next line
+            if line.strip() == 'G00':
+                self._previous_line = line
+                return
+
+            self.statements.append(RouteModeStmt())
+            self.state = 'ROUT'
+
+            stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
+            stmt.mode = self.state
+
+            x = stmt.x
+            y = stmt.y
+            self.statements.append(stmt)
+            if self.notation == 'absolute':
+                if x is not None:
+                    self.pos[0] = x
+                if y is not None:
+                    self.pos[1] = y
+            else:
+                if x is not None:
+                    self.pos[0] += x
+                if y is not None:
+                    self.pos[1] += y
+
+        elif line[:3] == 'G01':
+
+            # Coordinates might be on the next line...
+            if line.strip() == 'G01':
+                self._previous_line = line
+                return
+
+            self.statements.append(RouteModeStmt())
+            self.state = 'LINEAR'
+
+            stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
+            stmt.mode = self.state
+
+            # The start position is where we were before the rout command
+            start = (self.pos[0], self.pos[1])
+
+            x = stmt.x
+            y = stmt.y
+            self.statements.append(stmt)
+            if self.notation == 'absolute':
+                if x is not None:
+                    self.pos[0] = x
+                if y is not None:
+                    self.pos[1] = y
+            else:
+                if x is not None:
+                    self.pos[0] += x
+                if y is not None:
+                    self.pos[1] += y
+
+            # Our ending position
+            end = (self.pos[0], self.pos[1])
+
+            if self.drill_down:
+                if not self.active_tool:
+                    self.active_tool = self._get_tool(1)
+
+                self.hits.append(DrillSlot(self.active_tool, start, end, DrillSlot.TYPE_ROUT))
+                self.active_tool._hit()
+
+        elif line[:3] == 'G05':
+            self.statements.append(DrillModeStmt())
+            self.drill_down = False
+            self.state = 'DRILL'
+
+        elif 'INCH' in line or 'METRIC' in line:
+            stmt = UnitStmt.from_excellon(line)
+            self.units = stmt.units
+            self.zeros = stmt.zeros
+            if stmt.format:
+                self.format = stmt.format
+            self.statements.append(stmt)
+
+        elif line[:3] == 'M71' or line[:3] == 'M72':
+            stmt = MeasuringModeStmt.from_excellon(line)
+            self.units = stmt.units
+            self.statements.append(stmt)
+
+        elif line[:3] == 'ICI':
+            stmt = IncrementalModeStmt.from_excellon(line)
+            self.notation = 'incremental' if stmt.mode == 'on' else 'absolute'
+            self.statements.append(stmt)
+
+        elif line[:3] == 'VER':
+            stmt = VersionStmt.from_excellon(line)
+            self.statements.append(stmt)
+
+        elif line[:4] == 'FMAT':
+            stmt = FormatStmt.from_excellon(line)
+            self.statements.append(stmt)
+            self.format = stmt.format_tuple
+
+        elif line[:3] == 'G40':
+            self.statements.append(CutterCompensationOffStmt())
+
+        elif line[:3] == 'G41':
+            self.statements.append(CutterCompensationLeftStmt())
+
+        elif line[:3] == 'G42':
+            self.statements.append(CutterCompensationRightStmt())
+
+        elif line[:3] == 'G90':
+            self.statements.append(AbsoluteModeStmt())
+            self.notation = 'absolute'
+
+        elif line[0] == 'F':
+            infeed_rate_stmt = ZAxisInfeedRateStmt.from_excellon(line)
+            self.statements.append(infeed_rate_stmt)
+
+        elif line[0] == 'T' and self.state == 'HEADER':
+            if not ',OFF' in line and not ',ON' in line:
+                tool = ExcellonTool.from_excellon(line, self._settings(), None, self.plated)
+                self._merge_properties(tool)
+                self.tools[tool.number] = tool
+                self.statements.append(tool)
+            else:
+                self.statements.append(UnknownStmt.from_excellon(line))
+
+        elif line[0] == 'T' and self.state != 'HEADER':
+            stmt = ToolSelectionStmt.from_excellon(line)
+            self.statements.append(stmt)
+
+            # T0 is used as END marker, just ignore
+            if stmt.tool != 0:
+                tool = self._get_tool(stmt.tool)
+
+                if not tool:
+                    # FIXME: for weird files with no tools defined, original calc from gerb
+                    if self._settings().units == "inch":
+                        diameter = (16 + 8 * stmt.tool) / 1000.0
+                    else:
+                        diameter = metric((16 + 8 * stmt.tool) / 1000.0)
+
+                    tool = ExcellonTool(
+                        self._settings(), number=stmt.tool, diameter=diameter)
+                    self.tools[tool.number] = tool
+
+                    # FIXME: need to add this tool definition inside header to
+                    # make sure it is properly written
+                    for i, s in enumerate(self.statements):
+                        if isinstance(s, ToolSelectionStmt) or isinstance(s, ExcellonTool):
+                            self.statements.insert(i, tool)
+                            break
+
+                self.active_tool = tool
+
+        elif line[0] == 'R' and self.state != 'HEADER':
+            stmt = RepeatHoleStmt.from_excellon(line, self._settings())
+            self.statements.append(stmt)
+            for i in range(stmt.count):
+                self.pos[0] += stmt.xdelta if stmt.xdelta is not None else 0
+                self.pos[1] += stmt.ydelta if stmt.ydelta is not None else 0
+                self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
+                self.active_tool._hit()
+
+        elif line[0] in ['X', 'Y']:
+            if 'G85' in line:
+                stmt = SlotStmt.from_excellon(line, self._settings())
+
+                # I don't know if this is actually correct, but it makes sense
+                # that this is where the tool would end
+                x = stmt.x_end
+                y = stmt.y_end
+
+                self.statements.append(stmt)
+
+                if self.notation == 'absolute':
+                    if x is not None:
+                        self.pos[0] = x
+                    if y is not None:
+                        self.pos[1] = y
+                else:
+                    if x is not None:
+                        self.pos[0] += x
+                    if y is not None:
+                        self.pos[1] += y
+
+                if self.state == 'DRILL' or self.state == 'HEADER':
+                    if not self.active_tool:
+                        self.active_tool = self._get_tool(1)
+
+                    self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end), DrillSlot.TYPE_G85))
+                    self.active_tool._hit()
+            else:
+                stmt = CoordinateStmt.from_excellon(line, self._settings())
+
+                # We need this in case we are in rout mode
+                start = (self.pos[0], self.pos[1])
+
+                x = stmt.x
+                y = stmt.y
+                self.statements.append(stmt)
+                if self.notation == 'absolute':
+                    if x is not None:
+                        self.pos[0] = x
+                    if y is not None:
+                        self.pos[1] = y
+                else:
+                    if x is not None:
+                        self.pos[0] += x
+                    if y is not None:
+                        self.pos[1] += y
+
+                if self.state == 'LINEAR' and self.drill_down:
+                    if not self.active_tool:
+                        self.active_tool = self._get_tool(1)
+
+                    self.hits.append(DrillSlot(self.active_tool, start, tuple(self.pos), DrillSlot.TYPE_ROUT))
+
+                elif self.state == 'DRILL' or self.state == 'HEADER':
+                    # Yes, drills in the header doesn't follow the specification, but it there are many
+                    # files like this
+                    if not self.active_tool:
+                        self.active_tool = self._get_tool(1)
+
+                    self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
+                    self.active_tool._hit()
+
+        else:
+            self.statements.append(UnknownStmt.from_excellon(line))
+
+    def _settings(self):
+        return FileSettings(units=self.units, format=self.format,
+                            zeros=self.zeros, notation=self.notation)
+
+    def _add_comment_tool(self, tool):
+        """
+        Add a tool that was defined in the comments to this file.
+
+        If we have already found this tool, then we will merge this comment tool definition into
+        the information for the tool
+        """
+
+        existing = self.tools.get(tool.number)
+        if existing and existing.plated == None:
+            existing.plated = tool.plated
+
+        self.comment_tools[tool.number] = tool
+
+    def _merge_properties(self, tool):
+        """
+        When we have externally defined tools, merge the properties of that tool into this one
+
+        For now, this is only plated
+        """
+
+        if tool.plated == ExcellonTool.PLATED_UNKNOWN:
+            ext_tool = self.ext_tools.get(tool.number)
+
+            if ext_tool:
+                tool.plated = ext_tool.plated
+
+    def _get_tool(self, toolid):
+
+        tool = self.tools.get(toolid)
+        if not tool:
+            tool = self.comment_tools.get(toolid)
+            if tool:
+                tool.settings = self._settings()
+                self.tools[toolid] = tool
+
+        if not tool:
+            tool = self.ext_tools.get(toolid)
+            if tool:
+                tool.settings = self._settings()
+                self.tools[toolid] = tool
+
+        return tool
+
+def detect_excellon_format(data=None, filename=None):
+    """ Detect excellon file decimal format and zero-suppression settings.
+
+    Parameters
+    ----------
+    data : string
+        String containing contents of Excellon file.
+
+    Returns
+    -------
+    settings : dict
+        Detected excellon file settings. Keys are
+            - `format`: decimal format as tuple (<int part>, <decimal part>)
+            - `zero_suppression`: zero suppression, 'leading' or 'trailing'
+    """
+    results = {}
+    detected_zeros = None
+    detected_format = None
+    zeros_options = ('leading', 'trailing', )
+    format_options = ((2, 4), (2, 5), (3, 3),)
+
+    if data is None and filename is None:
+        raise ValueError('Either data or filename arguments must be provided')
+    if data is None:
+        with open(filename, 'rU') as f:
+            data = f.read()
+
+    # Check for obvious clues:
+    p = ExcellonParser()
+    p.parse_raw(data)
+
+    # Get zero_suppression from a unit statement
+    zero_statements = [stmt.zeros for stmt in p.statements
+                       if isinstance(stmt, UnitStmt)]
+
+    # get format from altium comment
+    format_comment = [stmt.comment for stmt in p.statements
+                      if isinstance(stmt, CommentStmt)
+                      and 'FILE_FORMAT' in stmt.comment]
+
+    detected_format = (tuple([int(val) for val in
+                              format_comment[0].split('=')[1].split(':')])
+                       if len(format_comment) == 1 else None)
+    detected_zeros = zero_statements[0] if len(zero_statements) == 1 else None
+
+    # Bail out here if possible
+    if detected_format is not None and detected_zeros is not None:
+        return {'format': detected_format, 'zeros': detected_zeros}
+
+    # Only look at remaining options
+    if detected_format is not None:
+        format_options = (detected_format,)
+    if detected_zeros is not None:
+        zeros_options = (detected_zeros,)
+
+    # Brute force all remaining options, and pick the best looking one...
+    for zeros in zeros_options:
+        for fmt in format_options:
+            key = (fmt, zeros)
+            settings = FileSettings(zeros=zeros, format=fmt)
+            try:
+                p = ExcellonParser(settings)
+                ef = p.parse_raw(data)
+                size = tuple([t[0] - t[1] for t in ef.bounding_box])
+                hole_area = 0.0
+                for hit in p.hits:
+                    tool = hit.tool
+                    hole_area += math.pow(math.pi * tool.diameter / 2., 2)
+                results[key] = (size, p.hole_count, hole_area)
+            except:
+                pass
+
+    # See if any of the dimensions are left with only a single option
+    formats = set(key[0] for key in iter(results.keys()))
+    zeros = set(key[1] for key in iter(results.keys()))
+    if len(formats) == 1:
+        detected_format = formats.pop()
+    if len(zeros) == 1:
+        detected_zeros = zeros.pop()
+
+    # Bail out here if we got everything....
+    if detected_format is not None and detected_zeros is not None:
+        return {'format': detected_format, 'zeros': detected_zeros}
+
+    # Otherwise score each option and pick the best candidate
+    else:
+        scores = {}
+        for key in results.keys():
+            size, count, diameter = results[key]
+            scores[key] = _layer_size_score(size, count, diameter)
+        minscore = min(scores.values())
+        for key in iter(scores.keys()):
+            if scores[key] == minscore:
+                return {'format': key[0], 'zeros': key[1]}
+
+
+def _layer_size_score(size, hole_count, hole_area):
+    """ Heuristic used for determining the correct file number interpretation.
+    Lower is better.
+    """
+    board_area = size[0] * size[1]
+    if board_area == 0:
+        return 0
+
+    hole_percentage = hole_area / board_area
+    hole_score = (hole_percentage - 0.25) ** 2
+    size_score = (board_area - 8) ** 2
+    return hole_score * size_score
diff --git a/gerber/tests/test_excellon.py b/gerber/tests/test_excellon.py
index 6cddb60..d17791c 100644
--- a/gerber/tests/test_excellon.py
+++ b/gerber/tests/test_excellon.py
@@ -7,7 +7,7 @@ import os
 from ..cam import FileSettings
 from ..excellon import read, detect_excellon_format, ExcellonFile, ExcellonParser
 from ..excellon import DrillHit, DrillSlot
-from ..excellon_statements import ExcellonTool
+from ..excellon_statements import ExcellonTool, RouteModeStmt
 from .tests import *
 
 
@@ -127,7 +127,7 @@ def test_parse_header():
 
 def test_parse_rout():
     p = ExcellonParser(FileSettings())
-    p._parse_line('G00  ')
+    p._parse_line('G00X040944Y019842')
     assert_equal(p.state, 'ROUT')
     p._parse_line('G05 ')
     assert_equal(p.state, 'DRILL')
@@ -336,4 +336,25 @@ def test_drill_slot_bounds():
 
         assert_equal(slot.bounding_box, expected)
 
-#def test_exce
+def test_handling_multi_line_g00_and_g1():
+    """Route Mode statements with coordinates on separate line are handled
+    """
+    test_data = """
+%
+M48
+M72
+T01C0.0236
+%
+T01
+G00
+X040944Y019842
+M15
+G01
+X040944Y020708
+M16
+"""
+    uut = ExcellonParser()
+    uut.parse_raw(test_data)
+    assert_equal(len([stmt for stmt in uut.statements
+                      if isinstance(stmt, RouteModeStmt)]), 2)
+