Remove unnecessary typedefs in third_party/fips181.

third_party/fips181/fips181.cc

 /*
 ** This module uses code from the NIST implementation of  FIPS-181,
 ** but the algorythm is CHANGED and I think that I CAN
 ** copyright it. See copiright notes below.
 */
 
 /*
 ** Copyright (c) 1999, 2000, 2001, 2002, 2003
 ** Adel I. Mirzazhanov. All rights reserved
 **
@@ skipping 32 matching lines @@
 #include <time.h>
 #include <sys/types.h>
 #include "base/rand_util.h"
 #include "fips181.h"
 #include "randpass.h"
 #include "convert.h"
 
 struct unit
 {
     char    unit_code[5];
-    USHORT  flags;
+    unsigned short  flags;
 };
 
 static struct unit  rules[] =
 {   {"a", VOWEL},
     {"b", NO_SPECIAL_RULE},
     {"c", NO_SPECIAL_RULE},
     {"d", NO_SPECIAL_RULE},
     {"e", NO_FINAL_SPLIT | VOWEL},
     {"f", NO_SPECIAL_RULE},
     {"g", NO_SPECIAL_RULE},
@@ skipping 1184 matching lines @@
      /* ckwh */ ILLEGAL_PAIR,
      /* ckqu */ NOT_BEGIN | BREAK | NOT_END,
      /* ckck */ ILLEGAL_PAIR}
 };
 
 /*
 ** gen_pron_pass will generate a Random word and place it in the
 ** buffer word.  Also, the hyphenated word will be placed into
 ** the buffer hyphenated_word.  Both word and hyphenated_word must
 ** be pre-allocated.  The words generated will have sizes between
-** minlen and maxlen.  If restrict is TRUE, words will not be generated that
+** minlen and maxlen.  If restrict is true, words will not be generated that
 ** appear as login names or as entries in the on-line dictionary.
 ** This algorithm was initially worded out by Morrie Gasser in 1975.
 ** Any changes here are minimal so that as many word combinations
 ** can be produced as possible (and thus keep the words Random).
 ** The seed is used on first use of the routine.
 ** The length of the unhyphenated word is returned, or -1 if there
 ** were an error (length settings are wrong or dictionary checking
 ** could not be done.
 */
 int
-gen_pron_pass (char *word, char *hyphenated_word, USHORT minlen,
-               USHORT maxlen, unsigned int pass_mode)
+gen_pron_pass (char *word, char *hyphenated_word, unsigned short minlen,
+               unsigned short maxlen, unsigned int pass_mode)
 {
 
     int     pwlen;
 
  /* 
   * Check for minlen>maxlen.  This is an error.
   * and a length of 0.
   */
     if (minlen > maxlen || minlen > APG_MAX_PASSWORD_LENGTH ||
         maxlen > APG_MAX_PASSWORD_LENGTH)
@@ skipping 21 matching lines @@
 /*
  * This is the routine that returns a Random word -- as
  * yet unchecked against the passwd file or the dictionary.
  * It collects Random syllables until a predetermined
  * word length is found.  If a retry threshold is reached,
  * another word is tried.  Given that the Random number
  * generator is uniformly distributed, eventually a word
  * will be found if the retry limit is adequately large enough.
  */
 int
-gen_word (char *word, char *hyphenated_word, USHORT pwlen, unsigned int pass_mode)
+gen_word (char *word, char *hyphenated_word, unsigned short pwlen, unsigned int pass_mode)
 {
-    USHORT word_length;
-    USHORT syllable_length;
+    unsigned short word_length;
+    unsigned short syllable_length;
     char   *new_syllable;
     char   *syllable_for_hyph;
-    USHORT *syllable_units;
-    USHORT word_size;
-    USHORT word_place;
-    USHORT *word_units;
-    USHORT syllable_size;
-    UINT   tries;
-    int ch_flag = FALSE;
+    unsigned short *syllable_units;
+    unsigned short word_size;
+    unsigned short word_place;
+    unsigned short *word_units;
+    unsigned short syllable_size;
+    unsigned int   tries;
+    bool ch_flag = false;
     int dsd = 0;
 
     /*
      * Keep count of retries.
      */
     tries = 0;
 
     /*
      * The length of the word in characters.
      */
     word_length = 0;
 
     /*
      * The length of the word in character units (each of which is one or
      * two characters long.
      */
     word_size = 0;
 
     /*
      * Initialize the array storing the word units.  Since we know the
      * length of the word, we only need one of that length.  This method is
      * preferable to a static array, since it allows us flexibility in
      * choosing arbitrarily long word lengths.  Since a word can contain one
      * syllable, we should make syllable_units, the array holding the
      * analogous units for an individual syllable, the same length. No
      * explicit rule limits the length of syllables, but digram rules and
      * heuristics do so indirectly.
      */
-    if ( (word_units     = (USHORT *) calloc (sizeof (USHORT), pwlen+1))==NULL ||
-         (syllable_units = (USHORT *) calloc (sizeof (USHORT), pwlen+1))==NULL ||
-         (new_syllable   = (char *) calloc (sizeof (USHORT), pwlen+1))  ==NULL ||
+    if ( (word_units     = (unsigned short *) calloc (sizeof (unsigned short), pwlen+1))==NULL ||
+         (syllable_units = (unsigned short *) calloc (sizeof (unsigned short), pwlen+1))==NULL ||
+         (new_syllable   = (char *) calloc (sizeof (unsigned short), pwlen+1))  ==NULL ||
          (syllable_for_hyph = (char *) calloc (sizeof(char), 20))==NULL)
            return(-1);
 
     /*
      * Find syllables until the entire word is constructed.
      */
     while (word_length < pwlen)
     {
      /*
       * Get the syllable and find its length.
       */
      (void) gen_syllable (new_syllable, pwlen - word_length, syllable_units, &syllable_size);
-     syllable_length = (USHORT) strlen (new_syllable);
+     syllable_length = (unsigned short) strlen (new_syllable);
      
      /*
       * Append the syllable units to the word units.
       */
      for (word_place = 0; word_place <= syllable_size; word_place++)
          word_units[word_size + word_place] = syllable_units[word_place];
      word_size += syllable_size + 1;
 
      /* 
       * If the word has been improperly formed, throw out
@@ skipping 13 matching lines @@
          if (word_length == 0)
          {
           /*
           ** Modify syllable for numeric or capital symbols required
           ** Should be done after word quality check. 
           */
           dsd = base::RandInt(0, 1);
           if ( ((pass_mode & S_NB) > 0) && (syllable_length == 1) && dsd == 0)
             {
              numerize(new_syllable);
-             ch_flag = TRUE;
+             ch_flag = true;
             }
           if ( ((pass_mode & S_SS) > 0) && (syllable_length == 1) && (dsd == 1))
             {
               specialize(new_syllable);
-              ch_flag = TRUE;
+              ch_flag = true;
             }
-          if ( ( (pass_mode & S_CL) > 0) && (ch_flag != TRUE))
+          if ( ( (pass_mode & S_CL) > 0) && (ch_flag != true))
              capitalize(new_syllable);
-          ch_flag = FALSE;
+          ch_flag = false;
           /**/
           (void) strcpy (word, new_syllable);
           if (syllable_length == 1)
              {
               symb2name(new_syllable, syllable_for_hyph);
               (void) strcpy (hyphenated_word, syllable_for_hyph);
              }
           else
              {
               (void) strcpy (hyphenated_word, new_syllable);
              }
-          (void)memset ( (void *)new_syllable, 0, (size_t)(pwlen * sizeof(USHORT)+1));
+          (void)memset ( (void *)new_syllable, 0, (size_t)(pwlen * sizeof(unsigned short)+1));
           (void)memset ( (void *)syllable_for_hyph, 0, 20);
          }
          else
          {
           /*
           ** Modify syllable for numeric or capital symbols required
           ** Should be done after word quality check.
           */
           dsd = base::RandInt(0, 1);
           if ( ((pass_mode & S_NB) > 0) && (syllable_length == 1) && (dsd == 0))
             {
              numerize(new_syllable);
-             ch_flag = TRUE;
+             ch_flag = true;
             }
           if ( ( (pass_mode & S_SS) > 0) && (syllable_length == 1) && (dsd == 1))
             {
              specialize(new_syllable);
-             ch_flag = TRUE;
+             ch_flag = true;
             }
-          if ( ( (pass_mode & S_CL) > 0) && (ch_flag != TRUE))
+          if ( ( (pass_mode & S_CL) > 0) && (ch_flag != true))
              capitalize(new_syllable);
-          ch_flag = FALSE;
+          ch_flag = false;
           /**/
           (void) strcat (word, new_syllable);
           (void) strcat (hyphenated_word, "-");
           if (syllable_length == 1)
              {
               symb2name(new_syllable, syllable_for_hyph);
               (void) strcat (hyphenated_word, syllable_for_hyph);
              }
           else
              {
               (void) strcat (hyphenated_word, new_syllable);
              }
-          (void)memset ( (void *)new_syllable, 0, (size_t)(pwlen * sizeof(USHORT)+1));
+          (void)memset ( (void *)new_syllable, 0, (size_t)(pwlen * sizeof(unsigned short)+1));
           (void)memset ( (void *)syllable_for_hyph, 0, 20);
          }
          word_length += syllable_length;
      }
 
        /* 
         * Keep track of the times we have tried to get
         * syllables.  If we have exceeded the threshold,
         * reinitialize the pwlen and word_size variables, clear
         * out the word arrays, and start from scratch.
@@ skipping 27 matching lines @@
 /*
  * Check that the word does not contain illegal combinations
  * that may span syllables.  Specifically, these are:
  *   1. An illegal pair of units between syllables.
  *   2. Three consecutive vowel units.
  *   3. Three consecutive consonant units.
  * The checks are made against units (1 or 2 letters), not against
  * the individual letters, so three consecutive units can have
  * the length of 6 at most.
  */
-boolean
-improper_word (USHORT *units, USHORT word_size)
+bool
+improper_word (unsigned short *units, unsigned short word_size)
 {
-    USHORT unit_count;
-    boolean failure;
+    unsigned short unit_count;
+    bool failure;
 
-    failure = FALSE;
+    failure = false;
 
     for (unit_count = 0; !failure && (unit_count < word_size);
          unit_count++)
     {
      /* 
       * Check for ILLEGAL_PAIR.  This should have been caught
       * for units within a syllable, but in some cases it
       * would have gone unnoticed for units between syllables
       * (e.g., when saved_unit's in gen_syllable() were not
       * used).
       */
      if ((unit_count != 0) &&
           (digram[units[unit_count - 1]][units[unit_count]] &
               ILLEGAL_PAIR))
-         failure = TRUE;
+         failure = true;
 
      /* 
       * Check for consecutive vowels or consonants.  Because
       * the initial y of a syllable is treated as a consonant
       * rather than as a vowel, we exclude y from the first
       * vowel in the vowel test.  The only problem comes when
       * y ends a syllable and two other vowels start the next,
       * like fly-oint.  Since such words are still
       * pronounceable, we accept this.
       */
      if (!failure && (unit_count >= 2))
      {
          /*
           * Vowel check.
           */
          if ((((rules[units[unit_count - 2]].flags & VOWEL) &&
                    !(rules[units[unit_count - 2]].flags &
                     ALTERNATE_VOWEL)) &&
                (rules[units[unit_count - 1]].flags & VOWEL) &&
                (rules[units[unit_count]].flags & VOWEL)) ||
          /*
           * Consonant check.
           */
               (!(rules[units[unit_count - 2]].flags & VOWEL) &&
                !(rules[units[unit_count - 1]].flags & VOWEL) &&
                !(rules[units[unit_count]].flags & VOWEL)))
-          failure = TRUE;
+          failure = true;
      }
     }
 
     return (failure);
 }
 
 
 /*
  * Treating y as a vowel is sometimes a problem.  Some words
  * get formed that look irregular.  One special group is when
  * y starts a word and is the only vowel in the first syllable.
  * The word ycl is one example.  We discard words like these.
  */
-boolean
-have_initial_y (USHORT *units, USHORT unit_size)
+bool
+have_initial_y (unsigned short *units, unsigned short unit_size)
 {
-    USHORT unit_count;
-    USHORT vowel_count;
-    USHORT normal_vowel_count;
+    unsigned short unit_count;
+    unsigned short vowel_count;
+    unsigned short normal_vowel_count;
 
     vowel_count = 0;
     normal_vowel_count = 0;
 
     for (unit_count = 0; unit_count <= unit_size; unit_count++)
      /*
       * Count vowels.
       */
      if (rules[units[unit_count]].flags & VOWEL)
      {
@@ skipping 12 matching lines @@
 }
 
 
 /*
  * Besides the problem with the letter y, there is one with
  * a silent e at the end of words, like face or nice.  We
  * allow this silent e, but we do not allow it as the only
  * vowel at the end of the word or syllables like ble will
  * be generated.
  */
-boolean
-have_final_split (USHORT *units, USHORT unit_size)
+bool
+have_final_split (unsigned short *units, unsigned short unit_size)
 {
-    USHORT unit_count;
-    USHORT vowel_count;
+    unsigned short unit_count;
+    unsigned short vowel_count;
 
     vowel_count = 0;
 
     /*
      *    Count all the vowels in the word.
      */
     for (unit_count = 0; unit_count <= unit_size; unit_count++)
      if (rules[units[unit_count]].flags & VOWEL)
          vowel_count++;
 
     /*
-     * Return TRUE iff the only vowel was e, found at the end if the
+     * Return true iff the only vowel was e, found at the end if the
      * word.
      */
     return ((vowel_count == 1) &&
          (rules[units[unit_size]].flags & NO_FINAL_SPLIT));
 }
 
 
 /*
  * Generate next unit to password, making sure that it follows
  * these rules:
@@ skipping 23 matching lines @@
  *           or in "end" pair.
  *        e. "not_begin" pair generated but new syllable must
  *           begin (because previous syllable ended as defined in
  *           2 above).
  *        f. vowel is generated and 2a is satisfied, but no syllable
  *           break is possible in previous 3 pairs.
  *        g. Second and third units of syllable must begin, and
  *           first unit is "alternate_vowel".
  */
 char *
-gen_syllable (char *syllable, USHORT pwlen, USHORT *units_in_syllable,
-              USHORT *syllable_length)
+gen_syllable (char *syllable, unsigned short pwlen, unsigned short *units_in_syllable,
+              unsigned short *syllable_length)
 {
-    USHORT  unit = 0;
-    SHORT   current_unit = 0;
-    USHORT  vowel_count = 0;
-    boolean rule_broken;
-    boolean want_vowel;
-    boolean want_another_unit;
-    UINT    tries = 0;
-    USHORT  last_unit = 0;
-    SHORT   length_left = 0;
-    USHORT  hold_saved_unit = 0;
-    static  USHORT saved_unit;
-    static  USHORT saved_pair[2];
+    unsigned short  unit = 0;
+    short   current_unit = 0;
+    unsigned short  vowel_count = 0;
+    bool rule_broken;
+    bool want_vowel;
+    bool want_another_unit;
+    unsigned int    tries = 0;
+    unsigned short  last_unit = 0;
+    short   length_left = 0;
+    unsigned short  hold_saved_unit = 0;
+    static  unsigned short saved_unit;
+    static  unsigned short saved_pair[2];
 
     /*
      * This is needed if the saved_unit is tries and the syllable then
      * discarded because of the retry limit. Since the saved_unit is OK and
      * fits in nicely with the preceding syllable, we will always use it.
      */
     hold_saved_unit = saved_unit;
 
     /*
      * Loop until valid syllable is found.
      */
     do
     {
      /* 
       * Try for a new syllable.  Initialize all pertinent
       * syllable variables.
       */
      tries = 0;
      saved_unit = hold_saved_unit;
      (void) strcpy (syllable, "");
      vowel_count = 0;
      current_unit = 0;
      length_left = (short int) pwlen;
-     want_another_unit = TRUE;
+     want_another_unit = true;
 
      /*
       * This loop finds all the units for the syllable.
       */
      do
      {
-         want_vowel = FALSE;
+         want_vowel = false;
 
          /*
           * This loop continues until a valid unit is found for the
           * current position within the syllable.
           */
          do
          {
           /* 
            * If there are saved_unit's from the previous
            * syllable, use them up first.
@@ skipping 40 matching lines @@
               if (want_vowel)
                unit = random_unit (VOWEL);
               else
                unit = random_unit (NO_SPECIAL_RULE);
           length_left -= (short int) strlen (rules[unit].unit_code);
 
           /*
            * Prevent having a word longer than expected.
            */
           if (length_left < 0)
-              rule_broken = TRUE;
+              rule_broken = true;
           else
-              rule_broken = FALSE;
+              rule_broken = false;
 
           /*
            * First unit of syllable.  This is special because the
            * digram tests require 2 units and we don't have that yet.
            * Nevertheless, we can perform some checks.
            */
           if (current_unit == 0)
           {
               /* 
                * If the shouldn't begin a syllable, don't
                * use it.
                */
               if (rules[unit].flags & NOT_BEGIN_SYLLABLE)
-               rule_broken = TRUE;
+               rule_broken = true;
               else
                /* 
                 * If this is the last unit of a word,
                 * we have a one unit syllable.  Since each
                 * syllable must have a vowel, we make sure
                 * the unit is a vowel.  Otherwise, we
                 * discard it.
                 */
                if (length_left == 0)
                   {
                    if (rules[unit].flags & VOWEL)
-                    want_another_unit = FALSE;
+                    want_another_unit = false;
                    else
-                    rule_broken = TRUE;
+                    rule_broken = true;
                   }
           }
           else
           {
               /* 
                * There are some digram tests that are
                * universally true.  We test them out.
                */
 
               /*
                * Reject ILLEGAL_PAIRS of units.
                */
               if ((ALLOWED (ILLEGAL_PAIR)) ||
 
               /*
                * Reject units that will be split between syllables
                * when the syllable has no vowels in it.
                */
                    (ALLOWED (BREAK) && (vowel_count == 0)) ||
 
               /*
                * Reject a unit that will end a syllable when no
                * previous unit was a vowel and neither is this one.
                */
                    (ALLOWED (END) && (vowel_count == 0) &&
                     !(rules[unit].flags & VOWEL)))
-               rule_broken = TRUE;
+               rule_broken = true;
 
               if (current_unit == 1)
               {
                /*
                 * Reject the unit if we are at te starting digram of
                 * a syllable and it does not fit.
                 */
                if (ALLOWED (NOT_BEGIN))
-                   rule_broken = TRUE;
+                   rule_broken = true;
               }
               else
               {
                /* 
                 * We are not at the start of a syllable.
                 * Save the previous unit for later tests.
                 */
                last_unit = units_in_syllable[current_unit - 1];
 
                /*
@@ skipping 29 matching lines @@
 
                     /*
                      * Reject the unit if the digram it forms
                      * expects a vowel preceding it and there is
                      * none.
                      */
                     (ALLOWED (PREFIX) &&
                         !(rules[units_in_syllable
                              [current_unit - 2]].flags &
                          VOWEL)))
-                   rule_broken = TRUE;
+                   rule_broken = true;
 
                /*
                 * The following checks occur when the current unit
                 * is a vowel and we are not looking at a word ending
                 * with an e.
                 */
                if (!rule_broken &&
                     (rules[unit].flags & VOWEL) &&
                     ((length_left > 0) ||
                         !(rules[last_unit].flags &
                          NO_FINAL_SPLIT)))
                   {
                    /*
                     * Don't allow 3 consecutive vowels in a
                     * syllable.  Although some words formed like this
                     * are OK, like beau, most are not.
                     */
                    if ((vowel_count > 1) &&
                         (rules[last_unit].flags & VOWEL))
-                    rule_broken = TRUE;
+                    rule_broken = true;
                    else
                     /*
                      * Check for the case of
                      * vowels-consonants-vowel, which is only
                      * legal if the last vowel is an e and we are
                      * the end of the word (wich is not
                      * happening here due to a previous check.
                      */
                     if ((vowel_count != 0) &&
                          !(rules[last_unit].flags & VOWEL))
                     {
                         /*
                          * Try to save the vowel for the next
                          * syllable, but if the syllable left here
                          * is not proper (i.e., the resulting last
                          * digram cannot legally end it), just
                          * discard it and try for another.   
                          */
                         if (digram[units_in_syllable
                               [current_unit - 2]]
                              [last_unit] &
                              NOT_END)
-                         rule_broken = TRUE;
+                         rule_broken = true;
                         else
                         {
                          saved_unit = 1;
                          saved_pair[0] = unit;
-                         want_another_unit = FALSE;
+                         want_another_unit = false;
                         }
                     }
                   }
               }
 
               /*
                * The unit picked and the digram formed are legal.
                * We now determine if we can end the syllable.  It may,
                * in some cases, mean the last unit(s) may be deferred to
                * the next syllable.  We also check here to see if the
                * digram formed expects a vowel to follow.
                */
               if (!rule_broken && want_another_unit)
               {
                /*
                 * This word ends in a silent e.
                 */
 /******/        if (((vowel_count != 0) &&
                      (rules[unit].flags & NO_FINAL_SPLIT) &&
                      (length_left == 0) &&
                     !(rules[last_unit].flags & VOWEL)) ||
 
                     /*
                      * This syllable ends either because the digram
                      * is an END pair or we would otherwise exceed
                      * the length of the word.
                      */
                     (ALLOWED (END) || (length_left == 0)))
                    {
-                   want_another_unit = FALSE;
+                   want_another_unit = false;
                    }
                else
                    /*
                     * Since we have a vowel in the syllable
                     * already, if the digram calls for the end of the
                     * syllable, we can legally split it off. We also
                     * make sure that we are not at the end of the
                     * dangerous because that syllable may not have
                     * vowels, or it may not be a legal syllable end,
                     * and the retrying mechanism will loop infinitely
                     * with the same digram.
                     */
                    if ((vowel_count != 0) && (length_left > 0))
                    {
                     /*
                      * If we must begin a syllable, we do so if
                      * the only vowel in THIS syllable is not part
                      * of the digram we are pushing to the next
                      * syllable.
                      */
                     if (ALLOWED (BEGIN) &&
                          (current_unit > 1) &&
                          !((vowel_count == 1) &&
                          (rules[last_unit].flags & VOWEL)))
                     {
                         saved_unit = 2;
                         saved_pair[0] = unit;
                         saved_pair[1] = last_unit;
-                        want_another_unit = FALSE;
+                        want_another_unit = false;
                     }
                     else
                         if (ALLOWED (BREAK))
                         {
                          saved_unit = 1;
                          saved_pair[0] = unit;
-                         want_another_unit = FALSE;
+                         want_another_unit = false;
                         }
                    }
                    else
                     if (ALLOWED (SUFFIX))
                      {
-                        want_vowel = TRUE;
+                        want_vowel = true;
                      }
               }
           }
 /********/
           tries++;
 
           /*
            * If this unit was illegal, redetermine the amount of
            * letters left to go in the word.
            */
@@ skipping 40 matching lines @@
                length_left += (short int) strlen (rules[last_unit].unit_code);
                current_unit -= 2;
                break;
           }
          }
          else
          /*
           * Whoops!  Too many tries.  We set rule_broken so we can
           * loop in the outer loop and try another syllable.
           */
-          rule_broken = TRUE;
+          rule_broken = true;
 
          /*
           * ...and the syllable length grows.
           */
          *syllable_length = current_unit;
 
          current_unit++;
      }
      while ((tries <= MAX_RETRIES) && want_another_unit);
     }
     while (rule_broken ||
            illegal_placement (units_in_syllable, *syllable_length));
 
     return (syllable);
 }
 
 
 /*
  * This routine goes through an individual syllable and checks
  * for illegal combinations of letters that go beyond looking
  * at digrams.  We look at things like 3 consecutive vowels or
  * consonants, or syllables with consonants between vowels (unless
  * one of them is the final silent e).
  */
-boolean
-illegal_placement (USHORT *units, USHORT pwlen)
+bool
+illegal_placement (unsigned short *units, unsigned short pwlen)
 {
-    USHORT vowel_count;
-    USHORT unit_count;
-    boolean failure;
+    unsigned short vowel_count;
+    unsigned short unit_count;
+    bool failure;
 
     vowel_count = 0;
-    failure = FALSE;
+    failure = false;
 
     for (unit_count = 0; !failure && (unit_count <= pwlen);
          unit_count++)
     {
      if (unit_count >= 1)
      {
          /* 
           * Don't allow vowels to be split with consonants in
           * a single syllable.  If we find such a combination
           * (except for the silent e) we have to discard the
@@ skipping 23 matching lines @@
                     */
                    (((rules[units[unit_count - 2]].flags &
                          VOWEL) &&
                         !((rules[units[0]].flags &
                              ALTERNATE_VOWEL) &&
                          (unit_count == 2))) &&
                     (rules[units[unit_count - 1]].flags &
                         VOWEL) &&
                     (rules[units[unit_count]].flags &
                         VOWEL)))))
-          failure = TRUE;
+          failure = true;
      }
 
      /* 
       * Count the vowels in the syllable.  As mentioned somewhere
       * above, exclude the initial y of a syllable.  Instead,
       * treat it as a consonant.
       */
      if ((rules[units[unit_count]].flags & VOWEL) &&
           !((rules[units[0]].flags & ALTERNATE_VOWEL) &&
               (unit_count == 0) && (pwlen != 0)))
@@ skipping 21 matching lines @@
  * index 1 appears 10 times in the array, the probability of
  * selecting an `a' is 10/211.
  *
  * Changes may be made to the digram table without affect to this
  * procedure providing the letter-to-number correspondence of
  * the units does not change.  Likewise, the distribution of the
  * 34 units may be altered (and the array size may be changed)
  * in this procedure without affecting the digram table or any other
  * programs using the Random_word subroutine.
  */
-static USHORT numbers[] =
+static unsigned short numbers[] =
 {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     1, 1, 1, 1, 1, 1, 1, 1,
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
     5, 5, 5, 5, 5, 5, 5, 5,
     6, 6, 6, 6, 6, 6, 6, 6,
     7, 7, 7, 7, 7, 7,
     8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
@@ skipping 28 matching lines @@
 /*
  * This structure has a typical English frequency of vowels.
  * The value of an entry is the vowel position (a=0, e=4, i=8,
  * o=14, u=19, y=23) in the rules array.  The number of times
  * the value appears is the frequency.  Thus, the letter "a"
  * is assumed to appear 2/12 = 1/6 of the time.  This array
  * may be altered if better data is obtained.  The routines that
  * use vowel_numbers will adjust to the size difference
 automatically.
  */
-static USHORT vowel_numbers[] =
+static unsigned short vowel_numbers[] =
 {
     0, 0, 4, 4, 4, 8, 8, 14, 14, 19, 19, 23
 };
 
 
 /*
  * Select a unit (a letter or a consonant group).  If a vowel is
  * expected, use the vowel_numbers array rather than looping through
  * the numbers array until a vowel is found.
  */
-USHORT
-random_unit (USHORT type)
+unsigned short
+random_unit (unsigned short type)
 {
-     USHORT number;
+     unsigned short number;
 
     /*
      * Sometimes, we are asked to explicitly get a vowel (i.e., if
      * a digram pair expects one following it).  This is a shortcut
      * to do that and avoid looping with rejected consonants.
      */
     if (type & VOWEL)
       number = vowel_numbers[
-          base::RandInt(0, (sizeof (vowel_numbers) / sizeof (USHORT))-1)];
+          base::RandInt(0, (sizeof (vowel_numbers) / sizeof (unsigned short))-1)];
     else
      /*
       * Get any letter according to the English distribution.
       */
       number = numbers[
-          base::RandInt(0, (sizeof (numbers) / sizeof (USHORT))-1)];
+          base::RandInt(0, (sizeof (numbers) / sizeof (unsigned short))-1)];
     return (number);
 }