Merge remote-tracking branch 'origin/main' into text

Author: rahulk29

Cargo.lock

@@ -31,3 +31,4 @@ tower-lsp-server = "0.22"
 
 geometry = { version = "0.7", registry = "substrate" }
 enumify = { version = "0.2", registry = "substrate" }
+uniquify = { version = "0.4", registry = "substrate" }

Cargo.toml

@@ -58,12 +58,12 @@ vim.cmd([[autocmd BufRead,BufNewFile *.ar setfiletype argon]])
 To open an example Argon workspace, run the following from the root directory of your Argon clone:
 
 ```
-vim core/compiler/examples/argon_workspace/lib.ar
+vim pdks/sky130/lib.ar
 ```
 
 Start the GUI by running `:Argon gui`.
 
-From within the GUI, type `:openCell test()` to open the `test` cell. You should now be able to edit layouts 
+From within the GUI, type `:openCell inv(1200., 2000., 4)` to open the `inv` cell. You should now be able to edit layouts 
 in both Neovim and the GUI.
 
 ### VS Code
@@ -92,7 +92,7 @@ cd ../..
 To open an example Argon workspace, run the following from the root directory of your Argon clone:
 
 ```bash
-code --extensionDevelopmentPath=$(pwd)/plugins/vscode core/compiler/examples/argon_workspace
+code --extensionDevelopmentPath=$(pwd)/plugins/vscode pdks/sky130/lib.ar
 ```
 
 We recommend defining an alias in your shell configuration to simplify future commands:
@@ -104,7 +104,7 @@ alias codear="code --extensionDevelopmentPath=<absolute_path_to_argon_repo>/plug
 With this alias defined, you can now run:
 
 ```bash
-codear core/compiler/examples/argon_workspace
+codear pdks/sky130
 ```
 
 Open the `lib.ar` file within the workspace. You can then start the GUI by running `Command Palette > Argon: Start GUI`.
@@ -149,10 +149,8 @@ Hit `d` to use the Dimension tool and click on the top edge of each rectangle. C
 The dimension should now be highlighted yellow, indicating that you are editing that dimension. Type `5.` and hit enter to set the value
 of the dimension (the decimal point is important, since just `5` is considered an integer literal rather than a float).
 
-> [!WARNING]
-> Double check that there are no errors in your code editor, or the GUI will not be able to
-> display the updated cell. If you make a mistake, 
-> you can undo and redo changes from the GUI using `u` and `Ctrl + r`,
+> [!TIP]
+> If you make a mistake, you can undo and redo changes from the GUI using `u` and `Ctrl + r`,
 > respectively, or manually modify the code in the text editor if needed.
 
 Repeat for the other 3 sides of the rectangle.

README.md

@@ -7,6 +7,7 @@ edition = "2024"
 derive-where = { version = "1", features = ["serde"] }
 nalgebra = "0.34"
 klayout-lyp = "0.1.1"
+gds21 = "0.2"
 
 anyhow = { workspace = true }
 cfgrammar = { workspace = true }
@@ -19,13 +20,15 @@ serde = { workspace = true }
 approx = { workspace = true }
 indexmap = { workspace = true }
 geometry = { workspace = true }
+uniquify = { workspace = true }
 rgb = { workspace = true }
 thiserror = { workspace = true }
 toml = { workspace = true }
 regex = { workspace = true }
+tracing = { workspace = true }
 
 [dev-dependencies]
-gds21 = "0.2"
+const_format = "0.2"
 
 [build-dependencies]
 lrpar = { version = "0.13", features = ["serde"] }

core/compiler/Cargo.toml

@@ -0,0 +1,165 @@
+use std::{io::BufReader, ops::Deref, path::Path};
+
+use anyhow::{Result, anyhow};
+use gds21::{
+    GdsBoundary, GdsElement, GdsLayerSpec, GdsLibrary, GdsPoint, GdsStrans, GdsStruct, GdsStructRef,
+};
+use indexmap::IndexMap;
+use regex::Regex;
+use tracing::trace;
+use uniquify::Names;
+
+use crate::compile::{CellId, CompileOutput, CompiledData, ExecErrorCompileOutput, SolvedValue};
+
+pub struct GdsMap {
+    layers: IndexMap<String, GdsLayerSpec>,
+}
+
+struct GdsExporter {
+    lib: GdsLibrary,
+    map: GdsMap,
+    names: Names<CellId>,
+}
+
+impl GdsExporter {
+    fn new(name: impl Into<String>, map: GdsMap) -> Self {
+        Self {
+            lib: GdsLibrary::new(name),
+            map,
+            names: Names::new(),
+        }
+    }
+}
+
+impl FromIterator<(String, GdsLayerSpec)> for GdsMap {
+    fn from_iter<T: IntoIterator<Item = (String, GdsLayerSpec)>>(iter: T) -> Self {
+        Self {
+            layers: IndexMap::from_iter(iter),
+        }
+    }
+}
+
+impl Deref for GdsMap {
+    type Target = IndexMap<String, GdsLayerSpec>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.layers
+    }
+}
+
+impl GdsMap {
+    pub fn from_lyp(path: impl AsRef<Path>) -> Result<Self> {
+        let lyp = klayout_lyp::from_reader(BufReader::new(std::fs::File::open(path)?))?;
+        Ok(GdsMap::from_iter(
+            lyp.layers
+                .into_iter()
+                .map(|layer_prop| {
+                    let re = Regex::new(r"(\d*)/(\d*)@\d*")?;
+                    let caps = re
+                        .captures(&layer_prop.source)
+                        .ok_or_else(|| anyhow!("parse error"))?;
+                    let layer = caps
+                        .get(1)
+                        .ok_or_else(|| anyhow!("parse error"))?
+                        .as_str()
+                        .parse()?;
+                    let datatype = caps
+                        .get(2)
+                        .ok_or_else(|| anyhow!("parse error"))?
+                        .as_str()
+                        .parse()?;
+                    Ok((
+                        layer_prop.name,
+                        GdsLayerSpec {
+                            layer,
+                            xtype: datatype,
+                        },
+                    ))
+                })
+                .collect::<Result<Vec<_>>>()?,
+        ))
+    }
+}
+
+impl CompileOutput {
+    pub fn to_gds(&self, map: GdsMap, out_path: impl AsRef<Path>) -> Result<()> {
+        let out_path = out_path.as_ref();
+        trace!("Exporting to gds at {out_path:?}");
+        let mut exporter = GdsExporter::new("TOP", map);
+        if let CompileOutput::Valid(output)
+        | CompileOutput::ExecErrors(ExecErrorCompileOutput {
+            errors: _,
+            output: Some(output),
+        }) = self
+        {
+            output.cell_to_gds(&mut exporter, output.top)?;
+        }
+        if let Some(parent) = out_path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        exporter.lib.save(out_path).map_err(|e| anyhow!("{e}"))?;
+
+        Ok(())
+    }
+}
+
+impl CompiledData {
+    fn cell_to_gds(&self, exporter: &mut GdsExporter, id: CellId) -> Result<()> {
+        trace!("Exporting cell {id}");
+        let cell = &self.cells[&id];
+        let name = &cell.scopes[&cell.root].name;
+        let re = Regex::new(r".*cell ([a-zA-Z0-9_]*)")?;
+        let caps = re.captures(name).ok_or_else(|| anyhow!("parse error"))?;
+        let name = caps.get(1).ok_or_else(|| anyhow!("parse error"))?.as_str();
+        let name = exporter.names.assign_name(id, name);
+        let mut ocell = GdsStruct::new(name.to_string());
+        for (_, obj) in &cell.objects {
+            match obj {
+                SolvedValue::Rect(rect) => {
+                    if rect.construction {
+                        continue;
+                    }
+                    if let Some(layer) = &rect.layer {
+                        let GdsLayerSpec {
+                            layer,
+                            xtype: datatype,
+                        } = exporter.map[layer];
+                        let x0 = rect.x0.0 as i32;
+                        let x1 = rect.x1.0 as i32;
+                        let y0 = rect.y0.0 as i32;
+                        let y1 = rect.y1.0 as i32;
+                        ocell.elems.push(GdsElement::GdsBoundary(GdsBoundary {
+                            layer,
+                            datatype,
+                            xy: vec![
+                                GdsPoint::new(x0, y0),
+                                GdsPoint::new(x0, y1),
+                                GdsPoint::new(x1, y1),
+                                GdsPoint::new(x1, y0),
+                            ],
+                            ..Default::default()
+                        }));
+                    }
+                }
+                SolvedValue::Instance(i) => {
+                    self.cell_to_gds(exporter, i.cell)?;
+                    ocell.elems.push(GdsElement::GdsStructRef(GdsStructRef {
+                        name: exporter.names.name(&i.cell).unwrap().to_string(),
+                        xy: GdsPoint::new(i.x as i32, i.y as i32),
+                        strans: Some(GdsStrans {
+                            reflected: i.reflect,
+                            abs_mag: false,
+                            abs_angle: false,
+                            mag: None,
+                            angle: Some(i.angle.degrees()),
+                        }),
+                        ..Default::default()
+                    }));
+                }
+                _ => {}
+            }
+        }
+        exporter.lib.structs.push(ocell);
+        Ok(())
+    }
+}