Shell Programming and Scripting

#!/bin/sh

  log=0
  # generate log
  if [ $# -gt 0 ] && [ "$1" == "-x" ]; then
    log=1;
    shift 1;
  fi

   
  # 1. Protect abbreviations:  mr.  -> {Mr::dot::}; amer. ind. -> {Amer::dot::::space::Ind::dot::}
  # 2. "Tokenize" (divide line into words and punctuation): pay attention to protected shortcuts
   

  usage()
  {
    echo "Usage: subtitles.sh [-d file] [-d file2] ... [subtitles-file] [subtitles-file2] ..."
  }

  protectAbbreviations()
  {
    while read abbrev; do
    
      protectedAbbrev=$(echo "$abbrev" | sed 's/\./::dot::/g;s/ /::space::/g');
      lookedUpAbbrev=$(echo "$abbrev" | tr "[A-Z]" "[a-z]" | sed 's/\./\\./g')
      echo 's/ '"$lookedUpAbbrev"'\([^a-zA-Z]\{1\}[^.]*\.[^.]*\)/ {'"$protectedAbbrev"'}\1 /g;' 
    
    done<'dict.shortcuts.'$$ >'dict.commands.'$$  
    
    time sed -f 'dict.commands.'$$ <'output_rgt.'$$ >'tmp.'$$
    mv 'tmp.'$$ 'output_rgt.'$$
    rm 'dict.commands.'$$           
  }

  tokenizeLine() # one line from subtitle file
  {
    line=$(echo $line | sed 's/\([,\.\!\:\|\?]\{1\}\)/ \1/g;')
  }

  fixSpacesInFile() # parameter: file; fix occurences of strings like this: " ,", " .", " :", " |", " !"
  {
    sed 's/ \([,\.\|\:\!]\)/\1/g' "$1" >'tmp.'$$
    mv 'tmp.'$$ "$1"
  }

  echo -e "" >'dict.'$$;

  while true; do

    if [ "$1" == "-d" ]; then     

      if [ "$2" == "" ]; then
        echo "No input set for a dictionary.";
        rm 'dict.'*
        usage;
        exit 1; 
      else
        cat "$2" >>'dict.'$$
        shift 2
        continue;
      fi         
    else
      break;
    fi
  done;
  
  # Everything to lowercase
  cat $@ >'subtitles2.'$$  
  cat 'subtitles2.'$$ | tr 'A-Z' 'a-z' > 'subtitles.'$$

  sed 's/\({[0-9]\{1,\}}{[0-9]\{1,\}}\).*/\1/' 'subtitles.'$$ >'output_lft.'$$ 
  sed 's/{[0-9]\{1,\}}{[0-9]\{1,\}}\(.*\)/ \1/' 'subtitles.'$$ >'output_rgt.'$$   
  
  # generate list of shortcuts to: dict.shortcuts.$$
  grep '^[^\t]\{1,\}$' 'dict.'$$ | sed 's/\t//' >'dict.shortcuts.'$$
  
   
  cat 'dict.'$$ | sed '/^[^\t]\{1,\}$/{
                                       s/\t//
                                       p
                                       }' >'dict.shortcuts.'$$

  cat 'dict.'$$ | sed '/^[^\t]\{1,\}$/ ! {
                                       p
                                       }' >'dict.new.'$$
  mv 'dict.new.'$$ 'dict.'$$    

  time protectAbbreviations # changes file output_rgt.$$    
 
  exit 1;
  # generate log - place according to where you want to start logging 
  if [ "$log" -eq 1 ]; then
    set -x;
  fi

  # generate list of names
  while read word types value1 value2 value3; do
  
    start=0
    number=2;
      
    if [ "${types:0:1}" == "?" ]; then
      start=1
      number=1  
    fi
    
    if [ "${types:$start:1}" == "s" ]; then      
      if [ "$value1" == "" ]; then  # word has standard plural form      
        echo -n -e "${word} ${number}\n${word}s 1\n"    
      elif [ "$value1" == "-" ]; then # no plural form
        echo -n -e "${word} ${number}\n"
      else
        echo -n -e "${word} ${number}\n${value2} 1\n" 
      fi                
    elif [ "${types:$start:1}" == "v" ]; then          
      if [ "$value1" == "" ]; then
        echo -n -e "${word} ${number}\n"
        echo -n -e "${word}s 2\n"
      else 
        echo -n -e "${word}\n ${number}"
        echo -n -e "${value1} 2\n${value2} 2\n${value3} 2\n"  
      fi      
    elif [ "${types:$start:1}" == "<t>" ]; then
      echo -n -e "${word} 2\n"
    fi              
  
  done<'dict.'$$ >'dict.lowerXuppercase.'$$

  varNames=$(cat 'dict.lowerXuppercase.'$$)
  
  echo '' >'log.txt'

  useCapitalLetter=1; # start of line
  
  while read line; do

    tokenizeLine    
    
    for word in $line 
    do
      
      if [ "$word" == "." ] || [ "$word" == "!" ] || [ "$word" == "?" ]; then
        useCapitalLetter=1;
        echo -n "$word ";
        continue;
      fi
      
      if [ "$useCapitalLetter" -eq 1 ]; then             
        
        if [ $(echo "${word:0:1}" | grep -c '[a-z]') -gt 0 ]; then
          echo -n "${word:0:1}" | tr '[a-z]' '[A-Z]';
          echo -n "${word:1} "
        else
          echo -n "${word} ";
        fi                             
        useCapitalLetter=0;
        continue;
      fi
      
      if [ $(echo -e "$varNames" | grep -c '^'"$word"' 1$') -gt 0 ]; then       
        echo -n "${word:0:1}" | tr '[a-z]' '[A-Z]';
        echo -n "${word:1} "         
      else       
        echo -n "$word ";        
      fi          
    done;
    
    echo "";

  done<'output_rgt.'$$ >'output_final.'$$
  
  fixSpacesInFile 'output_final.'$$
  
  cat 'output_final.'$$

  #paste -d "" 'output_lft.'$$ 'output_rgt.'$$ >'output_final'.$$

  rm 'subtitles.'$$ 'output_final.'$$ 'output_lft.'$$ 'output_rgt.'$$ 'dict.shortcuts.'$$ 'subtitles2.'$$ 'dict.lowerXuppercase.'$$ 'dict.'$$

#!/usr/bin/perl

use strict;
use warnings;

my (%dict, $keys);

open (D, "dict.shortcuts") || die "$0: Could not open dict.shortcuts: $!\n";
while (<D>)
{
    chomp;
    my $key = lc($_);
    s/\./::dot::/g;
    s/ /::space::/g;
    $dict{$key} = $_;
}
close D;
$keys = join ("|", map { quotemeta } keys %dict);

while (<>)
{
    s/^(\{\d+\}\{\d+\})// && print $1;
    y/A-Z/a-z/;
    s/($keys)/$dict{$1}/g;
    s/^(.)/\U$1/;
    s/([.!?])\s+([a-z])/$1  \U$2/g;
    s/::dot::/./g;
    s/::space::/ /g;
    print;
}