Portierung Klassen Phyton nach Delphi, GDS2 parser

[bernhard_LA]

ich bin dabei einen GDS2 ( http://boolean.klaasholwerda.nl/inte.../gdsformat.html) Parser in Delphi zu implementieren.
Als Referenz wollte ich mich an die freie Phyton Implementierung unter
http://pythonhosted.org/python-gdsii.../elements.html


anlehnen. Hierzu nun folgende Fragen zum Verständnis der phyton Syntax

Delphi-Quellcode:

aref ::=  AREF
          [ELFLAGS]
          [PLEX]
          SNAME
          [strans]
          COLROW
          XY
          [properties]
          ENDE

Bedeutet die Schreibweise [class] eine Klasse ist nur optional Bestandteil der Oberklasse? Wie würde ich dieses Verhalten am besten in Delphi codieren?

Delphi-Quellcode:

properties ::=  property*
property   ::=  PROPATTR
                PROPVALUE
strans     ::=  STRANS
                [MAG]
                [ANGLE

Was bedeutet property* als Definition und wie ist diese Klasse auf die Klassen property und strans verteilt ?

Delphi-Quellcode:

element ::=  aref |
             boundary |
             ....
             sref |
             text

bedeutet

Delphi-Quellcode:

sref |

sowas wie

Delphi-Quellcode:

sfref = array of TSref

?

[Sherlock]

Leicht OT: Ich habe jetzt die letzten 1,5 Jahre Python entwickelt. Ich wäre im Leben nicht darauf gekommen, daß die Schnipsel da Python sein sollen :shock:

Sherlock

[bernhard_LA]

wie würde eine Liste aus einer Kombination von Attributen und Attribut-Werten in Delphi aussehen um unterschiedliche Daten zu speichern ?

hier die Beschreibung der Python Implementierung :

Zitat:

properties
Element properties, represented as a list of tupes (propattr, propvalue). propattr is an int, propvalue is bytes. This attribute is optional

[Namenloser]

Das ist auch kein Python, sondern EBNF. Im dem Artikel findest du die Antworten auf deine Fragen.

Übrigens: Dein erster Link funktioniert nicht, da bekomme ich nur 404.

[bernhard_LA]

in der python version werden im source code records definiert. (siehe code ausschnitt)
der Zugriff auf ein record sollte über ein Attribut und dann auf die richtige Datenauswerte Logik erfolgen.

Info : Primar liegen alle Daten im Hex Format in einer GDS Datei vor, über ein Flag kann ich dann die richtige Interpretation der Daten vornehmen.


Wie würde man die Python Lösung in Delphi realisieren ?

Delphi-Quellcode:

class AbstractRecord(object):
    def __init__(self, variable):
        self.variable = variable

    def read(self, instance, gen):
        raise NotImplementedError

    def save(self, instance, stream):
        raise NotImplementedError

    def __repr__(self):
        return '<property: %s>'%self.variable

class SecondVar(object):
    """Class that simplifies second property support."""
    def __init__(self, variable2):
        self.variable2 = variable2

class SimpleRecord(AbstractRecord):
    def __init__(self, variable, gds_record):
        AbstractRecord.__init__(self, variable)
        self.gds_record = gds_record

    def read(self, instance, gen):
        rec = gen.current
        rec.check_tag(self.gds_record)
        rec.check_size(1)
        setattr(instance, self.variable, rec.data[0])
        gen.read_next()

    def save(self, instance, stream):
        record.Record(self.gds_record, (getattr(instance, self.variable),)).save(stream)

class SimpleOptionalRecord(SimpleRecord):
    def optional_read(self, instance, unused_gen, rec):
        """
        Called when optional tag is found. `rec` contains that tag.
        `gen` is advanced to next record befor calling this function.
        """
        rec.check_size(1)
        setattr(instance, self.variable, rec.data[0])

    def read(self, instance, gen):
        rec = gen.current
        if rec.tag == self.gds_record:
            gen.read_next()
            self.optional_read(instance, gen, rec)

    def save(self, instance, stream):
        data = getattr(instance, self.variable, None)
        if data is not None:
            record.Record(self.gds_record, (data,)).save(stream)

class OptionalWholeRecord(SimpleOptionalRecord):
    """Class for records that need to store all data (not data[0])."""
    def optional_read(self, instance, unused_gen, rec):
        setattr(instance, self.variable, rec.data)

    def save(self, instance, stream):
        data = getattr(instance, self.variable, None)
        if data is not None:
            record.Record(self.gds_record, data).save(stream)

class PropertiesRecord(AbstractRecord):
    def read(self, instance, gen):
        rec = gen.current
        props = []
        while rec.tag == tags.PROPATTR:
            rec.check_size(1)
            propattr = rec.data[0]
            rec = gen.read_next()
            rec.check_tag(tags.PROPVALUE)
            props.append((propattr, rec.data))
            rec = gen.read_next()
        setattr(instance, self.variable, props)

    def save(self, instance, stream):
        props = getattr(instance, self.variable)
        if props:
            for (propattr, propvalue) in props:
                record.Record(tags.PROPATTR, (propattr,)).save(stream)
                record.Record(tags.PROPVALUE, propvalue).save(stream)
.....
....

PS: der Link zur Erklärung GDS Format

http://boolean.klaasholwerda.nl/inte...gdsformat.html


GDS Dateien mit Delphi lesen : https://github.com/delphiEDA/gdsparser/