From 04e68443040c7abad84d66477e98f93bed701760 Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Mon, 4 Feb 2019 13:09:03 +0100 Subject: Initial import --- app/eumelbase/2.2.1-schulis/source-disk | 1 + app/eumelbase/2.2.1-schulis/src/ACCESS.files | 7 ++ app/eumelbase/2.2.1-schulis/src/DIALOG.files | 8 ++ app/eumelbase/2.2.1-schulis/src/MM BAISY.files | 3 + app/eumelbase/2.2.1-schulis/src/db access.sc | 60 +++++++++++++ app/eumelbase/2.2.1-schulis/src/db archive.sc | 7 ++ app/eumelbase/2.2.1-schulis/src/db ddinfo.sc | 24 +++++ app/eumelbase/2.2.1-schulis/src/db ersatz.sc | 9 ++ app/eumelbase/2.2.1-schulis/src/db kernel.sc | 60 +++++++++++++ app/eumelbase/2.2.1-schulis/src/db manager.sc | 18 ++++ app/eumelbase/2.2.1-schulis/src/db memory.sc | 60 +++++++++++++ app/eumelbase/2.2.1-schulis/src/db q.sc | 100 +++++++++++++++++++++ app/eumelbase/2.2.1-schulis/src/db ref.sc | 10 +++ app/eumelbase/2.2.1-schulis/src/db sel.sc | 58 ++++++++++++ app/eumelbase/2.2.1-schulis/src/db snd query.sc | 18 ++++ app/eumelbase/2.2.1-schulis/src/db utils.sc | 60 +++++++++++++ .../2.2.1-schulis/src/isp archive manager.sc | 79 ++++++++++++++++ app/eumelbase/2.2.1-schulis/src/isp archive.sc | 35 ++++++++ 18 files changed, 617 insertions(+) create mode 100644 app/eumelbase/2.2.1-schulis/source-disk create mode 100644 app/eumelbase/2.2.1-schulis/src/ACCESS.files create mode 100644 app/eumelbase/2.2.1-schulis/src/DIALOG.files create mode 100644 app/eumelbase/2.2.1-schulis/src/MM BAISY.files create mode 100644 app/eumelbase/2.2.1-schulis/src/db access.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db archive.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db ddinfo.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db ersatz.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db kernel.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db manager.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db memory.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db q.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db ref.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db sel.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db snd query.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/db utils.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/isp archive manager.sc create mode 100644 app/eumelbase/2.2.1-schulis/src/isp archive.sc (limited to 'app/eumelbase') diff --git a/app/eumelbase/2.2.1-schulis/source-disk b/app/eumelbase/2.2.1-schulis/source-disk new file mode 100644 index 0000000..377f161 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/source-disk @@ -0,0 +1 @@ +schulis-grundpaket-schulverwaltung-2.2.1/01_eumelbase-quellen.img diff --git a/app/eumelbase/2.2.1-schulis/src/ACCESS.files b/app/eumelbase/2.2.1-schulis/src/ACCESS.files new file mode 100644 index 0000000..521f1a1 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/ACCESS.files @@ -0,0 +1,7 @@ +db ref.sc +db sel.sc +db q.sc +db memory.sc +db access.sc +db ersatz.sc + diff --git a/app/eumelbase/2.2.1-schulis/src/DIALOG.files b/app/eumelbase/2.2.1-schulis/src/DIALOG.files new file mode 100644 index 0000000..2cad586 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/DIALOG.files @@ -0,0 +1,8 @@ +isp edit.sc +screen manager.sc +window manager packets.sc +dialog.sc +db sel auswertung.sc +db dialog.sc + + diff --git a/app/eumelbase/2.2.1-schulis/src/MM BAISY.files b/app/eumelbase/2.2.1-schulis/src/MM BAISY.files new file mode 100644 index 0000000..6fb77a7 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/MM BAISY.files @@ -0,0 +1,3 @@ +db manager.sc + + diff --git a/app/eumelbase/2.2.1-schulis/src/db access.sc b/app/eumelbase/2.2.1-schulis/src/db access.sc new file mode 100644 index 0000000..7d6d1cd --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db access.sc @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + +� +#����# diff --git a/app/eumelbase/2.2.1-schulis/src/db archive.sc b/app/eumelbase/2.2.1-schulis/src/db archive.sc new file mode 100644 index 0000000..e68c5ce --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db archive.sc @@ -0,0 +1,7 @@ + PACKETdbarchive DEFINESdbtoarchive,dbfromarchive: TEXT VARuuuuuv:=""; PROCdbtoarchive( TEXT CONSTuuuuux):enablestop;logonarchive;fetchdb(uuuuux);uuuuuz;savetoarchive +(db);uuuuvu;logoffarchive. ENDPROCdbtoarchive; PROCdbfromarchive( TEXT CONSTuuuuux):dbfromarchive(uuuuux,"") ENDPROCdbfromarchive; PROCdbfromarchive( TEXT CONSTuuuuux +, TEXT CONSTuuuuwx):enablestop;logonarchive;uuuuuv:=postfix;postfix(uuuuwx);fetchfromarchive;uuuuuz; IF NOTtaskda(uuuuux) THEN IFyes("Server anlegen") CANDuuuuxw THEN +restoredb(uuuuux);uuuuvu FI ELSErestoredb(uuuuux);uuuuvu FI;uuuuyv.uuuuyv:postfix("");fetchdd(uuuuux); BOOL VARuuuuyy:=dbopen(uuuuux);postfix(uuuuuv);logoffarchive +.uuuuxw: IF NOTexists(uuuuux) THENcopy(uuuuux+uuuuwx,uuuuux) FI;createdb(uuuuux). ENDPROCdbfromarchive; PROCuuuuuz: IFonline THENline; FI ENDPROCuuuuuz; PROCuuuuvu +:commanddialogue( FALSE);forget(db);commanddialogue( TRUE) ENDPROCuuuuvu; ENDPACKETdbarchive; + diff --git a/app/eumelbase/2.2.1-schulis/src/db ddinfo.sc b/app/eumelbase/2.2.1-schulis/src/db ddinfo.sc new file mode 100644 index 0000000..3993705 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db ddinfo.sc @@ -0,0 +1,24 @@ + PACKETddinfopacket DEFINESddinfo: REAL PROCuuuuuv( INT CONSTuuuuuw):records(uuuuuw) ENDPROCuuuuuv; PROCddinfo( TEXT CONSTuuuuvu):ddinfo(uuuuvu,"") ENDPROCddinfo; + PROCddinfo( TEXT CONSTuuuuvu,uuuuwu): INT VARuuuuwv,uuuuww:=1,uuuuwx; TEXT VARuuuuwy; IFuuuuvu="" ORuuuuvu="screen" THENpage ELSEforget(uuuuvu+".dd",quiet);sysout +(uuuuvu+".dd"); IFuuuuvu="printer" THENputline("#type("""+uuuuwu+""")#") FI FI;uuuuxz;putline(" Datenbank: <"+name(1)+">");putline(" Anzahl Dateien erster Index Max DatID 1. Freier Eintrag" +);putline(" "+text(anzdateien)+" "+text(firstindex)+" "+text(maxdatid)+" "+text(firstfree));uuuuyu;uuuuwv:=2; WHILE +uuuuwv");pause;page ELSEsysout(""); IFuuuuvu="printer" THENprint(uuuuvu+".dd");forget(uuuuvu+".dd",quiet); FI FI.uuuuyy:uuuuxz;putline +(" Datei: "+name(uuuuwv)+" (DatID: "+text(datid(uuuuwv))+")");uuuuwy:=compress(text(uuuuuv(uuuuwv),15,0));uuuuwy:=subtext(uuuuwy,1,length(uuuuwy)-1);putline(" Anzahl Schlüsselfelder: " ++text(anzkey(uuuuwv))+" Befugnis: "+text(befugnis(uuuuwv))+" Datensätze: "+uuuuwy);putline(" Feld Typ Länge XN YN XF YF Befug 1234567890123456" +);uuuuwv INCR1;uuuuwx:=1; WHILEuuuuwv23 THENwrite(text(name(uuuuwv),23)+"<") ELSEwrite +(text(name(uuuuwv),23)+" ") FI;write(code(feldtyp(uuuuwv))+" "); IFfeldtyp(uuuuwv)=realfeld THENuuuuwy:=text(einglaenge(uuuuwv))+"."+text(nachkomma(uuuuwv));write +(text("",5-length(uuuuwy)));write(uuuuwy+" ") ELSEwrite(text(einglaenge(uuuuwv),5)+" ") FI;write(text(posxname(uuuuwv),2)+" ");write(text(posyname(uuuuwv),2)+" ") +;write(text(posxfeld(uuuuwv),2)+" ");write(text(posyfeld(uuuuwv),2)+" ");write(text(befugnis(uuuuwv),5)+" ");uuuwuy;line;uuuuwv INCR1; END REP;uuuuyu.uuuwvv:3*" " +.uuuuzw:uuuuyu;line;write("INITIALISIERUNGEN");line;line;uuuuwv:=3; WHILEuuuuwv"" CANDuuuwwv(uuuuwv) THENputline(text(uuuwvv ++"zu Feld "+text(text(uuuuwv),4)+": "+initialisierung(uuuuwv),76)) FI;uuuuwv INCR1 PER;line.uuuuzx:uuuuyu;line;write("PLAUSIBILITÄTEN");line;line;uuuuwv:=3; WHILE +uuuuwv"" CANDuuuwwv(uuuuwv) THENputline(text(uuuwvv+"zu Feld "+text(text(uuuuwv),4)+": "+plausi(uuuuwv),76)) FI;uuuuwv INCR1 PER; +line.uuuuzy:uuuuyu;line;write("HILFSTEXTNUMMERN");line;line;uuuuwv:=3; WHILEuuuuwv0 THENputline(uuuwvv+"zu Feld "+text(text(uuuuwv +),4)+": "+text(hilfstextnr(uuuuwv))) FI;uuuuwv INCR1 PER;line.uuuuzz:uuuuyu;line;write("STANDARD-AKTIONEN");line;line;uuuuwv:=3; WHILEuuuuwv1 CANDwas(uuuyuz)<>dateieintrag CANDwas(uuuyuz)<>indexeintrag ENDPROCuuuwwv; ENDPACKETddinfopacket; + diff --git a/app/eumelbase/2.2.1-schulis/src/db ersatz.sc b/app/eumelbase/2.2.1-schulis/src/db ersatz.sc new file mode 100644 index 0000000..bb8121d --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db ersatz.sc @@ -0,0 +1,9 @@ + PACKETdbersatz DEFINESinitsavedupdateposition,getsavedupdateposition,saveupdateposition,restoreupdateposition,changeindex,createdb,destroydb,updatedb,fetchdb,fetchdd +,restoredb,postfix,db,definedserverstation: INT PROCdefinedserverstation:station(myself) ENDPROCdefinedserverstation; PROCfetchdb( TEXT CONSTuuuuuy): ENDPROCfetchdb +; PROCfetchdd( TEXT CONSTuuuuuy): ENDPROCfetchdd; PROCrestoredb( TEXT CONSTuuuuuy): ENDPROCrestoredb; TEXT VARuuuuwu:=".archive"; TEXT PROCpostfix:uuuuwu ENDPROCpostfix +; PROCpostfix( TEXT CONSTuuuuuy):uuuuwu:=uuuuuy ENDPROCpostfix; THESAURUS PROCdb:emptythesaurus ENDPROCdb; PROCinitsavedupdateposition( INT CONSTuuuuyu):putplausi +(uuuuyu,"") ENDPROCinitsavedupdateposition; PROCgetsavedupdateposition( INT CONSTuuuuyu):puttupel(plausi(uuuuyu)); ENDPROCgetsavedupdateposition; PROCrestoreupdateposition +( INT CONSTuuuuyu):puttupel(plausi(uuuuyu));putplausi(uuuuyu,"") ENDPROCrestoreupdateposition; PROCsaveupdateposition( INT CONSTuuuuyu):putplausi(uuuuyu,gettupel) + ENDPROCsaveupdateposition; BOOL PROCcreatedb( TEXT CONSTuuuvuz): TRUE ENDPROCcreatedb; BOOL PROCupdatedb( TEXT CONSTuuuvuz): TRUE ENDPROCupdatedb; BOOL PROCdestroydb +( TEXT CONSTuuuvuz):cleardb(uuuvuz); TRUE ENDPROCdestroydb; PROCchangeindex: ENDPROCchangeindex; ENDPACKETdbersatz; + diff --git a/app/eumelbase/2.2.1-schulis/src/db kernel.sc b/app/eumelbase/2.2.1-schulis/src/db kernel.sc new file mode 100644 index 0000000..7d6d1cd --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db kernel.sc @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + +� +#����# diff --git a/app/eumelbase/2.2.1-schulis/src/db manager.sc b/app/eumelbase/2.2.1-schulis/src/db manager.sc new file mode 100644 index 0000000..edba990 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db manager.sc @@ -0,0 +1,18 @@ + PACKETdbmanager DEFINESgeneratedbmanager: LETuuuuuv=0,uuuuuw=1,uuuuux=2,#uuuuuy=3,uuuuuz=4,#uuuuvu=5,uuuuvv=12,uuuuvw=30,uuuuvx=31,uuuuvy=32,uuuuvz=33,uuuuwu=100 +; DATASPACE VARuuuuwv:=nilspace,uuuuww:=nilspace; TASK VARuuuuwx:=niltask,uuuuwy:=niltask; INT VARuuuuwz,uuuuxu:=0,uuuuxv; BOOL VARuuuuxw:= FALSE; BOUND TEXT VARuuuuxx +; BOUND STRUCT( TEXTname,uuuuxy,uuuuxz) VARuuuuyu; TEXT VARuuuuyv:=""; PROCuuuuyw: IFiserror THENforget(uuuuwv);uuuuwv:=nilspace;uuuuxx:=uuuuwv; CONCR(uuuuxx):=errormessage +;clearerror;send(uuuuwx,uuuuux,uuuuwv) FI ENDPROCuuuuyw; PROCgeneratedbmanager:break;setautonom;disablestop; REPwait(uuuuwv,uuuuwz,uuuuwx);#continue(2);write("Order :" ++text(uuuuwz)+" O-Task :"+name(uuuuwx));pause;break;# IFuuuuxw CANDuuuuwx<>uuuuwy THENuuuvvx ELSEcontrol FI;uuuvvy PER.uuuvvy: IFheapsize>uuuuxu+2 THENcollectheapgarbage +;uuuuxu:=heapsize FI. ENDPROCgeneratedbmanager; PROCcontrol:commanddialogue( FALSE);#enablestop;# SELECTuuuuwz OF CASEuuuuvw:uuuvwz CASEuuuuvx:uuuvxv CASEuuuuvz:uuuvxx + CASEuuuuvy:uuuvxz CASEuuuuvu,uuuuvv:uuuvyw OTHERWISE: IFuuuuwz>=uuuuwu ANDuuuuwx=supervisor THENforget(uuuuwv);uuuvzv ELSEerrorstop("Falscher Auftrag fuer EUMELbase-Manager-Task ""MM""!" +);uuuuyw FI; END SELECT.uuuvxz:uuuuww:=uuuuwv;forget(uuuuwv); IFuuuwuv<>niltask THENerrorstop("Datenbank-Server bereits vorhanden");uuuuyw ELSEuuuwux;uuuuxw:= TRUE +;uuuwuz FI.uuuvxv:uuuuww:=uuuuwv;forget(uuuuwv); IFuuuwuv<>niltask THENend(uuuwuv) FI;uuuwuz.uuuvwz:uuuuxw:= FALSE;send(uuuwuv,uuuuuv,uuuuww,uuuuxv); IFuuuuxv<>uuuuuv + THENforget(uuuuww) FI.uuuvyw: IF NOTuuuuxw THENuuuuyu:=uuuuwv;uuuuyv:=uuuuyu.name; IFexists(uuuuyv) THENforget(uuuuyv,quiet) FI;uuuuwy:=uuuuwx;send(uuuuwx,uuuuvu +,uuuuwv);uuuuxw:= TRUE ELSEuuuuxw:= FALSE;copy(uuuuwv,uuuuyv);uuuwuz FI.uuuvxx:uuuuww:=uuuuwv;forget(uuuuwv); IFuuuwuv<>niltask THEN REPsend(uuuwuv,uuuuvz,uuuuww, +uuuuxv) UNTILuuuuxv=uuuuuv PER; ELSEuuuvxz FI;uuuwuz. END PROCcontrol; TASK PROCuuuwuv: TASK VARuuuxxu;disablestop;clearerror;uuuxxu:=task(uuuxxw); IFiserror THEN +uuuxxu:=niltask FI;clearerror;enablestop;uuuxxu ENDPROCuuuwuv; TEXT PROCuuuxxw:forget("X",quiet);copy(uuuuww,"X"); IFdbopen("X") THENname(1) ELSE"???" FI ENDPROCuuuxxw +; PROCuuuwux:begin(uuuxxw, PROCautonomserver,uuuuwy) END PROCuuuwux; PROCuuuwuz:forget(uuuuwv);uuuuwv:=nilspace;send(uuuuwx,uuuuuv,uuuuwv) END PROCuuuwuz; PROCuuuvvx +:forget(uuuuwv);uuuuwv:=nilspace;send(uuuuwx,uuuuuw,uuuuwv) END PROCuuuvvx; TEXT VARuuuyvx:=""; PROCuuuvzv:enablestop;continue(uuuuwz-uuuuwu);disablestop; REPcommanddialogue +( TRUE);getcommand("Gib DB-Kommando (NUR AUTHORISIERTES PERSONAL !):",uuuyvx);do(uuuyvx) UNTIL NOTonline PER;commanddialogue( FALSE);break(quiet);setautonom END PROC +uuuvzv; BOOL OP<>( TASK CONSTuuuywy,uuuywz): NOT(uuuywy=uuuywz) ENDOP<>; ENDPACKETdbmanager; + diff --git a/app/eumelbase/2.2.1-schulis/src/db memory.sc b/app/eumelbase/2.2.1-schulis/src/db memory.sc new file mode 100644 index 0000000..7d6d1cd --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db memory.sc @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + +� +#����# diff --git a/app/eumelbase/2.2.1-schulis/src/db q.sc b/app/eumelbase/2.2.1-schulis/src/db q.sc new file mode 100644 index 0000000..c1e1d4f --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db q.sc @@ -0,0 +1,100 @@ +#$ IFmitinternerquery THEN# PACKETqueryparser DEFINES QUERY,query,getscanbedingung,getdnr,getinr,getanzahlverbunde,getselpointer,getstopbedpointer,getquery,putquery +,setzeschluessel,getanzahltupel,getswanzfld,getswnachfld,getswvonfld,getswallefelder,getswfwert,getsohnverb,getbruderverb,geterstestupel,puterstestupel,selektionerfuellt +,initquery,:=,baumdurchlauf,listeschluessel,putletzterverbund,getletzterverbund,puttid,gettid,getbruder,putbruder,tidfeld,updatefnr,updateausdruck,queryart,anzupdatefelder +: TYPE UPDSTACK= STRUCT( INTuuuuuv, TEXTuuuuuw); BOUND ROW100 UPDSTACK VARuuuuux; TYPE VERBELEMENT= STRUCT( TEXTuuuuuy,uuuuuz, BOOLuuuuvu, INTuuuuvv,uuuuvw,uuuuvx +,uuuuvy,uuuuvz,uuuuwu); TYPE VERBUND= ROWuuuuwv VERBELEMENT; TYPE QUERY= STRUCT( INTuuuuww,uuuuwx,uuuuwy, TEXTuuuuwz,uuuuxu, SELEKTIONuuuuxv, VERBUNDuuuuxw, SCHLUESSEL +uuuuxx); TYPE SWERT= STRUCT( INTuuuuxy,uuuuxz, TEXTwert); TYPE SCHLUESSELWERTE= STRUCT( BOOLuuuuyu, INTuuuuyv, ROWuuuuyw SWERTuuuuyx); TYPE SCHLUESSEL= ROWuuuuwv SCHLUESSELWERTE +; LETuuuuyz=0,uuuuzu=1,uuuuzv=2,uuuuzw=3,uuuuzx=6,uuuuzy=5,uuuuzz=7,uuuvuu=7,uuuvuv=4,uuuvuw="BY",uuuvux="UPDATE",uuuvuy="DELETE",uuuvuz=".query",uuuvvu=";",uuuvvv +="(",uuuvvw=")",#uuuvvx=",",uuuvvy="=",uuuvvz=">=",uuuvwu="<=",#uuuvwv="/",uuuvww="""",uuuvwx=".",uuuvwy=":",uuuvwz=" ",uuuvxu=":=",uuuvxv="<",uuuuwv=10,uuuvxx=20 +,uuuuyw=10,uuuvxz=80,uuuvyu=1,uuuvyv=2,uuuvyw=3; INT VARuuuvyx:=-5,uuuvyy:=-33,uuuvyz; DATASPACE VARuuuvzu:=nilspace; INT VARuuuvzv:=0; INT PROCtidfeld:uuuvyy ENDPROC +tidfeld; FILE VARuuuvzz; TEXT VARuuuwuu:="",uuuwuv:="",uuuwuw:="",uuuwux:=""; INT VARuuuwuy,uuuwuz,uuuwvu; BOOL VARuuuwvv,uuuwvw; INT VARuuuwvx:=0,uuuwvy,uuuwvz; ROW +uuuvxx TEXT VARuuuwwv; OP:=( QUERY VARuuuwww, QUERY CONSTuuuwwx): CONCR(uuuwww):= CONCR(uuuwwx) ENDOP:=; OP:=( VERBELEMENT VARuuuwww, VERBELEMENT CONSTuuuwwx): CONCR +(uuuwww):= CONCR(uuuwwx) ENDOP:=; OP:=( VERBUND VARuuuwww, VERBUND CONSTuuuwwx): CONCR(uuuwww):= CONCR(uuuwwx) ENDOP:=; INT PROCupdatefnr( INT CONSTuuuwyx):uuuuux +[uuuwyx].uuuuuv ENDPROCupdatefnr; TEXT PROCupdateausdruck( INT CONSTuuuwyx):uuuuux[uuuwyx].uuuuuw ENDPROCupdateausdruck; INT PROCqueryart:uuuvzv ENDPROCqueryart; PROC +queryart( INT CONSTuuuxvu):uuuvzv:=uuuxvu ENDPROCqueryart; INT PROCanzupdatefelder:uuuvyz ENDPROCanzupdatefelder; PROCinitquery( QUERY VARuuuxww):uuuxwx;uuuxww.uuuuww +:=0;uuuxww.uuuuwx:=0;uuuxww.uuuuwz:="";uuuxww.uuuuxu:="";initselektionen(uuuxww.uuuuxv);uuuxyw(uuuxww.uuuuxw);uuuxyz(uuuxww.uuuuxx) ENDPROCinitquery; PROCuuuxwx:forget +(uuuvzu);uuuvzu:=nilspace;uuuuux:=uuuvzu ENDPROCuuuxwx;initquery(uuuyuy); PROCuuuxyw( VERBUND VARuuuyvu): FORuuuwvy FROM1 UPTOuuuuwv REPuuuyvx(uuuyvu[uuuwvy]) PER + ENDPROCuuuxyw; PROCuuuyvx( VERBELEMENT VARuuuyww):uuuyww.uuuuuy:="";uuuyww.uuuuuz:="" ENDPROCuuuyvx;# BOUND QUERY VARuuuyuy;# QUERY VARuuuyuy; PROCgetquery( QUERY + VARuuuxww): CONCR(uuuxww):= CONCR(uuuyuy) ENDPROCgetquery; PROCputquery( QUERY CONSTuuuxww): CONCR(uuuyuy):= CONCR(uuuxww) ENDPROCputquery; PROCquery:query(lastparam +) ENDPROCquery; PROCuuuyzz( TEXT CONSTuuuzuu): TEXT VARuuuzuv:="",uuuzuw:="",uuuzux:="",uuuwuv:=""; INT VARuuuzuz;uuuxwx;uuuzvv;nextsymbol;queryparser(uuuzvx);uuuzvy +;uuuzvz;uuuzwu;uuuzwv;baumdurchlauf;.uuuzvy:nextsymbol; WHILEuuuwuy<>uuuuzz REPuuuzxu;nextsymbol PER.uuuzxu:uuuzuw:=""; IFuuuwuy<>uuuuzu THENuuuzxz("Refinementname erwartet: " ++uuuwuu) ELSEuuuzuv:=uuuwuu;nextsymbol; IFuuuwuu<>uuuvwy THENuuuzxz(uuuvww+uuuvwy+uuuvww+" erwartet: "+uuuwuu) ELSEuuuzzy;putref(uuuzuv,uuuzuw) FI FI.uuuzzy:nextsymbol +; WHILEuuuwuy<>uuuuzz CANDuuuwuu<>uuuvwx REPuuuzuw:=uuuzuw+uuvuvw;nextsymbol PER; IFuuuwuy=uuuuzz THENuuuzxz("Refinement nicht mit ""."" abgeschlossen") FI.uuuzvv +:enablestop;uuuvzz:=sequentialfile(input,uuuzuu); IFexists(uuuzuu+uuuvuz) THENforget(uuuzuu+uuuvuz,quiet) FI;#uuuyuy:=new(uuuzuu+uuuvuz);#lastparam(uuuzuu);uuvuxz +(0);uuuwvx:=0;clearrefs;scan(uuuvzz);.uuuzwu: FORuuuzuz FROM1 UPTOuuuwvx REPuuuzux:="";uuuwuv:=uuvuzv(uuuzuz);scan(uuuwuv);nextsymbol(uuuwuu,uuuwuy); WHILEuuuwuy<> +uuuuzz REP IFuuuwuy=uuuuzu THENuuuzux:=uuuzux+getreftext(uuuwuu) ELSEuuuzux:=uuuzux+uuvuvw FI;nextsymbol(uuuwuu,uuuwuy) PER;uuvvwu(uuuzux,uuuzuz) PER.uuuzwv: INT VAR +uuvvwy;initsel(uuuyuy.uuuuxv); FORuuuzuz FROM1 UPTOgetanzahlverbunde REPuuvvxx;uuvvxy PER.uuvvxx:uuvvwy:=getstopbedpointer(uuuzuz); IFuuvvwy>uuuuyz THENuuuwuv:=uuvuzv +(uuvvwy);uuvvzw(baueselektionauf(uuuyuy.uuuuxv,uuuwuv),uuuzuz) FI.uuvvxy:uuvvwy:=getselpointer(uuuzuz); IFuuvvwy>uuuuyz THENuuuwuv:=uuvuzv(uuvvwy);uuvwvy(baueselektionauf +(uuuyuy.uuuuxv,uuuwuv),uuuzuz) FI. ENDPROCuuuyzz; PROCuuuzvz: INT VARuuuzuz:=1; BOOL VARuuvwxu:= FALSE; TEXT VARuuuzux:=""; WHILEuuuzuz<=getanzahlverbunde REPuuuzux +:="";uuuwuv:=getscanbedingung(uuuzuz);scan(uuuwuv);nextsymbol(uuuwuu,uuuwuy); WHILEuuuwuy<>uuuuzz REP IFuuuwuy=uuuuzu THENuuuzux:=uuuzux+getreftext(uuuwuu) ELSEuuuzux +:=uuuzux+uuvuvw FI;nextsymbol(uuuwuu,uuuwuy) PER; IFgetdnr(uuuzuz)=uuuvyx THENqueryparser(uuuzux,uuuzuz);uuvwxu:= TRUE ELSEuuvxwu(uuuzux,uuuzuz) FI;uuuzuz INCR1 PER +; IFuuvwxu THENuuuzvz FI ENDPROCuuuzvz; PROCqueryparser( TEXT CONSTuuuwuv, INT CONSTuuvxxx): INT VARuuvxxy;scan(uuuwuv);nextsymbol;uuvxyu;queryparser(uuvxxx);uuvxyx +.uuvxyu:uuvxxy:=getbruderverb(uuvxxx);.uuvxyx:uuvxzx(uuvxxy,uuvxxx). ENDPROCqueryparser; PROCqueryparser( INT CONSTuuvxxx): TEXT VARuuvyux:=""; BOOL VARuuvyuy:= FALSE +;uuuvzv:=0; REPuuvyvu; UNTILuuvyuy PER;uuvyvw;uuvyvx;uuvyvy;uuvyvz; SELECTuuuvzv OF CASEuuuvyv,uuuvyu:uuvywx; IFuuvxxx=1 THENuuvywz FI CASEuuuvyw:uuvyxv ENDSELECT +.uuvyvu: IFuuuwuy=uuuvuv THENuuvyxz(dateinr(uuuwuu),uuvxxx); IFuuuvzv<1 THENuuuvzv:=uuuvyu FI;uuvyuy:= TRUE ELSE IFuuuwuy=uuuuzv THEN IFuuuwuu=uuuvux THENnextsymbol +;uuuvzv:=uuuvyw ELIFuuuwuu=uuuvuy THENnextsymbol;uuuvzv:=uuuvyv ELSEuuuzxz("Dateiname nicht gefunden: "+uuuwuu) FI FI FI.uuvyvw:nextsymbol; IFuuuwuy=uuuuzv CANDuuuwuu +=uuuvuw THENuuvzvz;uuvzwu ELSE IFuuuwuy=uuuuzx CANDuuuwuu=uuuvvv THENuuvzwz(#getdnr(uuvxxx)#0,uuvxxx) ELSEuuuzxz("Indexname bzw. ""("" fehlt") FI FI.uuvzvz:nextsymbol +; IFuuuwuy=uuuvuv THENuuvzwz(indexnr(uuuwuu),uuvxxx) ELSEuuuzxz("Indexname nicht gefunden: "+uuuwuu) FI.uuvzwu:nextsymbol; IF NOT(uuuwuy=uuuuzx CANDuuuwuu=uuuvvv) + THENuuuzxz(uuuvww+uuuvvv+uuuvww+" erwartet") FI.uuvyvx:uuwuuy(uuuwuv);uuvxwu(uuuwuv,uuvxxx);.uuvyvy: BOOL VARstop:= TRUE;uuwuvy.uuvyvz:stop:= FALSE;uuwuvy.uuwuvy +: INT VARuuvvwy;uuuwuw:=""; IF NOTuuuwvv THENuuwuuy(uuuwuw); IFuuuwuw="" THEN IFstop THENuuvvzw(uuuuyz,uuvxxx) ELSEuuvwvy(uuuuyz,uuvxxx) FI ELSEuuvvwy:=uuwuyx; IF +stop THENuuvvzw(uuvvwy,uuvxxx) ELSEuuvwvy(uuvvwy,uuvxxx) FI;uuvvwu(uuuwuw,uuvvwy) FI ELSEuuvwvy(uuuuyz,uuvxxx) FI.uuvywx: INT VARuuwvuz; IF NOTuuuwvv THENuuwvvv(uuvxxx +,uuwvuz);uuwvvy(uuwvuz,uuvxxx);uuvxzx(uuuuyz,uuvxxx) FI.uuvywz:nextsymbol; IFuuuwuy=uuuuzx ORuuuwuy=uuuuzz ORuuuwuy=uuuuzy THEN IFuuuwuu<>uuuvwv THENuuwvyv FI;uuuuwx +;uuwvyx ELSEuuuzxz(uuuvww+uuuvwv+uuuvww+" bzw. "+uuuvww+uuuvvu+uuuvww+uuuvwv+uuuvww+uuuvwx+uuuvww+" erwartet") FI.uuwvyv: IFuuuwuu=uuuvvu ORuuuwuu=uuuvwx ORuuuwuy +=uuuuzz THENuuwwvy(0); LEAVEuuvywz ELSEuuuzxz("Falscher Tupelzahl-Operator: "+uuuwuu) FI.uuuuwx:nextsymbol; IFuuuwuy=uuuuzw THENuuwwvy(int(uuuwuu)); ELSEuuuzxz("Keine Zahlenangabe: " ++uuuwuu) FI.uuwvyx:nextsymbol; IFuuuwuy<>uuuuzz CAND( NOT(uuuwuu=uuuvvu CORuuuwuu=uuuvwx)) THENuuuzxz("""."" oder "";"" erwartet") FI.uuvyxv:uuuvyz:=0;nextsymbol; + WHILE NOTuuuwvv REPuuuvyz INCR1;uuwwzx;uuwwzy;uuwwzz; PER.uuwwzx: IFuuuwuy=uuuuzu THENuuwxux ELSEuuwxuy FI.uuwxux:uuuzxz("Zur Zeit keine Refinements in Update-Liste erlaubt!" +).uuwxuy:uuuuux[uuuvyz].uuuuuv:=feldnr(uuuwuu); IFuuuuux[uuuvyz].uuuuuv<3 THENuuuzxz("Falscher Feldname: "+uuuwuu) FI;nextsymbol.uuwwzy: IF NOT(uuuwuy=uuuuzy CAND +uuuwuu=uuuvxu) THENuuuzxz("Keine Zuweisung: "+uuuwuu) FI.uuwwzz:uuwxyv(uuvyux);uuuuux[uuuvyz].uuuuuw:=uuvyux;nextsymbol. ENDPROCqueryparser; PROCuuwxyv( TEXT VARuuwxzx +): INT VARuuwxzy:=0,uuwxzz:=0;uuwxzx:="";uuuwuu:="";uuuwuy:=0; REPuuwxzx:=uuwxzx+uuvuvw;uuwxzy:=uuuwuy;nextsymbol UNTILuuwyvw PER.uuwyvw: IF(uuuwuy=uuuuzx CAND(uuuwuu +=uuuvvu COR(uuuwuu=uuuvvw CANDuuwxzz=0))) THENuuuwvv:=uuuwuu=uuuvvw; TRUE ELSE IFuuuwuy=uuuuzz THENuuuzxz("Vorzeitiges END OF FILE!"); FALSE ELSE IFuuuwuy=uuuuzx THEN + IFuuuwuu=uuuvvv THENuuwxzz INCR1 FI; IFuuuwuu=uuuvvw THENuuwxzz DECR1 FI; FI; FALSE FI FI. ENDPROCuuwxyv; PROCuuwvvv( INT CONSTuuvxxx, INT VARuuwvuz): INT VARuuwyzz +:=uuuuyz;uuwvuz:=uuuuyz;nextsymbol; IFuuuwuy=uuuuzx CANDuuuwuu=uuuvvw THENuuuwvv:= TRUE; LEAVEuuwvvv ELIFuuuwuy=uuuuzu THENuuwvuz:=uuuzvx;uuvxwu(uuuwuu,uuwvuz);uuvwvy +(uuuuyz,uuwvuz);uuvyxz(uuuvyx,uuwvuz);uuwvvv(uuwvuz,uuwyzz);uuvxzx(uuwyzz,uuwvuz) ELIFuuuwuy=uuuvuv THENuuwvuz:=uuuzvx;queryparser(uuwvuz);uuuwvv:= FALSE;uuwvvv(uuwvuz +,uuwyzz);uuvxzx(uuwyzz,uuwvuz) ELIF(uuuwuy=uuuuzx CANDuuuwuu=uuuvvu) THENuuwvvv(uuvxxx,uuwvuz) ELSEuuuzxz("Verbund-Fehler bei : "+uuuwuu) FI ENDPROCuuwvvv; PROCuuwuuy +( TEXT VARuuwxzx): INT VARuuwxzy:=0;uuwxzx:="";uuuwuu:="";uuuwuy:=0;uuuwvv:= FALSE; REPuuwxzx:=uuwxzx+uuvuvw;uuwxzy:=uuuwuy;nextsymbol UNTILuuxuyx PER.uuxuyx: IF( +uuuwuy=uuuuzy CANDuuuwuu=uuuvwv) THEN TRUE ELSE IFuuuwuy=uuuuzz THENuuuzxz(uuuvww+uuuvwv+uuuvww+" fehlt"); FALSE ELSE FALSE FI FI. ENDPROCuuwuuy; TEXT PROCuuvuvw: + IFuuuwuy=uuuvuv THENuuuvww+uuuwuu+uuuvww ELIFuuuwuy=uuuuzv THENuuuvwz+uuuwuu+uuuvwz ELSEuuuwuu FI ENDPROCuuvuvw; PROCnextsymbol:nextsymbol(uuuvzz,uuuwuu,uuuwuy); + ENDPROCnextsymbol; PROCuuuzxz( TEXT CONSTuuxvxx):errorstop("Zeile "+text(lineno(uuuvzz))+" : "+uuxvxx) ENDPROCuuuzxz; PROCputerstestupel( TEXT CONSTuuxvyw):uuuyuy +.uuuuwz:=uuxvyw ENDPROCputerstestupel; TEXT PROCgeterstestupel:uuuyuy.uuuuwz ENDPROCgeterstestupel; PROCuuxvzz( TEXT CONSTuuxvyw):uuuyuy.uuuuxu:=uuxvyw ENDPROCuuxvzz +; TEXT PROCuuxwuz:uuuyuy.uuuuxu ENDPROCuuxwuz; PROCuuwwvy( INT CONSTuuxwvy):uuuyuy.uuuuwx:=uuxwvy ENDPROCuuwwvy; INT PROCgetanzahltupel:uuuyuy.uuuuwx ENDPROCgetanzahltupel +; PROCputletzterverbund( INT CONSTuuxwxw):uuuyuy.uuuuwy:=uuxwxw ENDPROCputletzterverbund; INT PROCgetletzterverbund:uuuyuy.uuuuwy ENDPROCgetletzterverbund; PROCputtid +( INT CONSTuuxwzu, TEXT CONSTuuxwzv):uuuyuy.uuuuxw[uuxwzu].uuuuuz:=uuxwzv ENDPROCputtid; TEXT PROCgettid( INT CONSTuuxwzu):uuuyuy.uuuuxw[uuxwzu].uuuuuz ENDPROCgettid +; PROCputbruder( INT CONSTuuxwzu, BOOL CONSTuuxxvz):uuuyuy.uuuuxw[uuxwzu].uuuuvu:=uuxxvz ENDPROCputbruder; BOOL PROCgetbruder( INT CONSTuuxwzu):uuuyuy.uuuuxw[uuxwzu +].uuuuvu ENDPROCgetbruder; PROCuuvxwu( TEXT CONSTuuxxyw, INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuuy:=uuxxyw ENDPROCuuvxwu; TEXT PROCgetscanbedingung( INT CONST +uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuuy ENDPROCgetscanbedingung; PROCuuvyxz( INT CONSTuuxyvu,uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvv:=uuxyvu ENDPROCuuvyxz; PROCuuvzwz( INT + CONSTuuxywx,uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvw:=uuxywx ENDPROCuuvzwz; INT PROCgetdnr( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvv ENDPROCgetdnr; INT PROCgetinr +( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvw ENDPROCgetinr; PROCuuvwvy( INT CONSTuuxzuw,uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvx:=uuxzuw ENDPROCuuvwvy; INT PROCgetselpointer +( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvx ENDPROCgetselpointer; PROCuuvvzw( INT CONSTuuxzuw,uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvy:=uuxzuw ENDPROCuuvvzw; INT PROC +getstopbedpointer( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvy ENDPROCgetstopbedpointer; PROCuuvxzx( INT CONSTuuxzuw,uuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvz:=uuxzuw + ENDPROCuuvxzx; INT PROCgetbruderverb( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuvz ENDPROCgetbruderverb; PROCuuwvvy( INT CONSTuuxzuw,uuuzuz):uuuyuy.uuuuxw[uuuzuz +].uuuuwu:=uuxzuw ENDPROCuuwvvy; INT PROCgetsohnverb( INT CONSTuuuzuz):uuuyuy.uuuuxw[uuuzuz].uuuuwu ENDPROCgetsohnverb; PROCuuvuxz( INT CONSTuuyuzu):uuuyuy.uuuuww:= +uuyuzu ENDPROCuuvuxz; INT PROCgetanzahlverbunde:uuuyuy.uuuuww ENDPROCgetanzahlverbunde; INT PROCuuuzvx: INT VARuuyuzu:=getanzahlverbunde+1;uuvuxz(uuyuzu);uuvxzx(uuuuyz +,uuyuzu);uuwvvy(uuuuyz,uuyuzu);uuvxwu("",uuyuzu);uuyuzu ENDPROCuuuzvx; INT PROCuuwuyx:uuuwvx INCR1;uuuwvx ENDPROCuuwuyx; PROCuuvvwu( TEXT CONSTuuuwuw, INT CONSTuuvvwy +):uuuwwv[uuvvwy]:=uuuwuw ENDPROCuuvvwu; TEXT PROCuuvuzv( INT CONSTuuvvwy):uuuwwv[uuvvwy] ENDPROCuuvuzv; PROCbaumdurchlauf: IFmittestausgaben THENuuyvzz FI.uuyvzz: + INT VARuuywuv; FORuuywuv FROM1 UPTOgetanzahlverbunde REPnote("Verbund : "+text(uuywuv));noteline;note(" Datei : "+text(getdnr(uuywuv)));noteline;note(" Index : " ++text(getinr(uuywuv)));noteline;note(" Scan : "+getscanbedingung(uuywuv));noteline;note(" Bruder: "+text(getbruderverb(uuywuv)));noteline;note(" Sohn : "+ +text(getsohnverb(uuywuv)));noteline;note(" SelPoi: "+text(getselpointer(uuywuv)));noteline;noteline; PER;checkselektion(uuuyuy.uuuuxv). ENDPROCbaumdurchlauf; PROC +setzeschluessel( INT CONSTuuxwzu): TEXT VARuuywxy:=getscanbedingung(uuxwzu);scan(uuywxy);nextsymbol;uuywyw;uuywyx;uuywyy;uuywyz; WHILEuuuwuy<>uuuvuu REP IFuuuwuu= +uuuvxv THENnextsymbol;uuywzy(uuxwzu,uuyxuu,uuuwuu);uuyxuw(uuxwzu,uuyxuu,uuyxuz);uuyxvu(uuxwzu,uuyxuu,0); ELIFuuuwuy=uuuvuv THENuuywzy(uuxwzu,uuyxuu,"");uuyxuw(uuxwzu +,uuyxuu,uuyxuz);uuyxvu(uuxwzu,uuyxuu,feldnr(uuuwuu)); ELIFuuuwuu=uuuvvu THENuuyxyu FI;nextsymbol PER;uuyxyv.uuywyx: IFuuuwuy=uuuvuv CANDfeldtyp(feldnr(uuuwuu))=uuuvxz + THENuuywzy(uuxwzu,1,"");uuyxuw(uuxwzu,1,tidfeld);uuyxvu(uuxwzu,1,feldnr(uuuwuu));uuyyux(uuxwzu, TRUE);uuyyuz(uuxwzu,1); LEAVEsetzeschluessel FI;.uuywyz:uuywzy(uuxwzu +,1,"");uuyxuw(uuxwzu,1,0);uuyxvu(uuxwzu,1,0).uuyxyu: IFuuuwvw THENuuyxuz INCR1 ELSEuuuwuz:=uuuwvu+1;uuuwvu:=pos(uuuwux,uuuvvu,uuuwuz);uuyxuz:=uuxyvu+int(subtext(uuuwux +,uuuwuz,uuuwvu-1)) FI;uuyxuu INCR1.uuywyw: INT VARuuyyzv:=getinr(uuxwzu),uuxyvu:=getdnr(uuxwzu),uuyxuz; IFuuyyzv=0 THENuuuwvw:= TRUE;uuyxuz:=uuxyvu+1 ELSEuuuwux:= +zugriff(uuyyzv);uuuwvu:=pos(uuuwux,uuuvvu);uuyxuz:=int(subtext(uuuwux,1,uuuwvu-1))+uuxyvu;uuuwvw:= FALSE FI.uuyzwy: IFuuuwvw THEN(uuyxuz-uuxyvu)=anzkey(uuxyvu) ELSE +uuuwvu=length(uuuwux) FI.uuywyy: INT VARuuyxuu:=1; IFuuuwuy=uuuvuu THENuuyxuu:=0 FI.uuyxyv:uuyyux(uuxwzu,uuyzwy CAND(uuyxuu>0));uuyyuz(uuxwzu,uuyxuu). ENDPROCsetzeschluessel +; PROCuuyxvu( INT CONSTuuxwzu,uuzuux,uuyxuz):uuuyuy.uuuuxx[uuxwzu].uuuuyx[uuzuux].uuuuxy:=uuyxuz ENDPROCuuyxvu; PROCuuyxuw( INT CONSTuuxwzu,uuzuux,uuyxuz):uuuyuy. +uuuuxx[uuxwzu].uuuuyx[uuzuux].uuuuxz:=uuyxuz ENDPROCuuyxuw; INT PROCgetswvonfld( INT CONSTuuxwzu,uuzuux):uuuyuy.uuuuxx[uuxwzu].uuuuyx[uuzuux].uuuuxy ENDPROCgetswvonfld +; INT PROCgetswnachfld( INT CONSTuuxwzu,uuzuux):uuuyuy.uuuuxx[uuxwzu].uuuuyx[uuzuux].uuuuxz ENDPROCgetswnachfld; PROCuuywzy( INT CONSTuuxwzu,uuzuux, TEXT CONSTuuzvwu +):uuuyuy.uuuuxx[uuxwzu].uuuuyx[uuzuux].wert:=uuzvwu ENDPROCuuywzy; TEXT PROCgetswfwert( INT CONSTuuxwzu,uuzuux):uuuyuy.uuuuxx[uuxwzu].uuuuyx[uuzuux].wert ENDPROCgetswfwert +; PROCuuyyux( INT CONSTuuxwzu, BOOL CONSTuuzvzv):uuuyuy.uuuuxx[uuxwzu].uuuuyu:=uuzvzv ENDPROCuuyyux; BOOL PROCgetswallefelder( INT CONSTuuxwzu):uuuyuy.uuuuxx[uuxwzu +].uuuuyu ENDPROCgetswallefelder; PROCuuyyuz( INT CONSTuuxwzu,uuzwvz):uuuyuy.uuuuxx[uuxwzu].uuuuyv:=uuzwvz ENDPROCuuyyuz; INT PROCgetswanzfld( INT CONSTuuxwzu):uuuyuy +.uuuuxx[uuxwzu].uuuuyv ENDPROCgetswanzfld; PROCquery( TEXT CONSTuuzwyw): INT VARuuuzuz;uuuyzz(uuzwyw); FORuuuzuz FROM1 UPTOgetanzahlverbunde REPsetzeschluessel(uuuzuz +) PER;listeschluessel ENDPROCquery; OP:=( SCHLUESSELWERTE VARuuuwww, SCHLUESSELWERTE CONSTuuuwwx): CONCR(uuuwww):= CONCR(uuuwwx) ENDOP:=; OP:=( SWERT VARuuuwww, SWERT + CONSTuuuwwx): CONCR(uuuwww):= CONCR(uuuwwx) ENDOP:=; OP:=( SCHLUESSEL VARuuuwww, SCHLUESSEL CONSTuuuwwx): CONCR(uuuwww):= CONCR(uuuwwx) ENDOP:=; PROClisteschluessel +: IF NOTmittestausgaben THEN LEAVElisteschluessel FI; INT VARuuuzuz,uuywuv; FORuuuzuz FROM1 UPTOgetanzahlverbunde REPnoteline;note("Verbund : "+text(uuuzuz));noteline +;note("=============");noteline;noteline;note("ANZAHL FLD: "+text(getswanzfld(uuuzuz)));noteline;note("ALLE : "+uuzxxx);noteline;noteline; FORuuywuv FROM1 UPTO +getswanzfld(uuuzuz) REPnote(" VON : "+text(getswvonfld(uuuzuz,uuywuv)));noteline;note(" NACH: "+text(getswnachfld(uuuzuz,uuywuv)));noteline;note(" WERT: "+getswfwert +(uuuzuz,uuywuv));noteline; PER PER.uuzxxx: IFgetswallefelder(uuuzuz) THEN"vollständiger Schlüssel" ELSE"unvollständiger Schlüssel" FI. ENDPROClisteschluessel; BOOL + PROCselektionerfuellt( INT CONSTuuzyux):werteselektionaus(uuuyuy.uuuuxv,uuzyux) ENDPROCselektionerfuellt; PROCuuuxyz( SCHLUESSEL VARuuzyvx): FORuuuwvy FROM1 UPTO +uuuuwv REP FORuuuwvz FROM1 UPTOuuuuyw REPuuzyvx[uuuwvy].uuuuyx[uuuwvz].wert:="" PER PER ENDPROCuuuxyz; ENDPACKETqueryparser;#$ FI# + diff --git a/app/eumelbase/2.2.1-schulis/src/db ref.sc b/app/eumelbase/2.2.1-schulis/src/db ref.sc new file mode 100644 index 0000000..1b38c98 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db ref.sc @@ -0,0 +1,10 @@ +#$ IFmitinternerquery THEN# PACKETqueryref DEFINESputref,getreftext,anzahlrefs,listerefs,clearrefs: LETuuuuuv=50,uuuuuw=1,uuuuux=2; LET REFELEMENT= ROW2 TEXT; TYPE + REFINEMENT= STRUCT( INTuuuuuy, ROWuuuuuv REFELEMENTuuuuvu); REFINEMENT VARuuuuvv; PROCputref( TEXT CONSTuuuuvw,uuuuvx): INT VARuuuuvy; FORuuuuvy FROM1 UPTOuuuuvv +.uuuuuy REP IFuuuuvv.uuuuvu[uuuuvy][uuuuuw]=uuuuvw THENuuuuvv.uuuuvu[uuuuvy][uuuuuw]:=uuuuvx; LEAVEputref FI PER; IFuuuuvv.uuuuuy=uuuuuv THENerrorstop("Zuviele Refinements!" +) FI;uuuuvv.uuuuuy INCR1;uuuuvv.uuuuvu[uuuuvv.uuuuuy][uuuuuw]:=uuuuvw;uuuuvv.uuuuvu[uuuuvv.uuuuuy][uuuuux]:=uuuuvx ENDPROCputref; TEXT PROCgetreftext( TEXT CONSTuuuuvw +): INT VARuuuuvy; FORuuuuvy FROM1 UPTOuuuuvv.uuuuuy REP IFuuuuvv.uuuuvu[uuuuvy][uuuuuw]=uuuuvw THEN LEAVEgetreftext WITHuuuuvv.uuuuvu[uuuuvy][uuuuux] FI PER;uuuuvw + ENDPROCgetreftext; PROCclearrefs: INT VARuuuuvy; FORuuuuvy FROM1 UPTOuuuuvv.uuuuuy REPuuuuvv.uuuuvu[uuuuvy][uuuuuw]:="";uuuuvv.uuuuvu[uuuuvy][uuuuux]:="" PER;uuuuvv +.uuuuuy:=0 ENDPROCclearrefs; INT PROCanzahlrefs:uuuuvv.uuuuuy ENDPROCanzahlrefs; PROClisterefs: INT VARuuuwuu;note("Liste der Refinements :");noteline;note("=======================" +);noteline;noteline; FORuuuwuu FROM1 UPTOanzahlrefs REPnote(text(uuuuvv.uuuuvu[uuuwuu][uuuuuw],30)+":"+uuuuvv.uuuuvu[uuuwuu][uuuuux]);noteline PER ENDPROClisterefs +; ENDPACKETqueryref;#$ FI# + diff --git a/app/eumelbase/2.2.1-schulis/src/db sel.sc b/app/eumelbase/2.2.1-schulis/src/db sel.sc new file mode 100644 index 0000000..285e84e --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db sel.sc @@ -0,0 +1,58 @@ + PACKETqueryselektion DEFINES SELEKTION,#putoptyp,putrechts,putlinks,putselwert,#optyp,rechts,links,selwert,fnrlinks,fnrrechts,#allocselelement,#:=,checkselektion +,baueselektionauf,werteselektionaus,mittestausgaben,initselektionen,initsel,initialisiereselektion,lex,lexon,lexoff: LETuuuuuv=0,uuuuuw=1,uuuuux=2,uuuuuy=6,uuuuuz +=7,uuuuvu=8,uuuuvv=9,#uuuuvw=1,uuuuvx=3,#uuuuvy=2,uuuuvz=4,uuuuwu=5,uuuuwv=10,uuuuww=11,uuuuwx=12,uuuuwy=13,uuuuwz=14,uuuuxu=15,uuuuxv=16,uuuuxw=17,uuuuxx=18,uuuuxy +=19,uuuuxz=20,uuuuyu=30,uuuuyv=73,uuuuyw=82,uuuuyx=68,uuuuyy=84; TYPE NODE= STRUCT( INTuuuuyz,uuuuzu,uuuuzv, TEXTselwert); TYPE SELEKTION= STRUCT( INTuuuuzx, ROWuuuuyu + NODEexp); INT VARuuuuzz,uuuvuu,uuuvuv; REAL VARuuuvuw,uuuvux; TEXT VARuuuvuy,uuuvuz; INT VARuuuvvu; TEXT VARuuuvvv:=""; BOOL VARuuuvvw:= FALSE,lexsort:= FALSE; BOOL + PROClex:lexsort ENDPROClex; PROClexon:lexsort:= TRUE ENDPROClexon; PROClexoff:lexsort:= FALSE ENDPROClexoff; PROCmittestausgaben( BOOL CONSTuuuvwy):uuuvvw:=uuuvwy + ENDPROCmittestausgaben; BOOL PROCmittestausgaben:uuuvvw ENDPROCmittestausgaben; OP:=( NODE VARuuuvxz, NODE CONSTuuuvyu): CONCR(uuuvxz):= CONCR(uuuvyu) ENDOP:=; OP +:=( SELEKTION VARuuuvxz, SELEKTION CONSTuuuvyu): CONCR(uuuvxz):= CONCR(uuuvyu) ENDOP:=; PROCinitsel( SELEKTION VARuuuvzw):uuuvzw.uuuuzx:=0 ENDPROCinitsel; PROCinitselektionen +( SELEKTION VARuuuwuv): INT VARuuuwuw; FORuuuwuw FROM1 UPTOuuuuyu REPuuuwuv.exp[uuuwuw].selwert:="" PER ENDPROCinitselektionen; PROCinitialisiereselektion( SELEKTION + VARuuuvzw):initsel(uuuvzw);initselektionen(uuuvzw) ENDPROCinitialisiereselektion; PROCuuuwwy( SELEKTION VARuuuvzw, INT CONSTuuuwxu):uuuvzw.exp[uuuwxu].uuuuyz:=uuuuxy +;uuuvzw.exp[uuuwxu].uuuuzv:=0;uuuvzw.exp[uuuwxu].uuuuzu:=0;uuuvzw.exp[uuuwxu].selwert:="" ENDPROCuuuwwy; INT PROCallocselelement( SELEKTION VARuuuvzw):uuuvzw.uuuuzx + INCR1;uuuwwy(uuuvzw,uuuvzw.uuuuzx);uuuvzw.uuuuzx ENDPROCallocselelement; PROCputoptyp( SELEKTION VARuuuvzw, INT CONSTuuuxvy,optyp):uuuvzw.exp[uuuxvy].uuuuyz:=optyp + ENDPROCputoptyp; PROCuuuxwz( SELEKTION VARuuuvzw, INT CONSTuuuxvy,uuuxxw):uuuvzw.exp[uuuxvy].uuuuzv:=uuuxxw ENDPROCuuuxwz; PROCputrechts( SELEKTION VARuuuvzw, INT + CONSTuuuxvy,uuuxyz):uuuvzw.exp[uuuxvy].uuuuzv:=uuuxyz ENDPROCputrechts; PROCuuuxzz( SELEKTION VARuuuvzw, INT CONSTuuuxvy,uuuxxw):uuuvzw.exp[uuuxvy].uuuuzu:=uuuxxw + ENDPROCuuuxzz; PROCputlinks( SELEKTION VARuuuvzw, INT CONSTuuuxvy,uuuwuw):uuuvzw.exp[uuuxvy].uuuuzu:=uuuwuw ENDPROCputlinks; PROCputselwert( SELEKTION VARuuuvzw, + INT CONSTuuuxvy, TEXT CONSTuuuyxw):uuuvzw.exp[uuuxvy].selwert:=uuuyxw ENDPROCputselwert; INT PROCoptyp( SELEKTION VARuuuvzw, INT CONSTuuuxvy):uuuvzw.exp[uuuxvy]. +uuuuyz ENDPROCoptyp; INT PROCfnrrechts( SELEKTION VARuuuvzw, INT CONSTuuuxvy):uuuvzw.exp[uuuxvy].uuuuzv ENDPROCfnrrechts; INT PROCfnrlinks( SELEKTION VARuuuvzw, INT + CONSTuuuxvy):uuuvzw.exp[uuuxvy].uuuuzu ENDPROCfnrlinks; INT PROCrechts( SELEKTION CONSTuuuvzw, INT CONSTuuuxvy):uuuvzw.exp[uuuxvy].uuuuzv ENDPROCrechts; INT PROC +links( SELEKTION CONSTuuuvzw, INT CONSTuuuxvy):uuuvzw.exp[uuuxvy].uuuuzu ENDPROClinks; TEXT PROCselwert( SELEKTION VARuuuvzw, INT CONSTuuuxvy):uuuvzw.exp[uuuxvy]. +selwert ENDPROCselwert; INT PROCbaueselektionauf( SELEKTION VARuuuzzx, TEXT CONSTuuuzzy): IFcompress(uuuzzy)<>"" THENscan(uuuzzy);uuvuuv(uuuzzx) ELSE0 FI ENDPROCbaueselektionauf +; INT PROCuuvuuv( SELEKTION VARuuuzzx): INT VARuuuwuw,uuvuvv;uuuwuw:=uuvuvx(uuuzzx);nextsymbol; IFuuvuvz=uuuuxx ORuuvuvz=uuuuxv THENuuvuvv:=allocselelement(uuuzzx +);putoptyp(uuuzzx,uuvuvv,uuvuvz);putlinks(uuuzzx,uuvuvv,uuuwuw);putrechts(uuuzzx,uuvuvv,uuvuuv(uuuzzx));uuvuvv ELSEuuuwuw FI ENDPROCuuvuuv; INT PROCuuvuvx( SELEKTION + VARuuuzzx): INT VARuuvvuu;nextsymbol; SELECTuuvuvz OF CASEuuuuuw:uuvvuu:=uuvuuv(uuuzzx);#nextsymbol;# IFuuvuvz<>uuuuux THENerrorstop("Klammer zu fehlt! Gefunden: " ++uuuvvv) FI; CASEuuuuxw:uuvvuu:=allocselelement(uuuzzx);putoptyp(uuuzzx,uuvvuu,uuvuvz);putlinks(uuuzzx,uuvvuu,uuvuvx(uuuzzx)); CASEuuuuuy: CASEuuuuvu:uuvvuu:=allocselelement +(uuuzzx);uuvvyx;uuvvyy;nextsymbol;uuvvyz CASEuuuuvv:uuvvuu:=allocselelement(uuuzzx);uuvvzy;uuvvzz;uuvwuu CASEuuuuuz: OTHERWISE:errorstop("Falsches Symbol: "+uuuvvv ++text(uuuvvu)) ENDSELECT;uuvvuu.uuvvyx:nextsymbol; IFuuuvvu<>uuuuvz THENuuvwvw("Falsche Wertangabe") ELSEputselwert(uuuzzx,uuvvuu,uuuvvv);nextsymbol; IFuuuvvu<>uuuuwu + CANDuuuvvv<>">" THENuuvwvw(""">"" bei Wertangabe fehlt!") FI FI.uuvvzz:nextsymbol; IFuuuvvu<>uuuuwu THENuuvwvw("Falscher Operator: "+uuuvvv) FI;putoptyp(uuuzzx,uuvvuu +,uuvwyv).uuvvyy:nextsymbol; IF(uuuvvu=uuuuwu) COR(uuuvvu=uuuuvy CANDuuuvvv="IN") THENputoptyp(uuuzzx,uuvvuu,uuvwyv) ELSEuuvwvw("Falscher Operator: "+uuuvvv) FI;.uuvvyz +:uuuxwz(uuuzzx,uuvvuu,feldnr(uuuvvv)).uuvvzy:uuuxzz(uuuzzx,uuvvuu,feldnr(uuuvvv)).uuvwuu:nextsymbol; IFuuvuvz=uuuuvu THENuuvvyx ELSEuuvvyz FI. ENDPROCuuvuvx; INT PROC +uuvwyv: IFuuuvvv=">" THENuuuuwz ELIFuuuvvv="<" THENuuuuxu ELIFuuuvvv="=" THENuuuuwv ELIFuuuvvv=">=" THENuuuuwy ELIFuuuvvv="<=" THENuuuuwx ELIFuuuvvv="<>" THENuuuuww + ELIFuuuvvv="IN" THENuuuuxz ELSEuuuuxy FI ENDPROCuuvwyv; PROCnextsymbol:nextsymbol(uuuvvv,uuuvvu) ENDPROCnextsymbol; INT PROCuuvuvz: IFuuuvvv="(" THENuuuuuw ELIFuuuvvv +=")" THENuuuuux ELIFuuuvvv="NOT" ORuuuvvv="NICHT" THENuuuuxw ELIFuuuvvv="AND" ORuuuvvv="UND" THENuuuuxv ELIFuuuvvv="OR" ORuuuvvv="ODER" THENuuuuxx ELIFuuuvvu=13 THEN +uuuuuy ELIFuuuvvu=uuuuwu CANDuuuvvv="<" THENuuuuvu ELIFuuuvvu=uuuuvz THENuuuuvv ELIFuuuvvu=7 THENuuuuuz ELSEuuuuuv FI ENDPROCuuvuvz; PROCuuvwvw( TEXT CONSTuuvyyz) +:errorstop("FEHLERHAFTER AUSDRUCK: "+uuvyyz) ENDPROCuuvwvw; PROCcheckselektion( SELEKTION CONSTuuuzzx): INT VARuuvyzy,uuvyzz:=uuuzzx.uuuuzx;note("Anzahl Knoten: " ++text(text(uuvyzz),5));noteline;noteline;noteline; FORuuvyzy FROM1 UPTOuuvyzz REPnote("Knoten: "+text(uuvyzy));noteline;note(" Operat: "+uuvzvu(uuuzzx.exp[uuvyzy +]));noteline;note(" links : "+text(links(uuuzzx,uuvyzy)));noteline;note(" rechts: "+text(rechts(uuuzzx,uuvyzy)));noteline;note(" Wert : "+">"+uuuzzx. +exp[uuvyzy].selwert+"<");noteline PER ENDPROCcheckselektion; TEXT PROCuuvzvu( NODE CONSTuuuvzw): SELECTuuuvzw.uuuuyz OF CASEuuuuwv:"=" CASEuuuuww:"<>" CASEuuuuwx: +"<=" CASEuuuuwy:">=" CASEuuuuwz:">" CASEuuuuxu:"<" CASEuuuuxw:"NOT" CASEuuuuxv:"AND" CASEuuuuxx:"OR" CASEuuuuxz:"IN" OTHERWISE:"UNDEFINED OPERATOR" ENDSELECT ENDPROC +uuvzvu; BOOL PROCwerteselektionaus( SELEKTION VARuuuvzw, INT CONSTuuvyzy): IFuuvyzy=0 THEN LEAVEwerteselektionaus WITH TRUE FI;uuwuux; SELECTuuwuuy OF CASEuuuuxx: +uuwuvu ORuuwuvv CASEuuuuxv:uuwuvu ANDuuwuvv CASEuuuuxw: NOTuuwuvu CASEuuuuwx:uuwuww CASEuuuuwy:uuwuwy CASEuuuuww:uuwuxu CASEuuuuwv:uuwuxw CASEuuuuxu:uuwuxy CASEuuuuwz +:uuwuyu CASEuuuuxz:uuwuyw OTHERWISE: FALSE ENDSELECT.uuwuvu:werteselektionaus(uuuvzw,links(uuuvzw,uuvyzy)).uuwuvv:werteselektionaus(uuuvzw,rechts(uuuvzw,uuvyzy)). +uuwuux: IFuuwuuy=uuuuxx CORuuwuuy=uuuuxv CORuuwuuy=uuuuxw THEN LEAVEuuwuux ELSEuuwvvz;uuwvwu FI.uuwvvz: IFfnrlinks(uuuvzw,uuvyzy)=0 THEN SELECTuuwvwz OF CASEuuuuyv +:uuuvuu:=int(selwert(uuuvzw,uuvyzy));uuuuzz:=uuuuyv CASEuuuuyw:uuuvuw:=real(selwert(uuuvzw,uuvyzy));uuuuzz:=uuuuyw CASEuuuuyx:uuuvuw:=date(selwert(uuuvzw,uuvyzy)) +;uuuuzz:=uuuuyw OTHERWISE:uuuvuy:=selwert(uuuvzw,uuvyzy);uuuuzz:=uuuuyy ENDSELECT ELSE SELECTfeldtyp(fnrlinks(uuuvzw,uuvyzy)) OF CASEuuuuyv:uuuvuu:=intwert(fnrlinks +(uuuvzw,uuvyzy));uuuuzz:=uuuuyv CASEuuuuyw:uuuvuw:=realwert(fnrlinks(uuuvzw,uuvyzy));uuuuzz:=uuuuyw CASEuuuuyx:uuuvuw:=date(datumwert(fnrlinks(uuuvzw,uuvyzy)));uuuuzz +:=uuuuyw OTHERWISE:uuuvuy:=wert(fnrlinks(uuuvzw,uuvyzy));uuuuzz:=uuuuyy ENDSELECT FI.uuwvwu: IFfnrrechts(uuuvzw,uuvyzy)=0 THEN SELECTuuwxvv OF CASEuuuuyv:uuuvuv:= +int(selwert(uuuvzw,uuvyzy)) CASEuuuuyw:uuuvux:=real(selwert(uuuvzw,uuvyzy)) CASEuuuuyx:uuuvux:=date(selwert(uuuvzw,uuvyzy)) OTHERWISE:uuuvuz:=selwert(uuuvzw,uuvyzy +) ENDSELECT ELSE SELECTfeldtyp(fnrrechts(uuuvzw,uuvyzy)) OF CASEuuuuyv:uuuvuv:=intwert(fnrrechts(uuuvzw,uuvyzy)) CASEuuuuyw:uuuvux:=realwert(fnrrechts(uuuvzw,uuvyzy +)) CASEuuuuyx:uuuvux:=date(datumwert(fnrrechts(uuuvzw,uuvyzy))) OTHERWISE:uuuvuz:=wert(fnrrechts(uuuvzw,uuvyzy)) ENDSELECT FI.uuwxvv: IFfnrlinks(uuuvzw,uuvyzy)=0 THEN +uuuuyy ELSEfeldtyp(fnrlinks(uuuvzw,uuvyzy)) FI.uuwvwz: IFfnrrechts(uuuvzw,uuvyzy)=0 THENuuuuyy ELSEfeldtyp(fnrrechts(uuuvzw,uuvyzy)) FI.uuwuuy:optyp(uuuvzw,uuvyzy +). ENDPROCwerteselektionaus; BOOL PROCuuwuww: SELECTuuuuzz OF CASEuuuuyv:uuuvuu<=uuuvuv CASEuuuuyw:uuuvuw<=uuuvux OTHERWISE:uuuvuy<=uuuvuz ENDSELECT ENDPROCuuwuww +; BOOL PROCuuwuwy: SELECTuuuuzz OF CASEuuuuyv:uuuvuu>=uuuvuv CASEuuuuyw:uuuvuw>=uuuvux OTHERWISE:uuuvuy>=uuuvuz ENDSELECT ENDPROCuuwuwy; BOOL PROCuuwuxy: SELECTuuuuzz + OF CASEuuuuyv:uuuvuuuuuvuv CASEuuuuyw:uuuvuw>uuuvux OTHERWISE: IFlexsort THENuuuvuy LEXGREATERuuuvuz ELSEuuuvuy>uuuvuz FI ENDSELECT ENDPROC +uuwuyu; BOOL PROCuuwuxw: SELECTuuuuzz OF CASEuuuuyv:uuuvuu=uuuvuv CASEuuuuyw:uuuvuw=uuuvux OTHERWISE: IFlexsort THENuuuvuy LEXEQUALuuuvuz ELSEuuuvuy=uuuvuz FI ENDSELECT + ENDPROCuuwuxw; BOOL PROCuuwuxu: SELECTuuuuzz OF CASEuuuuyv:uuuvuu<>uuuvuv CASEuuuuyw:uuuvuw<>uuuvux OTHERWISE: IFlexsort THEN NOT(uuuvuy LEXEQUALuuuvuz) ELSEuuuvuy +<>uuuvuz FI ENDSELECT ENDPROCuuwuxu; BOOL PROCuuwuyw: IFuuuuzz=uuuuyy THENpos(uuuvuz,uuuvuy)>0 ELSE FALSE FI ENDPROCuuwuyw; ENDPACKETqueryselektion; + diff --git a/app/eumelbase/2.2.1-schulis/src/db snd query.sc b/app/eumelbase/2.2.1-schulis/src/db snd query.sc new file mode 100644 index 0000000..2d14756 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db snd query.sc @@ -0,0 +1,18 @@ +#$ IFmitinternerquery THEN# PACKETdbsndquery DEFINESauswertung,auswertungfortsetzen,qsucc,endofscan,ordernewstack,puttiefennr,gettiefennr,endqueryserver: LETuuuuuv +=25,uuuuuw=0,uuuuux=1,uuuuuy=2,uuuuuz=2,uuuuvu=37,uuuuvv=10,uuuuvw=39,uuuuvx=40,uuuuvy=41,uuuuvz=1; INT CONSTendofscan:=8,ordernewstack:=9; INT VARuuuuwu,uuuuwv; DATASPACE + VARuuuuww; BOUND QUERY VARuuuuwx; BOUND TEXT VARuuuuwy; ROWuuuuvv INT VARuuuuxu; TYPE TUPEL= STRUCT( INTuuuuxv,uuuuxw,uuuuxx, TEXTuuuuxy); TYPE QUERYSTACK= STRUCT +( INTuuuuxz, TASKuuuuyu, ROWuuuuuv TUPELuuuuyw); INT VARuuuuyx:=getanzahltupel,uuuuyy; TEXT VARuuuuyz:="",uuuuzu:=""; PROCendqueryserver:forget(uuuuww);uuuuww:=nilspace +;send(uuuuzy,uuuuvx,uuuuww) ENDPROCendqueryserver; TASK VARuuuuzy; BOUND QUERYSTACK VARuuuvux; OP:=( TUPEL VARuuuvuy, TUPEL CONSTuuuvuz): CONCR(uuuvuy):= CONCR(uuuvuz +) ENDOP:=; OP:=( QUERYSTACK VARuuuvuy, QUERYSTACK CONSTuuuvuz): CONCR(uuuvuy):= CONCR(uuuvuz) ENDOP:=; INT PROCgettiefennr( INT CONSTuuuvwv): IFuuuvwv=0 THEN0 ELSE +uuuuxu[uuuvwv] FI ENDPROCgettiefennr; PROCputtiefennr( INT CONSTuuuvwv,uuuvxw):uuuuxu[uuuvwv]:=uuuvxw ENDPROCputtiefennr; PROCauswertung( TEXT CONSTuuuvyv):uuuuyy +:=0;query(uuuvyv); IFqueryart=uuuuvz THENuuuvyz ELSEuuuvzu FI.uuuvyz:uuuvzw;forget(uuuuww);uuuuww:=nilspace;uuuuwx:=uuuuww;getquery(uuuuwx);call(/name(1),uuuuvu,uuuuww +,uuuuwu);uuuwuz;uuuvux:=uuuuww;uuuuzy:=uuuvux.uuuuyu.uuuvzu:forget(uuuuww);uuuuww:=old(uuuvyv);call(/name(1),uuuuvy,uuuuww,uuuuwu);uuuwuz. ENDPROCauswertung; PROC +uuuvzw:uuuuwv:=0;uuuwxx(1) ENDPROCuuuvzw; PROCuuuwxx( INT CONSTuuuwyu):uuuuwv INCR1;puttiefennr(uuuwyu,uuuuwv); IFgetsohnverb(uuuwyu)<>uuuuuw THENuuuwxx(getsohnverb +(uuuwyu)) FI; IFgetbruderverb(uuuwyu)<>uuuuuw THENuuuwxx(getbruderverb(uuuwyu)) FI ENDPROCuuuwxx; PROCauswertung( QUERY VARuuuvyv):queryart(uuuuvz);uuuvzw;uuuuyy:= +0;forget(uuuuww);uuuuww:=nilspace;uuuuwx:=uuuuww;uuuuwx:=uuuvyv;call(/name(1),uuuuvu,uuuuww,uuuuwu);uuuwuz;uuuvux:=uuuuww;uuuuzy:=uuuvux.uuuuyu ENDPROCauswertung; + PROCauswertungfortsetzen:uuuuyy:=0;forget(uuuuww);uuuuww:=nilspace;call(uuuuzy,uuuuvw,uuuuww,uuuuwu);uuuwuz;uuuvux:=uuuuww ENDPROCauswertungfortsetzen; PROCuuuwuz +: IFuuuuwu=uuuuuz THENdbstatus(dberror);uuuuwy:=uuuuww;forget(uuuuww);errorstop(uuuuwy) ELSEdbstatus(uuuuwu) FI ENDPROCuuuwuz; PROCqsucc( INT VARuuuwyu,uuuyuz):uuuuyy + INCR1; IFuuuuyy>uuuvux.uuuuxz THENuuuwyu:=0;uuuyuz:=0;dbstatus(endoffile) ELSEuuuyuz:=uuuvux.uuuuyw[uuuuyy].uuuuxw;#uuuywz(uuuvux.uuuuyw[uuuuyy].uuuuxy[uuuuux]); +uuuyxz(uuuvux.uuuuyw[uuuuyy].uuuuxy[uuuuuy]);#parsetupel(uuuyuz,uuuyzu); IFuuuyzv THENdbstatus(endofscan) ELSEdbstatus(ok) FI FI.uuuyzu:uuuvux.uuuuyw[uuuuyy].uuuuxy +.uuuyzv:uuuwyu:=uuuvux.uuuuyw[uuuuyy].uuuuxv; IFuuuwyu<0 THENuuuwyu:=abs(uuuwyu); TRUE ELSE FALSE FI. ENDPROCqsucc; ENDPACKETdbsndquery;#$ FI# + diff --git a/app/eumelbase/2.2.1-schulis/src/db utils.sc b/app/eumelbase/2.2.1-schulis/src/db utils.sc new file mode 100644 index 0000000..7d6d1cd --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/db utils.sc @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + + + +���� +���� +���� +���� +���� +���� + + + +���� +���� +���� + + +� +#����# diff --git a/app/eumelbase/2.2.1-schulis/src/isp archive manager.sc b/app/eumelbase/2.2.1-schulis/src/isp archive manager.sc new file mode 100644 index 0000000..0a70651 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/isp archive manager.sc @@ -0,0 +1,79 @@ + PACKETisparchivemanager DEFINESisparchivemanager,archivechannel: LETuuuuuv=128,uuuuuw=100,uuuuux=1,uuuuuy=2,uuuuuz=200,uuuuvu=100,uuuuvv=12,uuuuvw=0,#uuuuvx=1,uuuuvy +=2,#uuuuvz=5,uuuuwu=25,uuuuwv=26,#uuuuww=28,uuuuwx=19,uuuuwy=20,#uuuuwz=34,uuuuxu=35,uuuuxv=36,uuuuxw=37,uuuuxx=39,uuuuxy=40,uuuuxz=41,uuuuyu=42,uuuuyv=43,uuuuyw= +44,uuuuyx=45,uuuuyy=46,uuuuyz=47,uuuuzu=48,uuuuzv=10,uuuuzw=5,uuuuzx=7; LET ARCHIVECONTROL= STRUCT( INTuuuuzy, BOOLuuuuzz); BOUND ARCHIVECONTROL VARuuuvuu; TYPE HEADER += STRUCT( TEXTname,date, INTtype, TEXTuuuvuv, INTuuuvuw,uuuvux,uuuvuy,uuuvuz); TYPE DSNAMEN= STRUCT( INTuuuvvu, ROWuuuuuz TEXTuuuvvw); ROWuuuuuz DATASPACE VARuuuvvy +;uuuvvz( TRUE); BOUND DSNAMEN VARuuuvwu; TYPE FILEHEADER= STRUCT( TEXTuuuvwv, INTuuuvww,uuuvwx,uuuvwy, ROWuuuuuv INTuuuvxu); BOUND FILEHEADER VARuuuvxv; BOUND TEXT + VARuuuvxw; BOUND INT VARuuuvxx; BOUND HEADER VARuuuvxy; DATASPACE VARuuuvxz:=nilspace,uuuvyu:=nilspace,uuuvyv:=nilspace,uuuvyw:=nilspace,uuuvyx:=nilspace,uuuvyy:= +nilspace;uuuvyz; INT VARuuuvzu,uuuvzv,uuuvzw,uuuvzx,uuuvzy,uuuvzz,uuuwuu,uuuwuv,uuuwuw,uuuwux,uuuwuy,uuuwuz,uuuwvu,uuuwvv:=1; BOOL VARuuuwvw:= TRUE,uuuwvx:= FALSE +,uuuwvy:= FALSE; INT VARuuuwvz,uuuwwu,uuuwwv,uuuwww,uuuwwx,uuuwwy; TASK VARuuuwwz,uuuwxu:=niltask; BOUND STRUCT( TEXTname,uuuwxv,uuuwxw) VARuuuwxx; FILE VARuuuwxy +; TEXT VARuuuwxz:="",uuuwyu:="",uuuwyv:=""; REAL VARuuuwyw:=clock(1); INT VARuuuwyx:=31; INT PROCarchivechannel:uuuwyx ENDPROCarchivechannel; PROCarchivechannel( INT + CONSTuuuwzw):uuuwyx:=uuuwzw ENDPROCarchivechannel; PROCuuuvyz:forget(uuuvxz);forget(uuuvyu);forget(uuuvyv);forget(uuuvyw);forget(uuuvyx);forget(uuuvyy); ENDPROCuuuvyz +; PROCuuuvvz( BOOL CONSTuuuxvx): INT VARuuuwvz; FORuuuwvz FROM1 UPTOuuuuuz REP IFuuuxvx THENuuuvvy[uuuwvz]:=nilspace FI;forget(uuuvvy[uuuwvz]) PER ENDPROCuuuvvz; PROC +uuuxxv( DATASPACE VARuuuvyw, INT CONSTpage, INT CONSTuuuwuv): INT VARuuuxxy:=0,uuuxxz:=0,uuuxyu; REPblockin(uuuvyw,page,0,uuuwuv,uuuxxy); IFuuuxxy<>0 THENuuuxxz INCR +1;uuuxzu FI UNTILuuuxxy<>2 ORuuuxxz=uuuuzv PER;uuuxzy(uuuxxy,uuuwuv).uuuxzu: IFuuuxxz=uuuuzw THENblockin(uuuvyw,page,0,0,uuuxxy);uuuxxy:=2 FI;. ENDPROCuuuxxv; PROC +uuuyvw( DATASPACE VARuuuvyw, INT CONSTpage, INT CONSTuuuwuv): INT VARuuuxxy:=0,uuuxxz:=0,uuuxyu; REP FORuuuwvz FROM1 UPTOuuuwvv REPblockout(uuuvyw,page,0,uuuwuv,uuuxxy +); UNTILuuuxxy<>0 PER; IFuuuwvy CANDuuuxxy=0 THENblockin(uuuvyw,page,0,uuuwuv,uuuxxy); FI; IFuuuxxy<>0 THENuuuxxz INCR1;uuuxzu FI UNTILuuuxxy<>2 ORuuuxxz=uuuuzv PER +;uuuxzy(uuuxxy,uuuwuv).uuuxzu: IFuuuxxz=uuuuzw THENdisablestop;uuuvyy:=nilspace;blockin(uuuvyy,2,0,0,uuuxxy);forget(uuuvyy);clearerror;enablestop;uuuxxy:=2 FI;. ENDPROC +uuuyvw; PROCuuuxzy( INT CONSTuuuxxy,uuuzvx): SELECTuuuxxy OF CASE0: CASE1:errorstop("Schreiben/Lesen des Archives unmöglich") CASE2:errorstop("Schreib/Lese-Fehler:" ++text(uuuzvx)) CASE3:errorstop("Archive-Overflow") OTHERWISE:errorstop("Unbekannter Archive-Fehler:"+text(uuuxxy)+"/"+text(uuuzvx)) ENDSELECT ENDPROCuuuxzy; PROCuuuzwx +: INT VARuuuwvz:=1,uuuxxy;forget(uuuvyy);uuuvyy:=nilspace;uuuzxw( TRUE);uuuzxx(text(uuuwvz)); FORuuuwvz FROM1 UPTOarchiveblocks-1 REP IF(uuuwvz MOD50)=0 THENuuuzxx +(text(uuuwvz)); FI;blockin(uuuvyy,1,0,uuuwvz,uuuxxy);uuuxzy(uuuxxy,uuuwvz) PER;uuuzxx(text(uuuwvz));forget(uuuvyy) ENDPROCuuuzwx; PROCuuvuuv:uuuzxw( TRUE);forget( +uuuvxy.name,quiet);uuuwxy:=sequentialfile(output,uuuvxy.name); IFuuuwvw THENuuvuvv ELSEuuvuvw FI;forget(uuuvyw);forget(uuuvyu);uuuvyu:=old(uuuvxy.name);uuuvyw:=uuuvyu +;forget(uuuvyu);forget(uuuvxy.name,quiet);.uuvuvv:uuvuvw; REPuuvuxv;putline(uuuwxy,"! "+text(uuuvxv.uuuvwv,27)+"! "+text(text(uuuvxv.uuuvww),10)+"! "+text(text +(uuuwuw),7)+"! "+text(text(uuuvxv.uuuvwx),11)+"!");uuvuyy;uuuwuw:=uuuwuw+uuuwuz+1;uuuwuv:=uuuwuw+1 UNTILuuvuzy PER.uuvuvw:uuvvuu;putline(uuuwxy,"");putline(uuuwxy +," ARCHIVE: "+text(uuuvxy.name,20)+"erstellt am : "+text(uuuvxy.date,10));putline(uuuwxy,"");putline(uuuwxy,10*" "+" Disketten-Nr. : "+uuvvvv);putline(uuuwxy, +10*" "+" vorige Diskette der Sicherung : "+uuvvvx);putline(uuuwxy,10*" "+" nächste Diskette der Sicherung: "+uuvvvz);putline(uuuwxy,"");putline(uuuwxy,10*" "+" Blöcke insgesamt : " ++text(archiveblocks-1));putline(uuuwxy,10*" "+" Erster freier Block: "+text(uuuvxy.uuuvuw));putline(uuuwxy,"");putline(uuuwxy,"");uuvvxv.uuvvxv:putline(uuuwxy,"! Filename ! Anzahl Blöcke ! ab Block ! erste DS-Seite !" +);putline(uuuwxy,"+----------------------------+---------------+----------+----------------+");uuvuyy.uuvuyy:putline(uuuwxy,"! ! ! ! !" +);.uuvvvv:text(uuuvxy.uuuvuz).uuvvvz:text(uuuvxy.uuuvuy).uuvvvx:text(uuuvxy.uuuvux).uuvuzy:uuuwuv>=uuuvxy.uuuvuw.uuvuxv:uuvwuy;. ENDPROCuuvuuv; PROCuuvwuy:forget( +uuuvxz);uuuvxz:=nilspace;uuuxxv(uuuvxz,1,uuuwuw);uuuvxv:=uuuvxz;uuuwuz:=uuuvxv.uuuvww;uuuwvu:=uuuvxv.uuuvwx ENDPROCuuvwuy; PROCuuvwxx( TEXT CONSTuuvwxy):forget(uuuvyv +);uuuvyv:=nilspace;uuuvxy:=uuuvyv;uuuvxy.name:=uuvwxy;uuuvxy.uuuvuz:=0;uuuvxy.uuuvuy:=0;uuuvxy.uuuvux:=0;uuuvxy.uuuvuw:=-1;uuuvxy.date:=date;uuvxuw ENDPROCuuvwxx; + PROCuuvxuy:uuvvuu;uuuvxy.uuuvuz:=0;uuuvxy.uuuvuy:=0;uuuvxy.uuuvux:=0;uuuvxy.uuuvuw:=-1;uuuvxy.date:=date;uuvxuw ENDPROCuuvxuy; PROCuuuzxw( BOOL CONSTuuvxxu):uuuwvw +:= TRUE;uuvvuu;uuvxxx.uuvxxx: IFuuuvxy.uuuvuw<=0 THENuuuwvw:= FALSE;uuuvxy.uuuvuw:=uuuuuy FI; IFuuvxxu THENuuuwuw:=uuuuuy;uuuvxy.date:=date ELSEuuuwuw:=uuuvxy.uuuvuw + FI;uuuwuv:=uuuwuw+1#;note("Erster freier Block : "+text(uuuvxy.uuuvuw));noteline;note("Startblock : "+text(uuuwuw));noteline;#. ENDPROCuuuzxw; PROCuuvvuu:forget( +uuuvyv);uuuvyv:=nilspace;uuuxxv(uuuvyv,1,uuuuux);uuuvxy:=uuuvyv ENDPROCuuvvuu; PROCuuvxuw:uuuyvw(uuuvyv,nextdspage(uuuvyv,-1),uuuuux) ENDPROCuuvxuw; PROCuuvyxx:uuuwxz +:=uuuuuw*code(0);uuvyyu(1) ENDPROCuuvyxx; PROCuuvyyw:uuuwyu:=uuuuuw*code(0) ENDPROCuuvyyw; PROCuuvyzu( INT CONSTuuvyzv):uuvyzw(uuuwyu,uuvyzv) ENDPROCuuvyzu; INT PROC +uuvzuu( INT CONSTuuvyzv):uuvyzv MOD8 ENDPROCuuvzuu; INT PROCuuvzuy( INT CONSTuuvyzv):(uuvyzv DIV8)+1 ENDPROCuuvzuy; PROCuuvyyu( INT CONSTuuvyzv):uuvyzw(uuuwxz,uuvyzv +) ENDPROCuuvyyu; BOOL PROCuuvzww:uuuwyu=uuuwxz ENDPROCuuvzww; PROCuuvyzw( TEXT VARuuvzxv, INT CONSTuuvyzv): INT VARuuvzxx,bit,uuvzxy;uuvzxx:=uuvzuy(uuvyzv);bit:=uuvzuu +(uuvyzv);uuvzxy:=code(uuvzxv SUBuuvzxx);setbit(uuvzxy,bit);change(uuvzxv,uuvzxx,uuvzxx,code(uuvzxy)) ENDPROCuuvyzw; PROCuuwuuv: IFuuwuuw THENuuwuux ELSEuuwuuy FI. +uuwuuw:uuuwwx=uuuuwz.uuwuux:#uuuwux:=1;#uuuvuu:=uuuvyw;uuuwvv:=uuuvuu.uuuuzy;uuuwvy:=uuuvuu.uuuuzz;uuuwwy:=archiveblocks-1;uuuwwu:=0;uuuwww:=0;uuuwwv:=nextdspage( +uuuvyu,-1);uuwuxz; IFuuuwuv>uuuwwu THENerrorstop("Archive voll!") FI;uuwuyw.uuwuuy:uuuwwy:=archiveblocks-1;uuwuxz;uuwuzu;uuwuzv;uuwuyw.uuwuyw: WHILEuuuwwv>=0 REPuuwuzz +;uuwuzv PER;uuwvuv;uuwvuw;uuvxuw;forget(uuuvyu);uuwvuz.uuwuzz: IFuuuwuv>uuuwwu THENuuwvvx FI;uuwuzu.uuwuzu:#uuuzxx("Block "+text(uuuwuv)+" wird geschrieben !");#uuuyvw +(uuuvyu,uuuwwv,uuuwuv);uuuwww INCR1;uuuvxy.uuuvuw INCR1;uuwvxx;uuuwuv INCR1.uuwvxx:uuwvyu;uuwvyv.uuwvyu:uuuvzu:=uuuwwv-uuuvxv.uuuvwx+1;uuuvzw:=(uuuvzu DIV16)+1;uuuvzv +:=(uuuvzu) MOD16#;note("Seite : "+text(uuuwwv));noteline;note(" rel. Seite : "+text(uuuvzu));noteline;note(" Zeichen : "+text(uuuvzw));noteline;note(" Bit : " ++text(uuuvzv));noteline;#.uuwvyv:setbit(uuuvxv.uuuvxu[uuuvzw],uuuvzv).uuwuzv:uuuwwv:=nextdspage(uuuvyu,uuuwwv).uuwvuw:uuuwwv:=nextdspage(uuuvxz,-1);uuwwwx.uuwwwx: +uuuyvw(uuuvxz,1#uuuwwv#,uuuwuw);uuuvxy.uuuvuw INCR1.uuwwxz:forget(uuuvxz);uuuvxz:=nilspace;uuuvxv:=uuuvxz;uuuvxv.uuuvwy:=type(uuuvyu);uuuvxv.uuuvwx:=uuuwwv;uuuwww +:=0;#note("Erste Seite : "+text(uuuwwv));# FORuuuwvz FROM1 UPTOuuuuuv REPuuuvxv.uuuvxu[uuuwvz]:=0 PER.uuwvuv:uuuvxv.uuuvwv:=uuuwyv;#uuuzxx(uuuwyv+" wird archiviert !" +);#uuuvxv.uuuvww:=uuuwww;#note("Weggeschr. Seiten : "+text(uuuwww));noteline#.uuwvvx:uuwxwy;uuwxwz;#uuwuxz#.uuwxwz:uuwxxw; LEAVEuuwuuv.uuwxwy:uuwvuv;uuwwwx;uuuwux + INCR1;uuuvxy.uuuvuy:=uuuwux;uuvxuw.uuwuxz:uuuzxw( FALSE); IFuuwuuw THENuuwxzx FI;uuuvxy.uuuvuz:=uuuwux;uuuvxy.uuuvux:=uuuwux-1;uuuvxy.uuuvuy:=0;uuuwwu:=archiveblocks +-1;uuwwxz;.uuwxzx: IFuuuvxy.uuuvuz<=0 THENuuuwux:=1 ELSEuuuwux:=uuuvxy.uuuvuz FI. ENDPROCuuwuuv; PROCuuwywy( INT CONSTuuwywz): IFuuwywz=1 THENuuwyxv ELSEuuwyxw FI +.uuwyxv:uuuwxx:=uuuvyw;uuuwyv:=uuuwxx.name;uuwyyw.uuwyxw:forget(uuuwyv,quiet);forget(uuuvyu);uuuvyu:=uuuvyw;uuwyzw. ENDPROCuuwywy; PROCuuwyzy: INT VARuuwyzz,uuwzuu +; SELECTuuuwwx OF CASEuuuuxz:uuwzux CASEuuuuyu:uuwzuz CASEuuuuyv:uuwzvv ENDSELECT.#uuwuuw:uuuwwx=uuuuxz.#uuwzux:uuuwwy:=archiveblocks-1;uuuvzx:=1;uuuvzy:=-1;uuuvzz +:=0;forget(uuuvyx);uuuvyx:=nilspace;uuuvwu:=uuuvyx;uuuwuu:=0;uuvyxx;uuvyyw;uuwuyw.uuwzuz:uuuwwy:=archiveblocks-1;uuwuyw.uuwuyw:uuuzxw( TRUE);uuwzyz; REP REPuuvuxv +;uuwzzv; FORuuuwvz FROM1 UPTOuuuwuz REPuuwzzy PER;uuuwuw:=uuuwuv;uuuwuv:=uuuwuw+1 UNTILuuxuux PER; UNTILuuxuuy PER;uuxuuz;uuxuvu;uuwvuz.uuxuvu:uuuvwu.uuuvvu:=uuuvzz +;forget(uuuvyw);uuuvyw:=uuuvyx;forget(uuuvyx).uuwzvv:uuuvxx:=uuuvyw;uuuwuy:=uuuvxx;forget(uuuvyw);uuuvyw:=uuuvvy[uuuwuy];forget(uuuvvy[uuuwuy]);uuwvuz.uuxuuy: IF NOT +uuvzww THENuuwxwz; FALSE ELSE TRUE FI.uuwxwz:uuwxxw; LEAVEuuwyzy.uuxuux:uuuwuv>=uuuvxy.uuuvuw.uuwzzy:uuuxxv(uuuvvy[uuuwuu],uuxvvu,uuuwuv);uuuwuv INCR1.uuxvvu: REP + FORuuwyzz FROMuuuvzy+1 UPTO15 REP IFbit(uuuvxv.uuuvxu[uuuvzx],uuwyzz) THENuuuvzy:=uuwyzz;#;note("gelesene Seite : "+text(uuxvxu)+"Bit : "+text(uuwyzz));note(" akt. Zeichen : " ++text(uuuvzx));noteline;note(" akt. Bit : "+text(uuuvzy));noteline;# LEAVEuuxvvu WITHuuxvxu FI PER;uuuvzy:=-1;uuuvzx INCR1 UNTILuuuvzx>=uuuuuv PER;-1.uuxvxu +:((uuuvzx-1)*16+uuuvzy)+(uuuwvu-1).uuvuxv:uuvwuy;uuxvzy;uuuvwu.uuuvvw[uuuwuu]:=uuuvxv.uuuvwv;uuuzxx(""""+uuuvxv.uuuvwv+""" wird gelesen!").uuwzzv:type(uuuvvy[uuuwuu +],uuuvxv.uuuvwy);uuuvzx:=1;uuuvzy:=-1.uuxvzy: FORuuwzuu FROM1 UPTOuuuvzz REP IFuuuvxv.uuuvwv=uuuvwu.uuuvvw[uuwzuu] THENuuuwuu:=uuwzuu; LEAVEuuxvzy FI PER;uuuvzz INCR +1;uuuvvy[uuuvzz]:=nilspace;uuuwuu:=uuuvzz.uuwzyz:uuvyzu(uuuvxy.uuuvuz); IFuuuvxy.uuuvux>0 THENuuvyyu(uuuvxy.uuuvux) FI; IFuuuvxy.uuuvuy>0 THENuuvyyu(uuuvxy.uuuvuy +) FI. ENDPROCuuwyzy; PROCuuwyzw:send(uuuwwz,uuuuvw,uuuvyw);forget(uuuvyw) ENDPROCuuwyzw; PROCuuwyyw:send(uuuwwz,uuuuvz,uuuvyw);forget(uuuvyw) ENDPROCuuwyyw; PROCuuwvuz +:forget(uuuvyv);forget(uuuvxz);send(uuuwwz,uuuuxx,uuuvyw);forget(uuuvyw) ENDPROCuuwvuz; PROCuuwxxw:send(uuuwwz,uuuuxv,uuuvyw);forget(uuuvyw) ENDPROCuuwxxw; PROCuuuzxx +( TEXT CONSTuuxyuu): DATASPACE VARuuxyuv:=nilspace;uuuvxw:=uuxyuv;uuuvxw:=uuxyuu;send(uuuwwz,uuuuxw,uuxyuv);forget(uuxyuv);pause(5) ENDPROCuuuzxx; PROCuuxyvz: IFchannel +(myself)<>archivechannel THENarchive("");release(archive);continue(archivechannel) FI ENDPROCuuxyvz; PROCisparchivemanager:globalmanager( PROC( DATASPACE VAR, INT + CONST, INT CONST, TASK CONST)isparchivemanager) ENDPROCisparchivemanager; PROCisparchivemanager( DATASPACE VARuuxyxv, INT CONSTuuxyxw,uuxyxx, TASK CONSTuuxyxy): IF +uuxyxw>=uuuuvu THENforget(uuxyxv);uuxyyw(uuxyxw) ELSEclearerror;enablestop;uuxyyy;forget(uuuvyy);forget(uuuvyw);uuuvyw:=uuxyxv;forget(uuxyxv);uuuwwx:=uuxyxw;uuuwwz +:=uuxyxy; SELECTuuuwwx OF CASEuuuuwu:uuvxuy;uuwvuz CASEuuuuyz:uuuvxw:=uuuvyw;uuvwxx(uuuvxw);uuwvuz CASEuuuuzu:uuuzwx;uuwvuz CASEuuuuwv:uuvuuv;uuwvuz CASEuuuuvv:uuwywy +(uuxyxx) CASEuuuuwz,uuuuxu:uuwuuv CASEuuuuxz,uuuuyu,uuuuyv:uuwyzy CASEuuuuxy:uuxzyz;uuxzzu;uuwvuz CASEuuuuyw:uuuvvz( FALSE);forget(uuuvyw);break(quiet) CASEuuuuyx +:uuuvvz( FALSE);uuxyvz;uuuwxu:=uuuwwz;uuwvuz CASEuuuuyy:uuuvvz( FALSE);uuuwxu:=niltask;break(quiet);uuwvuz OTHERWISE:errorstop("Falscher Auftrag!") ENDSELECT;uuuwyw +:=clock(1) FI.uuxzzu:break(quiet);archive(uuyuvz);commanddialogue( FALSE);disablestop; SELECTuuyuwu OF CASE0:format(archive) CASE1:format(uuyuwu,archive) CASE2:format +(uuyuwu,archive) CASE3:format(uuyuwu,archive) OTHERWISE:errorstop("Falscher Formatcode: "+text(uuyuwu)) ENDSELECT;uuuwvx:=iserror;clearerror;commanddialogue( TRUE +);release(archive);uuxyvz; IFuuuwvx THENerrorstop(errormessage) FI;enablestop;uuvwxx(uuyuvz).uuyuvz:subtext(uuuvxw,2,length(uuuvxw)).uuyuwu:code(uuuvxw SUB1).uuxzyz +:uuuvxw:=uuuvyw.uuxyyy:uuyuzv;uuyuzw;uuuwyw:=clock(1).uuyuzw: IF NOT(uuuwxu=uuxyxy) CANDuuxyxw<>uuuuyx CANDuuxyxw<>uuuuyy CANDuuxyxw<>uuuuyw THENerrorstop("Archive nicht angemeldet" +) FI.uuyuzv: IF NOTuuyvvw THENerrorstop("EUMELbase-Archive wird von Task "+name(uuuwxu)+" benutzt") FI.uuyvvw:uuxyxy=uuuwxu ORuuuwxu=niltask OR NOTexists(uuuwxu) OR +uuyvwx.uuyvwx:abs(uuuwyw-clock(1))>600.0. ENDPROCisparchivemanager; PROCuuxyyw( INT CONSTuuuwwx): TEXT VARuuyvxx:="";enablestop;break(quiet);continue(uuuwwx-uuuuvu +);disablestop; REPcommanddialogue( TRUE);getcommand("Gib ISP-ARCHIVE-Kommando:",uuyvxx);do(uuyvxx) UNTIL NOTonline PER;commanddialogue( FALSE);break(quiet);setautonom + END PROCuuxyyw; PROCuuyvyx( TEXT CONSTtext):break(quiet);continue(1);out(text);continue(archivechannel) ENDPROCuuyvyx; PROCuuxuuz:forget(uuuvyw);uuuvyw:=nilspace + ENDPROCuuxuuz; ENDPACKETisparchivemanager; + diff --git a/app/eumelbase/2.2.1-schulis/src/isp archive.sc b/app/eumelbase/2.2.1-schulis/src/isp archive.sc new file mode 100644 index 0000000..f608a95 --- /dev/null +++ b/app/eumelbase/2.2.1-schulis/src/isp archive.sc @@ -0,0 +1,35 @@ + PACKETisparchive DEFINESarchivefiles,archivesize,savetoarchive,fetchfromarchive,initarchive,cleararchive,cleararchivetask,checkarchive,listarchive,formatarchive, +channelfree,logonarchive,logoffarchive,cleareacharchive,writefactor,readafterwrite,kf: LETuuuuuv=1,uuuuuw=2,uuuuux=34,uuuuuy=35,uuuuuz=25,uuuuvu=26,uuuuvv=36,uuuuvw +=37,uuuuvx=39,uuuuvy=40,uuuuvz=41,uuuuwu=42,uuuuwv=43,uuuuww=44,uuuuwx=45,uuuuwy=46,uuuuwz=47,uuuuxu=48,uuuuxv=200,uuuuxw="�",fehlertext="ARCHIVE-Fehler: "; LET ARCHIVECONTROL += STRUCT( INTuuuuxx, BOOLuuuuxy); BOUND ARCHIVECONTROL VARuuuuxz; INT VARuuuuyu,uuuuyv,uuuuyw,uuuuyx:=1; THESAURUS VARuuuuyy; TEXT VARuuuuyz:=""; BOOL VARuuuuzu:= + FALSE,uuuuzv:= FALSE,uuuuzw:= FALSE; BOUND STRUCT( INTuuuuzx, ROWuuuuxv TEXTuuuuzz) VARuuuvuu; DATASPACE VARuuuvuv; PROCkf( BOOL CONSTuuuvux):uuuuzw:=uuuvux ENDPROC +kf; PROCreadafterwrite( BOOL CONSTuuuuxy):uuuuzv:=uuuuxy ENDPROCreadafterwrite; BOOL PROCreadafterwrite:uuuuzv ENDPROCreadafterwrite; PROCwritefactor( INT CONSTuuuuxy +):uuuuyx:=uuuuxy ENDPROCwritefactor; INT PROCwritefactor:uuuuyx ENDPROCwritefactor; BOOL PROCcleareacharchive:uuuuzu ENDPROCcleareacharchive; PROCcleareacharchive +( BOOL CONSTuuuvyx):uuuuzu:=uuuvyx ENDPROCcleareacharchive; PROCcleararchivetask:logoffarchive;logonarchive ENDPROCcleararchivetask; THESAURUS PROCarchivefiles:uuuuyy + ENDPROCarchivefiles; INT PROCarchivesize:archivesize( SOMEmyself) ENDPROCarchivesize; INT PROCarchivesize( THESAURUS CONSTuuuwvu):uuuuyy:=uuuwvu;uuuuyu:=0;uuuuyv +:=1;uuuuyw:=0;get(uuuuyy,uuuuyz,uuuuyu); WHILEuuuuyu>0 REPuuuuyw INCRstorage(old(uuuuyz));uuuuyv INCR1;get(uuuuyy,uuuuyz,uuuuyu) PER;uuuuyw ENDPROCarchivesize; TASK + PROCuuuwyu:/"isp.archive" ENDPROCuuuwyu; BOUND TEXT VARuuuwyw; BOUND INT VARuuuwyx; DATASPACE VARuuuwyy; INT VARuuuwyz; TASK VARuuuwzu:=niltask; PROCformatarchive +( TEXT CONSTuuuwzw):formatarchive(0,uuuwzw) ENDPROCformatarchive; PROCformatarchive( INT CONSTuuuxuv, TEXT CONSTuuuwzw): IFpos("0123",text(uuuxuv))>0 THENuuuxuy(uuuuvy +,code(uuuxuv)+uuuwzw, TRUE) FI ENDPROCformatarchive; PROCsavetoarchive( THESAURUS CONSTuuuwvu): IFuuuuzu THENcleararchive; FI;do( PROC( TEXT CONST)uuuxwv,uuuwvu); + ENDPROCsavetoarchive; PROCfetchfromarchive:uuuxwz;uuuxxu;uuuxxv.uuuxwz:uuuxxx;call(uuuwyu,uuuuvz,uuuwyy,uuuwyz).uuuxxu: INT VARuuuxyx:=uuuuvz; WHILEuuuwyz<>uuuuvx + REPuuuxzv; IFuuuwyz=uuuuvw THENuuuxzy ELSEuuuxxx;call(uuuwyu,uuuxyx,uuuwyy,uuuwyz) FI PER.uuuxzv: SELECTuuuwyz OF CASEuuuuuw:uuuwyw:=uuuwyy;enablestop;errorstop( +fehlertext+uuuwyw) CASEuuuuvw: IFcommanddialogue THENuuuyvz;uuuwyw:=uuuwyy;out(uuuwyw) FI CASEuuuuvv:uuuyvz; IFuuuywz THENerrorstop("Archivieren inkonsistent abgebrochen" +) FI;uuuxyx:=uuuuwu ENDSELECT.uuuxxv: INT VARuuuyxx;forget(uuuvuv);uuuvuv:=uuuwyy;uuuvuu:=uuuvuv; FORuuuyxx FROM1 UPTOuuuvuu.uuuuzx REP#out("<"+uuuvuu.uuuuzz[uuuyxx +]+">");uuuyvz;#uuuyzy PER;forget(uuuvuv).uuuyzy:uuuxxx;uuuwyx:=uuuwyy;uuuwyx:=uuuyxx;call(uuuwyu,uuuuwv,uuuwyy,uuuwyz);forget(uuuvuu.uuuuzz[uuuyxx],quiet);copy(uuuwyy +,uuuvuu.uuuuzz[uuuyxx]). ENDPROCfetchfromarchive; BOOL PROCuuuywz: REPuuuyvz; IFonline THENout(2*uuuuxw) FI; IFyes("Nachfolgende Archive-Diskette eingelegt") THEN + LEAVEuuuywz WITH FALSE FI UNTILuuuuzw COR( NOTuuuuzw CANDyes("Sicherung wirklich abbrechen")) PER; TRUE ENDPROCuuuywz; PROCuuuxwv( TEXT CONSTuuuzyw#, BOOL PROCuuuzyx +#):save(uuuzyw,uuuwyu); IFcommanddialogue THENuuuyvz;out(""""+uuuzyw+""" wird gesichert!");#uuuyvz# FI;uuuzzx;uuuzzy.uuuzzx:uuuxxx;uuuuxz:=uuuwyy;uuuuxz.uuuuxx:=uuuuyx +;uuuuxz.uuuuxy:=uuuuzv;call(uuuwyu,uuuuux,uuuwyy,uuuwyz);uuvuwv.uuvuwv: WHILEuuuwyz<>uuuuvv REPuuuxzv;uuuxzy PER.uuuzzy: REP IFuuuwyz=uuuuvv THENuuuyvz; IFuuuywz THEN +errorstop("Sichern eventuell inkonsistent abgebrochen!"); LEAVEuuuxwv ELSE IFuuuuzu THENcleararchive; FI;out(""""+uuuzyw+""" wird gesichert!"); FI ELSEuuuxzv FI;uuuxxx +; IF NOTuuvuzu THENcall(uuuwyu,uuuuuy,uuuwyy,uuuwyz) ELSEuuuxzy FI; PER.uuvuzu:uuuwyz=uuuuvw.uuuxzv: SELECTuuuwyz OF CASEuuuuuw:uuuwyw:=uuuwyy;enablestop;errorstop +(fehlertext+uuuwyw) CASEuuuuvx: LEAVEuuuxwv CASEuuuuvw: IFcommanddialogue THENuuuwyw:=uuuwyy;uuuyvz;out(uuuwyw); FI ENDSELECT. ENDPROCuuuxwv; PROCinitarchive( TEXT + CONSTuuvvxu):uuuxuy(uuuuwz,uuvvxu, TRUE) ENDPROCinitarchive; PROCcheckarchive:uuuxuy(uuuuxu) ENDPROCcheckarchive; PROCcleararchive:uuuxuy(uuuuuz) ENDPROCcleararchive +; PROClistarchive:uuuxuy(uuuuvu);forget("ISP-Archive",quiet);type(uuuwyy,1003);copy(uuuwyy,"ISP-Archive");show("ISP-Archive");forget("ISP-Archive",quiet) ENDPROClistarchive +; PROClogonarchive:uuuxuy(uuuuwx,"", FALSE) ENDPROClogonarchive; PROClogoffarchive:uuuxuy(uuuuwy,"", FALSE) ENDPROClogoffarchive; PROCuuuxuy( INT CONSTuuvwvy):uuuxuy +(uuvwvy,"", FALSE) ENDPROCuuuxuy; PROCuuuxuy( INT CONSTuuvwvy, TEXT CONSTuuvwwy, BOOL CONSTuuvwwz):uuvwxu; WHILEuuvwxv REPuuvwxw;uuuxzy PER.uuvwxv:uuuwyz<>uuuuvx. +uuvwxu:uuuxxx; IFuuvwwz THENuuuwyw:=uuuwyy;uuuwyw:=uuvwwy FI;call(uuuwyu,uuvwvy,uuuwyy,uuuwyz).uuvwxw: IFuuuwyz=uuuuvw THEN IFcommanddialogue THENuuuwyw:=uuuwyy;uuuyvz +;out(uuuwyw) FI ELIFuuuwyz=uuuuuw THENuuuwyw:=uuuwyy;enablestop;errorstop(fehlertext+uuuwyw) FI. ENDPROCuuuxuy; PROCuuuxzy: REPforget(uuuwyy);wait(uuuwyy,uuuwyz,uuuwzu +); IF NOT(uuuwzu=uuuwyu) THEN#note("IN WARTE: "+text(uuuwyz)+"/"+name(uuuwzu));noteline;#uuvxxy FI UNTILuuuwzu=uuuwyu PER ENDPROCuuuxzy; PROCuuvxxy:send(uuuwzu,uuuuuv +,uuuwyy) ENDPROCuuvxxy; PROCchannelfree: DATASPACE VARuuvxzw:=nilspace;send(uuuwyu,uuuuww,uuvxzw);forget(uuvxzw) ENDPROCchannelfree; PROCuuuxxx:forget(uuuwyy);uuuwyy +:=nilspace ENDPROCuuuxxx; PROCuuuyvz: IFonline THENline; FI ENDPROCuuuyvz; ENDPACKETisparchive; + -- cgit v1.2.3