gds.go

package gds

import (
	"bufio"
	"fmt"
	"os"
)

// https://www.artwork.com/gdsii/gdsii/index.htm
// https://boolean.klaasholwerda.nl/interface/bnf/gdsformat.html
// http://bitsavers.informatik.uni-stuttgart.de/pdf/calma/GDS_II_Stream_Format_Manual_6.0_Feb87.pdf

func ReadGDS(f *os.File) (*Library, error) {
	var err error

	reader := bufio.NewReader(f)
	library, err := decodeLibrary(reader)
	if err != nil {
		return nil, err
	}
	return library, nil
}

func ReadRecords(f *os.File) ([]Record, error) {
	records := []Record{}
	reader := bufio.NewReader(f)
OuterLoop:
	for {
		record, err := decodeRecord(reader)
		if err != nil {
			return nil, err
		}
		records = append(records, *record)
		if record.Datatype == "ENDLIB" {
			break OuterLoop
		}
	}
	return records, nil
}

func WriteGDS(f *os.File, lib *Library) error {
	writer := bufio.NewWriter(f)
	records, err := lib.Records()
	if err != nil {
		return fmt.Errorf("could not write GDSII file: %v", err)
	}
	for _, record := range records {
		_, err := writer.Write(record.Bytes())
		if err != nil {
			return fmt.Errorf("could not write record %v to file: %v", record, err)
		}
	}
	writer.Flush()
	return nil
}

func (l Library) GetCellData(cell string) (*CellData, error) {
	data := &CellData{
		Layers:   []string{},
		Polygons: map[string]*PolygonLayer{},
		Paths:    map[string]*PathLayer{},
		Labels:   map[string]*LabelLayer{},
	}
	structure, ok := l.Structures[cell]
	if !ok {
		return nil, fmt.Errorf("cell with name %s does not exist", cell)
	}
	for _, element := range structure.Elements {
		if element.Type() == PolygonType {
			layer, ok := data.Polygons[element.GetLayer()]
			if ok {
				layer.appendPolygon(element.(Polygon).GetPoints())
			} else {
				data.Polygons[element.GetLayer()] = &PolygonLayer{Enabled: true, Polygons: [][]int32{element.(Polygon).GetPoints()}}
			}
		} else if element.Type() == PathType {
			layer, ok := data.Paths[element.GetLayer()]
			if ok {
				layer.appendPath(element.(*Path).XY, element.(*Path).Pathtype, element.(*Path).Width, element.(*Path).Bgnextn, element.(*Path).Endextn)
			} else {
				data.Paths[element.GetLayer()] = &PathLayer{
					Enabled:   true,
					Paths:     [][]int32{element.(*Path).XY},
					PathTypes: []int16{element.(*Path).Pathtype},
					ExtBegin:  []int32{element.(*Path).Bgnextn},
					ExtEnd:    []int32{element.(*Path).Endextn},
					Widths:    []int32{element.(*Path).Width},
				}
			}
		} else if element.Type() == LabelType {
			layer, ok := data.Labels[element.GetLayer()]
			points := element.(*Text).XY
			if ok {
				layer.appendLabel(points, element.(*Text).StringBody)
			} else {
				data.Labels[element.GetLayer()] = &LabelLayer{
					Enabled:     true,
					Labels:      []string{element.(*Text).StringBody},
					LabelCoords: [][]int32{points},
				}
			}
		} else if element.Type() == SRefType {
			resolveSRef(&l, data, []Reference{element.(*SRef)})
		} else if element.Type() == ARefType {
			resolveARef(&l, data, []Reference{element.(*ARef)})
		}
	}

	data.PopulateLayers()
	return data, nil
}

func (l Library) GetLayermapPolygons(cell string) (map[string]*PolygonLayer, error) {
	result := map[string]*PolygonLayer{}
	structure, ok := l.Structures[cell]
	if !ok {
		return map[string]*PolygonLayer{}, fmt.Errorf("cell with name %s does not exist", cell)
	}
	for _, element := range structure.Elements {
		if element.Type() == PolygonType {
			layer, ok := result[element.GetLayer()]
			if ok {
				layer.appendPolygon(element.(Polygon).GetPoints())
			} else {
				result[element.GetLayer()] = &PolygonLayer{Enabled: true, Polygons: [][]int32{element.(Polygon).GetPoints()}}
			}
		} else if element.Type() == SRefType {
			resolveSRef(&l, result, []Reference{element.(*SRef)})
		} else if element.Type() == ARefType {
			resolveARef(&l, result, []Reference{element.(*ARef)})
		}
	}
	return result, nil
}

func (l Library) GetLayermapPaths(cell string) (map[string]*PathLayer, error) {
	result := map[string]*PathLayer{}
	structure, ok := l.Structures[cell]
	if !ok {
		return map[string]*PathLayer{}, fmt.Errorf("cell with name %s does not exist", cell)
	}
	for _, element := range structure.Elements {
		if element.Type() == PathType {
			layer, ok := result[element.GetLayer()]
			if ok {
				layer.appendPath(element.(*Path).XY, element.(*Path).Pathtype, element.(*Path).Width, element.(*Path).Bgnextn, element.(*Path).Endextn)
			} else {
				result[element.GetLayer()] = &PathLayer{
					Enabled:   true,
					Paths:     [][]int32{element.(*Path).XY},
					PathTypes: []int16{element.(*Path).Pathtype},
					ExtBegin:  []int32{element.(*Path).Bgnextn},
					ExtEnd:    []int32{element.(*Path).Endextn},
					Widths:    []int32{element.(*Path).Width},
				}
			}
		} else if element.Type() == SRefType {
			resolveSRef(&l, result, []Reference{element.(*SRef)})
		} else if element.Type() == ARefType {
			resolveARef(&l, result, []Reference{element.(*ARef)})
		}
	}
	return result, nil
}

func (l Library) GetLayermapLabels(cell string) (map[string]*LabelLayer, error) {
	result := map[string]*LabelLayer{}
	structure, ok := l.Structures[cell]
	if !ok {
		return map[string]*LabelLayer{}, fmt.Errorf("cell with name %s does not exist", cell)
	}
	for _, element := range structure.Elements {
		if element.Type() == LabelType {
			layer, ok := result[element.GetLayer()]
			points := element.(*Text).XY
			if ok {
				layer.appendLabel(points, element.(*Text).StringBody)
			} else {
				result[element.GetLayer()] = &LabelLayer{
					Enabled:     true,
					Labels:      []string{element.(*Text).StringBody},
					LabelCoords: [][]int32{points},
				}
			}
		} else if element.Type() == SRefType {
			resolveSRef(&l, result, []Reference{element.(*SRef)})
		} else if element.Type() == ARefType {
			resolveARef(&l, result, []Reference{element.(*ARef)})
		}
	}
	return result, nil
}