Parser half-refactored

26 files changed, 448 insertions, 2916 deletions

diff --git a/examples/cairo_bottom.png b/examples/cairo_bottom.png
deleted file mode 100644
index 70f7551..0000000
--- a/examples/cairo_bottom.png
+++ /dev/null
diff --git a/examples/cairo_example.png b/examples/cairo_example.png
deleted file mode 100644
index 4b4ee0a..0000000
--- a/examples/cairo_example.png
+++ /dev/null
diff --git a/examples/cairo_example.py b/examples/cairo_example.py
deleted file mode 100644
index ecfed4d..0000000
--- a/examples/cairo_example.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2015 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.
-
-"""
-This example demonstrates the use of pcb-tools with cairo to render a composite
-image from a set of gerber files. Each layer is loaded and drawn using a
-GerberCairoContext. The color and opacity of each layer can be set individually.
-Once all thedesired layers are drawn on the context, the context is written to
-a .png file.
-"""
-
-import os
-from gerber import load_layer
-from gerber.render import RenderSettings, theme
-from gerber.render.cairo_backend import GerberCairoContext
-
-GERBER_FOLDER = os.path.abspath(os.path.join(os.path.dirname(__file__), 'gerbers'))
-
-
-# Open the gerber files
-copper = load_layer(os.path.join(GERBER_FOLDER, 'copper.GTL'))
-mask = load_layer(os.path.join(GERBER_FOLDER, 'soldermask.GTS'))
-silk = load_layer(os.path.join(GERBER_FOLDER, 'silkscreen.GTO'))
-drill = load_layer(os.path.join(GERBER_FOLDER, 'ncdrill.DRD'))
-
-# Create a new drawing context
-ctx = GerberCairoContext()
-
-# Draw the copper layer. render_layer() uses the default color scheme for the
-# layer, based on the layer type. Copper layers are rendered as
-ctx.render_layer(copper)
-
-# Draw the soldermask layer
-ctx.render_layer(mask)
-
-
-# The default style can be overridden by passing a RenderSettings instance to
-# render_layer().
-# First, create a settings object:
-our_settings = RenderSettings(color=theme.COLORS['white'], alpha=0.85)
-
-# Draw the silkscreen layer, and specify the rendering settings to use
-ctx.render_layer(silk, settings=our_settings)
-
-# Draw the drill layer
-ctx.render_layer(drill)
-
-# Write output to png file
-ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_example.png'))
-
-# Load the bottom layers
-copper = load_layer(os.path.join(GERBER_FOLDER, 'bottom_copper.GBL'))
-mask = load_layer(os.path.join(GERBER_FOLDER, 'bottom_mask.GBS'))
-
-# Clear the drawing
-ctx.clear()
-
-# Render bottom layers
-ctx.render_layer(copper)
-ctx.render_layer(mask)
-ctx.render_layer(drill)
-
-# Write png file
-ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_bottom.png'))
diff --git a/gerbonara/gerber/am_read.py b/gerbonara/gerber/am_read.py
index 906aaa9..c50bd01 100644
--- a/gerbonara/gerber/am_read.py
+++ b/gerbonara/gerber/am_read.py
@@ -19,7 +19,6 @@
 """
 
 from .am_opcode import OpCode
-from .am_primitive import eval_macro
 
 import string
 
@@ -251,5 +250,6 @@ if __name__ == '__main__':
     print_instructions(instructions)
 
     print("eval:")
-    for primitive in eval_macro(instructions):
+    from .am_primitive import eval_macro
+    for primitive in eval_macro(instructions, 'mm'):
         print(primitive)
diff --git a/gerbonara/gerber/cam.py b/gerbonara/gerber/cam.py
index 4f20283..5da8600 100644
--- a/gerbonara/gerber/cam.py
+++ b/gerbonara/gerber/cam.py
@@ -14,164 +14,50 @@
 # 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.
-"""
-CAM File
-============
-**AM file classes**
 
-This module provides common base classes for Excellon/Gerber CNC files
-"""
-
-
-class FileSettings(object):
-    """ CAM File Settings
-
-    Provides a common representation of gerber/excellon file settings
-
-    Parameters
-    ----------
-    notation: string
-        notation format. either 'absolute' or 'incremental'
-
-    units : string
-        Measurement units. 'inch' or 'metric'
-
-    zero_suppression: string
-        'leading' to suppress leading zeros, 'trailing' to suppress trailing zeros.
-        This is the convention used in Gerber files.
-
-    format : tuple (int, int)
-        Decimal format
-
-    zeros : string
-        'leading' to include leading zeros, 'trailing to include trailing zeros.
-        This is the convention used in Excellon files
-
-    Notes
-    -----
-    Either `zeros` or `zero_suppression` should be specified, there is no need to
-    specify both. `zero_suppression` will take on the opposite value of `zeros`
-    and vice versa
-    """
-
-    def __init__(self, notation='absolute', units='inch',
-                 zero_suppression=None, format=(2, 5), zeros=None,
-                 angle_units='degrees'):
-        if notation not in ['absolute', 'incremental']:
-            raise ValueError('Notation must be either absolute or incremental')
-        self.notation = notation
-
-        if units not in ['inch', 'metric']:
-            raise ValueError('Units must be either inch or metric')
-        self.units = units
-
-        if zero_suppression is None and zeros is None:
-            self.zero_suppression = 'trailing'
-
-        elif zero_suppression == zeros:
-            raise ValueError('Zeros and Zero Suppression must be different. \
-                             Best practice is to specify only one.')
-
-        elif zero_suppression is not None:
-            if zero_suppression not in ['leading', 'trailing']:
-                # This is a common problem in Eagle files, so just suppress it
-                self.zero_suppression = 'leading'
-            else:
-                self.zero_suppression = zero_suppression
-
-        elif zeros is not None:
-            if zeros not in ['leading', 'trailing']:
-                raise ValueError('Zeros must be either leading or trailling')
-            self.zeros = zeros
-
-        if len(format) != 2:
-            raise ValueError('Format must be a tuple(n=2) of integers')
-        self.format = format
-
-        if angle_units not in ('degrees', 'radians'):
-            raise ValueError('Angle units may be degrees or radians')
-        self.angle_units = angle_units
-
-    @property
-    def zero_suppression(self):
-        return self._zero_suppression
-
-    @zero_suppression.setter
-    def zero_suppression(self, value):
-        self._zero_suppression = value
-        self._zeros = 'leading' if value == 'trailing' else 'trailing'
-
-    @property
-    def zeros(self):
-        return self._zeros
-
-    @zeros.setter
-    def zeros(self, value):
-
-        self._zeros = value
-        self._zero_suppression = 'leading' if value == 'trailing' else 'trailing'
-
-    def __getitem__(self, key):
-        if key == 'notation':
-            return self.notation
-        elif key == 'units':
-            return self.units
-        elif key == 'zero_suppression':
-            return self.zero_suppression
-        elif key == 'zeros':
-            return self.zeros
-        elif key == 'format':
-            return self.format
-        elif key == 'angle_units':
-            return self.angle_units
-        else:
-            raise KeyError()
-
-    def __setitem__(self, key, value):
-        if key == 'notation':
-            if value not in ['absolute', 'incremental']:
-                raise ValueError('Notation must be either \
-                                 absolute or incremental')
-            self.notation = value
-        elif key == 'units':
-            if value not in ['inch', 'metric']:
-                raise ValueError('Units must be either inch or metric')
-            self.units = value
-
-        elif key == 'zero_suppression':
-            if value not in ['leading', 'trailing']:
-                raise ValueError('Zero suppression must be either leading or \
-                                 trailling')
-            self.zero_suppression = value
-
-        elif key == 'zeros':
-            if value not in ['leading', 'trailing']:
-                raise ValueError('Zeros must be either leading or trailling')
-            self.zeros = value
-
-        elif key == 'format':
-            if len(value) != 2:
-                raise ValueError('Format must be a tuple(n=2) of integers')
-            self.format = value
-
-        elif key == 'angle_units':
-            if value not in ('degrees', 'radians'):
-                raise ValueError('Angle units may be degrees or radians')
-            self.angle_units = value
-
-        else:
-            raise KeyError('%s is not a valid key' % key)
-
-    def __eq__(self, other):
-        return (self.notation == other.notation and
-                self.units == other.units and
-                self.zero_suppression == other.zero_suppression and
-                self.format == other.format and
-                self.angle_units == other.angle_units)
+from dataclasses import dataclass
+
+
+@dataclass
+class FileSettings:
+    output_axes : str = 'AXBY' # For deprecated AS statement
+    image_polarity : str = 'positive'
+    image_rotation: int = 0
+    mirror_image : tuple = (False, False)
+    scale_factor : tuple = (1.0, 1.0) # For deprecated SF statement
+    notation : str = 'absolute'
+    units : str = 'inch'
+    angle_units : str = 'degrees'
+    zeros : bool = None
+    number_format : tuple = (2, 5)
+
+    # input validation
+    def __setattr__(self, name, value):
+        if name == 'output_axes' and value not in [None, 'AXBY', 'AYBX']:
+            raise ValueError('output_axes must be either "AXBY", "AYBX" or None')
+        if name == 'image_rotation' and value not in [0, 90, 180, 270]:
+            raise ValueError('image_rotation must be 0, 90, 180 or 270')
+        elif name == 'image_polarity' and value not in ['positive', 'negative']:
+            raise ValueError('image_polarity must be either "positive" or "negative"')
+        elif name == 'mirror_image' and len(value) != 2:
+            raise ValueError('mirror_image must be 2-tuple of bools: (mirror_a, mirror_b)')
+        elif name == 'scale_factor' and len(value) != 2:
+            raise ValueError('scale_factor must be 2-tuple of floats: (scale_a, scale_b)')
+        elif name == 'notation' and value not in ['inch', 'mm']:
+            raise ValueError('Units must be either "inch" or "mm"')
+        elif name == 'units' and value not in ['absolute', 'incremental']:
+            raise ValueError('Notation must be either "absolute" or "incremental"')
+        elif name == 'angle_units' and value not in ('degrees', 'radians'):
+            raise ValueError('Angle units may be "degrees" or "radians"')
+        elif name == 'zeros' and value not in [None, 'leading', 'trailing']:
+            raise ValueError('zero_suppression must be either "leading" or "trailing" or None')
+        elif name == 'number_format' and len(value) != 2:
+            raise ValueError('Number format must be a (integer, fractional) tuple of integers')
+
+        super().__setattr__(name, value)
 
     def __str__(self):
-        return ('<Settings: %s %s %s %s %s>' %
-                (self.units, self.notation, self.zero_suppression, self.format, self.angle_units))
+        return f'<File settings: units={self.units}/{self.angle_units} notation={self.notation} zeros={self.zeros} number_format={self.number_format}>'
 
 
 class CamFile(object):
@@ -202,7 +88,7 @@ class CamFile(object):
         File notation setting. May be either 'absolute' or 'incremental'
 
     units : string
-        File units setting. May be 'inch' or 'metric'
+        File units setting. May be 'inch' or 'mm'
 
     zero_suppression : string
         File zero-suppression setting. May be either 'leading' or 'trailling'
@@ -226,6 +112,7 @@ class CamFile(object):
             self.zero_suppression = 'trailing'
             self.zeros = 'leading'
             self.format = (2, 5)
+
         self.statements = statements if statements is not None else []
         if primitives is not None:
             self.primitives = primitives
diff --git a/gerbonara/gerber/gerber_statements.py b/gerbonara/gerber/gerber_statements.py
index 9296d1b..d2f67c1 100644
--- a/gerbonara/gerber/gerber_statements.py
+++ b/gerbonara/gerber/gerber_statements.py
@@ -29,7 +29,7 @@ from .am_primitive import eval_macro
 from .primitives import AMGroup
 
 
-class Statement(object):
+class Statement:
     """ Gerber statement Base class
 
     The statement class provides a type attribute.
@@ -45,10 +45,6 @@ class Statement(object):
         String identifying the statement type.
     """
 
-    def __init__(self, stype, units='inch'):
-        self.type = stype
-        self.units = units
-
     def __str__(self):
         s = "<{0} ".format(self.__class__.__name__)
 
@@ -58,12 +54,6 @@ class Statement(object):
         s = s.rstrip() + ">"
         return s
 
-    def to_inch(self):
-        self.units = 'inch'
-
-    def to_metric(self):
-        self.units = 'metric'
-
     def offset(self, x_offset=0, y_offset=0):
         pass
 
@@ -72,201 +62,51 @@ class Statement(object):
 
 
 class ParamStmt(Statement):
-    """ Gerber parameter statement Base class
-
-    The parameter statement class provides a parameter type attribute.
-
-    Parameters
-    ----------
-    param : string
-        two-character code identifying the parameter statement type.
-
-    Attributes
-    ----------
-    param : string
-        Parameter type code
-    """
-
-    def __init__(self, param):
-        Statement.__init__(self, "PARAM")
-        self.param = param
-
-
-class FSParamStmt(ParamStmt):
-    """ FS - Gerber Format Specification Statement
-    """
+    pass
 
-    @classmethod
-    def from_settings(cls, settings):
+class FormatSpecStmt(ParamStmt):
+    """ FS - Gerber Format Specification Statement """
+    code = 'FS'
 
-        return cls('FS', settings.zero_suppression, settings.notation, settings.format)
+    def to_gerber(self, settings):
+        zeros = 'L' if settings.zero_suppression == 'leading' else 'T'
+        notation = 'A' if settings.notation == 'absolute' else 'I'
+        fmt = settings.number_format
+        number_format = str(settings.number_format[0]) + str(settings.number_format[1])
 
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        """
-        """
-        param = stmt_dict.get('param')
-
-        if stmt_dict.get('zero') == 'L':
-            zeros = 'leading'
-        elif stmt_dict.get('zero') == 'T':
-            zeros = 'trailing'
-        else:
-            zeros = 'none'
-
-        notation = 'absolute' if stmt_dict.get('notation') == 'A' else 'incremental'
-        fmt = tuple(map(int, stmt_dict.get('x')))
-        return cls(param, zeros, notation, fmt)
-
-    def __init__(self, param, zero_suppression='leading',
-                 notation='absolute', format=(2, 4)):
-        """ Initialize FSParamStmt class
-
-        .. note::
-            The FS command specifies the format of the coordinate data. It
-            must only be used once at the beginning of a file. It must be
-            specified before the first use of coordinate data.
-
-        Parameters
-        ----------
-        param : string
-            Parameter.
-
-        zero_suppression : string
-            Zero-suppression mode. May be either 'leading', 'trailing' or 'none' (all zeros are present)
-
-        notation : string
-            Notation mode. May be either 'absolute' or 'incremental'
-
-        format : tuple (int, int)
-            Gerber precision format expressed as a tuple containing:
-            (number of integer-part digits, number of decimal-part digits)
-
-        Returns
-        -------
-        ParamStmt : FSParamStmt
-            Initialized FSParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.zero_suppression = zero_suppression
-        self.notation = notation
-        self.format = format
-
-    def to_gerber(self, settings=None):
-        if settings:
-            zero_suppression = 'L' if settings.zero_suppression == 'leading' else 'T'
-            notation = 'A' if settings.notation == 'absolute' else 'I'
-            fmt = ''.join(map(str, settings.format))
-        else:
-            zero_suppression = 'L' if self.zero_suppression == 'leading' else 'T'
-            notation = 'A' if self.notation == 'absolute' else 'I'
-            fmt = ''.join(map(str, self.format))
-
-        return '%FS{0}{1}X{2}Y{3}*%'.format(zero_suppression, notation, fmt, fmt)
+        return f'%FS{zeros}{notation}X{number_format}Y{number_format}*%'
 
     def __str__(self):
-        return ('<Format Spec: %d:%d %s zero suppression %s notation>' %
-                (self.format[0], self.format[1], self.zero_suppression, self.notation))
+        return '<FS Format Specification>'
 
 
-class MOParamStmt(ParamStmt):
-    """ MO - Gerber Mode (measurement units) Statement.
-    """
+class UnitStmt(ParamStmt):
+    """ MO - Coordinate unit mode statement """
 
-    @classmethod
-    def from_units(cls, units):
-        return cls(None, units)
-
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        if stmt_dict.get('mo') is None:
-            mo = None
-        elif stmt_dict.get('mo').lower() not in ('in', 'mm'):
-            raise ValueError('Mode may be mm or in')
-        elif stmt_dict.get('mo').lower() == 'in':
-            mo = 'inch'
-        else:
-            mo = 'metric'
-        return cls(param, mo)
-
-    def __init__(self, param, mo):
-        """ Initialize MOParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter.
-
-        mo : string
-            Measurement units. May be either 'inch' or 'metric'
-
-        Returns
-        -------
-        ParamStmt : MOParamStmt
-            Initialized MOParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.mode = mo
-
-    def to_gerber(self, settings=None):
-        mode = 'MM' if self.mode == 'metric' else 'IN'
-        return '%MO{0}*%'.format(mode)
-
-    def to_inch(self):
-        self.mode = 'inch'
-
-    def to_metric(self):
-        self.mode = 'metric'
+    def to_gerber(self, settings):
+        return '%MOMM*%' if settings.units == 'mm' else '%MOIN*%'
 
     def __str__(self):
-        mode_str = 'millimeters' if self.mode == 'metric' else 'inches'
-        return ('<Mode: %s>' % mode_str)
-
-
-class LPParamStmt(ParamStmt):
-    """ LP - Gerber Level Polarity statement
-    """
-
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict['param']
-        lp = 'clear' if stmt_dict.get('lp') == 'C' else 'dark'
-        return cls(param, lp)
+        return ('<MO Coordinate unit mode statement>' % mode_str)
 
-    def __init__(self, param, lp):
-        """ Initialize LPParamStmt class
 
-        Parameters
-        ----------
-        param : string
-            Parameter
+class LoadPolarityStmt(ParamStmt):
+    """ LP - Gerber Load Polarity statement """
 
-        lp : string
-            Level polarity. May be either 'clear' or 'dark'
-
-        Returns
-        -------
-        ParamStmt : LPParamStmt
-            Initialized LPParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.lp = lp
+    def __init__(self, dark):
+        self.dark = dark
 
     def to_gerber(self, settings=None):
-        lp = 'C' if self.lp == 'clear' else 'D'
-        return '%LP{0}*%'.format(lp)
+        lp = 'D' if self.dark else 'C'
+        return f'%LP{lp}*%'
 
     def __str__(self):
-        return '<Level Polarity: %s>' % self.lp
+        lp = 'dark' if self.dark else 'clear'
+        return f'<LP Level Polarity: {lp}>'
 
 
 class ADParamStmt(ParamStmt):
-    """ AD - Gerber Aperture Definition Statement
-    """
+    """ AD - Aperture Definition Statement """
 
     @classmethod
     def rect(cls, dcode, width, height, hole_diameter=None, hole_width=None, hole_height=None):
@@ -418,10 +258,7 @@ class AMParamStmt(ParamStmt):
         self.name = name
         self.macro = macro
         self.units = units
-        self.primitives = list(eval_macro(self.instructions))
-
-    def read(self, macro):
-        return read_macro(macro)
+        self.primitives = list(eval_macro(read_macro(macro), units))
 
     @classmethod
     def circle(cls, name, units):
@@ -457,20 +294,8 @@ class AMParamStmt(ParamStmt):
     def polygon(cls, name, units):
         return cls('AM', name, '5,1,$2,0,0,$1,$3*1,0,$4,0,0,0', units)
 
-    def to_inch(self):
-        if self.units == 'metric':
-            self.units = 'inch'
-            for primitive in self.primitives:
-                primitive.to_inch()
-
-    def to_metric(self):
-        if self.units == 'inch':
-            self.units = 'metric'
-            for primitive in self.primitives:
-                primitive.to_metric()
-
-    def to_gerber(self, settings=None):
-        primitive_defs = '\n'.join(primitive.to_gerber() for primitive in self.primitives)
+    def to_gerber(self, unit=None):
+        primitive_defs = '\n'.join(primitive.to_gerber(unit=unit) for primitive in self.primitives)
         return f'%AM{self.name}*\n{primitive_defs}%'
 
     def rotate(self, angle, center=None):
@@ -478,444 +303,81 @@ class AMParamStmt(ParamStmt):
             primitive_def.rotate(angle, center)
 
     def __str__(self):
-        return '<Aperture Macro %s: %s>' % (self.name, self.macro)
-
-
-class ASParamStmt(ParamStmt):
-    """ AS - Axis Select. (Deprecated) """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        mode = stmt_dict.get('mode')
-        return cls(param, mode)
+        return '<AM Aperture Macro %s: %s>' % (self.name, self.macro)
 
-    def __init__(self, param, mode):
-        """ Initialize ASParamStmt class
 
-        Parameters
-        ----------
-        param : string
-            Parameter string.
+class AxisSelectionStmt(ParamStmt):
+    """ AS - Axis Selection Statement. (Deprecated) """
 
-        mode : string
-            Axis select. May be either 'AXBY' or 'AYBX'
-
-        Returns
-        -------
-        ParamStmt : ASParamStmt
-            Initialized ASParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.mode = mode
-
-    def to_gerber(self, settings=None):
-        return '%AS{0}*%'.format(self.mode)
+    def to_gerber(self, settings):
+        return f'%AS{settings.output_axes}*%'
 
     def __str__(self):
-        return ('<Axis Select: %s>' % self.mode)
-
-
-class INParamStmt(ParamStmt):
-    """ IN - Image Name Statement (Deprecated)
-    """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        return cls(**stmt_dict)
-
-    def __init__(self, param, name):
-        """ Initialize INParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter code
+        return '<AS Axis Select>'
 
-        name : string
-            Image name
+class ImagePolarityStmt(ParamStmt):
+    """ IP - Image Polarity Statement. (Deprecated) """
 
-        Returns
-        -------
-        ParamStmt : INParamStmt
-            Initialized INParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.name = name
-
-    def to_gerber(self, settings=None):
-        return '%IN{0}*%'.format(self.name)
+    def to_gerber(self, settings):
+        ip = 'POS' if settings.image_polarity == 'positive' else 'NEG'
+        return f'%IP{ip}*%'
 
     def __str__(self):
-        return '<Image Name: %s>' % self.name
-
-
-class IPParamStmt(ParamStmt):
-    """ IP - Gerber Image Polarity Statement. (Deprecated)
-    """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        ip = 'positive' if stmt_dict.get('ip') == 'POS' else 'negative'
-        return cls(param, ip)
+        return '<IP Image Polarity>'
 
-    def __init__(self, param, ip):
-        """ Initialize IPParamStmt class
 
-        Parameters
-        ----------
-        param : string
-            Parameter string.
-
-        ip : string
-            Image polarity. May be either'positive' or 'negative'
-
-        Returns
-        -------
-        ParamStmt : IPParamStmt
-            Initialized IPParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.ip = ip
+class ImageRotationStmt(ParamStmt):
+    """ IR - Image Rotation Statement. (Deprecated) """
 
-    def to_gerber(self, settings=None):
-        ip = 'POS' if self.ip == 'positive' else 'NEG'
-        return '%IP{0}*%'.format(ip)
+    def to_gerber(self, settings):
+        return f'%IR{settings.image_rotation}*%'
 
     def __str__(self):
-        return ('<Image Polarity: %s>' % self.ip)
-
-
-class IRParamStmt(ParamStmt):
-    """ IR - Image Rotation Param (Deprecated)
-    """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        angle = int(stmt_dict['angle'])
-        return cls(stmt_dict['param'], angle)
-
-    def __init__(self, param, angle):
-        """ Initialize IRParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter code
-
-        angle : int
-            Image angle
+        return '<IR Image Rotation>'
 
-        Returns
-        -------
-        ParamStmt : IRParamStmt
-            Initialized IRParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.angle = angle
+class MirrorImageStmt(ParamStmt):
+    """ MI - Mirror Image Statement. (Deprecated) """
 
-    def to_gerber(self, settings=None):
-        return '%IR{0}*%'.format(self.angle)
+    def to_gerber(self, settings):
+        return f'%SFA{int(bool(settings.mirror_image[0]))}B{int(bool(settings.mirror_image[1]))}*%'
 
     def __str__(self):
-        return '<Image Angle: %s>' % self.angle
+        return '<MI Mirror Image>'
 
+class OffsetStmt(ParamStmt):
+    """ OF - File Offset Statement. (Deprecated) """
 
-class MIParamStmt(ParamStmt):
-    """ MI - Image Mirror Param (Deprecated)
-    """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        a = int(stmt_dict.get('a', 0))
-        b = int(stmt_dict.get('b', 0))
-        return cls(param, a, b)
-
-    def __init__(self, param, a, b):
-        """ Initialize MIParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter code
-
-        a : int
-            Mirror for A output devices axis (0=disabled, 1=mirrored)
-
-        b : int
-            Mirror for B output devices axis (0=disabled, 1=mirrored)
-
-        Returns
-        -------
-        ParamStmt : MIParamStmt
-            Initialized MIParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.a = a
-        self.b = b
-
-    def to_gerber(self, settings=None):
-        ret = "%MI"
-        if self.a is not None:
-            ret += "A{0}".format(self.a)
-        if self.b is not None:
-            ret += "B{0}".format(self.b)
-        ret += "*%"
-        return ret
-
-    def __str__(self):
-        return '<Image Mirror: A=%d B=%d>' % (self.a, self.b)
-
-
-class OFParamStmt(ParamStmt):
-    """ OF - Gerber Offset statement (Deprecated)
-    """
-
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        a = float(stmt_dict.get('a', 0))
-        b = float(stmt_dict.get('b', 0))
-        return cls(param, a, b)
-
-    def __init__(self, param, a, b):
-        """ Initialize OFParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter
-
-        a : float
-            Offset along the output device A axis
-
-        b : float
-            Offset along the output device B axis
-
-        Returns
-        -------
-        ParamStmt : OFParamStmt
-            Initialized OFParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.a = a
-        self.b = b
+    def __init__(self, a, b):
+        self.a, self.b = a, b
 
     def to_gerber(self, settings=None):
-        ret = '%OF'
-        if self.a is not None:
-            ret += 'A' + decimal_string(self.a, precision=5)
-        if self.b is not None:
-            ret += 'B' + decimal_string(self.b, precision=5)
-        return ret + '*%'
-
-    def to_inch(self):
-        if self.units == 'metric':
-            self.units = 'inch'
-            if self.a is not None:
-                self.a = inch(self.a)
-            if self.b is not None:
-                self.b = inch(self.b)
-
-    def to_metric(self):
-        if self.units == 'inch':
-            self.units = 'metric'
-            if self.a is not None:
-                self.a = metric(self.a)
-            if self.b is not None:
-                self.b = metric(self.b)
-
-    def offset(self, x_offset=0, y_offset=0):
-        if self.a is not None:
-            self.a += x_offset
-        if self.b is not None:
-            self.b += y_offset
+        # FIXME unit conversion
+        return f'%OFA{decimal_string(self.a, precision=5)}B{decimal_string(self.b, precision=5)}*%'
 
     def __str__(self):
-        offset_str = ''
-        if self.a is not None:
-            offset_str += ('X: %f ' % self.a)
-        if self.b is not None:
-            offset_str += ('Y: %f ' % self.b)
-        return ('<Offset: %s>' % offset_str)
+        return f'<OF Offset a={self.a} b={self.b}>'
 
 
 class SFParamStmt(ParamStmt):
-    """ SF - Scale Factor Param (Deprecated)
-    """
-
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        param = stmt_dict.get('param')
-        a = float(stmt_dict.get('a', 1))
-        b = float(stmt_dict.get('b', 1))
-        return cls(param, a, b)
-
-    def __init__(self, param, a, b):
-        """ Initialize OFParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter
-
-        a : float
-            Scale factor for the output device A axis
-
-        b : float
-            Scale factor for the output device B axis
-
-        Returns
-        -------
-        ParamStmt : SFParamStmt
-            Initialized SFParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.a = a
-        self.b = b
-
-    def to_gerber(self, settings=None):
-        ret = '%SF'
-        if self.a is not None:
-            ret += 'A' + decimal_string(self.a, precision=5)
-        if self.b is not None:
-            ret += 'B' + decimal_string(self.b, precision=5)
-        return ret + '*%'
-
-    def to_inch(self):
-        if self.units == 'metric':
-            self.units = 'inch'
-            if self.a is not None:
-                self.a = inch(self.a)
-            if self.b is not None:
-                self.b = inch(self.b)
-
-    def to_metric(self):
-        if self.units == 'inch':
-            self.units = 'metric'
-            if self.a is not None:
-                self.a = metric(self.a)
-            if self.b is not None:
-                self.b = metric(self.b)
-
-    def offset(self, x_offset=0, y_offset=0):
-        if self.a is not None:
-            self.a += x_offset
-        if self.b is not None:
-            self.b += y_offset
-
-    def __str__(self):
-        scale_factor = ''
-        if self.a is not None:
-            scale_factor += ('X: %g ' % self.a)
-        if self.b is not None:
-            scale_factor += ('Y: %g' % self.b)
-        return ('<Scale Factor: %s>' % scale_factor)
-
-
-class LNParamStmt(ParamStmt):
-    """ LN - Level Name Statement (Deprecated)
-    """
-    @classmethod
-    def from_dict(cls, stmt_dict):
-        return cls(**stmt_dict)
-
-    def __init__(self, param, name):
-        """ Initialize LNParamStmt class
-
-        Parameters
-        ----------
-        param : string
-            Parameter code
-
-        name : string
-            Level name
-
-        Returns
-        -------
-        ParamStmt : LNParamStmt
-            Initialized LNParamStmt class.
-
-        """
-        ParamStmt.__init__(self, param)
-        self.name = name
-
-    def to_gerber(self, settings=None):
-        return '%LN{0}*%'.format(self.name)
-
-    def __str__(self):
-        return '<Level Name: %s>' % self.name
-
+    """ SF - Scale Factor Statement. (Deprecated) """
 
-class DeprecatedStmt(Statement):
-    """ Unimportant deprecated statement, will be parsed but not emitted.
-    """
-    @classmethod
-    def from_gerber(cls, line):
-        return cls(line)
-
-    def __init__(self, line):
-        """ Initialize DeprecatedStmt class
-
-        Parameters
-        ----------
-        line : string
-            Deprecated statement text
-
-        Returns
-        -------
-        DeprecatedStmt
-            Initialized DeprecatedStmt class.
-
-        """
-        Statement.__init__(self, "DEPRECATED")
-        self.line = line
+    def __init__(self, a, b):
+        self.a, self.b = a, b
 
     def to_gerber(self, settings=None):
-        return self.line
+        return '%SFA{decimal_string(self.a, precision=5)}B{decimal_string(self.b, precision=5)}*%'
 
     def __str__(self):
-        return '<Deprecated Statement: \'%s\'>' % self.line
-
+        return '<SF Scale Factor>'
 
 class CoordStmt(Statement):
-    """ Coordinate Data Block
-    """
-
-    OP_DRAW = 'D01'
-    OP_MOVE = 'D02'
-    OP_FLASH = 'D03'
-
-    FUNC_LINEAR = 'G01'
-    FUNC_ARC_CW = 'G02'
-    FUNC_ARC_CCW = 'G03'
+    """ D01 - D03 operation statements """
 
-    @classmethod
-    def from_dict(cls, stmt_dict, settings):
-        function = stmt_dict['function']
-        x = stmt_dict.get('x')
-        y = stmt_dict.get('y')
-        i = stmt_dict.get('i')
-        j = stmt_dict.get('j')
-        op = stmt_dict.get('op')
-
-        if x is not None:
-            x = parse_gerber_value(stmt_dict.get('x'), settings.format,
-                                   settings.zero_suppression)
-        if y is not None:
-            y = parse_gerber_value(stmt_dict.get('y'), settings.format,
-                                   settings.zero_suppression)
-        if i is not None:
-            i = parse_gerber_value(stmt_dict.get('i'), settings.format,
-                                   settings.zero_suppression)
-        if j is not None:
-            j = parse_gerber_value(stmt_dict.get('j'), settings.format,
-                                   settings.zero_suppression)
-        return cls(function, x, y, i, j, op, settings)
+    def __init__(self, x, y, i, j):
+        self.x = x
+        self.y = y
+        self.i = i
+        self.j = j
 
     @classmethod
     def move(cls, func, point):
@@ -943,94 +405,20 @@ class CoordStmt(Statement):
         else:
             return cls(None, None, None, None, None, CoordStmt.OP_FLASH, None)
 
-    def __init__(self, function, x, y, i, j, op, settings):
-        """ Initialize CoordStmt class
-
-        Parameters
-        ----------
-        function : string
-            function
-
-        x : float
-            X coordinate
-
-        y : float
-            Y coordinate
-
-        i : float
-            Coordinate offset in the X direction
-
-        j : float
-            Coordinate offset in the Y direction
-
-        op : string
-            Operation code
-
-        settings : dict {'zero_suppression', 'format'}
-            Gerber file coordinate format
-
-        Returns
-        -------
-        Statement : CoordStmt
-            Initialized CoordStmt class.
-
-        """
-        Statement.__init__(self, "COORD")
-        self.function = function
-        self.x = x
-        self.y = y
-        self.i = i
-        self.j = j
-        self.op = op
-
     def to_gerber(self, settings=None):
         ret = ''
-        if self.function:
-            ret += self.function
         if self.x is not None:
-            ret += 'X{0}'.format(write_gerber_value(self.x, settings.format,
-                                                    settings.zero_suppression))
+            ret += 'X{0}'.format(write_gerber_value(self.x, settings.format, settings.zero_suppression))
         if self.y is not None:
-            ret += 'Y{0}'.format(write_gerber_value(self.y, settings.format,
-                                                    settings.zero_suppression))
+            ret += 'Y{0}'.format(write_gerber_value(self.y, settings.format, settings.zero_suppression))
         if self.i is not None:
-            ret += 'I{0}'.format(write_gerber_value(self.i, settings.format,
-                                                    settings.zero_suppression))
+            ret += 'I{0}'.format(write_gerber_value(self.i, settings.format, settings.zero_suppression))
         if self.j is not None:
-            ret += 'J{0}'.format(write_gerber_value(self.j, settings.format,
-                                                    settings.zero_suppression))
+            ret += 'J{0}'.format(write_gerber_value(self.j, settings.format, settings.zero_suppression))
         if self.op:
             ret += self.op
         return ret + '*'
 
-    def to_inch(self):
-        if self.units == 'metric':
-            self.units = 'inch'
-            if self.x is not None:
-                self.x = inch(self.x)
-            if self.y is not None:
-                self.y = inch(self.y)
-            if self.i is not None:
-                self.i = inch(self.i)
-            if self.j is not None:
-                self.j = inch(self.j)
-            if self.function == "G71":
-                self.function = "G70"
-
-    def to_metric(self):
-        if self.units == 'inch':
-            self.units = 'metric'
-            if self.x is not None:
-                self.x = metric(self.x)
-            if self.y is not None:
-                self.y = metric(self.y)
-            if self.i is not None:
-                self.i = metric(self.i)
-            if self.j is not None:
-                self.j = metric(self.j)
-            if self.function == "G70":
-                self.function = "G71"
-
     def offset(self, x_offset=0, y_offset=0):
         if self.x is not None:
             self.x += x_offset
@@ -1076,13 +464,56 @@ class CoordStmt(Statement):
         # TODO this isn't required
         return self.function != None and self.op == None and self.x == None and self.y == None and self.i == None and self.j == None
 
+class InterpolateStmt(CoordStmt):
+    """ D01 interpolation operation """
+    code = 'D01'
 
-class ApertureStmt(Statement):
-    """ Aperture Statement
-    """
+class MoveStmt(CoordStmt):
+    """ D02 move operation """
+    code = 'D02'
+
+class FlashStmt(CoordStmt):
+    """ D03 flash operation """
+    code = 'D03'
+
+class InterpolationStmt(Statement):
+    """ G01 / G02 / G03 interpolation mode statement """
+    def to_gerber(self, **_kwargs):
+        return self.code + '*'
+
+    def __str__(self):
+        return f'<{self.__doc__.strip()}>'
+
+class LinearModeStmt(InterpolationStmt):
+    """ G01 linear interpolation mode statement """
+    code = 'G01'
 
-    def __init__(self, d, deprecated=None):
-        Statement.__init__(self, "APERTURE")
+class CircularCWModeStmt(InterpolationStmt):
+    """ G02 circular interpolation mode statement """
+    code = 'G02'
+
+class CircularCCWModeStmt(InterpolationStmt):
+    """ G03 circular interpolation mode statement """
+    code = 'G03'
+
+class SingleQuadrantModeStmt(InterpolationStmt):
+    """ G75 single-quadrant arc interpolation mode statement """
+    code = 'G75'
+
+class MultiQuadrantModeStmt(InterpolationStmt):
+    """ G74 multi-quadrant arc interpolation mode statement """
+    code = 'G74'
+
+class RegionStartStatement(InterpolationStmt):
+    """ G36 Region Mode Start Statement. """
+    code = 'G36'
+
+class RegionEndStatement(InterpolationStmt):
+    """ G37 Region Mode End Statement. """
+    code = 'G37'
+
+class ApertureStmt(Statement):
+    def __init__(self, d):
         self.d = int(d)
         self.deprecated = True if deprecated is not None and deprecated is not False else False
 
@@ -1097,23 +528,20 @@ class ApertureStmt(Statement):
 
 
 class CommentStmt(Statement):
-    """ Comment Statment
-    """
+    """ G04 Comment Statment """
 
     def __init__(self, comment):
-        Statement.__init__(self, "COMMENT")
         self.comment = comment if comment is not None else ""
 
     def to_gerber(self, settings=None):
-        return 'G04{0}*'.format(self.comment)
+        return f'G04{self.comment}*'
 
     def __str__(self):
-        return '<Comment: %s>' % self.comment
+        return f'<G04 Comment: {self.comment}>'
 
 
 class EofStmt(Statement):
-    """ EOF Statement
-    """
+    """ M02 EOF Statement """
 
     def __init__(self):
         Statement.__init__(self, "EOF")
@@ -1122,76 +550,14 @@ class EofStmt(Statement):
         return 'M02*'
 
     def __str__(self):
-        return '<EOF Statement>'
-
-
-class QuadrantModeStmt(Statement):
-
-    @classmethod
-    def single(cls):
-        return cls('single-quadrant')
-
-    @classmethod
-    def multi(cls):
-        return cls('multi-quadrant')
-
-    @classmethod
-    def from_gerber(cls, line):
-        if 'G74' not in line and 'G75' not in line:
-            raise ValueError('%s is not a valid quadrant mode statement'
-                             % line)
-        return (cls('single-quadrant') if line[:3] == 'G74'
-                else cls('multi-quadrant'))
-
-    def __init__(self, mode):
-        super(QuadrantModeStmt, self).__init__('QuadrantMode')
-        mode = mode.lower()
-        if mode not in ['single-quadrant', 'multi-quadrant']:
-            raise ValueError('Quadrant mode must be "single-quadrant" \
-                             or "multi-quadrant"')
-        self.mode = mode
-
-    def to_gerber(self, settings=None):
-        return 'G74*' if self.mode == 'single-quadrant' else 'G75*'
-
-
-class RegionModeStmt(Statement):
-
-    @classmethod
-    def from_gerber(cls, line):
-        if 'G36' not in line and 'G37' not in line:
-            raise ValueError('%s is not a valid region mode statement' % line)
-        return (cls('on') if line[:3] == 'G36' else cls('off'))
-
-    @classmethod
-    def on(cls):
-        return cls('on')
-
-    @classmethod
-    def off(cls):
-        return cls('off')
-
-    def __init__(self, mode):
-        super(RegionModeStmt, self).__init__('RegionMode')
-        mode = mode.lower()
-        if mode not in ['on', 'off']:
-            raise ValueError('Valid modes are "on" or "off"')
-        self.mode = mode
-
-    def to_gerber(self, settings=None):
-        return 'G36*' if self.mode == 'on' else 'G37*'
-
+        return '<M02 EOF Statement>'
 
 class UnknownStmt(Statement):
-    """ Unknown Statement
-    """
-
     def __init__(self, line):
-        Statement.__init__(self, "UNKNOWN")
         self.line = line
 
-    def to_gerber(self, settings=None):
+    def to_gerber(self, settings):
         return self.line
 
     def __str__(self):
-        return '<Unknown Statement: \'%s\'>' % self.line
+        return f'<Unknown Statement: "{self.line}">'
diff --git a/gerbonara/gerber/panelize/__init__.py b/gerbonara/gerber/panelize/__init__.py
deleted file mode 100644
index 7185aea..0000000
--- a/gerbonara/gerber/panelize/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2019 Hiroshi Murayama <opiopan@gmail.com>
-
-from .composition import GerberComposition, DrillComposition
-# from .dxf import DxfFile
diff --git a/gerbonara/gerber/panelize/utility.py b/gerbonara/gerber/panelize/utility.py
index fc44e79..0d57979 100644
--- a/gerbonara/gerber/panelize/utility.py
+++ b/gerbonara/gerber/panelize/utility.py
@@ -5,14 +5,6 @@
 
 from math import cos, sin, pi, sqrt
 
-# TODO: replace with ..utils.rotate
-#def rotate(x, y, angle, center):
-#    x0 = x - center[0]
-#    y0 = y - center[1]
-#    angle = angle * pi / 180.0
-#    return (cos(angle) * x0 - sin(angle) * y0 + center[0],
-#            sin(angle) * x0 + cos(angle) * y0 + center[1])
-
 def is_equal_value(a, b, error_range=0):
     return (a - b) * (a - b) <= error_range * error_range
 
diff --git a/gerbonara/gerber/render/__init__.py b/gerbonara/gerber/render/__init__.py
deleted file mode 100644
index c7dbdd5..0000000
--- a/gerbonara/gerber/render/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#! /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.
-"""
-gerber.render
-============
-**Gerber Renderers**
-
-This module provides contexts for rendering images of gerber layers. Currently
-SVG is the only supported format.
-"""
-
-from .render import RenderSettings
-from .cairo_backend import GerberCairoContext
-
-available_renderers = {
-    'cairo': GerberCairoContext,
-}
diff --git a/gerbonara/gerber/render/cairo_backend.py b/gerbonara/gerber/render/cairo_backend.py
deleted file mode 100644
index 431ab94..0000000
--- a/gerbonara/gerber/render/cairo_backend.py
+++ /dev/null
@@ -1,640 +0,0 @@
-#!/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.
-
-try:
-    import cairo
-except ImportError:
-    import cairocffi as cairo
-
-from operator import mul
-import tempfile
-import warnings
-import os
-
-from .render import GerberContext, RenderSettings
-from .theme import THEMES
-from ..primitives import *
-from ..utils import rotate_point
-
-from io import BytesIO
-
-
-class GerberCairoContext(GerberContext):
-
-    def __init__(self, scale=300):
-        super(GerberCairoContext, self).__init__()
-        self.scale = (scale, scale)
-        self.surface = None
-        self.surface_buffer = None
-        self.ctx = None
-        self.active_layer = None
-        self.active_matrix = None
-        self.output_ctx = None
-        self.has_bg = False
-        self.origin_in_inch = None
-        self.size_in_inch = None
-        self._xform_matrix = None
-        self._render_count = 0
-
-    @property
-    def origin_in_pixels(self):
-        return (self.scale_point(self.origin_in_inch)
-                if self.origin_in_inch is not None else (0.0, 0.0))
-
-    @property
-    def size_in_pixels(self):
-        return (self.scale_point(self.size_in_inch)
-                if self.size_in_inch is not None else (0.0, 0.0))
-
-    def set_bounds(self, bounds, new_surface=False):
-        origin_in_inch = (bounds[0][0], bounds[1][0])
-        size_in_inch = (abs(bounds[0][1] - bounds[0][0]),
-                        abs(bounds[1][1] - bounds[1][0]))
-        size_in_pixels = self.scale_point(size_in_inch)
-        self.origin_in_inch = origin_in_inch if self.origin_in_inch is None else self.origin_in_inch
-        self.size_in_inch = size_in_inch if self.size_in_inch is None else self.size_in_inch
-        self._xform_matrix = cairo.Matrix(xx=1.0, yy=-1.0,
-                                          x0=-self.origin_in_pixels[0],
-                                          y0=self.size_in_pixels[1])
-        if (self.surface is None) or new_surface:
-            self.surface_buffer = tempfile.NamedTemporaryFile()
-            self.surface = cairo.SVGSurface(self.surface_buffer, size_in_pixels[0], size_in_pixels[1])
-            self.output_ctx = cairo.Context(self.surface)
-
-    def render_layer(self, layer, filename=None, settings=None, bgsettings=None,
-                     verbose=False, bounds=None):
-        if settings is None:
-            settings = THEMES['default'].get(layer.layer_class, RenderSettings())
-        if bgsettings is None:
-            bgsettings = THEMES['default'].get('background', RenderSettings())
-
-        if self._render_count == 0:
-            if verbose:
-                print('[Render]: Rendering Background.')
-            self.clear()
-            if bounds is not None:
-                self.set_bounds(bounds)
-            else:
-                self.set_bounds(layer.bounds)
-            self.paint_background(bgsettings)
-        if verbose:
-            print('[Render]: Rendering {} Layer.'.format(layer.layer_class))
-        self._render_count += 1
-        self._render_layer(layer, settings)
-        if filename is not None:
-            self.dump(filename, verbose)
-
-    def render_layers(self, layers, filename, theme=THEMES['default'],
-                      verbose=False, max_width=800, max_height=600):
-        """ Render a set of layers
-        """
-        # Calculate scale parameter
-        x_range = [10000, -10000]
-        y_range = [10000, -10000]
-        for layer in layers:
-            bounds = layer.bounds
-            if bounds is not None:
-                layer_x, layer_y = bounds
-                x_range[0] = min(x_range[0], layer_x[0])
-                x_range[1] = max(x_range[1], layer_x[1])
-                y_range[0] = min(y_range[0], layer_y[0])
-                y_range[1] = max(y_range[1], layer_y[1])
-        width = x_range[1] - x_range[0]
-        height = y_range[1] - y_range[0]
-
-        scale = math.floor(min(float(max_width)/width, float(max_height)/height))
-        self.scale = (scale, scale)
-
-        self.clear()
-
-        # Render layers
-        bgsettings = theme['background']
-        for layer in layers:
-            settings = theme.get(layer.layer_class, RenderSettings())
-            self.render_layer(layer, settings=settings, bgsettings=bgsettings,
-                              verbose=verbose)
-        self.dump(filename, verbose)
-
-    def dump(self, filename=None, verbose=False):
-        """ Save image as `filename`
-        """
-        try:
-            is_svg = os.path.splitext(filename.lower())[1] == '.svg'
-        except:
-            is_svg = False
-
-        if verbose:
-            print('[Render]: Writing image to {}'.format(filename))
-
-        if is_svg:
-            self.surface.finish()
-            self.surface_buffer.flush()
-            with open(filename, "wb") as f:
-                self.surface_buffer.seek(0)
-                f.write(self.surface_buffer.read())
-                f.flush()
-        else:
-            return self.surface.write_to_png(filename)
-
-    def dump_str(self):
-        """ Return a byte-string containing the rendered image.
-        """
-        fobj = BytesIO()
-        self.surface.write_to_png(fobj)
-        return fobj.getvalue()
-
-    def dump_svg_str(self):
-        """ Return a string containg the rendered SVG.
-        """
-        self.surface.finish()
-        self.surface_buffer.flush()
-        return self.surface_buffer.read()
-
-    def clear(self):
-        self.surface = None
-        self.output_ctx = None
-        self.has_bg = False
-        self.origin_in_inch = None
-        self.size_in_inch = None
-        self._xform_matrix = None
-        self._render_count = 0
-        self.surface_buffer = None
-
-    def _new_mask(self):
-        class Mask:
-            def __enter__(msk):
-                size_in_pixels = self.size_in_pixels
-                msk.surface = cairo.SVGSurface(None, size_in_pixels[0],
-                                               size_in_pixels[1])
-                msk.ctx = cairo.Context(msk.surface)
-                msk.ctx.translate(-self.origin_in_pixels[0], -self.origin_in_pixels[1])
-                return msk
-
-
-            def __exit__(msk, exc_type, exc_val, traceback):
-                if hasattr(msk.surface, 'finish'):
-                    msk.surface.finish()
-
-        return Mask()
-
-    def _render_layer(self, layer, settings):
-        self.invert = settings.invert
-        # Get a new clean layer to render on
-        self.new_render_layer(mirror=settings.mirror)
-        for prim in layer.primitives:
-            self.render(prim)
-        # Add layer to image
-        self.flatten(settings.color, settings.alpha)
-
-    def _render_line(self, line, color):
-        start = self.scale_point(line.start)
-        end = self.scale_point(line.end)
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and line.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-
-        with self._clip_primitive(line):
-            with self._new_mask() as mask:
-                if isinstance(line.aperture, Circle):
-                    width = line.aperture.diameter
-                    mask.ctx.set_line_width(width * self.scale[0])
-                    mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
-                    mask.ctx.move_to(*start)
-                    mask.ctx.line_to(*end)
-                    mask.ctx.stroke()
-
-                elif hasattr(line, 'vertices') and line.vertices is not None:
-                    points = [self.scale_point(x) for x in line.vertices]
-                    mask.ctx.set_line_width(0)
-                    mask.ctx.move_to(*points[-1])
-                    for point in points:
-                        mask.ctx.line_to(*point)
-                    mask.ctx.fill()
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_arc(self, arc, color):
-        center = self.scale_point(arc.center)
-        start = self.scale_point(arc.start)
-        end = self.scale_point(arc.end)
-        radius = self.scale[0] * arc.radius
-        two_pi = 2 * math.pi
-        angle1 = (arc.start_angle + two_pi) % two_pi
-        angle2 = (arc.end_angle + two_pi) % two_pi
-
-        if arc.quadrant_mode == 'single-quadrant':
-            warnings.warn('Cairo backend does not support single-quadrant arcs.')
-
-        if angle1 == angle2:
-            # Make the angles slightly different otherwise Cario will draw nothing
-            angle2 -= 0.000000001
-        if isinstance(arc.aperture, Circle):
-            width = arc.aperture.diameter if arc.aperture.diameter != 0 else 0.001
-        else:
-            width = max(arc.aperture.width, arc.aperture.height, 0.001)
-
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and arc.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(arc):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(width * self.scale[0])
-                mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND if isinstance(arc.aperture, Circle) else cairo.LINE_CAP_SQUARE)
-                mask.ctx.move_to(*start)  # You actually have to do this...
-                if arc.direction == 'counterclockwise':
-                    mask.ctx.arc(center[0], center[1], radius, angle1, angle2)
-                else:
-                    mask.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
-                mask.ctx.move_to(*end)  # ...lame
-                mask.ctx.stroke()
-
-                #if isinstance(arc.aperture, Rectangle):
-                #    print("Flash Rectangle Ends")
-                #    print(arc.aperture.rotation * 180/math.pi)
-                #    rect = arc.aperture
-                #    width = self.scale[0] * rect.width
-                #    height = self.scale[1] * rect.height
-                #    for point, angle in zip((start, end), (angle1, angle2)):
-                #        print("{} w {} h{}".format(point, rect.width, rect.height))
-                #        mask.ctx.rectangle(point[0] - width/2.0,
-                #                           point[1] - height/2.0, width, height)
-                #        mask.ctx.fill()
-
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_region(self, region, color):
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert) and region.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(region):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(0)
-                mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
-                mask.ctx.move_to(*self.scale_point(region.primitives[0].start))
-                for prim in region.primitives:
-                    if isinstance(prim, Line):
-                        mask.ctx.line_to(*self.scale_point(prim.end))
-                    else:
-                        center = self.scale_point(prim.center)
-                        radius = self.scale[0] * prim.radius
-                        angle1 = prim.start_angle
-                        angle2 = prim.end_angle
-
-                        if angle1 == angle2:
-                            # Make the angles slightly different otherwise Cario will draw nothing
-                            angle2 -= 0.000000001
-                        if prim.direction == 'counterclockwise':
-                            mask.ctx.arc(center[0], center[1], radius,
-                                         angle1, angle2)
-                        else:
-                            mask.ctx.arc_negative(center[0], center[1], radius,
-                                                  angle1, angle2)
-                mask.ctx.fill()
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_circle(self, circle, color):
-        center = self.scale_point(circle.position)
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and circle.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(circle):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(0)
-                mask.ctx.arc(center[0], center[1], (circle.radius * self.scale[0]), 0, (2 * math.pi))
-                mask.ctx.fill()
-
-                if hasattr(circle, 'hole_diameter') and circle.hole_diameter is not None and circle.hole_diameter > 0:
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR)
-                    mask.ctx.arc(center[0], center[1], circle.hole_radius * self.scale[0], 0, 2 * math.pi)
-                    mask.ctx.fill()
-
-                if (hasattr(circle, 'hole_width') and hasattr(circle, 'hole_height')
-                        and circle.hole_width is not None and circle.hole_height is not None
-                        and circle.hole_width > 0 and circle.hole_height > 0):
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if circle.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-                    width, height = self.scale_point((circle.hole_width, circle.hole_height))
-                    lower_left = rotate_point(
-                        (center[0] - width / 2.0, center[1] - height / 2.0),
-                                              circle.rotation, center)
-                    lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
-                                               circle.rotation, center)
-                    upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
-                                              circle.rotation, center)
-                    upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
-                                               circle.rotation, center)
-                    points = (lower_left, lower_right, upper_right, upper_left)
-                    mask.ctx.move_to(*points[-1])
-                    for point in points:
-                        mask.ctx.line_to(*point)
-                    mask.ctx.fill()
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_rectangle(self, rectangle, color):
-        lower_left = self.scale_point(rectangle.lower_left)
-        width, height = tuple([abs(coord) for coord in
-                               self.scale_point((rectangle.width,
-                                                 rectangle.height))])
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and rectangle.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(rectangle):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(0)
-                mask.ctx.rectangle(lower_left[0], lower_left[1], width, height)
-                mask.ctx.fill()
-
-                center = self.scale_point(rectangle.position)
-                if rectangle.hole_diameter > 0:
-                    # Render the center clear
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if rectangle.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-
-                    mask.ctx.arc(center[0], center[1], rectangle.hole_radius * self.scale[0], 0, 2 * math.pi)
-                    mask.ctx.fill()
-
-                if rectangle.hole_width > 0 and rectangle.hole_height > 0:
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if rectangle.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-                    width, height = self.scale_point((rectangle.hole_width, rectangle.hole_height))
-                    lower_left = rotate_point((center[0] - width/2.0, center[1] - height/2.0), rectangle.rotation, center)
-                    lower_right = rotate_point((center[0] + width/2.0, center[1] - height/2.0), rectangle.rotation, center)
-                    upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0), rectangle.rotation, center)
-                    upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0), rectangle.rotation, center)
-                    points = (lower_left, lower_right, upper_right, upper_left)
-                    mask.ctx.move_to(*points[-1])
-                    for point in points:
-                        mask.ctx.line_to(*point)
-                    mask.ctx.fill()
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_obround(self, obround, color):
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and obround.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(obround):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(0)
-
-                # Render circles
-                for circle in (obround.subshapes['circle1'], obround.subshapes['circle2']):
-                    center = self.scale_point(circle.position)
-                    mask.ctx.arc(center[0], center[1], (circle.radius * self.scale[0]), 0, (2 * math.pi))
-                    mask.ctx.fill()
-
-                # Render Rectangle
-                rectangle = obround.subshapes['rectangle']
-                lower_left = self.scale_point(rectangle.lower_left)
-                width, height = tuple([abs(coord) for coord in
-                                       self.scale_point((rectangle.width,
-                                                         rectangle.height))])
-                mask.ctx.rectangle(lower_left[0], lower_left[1], width, height)
-                mask.ctx.fill()
-
-                center = self.scale_point(obround.position)
-                if obround.hole_diameter > 0:
-                    # Render the center clear
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR)
-                    mask.ctx.arc(center[0], center[1], obround.hole_radius * self.scale[0], 0, 2 * math.pi)
-                    mask.ctx.fill()
-
-                if obround.hole_width > 0 and obround.hole_height > 0:
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if rectangle.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-                    width, height =self.scale_point((obround.hole_width, obround.hole_height))
-                    lower_left = rotate_point((center[0] - width / 2.0, center[1] - height / 2.0),
-                                              obround.rotation, center)
-                    lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
-                                               obround.rotation, center)
-                    upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
-                                              obround.rotation, center)
-                    upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
-                                               obround.rotation, center)
-                    points = (lower_left, lower_right, upper_right, upper_left)
-                    mask.ctx.move_to(*points[-1])
-                    for point in points:
-                        mask.ctx.line_to(*point)
-                    mask.ctx.fill()
-
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_polygon(self, polygon, color):
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if (not self.invert)
-                                 and polygon.level_polarity == 'dark'
-                              else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(polygon):
-            with self._new_mask() as mask:
-
-                vertices = polygon.vertices
-                mask.ctx.set_line_width(0)
-                mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
-                # Start from before the end so it is easy to iterate and make sure
-                # it is closed
-                mask.ctx.move_to(*self.scale_point(vertices[-1]))
-                for v in vertices:
-                    mask.ctx.line_to(*self.scale_point(v))
-                mask.ctx.fill()
-
-                center = self.scale_point(polygon.position)
-                if polygon.hole_radius > 0:
-                    # Render the center clear
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if polygon.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-                    mask.ctx.set_line_width(0)
-                    mask.ctx.arc(center[0],
-                                 center[1],
-                                 polygon.hole_radius * self.scale[0], 0, 2 * math.pi)
-                    mask.ctx.fill()
-
-                if polygon.hole_width > 0 and polygon.hole_height > 0:
-                    mask.ctx.set_operator(cairo.OPERATOR_CLEAR
-                                          if polygon.level_polarity == 'dark'
-                                             and (not self.invert)
-                                          else cairo.OPERATOR_OVER)
-                    width, height = self.scale_point((polygon.hole_width, polygon.hole_height))
-                    lower_left = rotate_point((center[0] - width / 2.0, center[1] - height / 2.0),
-                                              polygon.rotation, center)
-                    lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
-                                               polygon.rotation, center)
-                    upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
-                                              polygon.rotation, center)
-                    upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
-                                               polygon.rotation, center)
-                    points = (lower_left, lower_right, upper_right, upper_left)
-                    mask.ctx.move_to(*points[-1])
-                    for point in points:
-                        mask.ctx.line_to(*point)
-                    mask.ctx.fill()
-
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_drill(self, circle, color=None):
-        color = color if color is not None else self.drill_color
-        self._render_circle(circle, color)
-
-    def _render_slot(self, slot, color):
-        start = map(mul, slot.start, self.scale)
-        end = map(mul, slot.end, self.scale)
-
-        width = slot.diameter
-
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if slot.level_polarity == 'dark' and
-                                 (not self.invert) else cairo.OPERATOR_CLEAR)
-        with self._clip_primitive(slot):
-            with self._new_mask() as mask:
-                mask.ctx.set_line_width(width * self.scale[0])
-                mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
-                mask.ctx.move_to(*start)
-                mask.ctx.line_to(*end)
-                mask.ctx.stroke()
-                self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
-    def _render_amgroup(self, amgroup, color):
-        # Since holes/clear areas in the mask group must be drawn as clear, we need to render the primitives of this
-        # group into a mask context first, then composite this mask context on top of our output surface. This means
-        # that a clear primitive inside the group will cover/draw over dark primitives inside the group, but it will
-        # *not* cover/draw over dark primitives outside the group.
-
-        mask_surface = cairo.SVGSurface(None, self.size_in_pixels[0], self.size_in_pixels[1])
-        mask_ctx = cairo.Context(mask_surface)
-        mask_ctx.set_matrix(self.ctx.get_matrix())
-
-        old_surface, self.surface = self.surface, mask_surface
-        old_ctx, self.ctx = self.ctx, mask_ctx
-
-        for primitive in amgroup.primitives:
-            self.render(primitive)
-
-        old_ctx.mask_surface(mask_surface, self.origin_in_pixels[0])
-        mask_surface.finish()
-        self.surface, self.ctx = old_surface, old_ctx
-
-    def _render_test_record(self, primitive, color):
-        position = [pos + origin for pos, origin in
-                    zip(primitive.position, self.origin_in_inch)]
-        self.ctx.select_font_face(
-            'monospace', cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
-        self.ctx.set_font_size(13)
-        self._render_circle(Circle(position, 0.015), color)
-        self.ctx.set_operator(cairo.OPERATOR_OVER
-                              if primitive.level_polarity == 'dark' and
-                              (not self.invert) else cairo.OPERATOR_CLEAR)
-        self.ctx.move_to(*[self.scale[0] * (coord + 0.015) for coord in position])
-        self.ctx.scale(1, -1)
-        self.ctx.show_text(primitive.net_name)
-        self.ctx.scale(1, -1)
-
-    def new_render_layer(self, color=None, mirror=False):
-        size_in_pixels = self.scale_point(self.size_in_inch)
-        m = self._xform_matrix
-        matrix = cairo.Matrix(m.xx, m.yx, m.xy, m.yy, m.x0, m.y0)
-        layer = cairo.SVGSurface(None, size_in_pixels[0], size_in_pixels[1])
-        ctx = cairo.Context(layer)
-
-        if self.invert:
-            ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
-            ctx.set_operator(cairo.OPERATOR_OVER)
-            ctx.paint()
-        if mirror:
-            matrix.xx = -1.0
-            matrix.x0 = self.origin_in_pixels[0] + self.size_in_pixels[0]
-        self.ctx = ctx
-        self.ctx.set_matrix(matrix)
-        self.active_layer = layer
-        self.active_matrix = matrix
-
-    def flatten(self, color=None, alpha=None):
-        color = color if color is not None else self.color
-        alpha = alpha if alpha is not None else self.alpha
-        self.output_ctx.set_source_rgba(color[0], color[1], color[2], alpha)
-        self.output_ctx.mask_surface(self.active_layer)
-        self.ctx = None
-        self.active_layer = None
-        self.active_matrix = None
-
-    def paint_background(self, settings=None):
-        color = settings.color if settings is not None else self.background_color
-        alpha = settings.alpha if settings is not None else 1.0
-        if not self.has_bg:
-            self.has_bg = True
-            self.output_ctx.set_source_rgba(color[0], color[1], color[2], alpha)
-            self.output_ctx.paint()
-
-    def _clip_primitive(self, primitive):
-        """ Clip rendering context to pixel-aligned bounding box
-
-        Calculates pixel- and axis- aligned bounding box, and clips current
-        context to that region. Improves rendering speed significantly. This
-        returns a context manager, use as follows:
-
-            with self._clip_primitive(some_primitive):
-                do_rendering_stuff()
-                do_more_rendering stuff(with, arguments)
-
-        The context manager will reset the context's clipping region when it
-        goes out of scope.
-
-        """
-        class Clip:
-            def __init__(clp, primitive):
-                (xmin, ymin), (xmax, ymax) = primitive.bounding_box
-
-                # Round bounds to the nearest pixel outside of the primitive
-                clp.xmin = math.floor(self.scale[0] * xmin)
-                clp.xmax = math.ceil(self.scale[0] * xmax)
-
-                # We need to offset Y to take care of the difference in y-pos
-                # caused by flipping the axis.
-                clp.ymin = math.floor(
-                    (self.scale[1] * ymin) - math.ceil(self.origin_in_pixels[1]))
-                clp.ymax = math.ceil(
-                    (self.scale[1] * ymax) - math.floor(self.origin_in_pixels[1]))
-
-                # Calculate width and height, rounded to the nearest pixel
-                clp.width = abs(clp.xmax - clp.xmin)
-                clp.height = abs(clp.ymax - clp.ymin)
-
-            def __enter__(clp):
-                # Clip current context to primitive's bounding box
-                self.ctx.rectangle(clp.xmin, clp.ymin, clp.width, clp.height)
-                self.ctx.clip()
-
-            def __exit__(clp, exc_type, exc_val, traceback):
-                # Reset context clip region
-                self.ctx.reset_clip()
-
-        return Clip(primitive)
-
-    def scale_point(self, point):
-        return tuple([coord * scale for coord, scale in zip(point, self.scale)])
diff --git a/gerbonara/gerber/rs274x.py b/gerbonara/gerber/rs274x.py
index 1d946e9..1ab030c 100644
--- a/gerbonara/gerber/rs274x.py
+++ b/gerbonara/gerber/rs274x.py
@@ -25,12 +25,10 @@ import json
 import os
 import re
 import sys
+import warnings
+from pathlib import Path
 from itertools import count, chain
-
-try:
-    from cStringIO import StringIO
-except(ImportError):
-    from io import StringIO
+from io import StringIO
 
 from .gerber_statements import *
 from .primitives import *
@@ -38,40 +36,6 @@ from .cam import CamFile, FileSettings
 from .utils import sq_distance, rotate_point
 
 
-def read(filename):
-    """ Read data from filename and return a GerberFile
-
-    Parameters
-    ----------
-    filename : string
-        Filename of file to parse
-
-    Returns
-    -------
-    file : :class:`gerber.rs274x.GerberFile`
-        A GerberFile created from the specified file.
-    """
-    return GerberParser().parse(filename)
-
-
-def loads(data, filename=None):
-    """ Generate a GerberFile object from rs274x data in memory
-
-    Parameters
-    ----------
-    data : string
-        string containing gerber file contents
-
-    filename : string, optional
-        string containing the filename of the data source
-
-    Returns
-    -------
-    file : :class:`gerber.rs274x.GerberFile`
-        A GerberFile created from the specified file.
-    """
-    return GerberParser().parse_raw(data, filename)
-
 
 class GerberFile(CamFile):
     """ A class representing a single gerber file
@@ -148,18 +112,31 @@ class GerberFile(CamFile):
         self.context.notation = 'absolute'
         self.context.zeros = 'trailing'
 
+
+    @classmethod
+    def open(kls, filename, enable_includes=False, enable_include_dir=None):
+        with open(filename, "r") as f:
+            if enable_includes and enable_include_dir is None:
+                enable_include_dir = Path(filename).parent
+            return kls.from_string(f.read(), enable_include_dir)
+
+
+    @classmethod
+    def from_string(kls, data, enable_include_dir=None):
+        return GerberParser().parse(data, enable_include_dir)
+
     @property
     def comments(self):
-        return [comment.comment for comment in self.statements if isinstance(comment, CommentStmt)]
+        return [stmt.comment for stmt in self.statements if isinstance(stmt, CommentStmt)]
 
     @property
     def size(self):
-        (x0, y0), (x1, y1)= self.bounding_box
+        (x0, y0), (x1, y1) = self.bounding_box
         return (x1 - x0, y1 - y0)
 
     @property
     def bounding_box(self):
-        bounds = [ p.bounding_box for p in self.primitives ]
+        bounds = [ p.bounding_box for p in self.pDeprecatedrimitives ]
 
         min_x = min(x0 for (x0, y0), (x1, y1) in bounds)
         min_y = min(y0 for (x0, y0), (x1, y1) in bounds)
@@ -169,19 +146,19 @@ class GerberFile(CamFile):
         return ((min_x, max_x), (min_y, max_y))
 
     # TODO: re-add settings arg
-    def write(self, filename=None):
-        self.context.notation = 'absolute'
-        self.context.zeros = 'trailing'
-        self.context.format = self.format
+    def write(self, filename):
+        self.settings.notation = 'absolute'
+        self.settings.zeros = 'trailing'
+        self.settings.format = self.format
         self.units = self.units
 
-        with open(filename or self.filename, 'w') as f:
-            print(MOParamStmt('MO', self.context.units).to_gerber(self.context), file=f)
-            print(FSParamStmt('FS', self.context.zero_suppression, self.context.notation, self.context.format).to_gerber(self.context), file=f)
-            print('%IPPOS*%', file=f)
+        with open(filename, 'w') as f:
+            print(UnitStmt().to_gerber(self.settings), file=f)
+            print(FormatSpecStmt().to_gerber(self.settings), file=f)
+            print(ImagePolarityStmt().to_gerber(self.settings), file=f)
 
             for thing in chain(self.aperture_macros.values(), self.aperture_defs, self.main_statements):
-                print(thing.to_gerber(self.context), file=f)
+                print(thing.to_gerber(self.settings), file=f)
 
             print('M02*', file=f)
 
@@ -236,7 +213,6 @@ class GerberFile(CamFile):
     
     def _generalize_apertures(self):
         # For rotation, replace standard apertures with macro apertures.
-
         if not any(isinstance(stm, ADParamStmt) and stm.shape in 'ROP' for stm in self.aperture_defs):
             return
 
@@ -269,68 +245,47 @@ class GerberFile(CamFile):
                     statement.shape = polygon
 
 
-class GerberParser(object):
-    """ GerberParser
-    """
+class GerberParser:
     NUMBER = r"[\+-]?\d+"
     DECIMAL = r"[\+-]?\d+([.]?\d+)?"
-    STRING = r"[a-zA-Z0-9_+\-/!?<>”’(){}.\|&@# :]+"
     NAME = r"[a-zA-Z_$\.][a-zA-Z_$\.0-9+\-]+"
 
-    FS = r"(?P<param>FS)(?P<zero>(L|T|D))?(?P<notation>(A|I))[NG0-9]*X(?P<x>[0-7][0-7])Y(?P<y>[0-7][0-7])[DM0-9]*"
-    MO = r"(?P<param>MO)(?P<mo>(MM|IN))"
-    LP = r"(?P<param>LP)(?P<lp>(D|C))"
-    AD_CIRCLE = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>C)[,]?(?P<modifiers>[^,%]*)"
-    AD_RECT = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>R)[,](?P<modifiers>[^,%]*)"
-    AD_OBROUND = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>O)[,](?P<modifiers>[^,%]*)"
-    AD_POLY = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>P)[,](?P<modifiers>[^,%]*)"
-    AD_MACRO = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>{name})[,]?(?P<modifiers>[^,%]*)".format(name=NAME)
-    AM = r"(?P<param>AM)(?P<name>{name})\*(?P<macro>[^%]*)".format(name=NAME)
-    # Include File
-    IF = r"(?P<param>IF)(?P<filename>.*)"
-
-
-    # begin deprecated
-    AS = r"(?P<param>AS)(?P<mode>(AXBY)|(AYBX))"
-    IN = r"(?P<param>IN)(?P<name>.*)"
-    IP = r"(?P<param>IP)(?P<ip>(POS|NEG))"
-    IR = r"(?P<param>IR)(?P<angle>{number})".format(number=NUMBER)
-    MI = r"(?P<param>MI)(A(?P<a>0|1))?(B(?P<b>0|1))?"
-    OF = r"(?P<param>OF)(A(?P<a>{decimal}))?(B(?P<b>{decimal}))?".format(decimal=DECIMAL)
-    SF = r"(?P<param>SF)(A(?P<a>{decimal}))?(B(?P<b>{decimal}))?".format(decimal=DECIMAL)
-    LN = r"(?P<param>LN)(?P<name>.*)"
-    DEPRECATED_UNIT = re.compile(r'(?P<mode>G7[01])\*')
-    DEPRECATED_FORMAT = re.compile(r'(?P<format>G9[01])\*')
-    # end deprecated
-
-    PARAMS = (FS, MO, LP, AD_CIRCLE, AD_RECT, AD_OBROUND, AD_POLY,
-              AD_MACRO, AM, AS, IF, IN, IP, IR, MI, OF, SF, LN)
-
-    PARAM_STMT = [re.compile(r"%?{0}\*%?".format(p)) for p in PARAMS]
-
-    COORD_FUNCTION = r"G0?[123]"
-    COORD_OP = r"D0?[123]"
-
-    COORD_STMT = re.compile((
-        r"(?P<function>{function})?"
-        r"(X(?P<x>{number}))?(Y(?P<y>{number}))?"
-        r"(I(?P<i>{number}))?(J(?P<j>{number}))?"
-        r"(?P<op>{op})?\*".format(number=NUMBER, function=COORD_FUNCTION, op=COORD_OP)))
-
-    APERTURE_STMT = re.compile(r"(?P<deprecated>(G54)|(G55))?D(?P<d>\d+)\*")
-
-    COMMENT_STMT = re.compile(r"G0?4(?P<comment>[^*]*)(\*)?")
-
-    EOF_STMT = re.compile(r"(?P<eof>M[0]?[012])\*")
-
-    REGION_MODE_STMT = re.compile(r'(?P<mode>G3[67])\*')
-    QUAD_MODE_STMT = re.compile(r'(?P<mode>G7[45])\*')
-
-    # Keep include loop from crashing us
-    INCLUDE_FILE_RECURSION_LIMIT = 10
-
-    def __init__(self):
-        self.filename = None
+    STATEMENT_REGEXES = {
+        'unit_mode': r"MO(?P<unit>(MM|IN))",
+        'interpolation_mode': r"(?P<code>G0?[123]|G74|G75)?",
+        'coord': = fr"(X(?P<x>{NUMBER}))?(Y(?P<y>{NUMBER}))?" \
+            fr"(I(?P<i>{NUMBER}))?(J(?P<j>{NUMBER}))?" \
+            fr"(?P<operation>D0?[123])?\*",
+        'aperture': r"(G54|G55)?D(?P<number>\d+)\*",
+        'comment': r"G0?4(?P<comment>[^*]*)(\*)?",
+        'format_spec': r"FS(?P<zero>(L|T|D))?(?P<notation>(A|I))[NG0-9]*X(?P<x>[0-7][0-7])Y(?P<y>[0-7][0-7])[DM0-9]*",
+        'load_polarity': r"LP(?P<polarity>(D|C))",
+        'load_name': r"LN(?P<name>.*)",
+        'offset': fr"OF(A(?P<a>{DECIMAL}))?(B(?P<b>{DECIMAL}))?",
+        'include_file': r"IF(?P<filename>.*)",
+        'image_name': r"IN(?P<name>.*)",
+        'axis_selection': r"AS(?P<axes>AXBY|AYBX)",
+        'image_polarity': r"IP(?P<polarity>(POS|NEG))",
+        'image_rotation': fr"IR(?P<rotation>{NUMBER})",
+        'mirror_image': r"MI(A(?P<a>0|1))?(B(?P<b>0|1))?",
+        'scale_factor': fr"SF(A(?P<a>{DECIMAL}))?(B(?P<b>{DECIMAL}))?",
+        'aperture_definition': fr"ADD(?P<number>\d+)(?P<shape>C|R|O|P|{NAME})[,]?(?P<modifiers>[^,%]*)",
+        'aperture_macro': fr"AM(?P<name>{NAME})\*(?P<macro>[^%]*)",
+        'region_mode': r'(?P<mode>G3[67])\*',
+        'quadrant_mode': r'(?P<mode>G7[45])\*',
+        'old_unit':r'(?P<mode>G7[01])\*',
+        'old_notation': r'(?P<mode>G9[01])\*',
+        'eof': r"M0?[02]\*",
+        'ignored': r"(?P<stmt>M01)\*",
+        }
+
+    STATEMENT_REGEXES = { key: re.compile(value) for key, value in STATEMENT_REGEXES.items() }
+
+
+    def __init__(self, include_dir=None):
+        """ Pass an include dir to enable IF include statements (potentially DANGEROUS!). """
+        self.include_dir = include_dir
+        self.include_stack = []
         self.settings = FileSettings()
         self.statements = []
         self.primitives = []
@@ -339,6 +294,7 @@ class GerberParser(object):
         self.current_region = None
         self.x = 0
         self.y = 0
+        self.last_operation = None
         self.op = "D02"
         self.aperture = 0
         self.interpolation = 'linear'
@@ -348,17 +304,9 @@ class GerberParser(object):
         self.region_mode = 'off'
         self.quadrant_mode = 'multi-quadrant'
         self.step_and_repeat = (1, 1, 0, 0)
-        self._recursion_depth = 0
 
-    def parse(self, filename):
-        self.filename = filename
-        with open(filename, "r") as fp:
-            data = fp.read()
-        return self.parse_raw(data, filename)
-
-    def parse_raw(self, data, filename=None):
-        self.filename = filename
-        for stmt in self._parse(self._split_commands(data)):
+    def parse(self, data):
+        for stmt in self._parse(data):
             self.evaluate(stmt)
             self.statements.append(stmt)
 
@@ -366,38 +314,37 @@ class GerberParser(object):
         for stmt in self.statements:
             stmt.units = self.settings.units
 
-        return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values(), filename)
+        return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values())
 
-    def _split_commands(self, data):
+    @classmethod
+    def _split_commands(kls, data):
         """
         Split the data into commands. Commands end with * (and also newline to help with some badly formatted files)
         """
 
-        length = len(data)
         start = 0
-        in_header = True
+        extended_command = False
 
-        for cur in range(0, length):
+        for pos, c in enumerate(data):
+            if c == '%':
+                if extended_command:
+                    yield data[start:pos+1]
+                    extended_command = False
+                    start = pos + 1
 
-            val = data[cur]
+                else:
+                    extended_command = True
 
-            if val == '%' and start == cur:
-                in_header = True
                 continue
 
-            if val == '\r' or val == '\n':
-                if start != cur:
-                    yield data[start:cur]
-                start = cur + 1
-
-            elif not in_header and val == '*':
-                yield data[start:cur + 1]
-                start = cur + 1
+            elif extended_command:
+                continue
 
-            elif in_header and val == '%':
-                yield data[start:cur + 1]
+            if c == '\r' or c == '\n' or c == '*':
+                word_command = data[start:pos+1].strip()
+                if word_command and word_command != '*':
+                    yield word_command
                 start = cur + 1
-                in_header = False
 
     def dump_json(self):
         return json.dumps({"statements": [stmt.__dict__ for stmt in self.statements]})
@@ -406,164 +353,189 @@ class GerberParser(object):
         return '\n'.join(str(stmt) for stmt in self.statements) + '\n'
 
     def _parse(self, data):
-        oldline = ''
-
-        for line in data:
-            line = oldline + line.strip()
-
-            # skip empty lines
-            if not len(line):
-                continue
-
-            # deal with multi-line parameters
-            if line.startswith("%") and not line.endswith("%") and not "%" in line[1:]:
-                oldline = line
-                continue
-
-            did_something = True  # make sure we do at least one loop
-            while did_something and len(line) > 0:
-                did_something = False
-
-                # consume empty data blocks
-                if line[0] == '*':
-                    line = line[1:]
-                    did_something = True
-                    continue
-
-                # coord
-                (coord, r) = _match_one(self.COORD_STMT, line)
-                if coord:
-                    yield CoordStmt.from_dict(coord, self.settings)
-                    line = r
-                    did_something = True
-                    continue
-
-                # aperture selection
-                (aperture, r) = _match_one(self.APERTURE_STMT, line)
-                if aperture:
-                    yield ApertureStmt(**aperture)
-                    did_something = True
-                    line = r
-                    continue
+        for line in self._split_commands(data):
+            # We cannot assume input gerber to use well-formed statement delimiters. Thus, we may need to parse
+            # multiple statements from one line.
+            while line:
+                for name, le_regex in self.STATEMENT_REGEXES.items():
+                    if (match := le_regex.match(line))
+                        yield from getattr(self, f'_parse_{name}')(self, match.groupdict())
+                        line = line[match.end(0):]
+                        break
 
-                # parameter
-                (param, r) = _match_one_from_many(self.PARAM_STMT, line)
-
-                if param:
-                    if param["param"] == "FS":
-                        stmt = FSParamStmt.from_dict(param)
-                        self.settings.zero_suppression = stmt.zero_suppression
-                        self.settings.format = stmt.format
-                        self.settings.notation = stmt.notation
-                        yield stmt
-                    elif param["param"] == "MO":
-                        stmt = MOParamStmt.from_dict(param)
-                        self.settings.units = stmt.mode
-                        yield stmt
-                    elif param["param"] == "LP":
-                        yield LPParamStmt.from_dict(param)
-                    elif param["param"] == "AD":
-                        yield ADParamStmt.from_dict(param)
-                    elif param["param"] == "AM":
-                        yield AMParamStmt.from_dict(param, units=self.settings.units)
-                    elif param["param"] == "OF":
-                        yield OFParamStmt.from_dict(param)
-                    elif param["param"] == "IF":
-                        # Don't crash on include loop
-                        if self._recursion_depth < self.INCLUDE_FILE_RECURSION_LIMIT:
-                            self._recursion_depth += 1
-                            with open(os.path.join(os.path.dirname(self.filename), param["filename"]), 'r') as f:
-                                inc_data = f.read()
-                            for stmt in self._parse(self._split_commands(inc_data)):
-                                yield stmt
-                            self._recursion_depth -= 1
-                        else:
-                            raise IOError("Include file nesting depth limit exceeded.")
-                    elif param["param"] == "IN":
-                        yield INParamStmt.from_dict(param)
-                    elif param["param"] == "LN":
-                        yield LNParamStmt.from_dict(param)
-                    # deprecated commands AS, IN, IP, IR, MI, OF, SF, LN
-                    elif param["param"] == "AS":
-                        yield ASParamStmt.from_dict(param)
-                    elif param["param"] == "IN":
-                        yield INParamStmt.from_dict(param)
-                    elif param["param"] == "IP":
-                        yield IPParamStmt.from_dict(param)
-                    elif param["param"] == "IR":
-                        yield IRParamStmt.from_dict(param)
-                    elif param["param"] == "MI":
-                        yield MIParamStmt.from_dict(param)
-                    elif param["param"] == "OF":
-                        yield OFParamStmt.from_dict(param)
-                    elif param["param"] == "SF":
-                        yield SFParamStmt.from_dict(param)
-                    elif param["param"] == "LN":
-                        yield LNParamStmt.from_dict(param)
-                    else:
+                else:
+                    if line[-1] == '*':
                         yield UnknownStmt(line)
+                        line = ''
+
+    def _parse_interpolation_mode(self, match):
+        if match['code'] == 'G01':
+            yield LinearModeStmt()
+        elif match['code'] == 'G02':
+            yield CircularCWModeStmt()
+        elif match['code'] == 'G03':
+            yield CircularCCWModeStmt()
+        elif match['code'] == 'G74':
+            yield MultiQuadrantModeStmt()
+        elif match['code'] == 'G75':
+            yield SingleQuadrantModeStmt()
+
+    def _parse_coord(self, match):
+        x = parse_gerber_value(match.get('x'), self.settings)
+        y = parse_gerber_value(match.get('y'), self.settings)
+        i = parse_gerber_value(match.get('i'), self.settings)
+        j = parse_gerber_value(match.get('j'), self.settings)
+        if not (op := match['operation']):
+            if self.last_operation == 'D01':
+                warnings.warn('Coordinate statement without explicit operation code. This is forbidden by spec.',
+                        SyntaxWarning)
+                op = 'D01'
+            else:
+                raise SyntaxError('Ambiguous coordinate statement. Coordinate statement does not have an operation '\
+                                  'mode and the last operation statement was not D01.')
+
+        if op in ('D1', 'D01'):
+            yield InterpolateStmt(x, y, i, j)
+
+        if i is not None or j is not None:
+            raise SyntaxError("i/j coordinates given for D02/D03 operation (which doesn't take i/j)")
+            
+        if op in ('D2', 'D02'):
+            yield MoveStmt(x, y, i, j)
+        else: # D03
+            yield FlashStmt(x, y, i, j)
+
+
+    def _parse_aperture(self, match):
+        number = int(match['number'])
+        if number < 10:
+            raise SyntaxError(f'Invalid aperture number {number}: Aperture number must be >= 10.')
+        yield ApertureStmt(number)
+    
+    def _parse_format_spec(self, match):
+        # This is a common problem in Eagle files, so just suppress it
+        self.settings.zero_suppression = {'L': 'leading', 'T': 'trailing'}.get(match['zero'], 'leading')
+        self.settings.notation = 'absolute' if match.['notation'] == 'A' else 'incremental'
 
-                    did_something = True
-                    line = r
-                    continue
-
-                # Region Mode
-                (mode, r) = _match_one(self.REGION_MODE_STMT, line)
-                if mode:
-                    yield RegionModeStmt.from_gerber(line)
-                    line = r
-                    did_something = True
-                    continue
+        if match['x'] != match['y']:
+            raise SyntaxError(f'FS specifies different coordinate formats for X and Y ({match["x"]} != {match["y"]})')
+        self.settings.number_format = int(match['x'][0]), int(match['x'][1])
 
-                # Quadrant Mode
-                (mode, r) = _match_one(self.QUAD_MODE_STMT, line)
-                if mode:
-                    yield QuadrantModeStmt.from_gerber(line)
-                    line = r
-                    did_something = True
-                    continue
+        yield FormatSpecStmt()
 
-                # comment
-                (comment, r) = _match_one(self.COMMENT_STMT, line)
-                if comment:
-                    yield CommentStmt(comment["comment"])
-                    did_something = True
-                    line = r
-                    continue
+    def _parse_unit_mode(self, match):
+        if match['unit'] == 'MM':
+            self.settings.units = 'mm'
+        else:
+            self.settings.units = 'inch'
 
-                # deprecated codes
-                (deprecated_unit, r) = _match_one(self.DEPRECATED_UNIT, line)
-                if deprecated_unit:
-                    stmt = MOParamStmt(param="MO", mo="inch" if "G70" in
-                                       deprecated_unit["mode"] else "metric")
-                    self.settings.units = stmt.mode
-                    yield stmt
-                    line = r
-                    did_something = True
-                    continue
+        yield MOParamStmt()
 
-                (deprecated_format, r) = _match_one(self.DEPRECATED_FORMAT, line)
-                if deprecated_format:
-                    yield DeprecatedStmt.from_gerber(line)
-                    line = r
-                    did_something = True
-                    continue
+    def _parse_load_polarity(self, match):
+        yield LoadPolarityStmt(dark=(match['polarity'] == 'D'))
 
-                # eof
-                (eof, r) = _match_one(self.EOF_STMT, line)
-                if eof:
-                    yield EofStmt()
-                    did_something = True
-                    line = r
-                    continue
+    def _parse_offset(self, match):
+        a, b = match['a'], match['b']
+        a = float(a) if a else 0
+        b = float(b) if b else 0
+        yield OffsetStmt(a, b)
 
-                if line.find('*') > 0:
-                    yield UnknownStmt(line)
-                    did_something = True
-                    line = ""
-                    continue
+    def _parse_include_file(self, match):
+        if self.include_dir is None:
+            warnings.warn('IF Include File statement found, but includes are deactivated.', ResourceWarning)
+        else:
+            warnings.warn('IF Include File statement found. Includes are activated, but is this really a good idea?', ResourceWarning)
+
+        include_file = self.include_dir / param["filename"]
+        if include_file in self.include_stack
+            raise ValueError("Recusive file inclusion via IF include statement.")
+        self.include_stack.append(include_file)
+
+        # Spec 2020-09 section 3.1: Gerber files must use UTF-8
+        yield from self._parse(f.read_text(encoding='UTF-8'))
+        self.include_stack.pop()
+
+
+    def _parse_image_name(self, match):
+        warnings.warn('Deprecated IN (image name) statement found. This deprecated since rev. I4 (Oct 2013).',
+                DeprecationWarning)
+        yield CommentStmt(f'Image name: {match["name"]}')
+
+    def _parse_load_name(self, match):
+        warnings.warn('Deprecated LN (load name) statement found. This deprecated since rev. I4 (Oct 2013).',
+                DeprecationWarning)
+        yield CommentStmt(f'Name of subsequent part: {match["name"]}')
+
+    def _parse_axis_selection(self, match):
+        warnings.warn('Deprecated AS (axis selection) statement found. This deprecated since rev. I1 (Dec 2012).',
+                DeprecationWarning)
+        self.settings.output_axes = match['axes']
+        yield AxisSelectionStmt()
+
+    def _parse_image_polarity(self, match):
+        warnings.warn('Deprecated IP (image polarity) statement found. This deprecated since rev. I4 (Oct 2013).',
+                DeprecationWarning)
+        self.settings.image_polarity = match['polarity']
+        yield ImagePolarityStmt()
+    
+    def _parse_image_rotation(self, match):
+        warnings.warn('Deprecated IR (image rotation) statement found. This deprecated since rev. I1 (Dec 2012).',
+                DeprecationWarning)
+        self.settings.image_rotation = int(match['rotation'])
+        yield ImageRotationStmt()
+
+    def _parse_mirror_image(self, match):
+        warnings.warn('Deprecated MI (mirror image) statement found. This deprecated since rev. I1 (Dec 2012).',
+                DeprecationWarning)
+        self.settings.mirror = bool(int(match['a'] or '0')), bool(int(match['b'] or '1'))
+        yield MirrorImageStmt()
+
+    def _parse_scale_factor(self, match):
+        warnings.warn('Deprecated SF (scale factor) statement found. This deprecated since rev. I1 (Dec 2012).',
+                DeprecationWarning)
+        a = float(match['a']) if match['a'] else 1.0
+        b = float(match['b']) if match['b'] else 1.0
+        self.settings.scale_factor = a, b
+        yield ScaleFactorStmt()
+
+    def _parse_comment(self, match):
+        yield CommentStmt(match["comment"])
+
+    def _parse_region_mode(self, match):
+        yield RegionStartStatement() if match['mode'] == 'G36' else RegionEndStatement()
+
+        elif param["param"] == "AM":
+            yield AMParamStmt.from_dict(param, units=self.settings.units)
+        elif param["param"] == "AD":
+            yield ADParamStmt.from_dict(param)
+
+    def _parse_quadrant_mode(self, match):
+        if match['mode'] == 'G74':
+            warnings.warn('Deprecated G74 single quadrant mode statement found. This deprecated since 2021.',
+                    DeprecationWarning)
+            yield SingleQuadrantModeStmt()
+        else:
+            yield MultiQuadrantModeStmt()
+
+    def _parse_old_unit(self, match):
+        self.settings.units = 'inch' if match['mode'] == 'G70' else 'mm'
+        warnings.warn(f'Deprecated {match["mode"]} unit mode statement found. This deprecated since 2012.',
+                    DeprecationWarning)
+        yield CommentStmt(f'Replaced deprecated {match["mode"]} unit mode statement with MO statement')
+        yield UnitStmt()
+
+    def _parse_old_unit(self, match):
+        # FIXME make sure we always have FS at end of processing.
+        self.settings.notation = 'absolute' if match['mode'] == 'G90' else 'incremental'
+        warnings.warn(f'Deprecated {match["mode"]} notation mode statement found. This deprecated since 2012.',
+                    DeprecationWarning)
+        yield CommentStmt(f'Replaced deprecated {match["mode"]} notation mode statement with FS statement')
+    
+    def _parse_eof(self, match):
+        yield EofStmt()
 
-            oldline = line
+    def _parse_ignored(self, match):
+        yield CommentStmt(f'Ignoring {match{"stmt"]} statement.')
 
     def evaluate(self, stmt):
         """ Evaluate Gerber statement and update image accordingly.
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
index 3ec60d8..f71c948 100644
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
+++ b/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
@@ -8,7 +8,6 @@
 1,1,0.015748,-0.0472441,0,$1*
 4,1,4,0.0472441,0,0.0551181,-0.00787402,0.0472441,-0.015748,0.0393701,-0.00787402,0.0472441,0,$1*
 5,1,6,0.0472441,0.00787402,0.015748,$1*
-6,-0.0275591,0,0.019685,0.0019685,0.00590551,2,0.0019685,0.023622,$1*
 7,0.0275591,0,0.023622,0.019685,0.00590551,$1*%
 %ADD10C,0.0003937*%
 %ADD11C,0.03937X0.01575*%
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
index 8dfbdd4..98833de 100644
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
+++ b/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
@@ -8,7 +8,6 @@
 1,1,0.4,-1.2,0,$1*
 4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
 5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
 7,0.7,0,0.6,0.5,0.15,$1*%
 %ADD10C,0.01*%
 %ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl
deleted file mode 100644
index f31f1e7..0000000
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl
+++ /dev/null
@@ -1,40 +0,0 @@
-%MOMM*%
-%FSLAX34Y34*%
-%IPPOS*%
-%ADD10C,0.1*%
-G74*
-%LPD*%
-
-D10*
-
-G36*
-G01*
-X0Y10000D02*
-Y90000D01*
-G02*
-X10000Y100000I10000*
-X20000Y90000J10000*
-G01*
-Y20000*
-X40000*
-G02*
-X50000Y10000J10000*
-X40000Y0I10000*
-G01*
-X10000*
-G02*
-X0Y10000J10000*
-G37*
-
-G03*
-X70000Y50000D02*
-X60000Y60000I10000D01*
-X50000Y50000J10000*
-X60000Y40000I10000*
-X70000Y50000J10000*
-
-G02*
-X60000Y90000D02*
-X60000Y90000I10000D01*
-
-M02*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
index 3dc3e6a..0bebd07 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
@@ -7,7 +7,6 @@
 1,1,0.4,-1.2,0,$1*
 4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
 5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
 7,0.7,0,0.6,0.5,0.15,$1*%
 %ADD10C,0.01*%
 %ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
index f7c82cd..00335b8 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
@@ -7,7 +7,6 @@
 1,1,0.4,-1.2,0,($1)+(20)*
 4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,($1)+(20)*
 5,1,6,1.2,0.2,0.4,($1)+(20)*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,($1)+(20)*
 7,0.7,0,0.6,0.5,0.15,($1)+(20)*%
 %AMMACR*
 21,1,$1,$2,0,0,20*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
index 5053d99..b4fe9e1 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
@@ -7,7 +7,6 @@
 1,1,0.4,-1.2,0,$1*
 4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
 5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
 7,0.7,0,0.6,0.5,0.15,$1*%
 %ADD10C,0.01*%
 %ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl
deleted file mode 100644
index dbec705..0000000
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl
+++ /dev/null
@@ -1,35 +0,0 @@
-%MOMM*%
-%FSLAX34Y34*%
-%IPPOS*%
-%ADD10C,0.1*%
-G75*
-%LPD*%
-D10*
-G36*
-G01*
-X0Y10000D02*
-X0Y90000D01*
-G02*
-X10000Y100000I10000J0D01*
-X20000Y90000I0J-10000D01*
-G01*
-X20000Y20000D01*
-X40000Y20000D01*
-G02*
-X50000Y10000I0J-10000D01*
-X40000Y0I-10000J0D01*
-G01*
-X10000Y0D01*
-G02*
-X0Y10000I0J10000D01*
-G37*
-G03*
-X70000Y50000D02*
-X60000Y60000I-10000J0D01*
-X50000Y50000I0J-10000D01*
-X60000Y40000I10000J0D01*
-X70000Y50000I0J10000D01*
-G02*
-X60000Y90000D02*
-X60000Y90000I0J0D01*
-M02*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
index cb9234e..ed23a58 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
@@ -7,7 +7,6 @@
 1,1,0.015748,-0.0472441,0,$1*
 4,1,4,0.0472441,0,0.0551181,-0.00787402,0.0472441,-0.015748,0.0393701,-0.00787402,0.0472441,0,$1*
 5,1,6,0.0472441,0.00787402,0.015748,$1*
-6,-0.0275591,0,0.019685,0.0019685,0.00590551,2,0.0019685,0.023622,$1*
 7,0.0275591,0,0.023622,0.019685,0.00590551,$1*%
 %ADD10C,0.0003937*%
 %ADD11C,0.03937X0.01575*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
index a8efda8..2a4df41 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
@@ -7,7 +7,6 @@
 1,1,0.399999,-1.2,0,$1*
 4,1,4,1.2,0,1.4,-0.2,1.2,-0.399999,1,-0.2,1.2,0,$1*
 5,1,6,1.2,0.2,0.399999,$1*
-6,-0.700001,0,0.499999,0.0499999,0.15,2,0.0499999,0.599999,$1*
 7,0.700001,0,0.599999,0.499999,0.15,$1*%
 %ADD10C,0.01*%
 %ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/test_am_expression.py b/gerbonara/gerber/tests/panelize/test_am_expression.py
index 45758b7..576be88 100644
--- a/gerbonara/gerber/tests/panelize/test_am_expression.py
+++ b/gerbonara/gerber/tests/panelize/test_am_expression.py
@@ -30,10 +30,6 @@ class TestAMConstantExpression(unittest.TestCase):
         self.assertEqual(self.const_int.to_gerber(), '7')
         self.assertEqual(self.const_float.to_gerber(), '1.2345')
 
-    def test_to_instructions(self):
-        self.const_int.to_instructions()
-        self.const_float.to_instructions()
-
 class TestAMVariableExpression(unittest.TestCase):
     def setUp(self):
         self.var1_num = 1
@@ -57,10 +53,6 @@ class TestAMVariableExpression(unittest.TestCase):
         self.assertEqual(self.var1.to_gerber(), '$1')
         self.assertEqual(self.var2.to_gerber(), '$512')
 
-    def test_to_instructions(self):
-        self.var1.to_instructions()
-        self.var2.to_instructions()
-
 class TestAMOperatorExpression(unittest.TestCase):
     def setUp(self):
         self.c1 = 10
@@ -132,11 +124,6 @@ class TestAMOperatorExpression(unittest.TestCase):
                              self.c1, self.c2, self.c1, self.c2
                          ))
     
-    def test_to_instructions(self):
-        for of, expression in self.vc_exps + self.cv_exps + self.cc_exps:
-            expression.to_instructions()
-        self.composition.to_instructions()
-
 class TestAMExpression(unittest.TestCase):
     def setUp(self):
         self.c1 = 10
diff --git a/gerbonara/gerber/tests/panelize/test_rs274x.py b/gerbonara/gerber/tests/panelize/test_rs274x.py
index 067717d..73f3172 100644
--- a/gerbonara/gerber/tests/panelize/test_rs274x.py
+++ b/gerbonara/gerber/tests/panelize/test_rs274x.py
@@ -68,8 +68,3 @@ class TestRs274x(unittest.TestCase):
             gerber.rotate(20, (10,10))
             gerber.write(outfile)
 
-    def test_single_quadrant(self):
-        with self._check_result('RS2724x_single_quadrant.gtl') as outfile:
-            gerber = read(self.SQ_FILE)
-            gerber.write(outfile)
-
diff --git a/gerbonara/gerber/tests/test_am_statements.py b/gerbonara/gerber/tests/test_am_statements.py
deleted file mode 100644
index 0d100b5..0000000
--- a/gerbonara/gerber/tests/test_am_statements.py
+++ /dev/null
@@ -1,395 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Hamilton Kibbe <ham@hamiltonkib.be>
-
-import pytest
-
-from ..am_statements import *
-from ..am_statements import inch, metric
-
-
-def test_AMPrimitive_ctor():
-    for exposure in ("on", "off", "ON", "OFF"):
-        for code in (0, 1, 2, 4, 5, 6, 7, 20, 21, 22):
-            p = AMPrimitive(code, exposure)
-            assert p.code == code
-            assert p.exposure == exposure.lower()
-
-
-def test_AMPrimitive_validation():
-    pytest.raises(TypeError, AMPrimitive, "1", "off")
-    pytest.raises(ValueError, AMPrimitive, 0, "exposed")
-    pytest.raises(ValueError, AMPrimitive, 3, "off")
-
-
-def test_AMPrimitive_conversion():
-    p = AMPrimitive(4, "on")
-    pytest.raises(NotImplementedError, p.to_inch)
-    pytest.raises(NotImplementedError, p.to_metric)
-
-
-def test_AMCommentPrimitive_ctor():
-    c = AMCommentPrimitive(0, " This is a comment *")
-    assert c.code == 0
-    assert c.comment == "This is a comment"
-
-
-def test_AMCommentPrimitive_validation():
-    pytest.raises(ValueError, AMCommentPrimitive, 1, "This is a comment")
-
-
-def test_AMCommentPrimitive_factory():
-    c = AMCommentPrimitive.from_gerber("0 Rectangle with rounded corners. *")
-    assert c.code == 0
-    assert c.comment == "Rectangle with rounded corners."
-
-
-def test_AMCommentPrimitive_dump():
-    c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
-    assert c.to_gerber() == "0 Rectangle with rounded corners. *"
-
-
-def test_AMCommentPrimitive_conversion():
-    c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
-    ci = c
-    cm = c
-    ci.to_inch()
-    cm.to_metric()
-    assert c == ci
-    assert c == cm
-
-
-def test_AMCommentPrimitive_string():
-    c = AMCommentPrimitive(0, "Test Comment")
-    assert str(c) == "<Aperture Macro Comment: Test Comment>"
-
-
-def test_AMCirclePrimitive_ctor():
-    test_cases = (
-        (1, "on", 0, (0, 0)),
-        (1, "off", 1, (0, 1)),
-        (1, "on", 2.5, (0, 2)),
-        (1, "off", 5.0, (3, 3)),
-    )
-    for code, exposure, diameter, position in test_cases:
-        c = AMCirclePrimitive(code, exposure, diameter, position)
-        assert c.code == code
-        assert c.exposure == exposure
-        assert c.diameter == diameter
-        assert c.position == position
-
-
-def test_AMCirclePrimitive_validation():
-    pytest.raises(ValueError, AMCirclePrimitive, 2, "on", 0, (0, 0))
-
-
-def test_AMCirclePrimitive_factory():
-    c = AMCirclePrimitive.from_gerber("1,0,5,0,0*")
-    assert c.code == 1
-    assert c.exposure == "off"
-    assert c.diameter == 5
-    assert c.position == (0, 0)
-
-
-def test_AMCirclePrimitive_dump():
-    c = AMCirclePrimitive(1, "off", 5, (0, 0))
-    assert c.to_gerber() == "1,0,5,0,0*"
-    c = AMCirclePrimitive(1, "on", 5, (0, 0))
-    assert c.to_gerber() == "1,1,5,0,0*"
-
-
-def test_AMCirclePrimitive_conversion():
-    c = AMCirclePrimitive(1, "off", 25.4, (25.4, 0))
-    c.to_inch()
-    assert c.diameter == 1
-    assert c.position == (1, 0)
-
-    c = AMCirclePrimitive(1, "off", 1, (1, 0))
-    c.to_metric()
-    assert c.diameter == 25.4
-    assert c.position == (25.4, 0)
-
-
-def test_AMVectorLinePrimitive_validation():
-    pytest.raises(
-        ValueError, AMVectorLinePrimitive, 3, "on", 0.1, (0, 0), (3.3, 5.4), 0
-    )
-
-
-def test_AMVectorLinePrimitive_factory():
-    l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
-    assert l.code == 20
-    assert l.exposure == "on"
-    assert l.width == 0.9
-    assert l.start == (0, 0.45)
-    assert l.end == (12, 0.45)
-    assert l.rotation == 0
-
-
-def test_AMVectorLinePrimitive_dump():
-    l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
-    assert l.to_gerber() == "20,1,0.9,0.0,0.45,12.0,0.45,0.0*"
-
-
-def test_AMVectorLinePrimtive_conversion():
-    l = AMVectorLinePrimitive(20, "on", 25.4, (0, 0), (25.4, 25.4), 0)
-    l.to_inch()
-    assert l.width == 1
-    assert l.start == (0, 0)
-    assert l.end == (1, 1)
-
-    l = AMVectorLinePrimitive(20, "on", 1, (0, 0), (1, 1), 0)
-    l.to_metric()
-    assert l.width == 25.4
-    assert l.start == (0, 0)
-    assert l.end == (25.4, 25.4)
-
-
-def test_AMOutlinePrimitive_validation():
-    pytest.raises(
-        ValueError,
-        AMOutlinePrimitive,
-        7,
-        "on",
-        (0, 0),
-        [(3.3, 5.4), (4.0, 5.4), (0, 0)],
-        0,
-    )
-    pytest.raises(
-        ValueError,
-        AMOutlinePrimitive,
-        4,
-        "on",
-        (0, 0),
-        [(3.3, 5.4), (4.0, 5.4), (0, 1)],
-        0,
-    )
-
-
-def test_AMOutlinePrimitive_factory():
-    o = AMOutlinePrimitive.from_gerber("4,1,3,0,0,3,3,3,0,0,0,0*")
-    assert o.code == 4
-    assert o.exposure == "on"
-    assert o.start_point == (0, 0)
-    assert o.points == [(3, 3), (3, 0), (0, 0)]
-    assert o.rotation == 0
-
-
-def test_AMOUtlinePrimitive_dump():
-    o = AMOutlinePrimitive(4, "on", (0, 0), [(3, 3), (3, 0), (0, 0)], 0)
-    # New lines don't matter for Gerber, but we insert them to make it easier to remove
-    # For test purposes we can ignore them
-    assert o.to_gerber().replace("\n", "") == "4,1,3,0,0,3,3,3,0,0,0,0*"
-
-
-def test_AMOutlinePrimitive_conversion():
-    o = AMOutlinePrimitive(4, "on", (0, 0), [(25.4, 25.4), (25.4, 0), (0, 0)], 0)
-    o.to_inch()
-    assert o.start_point == (0, 0)
-    assert o.points == ((1.0, 1.0), (1.0, 0.0), (0.0, 0.0))
-
-    o = AMOutlinePrimitive(4, "on", (0, 0), [(1, 1), (1, 0), (0, 0)], 0)
-    o.to_metric()
-    assert o.start_point == (0, 0)
-    assert o.points == ((25.4, 25.4), (25.4, 0), (0, 0))
-
-
-def test_AMPolygonPrimitive_validation():
-    pytest.raises(ValueError, AMPolygonPrimitive, 6, "on", 3, (3.3, 5.4), 3, 0)
-    pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 2, (3.3, 5.4), 3, 0)
-    pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 13, (3.3, 5.4), 3, 0)
-
-
-def test_AMPolygonPrimitive_factory():
-    p = AMPolygonPrimitive.from_gerber("5,1,3,3.3,5.4,3,0")
-    assert p.code == 5
-    assert p.exposure == "on"
-    assert p.vertices == 3
-    assert p.position == (3.3, 5.4)
-    assert p.diameter == 3
-    assert p.rotation == 0
-
-
-def test_AMPolygonPrimitive_dump():
-    p = AMPolygonPrimitive(5, "on", 3, (3.3, 5.4), 3, 0)
-    assert p.to_gerber() == "5,1,3,3.3,5.4,3,0*"
-
-
-def test_AMPolygonPrimitive_conversion():
-    p = AMPolygonPrimitive(5, "off", 3, (25.4, 0), 25.4, 0)
-    p.to_inch()
-    assert p.diameter == 1
-    assert p.position == (1, 0)
-
-    p = AMPolygonPrimitive(5, "off", 3, (1, 0), 1, 0)
-    p.to_metric()
-    assert p.diameter == 25.4
-    assert p.position == (25.4, 0)
-
-
-def test_AMMoirePrimitive_validation():
-    pytest.raises(
-        ValueError, AMMoirePrimitive, 7, (0, 0), 5.1, 0.2, 0.4, 6, 0.1, 6.1, 0
-    )
-
-
-def test_AMMoirePrimitive_factory():
-    m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
-    assert m.code == 6
-    assert m.position == (0, 0)
-    assert m.diameter == 5
-    assert m.ring_thickness == 0.5
-    assert m.gap == 0.5
-    assert m.max_rings == 2
-    assert m.crosshair_thickness == 0.1
-    assert m.crosshair_length == 6
-    assert m.rotation == 0
-
-
-def test_AMMoirePrimitive_dump():
-    m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
-    assert m.to_gerber() == "6,0,0,5.0,0.5,0.5,2,0.1,6.0,0.0*"
-
-
-def test_AMMoirePrimitive_conversion():
-    m = AMMoirePrimitive(6, (25.4, 25.4), 25.4, 25.4, 25.4, 6, 25.4, 25.4, 0)
-    m.to_inch()
-    assert m.position == (1.0, 1.0)
-    assert m.diameter == 1.0
-    assert m.ring_thickness == 1.0
-    assert m.gap == 1.0
-    assert m.crosshair_thickness == 1.0
-    assert m.crosshair_length == 1.0
-
-    m = AMMoirePrimitive(6, (1, 1), 1, 1, 1, 6, 1, 1, 0)
-    m.to_metric()
-    assert m.position == (25.4, 25.4)
-    assert m.diameter == 25.4
-    assert m.ring_thickness == 25.4
-    assert m.gap == 25.4
-    assert m.crosshair_thickness == 25.4
-    assert m.crosshair_length == 25.4
-
-
-def test_AMThermalPrimitive_validation():
-    pytest.raises(ValueError, AMThermalPrimitive, 8, (0.0, 0.0), 7, 5, 0.2, 0.0)
-    pytest.raises(TypeError, AMThermalPrimitive, 7, (0.0, "0"), 7, 5, 0.2, 0.0)
-
-
-def test_AMThermalPrimitive_factory():
-    t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,45*")
-    assert t.code == 7
-    assert t.position == (0, 0)
-    assert t.outer_diameter == 7
-    assert t.inner_diameter == 6
-    assert t.gap == 0.2
-    assert t.rotation == 45
-
-
-def test_AMThermalPrimitive_dump():
-    t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,30*")
-    assert t.to_gerber() == "7,0,0,7.0,6.0,0.2,30.0*"
-
-
-def test_AMThermalPrimitive_conversion():
-    t = AMThermalPrimitive(7, (25.4, 25.4), 25.4, 25.4, 25.4, 0.0)
-    t.to_inch()
-    assert t.position == (1.0, 1.0)
-    assert t.outer_diameter == 1.0
-    assert t.inner_diameter == 1.0
-    assert t.gap == 1.0
-
-    t = AMThermalPrimitive(7, (1, 1), 1, 1, 1, 0)
-    t.to_metric()
-    assert t.position == (25.4, 25.4)
-    assert t.outer_diameter == 25.4
-    assert t.inner_diameter == 25.4
-    assert t.gap == 25.4
-
-
-def test_AMCenterLinePrimitive_validation():
-    pytest.raises(ValueError, AMCenterLinePrimitive, 22, 1, 0.2, 0.5, (0, 0), 0)
-
-
-def test_AMCenterLinePrimtive_factory():
-    l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
-    assert l.code == 21
-    assert l.exposure == "on"
-    assert l.width == 6.8
-    assert l.height == 1.2
-    assert l.center == (3.4, 0.6)
-    assert l.rotation == 0
-
-
-def test_AMCenterLinePrimitive_dump():
-    l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
-    assert l.to_gerber() == "21,1,6.8,1.2,3.4,0.6,0.0*"
-
-
-def test_AMCenterLinePrimitive_conversion():
-    l = AMCenterLinePrimitive(21, "on", 25.4, 25.4, (25.4, 25.4), 0)
-    l.to_inch()
-    assert l.width == 1.0
-    assert l.height == 1.0
-    assert l.center == (1.0, 1.0)
-
-    l = AMCenterLinePrimitive(21, "on", 1, 1, (1, 1), 0)
-    l.to_metric()
-    assert l.width == 25.4
-    assert l.height == 25.4
-    assert l.center == (25.4, 25.4)
-
-
-def test_AMLowerLeftLinePrimitive_validation():
-    pytest.raises(ValueError, AMLowerLeftLinePrimitive, 23, 1, 0.2, 0.5, (0, 0), 0)
-
-
-def test_AMLowerLeftLinePrimtive_factory():
-    l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
-    assert l.code == 22
-    assert l.exposure == "on"
-    assert l.width == 6.8
-    assert l.height == 1.2
-    assert l.lower_left == (3.4, 0.6)
-    assert l.rotation == 0
-
-
-def test_AMLowerLeftLinePrimitive_dump():
-    l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
-    assert l.to_gerber() == "22,1,6.8,1.2,3.4,0.6,0.0*"
-
-
-def test_AMLowerLeftLinePrimitive_conversion():
-    l = AMLowerLeftLinePrimitive(22, "on", 25.4, 25.4, (25.4, 25.4), 0)
-    l.to_inch()
-    assert l.width == 1.0
-    assert l.height == 1.0
-    assert l.lower_left == (1.0, 1.0)
-
-    l = AMLowerLeftLinePrimitive(22, "on", 1, 1, (1, 1), 0)
-    l.to_metric()
-    assert l.width == 25.4
-    assert l.height == 25.4
-    assert l.lower_left == (25.4, 25.4)
-
-
-def test_AMUnsupportPrimitive():
-    u = AMUnsupportPrimitive.from_gerber("Test")
-    assert u.primitive == "Test"
-    u = AMUnsupportPrimitive("Test")
-    assert u.to_gerber() == "Test"
-
-
-def test_AMUnsupportPrimitive_smoketest():
-    u = AMUnsupportPrimitive.from_gerber("Test")
-    u.to_inch()
-    u.to_metric()
-
-
-def test_inch():
-    assert inch(25.4) == 1
-
-
-def test_metric():
-    assert metric(1) == 25.4
diff --git a/gerbonara/gerber/tests/test_cairo_backend.py b/gerbonara/gerber/tests/test_cairo_backend.py
deleted file mode 100644
index b8c9676..0000000
--- a/gerbonara/gerber/tests/test_cairo_backend.py
+++ /dev/null
@@ -1,382 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Garret Fick <garret@ficksworkshop.com>
-import os
-import shutil
-import io
-import tempfile
-import uuid
-import cv2
-from pathlib import Path
-
-import pytest
-from PIL import Image
-import numpy as np
-
-from ..render.cairo_backend import GerberCairoContext
-from ..rs274x import read
-
-class Tempdir:
-    def __init__(self):
-        self.path = tempfile.mkdtemp(prefix='gerbonara-test-')
-        self.delete = True
-
-    def cleanup(self):
-        if self.delete:
-            shutil.rmtree(self.path)
-
-    def create(self, prefix='fail-', suffix=''):
-        return Path(self.path) / f'{prefix}{uuid.uuid4()}{suffix}'
-
-    def keep(self):
-        self.delete = False
-
-output_dir = Tempdir()
-@pytest.fixture(scope='session', autouse=True)
-def cleanup(request):
-    global output_dir
-    request.addfinalizer(output_dir.cleanup)
-
-def test_render_two_boxes():
-    """Umaco exapmle of two boxes"""
-    _test_render("resources/example_two_square_boxes.gbr", "golden/example_two_square_boxes.png")
-
-
-def test_render_simple_contour():
-    """Umaco exapmle of a simple arrow-shaped contour"""
-    gerber = _test_render("resources/example_simple_contour.gbr", "golden/example_simple_contour.png")
-
-    # Check the resulting dimensions
-    assert ((2.0, 11.0), (1.0, 9.0)) == gerber.bounding_box
-
-
-def test_render_single_contour_1():
-    """Umaco example of a single contour
-
-    The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render(
-        "resources/example_single_contour_1.gbr", "golden/example_single_contour.png",
-        0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
-    )
-
-
-def test_render_single_contour_2():
-    """Umaco exapmle of a single contour, alternate contour end order
-
-    The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render(
-        "resources/example_single_contour_2.gbr", "golden/example_single_contour.png",
-        0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
-    )
-
-
-def test_render_single_contour_3():
-    """Umaco exapmle of a single contour with extra line"""
-    _test_render(
-        "resources/example_single_contour_3.gbr", "golden/example_single_contour_3.png",
-        0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
-    )
-
-
-def test_render_not_overlapping_contour():
-    """Umaco example of D02 staring a second contour"""
-    _test_render(
-        "resources/example_not_overlapping_contour.gbr",
-        "golden/example_not_overlapping_contour.png",
-    )
-
-
-def test_render_not_overlapping_touching():
-    """Umaco example of D02 staring a second contour"""
-    _test_render(
-        "resources/example_not_overlapping_touching.gbr",
-        "golden/example_not_overlapping_touching.png",
-    )
-
-
-def test_render_overlapping_touching():
-    """Umaco example of D02 staring a second contour"""
-    _test_render(
-        "resources/example_overlapping_touching.gbr",
-        "golden/example_overlapping_touching.png",
-    )
-
-
-def test_render_overlapping_contour():
-    """Umaco example of D02 staring a second contour"""
-    _test_render("resources/example_overlapping_contour.gbr", "golden/example_overlapping_contour.png")
-
-
-def test_render_level_holes():
-    """Umaco example of using multiple levels to create multiple holes"""
-    _test_render("resources/example_level_holes.gbr", "golden/example_level_holes.png",
-            autocrop_golden=True, auto_contrast=True, scale=50, max_delta=0.005)
-
-
-def test_render_cutin():
-    """Umaco example of using a cutin"""
-    _test_render("resources/example_cutin.gbr", "golden/example_cutin.png",
-            autocrop_golden=True, auto_contrast=True, max_delta=0.005)
-
-
-def test_render_fully_coincident():
-    """Umaco example of coincident lines rendering two contours"""
-
-    _test_render(
-        "resources/example_fully_coincident.gbr", "golden/example_fully_coincident.png"
-    )
-
-
-def test_render_coincident_hole():
-    """Umaco example of coincident lines rendering a hole in the contour"""
-
-    _test_render(
-        "resources/example_coincident_hole.gbr", "golden/example_coincident_hole.png"
-    )
-
-
-def test_render_cutin_multiple():
-    """Umaco example of a region with multiple cutins"""
-
-    _test_render(
-        "resources/example_cutin_multiple.gbr", "golden/example_cutin_multiple.png"
-    )
-
-
-def test_flash_circle():
-    """Umaco example a simple circular flash with and without a hole"""
-
-    _test_render(
-        "resources/example_flash_circle.gbr",
-        "golden/example_flash_circle.png",
-    )
-
-
-def test_flash_rectangle():
-    """Umaco example a simple rectangular flash with and without a hole"""
-
-    _test_render(
-        "resources/example_flash_rectangle.gbr", "golden/example_flash_rectangle.png"
-    )
-
-
-def test_flash_obround():
-    """Umaco example a simple obround flash with and without a hole"""
-
-    _test_render(
-        "resources/example_flash_obround.gbr", "golden/example_flash_obround.png"
-    )
-
-
-def test_flash_polygon():
-    """Umaco example a simple polygon flash with and without a hole"""
-
-    _test_render(
-        "resources/example_flash_polygon.gbr", "golden/example_flash_polygon.png"
-    )
-
-
-def test_holes_dont_clear():
-    """Umaco example that an aperture with a hole does not clear the area"""
-
-    _test_render(
-        "resources/example_holes_dont_clear.gbr", "golden/example_holes_dont_clear.png"
-    )
-
-
-def test_render_am_exposure_modifier():
-    """Umaco example that an aperture macro with a hole does not clear the area"""
-
-    _test_render(
-        "resources/example_am_exposure_modifier.gbr",
-        "golden/example_am_exposure_modifier.png",
-        scale = 50,
-        autocrop_golden = True,
-        auto_contrast = True,
-        max_delta = 0.005 # Take artifacts due to differences in anti-aliasing and thresholding into account
-    )
-
-
-def test_render_svg_simple_contour():
-    """Example of rendering to an SVG file"""
-    _test_simple_render_svg("resources/example_simple_contour.gbr")
-
-
-def test_fine_lines_x():
-    """ Regression test for pcb-tools upstream PR #199 """
-    for fn, axis in [
-        ('resources/test_fine_lines_x.gbr', 1),
-        ('resources/test_fine_lines_y.gbr', 0) ]:
-        gerber_path = _resolve_path(fn)
-
-        gerber = read(gerber_path)
-
-        # Create PNG image to the memory stream
-        ctx = GerberCairoContext(scale=51)
-        gerber.render(ctx)
-
-        global output_dir
-        with output_dir.create(suffix='.png') as outfile:
-            actual_bytes = ctx.dump(outfile)
-
-            out = Image.open(outfile)
-            out = np.array(out)
-            out = out.astype(float).mean(axis=2) / 255
-
-            means = out[10:-10,10:-10].mean(axis=axis)
-
-            print(means.mean(), means.max(), means.min(), means.std())
-            #print(means_y.mean(), means_y.max(), means_y.min(), means_y.std())
-            # means_x broken: 0.3240598567858516 0.3443678513071895 0.2778033088235294 0.017457710324088545
-            # means_x fixed:  0.33338519639882097 0.3443678513071895 0.3183159722222221 0.006792500045785638
-            # means_y broken: 0.3240598567858518 0.3247468922209409 0.1660387030629246 0.009953477851147686
-            # means_y fixed:  0.33338519639882114 0.3340766371908242 0.17388184031782652 0.010043400730860096
-
-            assert means.std() < 0.01
-
-# TODO add scale tests: Export with different scale=... params and compare against bitmap-scaled reference image
-
-def _resolve_path(path):
-    return os.path.join(os.path.dirname(__file__), path)
-
-def images_match(reference, output, max_delta, autocrop_golden=False, auto_contrast=False):
-    global output_dir
-
-    ref, out = Image.open(reference), Image.open(output)
-    if ref.mode == 'P': # palette mode
-        ref = ref.convert('RGB')
-
-    ref, out = np.array(ref), np.array(out)
-    # convert to grayscale
-    ref, out = ref.astype(float).mean(axis=2), out.astype(float).mean(axis=2)
-    
-    if autocrop_golden:
-        rows = ref.sum(axis=1)
-        cols = ref.sum(axis=0)
-        
-        x0 = np.argmax(cols > 0)
-        y0 = np.argmax(rows > 0)
-        x1 = len(cols) - np.argmax(cols[::-1] > 0)
-        y1 = len(rows) - np.argmax(rows[::-1] > 0)
-        print(f'{x0=} {y0=} {x1=} {y1=}')
-
-        ref = ref[y0:y1, x0:x1]
-        ref = cv2.resize(ref, dsize=out.shape[::-1], interpolation=cv2.INTER_LINEAR)
-
-    def print_stats(name, ref):
-        print(name, 'stats:', ref.min(), ref.mean(), ref.max(), 'std:', ref.std())
-
-    if auto_contrast:
-        print_stats('ref pre proc', ref)
-        print_stats('out pre proc', out)
-
-        ref -= ref.min()
-        ref /= ref.max() + 1e-9
-        ref *= 255
-
-        out -= out.min()
-        out /= out.max() + 1e-9
-        out *= 255
-
-    def write_refout():
-        nonlocal autocrop_golden, ref
-        if autocrop_golden:
-            global output_dir
-            with output_dir.create(suffix='.png') as ref_out:
-                cv2.imwrite(str(ref_out), ref)
-                print('Processed reference image:', ref_out)
-
-    if ref.shape != out.shape:
-        print(f'Rendering image size mismatch: {ref.shape} != {out.shape}')
-        print(f'Reference image: {Path(reference).absolute()}')
-        print(f'Actual output: {output}')
-
-        write_refout()
-        output_dir.keep()
-
-        return False
-
-    delta = np.abs(out - ref).astype(float) / 255
-    
-    if delta.mean() > max_delta:
-        print(f'Renderings mismatch: {delta.mean()=}, {max_delta=}')
-        print(f'Reference image: {Path(reference).absolute()}')
-        print(f'Actual output: {output}')
-        with output_dir.create(suffix='.png') as proc_out:
-            cv2.imwrite(str(proc_out), out)
-            print('Processed output image:', proc_out)
-        print_stats('reference', ref)
-        print_stats('actual', out)
-
-        write_refout()
-        output_dir.keep()
-
-        return False
-
-    return True
-
-
-def _test_render(gerber_path, png_expected_path, max_delta=1e-6, scale=300, autocrop_golden=False, auto_contrast=False):
-    """Render the gerber file and compare to the expected PNG output.
-
-    Parameters
-    ----------
-    gerber_path : string
-        Path to Gerber file to open
-    png_expected_path : string
-        Path to the PNG file to compare to
-    create_output : string|None
-        If not None, write the generated PNG to the specified path.
-        This is primarily to help with
-    """
-
-    gerber_path = _resolve_path(gerber_path)
-    png_expected_path = _resolve_path(png_expected_path)
-
-    gerber = read(gerber_path)
-
-    # Create PNG image to the memory stream
-    ctx = GerberCairoContext(scale=scale)
-    gerber.render(ctx)
-
-    global output_dir
-    with output_dir.create(suffix='.png') as outfile:
-        actual_bytes = ctx.dump(outfile)
-
-        assert images_match(png_expected_path, outfile, max_delta, autocrop_golden, auto_contrast)
-
-    return gerber
-
-
-def _test_simple_render_svg(gerber_path):
-    """Render the gerber file as SVG
-
-    Note: verifies only the header, not the full content.
-
-    Parameters
-    ----------
-    gerber_path : string
-        Path to Gerber file to open
-    """
-
-    gerber_path = _resolve_path(gerber_path)
-    gerber = read(gerber_path)
-
-    # Create SVG image to the memory stream
-    ctx = GerberCairoContext()
-    gerber.render(ctx)
-
-    temp_dir = tempfile.mkdtemp()
-    svg_temp_path = os.path.join(temp_dir, "output.svg")
-
-    assert not os.path.exists(svg_temp_path)
-    ctx.dump(svg_temp_path)
-    assert os.path.exists(svg_temp_path)
-
-    with open(svg_temp_path, "r") as expected_file:
-        expected_bytes = expected_file.read()
-    assert expected_bytes[:38] == '<?xml version="1.0" encoding="UTF-8"?>'
-
-    shutil.rmtree(temp_dir)
-
diff --git a/gerbonara/gerber/tests/test_gerber_statements.py b/gerbonara/gerber/tests/test_gerber_statements.py
index 140cbd1..17e2591 100644
--- a/gerbonara/gerber/tests/test_gerber_statements.py
+++ b/gerbonara/gerber/tests/test_gerber_statements.py
@@ -413,84 +413,29 @@ def test_AMParamStmt_factory():
 1,1,1.5,0,0*
 20,1,0.9,0,0.45,12,0.45,0*
 21,1,6.8,1.2,3.4,0.6,0*
-22,1,6.8,1.2,0,0,0*
 4,1,4,0.1,0.1,0.5,0.1,0.5,0.5,0.1,0.5,0.1,0.1,0*
 5,1,8,0,0,8,0*
-6,0,0,5,0.5,0.5,2,0.1,6,0*
 7,0,0,7,6,0.2,0*
-8,THIS IS AN UNSUPPORTED PRIMITIVE*
 """
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-    s.build()
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
     assert len(s.primitives) == 10
     assert isinstance(s.primitives[0], AMCommentPrimitive)
     assert isinstance(s.primitives[1], AMCirclePrimitive)
     assert isinstance(s.primitives[2], AMVectorLinePrimitive)
     assert isinstance(s.primitives[3], AMCenterLinePrimitive)
-    assert isinstance(s.primitives[4], AMLowerLeftLinePrimitive)
     assert isinstance(s.primitives[5], AMOutlinePrimitive)
     assert isinstance(s.primitives[6], AMPolygonPrimitive)
-    assert isinstance(s.primitives[7], AMMoirePrimitive)
     assert isinstance(s.primitives[8], AMThermalPrimitive)
-    assert isinstance(s.primitives[9], AMUnsupportPrimitive)
-
-
-def testAMParamStmt_conversion():
-    name = "POLYGON"
-    macro = "5,1,8,25.4,25.4,25.4,0*"
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-
-    s.build()
-    s.units = "metric"
-
-    # No effect
-    s.to_metric()
-    assert s.primitives[0].position == (25.4, 25.4)
-    assert s.primitives[0].diameter == 25.4
-
-    s.to_inch()
-    assert s.units == "inch"
-    assert s.primitives[0].position == (1.0, 1.0)
-    assert s.primitives[0].diameter == 1.0
-
-    # No effect
-    s.to_inch()
-    assert s.primitives[0].position == (1.0, 1.0)
-    assert s.primitives[0].diameter == 1.0
-
-    macro = "5,1,8,1,1,1,0*"
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-    s.build()
-    s.units = "inch"
-
-    # No effect
-    s.to_inch()
-    assert s.primitives[0].position == (1.0, 1.0)
-    assert s.primitives[0].diameter == 1.0
-
-    s.to_metric()
-    assert s.units == "metric"
-    assert s.primitives[0].position == (25.4, 25.4)
-    assert s.primitives[0].diameter == 25.4
-
-    # No effect
-    s.to_metric()
-    assert s.primitives[0].position == (25.4, 25.4)
-    assert s.primitives[0].diameter == 25.4
 
 
 def test_AMParamStmt_dump():
     name = "POLYGON"
     macro = "5,1,8,25.4,25.4,25.4,0.0"
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-    s.build()
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
     assert s.to_gerber() == "%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%"
 
     # TODO - Store Equations and update on unit change...
-    s = AMParamStmt.from_dict(
-        {"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}
-    )
-    s.build()
+    s = AMParamStmt.from_dict({"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}, units='mm')
     # assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%')
     assert s.to_gerber() == "%AMOC8*5,1,8,0,0,0,22.5*%"
 
@@ -498,8 +443,7 @@ def test_AMParamStmt_dump():
 def test_AMParamStmt_string():
     name = "POLYGON"
     macro = "5,1,8,25.4,25.4,25.4,0*"
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-    s.build()
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
     assert str(s) == "<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>"
 
 
diff --git a/gerbonara/gerber/utils.py b/gerbonara/gerber/utils.py
index 3d39df9..c2e81cd 100644
--- a/gerbonara/gerber/utils.py
+++ b/gerbonara/gerber/utils.py
@@ -29,7 +29,7 @@ from math import radians, sin, cos, sqrt, atan2, pi
 MILLIMETERS_PER_INCH = 25.4
 
 
-def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
+def parse_gerber_value(value, settings):
     """ Convert gerber/excellon formatted string to floating-point number
 
     .. note::
@@ -60,12 +60,16 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
         The specified value as a floating-point number.
 
     """
+
+    if value is None:
+        return None
+
     # Handle excellon edge case with explicit decimal. "That was easy!"
     if '.' in value:
         return float(value)
 
     # Format precision
-    integer_digits, decimal_digits = format
+    integer_digits, decimal_digits = settings.format
     MAX_DIGITS = integer_digits + decimal_digits
 
     # Absolute maximum number of digits supported. This will handle up to
@@ -82,9 +86,9 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
 
     missing_digits = MAX_DIGITS - len(value)
 
-    if zero_suppression == 'trailing':
+    if settings.zero_suppression == 'trailing':
         digits = list(value + ('0' * missing_digits))
-    elif zero_suppression == 'leading':
+    elif settings.zero_suppression == 'leading':
         digits = list(('0' * missing_digits) + value)
     else:
         digits = list(value)
@@ -94,7 +98,7 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
     return -result if negative else result
 
 
-def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
+def write_gerber_value(value, settings):
     """ Convert a floating point number to a Gerber/Excellon-formatted string.
 
     .. note::
@@ -128,7 +132,7 @@ def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
         return "%f" %value
     
     # Format precision
-    integer_digits, decimal_digits = format
+    integer_digits, decimal_digits = settings.format
     MAX_DIGITS = integer_digits + decimal_digits
 
     if MAX_DIGITS > 13 or integer_digits > 6 or decimal_digits > 7:
@@ -154,10 +158,10 @@ def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
         return '0'
 
     # Suppression...
-    if zero_suppression == 'trailing':
+    if settings.zero_suppression == 'trailing':
         while digits and digits[-1] == '0':
             digits.pop()
-    elif zero_suppression == 'leading':
+    elif settings.zero_suppression == 'leading':
         while digits and digits[0] == '0':
             digits.pop(0)