ING_DB
This commit is contained in:
Oliver Lehmann
parent
b3cbe703fe
commit
9365cdc377
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
** Es sollen alle Angaben zu allen Angestellten recherchiert werden.
|
||||
**
|
||||
**
|
||||
** Datenbank `dt' mit dem C-Programm verbinden
|
||||
*/
|
||||
## shared Dt
|
||||
/*
|
||||
** Die C-Variable name wird als Austauschvariable zwischen
|
||||
** dem C-Programm und der Datenbank deklariert
|
||||
*/
|
||||
## char *name;
|
||||
/*
|
||||
** Das Hauptprogramm muss `amx' und nicht `main' heissen !
|
||||
*/
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
/*
|
||||
** Wenn das Programm mit einem Argument gerufen wird,
|
||||
** wird das Argument als Bedingung fuer die auszuwaehlende
|
||||
** Saetze genommen, ansonsten `*', das heisst alle.
|
||||
*/
|
||||
name = (argc == 1)? "*": argv[1];
|
||||
/*
|
||||
** Relation `personal' fuer die Benutzung eroeffnen.
|
||||
*/
|
||||
## open Personal
|
||||
/*
|
||||
** Hole alle Saetze aus der Relation `personal', fuer die
|
||||
** das Feld `name' den Wert der C-Variablen `name' hat.
|
||||
*/
|
||||
## retrieve Personal $Name == name
|
||||
## {
|
||||
/*
|
||||
** Es folgt die Aktion, die fuer jeden entsprechend der
|
||||
** Bedingung gefunden Satz ausgefuert wird, hier das
|
||||
** Ausgeben des vollstaendigen Satzes.
|
||||
*/
|
||||
printf("------------\n");
|
||||
## print ()
|
||||
## }
|
||||
/*
|
||||
** Schliessen der Relation `personal'.
|
||||
*/
|
||||
## close Personal
|
||||
printf("------------\n");
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
/*
|
||||
** Es sollen die Namen aller Angestellten recherchiert werden.
|
||||
*/
|
||||
## shared Dt
|
||||
## char *name;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
name = (argc == 1)? "*": argv[1];
|
||||
## open Personal
|
||||
## retrieve Personal $Name == name { print ($Name) }
|
||||
## close Personal
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
/*
|
||||
** Es sollen die Namen aller Angestellten und ihre Leiter recherchiert werden.
|
||||
**
|
||||
** Jeder Angestellte besitzt eine Angestelltennummer `num' und einen
|
||||
** Leiter `leiter'. Die spezielle Leiternummer `0' bedeuted, dass der
|
||||
** Angestellte keinen Leiter besitzt, ansonsten verweist die Leiternummer
|
||||
** `leiter' auf einen Angestellten, der diese Nummer als Angestellten-
|
||||
** nummer `num' hat.
|
||||
*/
|
||||
## shared Dt
|
||||
## char name[21];
|
||||
## i2 leiter;
|
||||
## char *name_arg;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
name_arg = (argc == 1)? "*": argv[1];
|
||||
## open Personal
|
||||
/*
|
||||
** Das Feld `name' wird fuer jeden entsprechend der Bedingung gefundenen
|
||||
** Datensatz in die C-Variable `name' geladen, ebenso das Feld `leiter'
|
||||
** in die C-Variable `leiter'. Anschliessend wird die Aktion ausgefuehrt.
|
||||
*/
|
||||
## retrieve Personal $Name == name_arg (name = $Name, leiter = $Leiter)
|
||||
## {
|
||||
printf("Angestellter %-20s ", name);
|
||||
if (leiter == 0)
|
||||
{
|
||||
/*
|
||||
** Wenn die Leiternummer `0' ist, muss es ein
|
||||
** Direktor sein und ich finde keinen Leiter
|
||||
** fuer ihn.
|
||||
*/
|
||||
printf("Direktor\n");
|
||||
## nextretrieve
|
||||
}
|
||||
/*
|
||||
** Ich finde den Leiter des gerade gefundenen Angestellten,
|
||||
** indem ich die Nummer seines Leiters als Bedingung fuer
|
||||
** eine neue Recherche in der Relation `personal' nehme.
|
||||
** Gesucht wird der Angestellte der als Nummer die Nummer
|
||||
** hat, die der gefundene Angestellte als Leiternummer
|
||||
** hatte.
|
||||
*/
|
||||
## retrieve Personal $Num == $Leiter (name = $Name)
|
||||
## {
|
||||
printf("Leiter %s\n", name);
|
||||
## }
|
||||
## }
|
||||
## close Personal
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/*
|
||||
** Es sollen alle Angestellten und alle ihre Leiter recherchiert werden.
|
||||
*/
|
||||
## shared Dt
|
||||
## i2 leiter;
|
||||
## char name[21];
|
||||
## char *name_arg;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
name_arg = (argc == 1)? "*": argv[1];
|
||||
## open Personal
|
||||
## retrieve Personal $Name == name_arg (name = $Name, leiter = $Leiter)
|
||||
## {
|
||||
suche_leiter();
|
||||
## }
|
||||
## close Personal
|
||||
fflush(stdout);
|
||||
}
|
||||
/*
|
||||
** `suche_leiter' sucht rekursiv nach dem Leiter eines Angestellten,
|
||||
** bis dieser der Direktor ist, das heisst, der Angestellte als
|
||||
** Leiternummer eine `0' hat.
|
||||
*/
|
||||
suche_leiter()
|
||||
{
|
||||
printf("%-20s ", name);
|
||||
if (leiter == 0)
|
||||
{
|
||||
putchar('\n');
|
||||
return;
|
||||
}
|
||||
## retrieve Personal $Num == leiter (name = $Name, leiter = $Leiter)
|
||||
## {
|
||||
suche_leiter();
|
||||
## }
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/*
|
||||
** Es soll die Stellung aller Angestellten bestimmt werden.
|
||||
**
|
||||
** Die Stellung kann sein:
|
||||
** Direktor Der Angestellte hat keinen Leiter.
|
||||
** Leiter Der Angestellte hat einen Leiter und Unterstellte.
|
||||
** Angestellter Der Angestellte hat keine Unterstellte.
|
||||
**
|
||||
** Gleichzeitig soll die Anzahl der Direktoren, Leiter und
|
||||
** Angestellten gezaehlt werden.
|
||||
*/
|
||||
## shared Dt
|
||||
## i2 leiter;
|
||||
## char name[21];
|
||||
## char *name_arg;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
register int unterstellte;
|
||||
register int direktor_zaehler;
|
||||
register int leiter_zaehler;
|
||||
register int angestellten_zaehler;
|
||||
name_arg = (argc == 1)? "*": argv[1];
|
||||
direktor_zaehler = leiter_zaehler = angestellten_zaehler = 0;
|
||||
## open Personal
|
||||
## retrieve Personal $Name == name_arg (name = $Name, leiter = $Leiter)
|
||||
## {
|
||||
printf("%-20s ", name);
|
||||
if (leiter == 0)
|
||||
{
|
||||
/*
|
||||
** Wir haben einen Direktor gefunden !
|
||||
*/
|
||||
printf("Direktor\n");
|
||||
direktor_zaehler++;
|
||||
## nextretrieve
|
||||
}
|
||||
/*
|
||||
** Mit der Variable `unterstellte' soll bestimmt werden,
|
||||
** ob wir den eben gefundenen Angestellten auch als Leiter
|
||||
** bei einem beliebigen anderen Angestellten finden.
|
||||
*/
|
||||
unterstellte = 0;
|
||||
## retrieve Personal $Leiter == $Num
|
||||
## {
|
||||
/*
|
||||
** Ein gefundener Unterstellter reicht uns, wir
|
||||
** brechen die Suche nach weiteren ab !
|
||||
*/
|
||||
unterstellte++;
|
||||
## endretrieve
|
||||
## }
|
||||
if (unterstellte)
|
||||
{
|
||||
/*
|
||||
** Wir haben Unterstellte gefunden, als muss der
|
||||
** Angestellte ein Leiter sein, die Direktoren
|
||||
** haben wir ja schon abgehandelt.
|
||||
*/
|
||||
printf("Leiter\n");
|
||||
leiter_zaehler++;
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
** Die Angestellten bleiben uebrig.
|
||||
*/
|
||||
printf("Angestellter\n");
|
||||
angestellten_zaehler++;
|
||||
}
|
||||
## }
|
||||
## close Personal
|
||||
printf("TOTAL:\t%3d\n", direktor_zaehler + leiter_zaehler + angestellten_zaehler);
|
||||
printf("\t%3d Direktoren\n", direktor_zaehler);
|
||||
printf("\t%3d Leiter\n", leiter_zaehler);
|
||||
printf("\t%3d Angestellte\n", angestellten_zaehler);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
** Wir moechten die Betriebsstruktur (Unterstellungsverhaeltnisse)
|
||||
** recherchieren.
|
||||
*/
|
||||
## shared Dt
|
||||
## i2 leiter;
|
||||
## char name[21];
|
||||
int niveau;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
/*
|
||||
** Wird kein Argument gegeben, liefert `atoi()' den Wert `0'.
|
||||
*/
|
||||
leiter = atoi(argv[1]);
|
||||
## open Personal
|
||||
/*
|
||||
** Ausgangspunkt der Betriebsstruktur ist der Direktor, also die
|
||||
** Leiternummer `0'.
|
||||
*/
|
||||
## retrieve Personal $Leiter == leiter (name = $Name, leiter = $Num)
|
||||
## {
|
||||
suche_mitarbeiter();
|
||||
## }
|
||||
## close Personal
|
||||
fflush(stdout);
|
||||
}
|
||||
/*
|
||||
** `suche_mitarbeiter' sucht rekursiv alle Unterstellten eines Angestellten.
|
||||
*/
|
||||
suche_mitarbeiter()
|
||||
{
|
||||
register int i;
|
||||
/*
|
||||
** Die C-Variable `niveau' verwaltet die Unterstellungstiefe,
|
||||
** un optische Einrueckungen vornehmen zu koennen.
|
||||
*/
|
||||
niveau++;
|
||||
for (i = niveau - 1; i; --i)
|
||||
putchar('\t');
|
||||
printf("%-20s %4d\n", name, leiter);
|
||||
## retrieve Personal $Leiter == leiter (name = $Name, leiter = $Num)
|
||||
## {
|
||||
suche_mitarbeiter();
|
||||
## }
|
||||
--niveau;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
## shared Dt
|
||||
## char *farbe;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
farbe = (argc == 1)? "grau": argv[1];
|
||||
## open Teile
|
||||
## retrieve Teile $Farbe == farbe { print ($Tname, $Farbe) }
|
||||
## close Teile
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
## shared Dt
|
||||
## i2 menge;
|
||||
## i2 gewicht;
|
||||
## char *tname;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
tname = (argc == 1)? "*": argv[1];
|
||||
## open Teile
|
||||
## retrieve Teile $Tname == tname (menge = $Menge, gewicht = $Gewicht)
|
||||
## {
|
||||
## print ($Tname, $Tnum)
|
||||
printf("%12s:\t%d\n", "tot", menge * gewicht);
|
||||
## }
|
||||
## close Teile
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
## shared Dt
|
||||
## i2 lnum;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
lnum = (argc == 1)? 122: atoi(argv[1]);
|
||||
## open Lieferung
|
||||
## retrieve Lieferung $Lnum == lnum { print ($Tnum) }
|
||||
## close Lieferung
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
## shared +1 Dt
|
||||
## i2 lnum;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
lnum = (argc == 1)? 122: atoi(argv[1]);
|
||||
## open Teile
|
||||
## open Lieferung
|
||||
## use (shared Lieferung, shared Teile)
|
||||
## retrieve Lieferung $Lnum == lnum
|
||||
## {
|
||||
## retrieve Teile $Tnum == $Tnum { print ($Tname) }
|
||||
## }
|
||||
## commit
|
||||
## close Teile
|
||||
## close Lieferung
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
## shared +1 Dt
|
||||
## char *tname;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
tname = (argc == 1)? "Zentraleinheit": argv[1];
|
||||
## open Teile
|
||||
## open Lieferung
|
||||
## use (shared Lieferung, shared Teile)
|
||||
## retrieve Teile $Tname == tname
|
||||
## {
|
||||
## retrieve Lieferung $Tnum == $Tnum { print ($Lnum) }
|
||||
## }
|
||||
## commit
|
||||
## close Teile
|
||||
## close Lieferung
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
## shared Dt
|
||||
## char *name;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
register int c;
|
||||
name = (argc == 1)? "*": argv[1];
|
||||
## open Personal
|
||||
## use (exclusive Personal)
|
||||
## retrieve Personal $Name == name
|
||||
## {
|
||||
## print ()
|
||||
printf("STREICHEN ?\t");
|
||||
fflush(stdout);
|
||||
if ((c = getchar()) == 'y')
|
||||
## delete
|
||||
while (c && c != '\n')
|
||||
c = getchar();
|
||||
## }
|
||||
## commit
|
||||
## close Personal
|
||||
fflush(stdout);
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
## shared Dt
|
||||
## i2 leiter;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
leiter = (argc == 1)? 129: atoi(argv[1]);
|
||||
## open Personal
|
||||
## use (exclusive Personal)
|
||||
## retrieve Personal $Leiter == leiter { print ($Name); delete }
|
||||
## commit
|
||||
## close Personal
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
## shared Dt
|
||||
## char *name;
|
||||
## i2 num;
|
||||
## i2 leiter;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
name = (argc == 1)? "Unfug, Ulli": argv[1];
|
||||
num = (argc < 3)? 12: atoi(argv[2]);
|
||||
leiter = (argc < 4)? 157: atoi(argv[3]);
|
||||
## open Personal
|
||||
## use (exclusive Personal)
|
||||
## retrieve Personal $Name == name
|
||||
## { replace ($Num = num, $Leiter = leiter) }
|
||||
## commit
|
||||
## close Personal
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
## shared Dt
|
||||
## f8 gehalt;
|
||||
## char *name;
|
||||
amx(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
name = (argc == 1)? "*": argv[1];
|
||||
/*
|
||||
** Hier wird ueberprueft, ob der Ausfuehrende des Programms
|
||||
** auch der Uebersetzende war.
|
||||
*/
|
||||
## permit user
|
||||
## open Personal
|
||||
## use (exclusive Personal)
|
||||
## retrieve Personal $Name == name (gehalt = $Gehalt)
|
||||
## {
|
||||
gehalt *= 1.1;
|
||||
## replace ($Gehalt = gehalt)
|
||||
## }
|
||||
## commit
|
||||
## close Personal
|
||||
}
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
## import "menue.x"
|
||||
|
||||
# define MAX_AUSZUG 20
|
||||
|
||||
struct auszug
|
||||
{
|
||||
long a_datum;
|
||||
short a_betrag;
|
||||
short a_no_grund;
|
||||
};
|
||||
|
||||
auszug()
|
||||
{
|
||||
char buf[36];
|
||||
|
||||
while (!input(11, buf))
|
||||
pr_kunde();
|
||||
konto = atol(buf);
|
||||
pr_auszug();
|
||||
}
|
||||
|
||||
|
||||
auszuege()
|
||||
{
|
||||
register int cnt;
|
||||
|
||||
for ( ; ; )
|
||||
{
|
||||
cnt = 0;
|
||||
## retrieve buchung
|
||||
## (
|
||||
## konto = $konto
|
||||
## )
|
||||
## {
|
||||
cnt++;
|
||||
break;
|
||||
## }
|
||||
if (!cnt)
|
||||
return;
|
||||
pr_auszug();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pr_auszug()
|
||||
{
|
||||
register struct auszug **ap;
|
||||
register struct auszug *a;
|
||||
register int i;
|
||||
register int j;
|
||||
struct auszug abuf[MAX_AUSZUG];
|
||||
struct auszug *apbuf[MAX_AUSZUG];
|
||||
extern int cmpa();
|
||||
extern char *ctime();
|
||||
|
||||
if (get_konto())
|
||||
{
|
||||
error("ungueltige Kontonummer");
|
||||
return;
|
||||
}
|
||||
get_bank();
|
||||
get_kunde();
|
||||
get_name();
|
||||
get_vorname();
|
||||
get_str();
|
||||
get_ort();
|
||||
cls(1, 1, 25, 80);
|
||||
on_revers();
|
||||
cursor(1, 1);
|
||||
for (i = 0; i < 80; i++)
|
||||
putchar(' ');
|
||||
cursor(2, 1);
|
||||
for (i = 0; i < 80; i++)
|
||||
putchar(' ');
|
||||
cursor(1, 1);
|
||||
printf("KONTOAUSZUG #%ld# %s %s", konto, bank, ctime(&datum));
|
||||
cursor(2, 1);
|
||||
printf("NEUER SALDO %ld", saldo);
|
||||
off_revers();
|
||||
cursor(3, 1);
|
||||
on_bold();
|
||||
printf("%s, %s aus %s %s, %d", name, vorname, str, ort, plz);
|
||||
off_bold();
|
||||
i = 0;
|
||||
a = abuf;
|
||||
ap = apbuf;
|
||||
## use (+buchung)
|
||||
## retrieve buchung $konto == konto
|
||||
## (
|
||||
## datum = $datum,
|
||||
## betrag = $betrag,
|
||||
## no_grund = $no_grund
|
||||
## )
|
||||
## {
|
||||
a->a_datum = datum;
|
||||
a->a_betrag = betrag;
|
||||
a->a_no_grund = no_grund;
|
||||
*ap++ = a++;
|
||||
## delete
|
||||
if (i++ == MAX_AUSZUG)
|
||||
break;
|
||||
## }
|
||||
## commit
|
||||
if (!i)
|
||||
{
|
||||
error("keine Kontoauszuege vorhanden");
|
||||
goto done;
|
||||
}
|
||||
qsort(apbuf, i, sizeof (struct auszug *), cmpa);
|
||||
on_revers();
|
||||
cursor(4, 1);
|
||||
for (j = 0; j < 80; j++)
|
||||
putchar(' ');
|
||||
cursor(4, 1);
|
||||
printf("UMSAETZE %-35s BUCHUNGSDATUM", "BUCHUNGSTEXT");
|
||||
off_revers();
|
||||
cursor(5, 1);
|
||||
ap = apbuf;
|
||||
while (i--)
|
||||
{
|
||||
a = *ap++;
|
||||
no_grund = a->a_no_grund;
|
||||
get_grund();
|
||||
if (!plus)
|
||||
on_blinking();
|
||||
printf("%8d", a->a_betrag);
|
||||
if (!plus)
|
||||
off_blinking();
|
||||
printf(" %-35s %s", grund, ctime(&a->a_datum));
|
||||
a++;
|
||||
}
|
||||
done:
|
||||
if (Batch)
|
||||
return;
|
||||
cursor(2, 60);
|
||||
on_revers();
|
||||
on_blinking();
|
||||
printf("continue<enter>");
|
||||
off_blinking();
|
||||
off_revers();
|
||||
fflush(stdout);
|
||||
while ((i = getchar()) > 0 && i != '\n')
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
cmpa(a, b)
|
||||
register struct auszug *a;
|
||||
register struct auszug *b;
|
||||
{
|
||||
if (a->a_datum == b->a_datum)
|
||||
return (0);
|
||||
return (a->a_datum < b->a_datum);
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_bank()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve bank
|
||||
## (
|
||||
## bank = $bank
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%s", bank);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_bank()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve bank $no_bank == no_bank
|
||||
## (
|
||||
## no_str = $no_str,
|
||||
## no_ort = $no_ort,
|
||||
## bank = $bank
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_bank()
|
||||
{
|
||||
while (!input(10, bank))
|
||||
pr_bank();
|
||||
no_bank = 0;
|
||||
## use (+bank)
|
||||
## retrieve bank $bank == bank
|
||||
## (
|
||||
## no_bank = $no_bank,
|
||||
## no_str = $no_str,
|
||||
## no_ort = $no_ort
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_bank)
|
||||
{
|
||||
## tuplecount bank no_bank
|
||||
no_bank++;
|
||||
## commit
|
||||
new_str();
|
||||
new_ort();
|
||||
## use (+bank)
|
||||
## append bank
|
||||
## (
|
||||
## $no_bank = no_bank,
|
||||
## $no_str = no_str,
|
||||
## $no_ort = no_ort,
|
||||
## $bank = bank
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
## import "menue.x"
|
||||
|
||||
new_buchung()
|
||||
{
|
||||
register int i;
|
||||
register long l;
|
||||
char buf[36];
|
||||
extern long atol();
|
||||
extern long time();
|
||||
|
||||
if (Batch)
|
||||
{
|
||||
## tuplecount konto konto
|
||||
konto = l = rand() % konto + 1;
|
||||
hash_konto(&konto);
|
||||
i = (rand() % l) * 7;
|
||||
if (l > i)
|
||||
{
|
||||
if (l > 500 || time((char *) 0) & 01)
|
||||
pr_auszug();
|
||||
else
|
||||
new_konto();
|
||||
}
|
||||
betrag = rand() % 1000 + 1;
|
||||
on_revers();
|
||||
printf("\n%d Konto ", Batch);
|
||||
off_revers();
|
||||
printf("%5ld\n", konto);
|
||||
printf(" Betrag %5d\n", betrag);
|
||||
}
|
||||
else
|
||||
{
|
||||
while (!input(11, buf))
|
||||
pr_kunde();
|
||||
konto = atol(buf);
|
||||
input(12, buf);
|
||||
betrag = atoi(buf);
|
||||
}
|
||||
new_datum();
|
||||
new_grund();
|
||||
if (!plus)
|
||||
betrag = -betrag;
|
||||
## use (+buchung, +konto)
|
||||
## retrieve konto $konto == konto
|
||||
## (
|
||||
## saldo = $saldo
|
||||
## )
|
||||
## {
|
||||
saldo += betrag;
|
||||
## append buchung
|
||||
## (
|
||||
## $konto = konto,
|
||||
## $datum = datum,
|
||||
## $betrag = betrag,
|
||||
## $no_grund = no_grund
|
||||
## )
|
||||
## replace
|
||||
## (
|
||||
## $saldo = saldo,
|
||||
## $datum = datum
|
||||
## )
|
||||
## }
|
||||
## commit
|
||||
if (Batch && saldo < 0 && Mahnung++ == 10)
|
||||
{
|
||||
Mahnung = 0;
|
||||
mahnung();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_grund()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve grund
|
||||
## (
|
||||
## plus = $plus,
|
||||
## grund = $grund
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%c%s", plus? ' ': '-', grund);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_grund()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve grund $no_grund == no_grund
|
||||
## (
|
||||
## plus = $plus,
|
||||
## grund = $grund
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_grund()
|
||||
{
|
||||
char buf[36];
|
||||
|
||||
if (Batch)
|
||||
{
|
||||
## tuplecount grund no_grund
|
||||
no_grund = rand() % no_grund + 1;
|
||||
get_grund();
|
||||
printf(" Grund %c%s\n", plus? ' ': '-', grund);
|
||||
return;
|
||||
}
|
||||
while (!input(8, grund))
|
||||
pr_grund();
|
||||
no_grund = 0;
|
||||
## use (+grund)
|
||||
## retrieve grund $grund == grund
|
||||
## (
|
||||
## no_grund = $no_grund,
|
||||
## plus = $plus
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_grund)
|
||||
{
|
||||
## tuplecount grund no_grund
|
||||
no_grund++;
|
||||
## commit
|
||||
input(9, buf);
|
||||
if (plus = atoi(buf))
|
||||
plus = 1;
|
||||
## use (+grund)
|
||||
## append grund
|
||||
## (
|
||||
## $no_grund = no_grund,
|
||||
## $plus = plus,
|
||||
## $grund = grund
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
## import "menue.x"
|
||||
|
||||
get_konto()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve konto $konto == konto
|
||||
## (
|
||||
## konto = $konto,
|
||||
## saldo = $saldo,
|
||||
## datum = $datum,
|
||||
## no_bank = $no_bank
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_konto()
|
||||
{
|
||||
new_kunde();
|
||||
if (Batch)
|
||||
{
|
||||
## tuplecount bank no_bank
|
||||
no_bank = rand() % no_bank + 1;
|
||||
get_bank();
|
||||
printf(" Bank %5d %s\n", no_bank, bank);
|
||||
}
|
||||
else
|
||||
new_bank();
|
||||
new_datum();
|
||||
## use (+konto)
|
||||
## append konto
|
||||
## (
|
||||
## $konto = konto,
|
||||
## $saldo = 0,
|
||||
## $datum = datum,
|
||||
## $no_bank = no_bank
|
||||
## )
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_kunde()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve kunde
|
||||
## (
|
||||
## no_name = $no_name,
|
||||
## no_vorname = $no_vorname,
|
||||
## konto = $konto
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
get_name();
|
||||
get_vorname();
|
||||
printf("%-12.s %-12.s %ld", name, vorname, konto);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_kunde()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve kunde $konto == konto
|
||||
## (
|
||||
## no_name = $no_name,
|
||||
## no_vorname = $no_vorname,
|
||||
## no_str = $no_str,
|
||||
## no_ort = $no_ort
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_kunde()
|
||||
{
|
||||
if (Batch)
|
||||
{
|
||||
## tuplecount name no_name
|
||||
no_name = rand() % no_name + 1;
|
||||
get_name();
|
||||
on_revers();
|
||||
printf("\n%d Name ", Batch);
|
||||
off_revers();
|
||||
printf("%5d %s\n", no_name, name);
|
||||
## tuplecount vorname no_vorname
|
||||
no_vorname = rand() % no_vorname + 1;
|
||||
get_vorname();
|
||||
printf(" Vorname %5d %s\n", no_vorname, vorname);
|
||||
## tuplecount str no_str
|
||||
no_str = rand() % no_str + 1;
|
||||
get_str();
|
||||
printf(" Strasse %5d %s\n", no_str, str);
|
||||
## tuplecount ort no_ort
|
||||
no_ort = rand() % no_ort + 1;
|
||||
get_ort();
|
||||
printf(" PLZ %5d\n", plz);
|
||||
printf(" Ort %5d %s\n", no_ort, ort);
|
||||
}
|
||||
else
|
||||
{
|
||||
new_name();
|
||||
new_vorname();
|
||||
new_str();
|
||||
new_ort();
|
||||
}
|
||||
## use (+kunde)
|
||||
## tuplecount kunde konto
|
||||
konto++;
|
||||
hash_konto(&konto);
|
||||
## append kunde
|
||||
## (
|
||||
## $konto = konto,
|
||||
## $no_name = no_name,
|
||||
## $no_vorname = no_vorname,
|
||||
## $no_str = no_str,
|
||||
## $no_ort = no_ort
|
||||
## )
|
||||
## commit
|
||||
if (Batch)
|
||||
printf(" Konto %5ld\n", konto);
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_name()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve name
|
||||
## (
|
||||
## name = $name
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%s", name);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_name()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve name $no_name == no_name
|
||||
## (
|
||||
## name = $name
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_name()
|
||||
{
|
||||
while (!input(4, name))
|
||||
pr_name();
|
||||
no_name = 0;
|
||||
## use (+name)
|
||||
## retrieve name $name == name
|
||||
## (
|
||||
## no_name = $no_name
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_name)
|
||||
{
|
||||
## tuplecount name no_name
|
||||
no_name++;
|
||||
## append name
|
||||
## (
|
||||
## $no_name = no_name,
|
||||
## $name = name
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_ort()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve ort
|
||||
## (
|
||||
## plz = $plz,
|
||||
## ort = $ort
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%4d %s", plz, ort);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_ort()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve ort $no_ort == no_ort
|
||||
## (
|
||||
## plz = $plz,
|
||||
## ort = $ort
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_ort()
|
||||
{
|
||||
char buf[36];
|
||||
|
||||
while (!input(6, ort))
|
||||
pr_ort();
|
||||
input(7, buf);
|
||||
plz = atoi(buf);
|
||||
no_ort = 0;
|
||||
## use (+ort)
|
||||
## retrieve ort $plz == plz and $ort == ort
|
||||
## (
|
||||
## no_ort = $no_ort
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_ort)
|
||||
{
|
||||
## tuplecount ort no_ort
|
||||
no_ort++;
|
||||
## append ort
|
||||
## (
|
||||
## $no_ort = no_ort,
|
||||
## $plz = plz,
|
||||
## $ort = ort
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_str()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve str
|
||||
## (
|
||||
## str = $str
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%s", str);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_str()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve str $no_str == no_str
|
||||
## (
|
||||
## str = $str
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_str()
|
||||
{
|
||||
while (!input(5, str))
|
||||
pr_str();
|
||||
no_str = 0;
|
||||
## use (+str)
|
||||
## retrieve str $str == str
|
||||
## (
|
||||
## no_str = $no_str
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_str)
|
||||
{
|
||||
## tuplecount str no_str
|
||||
no_str++;
|
||||
## append str
|
||||
## (
|
||||
## $no_str = no_str,
|
||||
## $str = str
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
## import "menue.x"
|
||||
|
||||
pr_vorname()
|
||||
{
|
||||
pr_init();
|
||||
## retrieve vorname
|
||||
## (
|
||||
## vorname = $vorname
|
||||
## )
|
||||
## {
|
||||
if (pr_line())
|
||||
break;
|
||||
printf("%s", vorname);
|
||||
## }
|
||||
pr_end();
|
||||
}
|
||||
|
||||
|
||||
get_vorname()
|
||||
{
|
||||
register int rc;
|
||||
|
||||
rc = 1;
|
||||
## retrieve vorname $no_vorname == no_vorname
|
||||
## (
|
||||
## vorname = $vorname
|
||||
## )
|
||||
## {
|
||||
rc = 0;
|
||||
break;
|
||||
## }
|
||||
return (rc);
|
||||
}
|
||||
|
||||
|
||||
new_vorname()
|
||||
{
|
||||
while (!input(3, vorname))
|
||||
pr_vorname();
|
||||
no_vorname = 0;
|
||||
## use (+vorname)
|
||||
## retrieve vorname $vorname == vorname
|
||||
## (
|
||||
## no_vorname = $no_vorname
|
||||
## )
|
||||
## {
|
||||
break;
|
||||
## }
|
||||
if (!no_vorname)
|
||||
{
|
||||
## tuplecount vorname no_vorname
|
||||
no_vorname++;
|
||||
## append vorname
|
||||
## (
|
||||
## $no_vorname = no_vorname,
|
||||
## $vorname = vorname
|
||||
## )
|
||||
}
|
||||
## commit
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
## char kenn[2];
|
||||
## char t[31];
|
||||
## i2 m;
|
||||
|
||||
amx()
|
||||
{
|
||||
register int cnt;
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Ermittlung aller Endprodukte\n\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Teile (kenn = $Kenn, t = $T, m = $M)
|
||||
## {
|
||||
cnt = 0;
|
||||
## retrieve Inf $Ut == $T
|
||||
## {
|
||||
cnt++;
|
||||
break;
|
||||
## }
|
||||
if (cnt)
|
||||
continue;
|
||||
printf("%s %s %4d\n", kenn, t, m);
|
||||
fflush(stdout);
|
||||
count++;
|
||||
## }
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
printf("TUPLECOUNT %d\n", count);
|
||||
fflush(stdout);
|
||||
## close Inf
|
||||
## close Teile
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
## char ot[14];
|
||||
|
||||
amx()
|
||||
{
|
||||
register int i;
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Konsistenzcheck Inf.Ot --> Teile.T\n\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Inf (ot = $Ot)
|
||||
## {
|
||||
count++;
|
||||
i = 0;
|
||||
## retrieve Teile $T == $Ot
|
||||
## {
|
||||
i++;
|
||||
## }
|
||||
if (!i)
|
||||
{
|
||||
printf("ot = %s LOST\n", ot);
|
||||
fflush(stdout);
|
||||
}
|
||||
if (i != 1)
|
||||
{
|
||||
printf("ot = %s has %d entries\n", ot, i);
|
||||
fflush(stdout);
|
||||
}
|
||||
## }
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
printf("TUPLECOUNT %d\n", count);
|
||||
fflush(stdout);
|
||||
## close Inf
|
||||
## close Teile
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
## char t[31];
|
||||
## i2 m;
|
||||
|
||||
amx()
|
||||
{
|
||||
register int cnt;
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Ermittlung aller Endprodukte die Unterteile haben\n\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Teile $Kenn == "a" (t = $T, m = $M)
|
||||
## {
|
||||
cnt = 0;
|
||||
## retrieve Inf $Ut == $T
|
||||
## {
|
||||
cnt++;
|
||||
break;
|
||||
## }
|
||||
if (cnt)
|
||||
continue;
|
||||
printf("%s %4d\n", t, m);
|
||||
fflush(stdout);
|
||||
count++;
|
||||
## }
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
printf("TUPLECOUNT %d\n", count);
|
||||
fflush(stdout);
|
||||
## close Inf
|
||||
## close Teile
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
## char t[31];
|
||||
## i2 m;
|
||||
|
||||
amx()
|
||||
{
|
||||
register int cnt;
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Ermittlung aller Endprodukte die keine Unterteile haben\n\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Teile $Kenn != "a" (t = $T, m = $M)
|
||||
## {
|
||||
cnt = 0;
|
||||
## retrieve Inf $Ut == $T
|
||||
## {
|
||||
cnt++;
|
||||
break;
|
||||
## }
|
||||
if (cnt)
|
||||
continue;
|
||||
printf("%s %4d\n", t, m);
|
||||
fflush(stdout);
|
||||
count++;
|
||||
## }
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
printf("TUPLECOUNT %d\n", count);
|
||||
fflush(stdout);
|
||||
## close Inf
|
||||
## close Teile
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
int lev;
|
||||
## char ot[14];
|
||||
## char ut[14];
|
||||
## char name[31];
|
||||
## char me[3];
|
||||
|
||||
amx()
|
||||
{
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Strukturstueckliste\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Teile $Kenn == "a" (ot = $T, name = $Name)
|
||||
## {
|
||||
lev = 0;
|
||||
printf("\n*** ALLE STRUKTURLISTEN ***\n");
|
||||
printf("\nStueckliste %s %s\n", ot, name);
|
||||
printf("\n\tAufl.St.\t Gegenst.Nr. Gegenst.Bez. ME\n\n");
|
||||
fflush(stdout);
|
||||
stl_structure();
|
||||
## }
|
||||
## close Inf
|
||||
## close Teile
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
|
||||
stl_structure()
|
||||
{
|
||||
register int i;
|
||||
|
||||
lev++;
|
||||
## retrieve Inf $Ot == ot (ut = $Ut)
|
||||
## {
|
||||
## retrieve Teile $T == ut (name = $Name, me = $Me)
|
||||
## {
|
||||
putchar('\t');
|
||||
for (i = lev; i; --i)
|
||||
putchar('.');
|
||||
printf("%d\t\t", lev);
|
||||
printf("%13s %30s %2s\n", ut, name, me);
|
||||
fflush(stdout);
|
||||
## }
|
||||
AAsmove(ut, ot);
|
||||
stl_structure();
|
||||
## }
|
||||
--lev;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
int lev;
|
||||
## char ot[14];
|
||||
## char ut[14];
|
||||
## char name[31];
|
||||
## char me[3];
|
||||
|
||||
amx()
|
||||
{
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("einstufige Strukturstueckliste\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Teile $Kenn == "a" (ot = $T, name = $Name)
|
||||
## {
|
||||
lev = 0;
|
||||
printf("\n*** einstufige STRUKTURLISTEN ***\n");
|
||||
printf("\nStueckliste %s %s\n", ot, name);
|
||||
printf("\n\tAufl.St.\t Gegenst.Nr. Gegenst.Bez. ME\n\n");
|
||||
fflush(stdout);
|
||||
stl_structure();
|
||||
## }
|
||||
## close Inf
|
||||
## close Teile
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
}
|
||||
|
||||
stl_structure()
|
||||
{
|
||||
register int i;
|
||||
|
||||
lev++;
|
||||
## retrieve Inf $Ot == ot (ut = $Ut)
|
||||
## {
|
||||
## retrieve Teile $T == ut (name = $Name, me = $Me)
|
||||
## {
|
||||
putchar('\t');
|
||||
for (i = lev; i; --i)
|
||||
putchar('.');
|
||||
printf("%d\t\t", lev);
|
||||
printf("%13s %30s %2s\n", ut, name, me);
|
||||
fflush(stdout);
|
||||
## }
|
||||
## }
|
||||
--lev;
|
||||
}
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
## shared Dbsr
|
||||
|
||||
## int lev;
|
||||
## char ot[14];
|
||||
## char ut[14];
|
||||
## char name[31];
|
||||
## char me[3];
|
||||
## int m;
|
||||
## int menge;
|
||||
## int meng;
|
||||
|
||||
int count;
|
||||
int mengen[20];
|
||||
char titname[31];
|
||||
char titnr[13];
|
||||
|
||||
amx()
|
||||
{
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Strukturstueckliste fuer das Teil Nr. 10 (20 Stueck)\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Total
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
|
||||
## use (exclusive Total, shared Teile, shared Inf)
|
||||
## retrieve Total { delete }
|
||||
## retrieve Teile $T == "0000000000010" (ot = $T, name = $Name, me = $Me)
|
||||
## {
|
||||
lev = 0;
|
||||
menge = 20;
|
||||
mengen[lev] = 20;
|
||||
printf("\nStueckliste %-s %-s\n", ot, name);
|
||||
printf("\n\tAufl.St.\t Gegenst.Nr. Gegenst.Bez.\t\t ME Menge\n");
|
||||
fflush(stdout);
|
||||
AAsmove(ot, ut);
|
||||
AAsmove(ut, titnr);
|
||||
AAsmove(name, titname);
|
||||
app();
|
||||
AAsmove(ut, ot),
|
||||
|
||||
stl_structure();
|
||||
## }
|
||||
printtot();
|
||||
## commit
|
||||
## close Inf
|
||||
## close Total
|
||||
## close Teile
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
|
||||
stl_structure()
|
||||
{
|
||||
register int i;
|
||||
|
||||
lev++;
|
||||
## retrieve Inf $Ot == ot (ut = $Ut, m = $M)
|
||||
## {
|
||||
menge = mengen[--lev] * m;
|
||||
mengen[++lev] = menge;
|
||||
## retrieve Teile $T == ut (name = $Name, me = $Me)
|
||||
## {
|
||||
putchar('\t');
|
||||
for (i = lev; i; --i)
|
||||
putchar('.');
|
||||
printf("%d\t\t", lev);
|
||||
printf("%13s %-30s %-2s %5d\n", ut, name, me, menge);
|
||||
fflush(stdout);
|
||||
app();
|
||||
## }
|
||||
AAsmove(ut, ot);
|
||||
stl_structure();
|
||||
## }
|
||||
--lev;
|
||||
}
|
||||
|
||||
|
||||
app()
|
||||
{
|
||||
register int count;
|
||||
register int i;
|
||||
|
||||
count = 0;
|
||||
i++;
|
||||
## retrieve Total $T == ut (meng = $Menge)
|
||||
## {
|
||||
count++;
|
||||
menge += meng;
|
||||
## replace ($Menge = menge)
|
||||
## }
|
||||
if (!count)
|
||||
## append Total
|
||||
## ($Lev = lev, $T = ut, $Name = name, $Menge = menge, $Me = me)
|
||||
}
|
||||
|
||||
|
||||
printtot()
|
||||
{
|
||||
printf("\n\tDBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("\tTotale Stueckliste fuer das Teil Nr. 10 (20 Stueck)\n");
|
||||
printf("\n\tStueckliste %-s %-s\n", titnr, titname);
|
||||
printf("\n\t Gegenst.Nr. Gegenst.Bez. ME Menge\n");
|
||||
fflush(stdout);
|
||||
## retrieve Total $T != "0000000000010"
|
||||
## (ut = $T, name = $Name, menge = $Menge, me = $Me)
|
||||
## {
|
||||
printf("\t%13s %-30s %-2s %5d\n", ut, name, me, menge);
|
||||
fflush(stdout);
|
||||
## }
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
## shared Dbsr
|
||||
|
||||
int count;
|
||||
## char ut[14];
|
||||
|
||||
amx()
|
||||
{
|
||||
register int i;
|
||||
long old;
|
||||
long new;
|
||||
char buf[BUFSIZ];
|
||||
extern long time();
|
||||
|
||||
setbuf(stdout, buf);
|
||||
printf("DBS/R-DEMONSTRATIONSBEISPIEL:\n");
|
||||
printf("Konsistenzcheck Inf.Ut --> Teile.T\n\n");
|
||||
fflush(stdout);
|
||||
|
||||
## open Teile
|
||||
## open Inf
|
||||
old = time((char *) 0);
|
||||
## retrieve Inf (ut = $Ut)
|
||||
## {
|
||||
count++;
|
||||
i = 0;
|
||||
## retrieve Teile $T == $Ut
|
||||
## {
|
||||
i++;
|
||||
## }
|
||||
if (!i)
|
||||
{
|
||||
printf("ut = %s LOST\n", ut);
|
||||
fflush(stdout);
|
||||
}
|
||||
if (i != 1)
|
||||
{
|
||||
printf("ut = %s has %d entries\n", ut, i);
|
||||
fflush(stdout);
|
||||
}
|
||||
## }
|
||||
new = time((char *) 0);
|
||||
printf("\nEXECUTE %ld sec\n", new - old);
|
||||
printf("TUPLECOUNT %d\n", count);
|
||||
fflush(stdout);
|
||||
## close Inf
|
||||
## close Teile
|
||||
}
|
||||
Loading…
Reference in New Issue