home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / OB3.2D2.DMS / in.adf / Module / Conversions.mod < prev    next >
Encoding:
Text File  |  1994-08-05  |  6.0 KB  |  255 lines
  1. (*-------------------------------------------------------------------------*)
  2. (*                                                                         *)
  3. (*  Amiga Oberon Library Module: Conversions          Date: 02-Nov-92      *)
  4. (*                                                                         *)
  5. (*   © 1992 by Fridtjof Siebert                                            *)
  6. (*                                                                         *)
  7. (*-------------------------------------------------------------------------*)
  8.  
  9. MODULE Conversions;
  10.  
  11. IMPORT Str := Strings;
  12.  
  13. (*------  StringToInt:  ------*)
  14.  
  15. PROCEDURE StringToInt* (VAR str: ARRAY OF CHAR;
  16.                         VAR int: LONGINT): BOOLEAN;
  17.  
  18. (* parst den String nach folgender Grammatik:
  19.  
  20.     digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9".
  21.     hexdigit = "A" | "B" | "C" | "D" | "E" | "F".
  22.  
  23.     int = hex | dec.
  24.     hex = {hexdigit | digit} "H".
  25.     dec = ["+"|"-"] {digit}.
  26.  
  27.   führende und folgende Spaces werden überlesen. Ergebnis ist TRUE, wenn
  28.   String Element der Grammatik ist und das Ergebnis im LONGINT-Bereich ist.
  29.   Bei Hexzahlen werden automatisch negative, wenn sie >= 80000000H sind.
  30.   Beispiel: FFFFFFF8H = -8.
  31. *)
  32.  
  33. VAR
  34.   i,l,n: INTEGER;
  35.   ch: CHAR;
  36.   hex: BOOLEAN;
  37.   neg: BOOLEAN;
  38.  
  39.   PROCEDURE Next;
  40.   BEGIN
  41.     IF i=l THEN ch := 0X ELSE ch := CAP(str[i]); INC(i) END;
  42.   END Next;
  43.  
  44. BEGIN
  45.   l := SHORT(Str.Length(str));
  46.   WHILE (l>0) & (str[l-1]=" ") DO DEC(l) END;
  47.   hex := (l>0) & (CAP(str[l-1])="H");
  48.   i := 0; int := 0;
  49.   REPEAT Next UNTIL ch#" ";
  50.   IF hex THEN
  51.     n := 0;
  52.     LOOP
  53.       CASE ch OF
  54.       "0".."9":
  55.         IF n=8 THEN RETURN FALSE END;
  56.         (* $OvflChk- *) int := 16*int+ORD(ch)-    ORD("0");  | (* $OvflChk= *)
  57.       "A".."F":
  58.         IF n=8 THEN RETURN FALSE END;
  59.         (* $OvflChk- *) int := 16*int+ORD(ch)+(10-ORD("A")); | (* $OvflChk= *)
  60.       ELSE
  61.         RETURN ch="H";
  62.       END;
  63.       Next; INC(n);
  64.     END;
  65.   ELSE
  66.     neg := FALSE;
  67.     CASE ch OF "-","+": neg := ch="-"; Next ELSE END;
  68.     LOOP
  69.       CASE ch OF
  70.       "0".."9":
  71.         n := ORD(ch)-ORD("0");
  72.         IF int>(MAX(LONGINT)-n) DIV 10 THEN RETURN FALSE
  73.                                        ELSE int := 10*int + n END |
  74.       ELSE
  75.         IF neg THEN int := -int END;
  76.         RETURN ch=0X
  77.       END;
  78.       Next;
  79.     END;
  80.   END;
  81. END StringToInt;
  82.  
  83.  
  84. (*------  IntToString:  ------*)
  85.  
  86.  
  87. PROCEDURE IntToString*(    int: LONGINT;
  88.                        VAR str: ARRAY OF CHAR;
  89.                              n: INTEGER): BOOLEAN;
  90.  
  91. (* wandelt int in n-stellige Dezimalzahl um. LEN(str) muß größer als n+2
  92.    sein. Ergebnis ist FALSE, wenn int zu groß ist. *)
  93.  
  94. VAR
  95.   mi: BOOLEAN;
  96.   c: INTEGER;
  97.  
  98. BEGIN
  99.   str[n+1] := 0X; mi := FALSE;
  100.   mi := int=MIN(LONGINT);
  101.   IF mi THEN int := MIN(LONGINT)+1000000000 END;
  102.   IF int<0 THEN int := -int; str[0] := "-" ELSE str[0] := " " END;
  103.   c := n;
  104.   WHILE c>0 DO
  105.     str[c] := CHR(int MOD 10 + ORD("0"));
  106.     int := int DIV 10;
  107.     DEC(c);
  108.   END;
  109.   LOOP
  110.     INC(c);
  111.     IF (str[c]#"0") OR (c=n) THEN EXIT END;
  112.     str[c] := " ";
  113.   END;
  114.   IF mi THEN INC(str[c]) END;
  115.   RETURN int=0;
  116. END IntToString;
  117.  
  118.  
  119. (*------  IntToHex:  ------*)
  120.  
  121.  
  122. PROCEDURE IntToHex*(    int: LONGINT;
  123.                     VAR str: ARRAY OF CHAR;
  124.                           n: INTEGER): BOOLEAN;
  125.  
  126. (* wandelt int in n-stellige Hexzahl um. LEN(str) muß größer als n+2
  127.    sein. Ergebnis ist FALSE, wenn int zu groß ist. *)
  128.  
  129. VAR
  130.   d: CHAR;
  131.  
  132. BEGIN
  133.   str[n] := "H"; str[n+1] := 0X;
  134.   WHILE n>0 DO
  135.     DEC(n);
  136.     d := CHR(int MOD 16);
  137.     IF d<0AX THEN INC(d,ORD("0")   )
  138.              ELSE INC(d,ORD("A")-10) END;
  139.     str[n] := d;
  140.     int := int DIV 16;
  141.   END;
  142.   RETURN (int=0) OR (int=-1);
  143. END IntToHex;
  144.  
  145.  
  146. (*------  StrToInt:  ------*)
  147.  
  148.  
  149. PROCEDURE StrToInt* (VAR str: ARRAY OF CHAR;
  150.                      VAR int: LONGINT;
  151.                         base: INTEGER): BOOLEAN;
  152.  
  153. VAR
  154.   i,l,n,z: INTEGER;
  155.   ch: CHAR;
  156.   neg: BOOLEAN;
  157.  
  158.   PROCEDURE Next;
  159.   BEGIN
  160.     IF i=l THEN ch := 0X ELSE ch := CAP(str[i]); INC(i) END;
  161.   END Next;
  162.  
  163. BEGIN
  164.   l := SHORT(Str.Length(str));
  165.   WHILE (l>0) & (str[l-1]=" ") DO DEC(l) END;
  166.   i := 0; int := 0;
  167.   REPEAT Next UNTIL ch#" ";
  168.   neg := ch="-"; IF neg THEN Next END;
  169.   n := 0;
  170.   LOOP
  171.     CASE ch OF
  172.     "0".."9": z := ORD(ch)-    ORD("0")  |
  173.     "A".."Z": z := ORD(ch)+(10-ORD("A")) |
  174.     0X: EXIT |
  175.     ELSE RETURN FALSE END;
  176.     IF (z>=base) OR (int>(MAX(LONGINT)-z) DIV base) THEN RETURN FALSE END;
  177.     int := base*int+z;
  178.     Next; INC(n);
  179.   END;
  180.   IF neg THEN int := - int END;
  181.   RETURN TRUE;
  182. END StrToInt;
  183.  
  184.  
  185. (*------  IntToStr:  ------*)
  186.  
  187.  
  188. PROCEDURE IntToStr* (int: LONGINT;
  189.                      VAR str: ARRAY OF CHAR;
  190.                      base,width: SHORTINT;
  191.                      fillChar: CHAR): BOOLEAN;
  192.  
  193. VAR
  194.   d: INTEGER;
  195.   neg,inv: BOOLEAN;
  196.  
  197. BEGIN
  198.   str[width] := 0X; inv := int<0; int := ABS(int);
  199.   neg := inv & (base=10); IF neg THEN inv := FALSE END;
  200.   WHILE width>0 DO
  201.     DEC(width);
  202.     d := SHORT(int MOD base);
  203.     IF inv & (d#0) THEN d := base-d END;
  204.     IF d<10 THEN INC(d,ORD("0")   )
  205.             ELSE INC(d,ORD("A")-10) END;
  206.     str[width] := CHR(d);
  207.     int := int DIV base;
  208.     IF int=0 THEN
  209.       IF inv THEN IF base<10 THEN fillChar := CHR(base+(ORD("0")- 1))
  210.                              ELSE fillChar := CHR(base+(ORD("A")-11)) END; END;
  211.       IF neg THEN
  212.           IF width<=0 THEN RETURN FALSE
  213.                     ELSE DEC(width); str[width] := "-" END;
  214.       END;
  215.       WHILE width>0 DO DEC(width); str[width] := fillChar END;
  216.       RETURN TRUE;
  217.     END;
  218.   END;
  219.   RETURN (int=0) OR (int=-1);
  220. END IntToStr;
  221.  
  222.  
  223. (*------  IntToStringLeft:  ------*)
  224.  
  225.  
  226. PROCEDURE IntToStringLeft* (int: LONGINT; VAR str: ARRAY OF CHAR);
  227.  
  228. VAR
  229.   index: INTEGER;
  230.  
  231.   PROCEDURE IToS(int: LONGINT);
  232.   BEGIN
  233.     IF int>9 THEN IToS(int DIV 10) END;
  234.     IF index<LEN(str) THEN
  235.       str[index] := CHR(int MOD 10 + ORD("0"));
  236.       INC(index);
  237.     END;
  238.   END IToS;
  239.  
  240. BEGIN
  241.   index := 0;
  242.   IF int<0 THEN
  243.     str[0] := "-";
  244.     index := 1;
  245.     int := -int;
  246.   END;
  247.   IToS(int);
  248.   IF index<LEN(str) THEN str[index] := 0X END;
  249. END IntToStringLeft;
  250.  
  251.  
  252. END Conversions.
  253.  
  254.  
  255.