Station - Ein Interpreter für DiagramML

Verarbeitung von DiagramML-Dokumenten

Ein XML-Dokument ist zunächst nur eine textuelle Darstellung von Information, die nach den Regeln von XML - und gegebenenfalls einer Dokumenttypdefinition - erstellt ist.

<?xml version="1.0" encoding="iso-8859-1"?>
<diagramm>
  <stabdiagramm>
    <breite>4</breite>
    <einheit>4</einheit>
    <abstand>16</abstand>
    <farbe>blau</farbe>
    <wert>-3.6</wert>
    <wert>-0.5</wert>
    <wert>4.2</wert>
    <wert>8.7</wert>
    <wert>10.4</wert>
    <wert>16.3</wert>
    <wert>20.3</wert>
    <wert>16.7</wert>
    <wert>12.4</wert>
    <wert>8.1</wert>
    <wert>4.8</wert>
    <wert>-3.7</wert>
  </stabdiagramm>
</diagramm>

Mit einer solchen textuellen Darstellung ist zunächst noch keine spezielle Verarbeitung verknüpft. So zeigt ein Browser ein DiagramML-Dokument als XML-Baum an, nicht jedoch in Form eines Stabdiagramms.

Darstellung in einem Browser

Ein Browser "weiß" nicht, was die einzelnen XML-Elemente bedeuten. Die Situation ändert sich, wenn man spezielle Programme zur Verarbeitung von DiagramML-Dokumenten entwickelt.

Ein Interpreter zur Verarbeitung von DiagramML-Dokumenten

Ein Interpreter für DiagramML-Dokumente ist ein Programm, das DiagramML so verarbeitet, wie es bei für die Sprache DiagramML beabsichtigt ist.

Ein Interpreter für DiagramML-Dokumente erstellt aus einer textuellen Beschreibung eines Stabdiagramms eine bildliche Darstellung des Stabdiagramms.

Das folgende Python-Programm liefert einen sehr einfachen Interpreter für DiagramML-Dokumente.

from turtle import *
t = Turtle()

from xml.dom.minidom import *

# Verarbeitung von DiagrammXML-Dokumenten

def zeichneStab(breite, hoehe, farbe):
    t.down()
    t.color(farbe)
    t.begin_fill()
    t.forward(breite)
    t.left(90)
    t.forward(hoehe)
    t.left(90)
    t.forward(breite)
    t.left(90)
    t.forward(hoehe)
    t.left(90)
    t.end_fill()
    t.up()

def geheZurAusgansposition():
    t.hideturtle()

def geheZurNaechsteAusgangsposition(abstand):
    t.up()
    t.forward(abstand)
    t.down()

def verarbeiteStabdiagramm(knoten):
    kBreite = knoten.getElementsByTagName("breite")
    kEinheit = knoten.getElementsByTagName("einheit")
    kAbstand = knoten.getElementsByTagName("abstand")
    kFarbe = knoten.getElementsByTagName("farbe")
    kListeDaten = knoten.getElementsByTagName("wert")
    breite = int(kBreite[0].firstChild.data)
    einheit = int(kEinheit[0].firstChild.data)
    abstand = int(kAbstand[0].firstChild.data)
    farbname = kFarbe[0].firstChild.data
    if farbname == 'blau':
        farbe = 'blue'
    elif farbname == 'rot':
        farbe = 'red'
    elif farbname == 'gruen':
        farbe = 'green'
    elif farbname == 'gelb':
        farbe = 'yellow'
    elif farbname == 'weiss':
        farbe = 'white'
    elif farbname == 'schwarz':
        farbe = 'black'
    listeDaten = []
    for k in kListeDaten:
        datum = float(k.firstChild.data)
        listeDaten = listeDaten + [datum]
    geheZurAusgansposition()
    for datum in listeDaten:
        zeichneStab(breite, datum*einheit, farbe)
        geheZurNaechsteAusgangsposition(abstand)
        
def verarbeitenDiagrammXML(quelltext):
    dokument = parseString(quelltext)
    kStabdiagramm = dokument.getElementsByTagName("stabdiagramm")
    for k in kStabdiagramm:
        verarbeiteStabdiagramm(k)

# Test
f_xml = open("diagramm1.xml", "r")
xml_quelltext = f_xml.read()
verarbeitenDiagrammXML(xml_quelltext)

Aufgabe 1

Teste den DiagramML-Interpreter mit verschiedenen DiagramML-Dokumenten.

Hinweis: Das gezeigte Programm öffnet ein neues Fenster und zeichne das gewünschte Stabdiagramm mit dem in Python integrierten Turtle-Grafik-Modul. Das Grafikfenster schließt man mit den Befehl bye().

>>> bye()

Klärung der Bedeutung von Sprachelemente

Interpreter benutzt man auch, um die Bedeutung von Sprachelementen präzise festzulegen.

Im Fall der Sprache DiagramML wird die Bedeutung der einzelnen XML-Elemente durch die Tagbezeichner suggestiv vorgegeben. Dennoch bleibt auch hier einiges im Unklaren, z.B.:

Klarheit erhält man erst, wenn man die Bedeutung der einzelnen DiagramML-Elemente verbal weiter präzisiert oder einen Interpreter entwickelt, der über die Verarbeitung des DiagramML-Dokuments implizit die Bedeutung aller DiagramML-Elemente vorgibt.

X

Fehler melden

X

Suche