plceye 0.7.1

PLC code smell detector and static analyzer for L5X and PLCopen files
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

//! RLL (Relay Ladder Logic) parsing utilities.
//!
//! Extract and parse ladder logic rungs from L5X structures.

use l5x::rll;
use l5x::{
    Routine, RoutineContent, Rung, RungContent,
    RungCollection, TextWide, TextWideContent,
};

use super::{RungLocation, LocatedRung};

/// Extract the text content from a TextWide element.
pub fn extract_text_content(text_wide: &TextWide) -> Option<String> {
    for content in &text_wide.content {
        if let TextWideContent::TextContent(text) = content {
            let trimmed = text.trim();
            if !trimmed.is_empty() {
                return Some(trimmed.to_string());
            }
        }
    }
    None
}

/// Extract rung text from a Rung element.
pub fn extract_rung_text(rung: &Rung) -> Option<String> {
    for content in &rung.content {
        if let RungContent::Text(text_wide) = content {
            if let Some(text) = extract_text_content(text_wide) {
                return Some(text);
            }
        }
    }
    None
}

/// Parse all rungs from a RungCollection (RLLContent).
pub fn parse_rung_collection(
    rungs: &RungCollection,
    program: &str,
    routine: &str,
) -> Vec<LocatedRung> {
    let mut results = Vec::new();

    for rung in &rungs.rung {
        let rung_number: u32 = rung
            .number
            .as_ref()
            .and_then(|n| n.parse().ok())
            .unwrap_or(0);

        if let Some(text) = extract_rung_text(rung) {
            let parsed = rll::parse_rung(&text);
            results.push(LocatedRung {
                location: RungLocation::new(program, routine, rung_number),
                parsed,
            });
        }
    }

    results
}

/// Parse all rungs from a Routine.
pub fn parse_routine(routine: &Routine, program: &str) -> Vec<LocatedRung> {
    let mut results = Vec::new();

    // Only process RLL routines
    if routine.r#type != "RLL" {
        return results;
    }

    for content in &routine.content {
        if let RoutineContent::RLLContent(rung_collection) = content {
            results.extend(parse_rung_collection(rung_collection, program, &routine.name));
        }
    }

    results
}