home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / sigm / vol131 / alph2int.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1984-04-29  |  3.6 KB  |  110 lines
  1. FUNCTION dig2integer(input_character    : CHAR;
  2.              VAR output_number    : INTEGER) : BOOLEAN;
  3.  
  4. BEGIN
  5. dig2integer := TRUE;
  6. IF input_character IN ['0'..'9']
  7.   THEN output_number := ORD(input_character) - ORD('0')
  8.   ELSE dig2integer   := FALSE;
  9. END; { of : FUNCTION dig2integer }
  10.  
  11. FUNCTION Str2Integer(InputString    : string255;
  12.              VAR output#,
  13.                  error#        : INTEGER    ) : BOOLEAN;
  14. { COMMENT:
  15.     This function takes as input any PASCAL/Z string and , if the
  16.  string is acceptable , returns the integer value equivalent in output#.
  17.  Errors are reported in two ways : 
  18.     If the function returns TRUE then no errors were detected.
  19.     If the function returns FALSE :
  20.         error# will = 1 if the string was too long to convert,
  21.         or would have resulted in a number greater than MAXINT
  22.         error# will = 2 if the string contained nonconvertable
  23.         characters.
  24.  N.B.The input string may be signed (i.e. first character = '+' or '-' )
  25.   and may contain leading zeroes.
  26. }
  27. CONST    str2long    = 1;
  28.     toobig        = str2long;
  29.     bad_character    = 2;
  30. VAR    stillvalid,
  31.     overflow,
  32.     negative    : BOOLEAN;
  33.     value,
  34.     multiplier,
  35.     last_character,
  36.     first_character,
  37.     next_character  : INTEGER;
  38. FUNCTION StringTooLong(instring : STRING255) : BOOLEAN;
  39. {COMMENT:
  40.     Checks the string's length for Str2Integer.
  41.     Allows first character to be '0','+',or'-'.
  42.     Allows leading zeroes.
  43.     Returns true if more than 5 significant characters in string.
  44.     Does not check completely for inappropriate characters or
  45.         possibility of potential overflow.
  46. }
  47. CONST    ok    = TRUE;
  48. VAR    leading_zeros,
  49.     str_length    : BOOLEAN;
  50.     string_length,
  51.     char#        : INTEGER;
  52. BEGIN
  53. leading_zeros := TRUE;
  54. string_length := length(instring);
  55. IF string_length < 5 THEN StringTooLong := FALSE
  56.    ELSE BEGIN
  57.         FOR char# := 2 TO (string_length - 5) DO BEGIN
  58.            leading_zeros := leading_zeros AND (instring[char#] = '0')
  59.        END;
  60.     leading_zeros := leading_zeros AND (instring[1] IN ['+','-','0']);
  61.     StringTooLong := NOT leading_zeros;
  62.    END;
  63. END; { of : FUNCTION StringTooLong }
  64.  
  65. BEGIN { FUNCTION Str2Integer }
  66. Str2Integer    := TRUE;
  67. stillvalid    := TRUE;
  68. last_character := length(InputString);
  69. IF last_character = 0 THEN output# := 0 ELSE BEGIN
  70.  IF StringTooLong(InputString) THEN BEGIN
  71.    Str2Integer   := false;
  72.    error#    := str2long;
  73.    END
  74.  ELSE BEGIN
  75.    negative    := InputString[1] = '-';
  76.    IF last_character > 4 THEN first_character:= last_character - 4
  77.      ELSE first_character := 1;
  78.    output#    := 0;
  79.    multiplier    := 1;
  80.    FOR next_character := last_character DOWNTO first_character DO BEGIN
  81.        overflow   := NOT( 
  82.              (multiplier < 10000) OR
  83.         ((multiplier = 10000) AND 
  84.         ((InputString[next_character] IN ['0'..'2']) OR
  85.         ((InputString[next_character] = '3') AND (output# < 2767)))));
  86.        IF (next_character > first_character) OR
  87.     (InputString[first_character] IN ['0'..'9']) THEN BEGIN
  88.           stillvalid := stillvalid AND
  89.           Dig2Integer(InputString[next_character],value);
  90.           IF stillvalid AND NOT overflow THEN BEGIN
  91.             output#    := multiplier * value + output#;
  92.             multiplier := multiplier * 10;
  93.             END;  { of : IF stillvalid AND ...     }
  94.     END;    { of : IF (next_character...   }
  95.       END;    { of : FOR next_character    }
  96.     IF stillvalid THEN BEGIN
  97.         IF negative THEN output# := -output#;
  98.       END
  99.       ELSE BEGIN { i.e. at least one character was non-numeric }
  100.         Str2Integer := FALSE;
  101.         error#      := bad_character;
  102.       END; { of : IF stillvalid }
  103.     IF overflow THEN BEGIN
  104.        Str2Integer := FALSE;
  105.        error#      := toobig;
  106.        END;
  107.     END;   { of : IF StringTooLong .. ELSE BEGIN...  }
  108.   END;     { of : IF last_character = 0 ...ELSE BEGIN...}
  109. END; { of : FUNCTION Str2Integer }
  110.