Sehr viele bsh-Skripte aus Privat- und Berufsleben

Nachfolgend eine Zusammenstellung aus etwa 295 neueren, alten und ganz alten bsh-Skripten. Es ist erkennbar, da▀ frŘher manche Ausstattungsmerkmale noch nicht vorhanden waren. Weiterhin durften in der Anfangszeit Variablen-Namen fast alle Zeichen enthalten, also nicht nur [a-zA-Z_0-9]. Diese gro▀e Anzahl von Skripten, gepaart mit der Hauptdokumentation, ist gut geeignet, bsh interessierten Personen beizubringen. Diese Datei ist eine ultimative Beispiele-Kollektion.




end=4095
mul=16

for F in  up rnd dwn
do
   echo "//$F:"
   echo "   {"
   for n from 0 to $end repeat
   do
      W=$( ti "$F(sqrt($n*$mul))" )
      prints ss4ss3s "/*" $n "*/  " $W ,
   done
   echo "   },"
done



###  99.bsh  #############################################


#am 3.1.2000 5:00
#7.7.1999 6:00
#ls zeigt erst bei um (>?)180 Tage ńlteren
#Dateien JJJJ an.

M=07 T=07 S=06 m=59

while :
do
   touch -t 1999$M$T$S$m.00 t.bsh
   l t.bsh
   l t.bsh | grep -q 1999 && break
   #let "--M<1" && break
   #let "M<10" && M=0$M
   #let "--T<1" && break
   #let "T<10" && T=0$T
   #let "--S<0" && break
   #let "S<10" && S=0$S
   let "--m<0" && break
   let "m<10" && m=0$m
done



###  C.bsh  #############################################


# define MSK16  0x0810= 2064
#/ start= 0x1d0f= 7439
#CRC:EEDATA von WORD @1 ... @949 einschl.
#       Offs 2 ... 1899 = 1898 Byte
#WORD Crc16(crc, word)

# CRC<--  Buf $offs $len
Crc16()  {
   local n=00 crc_=0007439 byte=000000
   for byte in  $Bytes $Bytes
   do
      prints sf08bsf016b- $((2#, byte)) $((2#, crc_))
      for n from 0 to 7 repeat
      do
         if let "{{crc_&16#8000} ^ {[byte&(1<<n)]<<(15-n)}}&16#ffff"
         then
            (( crc_=  ((((crc_^2064)&2064)<<1)|(crc_<<1))
                     &((((crc_^2064)&2064)<<1)|~(2064<<1)),
               crc_&=16#ffff, crc_|=1
            ))
         else
            (( crc_=  ((((crc_^~2064)&2064)<<1)|(crc_<<1))
                     &((((crc_^~2064)&2064)<<1)|~(2064<<1)),
               crc_&=~1, crc_&=16#ffff
            ))
         fi
      done
      prints sf016  $((2#, crc_))
   done
   return 0
}


for n from 0 to 255 repeat
do
   Bytes="$Bytes $n"
done
Crc16



###  Cccvbm  #############################################

#!/u/bin/bsh

#startx_plus, FreeBSD4.5

set -f

#u==user s==sys,server c==client
#bindir=/usr/X11R6/bin
uc_rc=$HOME/.xinitrc
us_rc=$HOME/.xserverrc
sc_rc=/usr/X11R6/lib/X11/xinit/xinitrc
ss_rc=/usr/X11R6/lib/X11/xinit/xserverrc

[ -s $sc_rc ] && cargs=$sc_rc
[ -s $uc_rc ] && cargs=$uc_rc

[ -s $ss_rc ] && sargs=$ss_rc
[ -s $us_rc ] && sargs=$us_rc

args=cargs
for  A  in  $@
do
   [ "$A" == -- ] && args=sargs continue
   $args="${{args} $A"
done

#  ---------------------------------------------------
sargs=$sargs
ifset sargs || {
   pids=$( ps -wajx | grep '[/ ]xinit .*--' | cut -d'  ' -f2 )
   ps -wajx | grep ' :[0-9]' |
      while read - - ppid - - - - - - cmd
      do
         expr " $pids " :: " $ppid " || continue
         expr "$cmd" :dpy '/[^ ]%{1,} %(:[0-9]%)' || continue
         expr "$cmd" :cmd '%([^ ]%{1,}%) :[0-9]' || continue
         sargs=$cmd displ="$displ$dpy "
      done

   for dpy from 0 to 9 repeat
   do
      echo " :$dpy%c"
      expr "$displ" :: ":$dpy " || sargs="$sargs :$dpy" break
   done
   echo
   if expr "$sargs" :: '/[^ ]%{1,} :[0-9]'
   then  echo trying display :$dpy ...; sleep -m 1700
   else  sargs=''
   fi
}
# /---------------------------------------------------

exec xinit $cargs -- $sargs



###  Cccvbm  #############################################

:
cd /home/bsh
b=/home/cie/wms/cgi/bsh_folso_cgi
Ccc -o$b -DVBM -DCGI bsh.c
mcs -d $b
l $b


###  H.bsh  #############################################


echo "hash%nverbose%nopen schellong.com" > Hftp
echo "user u8888888 rrrrrrrr%nbinary" >> Hftp
for Fh in $( cat H )
do
   echo $Fh
   echo "put $Fh" >> Hftp
   <> $Fh
   while seek + 0 sk; readl Z
   do
      expr "$Z" =:: '<table [^>]*WIDTH="150"  *HEIGHT="35"[^>]*>' || continue
      expr "$Z" =:Z 'WIDTH="150"' = 'WIDTH="150"'
      catv Z =$sk,,0.
      break
   done
   while seek + 0 sk; readl Z
   do
      expr "$Z" =:: '</table>' && break
      ow=0
      expr "$Z" :Z '%.d5' += '.d6' && ow=1
      expr "$Z" =:Z 'width=60' = 'width=72' && ow=1
      expr "$Z" =:Z 'width=40' = 'width=48' && ow=1
      expr "$Z" =:Z 'width="60"' = 'width="72"' && ow=1
      expr "$Z" =:Z 'width="40"' = 'width="48"' && ow=1
      [ ow -eq 1 ] && catv Z =$sk,,0.
   done
   ><
done
echo "quit" >> Hftp



###  M.bsh  #############################################


headEMAIL='From: post@schellong.com
Reply-To: schellong@t-online.de
MIME-Version: 1.0
To: ~email~
Subject: 1000-fach-WebCounter
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit

'
headEMAIL2='From: webmaster@schellong.com
Reply-To: webmaster@schellong.com
MIME-Version: 1.0
To: schellong@t-online.de
Subject: 1000-fach-WebCounter
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit

'
#date=$(date '+%m/%d/%y %H:%M')

Mtxt='
Sehr geehrte/r WebCounter-Kundin/Kunde,

den 1000-fach-Zńhler, den Sie verwenden, hatte ich zu Anfang nur
WŘW WWWW WWWWWW WWWWWWWWWW, WW WWWW .WWWW-WWWWWWW WWW WWWWWW WWWWWWWW
WWWWWWW WWW WWWWWńWWWW WńWWWW WWW WWWWWWWWWWW WWWWWWWW WW W÷WWWW.
WWWW WWWWW WWWWWWW WWWW-WWWW-WńWWWW WWWW WW WWWWW WWWWWWWW.

WW WWW WWWWWWW WWWW WWWWWWWWWWWWWW WWWWWW WWW WWWW WWWWW WWWWW
.WWWW-WWWWWWWWW (WWWWWWWWWWWWWWWWW) ŘWWW WWWWW WWWWWWWW WWWWWWW
WWW WWWWWWW WWWWWWWWWW WWW WWW WW, WW WWW WWWWW WWWWWWW WWWWW-WńWWWW
WWWW WŘW WWW WWWWWWWWWW W÷WWW.
WWW WWWWWW - WWW WW WWWWWWWW WWWWWW WńWWWWWWWWWW WWWWW WWWWWWW WWWŘWW
WWW WńWWWWWW WWWW WWWWW-WWWWWW WWW ─WWWWWWWW.

WWWWW WWWWWW ''WWW WWWWWW WWWWWW'' WWWWWW WW WWW WWWWWWWWW WWWWWW
WńWWWW -WWWWWWńWWWWWW WW WWWWWWWWWW- WWW WWWWWWWWWWWWW WWWWWWWWWWWWW
WWWWWWWWWWWWWWW.
WW WWW WW, WW▀ WWW WWW WWWWWWWWWWWW WWW WWWWWWWWWW WWWWWWWWW WWW WW
WW WWWWWWWWW WWWWWWWWWWWW WWWWWW.

WWWWWWWWWWWW WWWW WWW WWWWWW WWW WWWW W WWWWWWWWW WWWW W-W WWWWWW,
WWW WWWW WWWWWWWWWW WWWWWWWW WW, WWWWńWWWWW WWWWW.
WW WWWWWWWWW WWWW.
WWWW WW WWW WWWWWW WWWWWWWWWW WWWWWW, WWWWW WWW WWW WWWWWWWWWWW
WWWWWWWWWW WWWWWW WńWWWWWWWWWWWW WWWWWWWWWW.
WWW WWWWW WWWW WWWWW WWWWWWWWW WWWW WWWWWWWWW WWW WWWWW WWWWńWWWWWWWWW
WWWW WWWWWWWWWWWW.

WWW W÷WWWW WWWWWWWWWWW WWWWWW - WWW WWWW WWW WWWW WWWWW.
WWW W÷WWWW WWWWWWW WWW WWWWWW WWWWWWWWWWWWWWWWWWWW WWWWW WWWWWWWWW.WW
WWWWWW, WWW WWWW WW-WWWW WńWWWWWW WWWWWWW WWWW WWW WWWWWWWWW.WWW
- WWW WWWW WWW WWWW WWWW WWWWW.
WWW W÷WWWW WWWWW WWWWWWWWW WWWWWWW WWWWWWW WWW WWWWWW WWWWW WWWWWWWWWW
- WWWW WWWW WWW WWWńWWW WWW WWWWW.

WWW WWW WWWW WWWWWW WWWWWWWWWW, WW▀ WWWWWWWWWW WńWWWWWWWWWW WWWWWWWWWWWW
WWWWWW WńWWWWWWWWWW WWWWWWWWWWWWWWW!
WWW WWWWWW WWWW WWW WW WWWWWWWWWW WWWWW WWW, WW WWW WWWW WWWWWW WWW
''WWWWWWŘWWWW'' WWWWWWWWWW WŘWWW.

WWWW WWW WWWWWWW WWWWWW WWWWWW WWWWWW WWW WWWW-WWWW-WWWWWWW WWW WWW,
WWWWW WWW WWW WWWW WWW WWW WWWW W÷WWWWWWW WWWWWWW WWWWWW WWW WWW WWWW
WWWWW WńWWWWWWWWWWWW WWWWWWWWWWWW WWWWW.
WWWWWWWW WńWW WW WWWWWWWW WWWWW WWWWWW, WWWW WWWWWW WWWW WńWWWWWWWWWWW
WWWWWWWWWW WWWWW WWWW WWWWWWWWWWWWWWW WŘWWW.

WWWWWWWWW WWWW WWW WWWWWW WWWWWWWWWWWWW WńWWWWWWWWWW WWWWWWWWWWW
WWWWWWWW, WWWW WWW WWWWW WWWWWW WWW▀, WWW WWWW WWWWWWWW WWWWWW WWWWW
WWW WWW WWWWWWW WWWW WŘW WWWWWWWWWW WWWWWWWW.

WWW WWWWW WWW WWWW WWWW WWWWWWWW WWWWW, WW WWW WWW WWWWWW WWWWWWWWW
WWWW WWWWW WWWWWWWWW.


Mit freundlichen GrŘ▀en
Helmut Schellong

'

for z in  $( grep '[^@ ]%{1,}@[^@ ]%{1,}' K )
do
   ifset z || continue
   expr "$z" :z '[| ]' += ''
   #expr "$z" :: 'schellong@' && continue
   echo sendmail "$z"
   expr "$headEMAIL" :Hbuf '~email~' = "$z"
   catv Hbuf Mtxt | /etc/mail/sendmail "$z"
done
catv headEMAIL2 Mtxt | /etc/mail/sendmail "schellong@t-online.de"



###  R.bsh  #############################################


local n=0000 rand1=00000 rand2=00000
> Rand
while [ n -lt 1000 ]
do
   rand1=$RANDOM
   [ rand1 -lt 200 ] || continue
   rand2=$RANDOM
   [ rand2 -lt 200 ] || continue
   let ++n
   echo $rand1 $rand2
done
><



###  a.bsh  #############################################


v1="80 c0 ff 41 81 bf 00 42 82 c2 01 3f 7f c1 02 44 84 c4 03 45 85 c3 04 3e 7e be"
v2="0f cf 92 4f 12 d4 95 4e 15 d5 78 39 f8 ba 97 4c fb bb 96 3b 16 e0 a0 b2 22 e1"

i=0
for b in  A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
do
   let ++i,ii=0
   for v in  $v1
   do
      let "++ii==i" && { d=$(catv /$b | base -b +10)
         let "v=16#$v"
         prints sss3ssf08ssf02ss3ssf08 $b : $d : $((2#,d)) "   " %
                       $((16#,v)) : $v : $((2#,v))
      }
   done
done


echo %n
i=0
for b in  AA BB CC DD EE FF GG HH II JJ KK LL MM NN %
          OO PP QQ RR SS TT UU VV WW XX YY ZZ
do
   let ++i,ii=0
   for v in  $v2
   do
      let "++ii==i" && { d=$(catv /$b =1,1 | base -b +10)
         let "v=16#$v"
         prints sss3ssf08ssf02ss3ssf08 $b : $d : $((2#,d)) "   " %
                       $((16#,v)) : $v : $((2#,v))
      }
   done
done



###  ab.bsh  #############################################

#!/u/bin/bsh


cd a
a=*.LST
cd ../b
b=*.LST
cd ..
mkdirs a1 b1

for B in a b
do
for F in ${{B}
do
   echo $B/$F ...
   > ${B}1/$F
   < $B/$F
   while readl zeile
   do
      expr "$zeile" :: '^CO ' && {
         expr "$zeile" :zeile '^%(.%{32}%)'
        #expr "$zeile" :d '    %(%D%{1,}%)    ' && {
        #   expr "$d" :d '%D' += ' '
        #   expr "$zeile" :zeile '    %D%{1,}    ' = %
        #        "    $d    "
        #}
         catv zeile /%n
      }
   done
   ><<
done
done





###  add.bsh  #############################################


read "script? Script(s) *.scr angeben: "

[ -e sym.scr ] || : > sym.scr
[ -e pac.scr ] || : > pac.scr
[ -e dev.scr ] || : > dev.scr
:>add.log

for scr in  $script
do
   [ "$scr" == sym.scr -o "$scr" == pac.scr -o "$scr" == dev.scr ] &&
      continue
   read "prefix? Prefix fŘr $scr [pre|Q]: "
   [ "$prefix" == Q ] && continue
   z=start
   < $scr
   while readl zeile
   do
      expr "$zeile" :nam '^Edit %([^ .]%{1,%}%)%.sym' && {
         z=sym; of=sym.scr; pre=""
      }
      expr "$zeile" :nam '^Edit %([^ .]%{1,%}%)%.pac' && {
         z=pac; of=pac.scr; pre=$prefix
      }
      expr "$zeile" :nam '^Edit %([^ .]%{1,%}%)%.dev' && {
         z=dev; of=dev.scr; pre=$prefix
      }
      [ $z == start ] && {
         expr "$zeile" :num '^Layer  *%([0-9]%{1,%}%)' &&
            let "num<100" && continue
         catv zeile /%r%n >> sym.scr
         catv zeile /%r%n >> pac.scr
         catv zeile /%r%n >> dev.scr
         continue
      }
      [ $z == cancel ] && continue
      [ $z == sym -o $z == pac -o $z == dev ] &&
         grep -q "^Edit $pre$nam%.$z" $of && {
            print -r "$scr-!->$of: $pre$nam.$z" >> add.log
            z=cancel; continue
         }
      case "$z" in
        sym|pac|dev)  expr "$zeile" :zeile "$nam" "$pre&"
                      z=${z}2; print -r "$zeile" ;;
          sym2|pac2)  : ;;
               dev2)  expr "$zeile" :zeile '%(Package ''%)%([^'']%)' %
                           '%1'"$pre"'%2'
                      ;;
      esac
      catv zeile /%r%n >> $of
   done
   ><
done





###  all.bsh  #############################################


dirs=$( list -dp /home2 )
expr "$dirs" :dirs '/home2/All' = ''
local f=000000
list -fpR $dirs |
   while let "++f<=10000" && readl F
   do
      link -s "$F" /home2/All/$f
   done



###  allprjzip.bsh  #############################################


remove -s /u/all.zip
zip /u/all.zip %
   /dos/cie/mc/c/lib/*.* %
   /dos/cie/mc/c/mu1000c/*.* %
   /dos/cie/mc/c/mu1000c200/*.* %
   /dos/cie/mc/c/mu2000c/*.* %
   /dos/cie/mc/c/mu2000cFR/*.* %
   /dos/cie/mc/c/mu2doc/*.* %
   /dos/cie/mc/c/mu2siemens/*.* %
   /dos/cie/mc/c/pms300/*.* %
   /dos/cie/mc/c/tds/*.*
ls -l /u/*.zip



###  anz1.bsh  #############################################


OFILE=bsh_anz.out

NAM="Helmut Schellong%r"
STR="Pestalozzi-Stra▀e 72%r"
ORT="32108  Bad Salzuflen%r"
TEL="Tel (05222) 82513 ¨ Fax 84540%r"

YMAX=2710 XMAX=1980

start()  {
   echo "%eE%e&a9L%e&k2G%e*t600R%e%1Binsc0,4,0,4,2;
sd1,341,2,1,4,10,5,0,6,3,7,4148ss;
DT│,1sp1wu0pw0.0lo2;
rf1,10,8,1,%c" >> $OFILE
   echo "1,1,0,0,0,0,0,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,0,0,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,1,1,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,0,0,0,0,0,%c" >> $OFILE
   echo "1,1,0,0,0,0,0,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,0,0,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,1,1,0,0,0,%c" >> $OFILE
   echo "0,0,0,0,0,0,0,0,0,0,;" >> $OFILE
   echo "PUpa0,0;" >> $OFILE
}

init()  {
   #1/8 S. = 128x43mm = H~The x Breite
   M=$1
   AH=$((1280*M)) AB=$((430*M))
   RDEC=$((7*M))
   XY0=$(([XMAX-AB]-900)),$(([YMAX-AH]/2))
   E1=$((30*M)) E2=$((45*M)) EB=$((10*M))
   RO=$((12*M)) RU=$((12*M)) RLR=$((12*M)) RAD=$((50*M))
}

ecken()  {
   echo "
pa$XY0;rr-$E1,-${EB}rr$E2,-${EB}rr-$EB,-${E1}rr-$EB,$E2;
pr$AB,0rr-$E2,-${EB}rr$E1,-${EB}rr$EB,-${E1}rr$EB,$E2;
pr0,$AH;rr-$E2,${EB}rr$E1,${EB}rr$EB,-${E2}rr$EB,$E1;
pr-$AB,0rr-$E1,${EB}rr$E2,${EB}rr-$EB,-${E2}rr-$EB,$E1;
" >> $OFILE
}

rahmen()  {
   echo "
pa$XY0;pr$RDEC,$RDEC;rr$((AB-RDEC*2)),$((AH-RDEC*2));
pr$RLR,$((RU+RAD))pm0pr0,$((AH-RDEC*2-RAD*2-RU-RO));
ar$RAD,0,-90,0.5pr$((AB-RDEC*2-RAD*2-RLR*2)),0ar0,-$RAD,-90,0.5;
pr0,-$((AH-RDEC*2-RAD*2-RU-RO))ar-$RAD,0,-90,0.5;
pr-$((AB-RDEC*2-RAD*2-RLR*2)),0ar0,$RAD,-90,0.5pm2tr0ft10,0fptr;
" >> $OFILE
   [ $M = 1 ] && echo "pa$XY0;ft11,1rr$AB,$AH;ft1;" >> $OFILE
}

abs()  {
   local rad=25 abs=6 ybr=10 neig=15 y
   y=$(([rad*2-abs*2-ybr]*M))
   echo "
sd4,$((8*M)),5,4lo14pa$XY0;pr$((AB/2)),$((RDEC+RU+10*M));
lb$TEL│pr0,$((28*M))sd4,$((8*M)),5,0lb$ORT│pr0,$((27*M));
lb$STR│pr0,$((27*M))lb$NAM│sd4,$((12*M));
pr0,$((27*M+32*M))pm0ci$((rad*M)),0.5pm2ft1fp;
pr0,$(([rad-abs]*M))pm0;
pr0,-$((ybr*M)),$((neig*M)),-$y,0,$((ybr*M)),-$((neig*M)),$y;
pm2ft10,0tr0fp
pr0,-$(([rad-abs]*2*M))pm0;
pr0,$((ybr*M)),-$((neig*M)),$y,0,-$((ybr*M)),$((neig*M)),-$y;
pm2fpft1tr1;
" >> $OFILE
#\\
}

text()  {
   local my=25
   echo "
sd4,$((22*M)),5,4lo16pa$XY0;pr$((AB/2)),$((AH-RDEC-RO));
lbDOS...UNIX%r│pr0,-$((94*M));
sd4,$(mulfp 11 $M)lo6;
WWWWWWW-WWWWWWWW  »WWW«%W│WWW,-$((WW*W));
WWWWWW~DWW WWWW WW~AWWW.%W│WWW,$(WWWWW WW $W)WWW,-$((WW*W));
WWWWWWW W~AW WWWWWWWWW WWW%W│WWW,-$((WW*W));
WWWWWWWWWW WWWWWWWW WWWWWWW.%W│WWW,-$((WW*W));
WWWWWWWWWWWW WWW WWWW-WWW.%W│WWW,-$((WW*W));
WWWWWWWWWW WWW WW WWW-WWWW%W│WWW,-$((WW*W));
WWWWWWWWWWW WWW WWWWWW WWWWWW!%W│WWW,-$((WW*W));
WWW,$(WWWWW W.WW $W),W,WWWWWW-$((WW/W-WWWW-WWW-WW*W)),W;
WW■ WWWWWWWWWWWWW WWWWW~AWWW WWW WWWWWWWW%W│WWW,-$((WW*W));
WW■ WWWWW WWWWWW WWWWWWWWW%W│WWW,-$((WW*W));
WW   ( WWWWW,WWWWWW; WWWWWWWWW- W. WWWWW-WWWWW )%W│WWW,-$((WW*W));
WW■ WWWW-WWWW-WWWWWWWW-WWWWWWWWWW  &|%W│WWW,-$((WW*W));
WW■ WWWWWWWWWWWWWW-WWW-WWWWWWWW%W│WWW,-$((WW*W));
WW■ WWW-WWWW-WW-WW-WWWWWW-WWWWWWWW%W│WWW,-$((WW*W));
WW■ WWWW,WWWW,WW,WWW,WWW,WW,WWW,...  WWWWWW!%W│WWW,-$((WW*W));
WW■ WWWWWWW WWWWWWWWWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWWWWW~DWWWW WWWWWWW WWWWWWWWWWW%W│WWW,-$((WW*W));
WW■ WW WWWWWW WW-WWWW WWWWWWWWW WWW WWW. WW.%W│WWW,-$((WW*W));
WW■ WWWWWW WWWWWWWWWWWWWWW WWWWWWWWWWWWWWW%W│WWW,-$((WW*W));
WW■ WW~TßWW-WWWWWW W WWWWWWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWW W~AW WWWWWWWWWWW WWWWWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWWWWW WWWWWWWWWWWWWW-WWWWWW%W│WWW,-$((WW*W));
" >> $WWWWW
   WWWW "
WW■ WWWWWWWWWWW~DWWWWWW W-WWW-W~DWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWW WWWWWWW WWWWWWWWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWWWWWWWWW  ¨  WWWWW. >WWWW%W│WWW,-$((WW*W));
WW■ WWWWWWWWWWW  WWW,WW,WW,WW,...  WWWW~AWWWW%W│WWW,-$((WW*W));
WW■ WWWWWWW WWWWWWWWW W~AW WWW WWW WWW-WWWW%W│WWW,-$((WW*W));
WWW,$(WWWWW W.W $W),W,W;
WWWWW WW.WW :   WW WWW,-- / WW,--%W│WWW,-$((WW*W));
WWWWW. WWWW. :   WW WW WW,--%W│WWW,-$((WW*W));
WWW,W;
WWWWWWW-WWWWWW  WWW~AWW. WW% WWWW%W│WWW,-$((WW*W));
WWWWW~AWWW W. WWWWWWWWW  WW% WWWWWWß%W│WWW,-$((WW*W));
WWW,W;
WWWWWWWWWWWW WWWW WWWWW WWWWWWW.%W│WWW,-$((WW*W));
WWW~AWWWWWWWWWW ˛WW/WWW.%W│WWW,-$((WW*W));
WWWWWW/WWWW-WWWWWWWW WWWWW WW WW.%W│WWW,-$((WW*W));
" >> $OFILE
}

M1txt()  {
   echo "
pa$XY0;pr$((AB+200)),$AH;lo3sd4,28,5,0,6,3;
lbM $M:1%r%n│sd4,12,5,4,6,0;
lbDies ist nur ein Anschauungsbeispiel im%r%n
lbOriginal-Maßstab.%r%n
lbAls Auflichtvorlage verwenden Sie bitte%r%n
lbdie gr~Tßere Beilage  M 2:1.%r%n
lbDer Grauton zeigt die einfarbige%r%n
lbUnterlegung der Anzeigenfl~Dche.%r%n
lbAnzeigenh~The = 128 mm%r%n
lbAnzeigenbreite = 43 mm%r%n
lbFarbprobe (gelb) aus iX:%r%n
" >> $OFILE
}

MXtxt()  {
   echo "
pa$XY0;pr$((AB+200)),$AH;lo3sd4,28,5,0,6,3;
lbM $M:1%r%n│sd4,12,5,4,6,0;
lbBitte als Auflichtvorlage verwenden.%r%n
lbDie Eckenkreuze begrenzen die gekaufte%r%n
lbAnzeigenfl~Dche und sind nicht%r%n
lbBestandteil dieser Fl~Dche.%r%n
lbAnzeigenh~The = 128 mm (M1:1)%r%n
lbAnzeigenbreite = 43 mm (M1:1)%r%n
lbDie Anzeigenfl~Dche soll einfarbig%r%n
lbunterlegt werden.%r%n
lbFarbprobe (gelb) aus iX:%r%n
" >> $OFILE
}


end_gl()  {
   echo '%e%%0A%c' >> $OFILE
}


mulfp()  {
   local  ganz mul nn x nnx
   expr $1 :: '.*%.' || { let "x=$1*$2"; echo $x%c; return; }
   ganz=`expr $1 : '^%(.*%)%.'`
   mul=`expr $1 : '^.*%.%([0-9]*%)0*$'`
   nn=${#mul}
   let "x=$ganz$mul*$2"
   nnx=${#x}
   echo `expr $x : '^%(.%{'$((nnx-nn))'%}%)'`.%c
   echo `expr $x : '^.%{'$((nnx-nn))'%}%(.*%)$'`%c
   return
}


read "maßstab? Maßstab:  " rest

[ "$maßstab" = 1 ] && {
   echo %c > $OFILE
   start
   init 1
   ecken
   rahmen
   abs
   text
   M1txt
   end_gl
   echo '%eE%c' >> $OFILE
   cat $OFILE >> $DRUCKER
}

[ "$maßstab" -gt 1 ] && {
   echo %c > $OFILE
   start
   init $maßstab
   ecken
   rahmen
   abs
   text
   MXtxt
   end_gl
   echo '%eE%c' >> $OFILE
   cat $OFILE >> $DRUCKER
}


[ -f $OFILE ] && rm $OFILE



###  array_pas.bsh  #############################################



Err()  {
   print -u2 "ERR: $1"
   exit 1
   return 0
}

set L:' '50
set E:.100
set D:.100
set R:.100
RA='^#define [^"]%{1,}_%D%D%D_'
z=e
n=-00001

cat texts256.h | {
   > /tmp/_ps_txt
   while readl Z
   do
      ifset Z || continue
      case $z in
        e)
           expr "$Z" :E "$RA"'en %{1,3}"%([^"]%{1,}%)"' || continue
           z=d
        ;;
        d)
           expr "$Z" :D "$RA"'de %{1,3}"%([^"]%{1,}%)"' || Err de
           z=r
        ;;
        r)
           expr "$Z" :R "$RA"'ru %{1,3}"%([^"]%{1,}%)"' || Err ru
           z=e
           expr "$E" :E "'" += "''"
           expr "$D" :D "'" += "''"
           expr "$R" :R "'" += "''"
           let "e=40-${#E}" "d=40-${#D}" "r=40-${#R}" "++n"
           catv ". ( '" E ".', " $e,L %
                ".'"    D ".', " $d,L %
                ".'"    R ".' "  $r,L ".)," /%n
        ;;
      esac
   done
   ><
}

> "array.pas"
echo '%n(*Eventuell letztes Komma l÷schen*)'
echo '%nconst%nERRMESG : array[0..'"$n"'] of array[0..2] of string = ('
cat /tmp/_ps_txt
echo ");%n"
><




###  ash.bsh  #############################################

#!/u/bin/bsh
#!/usr/bin/bsh
#sc/20.04.01
#nur bsh_VV


[ -s "$1" ] || { print -u2 "Keine (gueltige) Datei: '$1'"; exit 1; }
set -f

asm1='

 .PROGRAM ~nameteil~
 .TITLE   ~nameteil~

; Erzeugt von ash.bsh: ~datetime~

 .section IOBASE, IO, locate=0x0000

'
asm2='

 .section IOXTND, DATA, locate=0x~extend~

'
h1='
#ifndef   __MB90XXX_H
#  define __MB90XXX_H
/*
- Please define __IO_NEAR in LARGE and COMPACT memory model, if the default
  data bank (DTB) is 00. This will result in better performance in these
  models.
- Please define __IO_FAR in SMALL and MEDIUM memory model, if the default
  data bank (DTB) is other than 00. This might be the case in systems with
  external RAM, which are not using internal RAM as default data area.
- Please define neither __IO_NEAR nor __IO_FAR in all other cases. This
  will work with almost all configurations.
*/

#if defined(byte) || defined(word) || defined(dword)
# error "byte/word/dword  definiert!"
#endif

#  ifdef  __IO_NEAR
#    ifdef  __IO_FAR
#      error __IO_NEAR and __IO_FAR must not be defined at the same time
#    else
#      define ___IOWIDTH __near
#    endif
#  else
#    ifdef __IO_FAR
#      define ___IOWIDTH __far
#    else                               /* specified by memory model */
#      define ___IOWIDTH
#    endif
#  endif
#  ifdef  __IO_DEFINE
#    define __IO_EXTERN
#    define __IO_EXTENDED volatile ___IOWIDTH
#  else
#    define __IO_EXTERN   extern      /* for data, which can have __io */
#    define __IO_EXTENDED extern volatile ___IOWIDTH
#  endif

typedef unsigned char         IO_BYTE;
typedef unsigned short        IO_WORD;
typedef unsigned long         IO_LWORD;
typedef const unsigned short  IO_WORD_READ;

'
# .GLOBAL __pdr0,     __pdr1,     __pdr2,     __pdr3,     __pdr4,     __pdr5
# .org 0xhhhh
#__xxx .res.b 16|0x10
# .end

#typedef union{
#    IO_BYTE        byte;
#    struct{
#    IO_BYTE ADE0 :1;
#    IO_BYTE ADE7 :1;
#  }bit;
#}ADERSTR;
#__IO_EXTERN __io ADERSTR _ader;
#define ADER _ader.byte
#define ADER_ADE0 _ader.bit.ADE0
#define ADER_ADE7 _ader.bit.ADE7
#__IO_EXTENDED TMR0STR _tmr0;


mktemp Tmpf1
mktemp Tmpf2
mktemp Tmpf3


Err()  {
   [ $# -gt 0 ] && print -u2 "ash.bsh: ERROR: '$*'%n   >>>$zeile<<<"
   remove $Tmpf1 $Tmpf2 $Tmpf3
   [ $# -eq 0 ] && exit 0
   exit 1
   return
}


PrGlob()  {
   local n=1 v=.. g1 g2 g3 g4
   echo >> $Tmpf1
   for 4 g1 g2 g3 g4 in $Glob
   do
      conv -l g1 g2 g3 g4
      for n from 1 to 4 repeat
      do
         v=g$n
         ifset g$n && g$n="__${{v}"
         ifset g$((n+1)) && g$n="${{v}, "
      done
      prints ss-18s-18s-18s-18 " .GLOBAL " %
             "$g1" "$g2" "$g3" "$g4" >> $Tmpf1
   done
   echo >> $Tmpf1
   Glob=''
   return
}


MkBitF()  {
   local bf=,,,,,,,, bfc0=,,,,,,,, bfc=,,,,,,,,
   local b=00 b2=00 d=00 d0=00
   BitFc='' bfc0=''
   for bf in $BitF
   do
      let ++b
      expr "$bf" :bfc '^%(..*%)%D$' && expr "$bf" :d '%(%D%)$' && {
         let "d-d0==1" && [ "$bfc0" == "$bfc" ] && { d0=$d
            let "b2==0" && { b2=1
               let "(b-=2)>0" && BitFc="$BitFc . $b"
               b=2
            }
            continue
         }
         let b2 && BitFc="$BitFc $bfc0 $((b-1))"  b=1
         bfc0=$bfc d0=$d b2=0
         continue
      }
      let b2 && BitFc="$BitFc $bfc0 $((b-1))"  b=1
      bfc0='' d0=0 b2=0
   done
   ifset BitFc && {
      let b2 && BitFc="$BitFc $bfc0 $b"
      let !b2 && BitFc="$BitFc . $b"
      for 2 bf b in $BitFc
      do
         [ "$bf" != . ] && expr "$BitF" :: "%<$bf%>" && { BitFc='' ; return 1; }
      done
      return 0
   }
   return 1
}



prints vs300 zeile

expr "$1" :ifn '^%(..*%)%.[^.]%{1,}$' || ifn="$1"

tz -2
time=$(systime -t)
expr "$asm1" :asm1 '~nameteil~' += "_$ifn"
expr "$asm1" :asm1 '~datetime~' = "$time"
catv asm1 >> $Tmpf1
echo "%n/* Erzeugt von ash.bsh: $time, $ifn */" >> $Tmpf3
catv h1 >> $Tmpf3

extend=0000
adr=00000000
siz=00000001
siz2=00000000
arr=00000000
arr1=00000000
arr2=00000000
nam=..........
namu=..........
nam0=............
org=........
extrn=...........................
typ=................
typ2=................
typ20=................
typ21=................
type=................
prints vs2500 Glob
prints vs300 BitF
prints vs300 BitFc
Glob=''
nbitf=000 n=00000000 rb=000

local adrlim=00000255 mk=..............  ak=..............
local ab=..............  ar=.............. s=00000000


PrBitFields()  {
   local nn="$1" nk="$2" typ="$3"
   local n=.......... un=.......... s=00
   [ -n "$nn" ] && let "arr>=10&&nn<10" && nn=0$nn
   prints s-17s14s "#define" "$namu$nn" "    _$nam$nk.$typ"
   {  #nbitf
      for n in $BitF
      do
         expr "$n" :: '[.-]' && continue
         un=$n  conv -u un
         [ $n == int ] && n=_int
         prints s-9s-24s "#define" $namu${nn}_$un "  _$nam$nk.bit.$n"
      done
   }
   for 2 n s in $BitFc
   do
      expr "$n" :: '[.-]' && continue
      un=$n  conv -u un
      [ $n == int ] && n=_int
      prints s-9s-24s "#define" $namu${nn}_$un "  _$nam$nk.bitc.$n"
   done
   echo
}


GetZeile()  {
   local z='                                          '
   while readl zeile
   do
      ifset zeile || continue
      expr "$zeile" =:extend '^EXT:%(....%)$' && continue
      expr "$zeile" :: '^[+0-9]' || continue
      while expr "$zeile" :zeile '^%(..*%)[ %t]*+%{1,}$'
      do
         readl z || break
         zeile="$zeile $z"
      done
      return 0
   done
   return 1
}


PutBF()  {
   local w="$1" a=00 b=00
   expr "$w" :a '(%(%D%{1,}%),%D%{1,})$'
   expr "$w" :b '(%D%{1,},%(%D%{1,}%))$'
   expr "$w" :w '^%([^(]%{1,}%)('
   let "${#w}>6" && Err "Bitfeld-Name zu lang [6]: '$w'"
   while :
   do
      BitF="$BitF $w$a"
      let ++nbitf "a==b" && break
      let "a<b" && let ++a
      let "a>b" && let --a
   done
   return
}


DataFromZeile()  {
   local cas=adr w=.....................
   for w in $zeile
   do
      case "$cas" in
        adr)  cas=nam
              expr "$w" :: '^+$' && continue
              expr "$w" :: '^[0-9][0-9a-fA-F]*$' && {
                 let "16#$w==adr" && continue
                 let "16#$w<adr" && let "siz=adr-16#$w"
                 let "adr=16#$w"
                 org=$w
                 continue
              }
              ;,
        nam)  expr "$w" :: '^[a-zA-Z_]%W*$' || Err "$w"
              cas=siz
              let "${#w}>14" && Err "Name zu lang [14]: '$w'"
              nam=$w
              conv -l nam
              [ "$nam" == "$nam0" ] && Err "Doppelt: $nam"
              nam0="$nam"
              Glob="$Glob $w"
              ;;
        siz)  cas=arr
              expr "$w" :: '^%D$' && { siz=$w ; continue; }
              expr "$w" :siz '^%(%D%):%D$' &&
                 expr "$w" :siz2 '^%D:%(%D%)$' && continue
              ;,
        arr)  cas=bit
              expr "$w" :arr '^%(%D%{1,2}%)' &&
                 expr "$w" :w '^%D%{1,2}%(.*%)$'
              expr "$w" :arr1 '^(%(%D%{1,2}%))$' && continue
              expr "$w" :: '^(%D%{1,2},%D%{1,2})$' && {
                 expr "$w" :arr1 '%(%D%{1,}%)'
                 expr "$w" :arr2 ',%(%D%{1,}%))$'
                 continue
              }
              [ "$arr" != 0000 ] && continue
              ;,
        bit)  expr "$w" :: '^[a-zA-Z_]%W*(%D%{1,2},%D%{1,2})$' && {
                 PutBF "$w" ; continue
              }
              expr "$w" :: '^[-.a-zA-Z_]%W*$' || Err "$w"
              expr "$w" :: '^[-.].' && Err "$w"
              let "${#w}>6" && Err "Bitfeld-Name zu lang [6]: '$w'"
              BitF="$BitF $w"
              let ++nbitf
              ;;
          *)  Err Interner Fehler ;;
      esac
   done
   [ "$cas" == adr -o "$cas" == nam ] && Err "$zeile"
   [ "$cas" == bit ] && {
      let "nbitf>0&&(siz2==0&&nbitf!=siz*8||siz2!=0&&nbitf!=siz2*8)" &&
         Err "Anzahl:$BitF"
      conv -l BitF
   }
   return
}


< "$1"
while GetZeile
do
   BitF='' org=''
   nbitf=000 arr=0000 arr1=00 arr2=00
   siz=1 siz2=0
   DataFromZeile

   let "siz!=1&&siz!=2&&siz!=4" && Err "sz==$siz"
   let "siz2!=0&&siz2!=1&&siz2!=2&&siz2!=4" && Err ":sz2==$siz2"
   let "siz2>=siz" && Err "sz:sz $siz<=$siz2"
   let "adrlim>0&&adr>adrlim" && { adrlim=0
      let "16#$extend<256" && Err "EXT:hhhh-Zeile fehlt"
      expr "$asm2" :asm2 '~extend~' = "$extend"
      PrGlob
      cat $Tmpf2 >> $Tmpf1
      : > $Tmpf2
      catv asm2 >> $Tmpf1
   }
   ifset org && prints sbssf04 " .org" 0x $org >> $Tmpf2
   s=$siz
   let arr  && let "s*=arr"
   let arr1 && let "s*=arr1"
   let arr2 && let "s*=arr2"
   prints s-17sbs __$nam .res.b $s >> $Tmpf2
   let "adr+=s"

   extrn="__IO_EXTERN __io"
   let "adr-s>255" && extrn="__IO_EXTENDED   "
   let siz==1 && typ=IO_BYTE typ2=byte
   let siz==2 && typ=IO_WORD typ2=word
   let siz==4 && typ=IO_LWORD typ2=dword
   let siz2==1 && typ20=IO_BYTE typ21=byte
   let siz2==2 && typ20=IO_WORD typ21=word
   let siz2==4 && typ20=IO_LWORD typ21=dword
   armkakabrb=14
   let "arr"  && ar="[$arr]"
   let "arr1" && mk="(a)" ak="[$arr1]" ab="[a]" rb=19
   let "arr2" && mk="(a,b)" ak="[$arr1][$arr2]" ab="[a][b]" rb=19
   namu="$nam"
   conv -u namu
   >> $Tmpf3
   let "nbitf==0&&siz2==0" && {
      prints s-17s${rb}sss "$extrn" $typ "  _$nam" "$ar$ak" ";"
      let "!arr" && {
         prints s-17s${rb}ssn "#define" $namu$mk "  _$nam" "$ab"
         >< ; continue
      }
      for n from 0 to 0$((arr-1)) repeat
      do
         let "arr>=10&&n<10" && n=0$n
         prints s-17s$((rb+2))ss "#define" $namu$n$mk "  _$nam" "[$n]$ab"
      done
      echo
      >< ; continue
   }
   let "nbitf==0&&siz2!=0" && {
      echo "typedef union {"
      echo "   $typ $typ2;"
      echo "   $typ20 $typ21;"
      echo "} ${namu}_t;"
      prints s-17s${rb}sss "$extrn" ${namu}_t "  _$nam" "$ar$ak" ";"
      let "!arr" && {
         prints s-17s${rb}sn "#define" $namu$mk "  _$nam$ab.$typ21"
         >< ; continue
      }
      for n from 0 to 0$((arr-1)) repeat
      do
         let "arr>=10&&n<10" && n=0$n
         prints s-17s$((rb+2))s "#define" $namu$n$mk "  _${nam}[$n]$ab.$typ21"
      done
      echo
      >< ; continue
   }
   let arr1 && Err "Operation nicht moeglich: $ar$ak"
   type=$typ
   echo "typedef union {"
   echo "   $typ $typ2;"
   let siz2 && type=$typ20 && echo "   $typ20 $typ21;"
   {  #nbitf
      echo "   struct {"
      for n in $BitF
      do
         expr "$n" :: '[.-]' && n=''
         [ "$n" == int ] && n=_int
         prints ss10s7s "      " $type "$n" ":1;"
      done
      echo "   } bit;"
   }
   MkBitF && {
      echo "   struct {"
      for 2 n s in $BitFc
      do
         expr "$n" :: '[.-]' && n=''
         [ "$n" == int ] && n=_int
         prints ss10s7s "      " $type "$n" ":$s;"
      done
      echo "   } bitc;"
   }
   echo "} ${namu}_t;"
   prints s-17s16sss "$extrn" ${namu}_t "  _$nam" "$ar" ";"
   type=$typ2
   let siz2 && type=$typ21
   let  arr && {
      for n from 0 to 0$((arr-1)) repeat
      do
         PrBitFields $n "[$n]" $type
      done
   }
   let !arr && PrBitFields "" "" $type
   ><
done
><


echo " .end%n" >> $Tmpf2
PrGlob
cat $Tmpf2 >> $Tmpf1
cat $Tmpf1 > $ifn.asm

>> $Tmpf3
echo "#define IDRw(i,v)  (IDR(i)=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define IDRr(i)  ((IDR(i)<<8|IDR(i)>>8)>>5)"
echo "#define AMR0w(v)  (AMR0=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR0r  ((AMR0<<8|AMR0>>8)>>5)"
echo "#define AMR1w(v)  (AMR1=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR1r  ((AMR1<<8|AMR1>>8)>>5)"
echo
echo "#define IDR0w(i,v)  (IDR0(i)=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define IDR0r(i)  ((IDR0(i)<<8|IDR0(i)>>8)>>5)"
echo "#define AMR00w(v)  (AMR00=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR00r  ((AMR00<<8|AMR00>>8)>>5)"
echo "#define AMR10w(v)  (AMR10=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR10r  ((AMR10<<8|AMR10>>8)>>5)"
echo
echo "#define IDR1w(i,v)  (IDR1(i)=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define IDR1r(i)  ((IDR1(i)<<8|IDR1(i)>>8)>>5)"
echo "#define AMR01w(v)  (AMR01=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR01r  ((AMR01<<8|AMR01>>8)>>5)"
echo "#define AMR11w(v)  (AMR11=(((v)<<5)<<8|((v)<<5)>>8))"
echo "#define AMR11r  ((AMR11<<8|AMR11>>8)>>5)"
><

echo "%n#endif%n" >> $Tmpf3
cat $Tmpf3 > $ifn.h


Err
exit 0





###  atp.bsh  #############################################

#!/u/bin/bsh_com
#!/u/cie/wms/cgi/bsh_folso_cgi -p_


set -f

MUanrufen()  {
   local telnu=$1 ch=00 offs=00000 cksum:010 ring="RING$RN.........."
   while :
   do
   case $AnrufZ in
     dialout)
        [ MOwahl -eq 0 ] && AnrufZ=getdata continue
        let "$SECONDS-DOtime<=40" && { sleep 2; continue; }
        WriteAT "$MOdialout" "$telnu" || DOtime=$SECONDS break
        AnrufZ=waitpass TOsec=$SECONDS DOtime=0
     ;;
     waitpass)
        let "$SECONDS-TOsec>10" && break
        com -p || return 0
        AnrufZ=pass
     ;;
     pass)
        com -it400id15i1000 Ibuf
        catv $.,Ibuf =Hbuf:
        catv Hbuf
        expr "$Hbuf" =:: 'PASSWORD:' || break
        ring="@DK40mopas"
        com -cot50od10o10 ring
        sleep -m 150
        com -ocot30od10o2 RN
        AnrufZ=waitpassok TOsec=$SECONDS
     ;;
     waitpassok)
        let "$SECONDS-TOsec>10" && break
        com -p || return 0
        AnrufZ=passok
     ;;
     passok)
        com -it300id15i1000 Ibuf
        catv $.,Ibuf =Hbuf:
        catv Hbuf
        expr "$Hbuf" =:: 'PASSWORD %{1,3}OK' || break
        AnrufZ=getdata
     ;;
     getdata)
        [ Status -eq 2 ] && AnrufZ=writecfg continue
        [ Status -eq 3 ] && AnrufZ=readcfg continue
        GetMUdata $Fmustatus Nn dk40 || {
           echo "$Nn Bytes"
           [ MOwahl -eq 0 ] && break
           ring=@EN:
           com -cot30od10o4 ring
           break
        }
        echo "$Nn Bytes"
        AnrufZ=data
     ;;
     data)
        MUkategorie_c $Fmustatus
        cat $Fmustatus > $MUdir/stat
        [ ! -e "$MUdir/lock" -o ! -s "$MUdir/eepr" ] && AnrufZ=readcfg continue
        [ MOwahl -eq 0 ] && AnrufZ=0 goend
        AnrufZ=mowrite continue
     ;;
     mowrite)
        ring=@EN:
        sleep -m 400
        com -cot50od10o4 ring
        echo @EN: = $.
        AnrufZ=waitmoend TOsec=$SECONDS
     ;;
     waitmoend)
        let "$SECONDS-TOsec>10" && break
        com -p || return 0
        AnrufZ=moend
     ;;
     moend)
        com -it300id15i1000 Ibuf
        catv $.,Ibuf =Hbuf:
        catv Hbuf
        expr "$Hbuf" =:: 'Connection %{1,3}aborted' || break
        AnrufZ=0
        #[ Status -eq 2 -o Status -eq 3 ] && AnrufZ=0
     ;;
     dialin)
        WriteAT "$MOabnehmen" || break
        AnrufZ=getokayfail
     ;;
     getokayfail)
        GetMUdata $Fokayfail Nn rdonly || break
        echo "$Nn Bytes"
        AnrufZ=okayfail
     ;;
     okayfail)
        #< $Fokayfail
        #><
        #MkTbl5data $Ftbl5 addmu "$mustat" "$muokfa" "$mudati"
        AnrufZ=0
     ;;
     writecfg)
        sum -w cksum < $MUdir/eepr
        let "cksum+=16#1d0f, cksum&=65535"
        base -10 cksum +w cksum
        ring=129
        base -10 ring +b ch
        ring=@PC:
        com -cot40od10o4 ring
        com -it400id20i1 Ibuf
        catv 1,Ibuf /%j
        com -cot30od10o1 ch
        com -it400id10i1 Ibuf
        catv 1,Ibuf /%j
        catv 2048,0 =Hbuf < $MUdir/eepr
        for offs from 0 by 32 to 2016 repeat
        do
           com -cot80od10oO${offs}o32 Hbuf
           com -it600id20i1 Ibuf
           catv 1,Ibuf
        done
        com -cot30od10o2 cksum
        com -it400id10i2 ring
        echo
        catv 2,cksum =cksum:
        catv 2,ring =ring:
        base -w cksum +16
        base -w ring +16
        cmpv cksum ring || break
        [ MOwahl -ne 0 ] && AnrufZ=mowrite continue
        AnrufZ=0
     ;;
     readcfg)
        ring=128
        base -10 ring +b ch
        ring=@PC:
        com -cot40od10o4 ring
        com -it400id20i1 Ibuf
        catv 1,Ibuf /%j
        com -cot30od10o1 ch
        com -it3500id20i2050 Ibuf
        echo $.
        catv 2048,Ibuf > ../tmp/eeprin
        sum -w cksum < ../tmp/eeprin
        let "cksum+=16#1d0f, cksum&=65535"
        base -10 cksum +w cksum
        com -cot30od10o2 cksum
        catv 2,cksum =cksum:
        catv 2048,2,Ibuf =ring:
        base -w cksum +16
        base -w ring +16
        cmpv cksum ring || break
        mucrc cksum Ibuf 2 1898 || break
        catv 0,2,Ibuf =ring:
        base -w ring +10 ring
        echo "$cksum : $ring"
        [ cksum -ne ring ] && break
        cat ../tmp/eeprin > $MUdir/eepr
        remove ../tmp/eeprin
        #base -W +w < $MUdir/eepr | catv 2048,0 =5000,2048,3  3<> C:\DATA.MUC
        #catv $(( 960<<1)),2,0 =ring:  < $MUdir/eepr
        #base -w ring +10 ring
        #MUspsw=0
        #let "ring==1" && MUspsw=1
        #catv $((1001<<1)),2,0 =ring:  < $MUdir/eepr
        #base -w ring +10 ring
        #let "ring==1" && MUspsw=2
        [ MOwahl -ne 0 ] && AnrufZ=mowrite continue
        AnrufZ=0
     ;;
   esac
   return 0
   done
   return 1
}


GetMUdata()  {
   local nrw=0000000000 sum=00000
   catv /@DK40: =6,Ibuf
   [ "$3" == dk40 ] && com -cot100od10o6 Ibuf
   until com -p
   do
      let "sum+=10, sum>3000" && break
      sleep -m 10
   done
   echo "InputWait: $sum ms"
   com -it500id20i4000 Ibuf
   nrw=$. $2=$. sum=0
   let "sum+=nrw, nrw==0" && return 1
   > $1
   while [ nrw -gt 0 ]
   do
      [ "$3" == dk40 ] && conv '-t `' Ibuf
      catv $nrw,Ibuf
      com -it500id20i4000 Ibuf
      let "nrw=$., sum+=nrw"
   done
   ><
   $2=$sum
   return 0
}


MAIN()  {
   sleep -m $Wait
   Sec=$SECONDS
   case $Status in
     0)
        [ MUcall -ge 30 -a MUcall -le 39 ] && { let "MUcall-=20"; Uvars MUcall; }
        com -p && {
           [ MOwahl -eq 0 ] && { com -ic; continue; }
           com -it60id10i1500 Ibuf
           catv $.,Ibuf =Hbuf:
           catv '/[' Hbuf '/]'
           GetMOmsgNr Hbuf && let "Hbuf&4" && MOri=1 MOrings=0 %
              MOritime=$Sec Wait=150 Status=9 MUcall=39 Uvars MUcall
           continue
        }
        fstat -mv Uv uvars.bsh
        [ Uv -ne Uv0 ] && { Uv0=$Uv  . ./uvars.bsh; }
        [ MOwahl -ne 0 -a MOisinit -ne 1 ] && {
           Status=7 MOinittime=-30
           [ MOisinit -eq 0 ] && MUcall=37 Uvars MUcall
           continue
        }
        [ MOwahl -eq 0 ] && MOisinit=0
        [ Sec -ge St ] && {
           let "St=Sec+10"; systime Stime
           [ ConnTest -gt 0 ] && [ -s $Fstation ] && {
              [ CTbuild -ne 0 ] && { BuildCT; continue; }
              let "Sec-DOtime<=90||Sec-CTwait<=150" && continue
              [ Stime -ge CTtime -a CTtime -ge 10 ] && {
                 SetVarsCT && MUcall=6; } ||
                 WrLog "Connect test" "SetVars failed: $CTgid/$CTaid"
           }
        }
        [ MUcall -eq  1 ] && Status=1
        [ MUcall -eq  2 ] && Status=2
        [ MUcall -eq  6 ] && Status=6 echo CT: $CTgid $CTaid $CTtime $CTday
        [ MUcall -lt  0 ] && MUcall=00 Uvars MUcall
        [ Status -ne 0 ] && { AnrufZ=dialout let "MUcall=Status+30"; Uvars MUcall; }
        continue
     ;;
     9)
        if com -p
        then  
              MOri=0
              com -it60id10i1500 Ibuf
              catv $.,Ibuf =Hbuf:
              catv '/[' Hbuf '/]'
              GetMOmsgNr Hbuf && let "Hbuf&4" && MOri=1
        else  let "MOrings+=MOri, MOrings>=3" && {
                 Status=8 Wait=500 MUcall=38 Uvars MUcall
                 AnrufZ=dialin continue
              }
              MOri=0
        fi
        let "Sec-MOritime>20" && {
           Status=0 Wait=500 MUcall=29 Uvars MUcall
           WrLog "RING event" "less then 3 rings"
           continue
        }
        continue
     ;;
     1)
        MUanrufen $Telnu || {
           MOisinit=2 Status=0 MUcall=21 Uvars MUcall
           WrLog "Call get data" "failed: $AnrufZ" $MUdir/log
        }
        [ $AnrufZ != 0 ] && continue
        MOisinit=2 Status=0 MUcall=11 Uvars MUcall
        continue
     ;;
     2)
        MUanrufen $Telnu || {
           MOisinit=2 Status=0 MUcall=22 Uvars MUcall
           WrLog "Call configure" "failed: $AnrufZ" $MUdir/log
        }
        [ $AnrufZ != 0 ] && continue
        MOisinit=2 Status=0 MUcall=12 Uvars MUcall
        continue
     ;;
     6)
        MUanrufen $Telnu || {
           WrLog "Connect test $MUdir" "failed: $AnrufZ"
           WrLog "Connect test" "failed: $AnrufZ" $MUdir/log
           GetTryCT Hbuf
           if [ Hbuf -ge CTtries ]
           then  FailCT; WriteCT full
           else  WriteCT try
           fi
           NextCT; CTwait=$Sec
           MOisinit=2 Status=0 MUcall=26 Uvars MUcall
        }
        [ $AnrufZ != 0 ] && continue
        WriteCT okay; NextCT; CTwait=$Sec
        MOisinit=2 Status=0
        continue
     ;;
     8)
        MUanrufen || {
           MOisinit=2 Status=0 MUcall=28 Uvars MUcall
           WrLog "Incoming call" "failed: $AnrufZ"
        }
        [ $AnrufZ != 0 ] && continue
        OkayFail $Fokayfail || MUcall=28 Uvars MUcall
        MOisinit=2 Status=0
        continue
     ;;
     7)
        fstat -mv Uv uvars.bsh
        [ Uv -ne Uv0 ] && { Uv0=$Uv  . ./uvars.bsh; }
        [ MOwahl -eq 0 ] && Status=0 MOisinit=0 continue
        let "$Sec-MOinittime<30" && continue
        WriteAT "$MOauflegen"
        WriteAT "$MOinit" && Status=0 MOisinit=1
        [ MOisinit -eq 2 ] && Status=0 MOisinit=0
        MOinittime=$Sec
        continue
     ;;
   esac
}
#------------------------------------------------------------------------


WaitData()  {
   local dp=0 len=00000
   Ilen=0
   com -it400id20i1 dp
   if expr "$dp" :: '^:$'
   then
      com -it400id20i1 dp
      base -b dp +10 len
      com -it400id20i$len Ibuf
      Ilen=$.
      Mode=BIN
   else
      com -it400id20i1000 Ibuf
      Ilen=$.
      catv 1,dp $Ilen,Ibuf =Ibuf
      let "++Ilen"
      Mode=TXT
   fi
   return 0
}


WaitREADY()  {
   local ok:.20
   com -it700id20i10 Ibuf
   catv $.,Ibuf =20,ok:
   expr "$ok" :: '^@[0-9]:READY'"$RN" || return 1
   catv 10,Ibuf
   return 0
}


WaitOK()  {
   local ok:.20
   com -it400id20i7 Ibuf
   catv $.,Ibuf =20,ok:
   expr "$ok" :: '^@[0-9]:OK'"$RN" || return 1
   catv 7,Ibuf
   return 0
}


Kommando()  {
   echo $1
   return 0
}


ID()  {
   local n=0000000000 id=0000000000$1
   local len=5 cksum=00000 ilen=00000
   base -10 id +l id
   base -10 len +b len
   catv 1,len 4,id | sum -b cksum
   let "cksum=~cksum&255"
   base -10 cksum +b cksum
   catv /: 1,len 4,id 1,cksum =id:
   for n to $Lcnt repeat
   do
      [ Lcnt -gt 1 ] && echo %t$n
      while :
      do
         case $IdZ in
           IDsend)
             Obuf="@3!ID$RN"
             com -cot40od10o7 Obuf
             WaitOK || break 2
             com -cot40od10o7 id
             WaitOK || break 2
             Obuf="@3!SEND$RN"
             com -cot40od10o9 Obuf
             WaitOK || break 2
             IdZ=datarecv
             ;;
           datarecv)
             WaitData || break 2
             ilen=$Ilen
             [ $Mode == BIN ] && let --ilen
             catv $ilen,Ibuf /%j
             Obuf="@3:OK$RN"
             com -cot40od10o7 Obuf
             IdZ=IDsend
             WaitREADY || break 2
             #sleep -m 10
             break
             ;;
         esac
      done
   done
   IdZ=IDsend
   return 0
}
#------------------------------------------------------------------------


#8>&1

set Ibuf:0.2048
set Obuf:0.1024
IdZ=IDsend
Ilen=0000000000
Mode=BIN
Lcnt=0000000001
Lcnt=1
Ofile=stdout
catv /%r%n =RN:

#BSD: /dev/cuaa0, /dev/ttyd0
case "FreeBSD" in
  FreeBSD)   Sio='/dev/ttyd0' Tty='/dev/ttyp1';;
  OpenUnix)  Sio='/dev/term/00t' Tty='/dev/pts016';;
  *)         Sio='/dev/null' Tty='/dev/console';;
esac
#1>> $Tty
#2>> $Tty

com +L  $Sio || { print -u2 "TTY-Device '$Sio'" "open failed"; com -; exit 1; }
com -B57600
com -s 1
com -H comhandle
fstat -h 0 1 2 $comhandle
echo

Obuf="@3!START$RN"
com -cot40od10o10 Obuf
WaitOK || { print -u2 "START failed"; com -; exit 2; }


while print -u2 "
%tAusgabedatei  : o file  [$Ofile]
%tLoop count    : l #     [$Lcnt]
%tKommando      : Kommando
%tID+SEND       : #       (id)
%tBeenden       : E

%t              : _%b%c"
do
   read cmd opt
   com -p && { com -it700id20i1000 Ibuf; catv $.,Ibuf; }
   ifset cmd || continue
   case "$cmd" in
     o)  expr "$opt" :: '^[a-zA-Z_0-9/\]%{1,}$' || continue
         [ $Ofile == $opt ] && continue
         Ofile=$opt
         if [ $Ofile == stdout ]
         then  ><
         else  1>$Ofile
         fi
         ;;
     l)  expr "$opt" :: '^[1-9][0-9]*$' || continue
         Lcnt=$opt
         ;;
     [a-zA-Z][a-zA-Z_0-9]*)  
         expr "$cmd" :: '^[a-zA-Z_0-9]%{2,15}$' || continue
         Kommando $cmd ;;
     [0-9]??*)  
         expr "$cmd" :: '^[0-9][0-9]*$' || continue
         ID $cmd ;;
     E)  break;;
     *)  echo %a%c; continue;;
   esac
done


Obuf="@3!END$RN"
com -cot40od10o8 Obuf
WaitOK || print -u2 "END failed"

com -
#[ -t 1 -a -n "$Tty" -a -c "$Tty" ] && ><
#[ -t 2 -a -n "$Tty" -a -c "$Tty" ] && ><
exit 0





###  autoexec.bsh  #############################################


global
alias MU="cd \u\mc\c\mu1000c"
alias CV="cd \u\c\mucv"



###  base2bin.bsh  #############################################

#!/u/bin/bsh

set -f
set Z:.250 liste:.150 null:0.256
l=00 u=.. v=........ mif=0000 maf=0000

MakeBin()  {
   #0.0.000.00000
   >$2
   <$1
   while read id dd adr grp idlink sort parbn typ bytelen darst nbit bitpos %
              access dflt1 min max %
              flags einheit name Tinfo Tgrp Tsgrp Tbit Text text
   do
      expr "$id" :: '^%$' && break
      expr "$id" :: '^[:.]..*' && continue;
      expr "$id" :id '^@%([0-9]%{1,}%)' && {
         let "adr=$adr" "bytelen=$bytelen" "id=$id" "parbn=$parbn"
         let "id+=dd*100000000"
         prints vsf010 pid $id
         nelem=1 mif=0 maf=0 voffs=0
         expr "$flags" :nelem 'A%([0-9]%{1,}%)'
         expr "$flags" :nelem 'S%([0-9]%{1,}%)'
         liste=
         while :
         do
            seek + 0 sk
            readl Z
            expr "$Z" :: '^@:.' || { seek $sk 0; break; }
            catv 2,,Z =0:,,liste
         done
         [ "$darst" ==  1 ] && darst=/
         expr "$darst" :darst '%.%([0-9]%)'
         if [ "$typ" == s ]
         then
            min=0
            max=0
         else
            [ "$min" == '"' ] && min=0
            [ "$max" == '"' ] && max=0
            l=4 u=u
            [ bytelen -eq 4 ] && l=8 u=ul
            for v in min max
            do
               case "$typ" in
                 b)  expr "${{v}}" :$v '^x%([0-9a-fA-F]%{1,}%)$' && goend
                     base -2 $v +16 $v ;;
                 x)  goend ;;
                 *)  continue ;;
               esac
               prints vssf0${l}s $v 0x ${{v}} $u ;;
            done
         fi
         [ "$einheit" == '"' ] && einheit=
         flg=0000000000 txtgrp=0 txtnum=0
         expr "$flags" :txtnum 'T%(%D%{1,3}%)'
         expr "$flags" :txtgrp 'G%(%D%{1,3}%)'
         expr "$flags" :: 'a'   && let "flg|=1<<30"
         expr "$flags" :: 'Z'   && let "flg|=1<<24"
         expr "$flags" :: 'S'   && let "flg|=1<<23"
         expr "$flags" :: 'A'   && let "flg|=1<<22"
         expr "$flags" :: 'E'   && let "flg|=1<<21"
         expr "$flags" :: 'N'   && let "flg|=1<<19"
         expr "$flags" :: 'F'   && let "flg|=1<<18"
         expr "$flags" :: 'm'   && let "flg|=1<<17"
         expr "$flags" :: 'D'   && let "flg|=1<<16"
         expr "$flags" :: 'd'   && let "flg|=1<<15"
         expr "$flags" :: ':'   && let "flg|=1<<14"
         expr "$flags" :: 'I'   && let "flg|=1<<13"
         expr "$flags" :: 't1'  && let "flg|=1<<12"
         expr "$flags" :: 'l'   && let "flg|=1<<11"
         expr "$flags" :: 't2'  && let "flg|=1<<10"
         expr "$flags" :: 'B'   && let "flg|=1<<8"
         expr "$flags" :: '1%.' && let "flg|=1<<7"
         expr "$flags" :: 'q'   && let "flg|=1<<6"
         expr "$flags" :: 'K'   && let "flg|=1<<5"
         expr "$flags" :: 'i'   && let "flg|=1<<4"
         expr "$flags" :: 's'   && let "flg|=1<<3"
         expr "$flags" :: 'n'   && let "flg|=1<<2"
         expr "$flags" :: 'b'   && let "flg|=1<<1"
         expr "$flags" :: 'r'   && let "flg|=1"
         [ "$name" == 0 -o "$name" == '"' ] && name=0 ptrlet "flg|=512"

         base -10 pid +l
         base -10 flg +l
         let "flg&1<<15" && min=0 max=3200
         if [ $typ == b -o $typ == x ]
         then
            expr "$min" :min '^0x%([0-9a-fA-F]%{1,}%)'
            base -16 min +l
            base -10 mif +w
            expr "$max" :max '^0x%([0-9a-fA-F]%{1,}%)'
            base -16 max +l
            base -10 maf +w
         else
            if [ $typ == s ]
            then
               base -10 mif +l; base -10 mif +w
               base -10 maf +l; base -10 maf +w
            else
               [ "$darst" == 'm' ] && let "min=(min+30)/60" "max=(max+30)/60"
               expr "$darst" :: '^[123]$' && {
                  d=0001 g=... f=...
                  to 0$darst repeat; do let "d*=10"; done
                  for 2 g f in min mif max maf
                  do
                     let "$f=$g%d" "$g/=d" "$g<0&&$f<0" && let "$f*=-1"
                  done
               }
               base -10 min +l; base -10 mif +w
               base -10 max +l; base -10 maf +w
            fi
         fi
         base -16 access +w
         base -10 nelem +w
         base -10 bytelen +b
         base -10 nbit +b
         catv 1,typ 1,darst
         #28 bis hier
         prints vsF00020 null ''
         catv einheit =null
         catv 19,null /%n
         if let "flg&1<<11"
         then
            prints vsF00096 null ''
            catv liste =null
            catv 95,null /%n
         fi
      }
   done
   ><<
   return 0
}


MakeBin ./base/cfgbase.txt cfg.dat
MakeBin ./base/mesbase.txt mes.dat

:





###  batt.bsh  #############################################

#:EnerSys SBS190F: Entl.->1.8V; 20░C
#:zeit  [A]     [Ah]
#5m     377.2   31.4
#10m    377.2   62.8
#15m    313.0   78.3
#20m    266.7   88.9
#25m    234.4   97.7
#30m    208.6   104.3
#35m    188.8   110.1
#40m    172.6   115.1
#45m    159.2   119.4
#1h     129.5   129.5
#2h     76.0    152.0
#3h     54.4    163.2
#4h     42.5    170.0
#5h     35.0    175.0
#6h     29.9    179.4
#7h     26.1    182.7
#8h     23.2    185.6
#9h     20.9    188.1
#10h    19.0    190.0
#20h    10.3    206.0
#:Ladung: I= (3+Ib/C10)/4
#: I= 750+250*Ib/C10
#$

C10=190
K10=1900

<"$0"
while read z Ib ah
do
   expr "$z" :: '^#%D%{1,}[mh]' || {
      expr "$z" :: '^#$' && break
      continue
   }
   conv -d. Ib ah
   let "I=750+250*Ib/C10"
   echo $z $Ib $ah $((100*K10/ah)) $I
done
><





###  batt.bsh  #############################################


[ $# -eq 0 ] && {
   Files=?*.[chCH]
   Files="$Files CFGBASE.TXT"
}
[ $# -gt 0 ] && Files=$*

for F in $Files
do
   m=0
   cat $F | {
      > $F
      while readl Z
      do
         expr "$Z" :Z 'Batt%.i1%[' += 'Batt.i[' && m=1
         expr "$Z" :Z 'Batt%.%(%W%{1,}%)%(%[[^]]%{1,}]%)' + 'Batt.B%2.%1' && m=1
         catv Z /%r%n
      done
      ><
   }
   [ m -eq 1 ] && echo $F
done



###  bool.bsh  #############################################


ho=$((2#100000))
hs=$((2#010000))
ht=$((2#001000))
so=$((2#000100))
ss=$((2#000010))
st=$((2#000001))
echo ho hs ht so ss st

for n from 0 to 63 repeat
do
   let "n&hs&&n&ss" && continue
   let "e= (n&ho||(n&hs)==0&&(n&ht)==0)&&
           (n&so||(n&ss)==0&&(n&st)==0)"
   prints sf06s $((2#, n)) =$e
done

#sense= !( !ho&&(hs||ht) || !so&&(ss||st) )


###  box11.bsh  #############################################

#!/u/bin/bsh

X=200 Y=1500 A=100
nthlr=10 nthou=6
nbav=1  #Nutenbreitenaddition vorn
dou=16 dlr=25 dv=8 dh=8 dvh=8  #Dicken
r=$((dou/2))  #Radius
uebhh=$dou  #▄berhang hinten
uebhv=$((dou+nbav))  #▄berhang vorn
bi=850  #Breite innen
ti=425  #Tiefe innen
hi=400  #H÷he innen
bou=$((bi+2*dlr))
tlr=$((ti+dh+uebhh))
hlr=$hi
tou=$((tlr+uebhv))

Box="pa$X,$Y
er$bou,$dou;pr0,$dou;er$dlr,$hi;pr0,$hi;er$bou,$dou;pr$bou,0;er-$dlr,-$hi
pa$((X+bou+A)),$Y
er$tou,$dou;pr0,$dou;er$tlr,$hlr;pr0,$hlr;er$tou,$dou
pa$X,$((Y-A))
er$bou,-$tou
pa$X,$Y;pw0.3lt-2,5,1
pr$((dlr-nthlr)),$((dou-nthou));er$((bi+nthlr*2)),$((hi+nthou*2))
"

print -n "%e%1Bin;sc0,1980,0,2724,0sp1puwu0pw0.5la1,4,2,4;"
catv Box
print -n "%e%1A%eE"




###  brand_lx  #############################################

#!/u/bin/bsh

[ $# -eq 0 ] && exit
Tmp=/tmp/blx_$$
find "$@" -type f -print | file -N -f - > $Tmp
[ -s $Tmp ] || { rm $Tmp; exit; }
<$Tmp
while readl F
do
   expr "$F" :: 'ELF .*executable' || continue
   expr "$F" :F '^%(..*%): ' || continue
   [ -L "$F" -o -d "$F" ] && continue
   [ -s "$F" ] || continue
   brandelf "$F" || continue
   brandelf -t Linux "$F" && brandelf "$F"
done
><
rm $Tmp




###  bsatz  #############################################

#!/u/bin/bsh
# Blocksatz


ozadd()  {
   typeset -i10 nadd=$1 nz=$# zn
   shift
   (( nz-=2 ))
   for zn from $nz by -1 to 1 repeat
   do
      print -nr "$1"; shift
      prints s$(( nadd/nz+1+[zn<=nadd%nz] ))-
   done
   print -r "$1"
}



set -f
[ $# -gt 0 ] && < "$1"
sps="`prints s18-`"
rw=`prints sf+80-`
rz=`prints sf+120-`
oz=`prints sf+120-`
oz=''
while read inp
do
   ifset inp || {
      ifset oz && {
         #let "rw=44-${#oz}"
         #oz="`ozadd $rw $oz`"
         catv sps oz /%n; oz=''
      }
      echo; continue
   }
   ifset oz && oz="$oz $inp"
   ifset oz || oz="$inp"
   [ ${#oz} -lt 44 ] && continue
   while [ ${#oz} -ge 44 ]
   do
      [ ${#oz} -eq 44 ] && { catv sps oz /%n;oz=''; continue 2; }
      #expr "$oz" :rz '^.%{44%}%(.*%)$'
      #expr "$oz" :oz '^%(.%{44%}%)'
      catv 44,,oz =:rz
      catv 44,oz =:oz
      if expr "$rz" :: '^ '
      then
         catv sps oz /%n
         expr "$rz" :oz '^.%(.*%)$'
      elif expr "$oz" :rw ' %([^ ]*%)$'
      then
         rz="$rw$rz"
         expr "$oz" :oz '^%(.*%) [^ ]*$'
         let "rw=44-${#oz}"
         catv sps
         ozadd $rw $oz
         oz="$rz"
      else
         catv sps oz /%n
         oz="$rz"
      fi
   done
   #[ ${#oz} -eq 44 ] && { prints s18-; echo "$oz"; oz=''; }
done

ifset oz && {
   #let "rw=44-${#oz}"
   #oz="`ozadd $rw $oz`"
   catv sps oz /%n
}

[ $# -gt 0 ] && ><





###  bsatz  #############################################

#!/u/bin/bsh

o=$1
until [ "$o" == l -o "$o" == u -o "$o" == lr -o "$o" == ur ]
do
   echo ToLower/ToUpper [rekursiv]
   read "o?Optionen {l|u}[r]: "
   ifset o || exit 0
done

expr "$o" :: 'l' && lu=L
expr "$o" :: 'u' && lu=U
r=' '
expr "$o" :: 'r' && r=R

bsh -c "list -d$r; list -f$r" |
while readl Z z
do
   expr "$Z" :z '[^/\]%{1,}$' "%%$lu&"
   cmpv Z z && continue
   zz="$z"
   a=0
   while [ -e "$z" ]
   do
      let "++a>9" && continue 2
      print -r "Bereits existent: '$z'"
      expr "$z" :z '%(.%)%(%.[^.]%{1,}%)$' "%1$a%2" || z="$z$a"
   done
   print -r "$Z --> $z"
   move "$Z" "$z"
   fsync "$z"
   let 'a==0' && continue
   [ -e "$zz" ] && print -r "Bereits existent: '$zz'"
   [ -e "$zz" -a -d "$zz" ] && continue
   print -r "$z --> $zz"
   move "$z" "$zz"
   fsync "$zz"
done

exit 0



###  bsatz  #############################################

#!/u/bin/bsh

N=-15
[ $# -lt 1 ] && exit 0
[ $# -ge 2 ] && N=-$1 shift

ps -xhwwo user,pid,ppid,pgid,stat,tt,time,command |
   while read - pid - - - - - cmd
   do
      [ pid -eq $$ ] && continue
      expr "$cmd" :: "$1" && {
         echo kill $cmd ...
         kill $N $pid
      }
   done

:



###  bsatz.bsh  #############################################

#!/u/bin/bsh
# Blocksatz
# Copyright (c) 1996  Helmut Schellong


ozadd()  {
   typeset -i10 nadd=$1 nz=$# zn
   shift
   (( nz-=2 ))
   for zn from $nz by -1 to 1 repeat
   do
      print -nr "$1"; shift
      prints s$(( nadd/nz+1+[zn<=nadd%nz] ))-
   done
   print -r "$1"
}



set -f
[ $# -gt 0 ] && < "$1"
sps="`prints s18-`"
rw=`prints sf+80-`
rz=`prints sf+120-`
oz=`prints sf+120-`
oz=''
while read inp
do
   ifset inp || {
      ifset oz && {
         #let "rw=44-${#oz}"
         #oz="`ozadd $rw $oz`"
         catv sps oz /%n; oz=''
      }
      echo; continue
   }
   ifset oz && oz="$oz $inp"
   ifset oz || oz="$inp"
   [ ${#oz} -lt 44 ] && continue
   while [ ${#oz} -ge 44 ]
   do
      [ ${#oz} -eq 44 ] && { catv sps oz /%n;oz=''; continue 2; }
      #expr "$oz" :rz '^.%{44%}%(.*%)$'
      #expr "$oz" :oz '^%(.%{44%}%)'
      catv 44,,oz =:rz
      catv 44,oz =:oz
      if expr "$rz" :: '^ '
      then
         catv sps oz /%n
         expr "$rz" :oz '^.%(.*%)$'
      elif expr "$oz" :rw ' %([^ ]*%)$'
      then
         rz="$rw$rz"
         expr "$oz" :oz '^%(.*%) [^ ]*$'
         let "rw=44-${#oz}"
         catv sps
         ozadd $rw $oz
         oz="$rz"
      else
         catv sps oz /%n
         oz="$rz"
      fi
   done
   #[ ${#oz} -eq 44 ] && { prints s18-; echo "$oz"; oz=''; }
done

ifset oz && {
   #let "rw=44-${#oz}"
   #oz="`ozadd $rw $oz`"
   catv sps oz /%n
}

[ $# -gt 0 ] && ><





###  btr.bsh  #############################################

#!/u/bin/bsh

# CAN BTR Bittimeregister

#100 kHz, RSJ=2-->RSJW=3
#0 100 1001 10  001001
#- TS2 TS1  RSJ PSC
local mhz=000 bt=0000000000 BT=10000000 #picos Periodendauer fŘr ein Bit in Picosekunden
local picos=00000 rsj=00 ts1=00 ts2=00 psc=00
local tq=0000000000 rsjw=00000 btr=0000000000 proz=0000
local Ts1=0000000000 Ts2=0000000000 c=00

#for 2 mhz picos in 16 62500 24 41667 32 31250
#mhz Ist die Quartzfrequenz, picos ist 1/Quartzfrequenz und BT ist die Bittime in picosekunden
#BT fŘr 100Khz = 10000000
#BT fŘr 125Khz =  8000000
#for 3 mhz picos BT in 16 62500  8000000
#for 3 mhz picos BT in 24 41667  8000000
#for 3 mhz picos BT in 24 41667 10000000
for 3 mhz picos BT in 16 62500 10000000
do
   for rsj from 0 to 3 repeat
   do
      for ts1 from 0 to 15 repeat
      do
         for ts2 from 0 to 7 repeat
         do
            for psc from 1 to 63 repeat
            do
               (( tq= (psc+1)*picos,
                  bt= (3+ts1+ts2)*tq,
                  rsjw= (rsj+1)*tq,
                  Ts1= (ts1+1)*tq,
                  Ts2= (ts2+1)*tq,
                  1000000%mhz!=0&&(bt>BT+100||bt<BT-100)||
                  1000000%mhz==0&&bt!=BT
               )) && continue
               #  bt!=BT
               c=00
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw+2*tq" && c='>> '
               [ $c == 00 ] &&
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw" && c='G> '
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw+2*tq" && c='>>='
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw" && c='G>='
               [ $c == 00 ] && continue
               let "btr=ts2<<12|ts1<<8|rsj<<6|psc"
               btr=$((16#, btr)); conv -u btr; prints vsf04 btr $btr
               let "proz=(1+Ts1+1)*100/(1+Ts1+1+Ts2+1)"
               echo "// ${mhz}[MHz]" "$((bt/1000))[ns]" $btr $proz %
                    "$c" ts2=$ts2 ts1=$ts1 rsj=$rsj psc=$psc
               #echo psc=$psc ts1=$ts1 ts2=$ts2 rsj=$rsj
               #Ts1=$Ts1 Ts2=$Ts2 rsjw=$rsjw tq=$tq
            done
         done
      done
   done
done

:




###  btr.bsh  #############################################

#!/u/bin/bsh

# CAN BTR Bittimeregister

#100 kHz, RSJ=2-->RSJW=3
#0 100 1001 10  001001
#- TS2 TS1  RSJ PSC
local mhz=000 bt=0000000000 BT=10000000 #picos Periodendauer fŘr ein Bit in Picosekunden
local picos=00000 rsj=00 ts1=00 ts2=00 psc=00
local tq=0000000000 rsjw=00000
local Ts1=0000000000 Ts2=0000000000 c=00

#for 2 mhz picos in 16 62500 24 41667 32 31250
#mhz Ist die Quartzfrequenz, picos ist 1/Quartzfrequenz und BT ist die Bittime in picosekunden
#BT fŘr 100Khz = 10000000
#BT fŘr 125Khz =  8000000
#for 3 mhz picos BT in 16 62500  8000000
for 3 mhz picos BT in 24 41667  8000000
do
   for rsj from 0 to 3 repeat
   do
      for ts1 from 0 to 15 repeat
      do
         for ts2 from 0 to 7 repeat
         do
            for psc from 1 to 63 repeat
            do
               (( tq= (psc+1)*picos,
                  bt= (3+ts1+ts2)*tq,
                  rsjw= (rsj+1)*tq,
                  Ts1= (ts1+1)*tq,
                  Ts2= (ts2+1)*tq,
                  1000000%mhz!=0&&(bt>BT+100||bt<BT-100)||
                  1000000%mhz==0&&bt!=BT
               )) && continue
               #  bt!=BT
               c=00
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw+2*tq" && c='>> '
               [ $c == 00 ] &&
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw" && c='G> '
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw+2*tq" && c='>>='
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw" && c='G>='
               [ $c == 00 ] && continue
               echo "// ${mhz}[MHz]" "$((bt/1000))[ns]" %
                    "$c" ts2=$ts2 ts1=$ts1 rsj=$rsj psc=$psc
               #echo psc=$psc ts1=$ts1 ts2=$ts2 rsj=$rsj
               #Ts1=$Ts1 Ts2=$Ts2 rsjw=$rsjw tq=$tq
            done
         done
      done
   done
done

:




###  btr.bsh  #############################################

#!/u/bin/bsh

# CAN BTR Bittimeregister

#100 kHz, RSJ=2-->RSJW=3
#0 100 1001 10  001001
#- TS2 TS1  RSJ PSC
local mhz=000 bt=0000000000 BT=10000000 #picos
local picos=00000 rsj=00 ts1=00 ts2=00 psc=00
local tq=0000000000 rsjw=00000
local Ts1=0000000000 Ts2=0000000000 c=00

for 2 mhz picos in 16 62500 24 41667 32 31250
do
   for rsj from 0 to 3 repeat
   do
      for ts1 from 0 to 15 repeat
      do
         for ts2 from 0 to 7 repeat
         do
            for psc from 1 to 63 repeat
            do
               (( tq= (psc+1)*picos,
                  bt= (3+ts1+ts2)*tq,
                  rsjw= (rsj+1)*tq,
                  Ts1= (ts1+1)*tq,
                  Ts2= (ts2+1)*tq,
                  1000000%mhz!=0&&(bt>BT+100||bt<BT-100)||
                  1000000%mhz==0&&bt!=BT
               )) && continue
               #  bt!=BT
               c=00
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw+2*tq" && c='>> '
               [ $c == 00 ] &&
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw" && c='G> '
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw+2*tq" && c='>>='
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw" && c='G>='
               [ $c == 00 ] && continue
               echo "// ${mhz}[MHz]" "$((bt/1000))[ns]" %
                    "$c" ts2=$ts2 ts1=$ts1 rsj=$rsj psc=$psc
               #Ts1=$Ts1 Ts2=$Ts2 rsjw=$rsjw tq=$tq
            done
         done
      done
   done
done

:




###  btr.bsh  #############################################

#!/u/bin/bsh

# CAN BTR Bittimeregister

local mhz=000 bt=0000000000 BT=10000000 #picos
local picos=00000 rsj=00 ts1=00 ts2=00 psc=00
local tq=0000000000 rsjw=00000
local Ts1=0000000000 Ts2=0000000000 c=00

for 2 mhz picos in 32 31250 16 62500
do
   for rsj from 0 to 3 repeat
   do
      for ts1 from 0 to 15 repeat
      do
         for ts2 from 0 to 7 repeat
         do
            for psc from 1 to 63 repeat
            do
               (( tq= (psc+1)*picos,
                  bt= (3+ts1+ts2)*tq,
                  rsjw= (rsj+1)*tq,
                  Ts1= (ts1+1)*tq,
                  Ts2= (ts2+1)*tq,
                  bt!=BT
               )) && continue
               c=00
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw+2*tq" && c='>> '
               [ $c == 00 ] &&
               let "Ts1>2*tq&&Ts1>rsjw&&Ts2>2*tq&&Ts2>rsjw" && c=' > '
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw+2*tq" && c='>>='
               [ $c == 00 ] &&
               let "Ts1>=2*tq&&Ts1>=rsjw&&Ts2>=2*tq&&Ts2>=rsjw" && c=' >='
               [ $c == 00 ] && continue
               echo "// ${mhz}[MHz]" "$((bt/1000))[ns]" %
                    "$c" ts2=$ts2 ts1=$ts1 rsj=$rsj psc=$psc
               #Ts1=$Ts1 Ts2=$Ts2 rsjw=$rsjw tq=$tq
            done
         done
      done
   done
done

:




###  build.bsh  #############################################


expr "$PWD" =:: '[/\]release$' && cd ..
expr "$PWD" :PD '[/\]%([^/\]%{1,}%)$'
conv -l PD
case "$PD" in
   mu2000)  DSH='8000 10000 10000 4000 4000 4000 4000';;
     upc3)  DSH='8000 10000 10000 4000 4000 4000 4000';;
   upc3cf)  DSH='40000 40000 40000';;
     upc4)  DSH='40000 40000 40000';;
        *)  echo "Verzeichnisname ist so unbekannt. Bitte in 'build.bsh anpassen!"; exit 1;;
esac
echo $PD

(. ./bsh/uniqid.bsh base/cfgbase.txt %
                    base/mesbase.txt %
                    base/txtbase.h   ) || exit 9
(. ./bsh/uniqadr.bsh base/cfgbase.txt) || exit 9
(. ./bsh/overlapadr.bsh base/cfgbase.txt) || exit 9
(. ./bsh/texts.bsh)
(. ./bsh/tpa.bsh $DSH)
(. ./bsh/cfg.bsh)

:





###  build.bsh  #############################################


expr "$PWD" =:: '[/\]release$' && cd ..
expr "$PWD" :PD '[/\]%([^/\]%{1,}%)$'
conv -l PD
case "$PD" in
   mu2000)  DSH='8000 10000 10000 4000 4000 4000 4000';;
     upc3)  DSH='8000 10000 10000 4000 4000 4000 4000';;
   upc3cf)  DSH='40000 40000 40000';;
     upc4)  DSH='40000 40000 40000';;
     u229)  DSH='40000 40000 40000';;
        *)  echo "Verzeichnisname ist so unbekannt. Bitte in 'build.bsh anpassen!"; exit 1;;
esac
echo $PD

(. ./bsh/uniqid.bsh base/cfgbase.txt %
                    base/mesbase.txt %
                    base/txtbase.h   ) || exit 9
(. ./bsh/texts.bsh)
(. ./bsh/tpa.bsh $DSH)
(. ./bsh/cfg.bsh)

:





###  build.bsh  #############################################


expr "$PWD" =:: '[/\]release$' && cd ..
expr "$PWD" :PD '[/\]%([^/\]%{1,}%)$'
conv -l PD
case "$PD" in
   mu2000)  DSH='8000 10000 10000 4000 4000 4000 4000';;
     upc3)  DSH='8000 10000 10000 4000 4000 4000 4000';;
   upc3cf)  DSH='40000 40000 40000';;
     upc4)  DSH='40000 40000 40000';;
        *)  echo "Verzeichnisname ist so unbekannt. Bitte in 'build.bsh anpassen!"; exit 1;;
esac
echo $PD

(. ./bsh/uniqid.bsh base/cfgbase.txt %
                    base/mesbase.txt %
                    base/txtbase.h   ) || exit 9
(. ./bsh/texts.bsh)
(. ./bsh/tpa.bsh $DSH)
(. ./bsh/cfg.bsh)

:





###  build.bsh  #############################################



expr "$PWD" :PD '/%([^/]%{1,}%)$'
conv -l PD
case "$PD" in
   mu2000)  DSH='8000 10000 10000 4000 4000 4000 4000';;
     upc3)  DSH='8000 10000 10000 4000 4000 4000 4000';;
        *)  DSH='8000 10000 10000 4000 4000 4000 4000';;
esac
echo $PD

(. ../bsh/texts.bsh)
(. ../bsh/tpa.bsh $DSH)
(. ../bsh/cfg.bsh)

:





###  build.bsh  #############################################



(. ../bsh/texts.bsh)
(.  ./tpa.bsh)
(. ../bsh/cfg.bsh)




###  build.bsh  #############################################



(. texts.bsh)
(. tpa.bsh)
(. cfg.bsh)




###  c256.bsh  #############################################

#!/home/bin/bsh

for C from 0 to 255 repeat
do
   base -10 C +b CB
   let "C<32" && CB=" "
   prints ss3ss4  "   /* " $C " '$CB' */  " $C,
done



###  calcaddrsigen.bsh  #############################################

#!/u/bsh


#
CalcSet()  {
   local pad=0000 ele=0000 adr=110000
   while readl Z
   do
      expr "$Z" :flags ' %(p%D%{1,}A%D%{1,}%)st2T' && {
         expr "$flags" :pad 'p%(%D%{1,}%)'
         expr "$flags" :ele 'A%(%D%{1,}%)'
         [ adr -gt 110000 ] && {
            prints vsf06 adr $adr
            expr "$Z" :Z ' %D%{6} ' = " $adr " ||
            expr "$Z" :Z ' ' = '!'
         }
         let 'adr+=ele+pad'
      }
      catv Z /%n
   done
   return 0
}


CalcSet





###  call.bsh  #############################################


< $1
> _$1
while readl zeile
do
   expr "$zeile" :: '[ %t]call .' || { catv zeile /%j; continue; }
   grep -Fq -e "$zeile" call || { catv zeile /%j; continue; }
   echo '%tmovl %%ecx,ECX'
   catv zeile /%j
   echo '%tmovl ECX,%%ecx'
done
><<



###  canid.bsh  #############################################

#!/u/bin/bsh

set GER:.100
Found=00

# ID
Get()  {
   local ger=.... id=0000 n=000 inc=000 fnd=00 cid=$1
   GER=
   for 4 ger id n inc in %
        LAMP  10   1   0 %
         BUI  80  16 -64 %
          MU  48  16 -16 %
         STS  64  16 256 %
        INV0  96  32 256 %
         REC 128 128 256 %
         DCC 768 128 256 %
         RK1 256  16  16 %
         FMB 288   4 256 %
         XXA 292   4 256 %
         XXX 296  16 256 %
         CAL 312   8 256 %
         FAN 320  16 256 %
         MMB 336   4 256 %
         DEB 340   2 256 %
         RYB 342   2 256 %
         BMB 344   8 256 %
        INV1 352  32 256 %
         RD1 736  32 256 %
         RDP 760   8 256
   do
      let "$1>=id&&$1<id+n" && { let ++fnd; GER="$GER tx ${ger}.$((cid-id))"; }
      let "$1>=id+inc&&$1<id+n+inc" && { let ++fnd; GER="$GER rx ${ger}.$((cid-id-inc))"; }
   done
   Found=$fnd
   [ fnd -eq 0 ] && return 1
   return 0
}



N=0000
local txrx=.... ger=..........

for N from 0 to $((1023+256)) repeat
do
   prints s4- $N
   Get $N
   [ Found -eq 0 ] && GER="- - - -"
   [ Found -eq 1 ] && GER="$GER - -"
   for 2 txrx ger in $GER
   do
      prints s6ss-9-  "&$txrx" " " "&$ger"
   done
   if let "(N&15)==15"
   then
      echo " \\%n%%%%%n%%%%%%%%"
   else
      echo " \\"
   fi
done





###  cat.bsh  #############################################


p=/scratch/VALUE
cat /scratch/NT/EAGLE/SC/SMD.LBR- > 1.lib
cat /scratch/NT/EAGLE/SC/SMD.LBR- > 2.lib
cat /scratch/NT/EAGLE/SC/SMD.LBR- > 3.lib
n=31
while let "++n<=43"
do
   cat $p/350$n >> 1.lib
   cat $p/350$((n+12)) >> 2.lib
   cat $p/350$((n+12*2)) >> 3.lib
done



###  catinfo.bsh  #############################################

#!/u/bin/bsh

base=gcc
name=/usr/local/info/$base.info

[ -s $name ] && cat $name >> ${base}_info

for n from 0 to 99 repeat
do
   [ -s $name-$n ] && cat $name-$n >> ${base}_info
   [ -s $name-$n.gz ] && gunzip -c $name-$n.gz >> ${base}_info
done




###  cfg.bsh  #############################################

#!/u/bin/bsh

set -f

VonBis()  {
   local sd=0000 nam
   [ $# -gt 0 ] || return
   for nam in $*
   do
      ifset $nam || continue
      while expr "${{nam}}" :sd '##%(-%{0,1}[0-9]%{1,}%)'
      do
         let 'sd+=von*inc2'
         expr "${{nam}}" :$nam '##-%{0,1}[0-9]%{1,}' = "$sd"
      done
      while expr "${{nam}}" :sd '#%(-%{0,1}[0-9]%{1,}%)'
      do
         let 'sd+=von'
         expr "${{nam}}" :$nam '#-%{0,1}[0-9]%{1,}' = "$sd"
      done
   done
   return 0
}


MakeTexte()  {
   #0.0.000.00000
   _id=0000000000
   grp=0000000
   obj=0000000
   sk=000000
   skvb=000000
   adr=0032
   buf=..................................................................
   von=000
   bis=000
   inc=000
   inc2=000
   info1=000
   info2=000
   parbn=00
   idadd=0000
   3>d__1
   print -u3 '%n#                include <def.h>'
   print -u3 '#                include <var.h>'
   print -u3 '#                include <texte.h>%n%n%n'
   print -u3 '// id: 0.0.000.00000'
   print -u3 '//       d grp object'
   print -u3 '
   // struct cfgdata_t { const BYTE *grp, *sgrp;
   //                    UNS4 id;
   //                    UNS2 adr, len, nbit, bitpos;
   //                    UNS4 flags;
   //                    BYTE typ, darst, info1, info2;
   //                    UNS2 parbn, nelem, voffs;
   //                    const BYTE FAR *dfstr;
   //                    UNS4 dfmima[3];
   //                    UNS2 szname;
   //                    VOL void *name;
   //                    const BYTE FAR *einheit, *text, *info;
   //                    cfap_t Tinfo, Tgrp, Tsgrp, Tbit, Text;
   // };
   '
  
   [ -n "$4" ] && : >$4
    >d__2
   4>d__3
   print -u4 '%n%n%nconst struct cfgdata_t FAR '"$1"'data[]= {'
   <$2
   while seek + 0 sk; read id dd typ bytelen darst nbit bitpos %
              dflt1 min1 max1 %
              parbn flags einheit name Tinfo Tgrp Tsgrp Tbit Text text
   do
      info1=?
      expr "$id" :: '^%$' && break
      expr "$id" :: '^}$' && {
         [ von -ge bis ] && inc=0 continue
         seek $skvb 0; let 'von+=inc'; continue
      }
      expr "$id" :: '^{#$' && {
         von=$dd bis=$typ inc=$bytelen inc2=$darst
         ifset inc2 || inc2=1
         seek + 0 skvb; continue
      }
      expr "$id" :: '^:..*' && {
         idadd=0 psgrp=0 obj=0 let grp+=500000
         seek $sk 0; readl Z; conv -D: Z
         [ inc -gt 0 ] && VonBis Z
         prints vssf08 pgrp G$1 $grp
         prints su3ss '       const BYTE       ' $pgrp "[]= %"$Z%";"
         echo
         let "adr>32" && let "adr=[(adr/264)+1+(adr%%264>=264/2)]*264"
         continue
      }
      expr "$id" :: '^%...*' && {
         seek $sk 0; readl Z; conv -D. Z
         [ inc -gt 0 ] && VonBis Z
         prints vssf08 psgrp g$1 $grp
         prints su3ss '       const BYTE       ' $psgrp "[]= %"$Z%";"
         continue
      }
      expr "$id" :id '^@%([0-9]%{1,}%)' && {
         let "obj+=500+idadd" "_id=grp+obj" "adr=$adr" "bytelen=$bytelen" "id=$id"
         idadd=0
         let dd && let "_id+=dd*100000000"
         let id && _id=$id
         [ inc -gt 0 -a "$typ" != s ] && VonBis parbn name text Tinfo Tgrp Tsgrp Tbit Text
         [ inc -gt 0 -a "$typ" == s ] && VonBis parbn name text dflt1 Tinfo Tgrp Tsgrp Tbit Text
         conv '-t` ' name
         idname="$name"
         expr "$idname" :: '^[A-Za-z_]' || idname="$text"
         expr "$idname" :idname '^%([^\]%{1,}%)\000'
         conv '-d[d]' idname
         expr "$idname" :idname '[^A-Za-z_0-9]' += '_'
         [ -n "$4" ] && prints ss-24s12 '#define ID_' "$idname" "$_id" >> $4
         nelem=1 voffs=0
         expr "$flags" :nelem 'A%([0-9]%{1,}%)' && {
            voffs='sizeof('"$name"')'
            [ "$name" == 0 ] && voffs=$bytelen
         }
         expr "$flags" :nelem 'S%([0-9]%{1,}%)' && {
            #expr "$name" :idname '^%(.*[^.]%)%.[^.]%{1,}$'
            expr "$name" :idname ']%..%{1,}$' = ']'
            voffs='sizeof('"$idname"')'
            [ "$name" == 0 ] && voffs=$bytelen
         }
         pad=0 autopad=0
         expr "$flags" :pad 'p%([0-9]%{1,}%)' || {
            autopad=1 let 'pad=bytelen*nelem'
         }
         buf='"'
         while :
         do
            seek + 0 sk
            readl Z
            expr "$Z" :: '^@:.' || { seek $sk 0; break; }
            catv 2,,Z =0:,,buf
         done
         [ ${#buf} -le 1 ] && buf=0
         [ ${#buf} -gt 1 ] && buf="$buf%""
         conv '-t` ' dflt1 text
         [ "$darst" ==  1 ] && darst=/
         expr "$darst" :darst '%.%([0-9]%)'
         [ "$dflt1" == '"' ] && dflt1=0
         [ "$typ" == s -a "$dflt1" == '\000' ] && dflt1=
         if [ "$typ" == s ]
         then
            let "autopad&&pad>4" && let "pad>>=1"
            ptr='&'
            w1w2w3=
            min1='0'
            max1="$min1"
            expr "$flags" :: '#' && goend
            dflt1="%"$dflt1%""
         else
            ptr='&'
            w1=15 w2=15 w3=14
            [ "$min1" == '"' ] && min1=0
            [ "$max1" == '"' ] && max1=0
            [ "$typ" == s ] && goend
            l=4 u=u
            [ bytelen -eq 4 ] && l=8 u=ul
            for v in dflt1 min1 max1
            do
               case "$typ" in
                 b)  expr "${{v}}" :$v '^x%([0-9a-fA-F]%{1,}%)$' && goend
                     base -2 $v +16 $v ;;
                 x)  goend ;;
                 *)  continue ;;
               esac
               prints vssf0${l}s $v 0x ${{v}} $u ;;
            done
         fi
         flg=000000 info2=0
         expr "$flags" :info2 '=%([1-9][0-9]%{0,2}%)'
         expr "$flags" :: '[sz]' && let autopad && pad=0
         expr "$flags" :: 'a' && let "flg|=1<<30"
         expr "$flags" :: 'h' && let "flg|=1<<20"
         expr "$flags" :: 'u4' && let "flg|=1<<19"
         expr "$flags" :: 'u3' && let "flg|=1<<18"
         expr "$flags" :: 'u2' && let "flg|=1<<17"
         expr "$flags" :: 'u1' && let "flg|=1<<16"
         expr "$flags" :: 'd' && let "flg|=1<<15"
         expr "$flags" :: 'c' && let "flg|=1<<14"
         expr "$flags" :: 'I' && let "flg|=1<<13"
         expr "$flags" :: 't1' && let "flg|=1<<12"
         expr "$flags" :: 'l' && let "flg|=1<<11"
         expr "$flags" :: 't2' && let "flg|=1<<10"
         expr "$flags" :: 'B[AS][0-9]' && let "flg|=256"
         expr "$flags" :: '1%.' && let "flg|=128"
         expr "$flags" :: 'q' && let "flg|=64"
         expr "$flags" :: 'K[AS][0-9]' && let "flg|=32"
         expr "$flags" :: 'i' && let "flg|=16"
         expr "$flags" :: 's' && let "flg|=8"
         expr "$flags" :: 'n' && let "flg|=4"
         expr "$flags" :: 'b' && let "flg|=2"
         expr "$flags" :: 'r' && let "flg|=1"
         expr "$flags" :: '&' && ptr=
         ds=0000000000000000000
         vname=$name
         expr "$flags" :: 'v' && ds=v name=0
         [ "$name" == 0 -o "$name" == '"' ] && name=0 ptrlet "flg|=512"
         [ "$name" != 0 ] && print -u5 "$1%t$bytelen%t$name"
         prints vssf08s flags 0x $((16#, flg)) ul
         prints vsf010 pid $_id
         echo
         prints s-28sbs %
                "#define D${pid}grp" $pgrp, $psgrp
         echo "// id; adr, len, nbit, bitpos,"
         echo "// flags(_|abgl|_|_|_|_|_|_ | _|_|_|halten|u4cal|u3sys|u2hw|u1root)"
         echo "// flags(dfltcalc|access|IP|Telem|infovals|Tbbig|novar|batt | step10|mess|kamm|initcan|sig|nod|bak|ro);"
         echo "// typ, darst, info1, info2, parbn, nelem, voffs;"
         prints s-28s11bs6bs5bs5bs5bsbsbsbsbsbsbsbs %
                "#define D${pid}obj" %
                 $_id, $adr, $bytelen, $nbit, $bitpos, $flags, %
                 "'$typ'," "'$darst'," "'$info1'," "$info2," %
                 $parbn, "$nelem," "$voffs"
         if [ "$typ" == s ]
         then
            [ "$ds" == v ] && prints s "       const BYTE ${vname}[]= $dflt1;"
            prints s "       const BYTE FAR S${pid}[]= $dflt1;"
            ds=S${pid} dflt1=0 min1=0 max1=0
         else
            ds=0
         fi
         prints s-28s %
                "#define D${pid}str" "$ds"
         prints s-28s${w1}bs${w2}bs${w3} %
                "#define D${pid}dfmima" "$dflt1," "$min1," "$max1"
         prints s-28sbs %
                "#define D${pid}szname" "sizeof($name)," "$ptr$name"
         if [ "$einheit" != '"' ]
         then
            prints s "       const BYTE FAR E${pid}[]= %"$einheit%";"
            einheit=E${pid}
         else
            einheit=0
         fi
         prints s "       const BYTE FAR T${pid}[]= %"$text%";"
         text=T${pid}
         prints s-28s11sbs11 %
                "#define D${pid}einhtxt" "$einheit" , "$text"
         if [ "$buf" != 0 ]
         then
            prints s "       const BYTE FAR I${pid}[]= $buf;"
            buf=I${pid}
         else
            buf=0
         fi
         prints s-28s11 %
                "#define D${pid}info" "$buf"
         prints s-28sbsbsbsbs %
                "#define D${pid}Text"  $Tinfo, $Tgrp, $Tsgrp, $Tbit, $Text
         let "adr+=bytelen*nelem+pad"
         let "nelem>1" && idadd=500
         prints su4sbsbsbsbsbsbsbsbs '   { ' %
                D${pid}grp, D${pid}obj, D${pid}str, %
              "{D${pid}dfmima}," %
                D${pid}szname, D${pid}einhtxt, D${pid}info, D${pid}Text ' },'
         continue
      }
   done
   print -u4 '   { 0 }%n};%n%nconst unsigned '"$1"'data_ne= sizeof('"$1"'data)/sizeof(*'"$1"'data);%n%n'
   ><<<<
   cat d__1 d__2 d__3 > $3
   remove d__1 d__2 d__3
   return 0
}


5>vn.txt
MakeTexte CFG cfgbase.txt cfgdata.c cfg.h
MakeTexte MES mesbase.txt mesdata.c
><

#(cfg2.bsh)

exit 0

#     prints s-33s${w1}bs${w2}bs${w3} %
#            "#define D${pid}dfltminmax10" "$dfltbm," "$minbm," "$maxbm"
#     prints s-33s${w1}bs${w2}bs${w3} %
#            "#define D${pid}dfltminmax11" "$dfltbm2," "$minbm2," "$maxbm2"
#            D${pid}dfltminmax10, "D${pid}dfltminmax11}," %



###  cfg.bsh  #############################################

#!/u/bin/bsh

set -f

MakeTexte()  {
   #0.0.000.00000
   sk=000000
   buf=..................................................................
   txtnum=000
   txtgrp=000
   3>d__1
   print -u3 '%n/* Made by script cfg.bsh (H.Schellong) */'
   print -u3 '%n#                include "def.h"'
   print -u3 '#                include "share/var.h"'
   print -u3 '#                include "texte.h"%n%n%n'
   print -u3 '// id: 0.0.000.00000'
   print -u3 '//       d grp object'
   print -u3 '
   // struct cfgdata_t { UNS4 id, adr, flags, idlink, sort;
   //                    UNS2 grp, len, nbit, bitpos;
   //                    BYTE typ, darst, txtnum, txtgrp;
   //                    UNS2 parbn, nelem, voffs, access;
   //                    const BYTE *dfstr;
   //                    UNS4 dfmima[3];
   //                    UNS2 szname;
   //                    VOL void *name;
   //                    const BYTE *einheit, *info;
   //                    tsp_t Tinfo, Tgrp, Tsgrp, Tbit, Text;
   // };
   '
  
   [ -n "$4" ] && print '%n/* Made by script cfg.bsh (H.Schellong) */%n' >$4
    >d__2
   4>d__3
   print -u4 '%n%n%nconst struct cfgdata_t '"$1"'data[]= {'
   <$2
   while read id dd adr grp idlink sort parbn typ bytelen darst nbit bitpos %
              access dflt1 min1 max1 %
              flags einheit name Tinfo Tgrp Tsgrp Tbit Text text
   do
      expr "$id" :: '^%$' && break
      expr "$id" :: '^:..*' && { echo; continue; }
      expr "$id" :: '^%...*' && { continue; }
      expr "$id" :id '^@%([0-9]%{1,}%)' && {
         let "adr=$adr" "bytelen=$bytelen" "id=$id" "parbn=$parbn"
         let "idlink=$idlink" "sort=$sort" "grp=$grp"
         let "id+=dd*100000000" "idlink+=dd*100000000"
         #let "grp=(id/100000) % 1000"
         conv '-t` ' name
         idname="$name"
         expr "$idname" :: '^[A-Za-z_]' || idname="$text"
         expr "$idname" :idname '^%([^\]%{1,}%)\000'
         conv '-d[d]' idname
         expr "$idname" :idname '[^A-Za-z_0-9]' += '_'
         [ -n "$4" ] && prints ss-24s12 '#define ID_' "$idname" "$id" >> $4
         nelem=1 voffs=0
         expr "$flags" :nelem 'A%([0-9]%{1,}%)' && {
            voffs='sizeof('"$name"')'
            [ "$name" == 0 ] && voffs=$bytelen
         }
         expr "$flags" :nelem 'S%([0-9]%{1,}%)' && {
            expr "$name" :idname ']%..%{1,}$' = ']'
            voffs='sizeof('"$idname"')'
            [ "$name" == 0 ] && voffs=$bytelen
         }
         buf='"'
         while :
         do
            seek + 0 sk
            readl Z
            expr "$Z" :: '^@:.' || { seek $sk 0; break; }
            catv 2,,Z =0:,,buf
         done
         [ ${#buf} -le 1 ] && buf=0
         [ ${#buf} -gt 1 ] && buf="$buf%""
         conv '-t` ' dflt1
         [ "$darst" ==  1 ] && darst=/
         expr "$darst" :darst '%.%([0-9]%)'
         [ "$dflt1" == '"' ] && dflt1=0
         [ "$typ" == s -a "$dflt1" == '\000' ] && dflt1=
         if [ "$typ" == s ]
         then
            ptr='&'
            w1w2w3=
            min1='0'
            max1="$min1"
            expr "$flags" :: '#' && goend
            dflt1="%"$dflt1%""
         else
            ptr='&'
            w1=15 w2=15 w3=14
            [ "$min1" == '"' ] && min1=0
            [ "$max1" == '"' ] && max1=0
            [ "$typ" == s ] && goend
            l=4 u=u
            [ bytelen -eq 4 ] && l=8 u=ul
            for v in dflt1 min1 max1
            do
               case "$typ" in
                 b)  expr "${{v}}" :$v '^x%([0-9a-fA-F]%{1,}%)$' && goend
                     base -2 $v +16 $v ;;
                 x)  goend ;;
                 *)  continue ;;
               esac
               prints vssf0${l}s $v 0x ${{v}} $u ;;
            done
         fi
         flg=0000000000 txtgrp=0 txtnum=0
         expr "$flags" :txtnum 'T%(%D%{1,3}%)'
         expr "$flags" :txtgrp 'G%(%D%{1,3}%)'
         expr "$flags" :: 'a'   && let "flg|=1<<30"
         expr "$flags" :: 'Z'   && let "flg|=1<<24"
         expr "$flags" :: 'S'   && let "flg|=1<<23"
         expr "$flags" :: 'A'   && let "flg|=1<<22"
         expr "$flags" :: 'E'   && let "flg|=1<<21"
         expr "$flags" :: 'N'   && let "flg|=1<<19"
         expr "$flags" :: 'F'   && let "flg|=1<<18"
         expr "$flags" :: 'm'   && let "flg|=1<<17"
         expr "$flags" :: 'D'   && let "flg|=1<<16"
         expr "$flags" :: 'd'   && let "flg|=1<<15"
         expr "$flags" :: ':'   && let "flg|=1<<14"
         expr "$flags" :: 'I'   && let "flg|=1<<13"
         expr "$flags" :: 't1'  && let "flg|=1<<12"
         expr "$flags" :: 'l'   && let "flg|=1<<11"
         expr "$flags" :: 't2'  && let "flg|=1<<10"
         expr "$flags" :: 'B'   && let "flg|=1<<8"
         expr "$flags" :: '1%.' && let "flg|=1<<7"
         expr "$flags" :: 'q'   && let "flg|=1<<6"
         expr "$flags" :: 'K'   && let "flg|=1<<5"
         expr "$flags" :: 'i'   && let "flg|=1<<4"
         expr "$flags" :: 's'   && let "flg|=1<<3"
         expr "$flags" :: 'n'   && let "flg|=1<<2"
         expr "$flags" :: 'b'   && let "flg|=1<<1"
         expr "$flags" :: 'r'   && let "flg|=1"
         expr "$flags" :: '&'   && ptr=
         ds=0000000000000000000
         vname=$name
         expr "$flags" :: 'v' && ds=v name=0
         [ "$name" == 0 -o "$name" == '"' ] && name=0 ptrlet "flg|=512"
         [ "$name" != 0 ] && print -u5 "$1%t$bytelen%t$name"
         prints vssf08 sort 0x $sort
         prints vssf08 flags 0x $((16#, flg))
         prints vsf010 pid $id
         echo
         echo "// id, adr,"
         echo "// flags(_|abgl|_|_|_|_|_|strarr | sarr|arr|eventmap|_|nidlnk|feld|messw|unbdflt)"
         echo "// flags(dfltcalc|bitfeld|IP|Telem|infovals|Tbbig|_|batt | step10|mess|kamm|initcan|sig|nod|bak|ro),"
         echo "// idlink, sort;"
         echo "// grp, len, nbit, bitpos, typ, darst, txtnum, txtgrp, parbn, nelem, voffs, access;"
         prints s-28s11bs11bsbs11bs11 %
                "#define D${pid}long" %
                 $id, $adr, $flags, $idlink, $sort
         prints s-28s5bs5bs5bsbsbsbsbsbsbsbsbs %
                "#define D${pid}obj" %
                 $grp, $bytelen, $nbit, $bitpos, %
                 "'$typ'," "'$darst'," "$txtnum," "$txtgrp," %
                 "$parbn," "$nelem," "$voffs," 0x${access}u
         if [ "$typ" == s ]
         then
            [ "$ds" == v ] && prints s "       const BYTE ${vname}[]= $dflt1;"
            prints s "       const BYTE S${pid}[]= $dflt1;"
            ds=S${pid} dflt1=0 min1=0 max1=0
         else
            ds=0
         fi
         prints s-28s %
                "#define D${pid}str" "$ds"
         prints s-28s${w1}bs${w2}bs${w3} %
                "#define D${pid}dfmima" "$dflt1," "$min1," "$max1"
         prints s-28sbs %
                "#define D${pid}szname" "sizeof($name)," "$ptr$name"
         if [ "$einheit" != '"' ]
         then
            prints s "       const BYTE E${pid}[]= %"$einheit%";"
            einheit=E${pid}
         else
            einheit=0
         fi
         prints s-28s11 "#define D${pid}einhtxt" "$einheit"
         if [ "$buf" != 0 ]
         then
            prints s "       const BYTE I${pid}[]= $buf;"
            buf=I${pid}
         else
            buf=0
         fi
         prints s-28s11 %
                "#define D${pid}info" "$buf"
         prints s-28sbsbsbsbs %
                "#define D${pid}Text"  $Tinfo, $Tgrp, $Tsgrp, $Tbit, $Text
         prints su4sbsbsbsbsbsbsbsbs '   { ' %
                D${pid}long, D${pid}obj, D${pid}str, %
              "{D${pid}dfmima}," %
                D${pid}szname, D${pid}einhtxt, D${pid}info, D${pid}Text ' },'
         continue
      }
   done
   print -u4 '   { 0 }%n};%n%nconst unsigned '"$1"'data_ne= sizeof('"$1"'data)/sizeof(*'"$1"'data);%n%n'
   ><<<<
   cat d__1 d__2 d__3 > $3
   remove d__1 d__2 d__3
   return 0
}


5>./base/vn.txt
MakeTexte CFG ./base/cfgbase.txt cfgdata.c cfg.h
MakeTexte MES ./base/mesbase.txt mesdata.c
><

:





###  cfg.bsh  #############################################


set -f

VonBis()  {
   local sd=0000 nam
   [ $# -gt 0 ] || return
   for nam in $*
   do
      ifset $nam || continue
      while expr "${{nam}" :sd '#%(-%{0,1}[0-9]%)'
      do
         let 'sd+=von'
         expr "${{nam}" :$nam '#-%{0,1}[0-9]' = "$sd"
      done
   done
   return 0
}

#0.0.000.00000
_id=0000000000
grp=0000000
obj=0000000
sk=000000
skvb=000000
adr=0032
buf=..................................................................
von=000
bis=000
inc=000
3>d1
print -u3 '%n#                include "def.h"'
print -u3 '#                include "var.h"%n%n%n'
print -u3 '// id: 0.0.000.00000'
print -u3 '//         grp object'
print -u3 '
// struct cfgdata_t { const BYTE *grp; WORD pdummy;
//                    DWORD id;
//                    WORD adr, len, flags, dummy;
//                    BYTE typ, darst, nelem, voffs;
//                    const BYTE __far *dfstr;
//                    DWORD dfmima[2][3];
//                    WORD szname;
//                          void *name;
//                    const BYTE __far *einheit, *text, *info;
// };
'

: >cfg.h
 >d2
4>d3
print -u4 '%n%n%nconst struct cfgdata_t __far CFGdata[]= {'
<cfgbase.txt
while seek + 0 sk; read id typ bytelen darst %
           dflt1 min1 max1 dflt2 min2 max2 %
           flags einheit name text
do
   pdummy=0
   dummy=0
   expr "$id" :: '^%$' && break
   expr "$id" :: '^}$' && {
      [ von -ge bis ] && inc=0 continue
      seek $skvb 0; let 'von+=inc'; continue
   }
   expr "$id" :: '^{#$' && {
      von=$typ bis=$bytelen inc=$darst
      seek + 0 skvb; continue
   }
   expr "$id" :: '^:..*' && {
      obj=0 let grp+=500000
      seek $sk 0; readl Z; conv -D: Z
      [ inc -gt 0 ] && VonBis Z
      prints vssf08 pgrp G $grp
      prints su3ss '       const BYTE       ' $pgrp "[]= %"$Z%";"
      echo
      let "adr>32" && let "adr=[(adr/264)+1+(adr%%264>=264/2)]*264"
      continue
   }
   expr "$id" :id '^@%([0-9]%{1,}%)' && {
      let "obj+=100" "_id=grp+obj" "adr=$adr" "bytelen=$bytelen" "id=$id"
      let id && _id=$id
      [ inc -gt 0 -a "$typ" != s ] && VonBis name text
      [ inc -gt 0 -a "$typ" == s ] && VonBis name text dflt1 dflt2
      idname="$name"
      expr "$idname" :: '^[A-Za-z_]' || idname="$text"
      expr "$idname" :idname '^%([^\]%{1,}%)\000'
      conv '-d[d]' idname
      expr "$idname" :idname '[^A-Za-z_0-9]' += '_'
      prints ss-24s12 '#define ID_' "$idname" "$_id" >> cfg.h
      nelem=1 voffs=0
      expr "$flags" :nelem 'A%([0-9]%{1,}%)' && {
         voffs='sizeof('"$name"')'
         [ "$name" == 0 ] && voffs=$bytelen
      }
      expr "$flags" :nelem 'S%([0-9]%{1,}%)' && {
         expr "$name" :idname '^%(.*[^.]%)%.[^.]%{1,}$'
         voffs='sizeof('"$idname"')'
         [ "$name" == 0 ] && voffs=$bytelen
      }
      pad=0
      expr "$flags" :pad 'p%([0-9]%{1,}%)' || {
         let 'pad=bytelen*nelem'
      }
      buf='"'
      while :
      do
         seek + 0 sk
         readl Z
         expr "$Z" :: '^@:.' || { seek $sk 0; break; }
         catv 2,,Z =0:,,buf
      done
      [ ${#buf} -le 1 ] && buf=0
      [ ${#buf} -gt 1 ] && buf="$buf%""
      conv '-t` ' dflt1 dflt2 name text
      [ "$darst" ==  1 ] && darst=/
      expr "$darst" :darst '%.%([0-9]%)'
      [ "$typ" == s -a "$dflt1" == '\000' ] && dflt1=
      [ "$dflt2" == '"' ] && dflt2="$dflt1"
      if [ "$typ" == s ]
      then
         let "pad>4" && let "pad>>=1"
         ptr=
         w1w2w3=
         min1='0'
         min2="$min1"
         max1="$min1"
         max2="$min1"
         expr "$flags" :: '#' && goend
         dflt1="%"$dflt1%""
         dflt2="%"$dflt2%""
      else
         ptr='&'
         w1=15 w2=15 w3=14
         [ "$min1" == '"' ] && min1=0
         [ "$max1" == '"' ] && max1=0
         [ "$min2" == '"' ] && min2="$min1"
         [ "$max2" == '"' ] && max2="$max1"
         [ "$typ" == s ] && goend
         l=4 u=u
         [ bytelen -eq 4 ] && l=8 u=ul
         for v in dflt1 dflt2 min1 min2 max1 max2
         do
            case "$typ" in
              b)  base -2 $v +16 $v; prints vssf0${l}s $v 0x ${{v} $u ;;
              x)  prints vssf0${l}s $v 0x ${{v} $u ;;
            esac
         done
      fi
      flg=000000
      #expr "$flags" :: ':SW:' && let "flg|=256"
      expr "$flags" :: '[sz]' && pad=0
      expr "$flags" :: 'l' && let "flg|=2048"
      expr "$flags" :: ':L:' && let "flg|=1024"
      expr "$flags" :: ':SP:' && let "flg|=512"
      expr "$flags" :: 'B[AS][0-9]' && let "flg|=256"
      expr "$flags" :: '1.' && let "flg|=128"
      expr "$flags" :: 'q' && let "flg|=64"
      expr "$flags" :: 'z' && let "flg|=32"
      expr "$flags" :: 'i' && let "flg|=16"
      expr "$flags" :: 's' && let "flg|=8"
      expr "$flags" :: 'n' && let "flg|=4"
      expr "$flags" :: 'a' && let "flg|=2"
      expr "$flags" :: 'r' && let "flg|=1"
      prints vssf04 flags 0x $((16#, flg))
      [ "$name" == 0 -o "$name" == '"' ] && name=0 ptr=
      prints vsf010 pid $_id
      echo
      prints s-28sbs %
             "#define D${pid}grp" $pgrp, $pdummy
      echo "// id; adr, len, flags(infovals|lang|spv|batt | step10|mess|zuo|initcan|sig|nod|abgl|ro), dummy; typ, darst, nelem, voffs;"
      prints s-28s11bs6bs5bsbsbsbsbsbs %
             "#define D${pid}obj" %
              $_id, $adr, $bytelen, $flags, $dummy, %
              "'$typ'," "'$darst'," "$nelem," "$voffs"
      if [ "$typ" == s ]
      then
         prints s "       const BYTE __far S${pid}[]= $dflt1;"
         ds=S${pid} dflt1=0 min1=0 max1=0 dflt2=0 min2=0 max2=0
      else
         ds=0
      fi
      prints s-28s11 %
             "#define D${pid}str" "$ds"
      prints s-28s${w1}bs${w2}bs${w3} %
             "#define D${pid}dfmima0" "$dflt1," "$min1," "$max1"
      prints s-28s${w1}bs${w2}bs${w3} %
             "#define D${pid}dfmima1" "$dflt2," "$min2," "$max2"
      prints s-28sbs %
             "#define D${pid}szname" "sizeof($name)," "$ptr$name"
      if [ "$einheit" != '"' ]
      then
         prints s "       const BYTE __far E${pid}[]= %"$einheit%";"
         einheit=E${pid}
      else
         einheit=0
      fi
      prints s "       const BYTE __far T${pid}[]= %"$text%";"
      text=T${pid}
      prints s-28s11sbs11 %
             "#define D${pid}einhtxt" "$einheit" , "$text"
      if [ "$buf" != 0 ]
      then
         prints s "       const BYTE __far I${pid}[]= $buf;"
         buf=I${pid}
      else
         buf=0
      fi
      prints s-28s11 %
             "#define D${pid}info" "$buf"
      let "adr+=bytelen*nelem+pad"
      prints su4sbsbsbsbsbsbsbss '   { ' %
             D${pid}grp, D${pid}obj, D${pid}str, %
           "{{D${pid}dfmima0}," "{D${pid}dfmima1}}," %
             D${pid}szname, D${pid}einhtxt, D${pid}info ' },'
      continue
   }
done
print -u4 '   { 0 }%n};%n%nconst unsigned CFGdata_ne= sizeof(CFGdata)/sizeof(*CFGdata);%n%n'
><<<<
cat d1 d2 d3 > cfgdata.c
remove d1 d2 d3

exit 0

#     prints s-33s${w1}bs${w2}bs${w3} %
#            "#define D${pid}dfltminmax10" "$dfltbm," "$minbm," "$maxbm"
#     prints s-33s${w1}bs${w2}bs${w3} %
#            "#define D${pid}dfltminmax11" "$dfltbm2," "$minbm2," "$maxbm2"
#            D${pid}dfltminmax10, "D${pid}dfltminmax11}," %



###  cfg2.bsh  #############################################

#!/u/bin/bsh


INCL='
#                include "def.h"
#                include "var.h"
#                include "texte.h"


'
HDR='
// id: 0.0.000.00000
//       d grp object

   // struct cfgdataT_t { cfap_t Tinfo, Tgrp, Tsgrp, Tbit, Text; };
   //
   // struct cfgdata_t { const BYTE *grp, *sgrp;
   //                    UNS4 id;
   //                    UNS2 adr, len, nbit, bitpos, flags;
   //                    BYTE typ, darst, info1, info2;
   //                    UNS2 parbn, nelem, voffs;
   //                    const BYTE FAR *dfstr;
   //                    UNS4 dfmima[2][3];
   //                    UNS2 szname;
   //                    VOL void *name;
   //                    const BYTE FAR *einheit, *text, *info;
   //                    const struct cfgdataT_t FAR *T;
   // };



'
i=000000
set Z:.200
set Ta:.100
set Tb:.100

CFG2()  {
   i=-1
   3>$1data0.c
   4>$1dataT.c
   catv HDR =3
   catv INCL HDR =4
   < $1data.c
   while readl Z
   do
      expr "$Z" :: '^#define D%D%{10}grp ' && {
         let ++i; catv /%n =4; catv Z /%n =3; continue
      }
      expr "$Z" :Ta ' %(const BYTE FAR E[0-9]%{10}%[]%)= ' && {
         expr "$Z" :Tb '%[]= %(".%{1,}%);$' || echo $i:$Ta
         catv '.   extern ' Ta '.;  //' Tb /%n =3
         catv Z /%n =4
         continue
      }
      expr "$Z" :Ta ' %(const BYTE FAR T[0-9]%{10}%[]%)= ' && {
         expr "$Z" :Tb '%[]= %(".%{1,}%);$' || echo $i:$Ta
         catv '.   extern ' Ta '.;  //' Tb /%n =3
         catv Z /%n =4
         continue
      }
      expr "$Z" :Ta ' %(const BYTE FAR I[0-9]%{10}%[]%)= ' && {
         expr "$Z" :Tb '%[]= %(".%{1,}%);$' || echo $i:$Ta
         catv '.   extern ' Ta '.;  //' Tb /%n =3
         catv Z /%n =4
         continue
      }
      expr "$Z" :Ta '^%(#define D%D%{10}Text %{1,}%)' && {
         catv Ta "/&$2dataT[$i]%n" =3
         catv Z /%n =4
         continue
      }
      expr "$Z" :: 'const struct cfgdata_t FAR '"$2"'data%[]= {' && {
         catv '/%n%n%nconst struct cfgdataT_t FAR '"$2"'dataT[]= {%n' =4
      }
      expr "$Z" :Ta '^ %{1,}{ D.%{1,}%( D%D%{10}Text %)' && {
         catv '/   {' Ta '/},%n' =4
      }
      catv Z /%n =3
   done
   catv '/   { 0 }%n};%n%n%n%n' =4
   ><<<
   echo $i
   return 0
}


CFG2 cfg CFG
CFG2 mes MES





###  cfgadr.bsh  #############################################



adr=110000

for n from 0 to 24 repeat
do
   echo $((adr)); let "adr+=78+202"
   echo $((adr)); let "adr+=36+114"
   echo $((adr)); let "adr+=56+164"
   echo $((adr)); let "adr+=192+64"
done




###  cfgbase.bsh  #############################################

#!/u/bin/bsh

if [ "$(-ver s)" == unix ]
then  MORE='gvim -fnR -' #'less -M'
      LESSCHARSET=iso8859; export LESSCHARSET
else  MORE='more' #ultraedit32
fi

set CfgB:.50 MesB:.50 cmd:.10 rest:.30
set Z:.200 File:.50
Base=k

if [ -s base/cfgbase.txt ]
then  CfgB=./base/cfgbase.txt
elif [ -s cfgbase.txt ]
then  CfgB=./cfgbase.txt
else  CfgB='???'
fi
if [ -s base/mesbase.txt ]
then  MesB=./base/mesbase.txt
elif [ -s mesbase.txt ]
then  MesB=./mesbase.txt
else  MesB='???'
fi

File="$CfgB"


Check() {
   catv '/noch nicht implementiert%j'
   return 0
}


IDCheck() {
   local id:010 id0:010 z0:.200 fst=0
   grep -n '^[@x]%D%{8,10} ' |
   sortl -f2 -d':@x ' | {
      while readl Z
      do
         expr "$Z" :id '%(%D%{8,}%)'
         if [ id -eq id0 ]
         then  [ fst -eq 0 ] && { fst=1; catv 140,z0 /%j; }
               catv 140,Z /%j
         else  fst=0
         fi
         id0=$id z0="$Z"
      done
   }
   return 0
}


Print() {
   catv '/noch nicht implementiert%j'
   return 0
}


while echo "
%tKonfigbasis  :  K datei  [$CfgB]
%tMessbasis    :  M datei  [$MesB]
%tBasis    [$Base] :  k|m
%tKorrektheit  :  c
%tID PrŘfung   :  i
%tAusgabe      :  a
%tBeenden      :  E
%t                _%b%c"
do
   read cmd rest
   case "$cmd" in
     K)  [ -s "$rest" ] || { echo "%a%c"; continue; }
         CfgB="$rest";;
     M)  [ -s "$rest" ] || { echo "%a%c"; continue; }
         MesB="$rest";;
     k)  Base=k File="$CfgB";;
     m)  Base=m File="$MesB";;
     c)  Check <"$File" | $MORE;;
     i)  IDCheck <"$File" | $MORE;;
     a)  Print <"$File" | $MORE;;
     E)  break;;
     *)  echo "%a%c"; continue;;
   esac
done

:




###  ch2t.bsh  #############################################



FILES=$*

set Z:.500
set Text:.100
set CText:.100
set Leer:.100
set FILE:.100
set HexC:010
R=000000000
G=000000000
B=000000000

PutText()  {
   expr "$Text" :Text '&quot;' += '"'
   expr "$Text" :Text '&lt;' += '<'
   expr "$Text" :Text '&gt;' += '>'
   expr "$Text" :Text '&amp;' += '&'
   expr "$Text" :Text ' ' += 'Ű'
   expr "$Text" :Text '\' += '\textbackslash '
   expr "$Text" :Text '''' += '\textquoteright '
   expr "$Text" :Text '`' += '\textquoteleft '
   expr "$Text" :Text '"' += '\textquotedblright '
   expr "$Text" :Text '%^' += '\textasciicircum '
   expr "$Text" :Text '~' += '\textasciitilde '
   expr "$Text" :Text '&' += '\&'
   expr "$Text" :Text '#' += '\#'
   expr "$Text" :Text '%$' += '\$'
   expr "$Text" :Text '%%' += '\%'
   expr "$Text" :Text '_' += '\_'
   expr "$Text" :Text '{' += '\{'
   expr "$Text" :Text '}' += '\}'
   while expr "$Text" :Leer '%(Ű%{1,}%)'
   do
      expr "$Leer" :Leer 'Ű' += ' '
      expr "$Text" :Text 'Ű%{1,}' = "\verb:$Leer:"
   done
   ifset Text || return 1
   catv Text
   return 0
}


PutCText()  {
   while ifset CText
   do
      expr "$CText" :Text '^%( %{1,}%)' && {
         PutText
         expr "$CText" :CText '^ %{1,}' = ''
      }
      expr "$CText" :Text '^%([^ ]%{1,}%)' && {
         catv ".\textcolor[rgb]{$R,$G,$B}{"
         PutText
         catv '/}'
         expr "$CText" :CText '^[^ ]%{1,}' = ''
      }
   done
   return 0
}


MkRgb()  {
   expr "$HexC" :R '^%(..%)....'
   expr "$HexC" :G '^..%(..%)..'
   expr "$HexC" :B '^....%(..%)'
   let "R=16#$R" "G=16#$G" "B=16#$B"
   let "R=(R*1000+127)/255" "G=(G*1000+127)/255" "B=(B*1000+127)/255"
   [ ${#R} -eq 1 ] && R=0.00$R
   [ ${#R} -eq 2 ] && R=0.0$R
   [ ${#R} -eq 3 ] && R=0.$R
   [ ${#R} -eq 4 ] && R=1.000
   [ ${#G} -eq 1 ] && G=0.00$G
   [ ${#G} -eq 2 ] && G=0.0$G
   [ ${#G} -eq 3 ] && G=0.$G
   [ ${#G} -eq 4 ] && G=1.000
   [ ${#B} -eq 1 ] && B=0.00$B
   [ ${#B} -eq 2 ] && B=0.0$B
   [ ${#B} -eq 3 ] && B=0.$B
   [ ${#B} -eq 4 ] && B=1.000
   return 0
}


RApre='%([^<]%{1,}%)'
RAfcc='<font color="#%(......%)">'
RAfcb='<font color="#......"><b>%([^<]%{1,}%)</b></font>'
RAfcn='<font color="#......">%([^<]%{1,}%)</font>'


for FILE in $FILES
do
   < $FILE
   while readl Z
   do  expr "$Z" :: '<pre>' && break; done
   catv '/\begin{ttfamily}%n'
   while readl Z
   do
      expr "$Z" :: '</pre>' && break
      catv "/\verb:   :"
      ifset Z || { catv /\\%n; continue; }
      while ifset Z
      do
         expr "$Z" :Text "^$RApre" && {
            PutText
            expr "$Z" :Z "^$RApre" = ''
            ifset Z || { catv /\\%n; continue 2; }
         }
         expr "$Z" :HexC "^$RAfcc" && {
            MkRgb
            expr "$Z" :CText "^$RAfcb" && {
               PutCText
               expr "$Z" :Z "^$RAfcb" = ''
               ifset Z || { catv /\\%n; continue 2; }
               continue
            }
            expr "$Z" :CText "^$RAfcn" && {
               PutCText
               expr "$Z" :Z "^$RAfcn" = ''
               ifset Z || { catv /\\%n; continue 2; }
               continue
            }
         }
         ><; print -u2 "*** $FILE ***"; exit 1
      done
   done
   ><
   catv '/\end{ttfamily}%n'
done

exit 0





###  chars.bsh  #############################################



array C NUL SOH STX ETX EOT ENQ ACK BEL BS HTAB LF VTAB FF CR SO SI %
        DLE XON DC2 XOFF DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
anz=256
col=4
start=0
[ $# -eq 1 ] && col=$1
[ $# -eq 2 ] && col=$1 anz=$2
[ $# -eq 3 ] && col=$1 anz=$2 start=$3
let row=anz/col
c=000 r=000 i=000

for r from 0 to $((row-1)) repeat
do
   for c from 0 to $((col-1)) repeat
   do
      z=$((c*row+r+start))
      i=$((z+1))
      [ z -lt 32 ] && Z="$C[i]"
      [ z -ge 32 ] && Z="\symbol{$z}"
      [ c -gt 0 ] && print -n ' & '
      prints sf@3bsf08- $z $((2#,z))
      #prints s3bsf08bsf03bsf02bs- $z $((2#,z)) $((8#,z)) $((16#,z)) $Z
      #prints sf@3bsf03bsf02bs- $z $((8#,z)) $((16#,z)) "\ $Z"
   done
   echo ' \\'
done




###  chpr.bsh  #############################################

# !/u/bin/bsh
# Print_xyz auf Print_lcd umbauen



set -f
File="\softune\sample\gfs_594\$1"
[ $# -lt 1 -o ! -s "$File" ] && { print -u2 "? $File ?"; exit; }

Zeile="$(prints s256-)"
Arg1="$(prints s25-)"
Arg2="$(prints s25-)"
Arg3="$(prints s25-)"
Arg4="$(prints s25-)"
ArgTyp=00000000
NArg=00000000
PfName=00000000
ZN=00000000



Args()  {
   local i=0 t=0 a
   expr "$1" :a 'Print[a-zA-Z_0-9]%{1,%}(%(..*%));'
   expr "$a" :: '^[ %t]*[^, %t]%{1,%}[ %t]%{1,%}[^, %t]' && return 1
   expr "$1" :PfName 'Print%([a-zA-Z_0-9]%{1,%}%)(..*);'
   ArgTyp=''
   while let "++i<=4"
   do
      t=0
      #echo "--$a--"
      while :
      do  t=1 expr "$a" :Arg$i '^[ %t]*%(".*[^\]"%)' &&
                 expr "$a" :a '^[ %t]*".*[^\]"%(.*%)$' && break
          t=2 expr "$a" :Arg$i '^[ %t]*%(""%)' &&
                 expr "$a" :a '^[ %t]*""%(.*%)$' && break
          t=3 expr "$a" :Arg$i '^[ %t]*%(''.''%)' &&
                 expr "$a" :a '^[ %t]*''.''%(.*%)$' && break
          t=4 expr "$a" :Arg$i '^[ %t]*%(''\.''%)' &&
                 expr "$a" :a '^[ %t]*''\.''%(.*%)$' && break
          t=5 expr "$a" :Arg$i '^[ %t]*%([0-9][0-9a-zA-Z]*%)' &&
                 expr "$a" :a '^[ %t]*[0-9][0-9a-zA-Z]*%(.*%)$' && break
          t=6 expr "$a" :Arg$i '^[ %t]*%([^, %t]*%)' &&
                 expr "$a" :a '^[ %t]*[^, %t]*%(.*%)$' && break
          print -u2 "Kein ArgTyp![$File:$ZN]" && exit
          break
      done
      catv t =$i,1,ArgTyp
      NArg=$i
      ifset a || break
      expr "$a" :a '^[ %t]*,%(.*%)$'
      expr "$a" :a '^[ %t]*%(.*%)$'
      ifset a || break
   done
   return 0
}



Skip()  {
   local skip=0 pr
   while ifset pr && print -r "$Zeile"
         pr=1 readl Zeile
   do
      let ++ZN
      ifset Zeile || continue
      [ $skip == 2 ] && expr "$Zeile" :: '^#endif' && { skip=0; continue; }
      [ $skip == 1 ] && expr "$Zeile" :: '%*/[ %t]*$' && { skip=0; continue; }
      [ $skip != 0 ] && continue
      expr "$Zeile" :: 'defined(OLDPRN)' && { skip=2; continue; }
      expr "$Zeile" :: '^[ %t]*//' && continue
      expr "$Zeile" :: '^[ %t]*/%*' && {
         expr "$Zeile" :: '%*/[ %t]*$' && continue
         skip=1
         continue
      }
      expr "$Zeile" :: 'Print[a-zA-Z_0-9]%{1,%}(' || continue
      expr "$Zeile" :: 'Print[a-zA-Z_0-9]%{1,%}(..*);' ||
         print -u2 "Mehrzeiler![$File:$ZN]" && continue
      Args "$Zeile" || continue
      pr=
      PrNewFu
      #PrA
   done
   let skip && print -u2 "Offenes Ende: $skip[$File:$ZN]"
   return 0
}



PrNewFu()  {
   local at=-------- na=0 fmt
   #print -rn "Print$PfName"
   case "Print$PfName" in
     Printf)        na=4 fmt='%?K%.16s' at=-kksu ;;
     Print2num)     na=3 fmt='%?K%.2u%?K' at=-kku ;;
     Printnum)      na=1 fmt='%3u' at=-u ;;
     Printnr)       na=1 fmt='%u' at=-u ;;
     Printword)     na=1 fmt='%5u' at=-u ;;
     Printfloat)    na=1 fmt='%,4.1u' at=-u ;;
     Printfloat2)   na=1 fmt='%,4.2u' at=-u ;;
     Printfloat3)   na=1 fmt='%,5.1u' at=-u ;;
     Print_Ch)      na=3 fmt='%?K%c' at=-kkc ;;
     Print_Str)     na=3 fmt='%?K%-16.16s' at=-kks ;;
     Print_Strc)    na=3 fmt='%?K%-16.16s' at=-kks ;;
     Print_Str_l)   na=3 fmt='%?K%.16s' at=-kks ;;
     Print_Wert)    na=3 fmt='%?K%3u' at=-kku ;;
     Print_W)       na=3 fmt='%?K%5u' at=-kku ;;
     Print_Bit8)    na=3 fmt='%?K%08b' at=-kku ;;
     Print_Bit16)   na=3 fmt='%?K%016b' at=-kku ;;
     Print_Hex)     na=3 fmt='%?K%#.4x' at=-kkx ;;
     Print_F)       na=3 fmt='%?K%,4.1u' at=-kku ;;
     Print_F2)      na=3 fmt='%?K%,4.2u' at=-kku ;;
     Print_F3)      na=3 fmt='%?K%,5.1u' at=-kku ;;
     PrintDate)     na=4 fmt='%?s %02u.%02u.%04u' at=-suuu ;;
     PrintDatum)    na=3 fmt='%02u.%02u.%04u' at=-uuu ;;
     PrintTime)     na=3 fmt='%02u:%02u:%02u' at=-uuu ;;
     PrintTime_os)  na=2 fmt='%02u:%02u' at=-uu ;;
     *)  print -u2 "? $PfName() ?" && exit ;;
   esac
   [ na -ne NArg ] && print -u2 "nArg: $NArg!=$na(soll)" && exit
   expr "$fmt" :: '^%%?K' && {
      :
   }
   local i=0
   while let "++i, --n>=0"
   do
      echo "%t${Arg[i]}"
   done
   return 0
}



PrA()  {
   local n=$NArg i=0
   echo "Print$PfName"
   while let "++i, --n>=0"
   do
      echo "%t${Arg[i]}"
   done
}



Skip < "$File"



#


###  chprint.bsh  #############################################

#!c:\u\bin\bsh32.exe


an=00000000000
ifs=_______________
Dir="$(prints s120-)"
F="$(prints s80-)"
liste="$(prints s150-)"
vorne="$(prints s80-)"
funam="$(prints s250-)"
reste="$(prints s80-)"
a1="$(prints s60-)"
a2="$(prints s60-)"
a3="$(prints s60-)"
a4="$(prints s60-)"
rest="$(prints s60-)"
Zeile="$(prints s300-)"
zeile="$(prints s300-)"


[ $# -lt 1 ] && Dir=.
[ $# -ge 1 ] && Dir="$1"
[ "$Dir" == . ] && Dir=$(pwd)
#expr "$Dir" =:: '[/\]lst$' || Dir="$Dir\lst"
conv -F/F\ Dir
[ -d "$Dir" ] || { echo "Keine Existenz: '$Dir'!"; exit 1; }
cd "$Dir"
echo Verzeichnis: $Dir
: *.c
[ $] -lt 1 ] && { echo "Keine *.c vorhanden!"; exit 1; }



local fmt=lu________________
funam=Print_Lan
read "funam?Funktionsname oder all: "
ifset funam || exit 0
[ "$funam" == all ] && funam="
        Print_Str Print_Wert Print_Ch Print_W Print_F Print_F_pm Print_F2 Print2num
        Printnum Printnum2 Printnr Printword Printfloat Printfloat_pm Printfloat2
        Print_Lan Convert_w_s Convert_w_ganz_s Convert_w_ganz3_s Convert_b_s"


Args()  {
   ifs="$IFS" IFS=, restan=0
   [ $1 -eq 1 ] && print -r "$liste" | read a1 rest
   [ $1 -eq 2 ] && print -r "$liste" | read a1 a2 rest
   [ $1 -eq 3 ] && print -r "$liste" | read a1 a2 a3 rest
   [ $1 -eq 4 ] && print -r "$liste" | read a1 a2 a3 a4 rest
   IFS="$ifs"
   ifset rest && return 1
   ifset a$1 || return 1
   expr "$a1" :a1 '^ *%([0-9]%{1,%}%) *$'  '%1' && let ++an
   expr "$a2" :a2 '^ *%([0-9]%{1,%}%) *$'  '%1' && let ++an
   return 0
}


for funam in  $funam
do
   echo "$funam"

for F in *.c
do
   grep -qm "$funam" "$F" || continue
   grep -qm "//.*$funam.*//F/" "$F" && continue
   echo "%t$F"
   #[ -f "obj\CHP$F" ] || cat "$F" > "obj\CHP$F"
   cat "$F" | {
   : > "$F"
   while readl Zeile zeile
   do
      while :
      do
         expr "$Zeile" :: '^[ %t]*/[*/]' && break
         expr "$Zeile" :: '[^a-zA-Z_0-9]'"$funam"'([^;]%{1,%});' || break
         expr "$Zeile" :vorne '^%(.*[^a-zA-Z_0-9]%)'"$funam(" || break
         expr "$Zeile" :Zeile '^.*[^a-zA-Z_0-9]%('"$funam"'(.*%)$'  '%1'
         expr "$Zeile" :liste "^$funam("'%(..*%)$'
         expr "$liste" :reste '^[^;]%{1,%}%();.*%)$'
         expr "$liste" :liste '^%([^;]%{1,%}%));.*$'
         expr "$liste" :liste '^  *' ''
         expr "$liste" :liste '  *$' ''
         case "$funam" in
           Print_Lan)
               Args 3 || break
               if [ an -eq 2 ]
               then
                  Zeile="${vorne}Print_lcd(%"%%$a1.${a2}K%%Fs%", MSG($a3)$reste"
               else
                  Zeile="${vorne}Print_lcd(%"%%K%%Fs%", $a1,$a2, MSG($a3)$reste"
               fi
               print -r "//$zeile//F/" >> "$F"
           ;;
           Print_Str|Print_Wert|Print_Ch|Print_W|Print_F|Print_F_pm|Print_F2|Print2num)
               case "$funam" in
                   Print_Str)   fmt=s ;;
                   Print_Wert)  fmt=3u ;;
                   Print_Ch)    fmt=c ;;
                   Print_W)     fmt=5u ;;
                   Print_F)     fmt=,4.1u ;;
                   Print_F2)    fmt=,4.2u ;;
                   Print_F_pm)  fmt=,4.1i ;;
                   Print2num)   fmt=2u ;;
               esac
               Args 3 || break
               if [ an -eq 2 ]
               then
                  Zeile="${vorne}Print_lcd(%"%%$a1.${a2}K%%$fmt%", $a3$reste"
               else
                  Zeile="${vorne}Print_lcd(%"%%K%%$fmt%", $a1,$a2, $a3$reste"
               fi
               print -r "//$zeile//F/" >> "$F"
           ;;
           Printnum|Printnum2|Printnr|Printword|Printfloat|Printfloat_pm|Printfloat2)
               case "$funam" in
                   Printnum)       fmt=3u ;;
                   Printnum2)      fmt=02u ;;
                   Printnr)        fmt=u ;;
                   Printword)      fmt=5u ;;
                   Printfloat)     fmt=,4.1u ;;
                   Printfloat2)    fmt=,4.2u ;;
                   Printfloat_pm)  fmt=,4.1i ;;
               esac
               Args 1 || break
               Zeile="${vorne}Print_lcd(%"%%$fmt%", $a1$reste"
               print -r "//$zeile//F/" >> "$F"
           ;;
           Convert_w_s|Convert_w_ganz_s|Convert_w_ganz3_s|Convert_b_s)
               case "$funam" in
                   Convert_w_s)        fmt=,6.1i ;;
                   Convert_w_ganz_s)   fmt=5i ;;
                   Convert_w_ganz3_s)  fmt=3u ;;
                   Convert_b_s)        fmt=02u ;;
               esac
               Args 2 || break
               Zeile="${vorne}sprintf_F($a2, %"%%$fmt%", $a1$reste"
               print -r "//$zeile//F/" >> "$F"
           ;;
           *)  print -ru2 "Unbekannt: '$funam'"; exit 0 ;;
         esac
         break
      done
      print -r "$Zeile" >> "$F"
   done
   }
done

done


read "-?bsh:$0: <Enter> "





###  chtm2tex.bsh  #############################################

#!/u/bin/bsh


[ $# -eq 0 ] && exit 0
SW=0
[ "$1" == -sw ] && SW=1 shift
DIR=.
[ $# -gt 1 ] && DIR="$1" shift
FILES="$*"

set Z:.1000
set Text:.100
set Leer:.100
set FILE:.100
set OFILE:.100
set HexC:010
R=000000000
G=000000000
B=000000000


PutText()  {
   local l:20.1 kl:21.1 kr:22.1
   expr "$Text" :Text '&quot;' += '"'
   expr "$Text" :Text '&lt;' += '<'
   expr "$Text" :Text '&gt;' += '>'
   expr "$Text" :Text '&amp;' += '&'
   expr "$Text" :Text ' ' += "$l"
   expr "$Text" :Text '{' += "$kl"
   expr "$Text" :Text '}' += "$kr"
  #expr "$Text" :Text '\' += '\textbackslash '
  #expr "$Text" :Text '''' += '\textquoteright '
  #expr "$Text" :Text '`' += '\textquoteleft '
  #expr "$Text" :Text '"' += '\textquotedblright '
  #expr "$Text" :Text '%^' += '\textasciicircum '
  #expr "$Text" :Text '~' += '\textasciitilde '
   expr "$Text" :Text '\' += '\symbol{92}'
   expr "$Text" :Text '''' += '\symbol{39}'
   expr "$Text" :Text '`' += '\symbol{96}'
   expr "$Text" :Text '"' += '\symbol{34}'
   expr "$Text" :Text '%^' += '\symbol{94}'
   expr "$Text" :Text '~' += '\symbol{126}'
  #expr "$Text" :Text '<' += '\textless '
  #expr "$Text" :Text '>' += '\textgreater '
   expr "$Text" :Text '&' += '\&'
   expr "$Text" :Text '#' += '\#'
   expr "$Text" :Text '%$' += '\$'
   expr "$Text" :Text '%%' += '\%'
   expr "$Text" :Text '_' += '\_'
   expr "$Text" :Text '<' += '\symbol{60}'
   expr "$Text" :Text '>' += '\symbol{62}'
   expr "$Text" :Text '-' += '\symbol{45}'
   expr "$Text" :Text '%[' += '\symbol{91}'
   expr "$Text" :Text ']' += '\symbol{93}'
   expr "$Text" :Text ',' += '\symbol{44}'
   #expr "$Text" :Text '%('"$l"'%{1,}%)' + '\verb:%1:'
   expr "$Text" :Text "$kl" += '\{'
   expr "$Text" :Text "$kr" += '\}'
   expr "$Text" :Text "$l" += '\ '
   ifset Text || return 1
   catv Text
   return 0
}


MkRgb()  {
   expr "$HexC" :R '^%(..%)....'
   expr "$HexC" :G '^..%(..%)..'
   expr "$HexC" :B '^....%(..%)'
   let "R=16#$R" "G=16#$G" "B=16#$B"
   let "R=(R*1000+127)/255" %
       "G=(G*1000+127)/255" %
       "B=(B*1000+127)/255"
   [ ${#R} -eq 1 ] && R=0.00$R
   [ ${#R} -eq 2 ] && R=0.0$R
   [ ${#R} -eq 3 ] && R=0.$R
   [ ${#R} -eq 4 ] && R=1.000
   [ ${#G} -eq 1 ] && G=0.00$G
   [ ${#G} -eq 2 ] && G=0.0$G
   [ ${#G} -eq 3 ] && G=0.$G
   [ ${#G} -eq 4 ] && G=1.000
   [ ${#B} -eq 1 ] && B=0.00$B
   [ ${#B} -eq 2 ] && B=0.0$B
   [ ${#B} -eq 3 ] && B=0.$B
   [ ${#B} -eq 4 ] && B=1.000
   [ "$HexC" == 000000 ] && return 1
   return 0
}


RAlez='%( %{1,}%)'
#RAtxt='%([^< ]%{1,}%)'
RAtxt='%([^<]%{1,}%)'
RAfcc='<font color="#%(......%)">'
RAbgc='<span style="background-color: #%(......%)">'
KZ='[%/*#(;"]%{1,2}'
Vim='&quot;&quot;'


Leerz()  {
   local k:.10 rek=$1
   shift
   expr "$rek" :k '[BFb]' += '}' || k=
   catv k /\verb: Text /:
   while ifset rek
   do
      catv 1,rek =k:
      expr "$rek" :rek '^.%(.*%)$'
      case "$k" in
        B)  catv ".\colorbox[rgb]{$1,$2,$3}{"; shift 3 ;;
        F)  catv ".\textcolor[rgb]{$1,$2,$3}{"; shift 3 ;;
        b)  catv '.\textbf{' ;;
      esac
   done
   return 0
}

Zeile()  {
   local a=. k=. rek=$1 sw=R
   [ SW -eq 1 ] && sw=r
   shift
   while :
   do
      ifset Z || return 0
      expr "$rek" :k '%(.%)$' || k=.
      case "$k" in
        B)  expr "$Z" :Z '^</span>' = '' && k=$sw ;;
        F)  expr "$Z" :Z '^</font>' = '' && k=$sw ;;
        f)  expr "$Z" :Z '^</font>' = '' && k=r ;;
        b)  expr "$Z" :Z '^</b>'    = '' && k=R ;;
      esac
      [ "$k" == r ] && { return 0; }
      [ "$k" == R ] && { catv '.}'; return 0; }
      #expr "$Z" :Text "^$RAlez" && {
      #   Leerz $rek $*
      #   expr "$Z" :Z "^$RAlez" = ''
      #}
      expr "$Z" :Text "^$RAtxt" && {
         PutText
         expr "$Z" :Z "^$RAtxt" = ''
      }
      expr "$Z" :HexC "^$RAbgc" && {
         expr "$Z" :Z "^$RAbgc" = ''
         [ SW -eq 0 ] && { MkRgb; catv ".\colorbox[rgb]{$R,$G,$B}{"; }
         Zeile ${rek}B $* $R $G $B
      }
      expr "$Z" :HexC "^$RAfcc" && {
         expr "$Z" :Z "^$RAfcc" = ''; a=f
         [ SW -eq 0 ] && MkRgb && a=F catv ".\textcolor[rgb]{$R,$G,$B}{"
         Zeile ${rek}$a $* $R $G $B
      }
      expr "$Z" :: "^<b>" && {
         expr "$Z" :Z "^<b>" = ''
         catv ".\textbf{"
         Zeile ${rek}b $*
      }
   done
   return 0
}


for FILE in $FILES
do
   < $FILE
   while :
   do
      OFILE=
      while readl Z
      do  expr "$Z" :OFILE "$KZ"'@+%(%W%{4,}%)@'"$KZ" &|
          expr "$Z" :OFILE "$Vim"'@+%(%W%{4,}%)@'"$Vim" && break
      done
      ifset OFILE || break
      print -u2 "%t$DIR/$OFILE.ctex"
      > $DIR/$OFILE.ctex
      catv '/\begin{flushleft}%n\begin{ttfamily}%n'
      while readl Z
      do
         expr "$Z" :: "$KZ@-$OFILE@$KZ" &|
         expr "$Z" :: "$Vim@-$OFILE@$Vim" && break
         catv '/\ \ \ '  #"/\verb:   :"
         Zeile
         catv /\\%n
      done
      catv '/\end{ttfamily}%n\end{flushleft}%n'
      ><
   done
   ><
done

exit 0





###  chtm2tex.bsh  #############################################

#!/u/bin/bsh


[ $# -eq 0 ] && exit 0
DIR=.
[ $# -gt 1 ] && DIR="$1" shift
FILES="$*"

set Z:.500
set Text:.100
set Leer:.100
set FILE:.100
set OFILE:.100
set HexC:010
R=000000000
G=000000000
B=000000000


PutText()  {
   local l:20.1
   expr "$Text" :Text '&quot;' += '"'
   expr "$Text" :Text '&lt;' += '<'
   expr "$Text" :Text '&gt;' += '>'
   expr "$Text" :Text '&amp;' += '&'
   expr "$Text" :Text ' ' += "$l"
   expr "$Text" :Text '\' += '\textbackslash '
   expr "$Text" :Text '''' += '\textquoteright '
   expr "$Text" :Text '`' += '\textquoteleft '
   expr "$Text" :Text '"' += '\textquotedblright '
   expr "$Text" :Text '%^' += '\textasciicircum '
   expr "$Text" :Text '~' += '\textasciitilde '
   #expr "$Text" :Text '<' += '\textless '
   #expr "$Text" :Text '>' += '\textgreater '
   expr "$Text" :Text '&' += '\&'
   expr "$Text" :Text '#' += '\#'
   expr "$Text" :Text '%$' += '\$'
   expr "$Text" :Text '%%' += '\%'
   expr "$Text" :Text '_' += '\_'
   expr "$Text" :Text '{' += '\{'
   expr "$Text" :Text '}' += '\}'
   #expr "$Text" :Text '%('"$l"'%{1,}%)' + '\verb:%1:'
   expr "$Text" :Text "$l" += '\ '
   ifset Text || return 1
   catv Text
   return 0
}


MkRgb()  {
   expr "$HexC" :R '^%(..%)....'
   expr "$HexC" :G '^..%(..%)..'
   expr "$HexC" :B '^....%(..%)'
   let "R=16#$R" "G=16#$G" "B=16#$B"
   let "R=(R*1000+127)/255" %
       "G=(G*1000+127)/255" %
       "B=(B*1000+127)/255"
   [ ${#R} -eq 1 ] && R=0.00$R
   [ ${#R} -eq 2 ] && R=0.0$R
   [ ${#R} -eq 3 ] && R=0.$R
   [ ${#R} -eq 4 ] && R=1.000
   [ ${#G} -eq 1 ] && G=0.00$G
   [ ${#G} -eq 2 ] && G=0.0$G
   [ ${#G} -eq 3 ] && G=0.$G
   [ ${#G} -eq 4 ] && G=1.000
   [ ${#B} -eq 1 ] && B=0.00$B
   [ ${#B} -eq 2 ] && B=0.0$B
   [ ${#B} -eq 3 ] && B=0.$B
   [ ${#B} -eq 4 ] && B=1.000
   [ "$HexC" == 000000 ] && return 1
   return 0
}


RAlez='%( %{1,}%)'
#RAtxt='%([^< ]%{1,}%)'
RAtxt='%([^<]%{1,}%)'
RAfcc='<font color="#%(......%)">'
RAbgc='<span style="background-color: #%(......%)">'
KZ='[%/*#(;"]%{2}'
Vim='&quot;&quot;'


Leerz()  {
   local k:.10 rek=$1
   shift
   expr "$rek" :k '[BFb]' += '}' || k=
   catv k /\verb: Text /:
   while ifset rek
   do
      catv 1,rek =k:
      expr "$rek" :rek '^.%(.*%)$'
      case "$k" in
        B)  catv ".\colorbox[rgb]{$1,$2,$3}{"; shift 3 ;;
        F)  catv ".\textcolor[rgb]{$1,$2,$3}{"; shift 3 ;;
        b)  catv '.\textbf{' ;;
      esac
   done
   return 0
}

Zeile()  {
   local a=. k=. rek=$1
   shift
   while :
   do
      ifset Z || return 0
      expr "$rek" :k '%(.%)$' || k=.
      case "$k" in
        B)  expr "$Z" :Z '^</span>' = '' && k=R ;;
        F)  expr "$Z" :Z '^</font>' = '' && k=R ;;
        f)  expr "$Z" :Z '^</font>' = '' && k=r ;;
        b)  expr "$Z" :Z '^</b>'    = '' && k=R ;;
      esac
      [ "$k" == r ] && { return 0; }
      [ "$k" == R ] && { catv '.}'; return 0; }
      #expr "$Z" :Text "^$RAlez" && {
      #   Leerz $rek $*
      #   expr "$Z" :Z "^$RAlez" = ''
      #}
      expr "$Z" :Text "^$RAtxt" && {
         PutText
         expr "$Z" :Z "^$RAtxt" = ''
      }
      expr "$Z" :HexC "^$RAbgc" && {
         expr "$Z" :Z "^$RAbgc" = ''
         MkRgb
         catv ".\colorbox[rgb]{$R,$G,$B}{"
         Zeile ${rek}B $* $R $G $B
      }
      expr "$Z" :HexC "^$RAfcc" && {
         expr "$Z" :Z "^$RAfcc" = ''; a=f
         MkRgb && a=F catv ".\textcolor[rgb]{$R,$G,$B}{"
         Zeile ${rek}$a $* $R $G $B
      }
      expr "$Z" :: "^<b>" && {
         expr "$Z" :Z "^<b>" = ''
         catv ".\textbf{"
         Zeile ${rek}b $*
      }
   done
   return 0
}


for FILE in $FILES
do
   < $FILE
   while :
   do
      OFILE=
      while readl Z
      do  expr "$Z" :OFILE "$KZ"'@+%(%W%{4,}%)@'"$KZ" &|
          expr "$Z" :OFILE "$Vim"'@+%(%W%{4,}%)@'"$Vim" && break
      done
      ifset OFILE || break
      print -u2 "%t$DIR/$OFILE.ctex"
      > $DIR/$OFILE.ctex
      catv '/\begin{flushleft}%n\begin{ttfamily}%n'
      while readl Z
      do
         expr "$Z" :: "$KZ@-$OFILE@$KZ" &|
         expr "$Z" :: "$Vim@-$OFILE@$Vim" && break
         catv '/\ \ \ '  #"/\verb:   :"
         Zeile
         catv /\\%n
      done
      catv '/\end{ttfamily}%n\end{flushleft}%n'
      ><
   done
   ><
done

exit 0





###  ck128.bsh  #############################################

#!/u/bsh/a.out

#grep -Xn -e '[%d{128}-%d{255}-[ń÷Ř▀─Í▄]]' /u/bsh/man/?*.mn? /u/bsh/bsh.c /u/bsh/mod/*.[hc]
grep -Xn -e '[%d{128}-%d{255}-[ń÷Ř▀─Í▄]]' /u/bsh/bsh.c /u/bsh/mod/*.[hc]
:




###  cmp.bsh  #############################################



for b from 64 by -1 to 2 repeat
do
   echo "%n#define SINGLE$b(A,B,F)" ' (  \'
   a=-0001
   while let '++a<=--b'
   do
      echo "%tA[$a]==B[$a]&&" ' \'
      let 'a>=b' && break
      echo "%tA[$b]==B[$b]&&" ' \'
   done
   echo '%t%t%t)'
done




###  cnt.bsh  #############################################


set -f
cd /u/hp/2

for mode in add num dir del nowebhits webhits numnam
do
read "inp?$mode?[y]: "
[ "$inp" != y ] && continue
[ "$mode" == numnam ] && : > /u/hp/cnt_htm.lst
n=00000000
for file in %
        index.htm %
        de/index.htm %
        produkte.htm %
        recover.htm %
        de/190.htm %
        de/atxcool.htm %
        de/bshbeisp.htm %
        de/c.htm %
        de/cc.htm %
        de/cksum.htm %
        de/cmd.htm %
        de/fan.htm %
        de/hinw.htm %
        de/htm/ansi.htm %
        de/htm/bshmnk.htm %
        de/htm/istepbsh.htm %
        de/htm/rgb.htm %
        de/kurz.htm %
        de/lim/compilo.htm %
        de/lim/lim.htm %
        de/lizenz.htm %
        de/mailcode.htm %
        de/old/delsafe.htm %
        de/old/forum.htm %
        de/old/hpinfo.htm %
        de/old/olinfo.htm %
        de/old/pearl.htm %
        de/overclk.htm %
        de/pent.htm %
        de/sco.htm %
        de/syntax.htm %
        de/win.htm %
        bsh/chprint.htm %
        bsh/proto.htm %
        bsh/segm.htm %
        bsh/stack.htm %
        bsh/var.htm
do
   [ -s $file ] || continue
   let ++n
   echo $mode:$n: $file
   case $mode in
     add)
        grep -qm 'cgi/icnt.pl?' $file && continue
        cat $file | {
           > $file
           while readl zeile
           do
              print -r "$zeile"
              expr "$zeile" =:: '^[ %t]*<body ' || continue
              cat /u/hp/cnt_htm
           done
           ><
        }
     ;;
     num)
        cat $file | {
           > $file
           while readl zeile
           do
              expr "$zeile" :: 'cgi/icnt.pl?' ||
                 print -r "$zeile" && continue
              expr "$zeile" :zeile %
               '%(cgi/icnt.pl?[0-9]%{1,%}%.%)[1-9][0-9]*' %
               "%%1$n"
              print -r "$zeile"
           done
           ><
        }
     ;;
     dir)
        vors='            '
        cat $file | {
           > $file
           while readl zeile
           do
              expr "$zeile" :: 'cgi/icnt.pl?' ||
                 print -r "$zeile" && continue
              expr "$file" :: '^[^/]%{1,%}/[^/]%{1,%}$' && vors=../de/
              expr "$file" :: '^de/[^/]%{1,%}$' && vors=
              expr "$file" :: '^de/[^/]%{1,%}/[^/]%{1,%}$' && vors=../
              expr "$file" :: '/' || vors=de/
              expr "$zeile" :zeile %
               '"[^"]*%(cgi/icnt.pl?[0-9][^"]%{1,%}"%)' + "%"$vors%%1"
              print -r "$zeile"
           done
           ><
        }
     ;;
     del)
        z=0
        cat $file | {
           > $file
           while readl zeile
           do
              let z==0 && expr "$zeile" =:: '<table ..*130..*35' &&
                 z=1 && continue
              let z==1 && expr "$zeile" =:: '</table>' &&
                 z=2 && continue
              let z==1 && continue
              print -r "$zeile"
           done
           ><
        }
     ;;
     nowebhits)
        cat $file | {
           > $file
           while readl zeile
           do
              expr "$zeile" =:: %
              '<img ..*Count.cgi..*df=27273.dat[^<>]*>' ||
                 print -r "$zeile" && continue
              expr "$zeile" =:: %
              '<!--<img ..*Count.cgi..*df=27273.dat[^<>]*>-->' &&
                 print -r "$zeile" && continue
              expr "$zeile" =:zeile %
              '%(<img ..*Count.cgi..*df=27273.dat[^<>]*>%)'  '<!--%1-->'
              print -r "$zeile"
           done
           ><
        }
     ;;
     webhits)
        cat $file | {
           > $file
           while readl zeile
           do
              expr "$zeile" =:zeile %
              '<!--%(<img ..*Count.cgi..*df=27273.dat[^<>]*>%)-->'  '%1'
              print -r "$zeile"
           done
           ><
        }
     ;;
     numnam)
        print -r "$n: $file" >> /u/hp/cnt_htm.lst
     ;;
     *)  echo "*** $n: $file ***"; break 2 ;;
   esac
done
done





###  cnt2.bsh  #############################################




set -f

html='<HTML><HEAD><TITLE></TITLE>
<META HTTP-EQUIV="refresh" CONTENT="0; URL=~url~">
</HEAD><BODY TEXT="#000000" BGCOLOR="#CDAA7D">
<center><br><br><h1>Hui</h1></center></BODY></HTML>
'
echo cd de > /u/hp/ren
cd /u/hp/2/de
list -fR |
while readl Z
do
   expr "$Z" :nam '%([^/]*%.htm%)$' || continue
   expr "$Z" :dir '^%(.*/%)[^/]*$' || dir=
   catv 3,nam =pre:
   base -b pre +12 pre
   conv -'d ' pre
   pre="${pre}_"
   Zg="$(- grep -m 'icnt.pl?0%.[1-9][0-9]*' $dir$nam )" ||
      echo !grep $dir$nam
   expr "$Zg" :Zg 'icnt.pl?%(0%.[1-9][0-9]*%)'
   move $dir$nam $dir$pre$nam
   echo rename $dir$nam $dir$pre$nam >> /u/hp/ren
   url="cgi/get.pl?$Zg:../$dir$nam"
   ifset dir && url="../$url"
   expr "$html" :HTML '~url~' = "$url"
   [ ! -e "$dir$nam" ] && catv HTML > $dir$nam
done

echo cd / >> /u/hp/ren
cd /u/hp/2
list -f |
while readl Z
do
   expr "$Z" :nam '%([^/]*%.htm%)$' || continue
   expr "$Z" :dir '^%(.*/%)[^/]*$' || dir=
   catv 3,nam =pre:
   base -b pre +12 pre
   conv -'d ' pre
   pre="${pre}_"
   Zg="$(- grep -m 'icnt.pl?0%.[1-9][0-9]*' $dir$nam )" ||
      echo !grep $dir$nam
   expr "$Zg" :Zg 'icnt.pl?%(0%.[1-9][0-9]*%)'
   move $dir$nam $dir$pre$nam
   echo rename $dir$nam $dir$pre$nam >> /u/hp/ren
   url="de/cgi/get.pl?$Zg:../../$dir$nam"
   ifset dir && url="../$url"
   expr "$html" :HTML '~url~' = "$url"
   [ ! -e "$dir$nam" ] && catv HTML > $dir$nam
done





###  cnt3.bsh  #############################################




set -f

cd /u/hp/2
: > /u/hp/hlst
for F in `find . -type f -name '*.htm' -print`
do
   < /u/hp/rlst
   while readl Z
   do
      grep -qm -e '="[^"]*'$Z'"' $F && echo $F: $Z >> /u/hp/hlst
   done
   ><
done





###  cntcodes.bsh  #############################################

#!/u/bin/bsh

set Z:.100 N:010

grep -c '^%%l%%[a-z]' kap/*.tex | {
   while readl Z
   do
      catv Z /%n
      expr "$Z" :Z ':%(%D%{1,}%)$' || continue
      let "N+=Z"
   done
}

catv .::: N /%n




###  code.bsh  #############################################



Chapters()  {
   local z=0 c:.30
   CHAP=
   < "$1"
   while readl Z
   do
      case $z in
        0)  expr "$Z" :: '^\mainmatter' && z=1 ;;
        1)  expr "$Z" :: '^\backmatter' && break
            expr "$Z" :c '^\include{%([^}]%{1,}%)}' || continue
            expr "$c" :c '%([^/}]%{1,}%)$'
            catv c /%n =:,,CHAP:
         ;;
      esac
   done
   ><
   return 0
}


HTML()  {
   local z=0
   HTMLa=
   < "$1"
   while readl Z
   do
      expr "$Z" :Z '<title>[^<>]*</title>' = "$Title"
      expr "$Z" :: '^<body[ >]' && z=1
      catv Z /%n =:,,HTMLa:
      [ z -eq 1 ] && break
   done
   ><
   return 0
}


#html|text lang ifile chapter
Code()  {
   local z=0 t=0 kz=.. ch:.20
   [ $1 == text ] && z=2
   < $3
   while readl Z
   do
      case $z in
        0)  
            expr "$Z" :ch '%(..%)@+%('"$4"'_[a-z0-9]%{2}%)@%1' || continue
            z=1 t=1; catv 2,ch =kz:; catv 2,,ch =ch:
            catv "/<a name=%"${ch}T%"></a>%n" =3
            catv "/&nbsp;&nbsp;&nbsp;<a href=%"#$ch%">$ch.$2</a><br>%n" =3
            catv "/<br><br><a name=%"$ch%"></a><br>%n"
            catv "/<a href=%"#${ch}T%">$ch.$2</a>%n<ul>%n"
            catv '/<table bgcolor="#000000" width="80%" border="0" cellpadding="10"><tr><td bgcolor="#ffffff"><pre>%n'
         ;;
        1)
            expr "$Z" :: "$kz@-$ch@$kz" && {
               catv '/</pre></td></tr></table></ul>%n'
               z=0 continue
            }
            catv Z /%n
         ;;
        2)  
            expr "$Z" :ch '%(..%)@+%('"$4"'_[a-z0-9]%{2}%)@%1' || continue
            z=3 t=1; catv 2,ch =kz:; catv 2,,ch =ch:
            catv "/$kz $ch.$2%n"
         ;;
        3)
            expr "$Z" :: "$kz@-$ch@$kz" && {
               catv '/%n%n'
               z=2 continue
            }
            catv Z /%n
         ;;
      esac
   done
   ><
   [ $1 == html -a t -eq 1 ] && { catv '/<br>%n' =3; catv '/<br><br>%n'; }
   [ $1 == text -a t -eq 1 ] && { catv '/%n%n%n'; }
   return 0
}


HTMLb='</body>
</html>'
Title='<title>Kodeabschnitte in Farbe</title>'
HTML3='<br>
<h1>Moderne C-Programmierung - Kompendium und Referenz</h1>
<h2>Kodeabschnitte des Buches in Farbe</h2>
Hergestellt mit Editor <tt>gvim</tt> und Shell <tt>bsh</tt><br>
<br><br><br>
'
TXT3='
Moderne C-Programmierung - Kompendium und Referenz
Kodeabschnitte des Buches als Plain-Text
Hergestellt mit Shell bsh



'
set Z:.300
set CHAP:.500
set HTMLa:.400
set DE:.10
set LE:.10
set CH:.20
set CO:.20
set HT:.20


Chapters c.tex
HTML ctex_c.htm

for DE in html text
do
   CO=code3.$DE
   print -u2 "%t$CO"
   >$CO
   3>"/tmp/$CO"
   for LE in c bsh cpp pl s txt
   do

      [ $DE == html ] && HT=ctex_$LE.htm
      [ $DE == text ] && HT=ctex_l.$LE
      print -u2 "%t%t$HT"
      for CH in $CHAP
      do
         print -u2 "%t%t%t$CH"
         Code $DE $LE $HT $CH
      done
   done
   ><<
   [ $DE == html ] && {
      catv HTMLa HTML3 3 0 HTMLb <$CO 3<"/tmp/$CO" | cat >$CO
      #move $CO ${CO}l
   }
   [ $DE == text ] && {
      catv TXT3 0 <$CO | {
         >$CO
         while readl Z
         do  catv Z /%r%n;  done
         ><
      }
   }
   remove -s /tmp/$CO
done

exit 0