Shell Bsh / Kommando Readv
 
StartSeite | ShellBsh/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern

Aus dem Manual zum neuen Kommando readv:

      readv  [[[delim,]offs,]max,]iname ...  =oname ...      (-Z-)
      readv  -name ... iname ... =oname ...
      readv  - iname = =oname -= ... =- ...
      readv          (Standardverwendung nach namen-Anmeldung)
                     ---
                     Etwa wie 'readl', mit Syntax wie 'catv'.
                     Es wird nacheinander aus existierenden Variablen gelesen,
                     die zuvor als iname(n) angemeldet werden müssen.
                     Es wird in bereits existierende Variablen geschrieben,
                     die zuvor als =oname(n) angemeldet werden müssen.
                     Es können bis zu 32 Variablen gleichzeitig
                     angemeldet sein.
                     Eine Anmeldung meldet eine noch nicht angemeldete
                     Variable an oder eine abgemeldete erneut an.
                     Der Lesezeiger des Kommandos wird auf die
                     iVariable gerichtet und es werden initial gesetzt:
                        max   = Variablengröße [Byte]
                        offs  = 0
                        delim = '\n'  (dezimal=10)
                     Eine Anmeldung bei bereits vorliegendem Angemeldetstatus
                     setzt nur den Lesezeiger entsprechend, sofern dabei keine
                     Parameterwerte explizit angegeben sind:
                        d,o,m,iname
                        o,m,iname
                        m,iname
                        d,,,iname
                        d,,m,iname
                        d,o,,iname
                        o,,iname
                        m,iname
                     Wie zu sehen ist, werden die Parameter anhand der
                     Position ihrer Werte erkannt.
                     Variablen, die per Name als 'max' und 'offs' angegeben
                     sind, werden von readv selbst 'ausgepackt':
                        readv o,nmax,iname
                     Selbstverständlich ist $o,$nmax,iname möglich.
                     Hier packt die Shell eben den Inhalt aus.
                     ---
                     Eine Abmeldung -name löscht den Lesezeiger,
                     falls es sich um den aktiven iNamen handelt!
                     Eine Abmeldung - meldet alle iNamen ab
                     und löscht den Lesezeiger.
                     Eine Abmeldung = meldet alle oNamen ab.
                     Eine Abmeldung -= oder =- meldet alle Namen ab
                     und löscht den Lesezeiger.
                     ---
                     Bei Aufruf von readv ohne Argumente wird gelesen
                     und geschrieben und der Lese-Offset dem Delimiter
                     entsprechend weitergesetzt.
                     Die Zielvariablen werden binär gesetzt.
                     Der Delimiter kann auf jeden Wert von 0..255
                     gesetzt werden, und zwar per Dezimalzahl oder durch
                     ein Zeichen ungleich '0'-'9'.
                     Bei delim='\n' wird '\r\n' automatisch berücksichtigt.
                     Durch einen Aufruf »readv« wird $. jeweils auf die
                     Offset-Schrittweite gesetzt, bei Exit==TRUE.
                     Dadurch ist ein Vorliegen von '\r\n' erkennbar.
                     Die Zielvariablen werden durch readv nicht vergrößert,
                     sie müssen vorher schon groß genug sein.
                     Die Größe der Zielvariablen (${#Z}) variiert je nach
                     aktuell darin enthaltener Datenmenge/Zeilenlänge.
                     Eine Veränderung der internen Länge (Claim) jedoch wird
                     bei bei readv angemeldeten Variablen blockiert.
                     (Normalerweise wird die Hälfte eines internen Restes
                      bei Bedarf genutzt.)
                     ---
                     Wie bei readl erfolgt auch bei readv keine Ausgabe
                     des Zeilenvorschubs bzw. des Delimiters.
                     readv braucht keinen abschließenden Delimiter.
                     ---
                     readv retourniert FALSE, sobald der Offset 'max'
                     erreicht hat, vor der Leseabsicht.
                     ---
                     Es gelten folgende Wertegrenzen:
                     max    <= iVariablenlänge
                     offset <= max
                     ---
                     Es ist der Gültigkeitsbereich lokaler Variablen
                     zu beachten!
                     readv erfährt es nicht, wenn angemeldete Variablen
                     durch andere Kommandos gelöscht oder verändert werden!
                     Allerdings informiert der Variablen-Manager readv
                     bei Änderung von Basiszeigern durch realloc().
                     ---
                     Vergleich readv <> readl:
                     -------------------------
                     readv:   3.52 real      3.46 user      0.00 sys
                     readl:  14.38 real      6.05 user      8.09 sys
                     (PIII/700)

                     Test-Script:
                     ------------
                        set Z:.250
                        
                        [ "$1" == readv ] && {
                           set F:.250000
                           catv =F <bsh.c   #7700 Zeilen
                           readv 237747,F =Z
                           to 100 repeat
                           do
                              readv 0,,F
                              while readv
                              do
                                 nop
                              done
                           done
                        }
                        
                        [ "$1" == readl ] && {
                           to 100 repeat
                           do
                              <bsh.c
                              while readl Z
                              do
                                 nop
                              done
                              ><
                           done
                        }
                     Es ist zu beachten, daß Variablen 100 MegaByte groß
                     sein können!
                     Das Kommando catv in Zusammenarbeit mit conv könnte
                     letztlich auch die Aufgabe von readv erfüllen.
                     Jedoch das Lesen bis jeweils zum (angebbaren) Delimiter
                     hat den Ausschlag für readv gegeben.
                     catv kann die Daten von readv weitergeben:
                        catv Z /%r%n =o,,Ziel
                        let "o+=${#Z}+2"
                     .

C-Kode des Ausgabeabschnitts:

   OUTPUT:;
   { int o, ni, no; byte d, *vpi, *vpo; struct rvv *po;
     if (!pi)  bsh_Err(LS16|E_FNOT, "readv: Kein iVariablen-Bezug");
     d=pi->delim; vpi=pi->vsp->p+pi->vsp->ln;
     ni=pi->nmax-pi->offs;
     if (ni<=0)  return 1;
     for (po=0;  (po=readv_va(RV_GETO, 0,0, p=po))!=0;  )  {
        ni = pi->nmax - (o=pi->offs);
        vpo= po->vsp->p + po->vsp->ln;
        no = po->vsp->l - po->vsp->ln; // - 1;
        for (i=0;  ni>0 && i<no && (vpo[i]=vpi[o++])!=d;  --ni,++i);
        if (i>=no)  bsh_Err(LS16|E_LIMIT, "readv: Variablen-Zuweisung");
        if (ni>0 && d=='\n'&&i>0&&vpi[o-2]=='\r')  --i;
        po->vsp->lv=i+1; vpo[i]=0;
     }
     if (!p)  bsh_Err(LS16|E_FNOT, "readv: Kein oVariablen-Bezug");
     Offs=o-pi->offs; pi->offs=o;
   }
   return 0;
   //Var(0, 's', V_S|V_b|V_c, A[0], buf, i);

Siehe auch CeeCompilerGcc.

--hs



StartSeite | ShellBsh/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 19. Juni 2005 0:35 (diff))
Suchbegriff: gesucht wird
im Titel
im Text