#!/bin/sh

EXPR=/bin/expr
MOUNT=/bin/mount
MKSWAP=/bin/mkswap
SWAPON=/bin/swapon

find_dev_by_type () {
    [ -z "$2" ] && \
        panic "find_dev_by_type called with too few arguments: $1, $2"
    local dev=""
    case "$2" in
        swap)
            dev=$(fdisk -l $1 | grep -i 'Linux Swap' | gawk '{print $1}')
            ;;
        ntfs)
            dev=$(fdisk -l $1 | grep -i 'NTFS' | gawk '{print $1}')
            ;;
        vfat)
            dev=$(fdisk -l $1 | grep -i 'FAT' | gawk '{print $1}')
            ;;
        ext2)
            dev=$(fdisk -l $1 | grep -i 'Linux$' | gawk '{print $1}')
            ;;
        *)
            panic "unknown filesystem searched: $2"
            ;;
    esac    
    echo $dev
}

find_fs () {
  # echoes all partitions found by given type
    [ -z "$1" ] && \
        panic "find_fs called with too few arguments: $1"
    local fstype=$1
    local found="n"
    local s=""
    local d=""
  # IDE:
    for d in a b c d e f g h i j k l; do
        if [ -e /dev/hd${d} ]; then
            s="$s $(find_dev_by_type /dev/hd${d} $fstype)"
            found="y"
        fi
    done
  # SCSI/USB
    for d in a b c d e f g h i j k l; do
        if [ -e /dev/sd${d} ]; then
            s="$s $(find_dev_by_type /dev/hd${d} $fstype)"
            found="y"
        fi
    done
    if [ "$found" = "y" ]; then 
        echo "$s"
        return 0
    else
        return -1
    fi
}

find_swap () {
    find_fs swap
}

find_ntfs () {
    find_fs ntfs
}

find_vfat () {
    find_fs vfat
}

find_ext2 () {
    find_fs ext2
}

find_part_by_label  ()
{
  # returns true/false only
    [ -z "$1" ] && \
        panic "find_part_by_label called with too few arguments: $1"
    local label=$1
    local plabel=""
    local found="n"
    local p=""

    if [ -e /dev/disk/by-label/$1 ]; then
        return 0
    fi
    for p in /dev/disk/by-id/*part* /dev/disk/by-path/*part*; do
        plabel=$(tune2fs -l $p 2>/dev/null| gawk '/Filesystem volume name:/ {print $4}')
        if [ "$label" = "$plabel" ]; then
            found="y"
            break;
        fi
    done
    if [ "$found" = "y" ]; then 
        return 0
    else
        return 1
    fi
}

kill_ext_part () {
    [ -z "$1" ] && \
        panic "kill_ext_part called with too few arguments: $1"
    local hd0dev=$1
    local i=""
    
  # get id of existing ext part
    extpart=$(sfdisk -l $hd0dev -uS 2>/dev/null| \
        gawk '/Extended/ {match($1,/^\/dev\/.*[a-z]([0-9]+)$/,a);\
                               print a[1];}')
    
  # 
    if [ -n "$extpart" ];then
        echo "DESTROYING extended partition ${extpart} as requested in 10 seconds!"
        echo "Last chance to reset!!"
        for i in 10 9 8 7 6 5 4 3 2 1 0; do
            echo -n "${i}..."
            sleep 1
        done
        fdisk $hd0dev <<EOT
d
$extpart
w
EOT
    fi
}

kill_swap_parts () {
    [ -z "$1" ] && \
        panic "kill_swap_parts called with too few arguments: $1"
    local hd0dev=$1
    local i=""
    
  # get ids of existing swap parts, largest id first
    local swapparts=$(sfdisk -l $hd0dev -uS 2>/dev/null| \
        gawk '/^\// {
                match($1,/^\/dev\/.*[a-z]([0-9]+)$/,a);
                if($2=="*") {
                        if($6=="82") print a[1];
                    } else {
                        if($5=="82") print a[1];
                    }
                    }' | sort -rn )
    
  # 
    if [ -n "$swapparts" ];then
        echo "DESTROYING all SWAP partitions (${swapparts}) as requested in 10 seconds!"
        echo "Last chance to reset!!"
        for i in 10 9 8 7 6 5 4 3 2 1 0; do
            echo -n "${i}..."
            sleep 1
        done
        for i in $swapparts; do
            fdisk $hd0dev <<EOT
d
$i
w
EOT
        done
    fi
}

kill_ext2fs_parts () {
    [ -z "$1" ] && \
        panic "kill_ext2fs_parts called with too few arguments: $1"
    local hd0dev=$1
    local i=""
    
  # get ids of existing ext2 parts, largest id first
    local ext2parts=$(sfdisk -l $hd0dev -uS 2>/dev/null| \
        gawk '/^\// {
                match($1,/^\/dev\/.*[a-z]([0-9]+)$/,a);
                if($2=="*") {
                        if($6=="83") print a[1];
                    } else {
                        if($5=="83") print a[1];
                    }
                    }' | sort -rn )
    
  # 
    if [ -n "$ext2parts" ];then
        echo "DESTROYING all uniklUbuntix EXT2FS partitions (${ext2parts}) as requested in 10 seconds!"
        echo "Last chance to reset!!"
        for i in 10 9 8 7 6 5 4 3 2 1 0; do
            echo -n "${i}..."
            sleep 1
        done
        for i in $ext2parts; do
            l=$(tune2fs -l $hd0dev$i 2>/dev/null| gawk '/Filesystem volume name:/ {print $4}')
            if [ "$l" = "UNIKLU" -o "$l" = "VAR" -o "$l" = "AFSCACHE" ]; then
                fdisk $hd0dev <<EOT
d
$i
w
EOT
            fi
        done
    fi
}

kill_all_parts () {
    [ -z "$1" ] && \
        panic "kill_all_parts called with too few arguments: $1"
    local hd0dev=$1
    echo "DESTROYING partition table on $hd0dev as requested in 10 seconds!"
    echo "Last chance to reset!!"
    for i in 10 9 8 7 6 5 4 3 2 1 0; do
        echo -n "${i}..."
        sleep 1
    done
    fdisk $hd0dev <<EOT
o
w
EOT
}

find_hd0 () {
  # determine bios drive 0x80 via grub:
    grub --no-curses >/tmp/hd0 <<EOT
geometry (hd0)
quit
EOT
  local hd0dev=$(gawk '/drive 0x80/ {print $12}' /tmp/hd0)
  if [ -z "${hd0dev}" ]; then
      panic "could not determine BIOS drive 0x80! reset now or risc damage!"
  else
      echo $hd0dev
  fi
}

auto_partition () {
    [ -z "$1" ] && \
        panic "auto_partition called with too few arguments: $1"

    TARGET=$1
   
    P1SIZE=0
    P2SIZE=0
    P3SIZE=0
    P4SIZE=0
 
    hd0dev=$(find_hd0)
    _log_msg "found ${hd0dev} as BIOS drive 0x80."
    
    echo initialize_part_if_necessary
    initialize_part_if_necessary $hd0dev
    echo get_part_sizes
    SECTORSIZE=0
    SECTORNUMBER=0
    USEDPARTS=0
    eval $(get_part_sizes $hd0dev)

    echo check_or_create_ext_part
    EXTPART=0
    EXTPART_LASTSECTOR=0
    check_or_create_ext_part $hd0dev
    echo get_ext_part_sectors
    LASTPART=0
    LASTSECTOR=0
    EXTPART_FIRSTSECTOR=0
    eval $(get_ext_part_sectors $hd0dev)

  # get remaining sectors at end of ext. partition:
    echo ${EXPR} $EXTPART_LASTSECTOR - $LASTSECTOR - 1 
    REMSECTORS=$(${EXPR} $EXTPART_LASTSECTOR - $LASTSECTOR - 1 )
  # in bytes:
    echo ${EXPR} $REMSECTORS \* $SECTORSIZE 
    REMBYTES=$(${EXPR} $REMSECTORS \* $SECTORSIZE )

    # MINSIZE, MAXSIZE, SWAPSIZE, CACHESIZE are in MB from here on
    # CMD line parameters are GB with decimals, so use bc -l !!
    if [ "$TARGET" = "install" ]; then
    # determine needed sizes
    if  [ -z "$MINSIZE" ]; then
      MINSIZE=$(${EXPR} 20 \* 1024)
    else
      MINSIZE=$(echo $MINSIZE \* 1024 | bc -l) 
      MINSIZE=${MINSIZE%%.*}
    fi
    if [ -z "$CACHESIZE" ]; then
      CACHESIZE=500
    else
      CACHESIZE=$(echo $CACHESIZE \* 1024 | bc -l)
      CACHESIZE=${CACHESIZE%%.*}
    fi

    # no swap needed if already found:
    if  [ -n "$SWAP"  ]; then
      SWAPSIZE=0
    else
        if [ -z "$SWAPSIZE" ]; then
           SWAPSIZE=$(${EXPR} 2 \* 1024)
        else 
           SWAPSIZE=$(echo $SWAPSIZE \* 1024 | bc -l)
           SWAPSIZE=${SWAPSIZE%%.*}
        fi
    fi

    if [ "$(${EXPR} $REMBYTES \< \(  \( $MINSIZE + $SWAPSIZE + $CACHESIZE \) \* 1024 \* 1024  \) )" = "1" ]; then
        echo "EXTPART_FIRSTSECTOR: $EXTPART_FIRSTSECTOR"
        echo "EXTPART_LASTSECTOR:  $EXTPART_LASTSECTOR"
        echo "LASTSECTOR:          $LASTSECTOR"
        echo "LASTPART:            $LASTPART"
        echo "REMSECTORS:          $REMSECTORS"
        echo "REMBYTES:            $REMBYTES"
        echo "SECTORSIZE:          $SECTORSIZE"
        if [ "$(${EXPR} $REMBYTES \>  \( 1 \* 1024  \* 1024 \* 1024 \) )" = "1" ]; then 
            echo "reducing swap size to 1GB < $REMBYTES"
            SWAPSIZE=$(${EXPR} 1 \* 1024)
        else
            panic "not enough (swap) space: $REMBYTES"
        fi
    fi

    # setup partition sizes, use max MAXSIZE G + SWAPSIZE G + 500M AFSCACHE
        if  [ -z "$MAXSIZE" -o "$(${EXPR} $MAXSIZE \< $MINSIZE )" = "1" ]; then
            MAXSIZE=$(${EXPR} 30 \* 1024)
        else
          MAXSIZE=$(echo $MAXSIZE \* 1024 | bc -l) 
          MAXSIZE=${MAXSIZE%%.*}
        fi 
        
        if [ "$(${EXPR} $REMBYTES \> \( \( $MAXSIZE + $SWAPSIZE + $CACHESIZE \) \* 1024 \* 1024 \) )" = "1" ]; then
        # enough space, check also for LOCAL partition
            P1SIZE=$(${EXPR} \( $MAXSIZE \* 1024 \* 1024 \) / $SECTORSIZE + 1 )
            P2SIZE=$(${EXPR} \( $CACHESIZE \* 1024 \* 1024 \) / $SECTORSIZE + 1 )
            if  [ "$SWAPSIZE" -gt 0  ]; then
                P3SIZE=$(${EXPR} \( $SWAPSIZE \* 1024 \* 1024 \) / $SECTORSIZE + 1 )
            else 
                P3SIZE=0
            fi
            if [ -n "$LOCALSIZE" ]; then
               if [ "$LOCALSIZE" = "max" ]; then
                  P4SIZE=$(${EXPR} $REMBYTES - \( \( $MAXSIZE + $SWAPSIZE + $CACHESIZE \) \* 1024 \* 1024 \) ) 
               else 
                  LOCALSIZE=$(echo $LOCALSIZE \* 1024 | bc -l)
                  LOCALSIZE=${LOCALSIZE%%.*}
                  P4SIZE=$(${EXPR} $LOCALSIZE \* 1024 \* 1024 ) 
                  P4MAXSIZE=$(${EXPR} $REMBYTES - \( \( $MAXSIZE + $SWAPSIZE + $CACHESIZE \) \* 1024 \* 1024 \) ) 
                  if [ "$(${EXPR} $P4SIZE \> $P4MAXSIZE)" = "1" ]; then
                     P4SIZE=$P4MAXSIZE
                  fi
               fi
               # litlle bit smaller:
               P4SIZE=$(${EXPR} $P4SIZE / $SECTORSIZE - 1024 )
            fi
        else
        # only something between MINSIZE and MAXSIZE useable
            P1SIZE=$(${EXPR} $REMSECTORS - \( \( $SWAPSIZE + $CACHESIZE \)  \* 1024 \* 1024 \) / $SECTORSIZE )
            P2SIZE=$(${EXPR} \( $CACHESIZE \* 1024 \* 1024 \) / $SECTORSIZE + 1 )
            if  [ "$SWAPSIZE" -gt 0  ]; then
                P3SIZE=$(${EXPR} \( $REMSECTORS - $P1SIZE - $P2SIZE \) )
            else 
                P3SIZE=0
            fi
        fi
        P1START=$(${EXPR} $LASTSECTOR + 1 ) 
        P2START=$(${EXPR} $LASTSECTOR + 1 + $P1SIZE )
        P3START=$(${EXPR} $LASTSECTOR + 1 + $P1SIZE  + $P2SIZE )
        P4START=$(${EXPR} $LASTSECTOR + 1 + $P1SIZE  + $P2SIZE + $P3SIZE )
        P1PART=$(${EXPR} $LASTPART + 1 )
        P2PART=$(${EXPR} $LASTPART + 2 )
        P3PART=$(${EXPR} $LASTPART + 3 )
        P4PART=$(${EXPR} $LASTPART + 4 )
        if [ "$SWAPSIZE" -eq 0 ]; then
          P4PART=$(${EXPR} $LASTPART + 3 )
        fi
    # write existing partitions into sfdisk script
        sfdisk -d $hd0dev -uS 2>/dev/null >  /tmp/sfdisk.script
    # append our 2 partitions to sfdisk script
        echo "${hd0dev}$P1PART : start= $P1START, size= $P1SIZE, Id= 83" >> /tmp/sfdisk.script
        _log_msg "will use partition $P1PART with $P1SIZE sectors as ext3 for root file system"
        echo "${hd0dev}$P2PART : start= $P2START, size= $P2SIZE, Id= 83" >> /tmp/sfdisk.script
        _log_msg "will use partition $P2PART with $P2SIZE sectors as ext2 for AFS cache"
        if  [ "$SWAPSIZE" -gt 0  ]; then
            echo "${hd0dev}$P3PART : start= $P3START, size= $P3SIZE, Id= 82" >> /tmp/sfdisk.script
            _log_msg "will use partition $P3PART with $P3SIZE sectors as swap"
        fi
        if  [ "$P4SIZE" -gt 0  ]; then
            echo "${hd0dev}$P4PART : start= $P4START, size= $P4SIZE, Id= 83" >> /tmp/sfdisk.script
            _log_msg "will use partition $P4PART with $P4SIZE sectors as ext3 for /local"
        fi
    fi

    # debug:
    if [ -n "$break" ]; then
        echo "USEDPARTS:  ${USEDPARTS}"
        echo "NOTEMPTY:   ${NOTEMPTY}"
        echo "EXTPART:    ${EXTPART}"
        echo "LASTPART:   ${LASTPART}"
        echo "LASTSECTOR: ${LASTSECTOR}"
        echo "REMSECTORS: ${REMSECTORS}"
        echo "REMBYTES:   ${REMBYTES}"
        echo "SECTORSIZE: ${SECTORSIZE}"
        panic "about to apply /tmp/sfdisk.script to $hd0dev"
    fi

  # ensure disk is offline:
  swapoff -a
  /bin/umount /target
  # backup old table
    sfdisk -d $hd0dev > /tmp/hd0.old

  # install new partition table, good luck ;-)
    sfdisk --force $hd0dev < /tmp/sfdisk.script

  #force partition table reread
  partprobe
  sleep 5
  partprobe
  if [ -n "$break" ]; then
    panic "after partprobe"
  fi
#    for b in /sys/class/scsi_host/host?/scan; do
#      echo "- - -" > $b
#    done

  # format (ext3, swap, ext2)

    _log_msg "now formatting ..."

    if [ "$TARGET" = "install" ]; then
        MKFSFAILED=""
        mkfs.ext3 -L UNIKLU ${hd0dev}$P1PART || MKFSFAILED="yes"
        if [ "$MKFSFAILED" = "yes" ]; then
          sleep 5
          partprobe
          echo "retry formatting ..."
          MKFSFAILED=""
          mkfs.ext3 -L UNIKLU ${hd0dev}$P1PART || MKFSFAILED="yes"
          if [ "$MKFSFAILED" = "yes" ]; then
            sleep 5
            partprobe
            echo "retry formatting ..."
            MKFSFAILED=""
            mkfs.ext3 -L UNIKLU ${hd0dev}$P1PART || MKFSFAILED="yes"
            if [ "$MKFSFAILED" = "yes" ]; then
              panic "mkfs failed three times?"
              echo "retry once more ..."
              mkfs.ext3 -L UNIKLU ${hd0dev}$P1PART || MKFSFAILED="yes"
            fi
          fi
        fi
        # let udev scan for new filesystem labels
        /sbin/udevadm trigger
        if [ -n "$break" ]; then
          panic "after mkfs.ext3"
        fi
        mkfs.ext2 -L AFSCACHE ${hd0dev}$P2PART
        # let udev scan for new filesystem labels
        /sbin/udevadm trigger
        if [ -n "$break" ]; then
          panic "after mkfs.ext2"
        fi

        if  [ "$P4SIZE" -gt 0  ]; then
          mkfs.ext3 -L LOCAL ${hd0dev}$P4PART
          # let udev scan for new filesystem labels
          /sbin/udevadm trigger
          if [ -n "$break" ]; then
            panic "after mkfs.ext2"
          fi
        fi

        if  [ "$SWAPSIZE" -gt 0  ]; then
          ${MKSWAP} -L SWAP     ${hd0dev}$P3PART
          # let udev scan for new filesystem labels
          /sbin/udevadm trigger
          if [ -n "$break" ]; then
            panic "after mkswap"
          fi
        fi
    fi
    # let udev scan for new filesystem labels
    /sbin/udevadm trigger

    _log_msg "Done."
}

initialize_part_if_necessary () {
    hd0dev=$1
   # check for unpartitioned disk
   # and write a new label:
    fdisk -l $hd0dev 2>&1| grep "t contain a valid" > /dev/null && \
        fdisk $hd0dev <<EOT
o
w
EOT
    fdisk -l $hd0dev 2>&1| grep "No partitions found" > /dev/null && \
        fdisk $hd0dev <<EOT
o
w
EOT
}

get_part_sizes () {
  # to be called via eval, echoes SECTORSIZE, SECTORNUMBER, USEDPARTS
    local hd0dev=$1
  # get sector size (bytes)
    local SECTORSIZE=$(sfdisk -l $hd0dev -uS 2>/dev/null| gawk '/Units = sectors/{print $5}')
  # get number of sectors
    if [ -z "$SECTORSIZE" ]; then
        panic "# could not get SECTORSIZE"
    fi
    local SECTORNUMBER=$(sfdisk -l $hd0dev -uS 2>/dev/null| gawk '/sectors\/track/{print $3*$5*$7}')
    if [ -z "$SECTORNUMBER:" ]; then
        panic "# could not get SECTORNUMBER:"
    fi

  # get used primary partitions
    local NOTEMPTY=$(sfdisk -l $hd0dev -uS 2>/dev/null| grep ^/dev/ | gawk '!/Empty/{print $1}')
  # find partitions in use
    local USEDPARTS=""
    for i in $NOTEMPTY; do
        USEDPARTS="$USEDPARTS $i"
    done
    echo "SECTORSIZE=$SECTORSIZE"
    echo "SECTORNUMBER=$SECTORNUMBER"
    echo "USEDPARTS=\"$USEDPARTS\""
}

check_or_create_ext_part () {
    hd0dev=$1
    EXTPART=0
  # check for extended partition
    EXTPART_LASTSECTOR=$(sfdisk -l $hd0dev -uS 2>/dev/null| grep ^/dev/ | gawk '/Extended/{print $4}')
    if [ -z "$EXTPART_LASTSECTOR" ]; then
        for i in ${hd0dev}1 ${hd0dev}2 ${hd0dev}3 ${hd0dev}4;do
            case $USEDPARTS in
                *$i*)
        #skip
;;
*)
if [ "$EXTPART" = "0" ]; then
           # create an extended partition:
    EXTPART=${i#${hd0dev}}
    _log_msg "# will use partition $i for extended partition"
    if [ -n "$INTERACTIVE" ]; then
        echo "USEDPARTS:  ${USEDPARTS}"
        echo "NOTEMPTY:   ${NOTEMPTY}"
        echo "EXTPART:    ${EXTPART}"
        echo "SECTORSIZE: ${SECTORSIZE}"
        panic "about to create partition $i of $hd0dev as extended partition"
    fi
    fdisk $hd0dev <<EOT
n
e
$EXTPART


w
EOT
fi
;;
esac
done
else
     # get id of existing ext part
EXTPART=$(sfdisk -l $hd0dev -uS 2>/dev/null| gawk '/Extended/ {match($1,/^\/dev\/.*[a-z]([0-9]+)$/,a);print a[1];}')
fi
  # exit on error:
if [ "$EXTPART" = "0" ];then
    panic "could not create an extended partition! reset now or risc damage!"
fi
}

get_ext_part_sectors () {
    hd0dev=$1
  # now get first + last sector of ext part:
    eval $(sfdisk -l $hd0dev -uS 2>/dev/null| grep ^/dev/ | \
        gawk '/Extended/ {print "EXTPART_LASTSECTOR="$3,"EXTPART_FIRSTSECTOR="$2;}')
    if [ -z "$EXTPART_LASTSECTOR" ]; then
        dropshell "could not get EXTPART_LASTSECTOR"
    fi
  # get last used sector in ext part:
    eval $(sfdisk -l $hd0dev -uS 2>/dev/null|                                         \
        gawk 'BEGIN {lastsector=0;lastpart=0}                      \
        /^\/dev\// { match($1,/^\/dev\/.*[a-z]([0-9]+)$/,a); \
        partnr=a[1];                            \
        if(partnr>4)                            \
        if(lastsector<$3)                      \
        {lastsector=$3; lastpart=partnr}     \
        }                                        \
        END {print "LASTSECTOR="lastsector";LASTPART="lastpart}')
    if [ "$LASTSECTOR" = "0" ]; then
        LASTSECTOR=$(${EXPR} $EXTPART_FIRSTSECTOR + 63 )
    fi
    if [ "$LASTPART" = "0" ]; then
        LASTPART=4
    fi
    echo "LASTSECTOR=$LASTSECTOR LASTPART=$LASTPART EXTPART_LASTSECTOR=$EXTPART_LASTSECTOR EXTPART_FIRSTSECTOR=$EXTPART_FIRSTSECTOR"
}

parse_partitions() {
# to be called via eval, echoes variables EXT2, WIN and SWAP
# put TARGET partition as no 1:
    TARGETDEV=$(${MOUNT} | grep "$TARGET" | \
        gawk '/ext3/ {print $1}'| sort | uniq)
    if [ -n "$TARGETDEV" ]; then
        EXT2="$TARGETDEV"
    else
        EXT2=""
    fi
    SWAP=""
    WIN=""
    # determine bios drive 0x80:
    hd0dev=$(find_hd0)
    if [ -n "$hd0dev" ]; then
        fdisk=$(fdisk -l $hd0dev)
        PARTS_NTFS=$(find_ntfs_dev $hd0dev)
        PARTS_FAT=$(find_fat_dev $hd0dev)
        if  [ -z "${WIN}"  ]; then
            if  [ -z "$PARTS_NTFS"  ]; then 
                WIN="$PARTS_FAT"
            else
                WIN="$PARTS_NTFS $PARTS_FAT"
            fi
        else
            WIN="${WIN} $PARTS_NTFS $PARTS_FAT"
        fi
      # create an array Variable
        if [ -n "$TARGETDEV" ]; then 
        # skip TARGETDEV:
            PARTS=$(find_ext2_dev $hd0dev | sed -e "s#$TARGETDEV##g")
        else
            PARTS=$(find_ext2_dev $hd0dev)
        fi
        if  [ -z "${EXT2}"  ]; then
            EXT2="$PARTS"
        else
            EXT2="${EXT2} $PARTS"
        fi
      # create an array Variable
      # swap is now called Linux swap / Solaris !!
      PARTS=$(find_swap_dev $hd0dev)
      if  [ -z "${SWAP}"  ]; then
        SWAP="$PARTS"
      else
        SWAP="${SWAP} $PARTS"
      fi
    fi
    echo "EXT2=\"$EXT2\""
    echo "WIN=\"$WIN\""
    echo "SWAP=\"$SWAP\""
}


#
# /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */ 
#
# (modify-all-frames-parameters '((font . "Courier-14"))) 
#
