virtuoso-cli 0.1.3

CLI tool to control Cadence Virtuoso from anywhere, locally or remotely
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::client::bridge::escape_skill_string;

#[derive(Default)]
pub struct LayoutOps;

impl LayoutOps {
    pub fn new() -> Self {
        Self
    }

    pub fn create_rect(&self, layer: &str, purpose: &str, bbox: &[(i64, i64); 4]) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        format!(r#"rodCreateRect(?layer "{layer}" ?purpose "{purpose}" ?bBox {bbox:?})"#)
    }

    pub fn create_polygon(&self, layer: &str, purpose: &str, points: &[(i64, i64)]) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        let pts: String = points
            .iter()
            .map(|(x, y)| format!("{x} {y}"))
            .collect::<Vec<_>>()
            .join(" ");
        format!(r#"rodCreatePolygon(?layer "{layer}" ?purpose "{purpose}" ?points list({pts}))"#)
    }

    pub fn create_path(
        &self,
        layer: &str,
        purpose: &str,
        width: i64,
        points: &[(i64, i64)],
    ) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        let pts: String = points
            .iter()
            .map(|(x, y)| format!("{x} {y}"))
            .collect::<Vec<_>>()
            .join(" ");
        format!(
            r#"rodCreatePath(?layer "{layer}" ?purpose "{purpose}" ?width {width} ?points list({pts}))"#
        )
    }

    pub fn create_via(&self, via_def: &str, origin: (i64, i64)) -> String {
        let via_def = escape_skill_string(via_def);
        let (x, y) = origin;
        format!(r#"rodCreateVia(?viaHeader "{via_def}" ?origin {x}:{y})"#)
    }

    pub fn create_label(
        &self,
        layer: &str,
        _purpose: &str,
        text: &str,
        origin: (i64, i64),
    ) -> String {
        let layer = escape_skill_string(layer);
        let text = escape_skill_string(text);
        let (x, y) = origin;
        format!(
            r#"dbCreateLabel(dbGetCurCellView() dbGetLayerByName(dbGetCurCellView() "{layer}") {x}:{y} "{text}" "centerCenter" "R0" "stick" 0.0625)"#
        )
    }

    pub fn create_instance(
        &self,
        lib: &str,
        cell: &str,
        view: &str,
        origin: (i64, i64),
        orient: &str,
    ) -> String {
        let lib = escape_skill_string(lib);
        let cell = escape_skill_string(cell);
        let view = escape_skill_string(view);
        let orient = escape_skill_string(orient);
        let (x, y) = origin;
        format!(
            r#"dbCreateInst(dbOpenCellViewByType("{lib}" "{cell}" "{view}" nil "r") nil nil {x}:{y} "{orient}" 1)"#
        )
    }

    pub fn set_active_lpp(&self, layer: &str, purpose: &str) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        format!(r#"leSetEntryLayer(list("{layer}" "{purpose}"))"#)
    }

    pub fn fit_view(&self) -> String {
        r#"hiRedraw() hiZoomBox(hiGetCurrentWindow() geGetWindowBox(hiGetCurrentWindow()) geGetEditCellView()~>bBox)"#.into()
    }

    pub fn read_summary(&self) -> String {
        r#"let((cv) cv = geGetEditCellView() list(cv~>libName cv~>cellName cv~>viewName cv~>bBox length(cv~>instances) length(cv~>nets)))"#.into()
    }

    pub fn read_geometry(&self, layer: &str, purpose: &str) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        format!(
            r#"let((cv shapes) cv = geGetEditCellView() shapes = nil foreach(shape cv~>shapes when(shape~>lpp == list("{layer}" "{purpose}") shapes = cons(shape~>bBox shapes))) shapes)"#
        )
    }

    pub fn delete_shapes_on_layer(&self, layer: &str, purpose: &str) -> String {
        let layer = escape_skill_string(layer);
        let purpose = escape_skill_string(purpose);
        format!(
            r#"let((cv) cv = geGetEditCellView() foreach(shape cv~>shapes when(shape~>lpp == list("{layer}" "{purpose}") dbDeleteObject(shape))))"#
        )
    }

    pub fn highlight_net(&self, net_name: &str) -> String {
        let net_name = escape_skill_string(net_name);
        format!(
            r#"let((cv net) cv = geGetEditCellView() net = dbFindNetByName(cv "{net_name}") when(net hiHighlight(net)))"#
        )
    }
}