simstim.py

download

#!/user/freepool/local/bin/python2.3
# -*- coding: Latin-1 -*-
#!/bin/env python2.3
#pysource: /user/freepool/libgrafen/python/grafen/eastools/simstim-0.1/simstim.py

"""\
Funktion:
%(PROGNAME)s enthält Funktionen um das Spezifikations-Verzeichnis
(Default = ./stim) für eine Simulation zu verwalten. Im Simulations-Skript
können die Funktionen nach Bedarf zusammengesetzt werden.

Stimuli und Ausgabedateien werden automatisch aus angegebenen VHDL87/93
Dateien gelesen als Parameter für verschiedene Operationen. Damit wird eine
individuelle Anpassung des Sim-Skriptes oft hinfällig.

Future Feature: Benannte Pipes
Wenn der Plattenplatz eng wird können benannte Pipes verwendet werden.
s.a. --help-named-pipes

Voraussetzungen:
- Betriebssystem ist Unix/Posix-konform
- Das sim-Verzeichnis entspricht den Designrules.
s.a. '%(PROGNAME)s --help-designrules'

** Bitte folgende Designrules beachten **:
- ist <SPEC_DIR> zum Spezifikations-Verzeichnis gelinkt darf kein
<SPEC_DIR>/_[\w_]+_ Pfad bestehen.

- Im Fall daß Links im Spezifikations-Verzeichnis auf die Dateien im
Remote- Verzeichnis zeigen soll ein Link <SPEC_DIR>/_spec_link_ auf
das Remote-Verzeichnis angelegt werden.

- Im Fall daß man selbst der Bearbeiter ist soll die (leere) Datei
<SPEC_DIR>/_no_reference_test_specified_ angelegt werden.

- Im Fall daß man <SPEC_DIR> in den IC-Account importiert hat soll die
(leere) Datei <SPEC_DIR>/_imported_ angelegt werden.
Beispiele:

Folgende Arbeitsschritte behandeln <SPEC_DIR>s mit gzippte, ungezippten oder
gemischt gezippten Inhalten immer richtig.

(1)
# preprocess
%(PROGNAME)s --remove-vhdl-output-paths
%(PROGNAME)s --prepare-spec-dir-for-simulation

# ** Starte Simulation hier **

# postprocess
%(PROGNAME)s --clean-spec-dir-from-unzipped-files

# ** Wähle eines der folgenden Kommandos **
%(PROGNAME)s --gzip-vhdl-output-paths
%(PROGNAME)s --remove-vhdl-output-paths

(2)
# preprocess
%(PROGNAME)s --remove-vhdl-output-paths --prepare-spec-dir-for-simulation

# -- Starte Simulation hier --

# postprocess
%(PROGNAME)s --clean-spec-dir-from-unzipped-files --remove-vhdl-output-paths
"""

help_designrules = """\
Designrules zum Aufbau des Spezifikations-Verzeichnisses:
a Default: SPEC_DIR = "./stim"
b Enthält nur Dateien vom Spezifizierer (also keine hand- oder skript-
modifizierten Dateien)

c enthält mindestens die Parameter, Stimuli, Responses und Zwischenwerte für
das entsprechende Modul.

d <SPEC_DIR> ist eins von d1 ... d4, in <SPEC_DIR> darf nur eine '_[\w_]+_'
Datei existieren:
d1 *vorzugsweise* ein Link zum Verzeichnis des Spezifizierers oder
** Achtung **: In diesem Fall darf keine '_[\w_]+_' in <SPEC_DIR>
existieren!

d2 im Verzeichnis <SPEC_DIR>./stim zeigen Links auf die Dateien des
Spezifizierers mit Ausnahme der geunzip-ten Dateien die temporär während
einer Simulation entstehen können und nach fehlerfreier Simulation wieder
gelöscht werden müssen.
** Achtung **: In diesem Fall soll <SPEC_DIR>/_spec_link_ als Link auf
das Remote-Verzeichnis angelegt werden!

d3 ist der Bearbeiter eines VHDL-Modules gleichzeitig der Spezifizierer, kann
das Spezifikations-Verzeichnis ungelinkte Parameter, Stimuli, Responses
und Zwischenwerte enthalten.
** Achtung **: In diesem Fall soll <SPEC_DIR>/_no_reference_test_specified
als (leere) Datei angelegt werden!

d4 das Modul ist in den IC-Account (z.B. /user/rxpro5) importiert worden.
** Achtung **: In diesem Fall soll <SPEC_DIR>/_imported_ als leere Datei
angelegt werden!

e Innerhalb eines tb-Verzeichnisses sollen alle Spezifikations-Verzeichnisse
gleichnamige Dateien enthalten.
"""

help_named_pipes = """\
Bemerkungen zur Verwendung von Named Pipes:
Wegen den untenstehenden Nachteilen von benannten Pipes sollten diese nur
dann verwendt werden, wenn sie wesentliche Vorteile bringen.

Große Dateien belegen unkomprimiert viel Speicherplatz auf dem Dateisystem.
Liest bzw. schreibt eine Anwendung direkt aus/in komprimierte Dateien wird
in der Regel kein zusätzlicher Speicherplatz benötigt. Wenn die Anwendung
(Simulator) keine komprimierten Dateien bearbeiten kann besteht unter Unix
die Möglichkeit, mit Hilfe von benamten Pipes die Anwendung zu unterstützen:

- Anwendung liest über infile.dat von komprimierter Datei infile.dat.gz:
mkfifo infile.dat; cat infile.dat.gz | gunzip >! infile.dat &

- Anwendung schreibt über outfile.dat in komprimierte Datei outfile.dat.gz:
mkfifo outfile.dat; cat outfile.dat | gzip >! outfile.dat.gz &

Vorteil:
- Der Kode in der Applikation muß nicht angepaßt werden.
- Kein zusätzlicher Plattenspeicherbedarf
- Es kann Zeit und Resourcen gespart werden, wenn die Datei nur teilweise
gelesen wird.

Nachteil:
- Pro benannter Pipe entsteht ein Prozess.
- Die Pipes dürfen nur von der vorgesehenen Applikation angesprochen werden.
Ein Konflikt entsteht beispielsweise, wenn man mit wc -l * prüft oder
diff verwendet ohne die Pipe zu reinitialisieren. In diesem Fall hängt der
Prozess.
"""

__version__ = "0.1"
__author__ = "Wolfgang Grafen"

VERBOSE = 0
SPEC_DIR = "stim"
REMOTE_DIR = None
USE_NAMED_PIPES = 0
VHDL_ARCHITECTURE_PATHS = []
EXAMPLE_SIMSKRIPT = ("/user/freepool/libgrafen/python/grafen/"
"eastools/simstim-0.1/slope_ed_tb2-a0-c0-cf.sim"
)

#PROGNAME = '?'

try:
from optik import OptionParser
from optik.help import IndentedHelpFormatter
except:
from optparse import OptionParser
from optparse import IndentedHelpFormatter

import os
import sys
import re

from os import listdir, curdir, readlink, symlink, remove, system, getcwd
from os.path import exists, isdir, islink, isfile, isabs
from os.path import join, basename, dirname, normpath
from sets import Set
from glob import glob

re_filterpaths = re.compile("^[^_\.][^~]*?\Z").match
re_gzip = re.compile("^.*?\.gz\Z").match

re_infile_vhdl87 = re.compile("\s*file\s+"
"(?P<fp>\w+)"
"\s*:\s*"
"(?P<datatype>[\w_]+)"
"\s+is\s+"
"(?P<mode>in)\s+"
'"(?P<fname>[^"]+)"'
"\s*;",re.I|re.M)

re_infile_vhdl93 = re.compile("\s*file\s+"
"(?P<fp>\w+)"
"\s*:\s*"
"(?P<datatype>[\w_]+)"
"\s+open\s+"
"(?P<filekind>read_mode)\s+"
"is\s+"
'"(?P<fname>[^"]+)"'
"\s*;",re.I|re.M)

re_outfile_vhdl87 = re.compile("\s*file\s+"
"(?P<fp>\w+)"
"\s*:\s*"
"(?P<datatype>[\w_]+)"
"\s+is\s+"
"(?P<mode>out)\s+"
'"(?P<fname>[^"]+)"'
"\s*;",re.I|re.M)

re_outfile_vhdl93 = re.compile("\s*file\s+"
"(?P<fp>\w+)"
"\s*:\s*"
"(?P<datatype>[\w_]+)"
"\s+open\s+"
"(?P<filekind>(?:(?:write)|(?:append))_mode)\s+"
"is\s+"
'"(?P<fname>[^"]+)"'
"\s*;",re.I|re.M)

def verbose(txt):
if VERBOSE:
print txt

def ssystem(cmds,parm=''):
kw = {'p' : parm, 'n' : '\n'}

if type(cmds) == type(''):
cmds = [cmds % kw]

for cmd in cmds:
cmd %= kw
verbose(cmd)
tst = system(cmd)
#if tst:
# raise IOError,"%s: '%s' failed" % (tst,cmd)

return tst

def __init__():
"Ermittle den relativen Pfad von <SPEC_DIR> und weise ihn der\n" \
"globalen Variablen SPEC_DIR zu."
global REMOTE_DIR

try:
REMOTE_DIR = get_remote_dir()

except ValueError:
relink_spec_dir_as_link()
REMOTE_DIR = get_remote_dir()

def readlink_base(path):
"Ermittle den Endpunkt (rekursiv) eines Links."
while exists(path) and islink(path):
path = readlink(path)

return path

def get_pathlist(path,
filterpaths = re_filterpaths):

"Gibt eine Liste des Verzeichnisinhaltes zurück. Nicht enthalten\n" \
"sind Dateien, die mit '.' oder '_' beginnen oder '~' enthalten."
basenames = filter(filterpaths,listdir(path))
paths = Set([join(path,basename) for basename in basenames])

return paths

def relink_spec_dir_as_link():

try:
spec_dir_state = get_spec_dir_state()

if spec_dir_state == '_no_reference_test_specified' or \
spec_dir_state == '_imported_':
return

except ValueError:
pass

if not islink(SPEC_DIR):
for p in get_pathlist(SPEC_DIR):
if islink(p):
link_dirname = dirname(readlink(p))
ssystem("\\rm -r %s" % SPEC_DIR)
ssystem("\ln -s %s %s" % (link_dirname,SPEC_DIR))
return

else:
raise IOError,"Kann Link von %s nicht ermitteln" % SPEC_DIR

def get_spec_dir_state():
"Ermittelt den Status des Spezifikationsverzeichnisses SPEC_DIR"

select = (
(islink,"" ,"linked_dir_to_specifier"),
(None, "_no_reference_test_specified_","owned_dir_by_specfier"),
(None, "_spec_link_","owned_dir_contents_linked_to_specifier"),
(None, "_imported_" ,"owned_dir_by_iclib")
)

if isdir(SPEC_DIR):
verbose("ls %s" % SPEC_DIR)
for tst,basename,state in select:
if tst:
if not tst(SPEC_DIR):
continue

tst_path = join(SPEC_DIR,basename)

if exists(tst_path):
spec_dir_state = state
verbose("spec_dir_state: %s" % spec_dir_state)
return spec_dir_state

raise ValueError,(
"SPEC_DIR %s must contain one Filename out of "
"(_no_reference_test_specified_,_spec_link_,_imported_),\n"
"Please refer to --help-designrules") % SPEC_DIR

raise ValueError,"SPEC_DIR %s is not a Link or Directory" % SPEC_DIR

def get_remote_dir():
"Ermittelt das Remote Verzeichnis von <SPEC_DIR>."

remote_dir = None

spec_dir_state = get_spec_dir_state()
if spec_dir_state == "linked_dir_to_specifier":
remote_dir = readlink_base(SPEC_DIR)

elif spec_dir_state == "owned_dir_by_specfier":
remote_dir = SPEC_DIR

elif spec_dir_state == "owned_dir_contents_linked_to_specifier":
rl = join(SPEC_DIR,"_spec_link_")
remote_dir = readlink_base(rl)

elif spec_dir_state == "owned_dir_by_iclib":
rl = join(SPEC_DIR,"_imported_")
remote_dir = SPEC_DIR

else:
raise ValueError,"This branch should never be reached, fix Code!"

verbose("remote_dir : %s" % remote_dir)
assert remote_dir,"ValueError: remote_dir => %s" % repr(remote_dir)
return remote_dir

def create_where_links(remote_dir,
where_dir):

"Ermittelt alle Pfade in <remote_dir> und erzeugt Links in <where_dir>."

if not isabs(remote_dir):
remote_dir = normpath(join(getcwd(),remote_dir))
#assert isabs(remote_dir),(
# "Please specify remote_dir %s as an absolute path!" % remote_dir)

remote_basenames = Set([basename(p) for p in get_pathlist(remote_dir)])
where_basenames = Set([basename(p) for p in get_pathlist(where_dir)])

new_links = remote_basenames - where_basenames

for lnk in new_links:
remote_path = join(remote_dir,lnk)
where_path = join(where_dir,lnk)
verbose("ln -s %s %s" % (remote_path,where_path))
symlink(remote_path,where_path)

def remove_paths(basenames,where_dir):

"Enfernt <basenames> in <where_dir>"

for bname in basenames:
b = join(where_dir,bname)
if exists(b):
verbose("remove %s" % b)
remove(b)

def gzip_paths(paths):

"Komprimiert mit gzip jeden <Pfad> in <paths> wenn <Pfad> existiert\n" \
"und eine Datei ist."

for p in paths:
if exists(p) and isfile(p):
ssystem ("gzip %s" % p)

def gunzip_paths(paths):

"Entkomprimiert jeden <Pfad> in <paths> wenn <Pfad> existiert und eine\n" \
"gzip-Datei ist."

gzipped_paths = filter(re_gzip,paths)
rawpaths = list(Set(paths) - Set(gzipped_paths))

x = rawpaths[0]
for p in rawpaths:
if exists(p + '.gz'):
gzipped_paths.append(p + '.gz')

for gzipped_path in gzipped_paths:
gunzipped_path = gzipped_path[:-3]

if not exists(gunzipped_path):
gzipped_path_base = readlink_base(gzipped_path)
ssystem ("gunzip --to-stdout %s > %s" % (gzipped_path_base,
gunzipped_path))

def remove_gunzip_paths(paths):

"Entkomprimiert jeden <Pfad> in <Paths> wenn <Pfad> existiert und eine\n" \
"gzip-Datei ist."

gzipped_paths = filter(re_gzip,paths)

for gzipped_path in gzipped_paths:
unzipped_path = gzipped_path[:-3]

if exists(unzipped_path):
verbose("remove %s" % unzipped_path)
remove(unzipped_path)

def convert_linkeddir_to_dir(where_dir):
"Wandelt das gelinktes Verzeichnis <where_dir> in ein ungelinktes um\n" \
"und erzeugt Links für alle Pfade in <where_dir>."

if islink(where_dir) and isdir(where_dir):
remote_dir = readlink_base(where_dir)
remote_paths = get_pathlist(remote_dir)

verbose("remove %s" % where_dir)
remove(where_dir)

ssystem("mkdir %s" % where_dir)
create_where_links(remote_dir,where_dir)

# create _spec_link_
rl = join(where_dir,"_spec_link_")
verbose("ln -s %s %s" % (remote_dir,rl))
symlink(remote_dir,rl)

else:
raise ValueError,"'%s' is not a directory or is not linked."

def mirror_remote_paths(remote_dir,where_dir):
"Spiegelt <remote_dir> zu <where_dir>."

remote_basenames = Set([basename(p) for p in get_pathlist(remote_dir)])
where_basenames = Set([basename(p) for p in get_pathlist(where_dir)])

same_basenames = remote_basenames & where_basenames

remove_paths(where_basenames - remote_basenames,where_dir)
create_where_links(remote_dir,where_dir)

def prepare_spec_dir_for_simulation():

"Bereitet <SPEC_DIR> für die Simulation vor, entkomprimiert alle\n" \
"gzip-Dateien die in <vhdl_architecture_paths> geöffnet werden,\n" \
"entfernt Fremddateien."

verbose(
"prepare <SPEC_DIR> for simulation, decompress .gzip files, remove foreign\n" \
"files, remove VHDL-Output-Files, remove ext VHDL-OUTPUT-Files ...")

if REMOTE_DIR:
if islink(SPEC_DIR):
convert_linkeddir_to_dir(SPEC_DIR)

else:
mirror_remote_paths(REMOTE_DIR,SPEC_DIR)

#gunzip_paths(get_pathlist(SPEC_DIR))

for vname in VHDL_ARCHITECTURE_PATHS:
innames = get_vhdl_input_paths_from(vname)
gunzip_paths(innames)

for vname in VHDL_ARCHITECTURE_PATHS:
onames = get_vhdl_output_paths_from(vname)
remove_paths(onames,curdir)

for vname in VHDL_ARCHITECTURE_PATHS:
remove_vhdl_output_paths_from(vname)

remove_ext_vhdl_output_paths()

def clean_spec_dir_from_unzipped_files():
"Entfernt alle gunzip-ten Dateien innerhalb <SPEC_DIR>, falls\n" \
"<DATEINAME> und <DATEINAME>.gz existiert."
verbose("clean %s from unzipped files ..." % SPEC_DIR)

remove_gunzip_paths(get_pathlist(SPEC_DIR))

def get_vhdl_input_paths_from(vhdl_architecture_path):

"Ermittelt alle Eingabedateien aus <vhdl_architecture_path>"

verbose("parse %s for input paths ..." % vhdl_architecture_path)
t = open(vhdl_architecture_path).read()
infiles87 = [x[-1] for x in re_infile_vhdl87.findall(t)]
infiles93 = [x[-1] for x in re_infile_vhdl93.findall(t)]

infiles = infiles87 + infiles93

return infiles

def get_vhdl_output_paths_from(vhdl_architecture_path):

"Ermittelt alle Ausgabedateien aus <vhdl_architecture_path>"

verbose("parse %s for output paths ..." % vhdl_architecture_path)
t = open(vhdl_architecture_path).read()
outfiles87 = [x[-1] for x in re_outfile_vhdl87.findall(t)]
outfiles93 = [x[-1] for x in re_outfile_vhdl93.findall(t)]

outfiles = outfiles87 + outfiles93

return outfiles

def get_resp_ref_paths():
"Ermittelt Referenz- und Responsedateien paarweise aus <VHDL_ARCHITECTURE_PATHS>.\n" \
"Gibt [[<REFDATPATH>,<RESPDATPATH>]...] zurück."

kdict = {}
yalist = []
xalist = []
for f in VHDL_ARCHITECTURE_PATHS:
yalist += get_vhdl_input_paths_from(f)
xalist += get_vhdl_output_paths_from(f)

for n in yalist + xalist:
tst = basename(n).split('.')
if len(tst) == 2:
key,ext = tst
key = key.lower()

if not kdict.has_key(key):
kdict[key] = [n]

else:
kdict[key].append(n)

for k,v in kdict.items():
val = Set(v)
if len(val) == 1:
del kdict[k]

elif len(val) > 2:
raise ValueError,(
"More than 2 Files with the same name found % s" % v)

else:
kdict[k] = v

return kdict.values()

def get_ext_resp_ref_paths():
"Ermittelt Referenz- und Responsedateien paarweise wenn nicht in\n" \
"<VHDL_ARCHITECTURE_PATHS> enthalten aber in <SPEC_DIR> und den\n" \
"Ausgabeverzeichnissen ermittelt mit <VHDL_ARCHITECTURE_PATHS> gefunden.\n" \
"Gibt [[<REFDATPATH>,<RESPDATPATH>]...] zurück."

kdict = {}
ikdict = {}
okdict = {}
xalist = []
for f in VHDL_ARCHITECTURE_PATHS:
xalist += get_vhdl_output_paths_from(f)

ipaths = filter(isfile,[join(SPEC_DIR,n) for n in listdir(SPEC_DIR)])
odirs = [dirname(f) for f in xalist]
opaths = []

for odir in Set(odirs):
if odir == '':
odir = curdir
opaths += filter(isfile,[join(odir,n) for n in listdir(odir)])

for n in ipaths:
tst = basename(n).split('.')
if len(tst) >= 2:
if len(tst) == 3 and tst[-1] == 'gz':
pass

elif len(tst) > 2:
continue

key,ext = tst[0],tst[1:]
key = key.lower()

if not ikdict.has_key(key):
ikdict[key] = [n]

else:
ikdict[key].append(n)

for k,v in ikdict.items():
if len(v) == 2:
for n in v:
tst = basename(n).split('.')
# Remove .gz when unzipped available
if len(tst) == 3:
v.remove(n)
break

if len(v) > 1:
raise ValueError,(
"Cannot uniquify % s" % v)

for n in opaths:
tst = basename(n).split('.')
if len(tst) >= 2:
if len(tst) == 3 and tst[-1] == 'gz':
pass

elif len(tst) > 2:
continue

key,ext = tst[0],tst[1:]
key = key.lower()

if not okdict.has_key(key):
okdict[key] = [n]

else:
okdict[key].append(n)

for k,v in okdict.items():
if len(v) == 2:
for n in v:
tst = basename(n).split('.')
# Remove .gz when unzipped available
if len(tst) == 3:
v.remove(n)
break

# Forget all pairs without .gz in outputs
if len(v) > 1:
del okdict[k]

for i in ikdict.keys():
if okdict.has_key(i):
kdict[i] = ikdict[i][0],okdict[i][0]

resp_ref_paths = get_resp_ref_paths()

for n1,n2 in resp_ref_paths:
tst = basename(n1).split('.')
key,ext = tst
key = key.lower()

if kdict.has_key(key):
del kdict[key]

return kdict.values()

def remove_vhdl_output_paths_from(vhdl_architecture_path):

"Löscht alle Ausgabedateien aus <vhdl_architecture_path>."

verbose("remove VHDL output paths in %s ..." % vhdl_architecture_path)

outfiles = get_vhdl_output_paths_from(vhdl_architecture_path)

relnames = ["%s.gz" % p for p in outfiles] + outfiles

remove_paths(relnames,curdir)

def remove_ext_vhdl_output_paths():

"Löscht alle externen VHDL-Ausgabedateien."

verbose("remove external VHDL output paths ..." )

outfiles = [y for (x,y) in get_ext_resp_ref_paths()]

relnames = ["%s.gz" % p for p in outfiles] + outfiles

remove_paths(relnames,curdir)

def gzip_vhdl_output_paths_from(vhdl_architecture_path):

"Komprimiere alle Ausgabedateien aus <vhdl_architecture_path>."

verbose("gzip VHDL output paths in %s ..." % vhdl_architecture_path)
outfiles = get_vhdl_output_paths_from(vhdl_architecture_path)

gzip_paths(outfiles)

def test():

"Teste Programm in <sim>-Verzeichnis. In <vhdl_architecture_path>\n" \
"werden die VHDL-Dateien als Liste angegeben, die eine Ausgabe ins\n" \
"Dateisystem erzeugen."

global VERBOSE
__init__()

VERBOSE = 1
bnames = []
for vname in VHDL_ARCHITECTURE_PATHS:
bnames.append(dirname(vname))
bnames = Set(bnames)

def print_bnames():
for bname in bnames:
ssystem("ls %s" % bname)

print "Starte Simulations-Trockenlauf:"
ssystem("ls %s" % SPEC_DIR)
print "Lösche VHDL-Output-Paths ..."
for vname in VHDL_ARCHITECTURE_PATHS:
remove_vhdl_output_paths_from(vname)
print
ssystem("ls %s" % SPEC_DIR)
print
print "Bereite Spezifikations-Verzeichnis zu Simulation vor ..."
prepare_spec_dir_for_simulation()
ssystem("ls %s" % SPEC_DIR)
print
print "Erzeuge Ausgabedateien (Normalerweise Simulation hier) ..."
print_bnames()
for vname in VHDL_ARCHITECTURE_PATHS:
outfiles = get_vhdl_output_paths_from(vname)
if outfiles:
ssystem("touch %s" % ' '.join(outfiles))
print_bnames()

print "Lösche geunzip-te Dateien vom Spezifikations-Verzeichnis ..."
clean_spec_dir_from_unzipped_files()
ssystem("ls %s" % SPEC_DIR)
print "Komprimiere Ausgabedateien ..."
for vname in VHDL_ARCHITECTURE_PATHS:
gzip_vhdl_output_paths_from(vname)
print
print_bnames()

print "Lösche Ausgabedateien ..."
for vname in VHDL_ARCHITECTURE_PATHS:
remove_vhdl_output_paths_from(vname)
print
print_bnames()

class formatter(IndentedHelpFormatter):

"Deaktiviert den Autoformatter"

def format_description (self, description):
return description

def main():

"Erzeugt den Kommandozeilenparser."

global VERBOSE
global SPEC_DIR
global USE_UNNAMED_PIPES
global VHDL_ARCHITECTURE_PATHS
global PROGNAME

usage = "usage: %prog [options]"
parser = OptionParser(usage,
version="%prog "+__version__,
description = __doc__ % globals(),
formatter = formatter())

parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
)

parser.add_option("",
"--help-designrules",
action="store_true",
dest="help_designrules",
help="Hilfe zu den Designrules für den Aufbau des "
"Spezifikations-Verzeichnisses")

parser.add_option("",
"--help-named-pipes",
action="store_true",
dest="help_named_pipes",
help="")

parser.add_option("-x",
"",
action = "store_true",
dest="show_example_simskript",
help="Show example simskript")

"""
parser.add_option("-g",
"",
action = "store_true",
dest="gen_simskript",
help="")
"""

parser.add_option("",
"--vhdl-architecture-path",
type='string',
dest="<VHDL_ARCHITECTURE_PATH>",
default=[],
action="append",
help=
"Spezifiziere den Pfad der Architektur hier, (default: ../*ar.vhd) "
"für mehrere Architekturen gebe das Kommando mehrfach ein.")

parser.add_option("",
"--spec-dir",
type='string',
dest="<SPEC_DIR>",
default='stim',
help="Pfadname des Spezifikations-Verzeichnisses "
"(default: stim)")

parser.add_option("-r",
"--relink-spec-dir-as-link",
action="store_true",
dest="relink_spec_dir_as_link",
help="Falls <SPEC_DIR> kein Link ist erzeuge "
"<SPEC_DIR> als Link. "
"Holt Info aus Links in <SPEC_DIR>. "
"Entferne alle Fremddateien")

parser.add_option("",
"--prepare-spec-dir-for-simulation",
action="store_true",
dest="prepare_spec_dir_for_simulation",
help="Bereite Spezifikations-Verzeichnis vor: "
"Entkomprimiere zip Dateien falls nötig. "
"Entferne alle Fremddateien, "
"VHDL-Ausgabedateien. "
"und externe Ausgabedateien mit Namensvettern "
"in <SPEC_DIR>")

parser.add_option("",
"--clean-spec-dir-from-unzipped-files",
action="store_true",
dest="clean_spec_dir_from_unzipped_files",
help="Entferne die gunzip-ten Dateien im "
"Spezifikations-Verzeichnis falls .gz "
"Datei vorhanden")

parser.add_option("",
"--remove-gunzip-paths",
action="append",
type="string",
dest="<DIR>",
default=[],
help="Entferne die gunzip-ten Dateien in <DIR> falls .gz "
"Datei vorhanden")

parser.add_option("",
"--gzip-vhdl-output-paths",
action="store_true",
dest="gzip_vhdl_output_paths",
help="Komprimiere VHDL Ausgabedateien mit gzip")

parser.add_option("",
"--remove-vhdl-output-paths",
action="store_true",
dest="remove_vhdl_output_paths",
help="Entferne alle VHDL-Ausgabedateien")

parser.add_option("",
"--remove-ext-vhdl-output-paths",
action="store_true",
dest="remove_ext_vhdl_output_paths",
help="Entferne alle externen VHDL-Ausgabedateien")

parser.add_option("",
"--get-spec-dir-state",
action="store_true",
dest="get_spec_dir_state",
help="Ermittle den <SPEC_DIR> Status "
"(linked_dir_to_specifier, "
"owned_dir_by_specfier, "
"owned_dir_contents_linked_to_specifier, "
"owned_dir_by_iclib)"
)

parser.add_option("",
"--get-remote-dir",
action="store_true",
dest="get_remote_dir",
help="Ermittle das Remote Verzeichnis"
)

parser.add_option("",
"--get-vhdl-input-paths",
action="store_true",
dest="get_vhdl_input_paths",
help="Gebe alle VHDL-Eingabedateien aus")

parser.add_option("",
"--get-vhdl-output-paths",
action="store_true",
dest="get_vhdl_output_paths",
help="Gebe alle VHDL-Ausgabedateien aus")

parser.add_option("",
"--get-resp-ref-paths",
action="store_true",
dest="get_resp_ref_paths",
help="Gebe <SPEC_DIR>/<REFNAME>.<ext1> paarweise mit "
"*/<RESPNAME>.<ext2> aus wenn <REFNAME> und "
"<RESPNAME> identisch sind. Information wird "
"aus <VHDL_ARCHITECTURE_PATHS> bestimmt.")

parser.add_option("",
"--get-ext-resp-ref-paths",
action="store_true",
dest="get_ext_resp_ref_paths",
help="Gebe <SPEC_DIR>/<REFNAME>.<ext1> paarweise mit "
"*/<RESPNAME>.<ext2> aus wenn <REFNAME> und "
"<RESPNAME> identisch sind. Es werden alle "
"Ausgabeverzeichnisse nach eine Übereinstimmung "
"mit einer Datei in <SPEC_DIR> durchsucht und "
"ausgegeben, wenn sie nicht in einem der "
"<VHDL_ARCHITECTURE_PATHS> als Ausgabedatei geöffnet "
"wird.")

parser.add_option("",
"--syscmd",
action="append",
type='string',
dest="<SYSCMD>",
default=[],
help=(
"Wende <SYSCMD> auf --get-... Ausgaben an. "
"%(p)s interpoliert den Parameter. "
"%(n)s fügt einen Zeilenumbruch ein. "
"Bsp(1): --syscmd='wc -l %(p)s' "
"Bsp(2): --syscmd='if ls %(p)s%(n)sthen rm %(p)s%(n)sfi'")
)

parser.add_option("",
"--use-named-pipes",
action="store_true",
dest="use_named_pipes",
help="Benütze benannte Pipes für die gzip "
"(De)Komprimierung, s.a. --help-named-pipes")

parser.add_option("",
"--test",
action="store_true",
dest="test",
help="Führe einen Test ohne Simulation durch")

(options, args) = parser.parse_args()

o = options

if o.verbose:
VERBOSE=1

do_exit = 0

# Help
if o.help_designrules:
print help_designrules
do_exit = 1

if o.help_named_pipes:
print help_named_pipes
do_exit = 1

if do_exit:
sys.exit(do_exit)

assert os.name == 'posix',("Betriebssystem %s ist nicht posix-konform. "
"Kode muß angepaßt werden!") % os.name

if o.show_example_simskript:
print open(EXAMPLE_SIMSKRIPT).read()
sys.exit(3)

# Paramter settings begin

# --spec_dir
SPEC_DIR = o.__dict__["<SPEC_DIR>"]
USE_NAMED_PIPES = o.use_named_pipes
if USE_NAMED_PIPES:
raise ValueError,(
"Sorry, Benannte Pipes sind noch nicht implementiert!")

# --vhdl-architecture-path
VHDL_ARCHITECTURE_PATHS = o.__dict__["<VHDL_ARCHITECTURE_PATH>"]
if not VHDL_ARCHITECTURE_PATHS:
VHDL_ARCHITECTURE_PATHS = glob("../*ar.vhd")

if VHDL_ARCHITECTURE_PATHS:
assert len(VHDL_ARCHITECTURE_PATHS) == 1,(
"Don't know what to use: %s \n"
"Please specify the VHDL architecture path with --architecture-path"
) % ' '.join(VHDL_ARCHITECTURE_PATHS)

else:
assert 0,(
"Please specify the VHDL architecture path with --architecture-path")

verbose("VHDL_ARCHITECTURE_PATHS: %s" % VHDL_ARCHITECTURE_PATHS)

# Paramter settings end

__init__()

# Test begin
if o.test:
test()
sys.exit(2)
# Test end

if o.relink_spec_dir_as_link:
relink_spec_dir_as_link()

if o.prepare_spec_dir_for_simulation:
prepare_spec_dir_for_simulation()

if o.clean_spec_dir_from_unzipped_files:
clean_spec_dir_from_unzipped_files()

dlist = o.__dict__["<DIR>"]
for f in dlist:
remove_gunzip_paths(get_pathlist(f))

if o.gzip_vhdl_output_paths:
for f in VHDL_ARCHITECTURE_PATHS:
gzip_vhdl_output_paths_from(f)

if o.remove_vhdl_output_paths:
for f in VHDL_ARCHITECTURE_PATHS:
remove_vhdl_output_paths_from(f)

if o.remove_ext_vhdl_output_paths:
remove_ext_vhdl_output_paths()

SYSCMD = o.__dict__["<SYSCMD>"]
if o.get_vhdl_input_paths:
yalist = []
exitval = 0
for f in VHDL_ARCHITECTURE_PATHS:
yalist += get_vhdl_input_paths_from(f)

if not SYSCMD:
print "vhdl_input_paths: %s" % yalist

else:
for k in yalist:
exitval = max(exitval,ssystem(SYSCMD,k))

sys.exit(exitval)

if o.get_vhdl_output_paths:
xalist = []
exitval = 0
for f in VHDL_ARCHITECTURE_PATHS:
xalist += get_vhdl_output_paths_from(f)

if not SYSCMD:
print "vhdl_output_paths: %s" % xalist

else:
for k in xalist:
exitval = max(exitval,ssystem(SYSCMD,k))

sys.exit(exitval)

if o.get_resp_ref_paths:
kvalues = get_resp_ref_paths()

if not SYSCMD:
print kvalues

else:
exitval = 0
for p1,p2 in kvalues:
for cmd in SYSCMD:
exitval = max(exitval,ssystem(cmd % locals()))
sys.exit(exitval)

if o.get_ext_resp_ref_paths:
kvalues = get_ext_resp_ref_paths()

if not SYSCMD:
print kvalues

else:
exitval = 0
for p1,p2 in kvalues:
for cmd in SYSCMD:
exitval = max(exitval,ssystem(cmd % locals()))
sys.exit(exitval)

if o.get_remote_dir:
remote_dir = get_remote_dir()

if not SYSCMD:
print "remote_dir: %s" % remote_dir

else:
k = remote_dir
sys.exit(ssystem(SYSCMD,k))

if o.get_spec_dir_state:
spec_dir_state = get_spec_dir_state()
if not SYSCMD:
print "spec_dir_state: %s" % spec_dir_state

else:
k = get_spec_dir_state()
sys.exit(ssystem(SYSCMD,k))

return parser

if __name__ == "__main__":
"Wird ausgeführt, wenn %(PROGNAME)s aus der Kommandozeile aufgerufen wird."
global PROGNAME
PROGNAME = basename(sys.argv[0])
p = main()

download