558 lines
13 KiB
Go
558 lines
13 KiB
Go
///opt/local/bin/go run
|
|
// Copyright (C) 2014 Chris Hinsley.
|
|
|
|
//package name
|
|
package main
|
|
|
|
//package imports
|
|
import (
|
|
"./router"
|
|
"bufio"
|
|
"flag"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type tree struct {
|
|
value *string
|
|
branches []*tree
|
|
}
|
|
|
|
type point struct {
|
|
x float64
|
|
y float64
|
|
}
|
|
|
|
type pin struct {
|
|
form *string
|
|
angle float64
|
|
name *string
|
|
x float64
|
|
y float64
|
|
}
|
|
|
|
type component struct {
|
|
name *string
|
|
pin_map map[string]*pin
|
|
}
|
|
|
|
type instance struct {
|
|
name *string
|
|
comp *string
|
|
x float64
|
|
y float64
|
|
side *string
|
|
angle float64
|
|
}
|
|
|
|
type rule struct {
|
|
radius float64
|
|
gap float64
|
|
shape *[]point
|
|
}
|
|
|
|
type circuit struct {
|
|
via *string
|
|
rule *rule
|
|
}
|
|
|
|
func shape_to_cords(shape *[]point, a1, a2 float64) *router.Cords {
|
|
cords := router.Cords{}
|
|
rads := math.Mod(a1+a2, 2*math.Pi)
|
|
s := math.Sin(rads)
|
|
c := math.Cos(rads)
|
|
for _, p := range *shape {
|
|
px := (c*p.x - s*p.y)
|
|
py := (s*p.x + c*p.y)
|
|
cords = append(cords, &router.Cord{float32(px), float32(py)})
|
|
}
|
|
return &cords
|
|
}
|
|
|
|
func cords_equal(pc1, pc2 *router.Cords) bool {
|
|
if pc1 == pc2 {
|
|
return true
|
|
}
|
|
c1 := *pc1
|
|
c2 := *pc2
|
|
if len(c1) != len(c2) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(c1); i++ {
|
|
if c1[i].X != c2[i].X {
|
|
return false
|
|
}
|
|
if c1[i].Y != c2[i].Y {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func term_equal(pt1, pt2 *router.Terminal) bool {
|
|
if pt1 == pt2 {
|
|
return true
|
|
}
|
|
if !cords_equal(&pt1.Shape, &pt2.Shape) {
|
|
return false
|
|
}
|
|
if pt1.Radius != pt2.Radius {
|
|
return false
|
|
}
|
|
if pt1.Gap != pt2.Gap {
|
|
return false
|
|
}
|
|
if pt1.Term != pt2.Term {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func peek_char(r *bufio.Reader) (byte, bool) {
|
|
bytes, err := r.Peek(1)
|
|
if err != nil {
|
|
//eof
|
|
return ' ', true
|
|
}
|
|
return bytes[0], false
|
|
}
|
|
|
|
func read_char(r *bufio.Reader) (byte, bool) {
|
|
b, err := r.ReadByte()
|
|
if err != nil {
|
|
//eof
|
|
return ' ', true
|
|
}
|
|
return b, false
|
|
}
|
|
|
|
func read_whitespace(r *bufio.Reader) {
|
|
for {
|
|
b, eof := peek_char(r)
|
|
if eof {
|
|
return
|
|
}
|
|
if b != ' ' && b != '\t' && b != '\r' && b != '\n' {
|
|
return
|
|
}
|
|
read_char(r)
|
|
}
|
|
}
|
|
|
|
func peek_until(r *bufio.Reader, c byte) {
|
|
for {
|
|
b, eof := peek_char(r)
|
|
if eof {
|
|
return
|
|
}
|
|
if b == c {
|
|
return
|
|
}
|
|
read_char(r)
|
|
}
|
|
}
|
|
|
|
func read_until(r *bufio.Reader, c byte) {
|
|
for {
|
|
b, eof := read_char(r)
|
|
if eof {
|
|
return
|
|
}
|
|
if b == c {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func read_node_name(r *bufio.Reader) *string {
|
|
s := ""
|
|
for {
|
|
b, eof := peek_char(r)
|
|
if eof || b == '\t' || b == '\n' || b == '\r' || b == ' ' || b == ')' {
|
|
break
|
|
}
|
|
s += string(b)
|
|
read_char(r)
|
|
}
|
|
return &s
|
|
}
|
|
|
|
func read_string(r *bufio.Reader) *tree {
|
|
t := tree{nil, nil}
|
|
s := ""
|
|
for {
|
|
b, eof := peek_char(r)
|
|
if eof || b == '\t' || b == '\n' || b == '\r' || b == ' ' || b == ')' {
|
|
break
|
|
}
|
|
s += string(b)
|
|
read_char(r)
|
|
}
|
|
t.value = &s
|
|
return &t
|
|
}
|
|
|
|
func read_quoted_string(r *bufio.Reader) *tree {
|
|
t := tree{nil, nil}
|
|
s := ""
|
|
for {
|
|
b, eof := peek_char(r)
|
|
if eof || b == '"' {
|
|
break
|
|
}
|
|
s += string(b)
|
|
read_char(r)
|
|
}
|
|
t.value = &s
|
|
return &t
|
|
}
|
|
|
|
func read_tree(r *bufio.Reader) *tree {
|
|
read_until(r, '(')
|
|
read_whitespace(r)
|
|
t := tree{read_node_name(r), nil}
|
|
for {
|
|
read_whitespace(r)
|
|
b, eof := peek_char(r)
|
|
if eof {
|
|
break
|
|
}
|
|
if b == ')' {
|
|
read_char(r)
|
|
break
|
|
}
|
|
if b == '(' {
|
|
t.branches = append(t.branches, read_tree(r))
|
|
continue
|
|
}
|
|
if b == '"' {
|
|
read_char(r)
|
|
t.branches = append(t.branches, read_quoted_string(r))
|
|
read_char(r)
|
|
continue
|
|
}
|
|
t.branches = append(t.branches, read_string(r))
|
|
}
|
|
return &t
|
|
}
|
|
|
|
func search_tree(t *tree, s *string) *tree {
|
|
if t.value != nil {
|
|
if *t.value == *s {
|
|
return t
|
|
}
|
|
}
|
|
for _, ct := range t.branches {
|
|
st := search_tree(ct, s)
|
|
if st != nil {
|
|
return st
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func print_tree(t *tree, indent int) {
|
|
if t.value != nil {
|
|
for i := 0; i < indent; i++ {
|
|
fmt.Print(" ")
|
|
}
|
|
fmt.Print(*t.value, "\n")
|
|
}
|
|
for _, ct := range t.branches {
|
|
print_tree(ct, indent+1)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
//command line flags and defaults etc
|
|
arg_infile := os.Stdin
|
|
var arg_b int
|
|
flag.IntVar(&arg_b, "b", 0, "border gap, default 0")
|
|
flag.Parse()
|
|
|
|
//input reader from default stdin or given file
|
|
if flag.NArg() > 0 {
|
|
//read access
|
|
file, err := os.Open(flag.Args()[0])
|
|
if err != nil {
|
|
os.Exit(1)
|
|
}
|
|
arg_infile = file
|
|
}
|
|
reader := bufio.NewReader(arg_infile)
|
|
|
|
//create tree from input
|
|
tree := read_tree(reader)
|
|
|
|
ss := "structure"
|
|
structure_root := search_tree(tree, &ss)
|
|
num_layers := 0
|
|
minx := 1000000.0
|
|
miny := 1000000.0
|
|
maxx := -1000000.0
|
|
maxy := -1000000.0
|
|
for _, structure_node := range structure_root.branches {
|
|
if *structure_node.value == "layer" {
|
|
num_layers++
|
|
}
|
|
if *structure_node.value == "boundary" {
|
|
for _, boundary_node := range structure_node.branches {
|
|
if *boundary_node.value == "path" {
|
|
cords := boundary_node.branches[2:]
|
|
for i := 0; i < len(cords); i += 2 {
|
|
px, _ := strconv.ParseFloat(*cords[i].value, 32)
|
|
py, _ := strconv.ParseFloat(*cords[i+1].value, 32)
|
|
px /= 1000.0
|
|
py /= -1000.0
|
|
if px < minx {
|
|
minx = px
|
|
}
|
|
if px > maxx {
|
|
maxx = px
|
|
}
|
|
if py < miny {
|
|
miny = py
|
|
}
|
|
if py > maxy {
|
|
maxy = py
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ss = "library"
|
|
library_root := search_tree(tree, &ss)
|
|
component_map := map[string]*component{}
|
|
rule_map := map[string]*rule{}
|
|
for _, library_node := range library_root.branches {
|
|
if *library_node.value == "image" {
|
|
component_name := library_node.branches[0].value
|
|
component := component{component_name, map[string]*pin{}}
|
|
for _, image_node := range library_node.branches[1:] {
|
|
if *image_node.value == "pin" {
|
|
pin := pin{}
|
|
pin.form = image_node.branches[0].value
|
|
if *image_node.branches[1].value == "rotate" {
|
|
pin.angle, _ = strconv.ParseFloat(*image_node.branches[1].branches[0].value, 32)
|
|
pin.name = image_node.branches[2].value
|
|
pin.x, _ = strconv.ParseFloat(*image_node.branches[3].value, 32)
|
|
pin.y, _ = strconv.ParseFloat(*image_node.branches[4].value, 32)
|
|
pin.angle = pin.angle * (math.Pi / 180.0)
|
|
} else {
|
|
pin.angle = 0.0
|
|
pin.name = image_node.branches[1].value
|
|
pin.x, _ = strconv.ParseFloat(*image_node.branches[2].value, 32)
|
|
pin.y, _ = strconv.ParseFloat(*image_node.branches[3].value, 32)
|
|
}
|
|
pin.x /= 1000.0
|
|
pin.y /= -1000.0
|
|
component.pin_map[*pin.name] = &pin
|
|
}
|
|
}
|
|
component_map[*component_name] = &component
|
|
}
|
|
if *library_node.value == "padstack" {
|
|
for _, padstack_node := range library_node.branches[1:] {
|
|
if *padstack_node.value == "shape" {
|
|
points := []point{}
|
|
rule := rule{0.5, 0.125, nil}
|
|
if *padstack_node.branches[0].value == "circle" {
|
|
rule.radius, _ = strconv.ParseFloat(*padstack_node.branches[0].branches[1].value, 32)
|
|
rule.radius /= 2000.0
|
|
}
|
|
if *padstack_node.branches[0].value == "path" {
|
|
rule.radius, _ = strconv.ParseFloat(*padstack_node.branches[0].branches[1].value, 32)
|
|
rule.radius /= 2000.0
|
|
x1, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[2].value, 32)
|
|
y1, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[3].value, 32)
|
|
x2, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[4].value, 32)
|
|
y2, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[5].value, 32)
|
|
x1 /= 1000.0
|
|
y1 /= -1000.0
|
|
x2 /= 1000.0
|
|
y2 /= -1000.0
|
|
points = append(points, point{x1, y1})
|
|
points = append(points, point{x2, y2})
|
|
}
|
|
if *library_node.branches[1].branches[0].value == "rect" {
|
|
rule.radius = 0.0
|
|
x1, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[1].value, 32)
|
|
y1, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[2].value, 32)
|
|
x2, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[3].value, 32)
|
|
y2, _ := strconv.ParseFloat(*padstack_node.branches[0].branches[4].value, 32)
|
|
x1 /= 1000.0
|
|
y1 /= -1000.0
|
|
x2 /= 1000.0
|
|
y2 /= -1000.0
|
|
points = append(points, point{x1, y1})
|
|
points = append(points, point{x2, y1})
|
|
points = append(points, point{x2, y2})
|
|
points = append(points, point{x1, y2})
|
|
points = append(points, point{x1, y1})
|
|
}
|
|
rule.shape = &points
|
|
rule_map[*library_node.branches[0].value] = &rule
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ss = "placement"
|
|
placement_root := search_tree(tree, &ss)
|
|
instance_map := map[string]*instance{}
|
|
for _, placement_node := range placement_root.branches {
|
|
if *placement_node.value == "component" {
|
|
component_name := placement_node.branches[0].value
|
|
for _, component_node := range placement_node.branches[1:] {
|
|
if *component_node.value == "place" {
|
|
instance := instance{}
|
|
instance_name := component_node.branches[0].value
|
|
instance.name = instance_name
|
|
instance.comp = component_name
|
|
instance.x, _ = strconv.ParseFloat(*component_node.branches[1].value, 32)
|
|
instance.y, _ = strconv.ParseFloat(*component_node.branches[2].value, 32)
|
|
instance.side = component_node.branches[3].value
|
|
instance.angle, _ = strconv.ParseFloat(*component_node.branches[4].value, 32)
|
|
instance.angle = instance.angle * (math.Pi / 180.0)
|
|
instance.x /= 1000.0
|
|
instance.y /= -1000.0
|
|
instance_map[*instance_name] = &instance
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
all_terminals := router.Terminals{}
|
|
for _, instance := range instance_map {
|
|
component := component_map[*instance.comp]
|
|
for _, pin := range component.pin_map {
|
|
x := pin.x
|
|
y := pin.y
|
|
if *instance.side != "front" {
|
|
x = -x
|
|
}
|
|
s := math.Sin(instance.angle)
|
|
c := math.Cos(instance.angle)
|
|
px := (c*x - s*y) + instance.x
|
|
py := (s*x + c*y) + instance.y
|
|
pin_rule := rule_map[*pin.form]
|
|
tp := router.Tpoint{float32(px), float32(py), 0.0}
|
|
cords := shape_to_cords(pin_rule.shape, pin.angle, instance.angle)
|
|
all_terminals = append(all_terminals, &router.Terminal{float32(pin_rule.radius), float32(pin_rule.gap), tp, *cords})
|
|
if px < minx {
|
|
minx = px
|
|
}
|
|
if px > maxx {
|
|
maxx = px
|
|
}
|
|
if py < miny {
|
|
miny = py
|
|
}
|
|
if py > maxy {
|
|
maxy = py
|
|
}
|
|
}
|
|
}
|
|
|
|
ss = "network"
|
|
network_root := search_tree(tree, &ss)
|
|
circuit_map := map[string]*circuit{}
|
|
for _, network_node := range network_root.branches {
|
|
if *network_node.value == "class" {
|
|
net_rule := rule{0.125, 0.125, nil}
|
|
circuit := circuit{nil, &net_rule}
|
|
for _, class_node := range network_node.branches {
|
|
if *class_node.value == "rule" {
|
|
for _, dims := range class_node.branches {
|
|
if *dims.value == "width" {
|
|
net_rule.radius, _ = strconv.ParseFloat(*dims.branches[0].value, 32)
|
|
net_rule.radius /= 2000.0
|
|
}
|
|
if *dims.value == "clearance" {
|
|
net_rule.gap, _ = strconv.ParseFloat(*dims.branches[0].value, 32)
|
|
net_rule.gap /= 2000.0
|
|
}
|
|
}
|
|
}
|
|
if *class_node.value == "circuit" {
|
|
for _, circuit_node := range class_node.branches {
|
|
if *circuit_node.value == "use_via" {
|
|
circuit.via = circuit_node.branches[0].value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for _, netname := range network_node.branches {
|
|
if netname.branches == nil {
|
|
circuit_map[*netname.value] = &circuit
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tracks := make([]router.Track, 0)
|
|
for _, network_node := range network_root.branches {
|
|
if *network_node.value == "net" {
|
|
terminals := router.Terminals{}
|
|
for _, pin := range network_node.branches[1].branches {
|
|
pin_info := strings.Split(*pin.value, "-")
|
|
instance_name := pin_info[0]
|
|
pin_name := pin_info[1]
|
|
instance := instance_map[instance_name]
|
|
component := component_map[*instance.comp]
|
|
pin := component.pin_map[pin_name]
|
|
x := pin.x
|
|
y := pin.y
|
|
if *instance.side != "front" {
|
|
x = -x
|
|
}
|
|
s := math.Sin(instance.angle)
|
|
c := math.Cos(instance.angle)
|
|
px := (c*x - s*y) + instance.x
|
|
py := (s*x + c*y) + instance.y
|
|
pin_rule := rule_map[*pin.form]
|
|
tp := router.Tpoint{float32(px), float32(py), 0.0}
|
|
cords := shape_to_cords(pin_rule.shape, pin.angle, instance.angle)
|
|
term := router.Terminal{float32(pin_rule.radius), float32(pin_rule.gap), tp, *cords}
|
|
terminals = append(terminals, &term)
|
|
for i, t := range all_terminals {
|
|
if term_equal(t, &term) {
|
|
all_terminals = append(all_terminals[:i], all_terminals[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
circuit := circuit_map[*network_node.branches[0].value]
|
|
net_rule := circuit.rule
|
|
via_rule := rule_map[*circuit.via]
|
|
tracks = append(tracks, router.Track{float32(net_rule.radius), float32(via_rule.radius), float32(net_rule.gap), terminals})
|
|
}
|
|
}
|
|
tracks = append(tracks, router.Track{0.0, 0.0, 0.0, all_terminals})
|
|
|
|
border := float64(arg_b)
|
|
fmt.Print("[", int(maxx-minx+(border*2)+0.5), ",", int(maxy-miny+(border*2)+0.5), ",", num_layers, "]\n")
|
|
for _, track := range tracks {
|
|
fmt.Print("[", track.Radius, ",", track.Via, ",", track.Gap, ",[")
|
|
for i, term := range track.Terms {
|
|
fmt.Print("(", term.Radius, ",", term.Gap, ",(", term.Term.X-float32(minx-border), ",",
|
|
term.Term.Y-float32(miny-border), ",", term.Term.Z, "),[")
|
|
for j, cord := range term.Shape {
|
|
fmt.Print("(", cord.X, ",", cord.Y, ")")
|
|
if j != (len(term.Shape) - 1) {
|
|
fmt.Print(",")
|
|
}
|
|
}
|
|
fmt.Print("])")
|
|
if i != (len(track.Terms) - 1) {
|
|
fmt.Print(",")
|
|
}
|
|
}
|
|
fmt.Println("]]")
|
|
}
|
|
}
|