You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

223 lines
7.4 KiB
Python

#! /usr/bin/python
# -*- coding: utf-8 -*-
# Copyright © 2010 Eugeniy Meshcheryakov <eugen@debian.org>
# This file is licensed under GNU Lesser General Public License version 3 or later.
from __future__ import print_function
from gdsii.library import Library
from gdsii import elements
import sys
from yaml.dumper import Dumper
from yaml import events
# standard tags
STR = 'tag:yaml.org,2002:str'
TIMESTAMP = 'tag:yaml.org,2002:timestamp'
FLOAT = 'tag:yaml.org,2002:float'
INT = 'tag:yaml.org,2002:int'
SEQ = 'tag:yaml.org,2002:seq'
MAP = 'tag:yaml.org,2002:map'
# non-standard tags
LIBRARY = 'tag:gdsii,2010:library'
STRUCTURE = 'tag:gdsii,2010:structure'
BOUNDARY = 'tag:gdsii,2010:element:boundary'
PATH = 'tag:gdsii,2010:element:path'
SREF = 'tag:gdsii,2010:element:sref'
AREF = 'tag:gdsii,2010:element:aref'
TEXT = 'tag:gdsii,2010:element:text'
NODE = 'tag:gdsii,2010:element:node'
BOX = 'tag:gdsii,2010:element:box'
def emit_string(dumper, prop, tag, value):
dumper.emit(events.ScalarEvent(None, STR, (True, False), prop))
dumper.emit(events.ScalarEvent(None, tag, (True, False), value))
def start_named_seq(dumper, name):
dumper.emit(events.ScalarEvent(None, STR, (True, False), name))
dumper.emit(events.SequenceStartEvent(None, SEQ, True))
def end_named_seq(dumper):
dumper.emit(events.SequenceEndEvent())
def simple_dumper(name, tag):
def dump_fn(dumper, obj):
value = getattr(obj, name)
emit_string(dumper, name, tag, str(value))
return dump_fn
def simple_string_dumper(name):
def dump_fn(dumper, obj):
value = getattr(obj, name)
emit_string(dumper, name, STR, value.decode())
return dump_fn
def timestamp_dumper(name):
def dump_fn(dumper, obj):
value = getattr(obj, name)
emit_string(dumper, name, TIMESTAMP, value.isoformat(' '))
return dump_fn
def optional_dumper(name, tag):
def dump_fn(dumper, obj):
try:
value = getattr(obj, name)
except AttributeError:
value = None
if value is not None:
emit_string(dumper, name, tag, str(value))
return dump_fn
def optional_flags_dumper(name, tag):
def dump_fn(dumper, obj):
try:
value = getattr(obj, name)
except AttributeError:
value = None
if value is not None:
emit_string(dumper, name, tag, '0x%x'%value)
return dump_fn
def xy_dumper(name):
def dump_fn(dumper, obj):
points = getattr(obj, name)
start_named_seq(dumper, name)
for point in points:
dumper.emit(events.SequenceStartEvent(None, SEQ, True, flow_style=True))
dumper.emit(events.ScalarEvent(None, INT, (True, False), str(point[0])))
dumper.emit(events.ScalarEvent(None, INT, (True, False), str(point[1])))
dumper.emit(events.SequenceEndEvent())
end_named_seq(dumper)
return dump_fn
def properties_dumper(name):
def dump_fn(dumper, obj):
properties = getattr(obj, name)
if (properties):
start_named_seq(dumper, name)
for (prop, value) in properties:
dumper.emit(events.MappingStartEvent(None, MAP, True))
dumper.emit(events.ScalarEvent(None, INT, (True, False), str(prop)))
dumper.emit(events.ScalarEvent(None, STR, (True, False), value.decode()))
dumper.emit(events.MappingEndEvent())
end_named_seq(dumper)
return dump_fn
def strans_dumper(name):
my_dumper = optional_flags_dumper('strans', INT)
mag = optional_dumper('mag', FLOAT)
angle = optional_dumper('angle', FLOAT)
def dump_fn(dumper, obj):
try:
value = getattr(obj, name)
except AttributeError:
value = None
if value is not None:
my_dumper(dumper, obj)
mag(dumper, obj)
angle(dumper, obj)
return dump_fn
elflags = optional_flags_dumper('elflags', INT)
plex = optional_dumper('plex', INT)
layer = simple_dumper('layer', INT)
data_type = simple_dumper('data_type', INT)
path_type = optional_dumper('path_type', INT)
width = optional_dumper('width', INT)
bgn_extn = optional_dumper('bgn_extn', INT)
end_extn = optional_dumper('end_extn', INT)
struct_name = simple_string_dumper('struct_name')
strans = strans_dumper('strans')
cols = simple_dumper('cols', INT)
rows = simple_dumper('rows', INT)
text_type = optional_dumper('text_type', INT)
presentation = optional_flags_dumper('presentation', INT)
string = simple_string_dumper('string')
node_type = simple_dumper('node_type', INT)
box_type = simple_dumper('box_type', INT)
xy = xy_dumper('xy')
properties = properties_dumper('properties')
DUMPERS = (
(elements.Boundary, BOUNDARY, (elflags, plex, layer, data_type, xy, properties)),
(elements.Path, PATH, (elflags, plex, layer, data_type, path_type, width, bgn_extn, end_extn, xy, properties)),
(elements.SRef, SREF, (elflags, plex, struct_name, strans, xy, properties)),
(elements.ARef, AREF, (elflags, plex, struct_name, strans, cols, rows, xy, properties)),
(elements.Text, TEXT, (elflags, plex, layer, text_type, presentation, path_type, width, strans, xy, string, properties)),
(elements.Node, NODE, (elflags, plex, layer, node_type, xy)),
(elements.Box, BOX, (elflags, plex, layer, box_type, xy, properties))
)
def dump_element(dumper, elem):
for rec in DUMPERS:
if isinstance(elem, rec[0]):
tag = rec[1]
dumpers = rec[2]
dumper.emit(events.MappingStartEvent(None, tag, False))
for fn in dumpers:
fn(dumper, elem)
dumper.emit(events.MappingEndEvent())
break
else:
raise Exception('Unsupported element: %s' % str(elem))
name = simple_string_dumper('name')
mod_time = timestamp_dumper('mod_time')
acc_time = timestamp_dumper('acc_time')
strclass = optional_dumper('strclass', INT)
def dump_structure(dumper, struc):
dumper.emit(events.MappingStartEvent(None, STRUCTURE, False))
name(dumper, struc)
mod_time(dumper, struc)
acc_time(dumper, struc)
strclass(dumper, struc)
start_named_seq(dumper, 'elements')
for elem in struc:
dump_element(dumper, elem)
end_named_seq(dumper)
dumper.emit(events.MappingEndEvent())
physical_unit = simple_dumper('physical_unit', FLOAT)
logical_unit = simple_dumper('logical_unit', FLOAT)
libdirsize = optional_dumper('libdirsize', INT)
def dump_library(dumper, lib):
dumper.emit(events.StreamStartEvent(encoding='utf-8'))
dumper.emit(events.DocumentStartEvent(explicit=False))
dumper.emit(events.MappingStartEvent(None, LIBRARY, False))
emit_string(dumper, 'version', INT, '0x%x'%lib.version)
name(dumper, lib)
mod_time(dumper, lib)
acc_time(dumper, lib)
libdirsize(dumper, lib)
# TODO
physical_unit(dumper, lib)
logical_unit(dumper, lib)
start_named_seq(dumper, 'structures')
for struc in lib:
dump_structure(dumper, struc)
end_named_seq(dumper)
dumper.emit(events.MappingEndEvent())
dumper.emit(events.DocumentEndEvent(explicit=False))
dumper.emit(events.StreamEndEvent())
def main(name):
with open(name, 'rb') as a_file:
lib = Library.load(stream=a_file)
dumper = Dumper(sys.stdout)
dump_library(dumper, lib)
def usage(prog):
print('Usage: %s <file.gds>' % prog)
if __name__ == '__main__':
if (len(sys.argv) > 1):
main(sys.argv[1])
else:
usage(sys.argv[0])
sys.exit(1)
sys.exit(0)