ngc 0.2.6

Library to parse G-code (LinuxCNC dialect)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// Copyright (c) 2019 Georg Brandl.  Licensed under the Apache License,
// Version 2.0 <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>
// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at
// your option. This file may not be copied, modified, or distributed except
// according to those terms.

use ngc::parse;

#[test]
fn test_parse() {
    let src = r#"; Try to exercise as much of the syntax as possible.

; comments anywhere, line numbers, and block deletion
/G1 X1 0(a)(b) Y2(a);rest
/(a)
(a)N1 G#1 X-[10] (a)

; number formats
#1=+1. (a) #2=1.5 #3=-.5

; expressions
G[[1+ 2]/ 3*4--5]
G+SIN[0]
G[ATAN[1]/[2]]
G[1 LE 2]

; parameter references
#1=[1+2]
#<de pth>=1
#<de(a) pth>=2
#[1 ]=3
#-#2=[+ 5]
#SIN [0]=7 ; LCNC doesn't like this.
# 10 = EXISTS[#<blub>]

"#;

    let parsed = r#"/ G1 X10 Y2
G#1 X-10
#1=1 #2=1.5 #3=-0.5
G[[[[1 + 2] / 3] * 4] - -5]
GSIN[0]
GATAN[1]/[2]
G[1 LE 2]
#1=[1 + 2]
#<depth>=1
#<de(a)pth>=2
#1=3
#-#2=5
#[SIN[0]]=7
#10=EXISTS[#<blub>]
"#;

    let prog = parse::parse("testfile", src).unwrap();

    // make sure we count lines correctly
    assert_eq!(prog.blocks[0].lineno, 4);

    println!("{:#?}", prog);
    assert_eq!(prog.to_string(), parsed.replace("\n", " \n"));
}

#[test]
fn test_invalid() {
    for snippet in &[
        "$",            // invalid characters
        "GG",           // missing values
        "O10",          // O-words are unsupported
        "(",            // unclosed comments
        "(\n)",         // comments spanning lines
        "G(a)1",        // comments between letter/value
        "G1(a)2",       // comments within the value
        "G[1(a)+2]",    // comments within an expression
        "G[1;]",        // line comments within expression
        "G[TEST[x]]",   // invalid function
        "#1.2=5",       // fractional parameter number
        "#1=EXISTS[5]", // invalid EXISTS argument
    ] {
        assert!(parse::parse("testfile", snippet).is_err());
    }
}