Blogvorlage

Realisierung mit Bash

Mit dem folgenden Skript ist es möglich, entweder eine Ascii-Zeichenfolge einzugeben und sich die dazugehörige Binärzeichenkette ausgeben zu lassen, oder umgekehrt.
Dabei wird immer zuerst die Eingabe einer Ascii-Zeichenkette erwartet (oder Enter zum Überspringen) und anschließend eine Binärzeichenkette.

Quellcode: ascii-binary.sh

#!/bin/bash

# oct: 40 - 176

##### -------- Ascii zu Binär wandeln -------- #####

asciitobin() {
   nummer=`printf '%x\n' "'$1"`                            # Die Ascii-Hex-Nummer
                                                           # des aktuellen Zeichens
   decnum=""
   bit=$globalbit

   while [ ! -z "$nummer" ] ; do                           # umwandeln der Hex-Nummer
      element=${nummer:0:1}                                # in eine Dezimalnummer
      let bit=$bit/16
      case $element in
         a)    let element=10*$bit
               let decnum=$decnum+$element;;
         b)    let element=11*$bit
               let decnum+=$element;;
         c)    let element=12*$bit
               let decnum+=$element;;
         d)    let element=13*$bit
               let decnum+=$element;;
         e)    let element=14*$bit
               let decnum+=$element;;
         f)    let element=15*$bit
               let decnum+=$element;;
         *)    let element=$element*$bit
               let decnum+=$element;;
      esac

      nummer=${nummer:1}
   done

   binaer=""
   bit=$globalbit

   while [ $bit -ge 2 ] ; do                               # Schreibe die Binärzeichen
      let bit=$bit/2                                       # aus der ermittelten
                                                           # Dezimalzahl
      if [ $decnum -ge $bit ] ; then
         binaer=${binaer}1
         let decnum-=$bit
      else
         binaer=${binaer}0
      fi
   done
}


##### -------- Binär zu Ascii wandeln -------- #####

bintoascii() {
   block=$1
   bit=$globalbit
   decnum=0

   while [ ${#block} -ge 1 ] ; do                          # ermittle die
      binaerzeichen=${block:0:1}                           # Dezimalzahl aus
      let bit=$bit/2                                       # den Binärzeichen

      if [ $binaerzeichen -eq 1 ] ; then
         let decnum+=$bit
      fi

      block=${block:1}
   done

                                                           # Dezimal -> Hex
   let erstes_zeichen=$decnum/16
   let zweites_zeichen=$decnum-$erstes_zeichen*16

   case $erstes_zeichen in
      15)  erstes_zeichen=f;;
      14)  erstes_zeichen=e;;
      13)  erstes_zeichen=d;;
      12)  erstes_zeichen=c;;
      11)  erstes_zeichen=b;;
      10)  erstes_zeichen=a;;
      *)   ;;
   esac

   case $zweites_zeichen in
      15)  zweites_zeichen=f;;
      14)  zweites_zeichen=e;;
      13)  zweites_zeichen=d;;
      12)  zweites_zeichen=c;;
      11)  zweites_zeichen=b;;
      10)  zweites_zeichen=a;;
      *)   ;;
   esac

   nummer=${erstes_zeichen}${zweites_zeichen}
                                                           # Gebe das Zeichen zur
   zeichen=`printf "%b\n" "\x$nummer"`                     # ermittelten Hexadezi-
}                                                          # malnummer aus


##### -------- Hauptroutine -------- #####

OLDIFS=$IFS
IFS='
'

globalbit=256                                              # 2^8 Möglichkeiten ->
                                                           # 8 Binärzeichen pro Zeichen
echo "Ascii -> Binär und umgekehrt"
echo "Geben Sie einen Ascii-Teststring ein:"

read asciistring

if [ -z "$asciistring" ] ; then
   echo "Sie haben nichts eingegeben"
fi

while [ ! -z "$asciistring" ] ; do                         # Für jedes Zeichen des
   asciitobin ${asciistring:0:1}                           # Ascii Strings soll die
   echo -n $binaer                                         # asciitobin Funktion auf-
   asciistring=${asciistring:1}                            # gerufen werden, die $binaer
done                                                       # auf den gewünschten Binärcode
                                                           # setzt (der ausgegeben wird)
echo ""

echo "Und nun einen Binär-String:"

read binstring

if [ -z $binstring ] ; then                                # Bei der Eingabe des Binär-
   echo "Sie haben nichts eingegeben"                      # strings sind mehrere
   exit 0                                                  # Prüfungen notwendig, weil
fi                                                         # der String nur aus 0 und 1
                                                           # bestehen darf
let laenge=${#binstring}%8                                 # Da jedes Zeichen durch
if [ $laenge -ne 0 ] ; then                                # 8 Binärzeichen dargestellt
   echo "Ungültige String-Länge"                           # wird, muss die Gesamtzahl
   exit 1                                                  # entsprechend sein, weil
fi                                                         # in der bintoascii Funktion
                                                           # nicht überprüft wird, ob
tempbinstring=${binstring//1/}                             # der übergebene String das
tempbinstring=${tempbinstring//0/}                         # richtige Format hat

if [ ! -z $tempbinstring ] ; then
   echo "Ungültige Zeichen enthalten"
   exit 1
fi

while [ ! -z $binstring ] ; do                             # Jeder 8-Binärzeichen Block
   bintoascii ${binstring:0:8}                             # wird übergeben und gewandelt
   echo -n $zeichen
   binstring=${binstring:8}
done

echo ""
IFS=$OLDIFS

exit 0