#   pc-kc87.src

declare -a -x R_
R_=""

#***************************************************
#Wartet bis der String ausgegeben wird,
#!!!!!!!!!!!!!!sofortige Rueckkehr bei RESET vom KC87
#belegt ST und Rueckkehrwert=Status
strausgabe ()
{
ST=$(pstatus)
if [[ ${ST} -eq 3 ]];then return 3;fi
while [[ ${ST} -ne 1 ]];
do
  ST=$(pstatus);
  if [[ ${ST} -eq 3 ]];then break;fi
done
if [[ ${ST} -eq 3 ]];then return 3;fi
echo -e "$1" | strout
ST=$?
return ${ST}
}
#Hilfsfunktion: Zuweisung eines Parameters zu einer Shellvariablen:
#R_ wird nicht veraendert.
rw () {
if [[ -n $2  ]];
then
  eval "$2=\"$1\"" ;
fi
}
#Aufruf: param parameterliste
#parameterliste hat SPACE als Trennzeichen
#Die einzelnen Teile von parameterliste werden in das R_-Array uebertragen.
#Das R_-Array wird vorher gelöscht.
#Die Teile befinden sich danach in R_[1], R_[2], R_[3] usw.
#Bem.: R_[0] ist identisch mit R_ und leer!
param ()
{ local BCI BCL BCP BCQ BCR BCQR BCLP LQ LR LQR FLAG LEN LE ;
BCI=${R_}
unset R_
R_=${BCI}
#Index fuer R_[]:
BCI=1
R_[1]=""
#FLAG=0 - nicht im String befindlich
#FLAG=1 - im String befindlich
FLAG=0
#Feststellen, ob saubere Strings, mit Anfuehrungs-Zeichen (nicht Apostroph) als Parameter vorhanden sind:
while [[ -n $1 ]];
do
  BCP=$1
  #Fall: (anfuehrungszeichen)(spaces), am Anfang eines Strings oder
  #      (spaces)(anfuehrungszeichen), am Ende eines Strings:
  if [[ ${BCP} == "\"" ]];
  then
    if [[ ${FLAG} -eq 0 ]];
    then
      #Es ist der Anfang eines Strings:
      FLAG=1;
      R_[${BCI}]=" ";
    else
      #Es ist der Rest eines Strings:
      R_[${BCI}]="${R_[${BCI}]} ";
      FLAG=0;
      BCI=$((${BCI}+1))
      R_[${BCI}]="";
    fi
    shift 1
    continue;
  fi;
  LP=${#BCP}
  BCQ=${BCP#\"}
  LQ=${#BCQ}
  BCR=${BCP%\"}
  LR=${#BCR}
  QR=${BCQ%\"}
  LQR=${#QR}
  if [[ (${LP} -eq ${LQ}) && (${LP} -eq ${LR}) ]];
  then
    if [[ ${FLAG} -eq 0 ]];
    then
      #Es ist kein Stringteil:
      R_[${BCI}]=${BCP}
      BCI=$((${BCI}+1))
      R_[${BCI}]="";
    else
      #Es ist Innenteil eines Strings:
      R_[${BCI}]="${R_[${BCI}]} ${BCP}";
    fi
    shift 1
    continue;
  fi
  if [[ (${LP} -gt ${LQ}) && (${LQ} -gt ${LQR}) ]];
  then
    #Es ist ein voller String:
    R_[${BCI}]=${QR}
    BCI=$((${BCI}+1))
    R_[${BCI}]=""
    FLAG=0
    shift 1
    continue;
  fi
  if [[ (${LP} -gt ${LQ}) && (${LQ} -eq ${LQR}) ]];
  then
    #Es ist der 1.Teil eines Strings:
    R_[${BCI}]=${BCQ}
    FLAG=1
    shift 1
    continue;
  fi
  if [[ (${LP} -eq ${LQ}) && (${LQ} -gt ${LQR}) ]];
  then
    #Es ist der Rest eines Strings:
    R_[${BCI}]="${R_[${BCI}]} ${QR}"
    FLAG=0
    BCI=$((${BCI}+1))
    R_[${BCI}]=""
    shift 1
    continue;
  fi;
done
}

#Aufruf: parn n parameterliste
#parameterliste hat SPACE als Trennzeichen zwischen den Parametern
#Parameter koennen auch mit Anfuehrungszeichen eingerahmte Strings mit mehreren Worten sein.
#Der n. Parameter von parameterliste wird in R_ zurueckgegeben.
parn ()
{
  local ALLE BCM=$1;
  ALLE=$@
  BCM=$((${BCM}+1))
  param ${ALLE}
  R_=${R_[${BCM}]}
}
#Abschneiden bzw. Auffuellen einer Zahl auf n- Dezimalstellen:
#Zahlen ohne fuehrende 0 werden korrekt gewandelt.
#Aufruf: scale ausdr n [var]
#Ergebnis in R_ und ggf. var
scale ()
{
local  BCF BCL BCN BCA=$1 BCV BCB BCC;
BCA=${BCA#+}
#R_=$(bco "${BCA}")
bcc "${BCA}"
#Vorzeichentest:
BCV=0
if [[ ${R_:0:1} == "-" ]] ;
then
  BCV=1
  R_=${R_/#-/} ;
fi
lnul ${R_}
BCF=$2
if [[ ${BCF} -lt 0 ]] ;
then
  BCF=0 ;
fi
#length zaehlt eine fuehrende 0 nicht, auch vor Dezimalpunkt nicht
BCL=$(echo "length(${R_})"|bc -q -l)
if [[ ${R_:0:1} == "0" ]] ;
then
  BCL=$((${BCL}+1)) ;
fi
BCN=$(echo "scale(${R_})"|bc -q -l)
if [[ ${BCN} -gt ${BCF} ]] ;
then
  BCA=$((${BCL}-${BCN}+${BCF}+1))
  R_=${R_:0:${BCA}} ;
fi
#if [[ ${R_:0:1}y == "." ]] ; then R_="0${R_}" ; fi
R_=${R_/%./}
if [[ ${BCV} -eq 1 ]] ;
then
  R_="-${R_}" ;
fi
#ggf. Mantisse mit 0 auffuellen:
if [[ ${BCF} -gt 0 ]];
then
  BCA=${R_//./ }
  parn 1 ${BCA}
  BCB=${R_}
  parn 2 ${BCA}
  BCC=${R_}
  if [[ -z ${BCC} ]];
  then
    BCC="0" ;
  fi
  BCL=${#BCC}
  while [[ ${BCF} -gt ${BCL} ]];
  do
    BCC="${BCC}0"
    BCL=${#BCC} ;
  done
  R_="${BCB}.${BCC}" ;
fi
rw "${R_}" $3
}
#Hilfsfunktion: Voranstellen einer 0, wenn noetig:
#Aufruf lnul string [varname]
#Ergebnis in R_ und [varname]
lnul ()
{ local FL=0 ;
R_=$1
if [[ ${R_:0:1} == "-" ]] ;
then
  R_=${R_:1}
  FL=1;
fi
if [[ ${R_:0:1} == "." ]] ;
then
  R_="0${R_}";
fi
if [[ ${FL} -eq 1 ]];
then
  R_="-${R_}";
fi
rw "${R_}" $2
}
#Berechnung eines numerischen Ausdruckes mit Zuweisung zu einer Shell-Variablen mit Skalierung,
#R_ enthaelt ebenfalls das Ergebnis:
#Aufruf: bcv bcstring variable [precision]
#wenn precision < 0 ist oder nicht angegeben ist, erfolgt keine Skalierung.
bcv ()
{
local BCS=$1 BCV=$2 BCP=$3 BCY;
R_=$(echo -e "$1"|bc -q -l)
lnul ${R_}
BCY=${R_}
if [[ ${BCP} == "" ]];
then
BCP="-1";
fi
if [[ ${BCP} -ge 0 ]];
then
  scale ${BCY} ${BCP};
fi
rw "${R_}" $2
}
