diff --git a/src/Mod/Path/PathScripts/post/marlin_post.py b/src/Mod/Path/PathScripts/post/marlin_post.py
index af975e812f..5e4c6ea02d 100644
--- a/src/Mod/Path/PathScripts/post/marlin_post.py
+++ b/src/Mod/Path/PathScripts/post/marlin_post.py
@@ -1,49 +1,50 @@
 # -*- coding: utf-8 -*-
-# ***************************************************************************
-# *                                                                         *
-# *   (c) sliptonic (shopinthewoods@gmail.com) 2014                         *
-# *   (c) Gauthier Briere - 2018, 2019                                      *
-# *   (c) Schildkroet - 2019-2020                                           *
-# *   (c) Gary L Hasson - 2020                                              *
-# *                                                                         *
-# *   This file is part of the FreeCAD CAx development system.              *
-# *                                                                         *
-# *   This program is free software; you can redistribute it and/or modify  *
-# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
-# *   as published by the Free Software Foundation; either version 2 of     *
-# *   the License, or (at your option) any later version.                   *
-# *   for detail see the LICENCE text file.                                 *
-# *                                                                         *
-# *   FreeCAD is distributed in the hope that it will be useful,            *
-# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
-# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
-# *   GNU Lesser General Public License for more details.                   *
-# *                                                                         *
-# *   You should have received a copy of the GNU Library General Public     *
-# *   License along with FreeCAD; if not, write to the Free Software        *
-# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
-# *   USA                                                                   *
-# *                                                                         *
-# ***************************************************************************/
+# *****************************************************************************
+# *                                                                           *
+# *   (c) sliptonic (shopinthewoods@gmail.com) 2014                           *
+# *   (c) Gauthier Briere - 2018, 2019                                        *
+# *   (c) Schildkroet - 2019-2020                                             *
+# *   (c) Gary L Hasson - 2020                                                *
+# *                                                                           *
+# *   This file is part of the FreeCAD CAx development system.                *
+# *                                                                           *
+# *   This program is free software; you can redistribute it and/or modify    *
+# *   it under the terms of the GNU Lesser General Public License (LGPL)      *
+# *   as published by the Free Software Foundation; either version 2 of       *
+# *   the License, or (at your option) any later version.                     *
+# *   for detail see the LICENCE text file.                                   *
+# *                                                                           *
+# *   FreeCAD is distributed in the hope that it will be useful,              *
+# *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
+# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
+# *   GNU Lesser General Public License for more details.                     *
+# *                                                                           *
+# *   You should have received a copy of the GNU Library General Public       *
+# *   License along with FreeCAD; if not, write to the Free Software          *
+# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307    *
+# *   USA                                                                     *
+# *                                                                           *
+# *****************************************************************************
 
 
-Revised = "2020-10-22" # Revision date for this file.
-
-'''
-Due to the fundamentals of the FreeCAD pre-processor,
-this post processor can only operate in the following modes:
-G90 Absolute positions
-G21 Metric units (mm)
-G17 XY plane (3 axis vertical milling only)
-'''
-
+from datetime import datetime
+import argparse
+import shlex
 import FreeCAD
 from FreeCAD import Units
-import PathScripts.PostUtils as PostUtils
-import argparse
-import datetime
-import shlex
 import PathScripts.PathUtil as PathUtil
+import PathScripts.PostUtils as PostUtils
+
+Revised = '2020-11-03'  # Revision date for this file.
+
+# *****************************************************************************
+# *   Due to the fundamentals of the FreeCAD pre-processor,                   *
+# *   this post processor can only operate in the following modes:            *
+# *   G90 Absolute positions                                                  *
+# *   G21 Metric units (mm)                                                   *
+# *   G17 XY plane (3 axis vertical milling only)                             *
+# *                                                                           *
+# *****************************************************************************
 
 
 TOOLTIP = '''
@@ -52,570 +53,718 @@ import marlin_post
 marlin_post.export(object, "/path/to/file.nc")
 '''
 
-# ***************************************************************************
-# * Initial configuration, not changeable
-# ***************************************************************************
-MOTION_MODE = 'G90'               # G90 only, for absolute moves
-WORK_PLANE = 'G17'                # G17 only, XY plane, for vertical milling
-UNITS = 'G21'                     # G21 only, for metric
+# *****************************************************************************
+# * Initial configuration, not changeable                                     *
+# *****************************************************************************
+MOTION_MODE = 'G90'             # G90 only, for absolute moves
+WORK_PLANE = 'G17'              # G17 only, XY plane, for vertical milling
+UNITS = 'G21'                   # G21 only, for metric
 UNIT_FORMAT = 'mm'
 UNIT_FEED_FORMAT = 'mm/s'
 
-# ***************************************************************************
-# * Initial configuration, changeable via command line arguments
-# ***************************************************************************
-PRECISION = 3                     # Decimal places displayed for metric
-DRILL_RETRACT_MODE = 'G98'        # End of drill-cycle retractation type. G99 is the alternative.
-TRANSLATE_DRILL_CYCLES = True     # If true, G81, G82, and G83 are translated into G0/G1 moves
-OUTPUT_TOOL_CHANGE = False        # Do not output M6 tool change (comment it)
-RETURN_TO = None                  # None = No movement at end of program
-SPINDLE_WAIT = 3.0                # 0 == No waiting after M3 / M4
-MODAL = False                     # True: Commands are suppressed if they are the same as the previous line
-LINENR = 100                      # Line number starting value
-LINEINCR = 10                     # Line number increment
-PRE_OPERATION = ''''''            # Pre operation text will be inserted before every operation
-POST_OPERATION = ''''''           # Post operation text will be inserted after every operation
-TOOL_CHANGE = ''''''              # Tool Change commands will be inserted before a tool change
+# *****************************************************************************
+# * Initial configuration, changeable via command line arguments              *
+# *****************************************************************************
+PRECISION = 3                   # Decimal places displayed for metric
+DRILL_RETRACT_MODE = 'G98'      # End of drill-cycle retractation type. G99
+# is the alternative.
+TRANSLATE_DRILL_CYCLES = True   # If true, G81, G82, and G83 are translated
+# into G0/G1 moves
+OUTPUT_TOOL_CHANGE = False      # Do not output M6 tool change (comment it)
+RETURN_TO = None                # None = No movement at end of program
+SPINDLE_WAIT = 3                # 0 == No waiting after M3 / M4
+MODAL = False                   # True: Commands are suppressed if they are
+# the same as the previous line
+LINENR = 100                    # Line number starting value
+LINEINCR = 10                   # Line number increment
+PRE_OPERATION = ''''''          # Pre operation text will be inserted before
+# every operation
+POST_OPERATION = ''''''         # Post operation text will be inserted after
+# every operation
+TOOL_CHANGE = ''''''            # Tool Change commands will be inserted
+# before a tool change
 
-# ***************************************************************************
-# * Initial gcode output options, changeable via command line arguments
-# ***************************************************************************
-OUTPUT_COMMENTS = True            # Comments in output gcode file
-OUTPUT_FINISH = False             # Include an operation finished comment
-OUTPUT_PATH = False               # Include a Path: comment
-OUTPUT_HEADER = True              # Output header in output gcode file
-OUTPUT_LINE_NUMBERS = False       # Output line numbers in output gcode file
-OUTPUT_BCNC = False               # Add bCNC operation block headers in output gcode file
-SHOW_EDITOR = True                # Display the resulting gcode file
+# *****************************************************************************
+# * Initial gcode output options, changeable via command line arguments       *
+# *****************************************************************************
+OUTPUT_HEADER = True            # Output header in output gcode file
+OUTPUT_COMMENTS = True          # Comments in output gcode file
+OUTPUT_FINISH = False           # Include an operation finished comment
+OUTPUT_PATH = False             # Include a Path: comment
+OUTPUT_MARLIN_CONFIG = False    # Display expected #defines for Marlin config
+OUTPUT_LINE_NUMBERS = False     # Output line numbers in output gcode file
+OUTPUT_BCNC = False             # Add bCNC operation block headers in output
+# gcode file
+SHOW_EDITOR = True              # Display the resulting gcode file
 
-# ***************************************************************************
-# * Command line arguments
-# ***************************************************************************
+# *****************************************************************************
+# * Command line arguments                                                    *
+# *****************************************************************************
 parser = argparse.ArgumentParser(prog='marlin', add_help=False)
-parser.add_argument('--comments',           action='store_true', help='output comment (default)')
-parser.add_argument('--no-comments',        action='store_true', help='suppress comment output')
-parser.add_argument('--finish-comments',    action='store_true', help='output finish-comment')
-parser.add_argument('--no-finish-comments', action='store_true', help='suppress finish-comment output (default)')
-parser.add_argument('--path-comments',      action='store_true', help='output path-comment')
-parser.add_argument('--no-path-comments',   action='store_true', help='suppress path-comment output (default)')
-parser.add_argument('--header',             action='store_true', help='output headers (default)')
-parser.add_argument('--no-header',          action='store_true', help='suppress header output')
-parser.add_argument('--line-numbers',       action='store_true', help='prefix with line numbers')
-parser.add_argument('--no-line-numbers',    action='store_true', help='do not prefix with line numbers (default)')
-parser.add_argument('--show-editor',        action='store_true', help='pop up editor before writing output (default)')
-parser.add_argument('--no-show-editor',     action='store_true', help='do not pop up editor before writing output')
-parser.add_argument('--precision',          default='3',         help='number of digits of precision, default=3')
-parser.add_argument('--translate_drill',    action='store_true', help='translate drill cycles G81, G82, and G83 into G0/G1 movements (default)')
-parser.add_argument('--no-translate_drill', action='store_true', help='do not translate drill cycles G81, G82, and G83 into G0/G1 movements')
-parser.add_argument('--preamble',                                help='set commands to be issued before the first command, default="G80\nG17\nG90\nG21"')
-parser.add_argument('--postamble',                               help='set commands to be issued after the last command, default="G80\nM5\nG17\nG90\nG21"')
-parser.add_argument('--tool-change',        action='store_true', help='Insert M6 for all tool changes')
-parser.add_argument('--wait-for-spindle',   type=int, default=0, help='Wait for spindle to reach desired speed after M3 or M4, default=0')
-parser.add_argument('--return-to',          default='',          help='Move to the specified coordinates at the end, e.g. --return-to="3.175, 4.702, 50.915"')
-parser.add_argument('--bcnc',               action='store_true', help='Add Job operations as bCNC block headers. Consider suppressing existing comments: Add argument --no-comments')
-parser.add_argument('--no-bcnc',            action='store_true', help='suppress bCNC block header output (default)')
+parser.add_argument(
+    '--header',
+    action='store_true',
+    help='output headers (default)')
+parser.add_argument(
+    '--no-header',
+    action='store_true',
+    help='suppress header output')
+parser.add_argument(
+    '--comments',
+    action='store_true',
+    help='output comment (default)')
+parser.add_argument(
+    '--no-comments',
+    action='store_true',
+    help='suppress comment output')
+parser.add_argument(
+    '--finish-comments',
+    action='store_true',
+    help='output finish-comment')
+parser.add_argument(
+    '--no-finish-comments',
+    action='store_true',
+    help='suppress finish-comment output (default)')
+parser.add_argument(
+    '--path-comments',
+    action='store_true',
+    help='output path-comment')
+parser.add_argument(
+    '--no-path-comments',
+    action='store_true',
+    help='suppress path-comment output (default)')
+parser.add_argument(
+    '--marlin-config',
+    action='store_true',
+    help='output #defines for Marlin')
+parser.add_argument(
+    '--no-marlin-config',
+    action='store_true',
+    help='suppress output #defines for Marlin (default)')
+parser.add_argument(
+    '--line-numbers',
+    action='store_true',
+    help='prefix with line numbers')
+parser.add_argument(
+    '--no-line-numbers',
+    action='store_true',
+    help='do not prefix with line numbers (default)')
+parser.add_argument(
+    '--show-editor',
+    action='store_true',
+    help='pop up editor before writing output (default)')
+parser.add_argument(
+    '--no-show-editor',
+    action='store_true',
+    help='do not pop up editor before writing output')
+parser.add_argument(
+    '--precision',
+    default='3',
+    help='number of digits of precision, default=3')
+parser.add_argument(
+    '--translate_drill',
+    action='store_true',
+    help='translate drill cycles G81, G82, G83 into G0/G1 movements (default)')
+parser.add_argument(
+    '--no-translate_drill',
+    action='store_true',
+    help='do not translate drill cycles G81, G82, G83 into G0/G1 movements')
+parser.add_argument(
+    '--preamble',
+    help='set commands to be issued before the first command, default=""')
+parser.add_argument(
+    '--postamble',
+    help='set commands to be issued after the last command, default="M5"')
+parser.add_argument(
+    '--tool-change', action='store_true',
+    help='Insert M6 for all tool changes')
+parser.add_argument(
+    '--wait-for-spindle',
+    type=int,
+    default=3,
+    help='Wait for spindle to reach desired speed after M3 or M4, default=0')
+parser.add_argument(
+    '--return-to',
+    default='',
+    help='When done, move to, e.g. --return-to="3.175, 4.702, 50.915"')
+parser.add_argument(
+    '--bcnc',
+    action='store_true',
+    help='Add Job operations as bCNC block headers. \
+    Consider suppressing existing comments: Add argument --no-comments')
+parser.add_argument(
+    '--no-bcnc',
+    action='store_true',
+    help='suppress bCNC block header output (default)')
 TOOLTIP_ARGS = parser.format_help()
 
-'''
-Marlin 2.x:
-Ignores commands that it does not implement.
-Some machining-related commands may conflict with gcodes that Marlin has used for 3D printing.
-Therefore, check FreeCAD gcodes for conflicts with Marlin.
-Marlin 2.x ignores the ENTIRE COMMAND LINE if there is more than one command per line.
-'''
+# *****************************************************************************
+# * Marlin 2.x:                                                               *
+# * Ignores commands that it does not implement.                              *
+# * Some machining-related commands may conflict with gcodes that Marlin      *
+# * has assigned to 3D printing commands.                                     *
+# * Therefore, check FreeCAD gcodes for conflicts with Marlin.                *
+# * Marlin 2.x ignores the ENTIRE COMMAND LINE if there is more than          *
+# * one command per line.                                                     *
+# *****************************************************************************
+
 # Default preamble text will appear at the beginning of the gcode output file.
-PREAMBLE = '''
-'''
+PREAMBLE = ''''''
 
 # Default postamble text will appear following the last operation.
 POSTAMBLE = '''M5
 '''
 
-# ***************************************************************************
-# * Internal global variables
-# ***************************************************************************
+# *****************************************************************************
+# * Internal global variables                                                 *
+# *****************************************************************************
 MOTION_COMMANDS = ['G0', 'G00', 'G1', 'G01', 'G2', 'G02', 'G3', 'G03']
-RAPID_MOVES = ['G0', 'G00'] # Rapid moves gcode commands definition
-SUPPRESS_COMMANDS = [''] # These commands are ignored by commenting them out
-COMMAND_SPACE = " "
+RAPID_MOVES = ['G0', 'G00']  # Rapid moves gcode commands definition
+SUPPRESS_COMMANDS = ['']  # These commands are ignored by commenting them out
+COMMAND_SPACE = ' '
 # Global variables storing current position (Use None for safety.)
 CURRENT_X = None
 CURRENT_Y = None
 CURRENT_Z = None
 
 
-# ***************************************************************************
-# * To distinguish python built-in open function from the one declared below
-# ***************************************************************************
-if open.__module__ in ['__builtin__', 'io']:
-  pythonopen = open
-
-
 def processArguments(argstring):
+    global OUTPUT_HEADER
+    global OUTPUT_COMMENTS
+    global OUTPUT_FINISH
+    global OUTPUT_PATH
+    global OUTPUT_MARLIN_CONFIG
+    global OUTPUT_LINE_NUMBERS
+    global SHOW_EDITOR
+    global PREAMBLE
+    global POSTAMBLE
+    global UNITS
+    global UNIT_FEED_FORMAT
+    global UNIT_FORMAT
+    global TRANSLATE_DRILL_CYCLES
+    global OUTPUT_TOOL_CHANGE
+    global SPINDLE_WAIT
+    global RETURN_TO
+    global OUTPUT_BCNC
+    global PRECISION
 
-  global OUTPUT_HEADER
-  global OUTPUT_COMMENTS
-  global OUTPUT_FINISH
-  global OUTPUT_PATH
-  global OUTPUT_LINE_NUMBERS
-  global SHOW_EDITOR
-  global PRECISION
-  global PREAMBLE
-  global POSTAMBLE
-  global UNITS
-  global UNIT_FEED_FORMAT
-  global UNIT_FORMAT
-  global TRANSLATE_DRILL_CYCLES
-  global OUTPUT_TOOL_CHANGE
-  global SPINDLE_WAIT
-  global RETURN_TO
-  global OUTPUT_BCNC
+    try:
+        args = parser.parse_args(shlex.split(argstring))
+        if args.no_header:
+            OUTPUT_HEADER = False
+        if args.header:
+            OUTPUT_HEADER = True
+        if args.no_comments:
+            OUTPUT_COMMENTS = False
+        if args.comments:
+            OUTPUT_COMMENTS = True
+        if args.no_finish_comments:
+            OUTPUT_FINISH = False
+        if args.finish_comments:
+            OUTPUT_FINISH = True
+        if args.no_path_comments:
+            OUTPUT_PATH = False
+        if args.path_comments:
+            OUTPUT_PATH = True
+        if args.no_marlin_config:
+            OUTPUT_MARLIN_CONFIG = False
+        if args.marlin_config:
+            OUTPUT_MARLIN_CONFIG = True
+        if args.no_line_numbers:
+            OUTPUT_LINE_NUMBERS = False
+        if args.line_numbers:
+            OUTPUT_LINE_NUMBERS = True
+        if args.no_show_editor:
+            SHOW_EDITOR = False
+        if args.show_editor:
+            SHOW_EDITOR = True
+        if args.preamble is not None:
+            PREAMBLE = args.preamble
+        if args.postamble is not None:
+            POSTAMBLE = args.postamble
+        if args.no_translate_drill:
+            TRANSLATE_DRILL_CYCLES = False
+        if args.translate_drill:
+            TRANSLATE_DRILL_CYCLES = True
+        if args.tool_change:
+            OUTPUT_TOOL_CHANGE = True
+        if args.return_to:
+            RETURN_TO = args.return_to
+            if RETURN_TO.find(',') == -1:
+                RETURN_TO = None
+                print('--return-to coordinates must be specified as:')
+                print('--return-to "x.n,y.n,z.n"')
+        if args.bcnc:
+            OUTPUT_BCNC = True
+        if args.no_bcnc:
+            OUTPUT_BCNC = False
+        SPINDLE_WAIT = args.wait_for_spindle
+        PRECISION = args.precision
 
-  try:
-    args = parser.parse_args(shlex.split(argstring))
-    if args.no_header:
-      OUTPUT_HEADER = False
-    if args.header:
-      OUTPUT_HEADER = True
-    if args.no_comments:
-      OUTPUT_COMMENTS = False
-    if args.comments:
-      OUTPUT_COMMENTS = True
-    if args.no_finish_comments:
-      OUTPUT_FINISH = False
-    if args.finish_comments:
-      OUTPUT_FINISH = True
-    if args.no_path_comments:
-      OUTPUT_PATH = False
-    if args.path_comments:
-      OUTPUT_PATH = True
-    if args.no_line_numbers:
-      OUTPUT_LINE_NUMBERS = False
-    if args.line_numbers:
-      OUTPUT_LINE_NUMBERS = True
-    if args.no_show_editor:
-      SHOW_EDITOR = False
-    if args.show_editor:
-      SHOW_EDITOR = True
-    PRECISION = args.precision
-    if args.preamble is not None:
-      PREAMBLE = args.preamble
-    if args.postamble is not None:
-      POSTAMBLE = args.postamble
-    if args.no_translate_drill:
-      TRANSLATE_DRILL_CYCLES = False
-    if args.translate_drill:
-      TRANSLATE_DRILL_CYCLES = True
-    if args.tool_change:
-      OUTPUT_TOOL_CHANGE = True
-    if args.wait_for_spindle > 0:
-      SPINDLE_WAIT = args.wait_for_spindle
-    if args.return_to:
-      RETURN_TO = args.return_to
-      if RETURN_TO.find(',') == -1:
-        RETURN_TO = None
-        print('--return-to coordinates must be specified as:\n--return-to "x.n,y.n,z.n"')
-    if args.bcnc:
-      OUTPUT_BCNC = True
-    if args.no_bcnc:
-      OUTPUT_BCNC = False
+    except Exception as e:
+        return False
 
-
-  except Exception as e:
-    return False
-
-  return True
+    return True
 
 
 # For debug...
 def dump(obj):
-  for attr in dir(obj):
-    try:
-      if attr.startswith('__'):
-        continue
-      print(": >" + attr + "<")
-      attr_text = "%s = %s" % (attr, getattr(obj, attr))
-      if attr in ['HorizFeed', 'VertFeed']:
-        print('==============\n', attr_text)
-        if 'mm/s' in attr_text:
-          print('===> metric values <===')
-    except: # Insignificant errors
-      # print("==>", obj, attr)
-      pass
+    for attr in dir(obj):
+        try:
+            if attr.startswith('__'):
+                continue
+            print('>' + attr + '<')
+            attr_text = "%s = %s" % (attr, getattr(obj, attr))
+            if attr in ['HorizFeed', 'VertFeed']:
+                print('==============\n', attr_text)
+                if 'mm/s' in attr_text:
+                    print('===> metric values <===')
+        except:  # Insignificant errors
+            # print('==>', obj, attr)
+            pass
+
 
 def export(objectslist, filename, argstring):
+    if not processArguments(argstring):
+        return None
 
-  if not processArguments(argstring):
-    return None
+    global UNITS
+    global UNIT_FORMAT
+    global UNIT_FEED_FORMAT
+    global MOTION_MODE
+    global SUPPRESS_COMMANDS
 
-  global UNITS
-  global UNIT_FORMAT
-  global UNIT_FEED_FORMAT
-  global MOTION_MODE
-  global SUPPRESS_COMMANDS
+    print('Post Processor: ' + __name__ + ' postprocessing...')
+    gcode = ''
 
-  print("Post Processor: " + __name__ + " postprocessing...")
-  gcode = ""
+    # Write header:
+    if OUTPUT_HEADER:
+        gcode += linenumber() + '(Exported by FreeCAD)\n'
+        gcode += linenumber() + '(Post Processor: ' + __name__
+        gcode += '.py, version: ' + Revised + ')\n'
+        gcode += linenumber() + '(Output Time:' + str(datetime.now()) + ')\n'
 
-  # Write header:
-  if OUTPUT_HEADER:
-    gcode += linenumber() + "(Exported by FreeCAD)\n"
-    gcode += linenumber() + "(Post Processor: " + __name__ + ".py, version: " + Revised + ")\n"
-    gcode += linenumber() + "(Output Time:" + str(datetime.datetime.now()) + ")\n"
+    # Suppress drill-cycle commands:
+    if TRANSLATE_DRILL_CYCLES:
+        SUPPRESS_COMMANDS += ['G80', 'G98', 'G99']
 
-  # Suppress drill-cycle commands:
-  if TRANSLATE_DRILL_CYCLES:
-    SUPPRESS_COMMANDS += ['G80', 'G98', 'G99']
-
-  # Write the preamble:
-  if OUTPUT_COMMENTS:
-    gcode += linenumber() + "(Begin preamble)\n"
-  for line in PREAMBLE.splitlines(True):
-    gcode += linenumber() + line
-
-  # Write these settings after the preamble to prevent the preamble from changing these:
-  gcode += linenumber() + "(Default Configuration)\n"
-  gcode += linenumber() + MOTION_MODE + "\n"
-  gcode += linenumber() + UNITS + "\n"
-  gcode += linenumber() + WORK_PLANE + "\n"
-
-  for obj in objectslist:
-    # Debug...
-    # print("\n" + "*"*70 + "\n")
-    # dump(obj)
-    # print("\n" + "*"*70 + "\n")
-    if not hasattr(obj, "Path"):
-      print("The object " + obj.Name + " is not a path. Please select only path and Compounds.")
-      return
-
-    # Skip inactive operations:
-    if PathUtil.opProperty(obj, 'Active') is False:
-      continue
-
-    # Do the pre_op:
-    if OUTPUT_BCNC:
-      gcode += linenumber() + "(Block-name: " + obj.Label + ")\n"
-      gcode += linenumber() + "(Block-expand: 0)\n"
-      gcode += linenumber() + "(Block-enable: 1)\n"
+    # Write the preamble:
     if OUTPUT_COMMENTS:
-      gcode += linenumber() + "(Begin operation: " + obj.Label + ")\n"
-    for line in PRE_OPERATION.splitlines(True):
-      gcode += linenumber() + line
+        gcode += linenumber() + '(Begin preamble)\n'
+    for line in PREAMBLE.splitlines(True):
+        gcode += linenumber() + line
 
-    # Get coolant mode:
-    coolantMode = 'None'
-    if hasattr(obj, "CoolantMode") or hasattr(obj, 'Base') and  hasattr(obj.Base, "CoolantMode"):
-        if hasattr(obj, "CoolantMode"):
-            coolantMode = obj.CoolantMode
-        else:
-            coolantMode = obj.Base.CoolantMode
-
-    # Turn coolant on if required:
+    # Write these settings AFTER the preamble,
+    # to prevent the preamble from changing these:
     if OUTPUT_COMMENTS:
-        if not coolantMode == 'None':
-            gcode += linenumber() + '(Coolant On:' + coolantMode + ')\n'
-    if coolantMode == 'Flood':
-        gcode  += linenumber() + 'M8' + '\n'
-    if coolantMode == 'Mist':
-        gcode += linenumber() + 'M7' + '\n'
+        gcode += linenumber() + '(Default Configuration)\n'
+    gcode += linenumber() + MOTION_MODE + '\n'
+    gcode += linenumber() + UNITS + '\n'
+    gcode += linenumber() + WORK_PLANE + '\n'
 
-    # Parse the op:
-    gcode += parse(obj)
+    for obj in objectslist:
+        # Debug...
+        # print('\n' + '*'*70 + '\n')
+        # dump(obj)
+        # print('\n' + '*'*70 + '\n')
+        if not hasattr(obj, 'Path'):
+            print('The object ' + obj.Name +
+                  ' is not a path. Please select only path and Compounds.')
+            return
 
-    # Do the post_op:
-    if OUTPUT_COMMENTS and OUTPUT_FINISH:
-      gcode += linenumber() + "(Finish operation: " + obj.Label + ")\n"
-    for line in POST_OPERATION.splitlines(True):
-      gcode += linenumber() + line
+        # Skip inactive operations:
+        if PathUtil.opProperty(obj, 'Active') is False:
+            continue
 
-    # Turn coolant off if required:
-    if not coolantMode == 'None':
+        # Do the pre_op:
+        if OUTPUT_BCNC:
+            gcode += linenumber() + '(Block-name: ' + obj.Label + ')\n'
+            gcode += linenumber() + '(Block-expand: 0)\n'
+            gcode += linenumber() + '(Block-enable: 1)\n'
         if OUTPUT_COMMENTS:
-            gcode += linenumber() + '(Coolant Off:' + coolantMode + ')\n'
-        gcode += linenumber() +'M9\n'
+            gcode += linenumber() + '(Begin operation: ' + obj.Label + ')\n'
+        for line in PRE_OPERATION.splitlines(True):
+            gcode += linenumber() + line
 
-  # Do the post_amble:
-  if OUTPUT_BCNC:
-    gcode += linenumber() + "(Block-name: post_amble)\n"
-    gcode += linenumber() + "(Block-expand: 0)\n"
-    gcode += linenumber() + "(Block-enable: 1)\n"
-  if OUTPUT_COMMENTS:
-    gcode += linenumber() + "(Begin postamble)\n"
-  for line in POSTAMBLE.splitlines(True):
-    gcode += linenumber() + line
+        # Get coolant mode:
+        coolantMode = 'None'  # None is the word returned from the operation
+        if hasattr(obj, 'CoolantMode') or hasattr(obj, 'Base') and \
+           hasattr(obj.Base, 'CoolantMode'):
+            if hasattr(obj, 'CoolantMode'):
+                coolantMode = obj.CoolantMode
+            else:
+                coolantMode = obj.Base.CoolantMode
 
-  # Optionally add a final XYZ position to the end of the gcode:
-  if RETURN_TO:
-    first_comma = RETURN_TO.find(',')
-    last_comma = RETURN_TO.rfind(',') # == first_comma if only one comma
-    ref_X = ' X' + RETURN_TO[0: first_comma].strip()
+        # Turn coolant on if required:
+        if OUTPUT_COMMENTS:
+            if not coolantMode == 'None':
+                gcode += linenumber() + '(Coolant On:' + coolantMode + ')\n'
+        if coolantMode == 'Flood':
+            gcode += linenumber() + 'M8\n'
+        if coolantMode == 'Mist':
+            gcode += linenumber() + 'M7\n'
 
-    # Z is optional:
-    if last_comma != first_comma:
-      ref_Z = ' Z' + RETURN_TO[last_comma + 1:].strip()
-      ref_Y = ' Y' + RETURN_TO[first_comma + 1: last_comma].strip()
+        # Parse the op:
+        gcode += parse(obj)
+
+        # Do the post_op:
+        if OUTPUT_COMMENTS and OUTPUT_FINISH:
+            gcode += linenumber() + '(Finish operation: ' + obj.Label + ')\n'
+        for line in POST_OPERATION.splitlines(True):
+            gcode += linenumber() + line
+
+        # Turn coolant off if previously enabled:
+        if not coolantMode == 'None':
+            if OUTPUT_COMMENTS:
+                gcode += linenumber() + '(Coolant Off:' + coolantMode + ')\n'
+            gcode += linenumber() + 'M9\n'
+
+    # Do the post_amble:
+    if OUTPUT_BCNC:
+        gcode += linenumber() + '(Block-name: post_amble)\n'
+        gcode += linenumber() + '(Block-expand: 0)\n'
+        gcode += linenumber() + '(Block-enable: 1)\n'
+    if OUTPUT_COMMENTS:
+        gcode += linenumber() + '(Begin postamble)\n'
+    for line in POSTAMBLE.splitlines(True):
+        gcode += linenumber() + line
+
+    # Optionally add a final XYZ position to the end of the gcode:
+    if RETURN_TO:
+        first_comma = RETURN_TO.find(',')
+        last_comma = RETURN_TO.rfind(',')  # == first_comma if only one comma
+        ref_X = ' X' + RETURN_TO[0: first_comma].strip()
+
+        # Z is optional:
+        if last_comma != first_comma:
+            ref_Z = ' Z' + RETURN_TO[last_comma + 1:].strip()
+            ref_Y = ' Y' + RETURN_TO[first_comma + 1:last_comma].strip()
+        else:
+            ref_Z = ''
+            ref_Y = ' Y' + RETURN_TO[first_comma + 1:].strip()
+
+        gcode += linenumber() + 'G0' + ref_X + ref_Y + ref_Z + '\n'
+
+    # Optionally add recommended Marlin 2.x configuration to gcode file:
+    if OUTPUT_MARLIN_CONFIG:
+        gcode += linenumber() + '(Marlin 2.x Configuration)\n'
+        gcode += linenumber() + '(The following should be enabled in)\n'
+        gcode += linenumber() + '(the configuration files of Marlin 2.x)\n'
+        gcode += linenumber() + '(#define ARC_SUPPORT)\n'
+        gcode += linenumber() + '(#define CNC_COORDINATE_SYSTEMS)\n'
+        gcode += linenumber() + '(#define PAREN_COMMENTS)\n'
+        gcode += linenumber() + '(#define GCODE_MOTION_MODES)\n'
+        gcode += linenumber() + '(#define G0_FEEDRATE)\n'
+        gcode += linenumber() + '(define VARIABLE_G0_FEEDRATE)\n'
+
+    # Show the gcode result dialog:
+    if FreeCAD.GuiUp and SHOW_EDITOR:
+        dia = PostUtils.GCodeEditorDialog()
+        dia.editor.setText(gcode)
+        result = dia.exec_()
+        if result:
+            final = dia.editor.toPlainText()
+        else:
+            final = gcode
     else:
-      ref_Z = ''
-      ref_Y = ' Y' + RETURN_TO[first_comma + 1:].strip()
+        final = gcode
 
-    gcode += linenumber() + "G0" + ref_X + ref_Y + ref_Z + '\n'
+    print('Done postprocessing.')
 
-  # Show the gcode result dialog:
-  if FreeCAD.GuiUp and SHOW_EDITOR:
-    dia = PostUtils.GCodeEditorDialog()
-    dia.editor.setText(gcode)
-    result = dia.exec_()
-    if result:
-      final = dia.editor.toPlainText()
-    else:
-      final = gcode
-  else:
-    final = gcode
-
-  print("Done postprocessing.")
-
-  # Write the file:
-  try:
-    gfile = pythonopen(filename, "w")
-    gfile.write(final)
-  except Exception as e:
-    print('Error in writing the gcode file:\n', e.args)
-  finally:
-    gfile.close()
+    # Write the file:
+    with open(filename, 'w') as fp:
+        fp.write(final)
 
 
 def linenumber():
-  if not OUTPUT_LINE_NUMBERS:
-    return ""
-  global LINENR
-  global LINEINCR
-  s = "N" + str(LINENR) + " "
-  LINENR += LINEINCR
-  return s
+    if not OUTPUT_LINE_NUMBERS:
+        return ''
+    global LINENR
+    global LINEINCR
+    LINENR += LINEINCR
+    return 'N' + str(LINENR) + ' '
 
 
-def format_outstring(strTable):
-  global COMMAND_SPACE
-  # construct the line for the final output
-  s = ""
-  for w in strTable:
-    s += w + COMMAND_SPACE
-  s = s.strip()
-  return s
+def format_outlist(strTable):
+    # construct the line for the final output
+    global COMMAND_SPACE
+    s = ''
+    for w in strTable:
+        s += w + COMMAND_SPACE
+    return s.strip()
 
 
 def parse(pathobj):
+    global DRILL_RETRACT_MODE
+    global MOTION_MODE
+    global CURRENT_X
+    global CURRENT_Y
+    global CURRENT_Z
 
-  global DRILL_RETRACT_MODE
-  global MOTION_MODE
-  global CURRENT_X
-  global CURRENT_Y
-  global CURRENT_Z
+    out = ''
+    lastcommand = None
+    precision_string = '.' + str(PRECISION) + 'f'
 
-  out = ""
-  lastcommand = None
-  precision_string = '.' + str(PRECISION) + 'f'
+    params = ['X', 'Y', 'Z', 'A', 'B', 'C', 'U', 'V', 'W', 'I', 'J', 'K', 'F',
+              'S', 'T', 'Q', 'R', 'L', 'P']
 
-  params = ['X', 'Y', 'Z', 'A', 'B', 'C', 'U', 'V', 'W', 'I', 'J', 'K', 'F', 'S', 'T', 'Q', 'R', 'L', 'P']
+    if hasattr(pathobj, 'Group'):  # We have a compound or project.
+        if OUTPUT_COMMENTS:
+            out += linenumber() + '(Compound: ' + pathobj.Label + ')\n'
+        for p in pathobj.Group:
+            out += parse(p)
+        return out
+
+    else:  # Parsing simple path
+        # groups might contain non-path things like stock.
+        if not hasattr(pathobj, 'Path'):
+            return out
+
+        if OUTPUT_COMMENTS and OUTPUT_PATH:
+            out += linenumber() + '(Path: ' + pathobj.Label + ')\n'
+
+        for c in pathobj.Path.Commands:
+            outlist = []
+            command = c.Name
+            outlist.append(command)
+            # Debug:
+            # print('pathobj.Path.Commands:', c)
+
+            # If modal is True, delete duplicate commands:
+            if MODAL:
+                if command == lastcommand:
+                    outlist.pop(0)
+
+            # Add the remaining parameters in order:
+            for param in params:
+                if param in c.Parameters:
+                    if param == 'F':
+                        if command not in RAPID_MOVES:
+                            feedRate = Units.Quantity(
+                                c.Parameters['F'], FreeCAD.Units.Velocity)
+                            if feedRate.getValueAs(UNIT_FEED_FORMAT) > 0.0:
+                                outlist.append(param + format(float(
+                                    feedRate.getValueAs(UNIT_FEED_FORMAT)),
+                                    precision_string))
+                    elif param in ['T', 'H', 'D', 'S', 'P', 'L']:
+                        outlist.append(param + str(c.Parameters[param]))
+                    elif param in ['A', 'B', 'C']:
+                        outlist.append(param + format(
+                            c.Parameters[param], precision_string))
+                    # [X, Y, Z, U, V, W, I, J, K, R, Q]
+                    else:
+                        pos = Units.Quantity(
+                            c.Parameters[param], FreeCAD.Units.Length)
+                        outlist.append(param + format(float(
+                            pos.getValueAs(UNIT_FORMAT)), precision_string))
+
+            # Store the latest command:
+            lastcommand = command
+
+            # Capture the current position for subsequent calculations:
+            if command in MOTION_COMMANDS:
+                if 'X' in c.Parameters:
+                    CURRENT_X = Units.Quantity(
+                        c.Parameters['X'], FreeCAD.Units.Length)
+                if 'Y' in c.Parameters:
+                    CURRENT_Y = Units.Quantity(
+                        c.Parameters['Y'], FreeCAD.Units.Length)
+                if 'Z' in c.Parameters:
+                    CURRENT_Z = Units.Quantity(
+                        c.Parameters['Z'], FreeCAD.Units.Length)
+
+            if command in ('G98', 'G99'):
+                DRILL_RETRACT_MODE = command
+
+            if TRANSLATE_DRILL_CYCLES:
+                if command in ('G81', 'G82', 'G83'):
+                    out += drill_translate(outlist, command, c.Parameters)
+                    # Erase the line just translated:
+                    outlist = []
+
+            if SPINDLE_WAIT > 0:
+                if command in ('M3', 'M03', 'M4', 'M04'):
+                    out += linenumber() + format_outlist(outlist) + '\n'
+                    # Marlin: P for milliseconds, S for seconds, change P to S
+                    out += linenumber()
+                    out += format_outlist(['G4', 'S%s' % SPINDLE_WAIT])
+                    out += '\n'
+                    outlist = []
+
+            # Check for Tool Change:
+            if command in ('M6', 'M06'):
+                if OUTPUT_COMMENTS:
+                    out += linenumber() + '(Begin toolchange)\n'
+                if OUTPUT_TOOL_CHANGE:
+                    for line in TOOL_CHANGE.splitlines(True):
+                        out += linenumber() + line
+                if not OUTPUT_TOOL_CHANGE and OUTPUT_COMMENTS:
+                    outlist[0] = '(' + outlist[0]
+                    outlist[-1] = outlist[-1] + ')'
+                if not OUTPUT_TOOL_CHANGE and not OUTPUT_COMMENTS:
+                    outlist = []
+
+            if command == 'message':
+                if OUTPUT_COMMENTS:
+                    outlist.pop(0)  # remove the command
+                else:
+                    out = []
+
+            if command in SUPPRESS_COMMANDS:
+                outlist[0] = '(' + outlist[0]
+                outlist[-1] = outlist[-1] + ')'
+
+            # Remove embedded comments:
+            if not OUTPUT_COMMENTS:
+                tmplist = []
+                list_index = 0
+                while list_index < len(outlist):
+                    left_index = outlist[list_index].find('(')
+                    if left_index == -1:  # Not a comment
+                        tmplist.append(outlist[list_index])
+                    else:  # This line contains a comment, and possibly more
+                        right_index = outlist[list_index].find(')')
+                        comment_area = outlist[list_index][
+                            left_index: right_index + 1]
+                        line_minus_comment = outlist[list_index].replace(
+                            comment_area, '').strip()
+                        if line_minus_comment:
+                            # Line contained more than just a comment
+                            tmplist.append(line_minus_comment)
+                    list_index += 1
+                # Done removing comments
+                outlist = tmplist
+
+            # Prepend a line number and append a newline
+            if len(outlist) >= 1:
+                out += linenumber() + format_outlist(outlist) + '\n'
 
-  if hasattr(pathobj, "Group"):  # We have a compound or project.
-    if OUTPUT_COMMENTS:
-      out += linenumber() + "(Compound: " + pathobj.Label + ")\n"
-    for p in pathobj.Group:
-      out += parse(p)
     return out
 
-  else: # Parsing simple path
-    if not hasattr(pathobj, "Path"):  # groups might contain non-path things like stock.
-      return out
 
-    if OUTPUT_COMMENTS and OUTPUT_PATH:
-      out += linenumber() + "(Path: " + pathobj.Label + ")\n"
+# *****************************************************************************
+# * As of Marlin 2.0.7.bugfix, canned drill cycles do not exist.              *
+# * The following code converts FreeCAD's canned drill cycles into            *
+# * gcode that Marlin can use.                                                *
+# *****************************************************************************
+def drill_translate(outlist, cmd, params):
+    global DRILL_RETRACT_MODE
+    global MOTION_MODE
+    global CURRENT_X
+    global CURRENT_Y
+    global CURRENT_Z
+    global UNITS
+    global UNIT_FORMAT
+    global UNIT_FEED_FORMAT
 
-    for c in pathobj.Path.Commands:
-      outstring = []
-      command = c.Name
-      outstring.append(command)
-      # Debug:
-      # print('pathobj.Path.Commands:', c)
+    class Drill:  # Using a class is necessary for the nested functions.
+        gcode = ''
 
-      # If modal is True, delete duplicate commands:
-      if MODAL:
-        if command == lastcommand:
-          outstring.pop(0)
+    strFormat = '.' + str(PRECISION) + 'f'
 
-      # Add the remaining parameters in order:
-      for param in params:
-        if param in c.Parameters:
-          if param == 'F':
-            if command not in RAPID_MOVES:
-              feedRate = Units.Quantity(c.Parameters['F'], FreeCAD.Units.Velocity)
-              if feedRate.getValueAs(UNIT_FEED_FORMAT) > 0.0:
-                outstring.append(param + format(float(feedRate.getValueAs(UNIT_FEED_FORMAT)), precision_string))
-          elif param in ['T', 'H', 'D', 'S', 'P', 'L']:
-            outstring.append(param + str(c.Parameters[param]))
-          elif param in ['A', 'B', 'C']:
-            outstring.append(param + format(c.Parameters[param], precision_string))
-          else:  # [X, Y, Z, U, V, W, I, J, K, R, Q] (Possible conversion mm/inches)
-            pos = Units.Quantity(c.Parameters[param], FreeCAD.Units.Length)
-            outstring.append(param + format(float(pos.getValueAs(UNIT_FORMAT)), precision_string))
+    if OUTPUT_COMMENTS:  # Comment the original command
+        outlist[0] = '(' + outlist[0]
+        outlist[-1] = outlist[-1] + ')'
+        Drill.gcode += linenumber() + format_outlist(outlist) + '\n'
 
-      # Store the latest command:
-      lastcommand = command
+    # Cycle conversion only converts the cycles in the XY plane (G17).
+    # --> ZX (G18) and YZ (G19) planes produce false gcode.
+    drill_X = Units.Quantity(params['X'], FreeCAD.Units.Length)
+    drill_Y = Units.Quantity(params['Y'], FreeCAD.Units.Length)
+    drill_Z = Units.Quantity(params['Z'], FreeCAD.Units.Length)
+    drill_R = Units.Quantity(params['R'], FreeCAD.Units.Length)
+    drill_F = Units.Quantity(params['F'], FreeCAD.Units.Velocity)
+    if cmd == 'G82':
+        drill_DwellTime = params['P']
+    elif cmd == 'G83':
+        drill_Step = Units.Quantity(params['Q'], FreeCAD.Units.Length)
 
-      # Capture the current position for calculating the related movements:
-      if command in MOTION_COMMANDS:
-        if 'X' in c.Parameters:
-          CURRENT_X = Units.Quantity(c.Parameters['X'], FreeCAD.Units.Length)
-        if 'Y' in c.Parameters:
-          CURRENT_Y = Units.Quantity(c.Parameters['Y'], FreeCAD.Units.Length)
-        if 'Z' in c.Parameters:
-          CURRENT_Z = Units.Quantity(c.Parameters['Z'], FreeCAD.Units.Length)
+    # R less than Z is error
+    if drill_R < drill_Z:
+        Drill.gcode += linenumber() + '(drill cycle error: R less than Z )\n'
+        return Drill.gcode
 
-      if command in ('G98', 'G99'):
-        DRILL_RETRACT_MODE = command
+    # Z height to retract to when drill cycle is done:
+    if DRILL_RETRACT_MODE == 'G98' and CURRENT_Z > drill_R:
+        RETRACT_Z = CURRENT_Z
+    else:
+        RETRACT_Z = drill_R
 
-      if TRANSLATE_DRILL_CYCLES:
-        if command in ('G81', 'G82', 'G83'):
-          out += drill_translate(outstring, command, c.Parameters)
-          # Erase the line we just translated
-          outstring = []
+    # Z motion nested functions:
+    def rapid_Z_to(new_Z):
+        Drill.gcode += linenumber() + 'G0 Z'
+        Drill.gcode += format(
+            float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + '\n'
 
-      if SPINDLE_WAIT > 0:
-        if command in ('M3', 'M03', 'M4', 'M04'):
-          out += linenumber() + format_outstring(outstring) + "\n"
-          # Note: Marlin uses P for milliseconds, S for seconds. Change P to S.
-          out += linenumber() + format_outstring(['G4', 'S%s' % SPINDLE_WAIT]) + "\n"
-          outstring = []
+    def feed_Z_to(new_Z):
+        Drill.gcode += linenumber() + 'G1 Z'
+        Drill.gcode += format(
+            float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + ' F'
+        Drill.gcode += format(
+            float(drill_F.getValueAs(UNIT_FEED_FORMAT)), '.2f') + '\n'
 
-      # Check for Tool Change:
-      if command in ('M6', 'M06'):
-        if OUTPUT_COMMENTS:
-          out += linenumber() + "(Begin toolchange)\n"
-        if not OUTPUT_TOOL_CHANGE:
-          outstring[0] = "(" + outstring[0]
-          outstring[-1] = outstring[-1] + ")"
-        else:
-          for line in TOOL_CHANGE.splitlines(True):
-            out += linenumber() + line
+    # Make sure that Z is not below RETRACT_Z:
+    if CURRENT_Z < RETRACT_Z:
+        rapid_Z_to(RETRACT_Z)
 
-      if command == "message":
-        if OUTPUT_COMMENTS is False:
-          out = []
-        else:
-          outstring.pop(0)  # remove the command
+    # Rapid to hole position XY:
+    Drill.gcode += linenumber() + 'G0 X'
+    Drill.gcode += format(
+        float(drill_X.getValueAs(UNIT_FORMAT)), strFormat) + ' Y'
+    Drill.gcode += format(
+        float(drill_Y.getValueAs(UNIT_FORMAT)), strFormat) + '\n'
 
-      if command in SUPPRESS_COMMANDS:
-        outstring[0] = "(" + outstring[0]
-        outstring[-1] = outstring[-1] + ")"
+    # Rapid to R:
+    rapid_Z_to(drill_R)
 
-      # Prepend a line number and append a newline
-      if len(outstring) >= 1:
-          out += linenumber() + format_outstring(outstring) + "\n"
+    # *************************************************************************
+    # * Drill cycles:                                                         *
+    # * G80 Cancel the drill cycle                                            *
+    # * G81 Drill full depth in one pass                                      *
+    # * G82 Drill full depth in one pass, and pause at the bottom             *
+    # * G83 Drill in pecks, raising the drill to R height after each peck     *
+    # * In preparation for a rapid to the next hole position:                 *
+    # * G98 After the hole has been drilled, retract to the initial Z value   *
+    # * G99 After the hole has been drilled, retract to R height              *
+    # * Select G99 only if safe to move from hole to hole at the R height     *
+    # *************************************************************************
+    if cmd in ('G81', 'G82'):
+        feed_Z_to(drill_Z)  # Drill hole in one step
+        if cmd == 'G82':  # Dwell time delay at the bottom of the hole
+            Drill.gcode += linenumber() + 'G4 S' + str(drill_DwellTime) + '\n'
+            # Marlin uses P for milliseconds, S for seconds, change P to S
 
-  return out
+    elif cmd == 'G83':  # Peck drill cycle:
+        chip_Space = drill_Step * 0.5
+        next_Stop_Z = drill_R - drill_Step
+        while next_Stop_Z >= drill_Z:
+            feed_Z_to(next_Stop_Z)  # Drill one peck of depth
 
+            # Set next depth, next_Stop_Z is still at the current hole depth
+            if (next_Stop_Z - drill_Step) >= drill_Z:
+                # Rapid up to clear chips:
+                rapid_Z_to(drill_R)
+                # Rapid down to just above last peck depth:
+                rapid_Z_to(next_Stop_Z + chip_Space)
+                # Update next_Stop_Z to next depth:
+                next_Stop_Z -= drill_Step
+            elif next_Stop_Z == drill_Z:
+                break  # Done
+            else:  # More to drill, but less than drill_Step
+                # Rapid up to clear chips:
+                rapid_Z_to(drill_R)
+                # Rapid down to just above last peck depth:
+                rapid_Z_to(next_Stop_Z + chip_Space)
+                # Dril remainder of the hole depth:
+                feed_Z_to(drill_Z)
+                break  # Done
+    rapid_Z_to(RETRACT_Z)  # Done, retract the drill
 
-''' As of Marlin 2.0.7.bugfix, canned drill cycles do not exist.
-    The following code converts FreeCAD's canned drill cycles into
-    gcode that Marlin can use.
-'''
-def drill_translate(outstring, cmd, params):
-  global DRILL_RETRACT_MODE
-  global MOTION_MODE
-  global CURRENT_X
-  global CURRENT_Y
-  global CURRENT_Z
-  global UNITS
-  global UNIT_FORMAT
-  global UNIT_FEED_FORMAT
-
-  class Drill: # Using a class is necessary for the nested functions
-    gcode = ''
-
-  strFormat = '.' + str(PRECISION) + 'f'
-
-  if OUTPUT_COMMENTS:  # Comment the original command
-    outstring[0] = "(" + outstring[0]
-    outstring[-1] = outstring[-1] + ")"
-    Drill.gcode += linenumber() + format_outstring(outstring) + "\n"
-
-  # Cycle conversion only converts the cycles in the XY plane (G17).
-  # --> ZX (G18) and YZ (G19) planes produce false gcode.
-  drill_X = Units.Quantity(params['X'], FreeCAD.Units.Length)
-  drill_Y = Units.Quantity(params['Y'], FreeCAD.Units.Length)
-  drill_Z = Units.Quantity(params['Z'], FreeCAD.Units.Length)
-  drill_R = Units.Quantity(params['R'], FreeCAD.Units.Length)
-  drill_F = Units.Quantity(params['F'], FreeCAD.Units.Velocity)
-  if cmd == 'G82':
-    drill_DwellTime = params['P']
-  elif cmd == 'G83':
-    drill_Step = Units.Quantity(params['Q'], FreeCAD.Units.Length)
-
-  # R less than Z is error
-  if drill_R < drill_Z :
-    Drill.gcode += linenumber() + "(drill cycle error: R less than Z )\n"
     return Drill.gcode
 
-  # Z height to retract to when drill cycle is done:
-  if DRILL_RETRACT_MODE == 'G98' and CURRENT_Z > drill_R:
-    RETRACT_Z = CURRENT_Z
-  else:
-    RETRACT_Z = drill_R
 
-  # Z motion nested functions:
-  def rapid_Z_to(new_Z):
-    Drill.gcode += linenumber() + 'G0 Z' + format(float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + "\n"
+print(__name__ + ': GCode postprocessor loaded.')
 
-  def feed_Z_to(new_Z):
-    Drill.gcode += linenumber() + 'G1 Z' + format(float(new_Z.getValueAs(UNIT_FORMAT)), strFormat) + ' F' + format(float(drill_F.getValueAs(UNIT_FEED_FORMAT)), '.2f') + "\n"
-
-  # Make sure that Z is not below RETRACT_z:
-  if CURRENT_Z < RETRACT_Z:
-    rapid_Z_to(RETRACT_Z)
-
-  # Rapid to hole position XY:
-  Drill.gcode += linenumber() + 'G0 X' + format(float(drill_X.getValueAs(UNIT_FORMAT)), strFormat) + ' Y' + format(float(drill_Y.getValueAs(UNIT_FORMAT)), strFormat) + "\n"
-
-  # Rapid to R:
-  rapid_Z_to(drill_R)
-
-  """ Drill cycles:
-  G80 Cancel the drill cycle.
-  G81 Drill full depth in one pass.
-  G82 Drill full depth in one pass, and pause at the bottom.
-  G83 Drill in small pecks (steps), raising the drill to R height after each peck.
-  In preparation for a rapid to the next hole position:
-  G98 After the hole has been drilled, retract to the initial Z value as the clearance height.
-  G99 After the hole has been drilled, retract to R height. G99 should only be selected if it is safe to move from hole to hole at the R height.
-  """
-  if cmd in ('G81', 'G82'):
-    feed_Z_to(drill_Z) # Drill hole in one step
-    if cmd == 'G82': # Dwell time delay at the bottom of the hole
-      Drill.gcode += linenumber() + 'G4 S' + str(drill_DwellTime) + "\n"
-      # Note: Marlin uses P for milliseconds, S for seconds. Change P to S.
-
-  elif cmd == 'G83': # Peck drill cycle:
-    chip_Space = drill_Step * 0.5
-    next_Stop_Z = drill_R - drill_Step
-    while next_Stop_Z >= drill_Z:
-      feed_Z_to(next_Stop_Z) # Drill one peck depth
-
-      # Set the next depth, next_Stop_Z is still at the current hole depth
-      if (next_Stop_Z - drill_Step) >= drill_Z:
-        rapid_Z_to(drill_R) # Rapid up to clear chips
-        rapid_Z_to(next_Stop_Z + chip_Space) # Rapid down above last peck depth
-        next_Stop_Z -= drill_Step # Update next_Stop_Z to the next depth
-      elif next_Stop_Z == drill_Z:
-        break # Done
-      else: # More to drill, but less than drill_Step
-        rapid_Z_to(drill_R) # Rapid up to clear chips
-        rapid_Z_to(next_Stop_Z + chip_Space) # Rapid down above last peck depth
-        feed_Z_to(drill_Z) # Dril remainder of the hole depth
-        break # Done
-  rapid_Z_to(RETRACT_Z) # Done, retract the drill
-
-  return Drill.gcode
-
-
-print(__name__ + ": GCode postprocessor loaded.")
+# PEP8 format passed using: http://pep8online.com/, which primarily covers
+# indentation and line length. Some other aspects of PEP8 which have not
+# been applied yet may be applied in future updates.