#!/bin/sh
 
 # gms
 # === 
 
 # This file is part of Gerolf Markup Shredder,
 # written by G. D. Brettschneider (1999-2006).
 
 GMSdateGMS=20060927
   
 # Prologue: ==================================================================
  
 # Debug:
   
 if [ "$GMS_DEBUG" = "X" -o "$GMS_DEBUG" = "Y" ]; then
   REPLY_BANNER=2
   REPLY_TEXT=15
   source "$GMS_SHELL/l_banner" -debug g_vars $1 $2 $3 $4
 elif  [ "$GMS_DEBUG" = "Z" -a "$GMS_MODE" != "quiet" ]; then
   echo " gms ($1) ($2) ($3) ($4) ($5) ($6) ($7) ($8) ($9)" >> "$Z"
 fi
 
 # 1. Check common variables: =================================================
 
 export GMS_PWD=$PWD
 
 # If necesssary, read launcher script to load environment:
  
 if [ "$GMS_SHELL" = "" ]; then
   source gerolf -passive $1 $2 $3 $4 $5 $6 $7 $8 $9
   if [ "$1" = "-passive" ]; then shift; fi # required for SuSE
   if [ "$GMS_SHELL" = "" ]; then
     echo " GMS error: Could not set environment variables."
     echo " Run 'gmssetup' to create GMS launcher script 'gerolf'!"
     echo
     exit 
   fi
 fi
  
 # 2. Check chapter variable: =================================================

 # GMS is not yet running:

 if [ "$1" = "" ]; then
   source "$GMS_SHELL/l_gms" -welcome called_by gms
   read
   exec "$GMS_SHELL/l_gms" -help called_by gms
 fi 
 
 # Remove optional "-mime" argument at first position (browser interface): ----
 
 if [ "$1" = "-mime" ]; then
   if [ "$2" = "-read" ]; then
     echo "Content-type: application/pdf"
   else 
     echo "Content-type: text/plain"
   fi
   shift
 fi
  
 # Get run time: --------------------------------------------------------------
 
 function get_runtime () { 
   if [ "$BEFORE" != "" ]; then
     AFTER=$(date +%s) 
     if [ "$AFTER" = "$BEFORE" ]; then
       GMS_RUNTIME="<1s" 
     else
       GMS_RUNTIME=$[$AFTER-$BEFORE]s
     fi 
   fi
   AFTER= 
   BEFORE=
   }
     
 # Chapters: ==================================================================
   
 # Set file, if $1 is one:
   
 if [ -f "$1" ]; then
   source "$GMS_SHELL/gms" -o "$1"
       
 # Quit: ----------------------------------------------------------------------

 elif [ "$1" = "-q" -o "$1" = "-Q" -o \
   "$1" = "--q" -o "$1" = "--Q" -o \
   "$1" = "/q" -o "$1" = "/Q" -o \
   "$1" = "q" -o "$1" = "Q" -o \
   "$1" = "qq" -o "$1" = "QQ" ]; then
   if [ "$GMS_MODE" != "quiet" ]; then setterm -clear; fi
   source "$GMS_SHELL/l_gms" -goodbye
 # Remove temporary files:
   if [ "$1" = "-Q" -o "$1" = "--Q" -o \
     "$1" = "/Q" -o "$1" = "Q" -o \
     "$1" = "QQ" ]; then
     if [ -f ./*.log ]; then rm ./*.log 2> ./nul; fi
     if [ -f ./*.ok ]; then rm ./*.ok 2> ./nul; fi
     if [ -f ./*.err ]; then rm ./*.err 2> ./nul; fi
     if [ -f ./nul ]; then rm ./nul; fi
   fi
 # Return to startup folder:
   if [ -d "$GMS_STARTUP" ]; then cd "$GMS_STARTUP"; fi
   source "$GMS_SHELL/g_vars" -write_memo
 # Restore environment:
   source "$GMS_SHELL/g_vars" -clear called_by gms -q
   
 # Create: --------------------------------------------------------------------
   
 elif [ "$1" = "-c" -o "$1" = "-C" -o \
   "$1" = "--c" -o "$1" = "--C" -o \
   "$1" = "/c" -o "$1" = "/C" -o \
   "$1" = "c" -o "$1" = "C" -o \
   "$1" = "cc" -o "$1" = "CC" ]; then
 # $2: new file name, $3: template file name
 # Get base name of file:
   mybase=$(basename $3 ".htm") 
   mybase=$(basename $mybase ".html")
 # Check if there is an old file with that name ($2):
   if [ -f "$GMS_PWD/$2" ]; then
     export GMS_MESSAGE="GMS error: There is already such a file $2"
     source "$GMS_SHELL/l_gms" -help called_by gms -c
     sleep 2
 # Look for template in current directory and copy it:
   elif [ -f "$GMS_PWD/$3" ]; then
     cp "$GMS_PWD/$3" "$GMS_PWD/$2"
   elif [ -f "$GMS_PWD/$mybase.htm" ]; then
     cp "$GMS_PWD/$mybase.htm" "$GMS_PWD/$2"
   elif [ -f "$GMS_PWD/$mybase.html" ]; then
     cp "$GMS_PWD/$mybase.html" "$GMS_PWD/$2"
 # Look for template in template main directory and copy it:
   elif [ -f "$GMS_TEMPLATE/$3" ]; then
     cp "$GMS_TEMPLATE/$3" "$GMS_PWD/$2"
   elif [ -f "$GMS_TEMPLATE/$mybase.htm" ]; then
     cp "$GMS_TEMPLATE/$mybase.htm" "$GMS_PWD/$2"
   elif [ -f "$GMS_TEMPLATE/$mybase.html" ]; then
     cp "$GMS_TEMPLATE/$mybase.html" "$GMS_PWD/$2"
 # Look for template in template subdirectory and copy it:
   elif [ -f "$GMS_TEMPLATE/$mybase/$3" ]; then
     cp "$GMS_TEMPLATE/$mybase/$3" "$GMS_PWD/$2"
   elif [ -f "$GMS_TEMPLATE/$mybase/$mybase.htm" ]; then
     cp "$GMS_TEMPLATE/$mybase/$mybase.htm" "$GMS_PWD/$2"
   elif [ -f "$GMS_TEMPLATE/$mybase/$mybase.html" ]; then
     cp "$GMS_TEMPLATE/$mybase/$mybase.html" "$GMS_PWD/$2"
   else
     export GMS_MESSAGE="GMS: Creating default file - got no template $3"
     source "$GMS_SHELL/l_gms" -help called_by gms -c
     sleep 2
     cp "$GMS_TEMPLATE/default/default.htm" "$GMS_PWD/$2"
   fi; unset myfolder
   if  [ -f "$GMS_PWD/$2" ]; then 
     export GMS_FILE="$2"; export GMS_FOLDER=$GMS_PWD
     source "$GMS_SHELL/g_vars" -write_memo called_by gmssetup  
   fi
    
 # Open: ----------------------------------------------------------------------
   
 elif [ "$1" = "-o" -o "$1" = "-O" -o \
   "$1" = "--o" -o "$1" = "--O" -o \
   "$1" = "/o" -o "$1" = "/O" -o \
   "$1" = "o" -o "$1" = "O" -o \
   "$1" = "oo" -o "$1" = "OO" ]; then
   shift
   source "$GMS_SHELL/g_vars" -ini_file $1 $2 $3 $4 $5 $6 $7 $8 $9
   source "$GMS_SHELL/l_gms" -help called_by gms -o
 
 # View: ----------------------------------------------------------------------
   
 elif [ "$1" = "-v" -o "$1" = "-V" -o \
   "$1" = "--v" -o "$1" = "--V" -o \
   "$1" = "/v" -o "$1" = "/V" -o \
   "$1" = "v" -o "$1" = "V" -o \
   "$1" = "vv" -o "$1" = "VV" ]; then
   export GMS_COMMAND=$GMS_VIEWER
   source "$GMS_SHELL/gms" -execute called_by gms -v
   
 # Edit: ----------------------------------------------------------------------
 
 elif [ "$1" = "-e" -o "$1" = "-E" -o \
   "$1" = "--e" -o "$1" = "--E" -o \
   "$1" = "/e" -o "$1" = "/E" -o \
   "$1" = "e" -o "$1" = "E" -o \
   "$1" = "ee" -o "$1" = "EE" ]; then
   export GMS_PROGRAM="text editor"
   export GMS_COMMAND=$GMS_EDITOR
   source "$GMS_SHELL/gms" -execute called_by gms -e
   
 # Browse: --------------------------------------------------------------------
   
 elif [ "$1" = "-b" -o "$1" = "-B" -o \
   "$1" = "--b" -o "$1" = "--B" -o \
   "$1" = "/b" -o "$1" = "/B" -o \
   "$1" = "b" -o "$1" = "B" -o \
   "$1" = "bb" -o "$1" = "BB" ]; then
   export GMS_PROGRAM="markup file browser"
   export GMS_COMMAND=$GMS_BROWSER
   source "$GMS_SHELL/gms" -execute called_by gms -b
 
 # Analyse file or all files in folder: ---------------------------------------
 
 elif [ "$1" = "-a" -o "$1" = "-A" -o \
   "$1" = "--a" -o "$1" = "--A" -o \
   "$1" = "/a" -o "$1" = "/A" -o \
   "$1" = "a" -o "$1" = "A" -o \
   "$1" = "aa" -o "$1" = "AA" ]; then
   # Get base name of file:
   if [ "$GMS_PERL" != "1" ]; then ###
     export GMS_BASE=$(basename $GMS_FILE ".htm") 
     export GMS_BASE=$(basename $GMS_BASE ".html")
   fi
   if [ "$GMS_MODE" != "quiet" ]; then
     echo "  GMS_FOLDER=$GMS_FOLDER" >> "$Z"
     echo "  GMS_FILE=$GMS_FILE" >> "$Z"
     echo "  GMS_BASE=$GMS_BASE" >> "$Z"
   fi
   export GMS_PROGRAM="markup syntax checker"
   export GMS_COMMAND=$GMS_VIEWER
   if [ "$2" != "" ]; then shift; fi
   slashline="/////////////////////////////"
 # If no file is specified, check folder:
   if [ "$GMS_FILE" = "" ]; then export GMS_FILE="_folder.err"; fi
   if [ "$GMS_FILE" = "_folder.err" ]; then
   # Process folder:
     echo " $GMS_FILE - GMS: Folder check. Running $GMS_PROGRAM ..." \
       > _folder.err
     echo " $slashline$slashline////////////////////" >> _folder.err
     echo >> _folder.err
     dashline="_____________________________"
     for i in *.htm*; do # Analyse kernel:
       "$GMS_BINARIES/$GMS_ANALYST" \
         -config "$TEXMFCNF/tidy.cfg" -f $i.er_ $i > $i.ok
       echo " $i" 
       echo " ____________________$dashline$dashline" 
       echo " $i" >> _folder.err
       echo " ____________________$dashline$dashline" >> _folder.err
       cat $i.er_
       cp _folder.err folder.er_
       cat folder.er_ $i.er_ > _folder.err
       echo >> _folder.err
       if [ -f folder.er_ ]; then rm folder.er_; fi
       if [ -f $i.er_ ]; then rm $i.er_;fi
       if [ -f $i.ok ]; then rm $i.ok; fi
     done; unset dashline
     echo " $slashline$slashline////////////////////" >> _folder.err
     echo " $GMS_FOLDER" >> _folder.err
   else
     export backup_file=$GMS_FILE; export backup_base=$GMS_BASE
     if [ "$GMS_MODE" != "quiet" ]; then
       source "$GMS_SHELL/l_gms" -desktop -draw called_by gms -a
     fi; export GMS_FILE=$backup_file
   # Run HTML Tidy:  
       if [ "$GMS_DEBUG" = "Z" -a "$GMS_MODE" != "quiet" ]; then
         echo "  GMS_ANALYST=$GMS_ANALYST" >> "$Z"; fi
       if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
       if [ -f "$GMS_BASE.err" ]; then rm "$GMS_BASE.err"; fi
       "$GMS_BINARIES/$GMS_ANALYST" -config "$GMS_SETTING/tidy.cfg" \
         -f $GMS_BASE.tmp "$GMS_FILE" > "$GMS_BASE.ok"
     export GMS_FILE="$GMS_BASE.err"
     if [ "$GMS_MODE" != "quiet" ]; then
         echo " $GMS_FILE - GMS: Running $GMS_PROGRAM ..." > errhead.err
         echo " $slashline$slashline////////////////////" >> errhead.err
         if [ -f errfoot.err ]; then rm errfoot.err; fi
       # Extra empty lines as cosmetics for "no error" results:
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
         echo " $slashline$slashline////////////////////" >> errfoot.err
         echo " $GMS_FOLDER" >> errfoot.err
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
         for i in 1 2 3 4 5 6 7 8 9 10 11 12; do echo >> errfoot.err; done
       cat errhead.err "$GMS_BASE.tmp" errfoot.err > "$GMS_BASE.err"
     fi; unset slashline
     if [ "$GMS_MODE" == "quiet" ]; then mv "$GMS_BASE.tmp" "$GMS_BASE.err"; fi
     if [ -f "$GMS_BASE.pmt" ]; then rm "$GMS_BASE.pmt"; fi
     if [ -f "$GMS_BASE.tmp" ]; then rm "$GMS_BASE".tmp; fi
     if [ -f errhead.err ]; then rm errhead.err; fi
     if [ -f errfoot.err ]; then rm errfoot.err; fi
   fi; source "$GMS_SHELL/gms" -execute called_by gms -a
 
 # Typeset: -------------------------------------------------------------------
   
 elif [ "$1" = "-t" -o "$1" = "-T" -o \
   "$1" = "--t" -o "$1" = "--T" -o \
   "$1" = "/t" -o "$1" = "/T" -o \
   "$1" = "t" -o "$1" = "T" -o \
   "$1" = "tt" -o "$1" = "TT" ]; then
   cd "$GMS_FONTS/tfm"
   if [ "$GMS_MODE" != "quiet" ]; then
    if [ ! -f *.tfm ]; then
     cd -
     if [ "$GMS_MODE" != "quiet" ]; then setterm -clear; fi
     mymsg="GMS error: TeX font metrics not found. Please 'Write font map'."
     echo " $mymsg"
     cat "$GMS_SETTING/desktop.scn"
     echo  -n " $GMS_FONTS/tfm"
     if [ "$GMS_DEBUG" = "Z" ]; then
       echo "$mymsg ($GMS_FOLDER/$GMS_FILE)." >> "$Z"
     fi
     unset mymsg
     sleep 2
     exit
    elif [ ! -f "$GMS_SETTING/font.map" ]; then
     cd -
     if [ "$GMS_MODE" != "quiet" ]; then setterm -clear; fi
     mymsg="GMS error: Missing font information. Please 'Write font map'."
     echo " $mymsg"
     cat "$GMS_SETTING/desktop.scn"
     echo  -n " $GMS_SETTING"
     if [ "$GMS_DEBUG" = "Z" ]; then
       echo "$mymsg ($GMS_FOLDER/$GMS_FILE)." >> "$Z"
     fi
     unset mymsg
     sleep 2
     exit
    fi
   fi
   cd -
 # Get base name of file:
   if [ "$GMS_PERL" != "1" ]; then ###
     export GMS_BASE=$(basename $GMS_FILE ".htm")
     export GMS_BASE=$(basename $GMS_BASE ".html")
   fi
   export backup_file=$GMS_FILE
   export backup_base=$GMS_BASE
   export GMS_PROGRAM="$GMS_TSETTER engine"
   export GMS_COMMAND="$GMS_VIEWER"
   export GMS_FILE="$GMS_BASE.log"
   slashline="//////////////////////////////"
     if [ "$GMS_MODE" != "quiet" ]; then
       setterm -clear
       echo " $GMS_FILE - GMS: Running $GMS_PROGRAM ..."
       echo " $slashline$slashline//////////////////"
     fi
   export GMS_FILE=$backup_file
   export TEXINPUTS=".//:$TEXMFCNF:$TEX_USER//"
   export WEB2C="$GMS_SETTING"
     if [ "$GMS_DEBUG" = "Z" -a "$GMS_MODE" != "quiet" ]; then
       echo "  GMS_TSETTER=$GMS_TSETTER" >> "$Z"
       echo "  GMS_FOLDER=$GMS_FOLDER" >> "$Z"
       echo "  GMS_FILE=$GMS_FILE" >> "$Z"
       echo "  GMS_BASE=$GMS_BASE" >> "$Z"
       echo "  TEXINPUTS=$TEXINPUTS" >> "$Z"
     fi
     if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
     export BEFORE=$(date +%s)
       "$GMS_BINARIES/$GMS_TSETTER" -progname=gerolf "$GMS_FILE" 2> gmserr.log
     get_runtime
   unset TEXINPUTS; unset WEB2C
   export GMS_FILE="$GMS_BASE.log"
   if [ "$GMS_MODE" = "quiet" ]; then   
     cat "$GMS_BASE.log" gmserr.log > "$GMS_BASE.tmp"
     if [ -f "$GMS_BASE.tmp" ]; then mv "$GMS_BASE.tmp" "$GMS_FILE"; fi 
   else
     echo " $GMS_FILE - GMS: Running $GMS_PROGRAM ..." > loghd.log
     echo " $slashline$slashline//////////////////" >> loghd.log
     if [ -f "readme.txt" ]; then cat "readme.txt" >> loghd.log
     elif [ -f "Readme.txt" ]; then cat "Readme.txt" >> loghd.log
     elif [ -f "README.TXT" ]; then cat "README.TXT" >> loghd.log; fi
     echo "GMS run time: $GMS_RUNTIME" > logft.log
     echo " $slashline$slashline//////////////////" >> logft.log
     echo " $GMS_FOLDER" >> logft.log
     for i in 1 2 3 4 5 6 7 8 9 10; do echo >> logft.log; done
     if [ -f "$GMS_FILE" ]; then mv "$GMS_FILE" "$GMS_BASE.pmt"; fi
     # pdfeTeX header cosmetics (insert newline):
       export AFTER=$(date)
         sed "/(format=gerolf.*$/{G;s/$/XyZZy/;};/^$/d;s/< /</g;s/ >/>/g" \
           < "$GMS_BASE.pmt" > "$GMS_BASE.pmu"
         sed "s/(format=gerolf.*$//;s/XyZZy/(format=gerolf) $AFTER/" \
           < "$GMS_BASE.pmu" > "$GMS_BASE.tmp"
       unset AFTER
     cat loghd.log "$GMS_BASE.tmp" logft.log gmserr.log > "$GMS_FILE"
     if [ -f "$GMS_BASE.pmt" ]; then rm "$GMS_BASE.pmt"; fi
     if [ -f "$GMS_BASE.pmu" ]; then rm "$GMS_BASE.pmu"; fi
     if [ -f "$GMS_BASE.tmp" ]; then rm "$GMS_BASE.tmp"; fi
     if [ -f loghd.log ]; then rm loghd.log; fi
     if [ -f logft.log ]; then rm logft.log; fi
     if [ -f gmserr.log ]; then rm gmserr.log; fi
     export GMS_BASE=$GMS_LOGBASE
     source "$GMS_SHELL/gms" -execute called_by gms -t
   fi
   unset slashline
      
 # Initialize TeX format: -----------------------------------------------------
 
 elif [ "$1" = "-i" -o "$1" = "-I" -o \
   "$1" = "--i" -o "$1" = "--I" -o \
   "$1" = "/i" -o "$1" = "/I" -o \
   "$1" = "i" -o "$1" = "I" -o \
   "$1" = "ii" -o "$1" = "II" ]; then
   mymode=$2   
   export backup_folder=$GMS_FOLDER
   export backup_file=$GMS_FILE
   export backup_base=$GMS_BASE
   export backup_short=$GMS_SHORT
   export GMS_FOLDER=$TEXFORMATS
   export GMS_FILE=gerolf.log
   export GMS_BASE=gerolf
   export GMS_SHORT=gerolf.log
   export GMS_PROGRAM="$GMS_TSETTER engine"
   export GMS_COMMAND=$GMS_VIEWER
   export GEROLF="*gerolf"
   if [ "$GMS_TSETTER" = "tex" ]; then export GEROLF="gerolf"
   elif [ "$GMS_TSETTER" = "pdftex" ]; then export GEROLF="gerolf"; fi
   export TEXINPUTS="$GMS_ROOT/data//:$TEX_BASE//:$TEXMFCNF:$GMS_BINARIES"
   export WEB2C="$GMS_SETTING"
     if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
     slashline="/////////////////////////////"
       if [ "$mymode" = "-quiet" ]; then 
         source "$GMS_SHELL/g_plug" -build -quiet called_by gms -i
       else
         if [ "$GMS_MODE" != "quiet" ]; then setterm -clear; fi
         echo " $GMS_FILE - GMS: Running $GMS_PROGRAM ..."       
         echo " $slashline$slashline////////////////////"
         source "$GMS_SHELL/g_plug" -build called_by gms -i
       fi
       echo " $GMS_FILE - GMS: Running $GMS_PROGRAM ..." > gmshd.log
       echo " $slashline$slashline////////////////////" >> gmshd.log
       export BEFORE=$(date +%s)
       if [ "$mymode" = "-quiet" ]; then
         echo "\dump" | "$GMS_BINARIES/$GMS_TSETTER" \
           -ini $GEROLF > nil 2> gmserr.log
         if [ -f nil ]; then rm nil; fi
       else
         echo "\dump" | "$GMS_BINARIES/$GMS_TSETTER" \
           -ini $GEROLF 2> gmserr.log
       fi
       get_runtime
       echo -n "GMS run time: $GMS_RUNTIME" > gmsft.log
       echo >> gmsft.log
       echo " $slashline$slashline////////////////////" >> gmsft.log
       echo " $GMS_FOLDER" >> gmsft.log
     unset slashline
     if [ -f gerolf.log ]; then mv gerolf.log gms.pmt; fi
     sed "s/^.openout.*$//;s/^system.*$//;/^$/d" < gms.pmt > gms.pmu
     # pdfeTeX header cosmetics (insert newline):
       export AFTER=$(date)
         sed "/(INITEX.*$/{G;s/$/XyZZy/;}" \
           < gms.pmu > gms.pmx
         sed "s/(INITEX.*$//;s/XyZZy/(INITEX) $AFTER/" \
           < gms.pmx > gms.tmp
       unset AFTER
     cat gmshd.log gms.tmp gmserr.log gmsft.log > gerolf.log
   # Remove temporary files:
     if [ -f gmshd.log ]; then rm gmshd.log; fi
     if [ -f gms.pmt ]; then rm gms.pmt; fi
     if [ -f gms.pmu ]; then rm gms.pmu; fi
     if [ -f gms.pmx ]; then rm gms.pmx; fi
     if [ -f gms.tmp ]; then rm gms.tmp; fi
     if [ -f gmserr.log ]; then rm gmserr.log; fi
     if [ -f gmsft.log ]; then rm gmsft.log; fi
     if [ -f "$GMS_BINARIES/font.lst" ]; then
       rm "$GMS_BINARIES/font.lst"; fi
     if [ -f "$GMS_BINARIES/sortfont.lst" ]; then
       rm "$GMS_BINARIES/sortfont.lst"; fi
     if [ -f "$GMS_BINARIES/entity.lst" ]; then
       rm "$GMS_BINARIES/entity.lst"; fi
     if [ -f "$GMS_BINARIES/sortent.lst" ]; then
       rm "$GMS_BINARIES/sortent.lst"; fi
   # Move .log, .enc and .htm files to appropriate locations:
     if [ -f gerolf.log ]; then cp gerolf.log "$GMS_SETTING"; fi
     if [ -f gerolf.log ]; then rm gerolf.log; fi
     if [ -f register.log ]; then cp register.log "$GMS_SETTING"; fi
     if [ -f register.log ]; then rm register.log; fi
     for i in *.enc; do if [ -f $i ]; then 
       cp $i "$GMS_ROOT/data/enc"; rm $i; fi; done
   unset TEXINPUTS; unset WEB2C
   export GMS_FOLDER="$GMS_SETTING"
   export GEROLF=
   if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
   source "$GMS_SHELL/g_plug" -remove called_by gms -i
   if [ "$mymode" != "-quiet" ]; then 
     source "$GMS_SHELL/gms" -execute called_by gms -w
   fi; unset mymode
   
 # Read output file: ----------------------------------------------------------
   
 elif [ "$1" = "-r" -o "$1" = "-R" -o \
   "$1" = "--r" -o "$1" = "--R" -o \
   "$1" = "/r" -o "$1" = "/R" -o \
   "$1" = "r" -o "$1" = "R" -o \
   "$1" = "rr" -o "$1" = "RR" ]; then
 # Get base name of file:
   export GMS_BASE=$(basename $GMS_FILE ".htm")
   export GMS_BASE=$(basename $GMS_BASE ".html")
   export backup_file=$GMS_FILE
   export GMS_FILE="$GMS_BASE.pdf"
   export GMS_PROGRAM="portable document file reader"
   export GMS_COMMAND=$GMS_READER
   source "$GMS_SHELL/gms" -execute called_by gms -r
      
 # Learn: ---------------------------------------------------------------------
   
 elif [ "$1" = "-l" -o "$1" = "-L" -o \
   "$1" = "--l" -o "$1" = "--L" -o \
   "$1" = "/l" -o "$1" = "/L" -o \
   "$1" = "l" -o "$1" = "L" -o \
   "$1" = "ll" -o "$1" = "LL" ]; then
   if [ -f "$GMS_TEMPLATE/handbook/handbook.htm" ]; then 
     export GMS_FOLDER="$GMS_TEMPLATE/handbook"
     export GMS_FILE="handbook.htm"
     export GMS_MESSAGE="handbook.htm                               The"
     export GMS_MESSAGE="$GMS_MESSAGE Gerolf Markup Shredder Handbook"
     cd "$GMS_FOLDER"
     source "$GMS_SHELL/g_vars" -write_memo called_by gmssetup
   fi; source "$GMS_SHELL/l_gms" -help called_by gms -l
   
 # Select: --------------------------------------------------------------------
   
 elif [ "$1" = "-s" -o "$1" = "-S" -o \
   "$1" = "--s" -o "$1" = "--S" -o \
   "$1" = "/s" -o "$1" = "/S" -o \
   "$1" = "s" -o "$1" = "S" -o \
   "$1" = "ss" -o "$1" = "LL" ]; then
   if  [ -f "$GMS_SETTING/gerolf" ]; then 
     export GMS_FILE="gerolf"; export GMS_FOLDER=$GMS_SETTING
     export GMS_MESSAGE="gerolf: The GMS launcher script. Here"
     export GMS_MESSAGE="$GMS_MESSAGE you can edit the programs"
     export GMS_MESSAGE="$GMS_MESSAGE to use via GMS "
     cd "$GMS_SETTING"
     source "$GMS_SHELL/g_vars" -write_memo called_by gmssetup
   fi; "source $GMS_SHELL/l_gms" -help called_by gms -s
   
 # Write font map: ------------------------------------------------------------
   
 elif [ "$1" = "-w" -o "$1" = "-W" -o \
   "$1" = "--w" -o "$1" = "--W" -o \
   "$1" = "/w" -o "$1" = "/W" -o \
   "$1" = "w" -o "$1" = "W" -o \
   "$1" = "ww" -o "$1" = "WW" ]; then
   export backup_folder=$GMS_FOLDER
   export backup_file=$GMS_FILE
   export backup_base=$GMS_BASE
   export GMS_FOLDER=$GMS_SETTING
   export GMS_FILE=font.map
   export GMS_BASE=font
   export GMS_SHORT=font.map
   export GMS_COMMAND=$GMS_VIEWER
   export GMS_PROGRAM="font installer"
   mymode=$2   
   if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
   source "$GMS_SHELL/g_font" -build_all $mymode 2> gmserr.log
   if [ -f gmserr.log ]; then
     sed "/^$/d; s/^/ \% /; s/^ \% $//" < gmserr.log >> font.log
     rm gmserr.log
   fi
   slashline="////////////////////////////////////////////////////////////"
     echo " % $slashline$slashline" >> font.log
     echo " % $GMS_FOLDER" >> font.log
   unset slashline
   if [ "$mymode" != "-quiet" ]; then 
     source "$GMS_SHELL/gms" -execute called_by gms -w
   fi; unset mymode
   
 # Execute program: -----------------------------------------------------------
   
 elif [ $1 = -execute ]; then
   # $2: program type, $3: binary name, $4: file name 
   if [ -f "$GMS_FOLDER/$GMS_FILE" ]; then
     if [ "$GMS_MODE" != "quiet" -a "$2" != "-quiet" ]; then
     # Contribute to gmsdebug.log:
       if [ "$GMS_DEBUG" = "Z" ]; then
         echo "   GMS_COMMAND=$GMS_COMMAND" >> "$Z"
         echo "   GMS_FOLDER=$GMS_FOLDER" >> "$Z"
         echo "   GMS_FILE=$GMS_FILE" >> "$Z"
       fi
     # Execute command:
       source "$GMS_SHELL/l_gms" -desktop -draw called_by gms -execute
       "$GMS_COMMAND" "$GMS_FOLDER/$GMS_FILE"
       source "$GMS_SHELL/l_gms" -desktop -draw called_by gms -execute
     fi
   else
     if [ "$GMS_MODE" != "quiet" ]; then setterm -clear; fi
     echo " $GMS_FILE - GMS error: File not found"
     cat "$GMS_SETTING/desktop.scn"
     echo -n " $GMS_FOLDER"
     if [ "$GMS_DEBUG" = "Z" ]; then
       mymsg=" ! GMS error: File not found"
         echo "$mymsg ($GMS_FOLDER/$GMS_FILE)." >> "$Z"
       unset mymsg
     fi
     sleep 2
   fi
   export GMS_COMMAND=
   export GMS_PROGRAM=
   if [ "$backup_base" != "" ]; then export GMS_BASE=$backup_base; fi
   if [ "$backup_file" != "" ]; then export GMS_FILE=$backup_file; fi
   if [ "$backup_folder" != "" ]; then export GMS_FOLDER=$backup_folder; fi
   if [ "$backup_folder" != "" ]; then 
     if [ -d "$GMS_FOLDER" ]; then cd "$GMS_FOLDER"; fi
   fi
   export backup_base=
   export backup_file=
   export backup_folder=
   source "$GMS_SHELL/l_gms" -help
   
 # Show error: ----------------------------------------------------------------

 else
   if [ ! -d "$GMS_FOLDER/$GMS_FILE" ]; then
     export GMS_MESSAGE="GMS error: No file or command line option $1"
     source "$GMS_SHELL/l_gms" -help
     sleep 1
     if [ "$GMS_DEBUG" = "Z" ]; then echo " $GMS_MESSAGE" >> "$Z"; fi
   exit   
   fi
 fi
