Major g-code parser overhaul. 100%* compliant. Other related updates.

- Completely overhauled the g-code parser. It’s now 100%* compliant. (*
may have some bugs). Being compliant, here are some of the major
differences.

- SMALLER and JUST AS FAST! A number of optimizations were found that
sped things up and allowed for the more thorough error-checking to be
installed without a speed hit. Trimmed a lot of ‘fat’ in the parser and
still was able to make it significantly smaller than it was.

- No default feed rate setting! Removed completely! This doesn’t exist
in the g-code standard. So, it now errors out whenever it’s undefined
for motions that require it (G1/2/3/38.2).

- Any g-code parser error expunges the ENTIRE block. This means all
information is lost and not passed on to the running state. Before some
of the states would remain, which could have led to some problems.

- If the g-code block passes all of the error-checks, the g-code state
is updated and all motions are executed according to the order of
execution.

- Changes in spindle speed, when already running, will update the
output pin accordingly. This fixes a bug, where it wouldn’t update the
speed.

- Update g-code parser error reporting. Errors now return detailed
information of what exact went wrong. The most common errors return a
short text description. For less common errors, the parser reports
‘Invalid gcode ID:20’, where 20 is a error ID. A list of error code IDs
and their descriptions will be documented for user reference elsewhere
to save flash space.

- Other notable changes:

- Added a print integer routine for uint8 variables. This saved
significant flash space by switching from a heavier universal print
integer routine.

- Saved some flash space with our own short hypotenuse calculation

- Some arc computation flash and memory optimizations.

protocol.c

@@ -36,37 +36,27 @@ static char line[LINE_BUFFER_SIZE]; // Line to be executed. Zero-terminated.
 // Directs and executes one line of formatted input from protocol_process. While mostly
 // incoming streaming g-code blocks, this also directs and executes Grbl internal commands,
 // such as settings, initiating the homing cycle, and toggling switch states.
-// TODO: Eventually re-organize this function to more cleanly organize order of operations,
-// which will hopefully reduce some of the current spaghetti logic and dynamic memory usage. 
 static void protocol_execute_line(char *line) 
 {      
   protocol_execute_runtime(); // Runtime command check point.
   if (sys.abort) { return; } // Bail to calling function upon system abort  
 
-  uint8_t status;
   if (line[0] == 0) {
     // Empty or comment line. Send status message for syncing purposes.
-    status = STATUS_OK;
+    report_status_message(STATUS_OK);
 
   } else if (line[0] == '$') {
     // Grbl '$' system command
-    status = system_execute_line(line);
+    report_status_message(system_execute_line(line));
     
+  } else if (sys.state == STATE_ALARM) {
+    // Everything else is gcode. Block if in alarm mode.
+    report_status_message(STATUS_ALARM_LOCK);
+
   } else {
-    // Everything else is gcode. Send to g-code parser! Block if in alarm mode.
-    if (sys.state == STATE_ALARM) { status = STATUS_ALARM_LOCK; }
-    else { status = gc_execute_line(line); }
-    
-    // TODO: Separate the parsing from the g-code execution. Need to re-write the parser
-    // completely to do this. First parse the line completely, checking for modal group 
-    // errors and storing all of the g-code words. Then, send the stored g-code words to
-    // a separate g-code executor. This will be more in-line with actual g-code protocol.
-    
-    // TODO: Clean up the multi-tasking workflow with the execution of commands. It's a 
-    // bit complicated and patch-worked. Could be made simplier to understand.
+    // Parse and execute g-code block!
+    report_status_message(gc_execute_line(line));
   }
-  
-  report_status_message(status);
 }
 
 
@@ -117,12 +107,27 @@ void protocol_main_loop()
           }
         } else {
           if (c <= ' ') { 
-            // Throw away whitepace and control characters
+            // Throw away whitepace and control characters  
           } else if (c == '/') { 
-            // Block delete not supported. Ignore character.
+            // Block delete NOT SUPPORTED. Ignore character.
+            // NOTE: If supported, would simply need to check the system if block delete is enabled.
           } else if (c == '(') {
             // Enable comments flag and ignore all characters until ')' or EOL.
+            // NOTE: This doesn't follow the NIST definition exactly, but is good enough for now.
+            // In the future, we could simply remove the items within the comments, but retain the
+            // comment control characters, so that the g-code parser can error-check it.
             iscomment = true;
+          // } else if (c == ';') {
+            // Comment character to EOL NOT SUPPORTED. LinuxCNC definition. Not NIST.
+            
+          // TODO: Install '%' feature 
+          // } else if (c == '%') {
+            // Program start-end percent sign NOT SUPPORTED.
+            // NOTE: This maybe installed to tell Grbl when a program is running vs manual input,
+            // where, during a program, the system auto-cycle start will continue to execute 
+            // everything until the next '%' sign. This will help fix resuming issues with certain
+            // functions that empty the planner buffer to execute its task on-time.
+
           } else if (char_counter >= LINE_BUFFER_SIZE-1) {
             // Detect line buffer overflow. Report error and reset line buffer.
             report_status_message(STATUS_OVERFLOW);