| (* StringConvert.mod provides functions to convert numbers to and from strings. |
| |
| Copyright (C) 2001-2026 Free Software Foundation, Inc. |
| Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>. |
| |
| This file is part of GNU Modula-2. |
| |
| GNU Modula-2 is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GNU Modula-2 is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| Under Section 7 of GPL version 3, you are granted additional |
| permissions described in the GCC Runtime Library Exception, version |
| 3.1, as published by the Free Software Foundation. |
| |
| You should have received a copy of the GNU General Public License and |
| a copy of the GCC Runtime Library Exception along with this program; |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| <http://www.gnu.org/licenses/>. *) |
| |
| IMPLEMENTATION MODULE StringConvert ; |
| |
| FROM SYSTEM IMPORT ADDRESS, ADR ; |
| FROM libc IMPORT free, printf ; |
| FROM libm IMPORT powl ; |
| FROM M2RTS IMPORT ErrorMessage ; |
| |
| IMPORT DynamicStrings ; |
| |
| FROM DynamicStrings IMPORT InitString, |
| InitStringChar, InitStringCharStar, |
| Mark, ConCat, Dup, string, |
| Slice, Index, char, Assign, Length, Mult, |
| RemoveWhitePrefix, ConCatChar, KillString, |
| InitStringDB, InitStringCharStarDB, |
| InitStringCharDB, MultDB, DupDB, SliceDB ; |
| |
| FROM ldtoa IMPORT Mode, strtold, ldtoa ; |
| IMPORT dtoa ; (* this fixes linking - as the C ldtoa uses dtoa *) |
| |
| |
| (* |
| #undef GM2_DEBUG_STRINGCONVERT |
| #if defined(GM2_DEBUG_STRINGCONVERT) |
| # define InitString(X) InitStringDB(X, __FILE__, __LINE__) |
| # define InitStringCharStar(X) InitStringCharStarDB(X, __FILE__, __LINE__) |
| # define InitStringChar(X) InitStringCharDB(X, __FILE__, __LINE__) |
| # define Mult(X,Y) MultDB(X, Y, __FILE__, __LINE__) |
| # define Dup(X) DupDB(X, __FILE__, __LINE__) |
| # define Slice(X,Y,Z) SliceDB(X, Y, Z, __FILE__, __LINE__) |
| #endif |
| *) |
| |
| (* |
| Assert - implement a simple assert. |
| *) |
| |
| PROCEDURE Assert (b: BOOLEAN; file: ARRAY OF CHAR; line: CARDINAL; func: ARRAY OF CHAR) ; |
| BEGIN |
| IF NOT b |
| THEN |
| ErrorMessage('assert failed', file, line, func) |
| END |
| END Assert ; |
| |
| |
| (* |
| Max - |
| *) |
| |
| PROCEDURE Max (a, b: CARDINAL) : CARDINAL ; |
| BEGIN |
| IF a>b |
| THEN |
| RETURN( a ) |
| ELSE |
| RETURN( b ) |
| END |
| END Max ; |
| |
| |
| (* |
| Min - |
| *) |
| |
| PROCEDURE Min (a, b: CARDINAL) : CARDINAL ; |
| BEGIN |
| IF a<b |
| THEN |
| RETURN( a ) |
| ELSE |
| RETURN( b ) |
| END |
| END Min ; |
| |
| |
| (* |
| LongMin - returns the smallest LONGCARD |
| *) |
| |
| PROCEDURE LongMin (a, b: LONGCARD) : LONGCARD ; |
| BEGIN |
| IF a<b |
| THEN |
| RETURN( a ) |
| ELSE |
| RETURN( b ) |
| END |
| END LongMin ; |
| |
| |
| (* |
| IsDigit - returns TRUE if, ch, lies between '0'..'9'. |
| *) |
| |
| PROCEDURE IsDigit (ch: CHAR) : BOOLEAN ; |
| BEGIN |
| RETURN (ch>='0') AND (ch<='9') |
| END IsDigit ; |
| |
| |
| (* |
| IsDecimalDigitValid - returns the TRUE if, ch, is a base legal decimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsDecimalDigitValid (ch: CHAR; base: CARDINAL; VAR c: CARDINAL) : BOOLEAN ; |
| BEGIN |
| IF IsDigit(ch) AND (ORD(ch)-ORD('0')<base) |
| THEN |
| c := c*base + (ORD(ch)-ORD('0')) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsDecimalDigitValid ; |
| |
| |
| (* |
| IsHexidecimalDigitValid - returns the TRUE if, ch, is a base legal hexidecimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsHexidecimalDigitValid (ch: CHAR; base: CARDINAL; VAR c: CARDINAL) : BOOLEAN ; |
| BEGIN |
| IF (ch>='a') AND (ch<='f') AND (ORD(ch)-ORD('a')+10<base) |
| THEN |
| c := c*base + (ORD(ch)-ORD('a')+10) ; |
| RETURN( TRUE ) |
| ELSIF (ch>='A') AND (ch<='F') AND (ORD(ch)-ORD('F')+10<base) |
| THEN |
| c := c*base + (ORD(ch)-ORD('A')+10) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsHexidecimalDigitValid ; |
| |
| |
| (* |
| IsDecimalDigitValidLong - returns the TRUE if, ch, is a base legal decimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsDecimalDigitValidLong (ch: CHAR; base: CARDINAL; |
| VAR c: LONGCARD) : BOOLEAN ; |
| BEGIN |
| IF IsDigit(ch) AND (ORD(ch)-ORD('0')<base) |
| THEN |
| c := c * VAL(LONGCARD, base + (ORD(ch)-ORD('0'))) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsDecimalDigitValidLong ; |
| |
| |
| (* |
| IsHexidecimalDigitValidLong - returns the TRUE if, ch, is a base legal hexidecimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsHexidecimalDigitValidLong (ch: CHAR; base: CARDINAL; VAR c: LONGCARD) : BOOLEAN ; |
| BEGIN |
| IF (ch>='a') AND (ch<='f') AND (ORD(ch)-ORD('a')+10<base) |
| THEN |
| c := c * VAL(LONGCARD, base + (ORD(ch)-ORD('a')+10)) ; |
| RETURN( TRUE ) |
| ELSIF (ch>='A') AND (ch<='F') AND (ORD(ch)-ORD('F')+10<base) |
| THEN |
| c := c * VAL(LONGCARD, base + (ORD(ch)-ORD('A')+10)) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsHexidecimalDigitValidLong ; |
| |
| |
| (* |
| IsDecimalDigitValidShort - returns the TRUE if, ch, is a base legal decimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsDecimalDigitValidShort (ch: CHAR; base: CARDINAL; VAR c: SHORTCARD) : BOOLEAN ; |
| BEGIN |
| IF IsDigit(ch) AND (ORD(ch)-ORD('0')<base) |
| THEN |
| c := c * VAL(SHORTCARD, base + (ORD(ch)-ORD('0'))) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsDecimalDigitValidShort ; |
| |
| |
| (* |
| IsHexidecimalDigitValidShort - returns the TRUE if, ch, is a base legal hexidecimal digit. |
| If legal then the value is appended numerically onto, c. |
| *) |
| |
| PROCEDURE IsHexidecimalDigitValidShort (ch: CHAR; base: CARDINAL; VAR c: SHORTCARD) : BOOLEAN ; |
| BEGIN |
| IF (ch>='a') AND (ch<='f') AND (ORD(ch)-ORD('a')+10<base) |
| THEN |
| c := c * VAL(SHORTCARD, base + (ORD(ch)-ORD('a')+10)) ; |
| RETURN( TRUE ) |
| ELSIF (ch>='A') AND (ch<='F') AND (ORD(ch)-ORD('F')+10<base) |
| THEN |
| c := c * VAL(SHORTCARD, base + (ORD(ch)-ORD('A')+10)) ; |
| RETURN( TRUE ) |
| ELSE |
| RETURN( FALSE ) |
| END |
| END IsHexidecimalDigitValidShort ; |
| |
| |
| (* |
| IntegerToString - converts INTEGER, i, into a String. The field with can be specified |
| if non zero. Leading characters are defined by padding and this |
| function will prepend a + if sign is set to TRUE. |
| The base allows the caller to generate binary, octal, decimal, hexidecimal |
| numbers. The value of lower is only used when hexidecimal numbers are |
| generated and if TRUE then digits abcdef are used, and if FALSE then ABCDEF |
| are used. |
| *) |
| |
| PROCEDURE IntegerToString (i: INTEGER; width: CARDINAL; padding: CHAR; sign: BOOLEAN; |
| base: CARDINAL; lower: BOOLEAN) : String ; |
| VAR |
| s: String ; |
| c: CARDINAL ; |
| BEGIN |
| IF i<0 |
| THEN |
| IF i=MIN(INTEGER) |
| THEN |
| (* remember that -15 MOD 4 = 1 in Modula-2 *) |
| c := VAL(CARDINAL, ABS(i+1))+1 ; |
| IF width>0 |
| THEN |
| RETURN( ConCat(IntegerToString(-VAL(INTEGER, c DIV base), |
| width-1, padding, sign, base, lower), |
| Mark(IntegerToString(c MOD base, 0, ' ', FALSE, base, lower))) ) |
| ELSE |
| RETURN( ConCat(IntegerToString(-VAL(INTEGER, c DIV base), |
| 0, padding, sign, base, lower), |
| Mark(IntegerToString(c MOD base, 0, ' ', FALSE, base, lower))) ) |
| END |
| ELSE |
| s := InitString('-') |
| END ; |
| i := -i |
| ELSE |
| IF sign |
| THEN |
| s := InitString('+') |
| ELSE |
| s := InitString('') |
| END |
| END ; |
| IF i>VAL(INTEGER, base)-1 |
| THEN |
| s := ConCat(ConCat(s, Mark(IntegerToString(VAL(CARDINAL, i) DIV base, 0, ' ', FALSE, base, lower))), |
| Mark(IntegerToString(VAL(CARDINAL, i) MOD base, 0, ' ', FALSE, base, lower))) |
| ELSE |
| IF i<=9 |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('0'))))) |
| ELSE |
| IF lower |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('a')-10)))) |
| ELSE |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('A')-10)))) |
| END |
| END |
| END ; |
| IF width>DynamicStrings.Length(s) |
| THEN |
| RETURN( ConCat(Mult(Mark(InitStringChar(padding)), width-DynamicStrings.Length(s)), Mark(s)) ) |
| END ; |
| RETURN( s ) |
| END IntegerToString ; |
| |
| |
| (* |
| CardinalToString - converts CARDINAL, c, into a String. The field with can be specified |
| if non zero. Leading characters are defined by padding. |
| The base allows the caller to generate binary, octal, decimal, hexidecimal |
| numbers. The value of lower is only used when hexidecimal numbers are |
| generated and if TRUE then digits abcdef are used, and if FALSE then ABCDEF |
| are used. |
| *) |
| |
| PROCEDURE CardinalToString (c: CARDINAL; width: CARDINAL; padding: CHAR; |
| base: CARDINAL; lower: BOOLEAN) : String ; |
| VAR |
| s: String ; |
| BEGIN |
| s := InitString('') ; |
| IF c>base-1 |
| THEN |
| s := ConCat(ConCat(s, Mark(CardinalToString(c DIV base, 0, ' ', base, lower))), |
| Mark(CardinalToString(c MOD base, 0, ' ', base, lower))) |
| ELSE |
| IF c<=9 |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(c+ORD('0'))))) |
| ELSE |
| IF lower |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(c+ORD('a')-10)))) |
| ELSE |
| s := ConCat(s, Mark(InitStringChar(CHR(c+ORD('A')-10)))) |
| END |
| END |
| END ; |
| IF width>DynamicStrings.Length(s) |
| THEN |
| RETURN( ConCat(Mult(Mark(InitStringChar(padding)), width-DynamicStrings.Length(s)), s) ) |
| END ; |
| RETURN( s ) |
| END CardinalToString ; |
| |
| |
| (* |
| LongIntegerToString - converts LONGINT, i, into a String. The field with |
| can be specified if non zero. Leading characters |
| are defined by padding and this function will |
| prepend a + if sign is set to TRUE. |
| The base allows the caller to generate binary, |
| octal, decimal, hexidecimal numbers. |
| The value of lower is only used when hexidecimal |
| numbers are generated and if TRUE then digits |
| abcdef are used, and if FALSE then ABCDEF are used. |
| *) |
| |
| PROCEDURE LongIntegerToString (i: LONGINT; width: CARDINAL; padding: CHAR; |
| sign: BOOLEAN; base: CARDINAL; lower: BOOLEAN) : String ; |
| |
| VAR |
| s: String ; |
| c: LONGCARD ; |
| BEGIN |
| IF i<0 |
| THEN |
| IF i=MIN(LONGINT) |
| THEN |
| (* remember that -15 MOD 4 is 1 in Modula-2, and although ABS(MIN(LONGINT)+1) |
| is very likely MAX(LONGINT), it is safer not to assume this is the case *) |
| c := VAL(LONGCARD, ABS(i+1))+1 ; |
| IF width>0 |
| THEN |
| RETURN( ConCat(LongIntegerToString(-VAL(LONGINT, c DIV VAL(LONGCARD, base)), |
| width-1, padding, sign, base, lower), |
| Mark(LongIntegerToString(c MOD VAL(LONGCARD, base), 0, ' ', FALSE, base, lower))) ) |
| ELSE |
| RETURN( ConCat(LongIntegerToString(-VAL(LONGINT, c DIV VAL(LONGCARD, base)), |
| 0, padding, sign, base, lower), |
| Mark(LongIntegerToString(c MOD VAL(LONGCARD, base), 0, ' ', FALSE, base, lower))) ) |
| END |
| ELSE |
| s := InitString('-') |
| END ; |
| i := -i |
| ELSE |
| IF sign |
| THEN |
| s := InitString('+') |
| ELSE |
| s := InitString('') |
| END |
| END ; |
| IF i>VAL(LONGINT, base-1) |
| THEN |
| s := ConCat(ConCat(s, Mark(LongIntegerToString(i DIV VAL(LONGINT, base), 0, ' ', FALSE, base, lower))), |
| Mark(LongIntegerToString(i MOD VAL(LONGINT, base), 0, ' ', FALSE, base, lower))) |
| ELSE |
| IF i<=9 |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('0'))))) |
| ELSE |
| IF lower |
| THEN |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('a')-10)))) |
| ELSE |
| s := ConCat(s, Mark(InitStringChar(CHR(VAL(CARDINAL, i)+ORD('A')-10)))) |
| END |
| END |
| END ; |
| IF width>DynamicStrings.Length(s) |
| THEN |
| RETURN( ConCat(Mult(Mark(InitStringChar(padding)), width-DynamicStrings.Length(s)), s) ) |
| END ; |
| RETURN( s ) |
| END LongIntegerToString ; |
| |
| |
| (* |
| StringToLongInteger - converts a string, s, of, base, into an LONGINT. |
| Leading white space is ignored. It stops converting |
| when either the string is exhausted or if an illegal |
| numeral is found. |
| The parameter found is set TRUE if a number was found. |
| *) |
| |
| PROCEDURE StringToLongInteger (s: String; base: CARDINAL; VAR found: BOOLEAN) : LONGINT ; |
| VAR |
| n, l : CARDINAL ; |
| c : LONGCARD ; |
| negative: BOOLEAN ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* returns a new string, s *) |
| l := DynamicStrings.Length(s) ; |
| c := 0 ; |
| n := 0 ; |
| negative := FALSE ; |
| IF n<l |
| THEN |
| (* parse leading + and - *) |
| WHILE (char(s, n)='-') OR (char(s, n)='+') DO |
| IF char(s, n)='-' |
| THEN |
| negative := NOT negative |
| END ; |
| INC(n) |
| END ; |
| WHILE (n<l) AND (IsDecimalDigitValidLong(char(s, n), base, c) OR |
| IsHexidecimalDigitValidLong(char(s, n), base, c)) DO |
| found := TRUE ; |
| INC(n) |
| END |
| END ; |
| s := KillString(s) ; |
| IF negative |
| THEN |
| RETURN( -VAL(LONGINT, LongMin(VAL(LONGCARD, MAX(LONGINT))+1, c)) ) |
| ELSE |
| RETURN( VAL(LONGINT, LongMin(MAX(LONGINT), c)) ) |
| END |
| END StringToLongInteger ; |
| |
| |
| (* |
| StringToInteger - converts a string, s, of, base, into an INTEGER. |
| Leading white space is ignored. It stops converting |
| when either the string is exhausted or if an illegal |
| numeral is found. |
| The parameter found is set TRUE if a number was found. |
| *) |
| |
| PROCEDURE StringToInteger (s: String; base: CARDINAL; |
| VAR found: BOOLEAN) : INTEGER ; |
| VAR |
| n, l : CARDINAL ; |
| c : CARDINAL ; |
| negative: BOOLEAN ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* returns a new string, s *) |
| l := DynamicStrings.Length(s) ; |
| c := 0 ; |
| n := 0 ; |
| negative := FALSE ; |
| IF n<l |
| THEN |
| (* parse leading + and - *) |
| WHILE (char(s, n)='-') OR (char(s, n)='+') DO |
| IF char(s, n)='-' |
| THEN |
| negative := NOT negative |
| END ; |
| INC(n) |
| END ; |
| WHILE (n<l) AND (IsDecimalDigitValid(char(s, n), base, c) OR |
| IsHexidecimalDigitValid(char(s, n), base, c)) DO |
| found := TRUE ; |
| INC(n) |
| END |
| END ; |
| s := KillString(s) ; |
| IF negative |
| THEN |
| RETURN( -VAL(INTEGER, Min(VAL(CARDINAL, MAX(INTEGER))+1, c)) ) |
| ELSE |
| RETURN( VAL(INTEGER, Min(MAX(INTEGER), c)) ) |
| END |
| END StringToInteger ; |
| |
| |
| (* |
| StringToCardinal - converts a string, s, of, base, into a CARDINAL. |
| Leading white space is ignored. It stops converting |
| when either the string is exhausted or if an illegal |
| numeral is found. |
| The parameter found is set TRUE if a number was found. |
| *) |
| |
| PROCEDURE StringToCardinal (s: String; base: CARDINAL; |
| VAR found: BOOLEAN) : CARDINAL ; |
| VAR |
| n, l: CARDINAL ; |
| c : CARDINAL ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* returns a new string, s *) |
| l := DynamicStrings.Length(s) ; |
| c := 0 ; |
| n := 0 ; |
| IF n<l |
| THEN |
| (* parse leading + *) |
| WHILE (char(s, n)='+') DO |
| INC(n) |
| END ; |
| WHILE (n<l) AND (IsDecimalDigitValid(char(s, n), base, c) OR |
| IsHexidecimalDigitValid(char(s, n), base, c)) DO |
| found := TRUE ; |
| INC(n) |
| END |
| END ; |
| s := KillString(s) ; |
| RETURN( c ) |
| END StringToCardinal ; |
| |
| |
| (* |
| stoi - decimal string to INTEGER |
| *) |
| |
| PROCEDURE stoi (s: String) : INTEGER ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToInteger(s, 10, found) ) |
| END stoi ; |
| |
| |
| (* |
| itos - integer to decimal string. |
| *) |
| |
| PROCEDURE itos (i: INTEGER; width: CARDINAL; padding: CHAR; sign: BOOLEAN) : String ; |
| BEGIN |
| RETURN( IntegerToString(i, width, padding, sign, 10, FALSE) ) |
| END itos ; |
| |
| |
| (* |
| ctos - cardinal to decimal string. |
| *) |
| |
| PROCEDURE ctos (c: CARDINAL; width: CARDINAL; padding: CHAR) : String ; |
| BEGIN |
| RETURN( CardinalToString(c, width, padding, 10, FALSE) ) |
| END ctos ; |
| |
| |
| (* |
| stoc - decimal string to CARDINAL |
| *) |
| |
| PROCEDURE stoc (s: String) : CARDINAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToCardinal(s, 10, found) ) |
| END stoc ; |
| |
| |
| (* |
| hstoi - hexidecimal string to INTEGER |
| *) |
| |
| PROCEDURE hstoi (s: String) : INTEGER ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToInteger(s, 16, found) ) |
| END hstoi ; |
| |
| |
| (* |
| ostoi - octal string to INTEGER |
| *) |
| |
| PROCEDURE ostoi (s: String) : INTEGER ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToInteger(s, 8, found) ) |
| END ostoi ; |
| |
| |
| (* |
| bstoi - binary string to INTEGER |
| *) |
| |
| PROCEDURE bstoi (s: String) : INTEGER ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToInteger(s, 2, found) ) |
| END bstoi ; |
| |
| |
| (* |
| hstoc - hexidecimal string to CARDINAL |
| *) |
| |
| PROCEDURE hstoc (s: String) : CARDINAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToCardinal(s, 16, found) ) |
| END hstoc ; |
| |
| |
| (* |
| ostoc - octal string to CARDINAL |
| *) |
| |
| PROCEDURE ostoc (s: String) : CARDINAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToCardinal(s, 8, found) ) |
| END ostoc ; |
| |
| |
| (* |
| bstoc - binary string to CARDINAL |
| *) |
| |
| PROCEDURE bstoc (s: String) : CARDINAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToCardinal(s, 2, found) ) |
| END bstoc ; |
| |
| |
| (* ********************************************************************** |
| R e a l a n d L o n g R e a l c o n v e r s i o n |
| ********************************************************************** *) |
| |
| |
| (* |
| ToThePower10 - returns a LONGREAL containing the value of v * 10^power. |
| *) |
| |
| PROCEDURE ToThePower10 (v: LONGREAL; power: INTEGER) : LONGREAL; |
| VAR |
| i: INTEGER ; |
| BEGIN |
| i := 0 ; |
| IF power>0 |
| THEN |
| WHILE i<power DO |
| v := v * 10.0 ; |
| INC(i) |
| END |
| ELSE |
| WHILE i>power DO |
| v := v / 10.0 ; |
| DEC(i) |
| END |
| END ; |
| RETURN( v ) |
| END ToThePower10 ; |
| |
| |
| (* |
| DetermineSafeTruncation - we wish to use TRUNC when converting REAL/LONGREAL |
| into a string for the non fractional component. |
| However we need a simple method to |
| determine the maximum safe truncation value. |
| *) |
| |
| PROCEDURE DetermineSafeTruncation () : CARDINAL ; |
| VAR |
| MaxPowerOfTen: REAL ; |
| LogPower : CARDINAL ; |
| BEGIN |
| MaxPowerOfTen := 1.0 ; |
| LogPower := 0 ; |
| WHILE MaxPowerOfTen*10.0<FLOAT(MAX(INTEGER) DIV 10) DO |
| MaxPowerOfTen := MaxPowerOfTen * 10.0 ; |
| INC(LogPower) |
| END ; |
| RETURN( LogPower ) |
| END DetermineSafeTruncation ; |
| |
| |
| (* |
| LongrealToString - converts a LONGREAL number, Real, which has, |
| TotalWidth, and FractionWidth into a string. |
| It uses decimal notation. |
| |
| So for example: |
| |
| LongrealToString(1.0, 4, 2) -> '1.00' |
| LongrealToString(12.3, 5, 2) -> '12.30' |
| LongrealToString(12.3, 6, 2) -> ' 12.30' |
| LongrealToString(12.3, 6, 3) -> '12.300' |
| |
| if total width is too small then the fraction |
| becomes truncated. |
| |
| LongrealToString(12.3, 5, 3) -> '12.30' |
| |
| Positive numbers do not have a '+' prepended. |
| Negative numbers will have a '-' prepended and |
| the TotalWidth will need to be large enough |
| to contain the sign, whole number, '.' and |
| fractional components. |
| *) |
| |
| PROCEDURE LongrealToString (x: LONGREAL; |
| TotalWidth, FractionWidth: CARDINAL) : String ; |
| VAR |
| maxprecision: BOOLEAN ; |
| s : String ; |
| r : ADDRESS ; |
| point : INTEGER ; |
| sign : BOOLEAN ; |
| l : INTEGER ; |
| BEGIN |
| IF TotalWidth=0 |
| THEN |
| maxprecision := TRUE ; |
| r := ldtoa(x, decimaldigits, 100, point, sign) |
| ELSE |
| r := ldtoa(x, decimaldigits, 100, point, sign) |
| END ; |
| s := InitStringCharStar(r) ; |
| free(r) ; |
| l := DynamicStrings.Length(s) ; |
| IF point>l |
| THEN |
| s := ConCat(s, Mark(Mult(Mark(InitStringChar('0')), point-l))) ; |
| s := ConCat(s, Mark(InitString('.0'))) ; |
| IF (NOT maxprecision) AND (FractionWidth>0) |
| THEN |
| DEC(FractionWidth) ; |
| IF VAL(INTEGER, FractionWidth)>point-l |
| THEN |
| s := ConCat(s, Mark(Mult(Mark(InitString('0')), FractionWidth))) |
| END |
| END |
| ELSIF point<0 |
| THEN |
| s := ConCat(Mult(Mark(InitStringChar('0')), -point), Mark(s)) ; |
| l := DynamicStrings.Length(s) ; |
| s := ConCat(InitString('0.'), Mark(s)) ; |
| IF (NOT maxprecision) AND (l<VAL(INTEGER, FractionWidth)) |
| THEN |
| s := ConCat(s, Mark(Mult(Mark(InitString('0')), VAL(INTEGER, FractionWidth)-l))) |
| END |
| ELSE |
| IF point=0 |
| THEN |
| s := ConCat(InitString('0.'), Mark(Slice(Mark(s), point, 0))) |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, point), '.'), |
| Mark(Slice(Mark(s), point, 0))) |
| END ; |
| IF (NOT maxprecision) AND (l-point<VAL(INTEGER, FractionWidth)) |
| THEN |
| s := ConCat(s, Mark(Mult(Mark(InitString('0')), VAL(INTEGER, FractionWidth)-(l-point)))) |
| END |
| END ; |
| IF DynamicStrings.Length(s)>TotalWidth |
| THEN |
| IF TotalWidth>0 |
| THEN |
| IF sign |
| THEN |
| s := Slice(Mark(ToDecimalPlaces(s, FractionWidth)), 0, TotalWidth-1) ; |
| s := ConCat(InitStringChar('-'), Mark(s)) ; |
| sign := FALSE |
| ELSE |
| (* minus 1 because all results will include a '.' *) |
| s := Slice(Mark(ToDecimalPlaces(s, FractionWidth)), 0, TotalWidth) ; |
| END |
| ELSE |
| IF sign |
| THEN |
| s := ToDecimalPlaces(s, FractionWidth) ; |
| s := ConCat(InitStringChar('-'), Mark(s)) ; |
| sign := FALSE |
| ELSE |
| (* minus 1 because all results will include a '.' *) |
| s := ToDecimalPlaces(s, FractionWidth) |
| END |
| END |
| END ; |
| IF DynamicStrings.Length(s)<TotalWidth |
| THEN |
| s := ConCat(Mult(Mark(InitStringChar(' ')), TotalWidth-DynamicStrings.Length(s)), Mark(s)) |
| END ; |
| RETURN( s ) |
| END LongrealToString ; |
| |
| |
| (* |
| StringToLongreal - returns a LONGREAL and sets found to TRUE if a legal number is seen. |
| *) |
| |
| PROCEDURE StringToLongreal (s: String; VAR found: BOOLEAN) : LONGREAL ; |
| VAR |
| error: BOOLEAN ; |
| value: LONGREAL ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* new string is created *) |
| value := strtold(string(s), error) ; |
| s := KillString(s) ; |
| found := NOT error ; |
| RETURN value |
| END StringToLongreal ; |
| |
| |
| (* |
| rtos - |
| *) |
| |
| PROCEDURE rtos (r: REAL; TotalWidth, FractionWidth: CARDINAL) : String ; |
| BEGIN |
| HALT ; |
| RETURN ( NIL ) |
| END rtos ; |
| |
| |
| (* |
| stor - returns a REAL given a string. |
| *) |
| |
| PROCEDURE stor (s: String) : REAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( VAL(REAL, StringToLongreal(s, found)) ) |
| END stor ; |
| |
| |
| (* |
| lrtos - |
| *) |
| |
| PROCEDURE lrtos (r: LONGREAL; TotalWidth, FractionWidth: CARDINAL) : String ; |
| BEGIN |
| HALT ; |
| RETURN ( NIL ) |
| END lrtos ; |
| |
| |
| (* |
| stolr - returns a LONGREAL given a string. |
| *) |
| |
| PROCEDURE stolr (s: String) : LONGREAL ; |
| VAR |
| found: BOOLEAN ; |
| BEGIN |
| RETURN( StringToLongreal(s, found) ) |
| END stolr ; |
| |
| |
| (* |
| LongCardinalToString - converts LONGCARD, c, into a String. The field |
| width can be specified if non zero. Leading |
| characters are defined by padding. |
| The base allows the caller to generate binary, |
| octal, decimal, hexidecimal numbers. |
| The value of lower is only used when hexidecimal |
| numbers are generated and if TRUE then digits |
| abcdef are used, and if FALSE then ABCDEF are used. |
| *) |
| |
| PROCEDURE LongCardinalToString (c: LONGCARD; width: CARDINAL; padding: CHAR; |
| base: CARDINAL; lower: BOOLEAN) : String ; |
| VAR |
| s: String ; |
| BEGIN |
| s := InitString('') ; |
| IF c>VAL(LONGCARD, base-1) |
| THEN |
| s := ConCat(ConCat(s, LongCardinalToString(c DIV VAL(LONGCARD, base), 0, ' ', base, lower)), |
| LongCardinalToString(c MOD VAL(LONGCARD, base), 0, ' ', base, lower)) |
| ELSE |
| IF c<=9 |
| THEN |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('0')))) |
| ELSE |
| IF lower |
| THEN |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('a')-10))) |
| ELSE |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('A')-10))) |
| END |
| END |
| END ; |
| IF width>DynamicStrings.Length(s) |
| THEN |
| RETURN( ConCat(Mult(Mark(InitStringChar(padding)), width-DynamicStrings.Length(s)), s) ) |
| END ; |
| RETURN( s ) |
| END LongCardinalToString ; |
| |
| |
| (* |
| StringToLongCardinal - converts a string, s, of, base, into a LONGCARD. |
| Leading white space is ignored. It stops converting |
| when either the string is exhausted or if an illegal |
| numeral is found. |
| The parameter found is set TRUE if a number was found. |
| *) |
| |
| PROCEDURE StringToLongCardinal (s: String; base: CARDINAL; VAR found: BOOLEAN) : LONGCARD ; |
| VAR |
| n, l: CARDINAL ; |
| c : LONGCARD ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* returns a new string, s *) |
| l := DynamicStrings.Length(s) ; |
| c := 0 ; |
| n := 0 ; |
| IF n<l |
| THEN |
| (* parse leading + *) |
| WHILE (char(s, n)='+') DO |
| INC(n) |
| END ; |
| WHILE (n<l) AND (IsDecimalDigitValidLong(char(s, n), base, c) OR |
| IsHexidecimalDigitValidLong(char(s, n), base, c)) DO |
| found := TRUE ; |
| INC(n) |
| END |
| END ; |
| s := KillString(s) ; |
| RETURN( c ) |
| END StringToLongCardinal ; |
| |
| |
| (* |
| ShortCardinalToString - converts SHORTCARD, c, into a String. The field |
| width can be specified if non zero. Leading |
| characters are defined by padding. |
| The base allows the caller to generate binary, |
| octal, decimal, hexidecimal numbers. |
| The value of lower is only used when hexidecimal |
| numbers are generated and if TRUE then digits |
| abcdef are used, and if FALSE then ABCDEF are used. |
| *) |
| |
| PROCEDURE ShortCardinalToString (c: SHORTCARD; width: CARDINAL; padding: CHAR; |
| base: CARDINAL; lower: BOOLEAN) : String ; |
| VAR |
| s: String ; |
| BEGIN |
| s := InitString('') ; |
| IF VAL(CARDINAL, c)>base-1 |
| THEN |
| s := ConCat(ConCat(s, ShortCardinalToString(c DIV VAL(SHORTCARD, base), 0, ' ', base, lower)), |
| ShortCardinalToString(c MOD VAL(SHORTCARD, base), 0, ' ', base, lower)) |
| ELSE |
| IF c<=9 |
| THEN |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('0')))) |
| ELSE |
| IF lower |
| THEN |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('a')-10))) |
| ELSE |
| s := ConCat(s, InitStringChar(CHR(VAL(CARDINAL, c)+ORD('A')-10))) |
| END |
| END |
| END ; |
| IF width>DynamicStrings.Length(s) |
| THEN |
| RETURN( ConCat(Mult(Mark(InitStringChar(padding)), width-DynamicStrings.Length(s)), s) ) |
| END ; |
| RETURN( s ) |
| END ShortCardinalToString ; |
| |
| |
| (* |
| StringToShortCardinal - converts a string, s, of, base, into a SHORTCARD. |
| Leading white space is ignored. It stops converting |
| when either the string is exhausted or if an illegal |
| numeral is found. |
| The parameter found is set TRUE if a number was found. |
| *) |
| |
| PROCEDURE StringToShortCardinal (s: String; base: CARDINAL; |
| VAR found: BOOLEAN) : SHORTCARD ; |
| VAR |
| n, l: CARDINAL ; |
| c : SHORTCARD ; |
| BEGIN |
| s := RemoveWhitePrefix(s) ; (* returns a new string, s *) |
| l := DynamicStrings.Length(s) ; |
| c := 0 ; |
| n := 0 ; |
| IF n<l |
| THEN |
| (* parse leading + *) |
| WHILE (char(s, n)='+') DO |
| INC(n) |
| END ; |
| WHILE (n<l) AND (IsDecimalDigitValidShort(char(s, n), base, c) OR |
| IsHexidecimalDigitValidShort(char(s, n), base, c)) DO |
| found := TRUE ; |
| INC(n) |
| END |
| END ; |
| s := KillString(s) ; |
| RETURN( c ) |
| END StringToShortCardinal ; |
| |
| |
| (* |
| ToDecimalPlaces - returns a floating point or base 10 integer |
| string which is accurate to, n, decimal |
| places. It will return a new String |
| and, s, will be destroyed. |
| Decimal places yields, n, digits after |
| the . |
| |
| So: 12.345 |
| |
| rounded to the following decimal places yields |
| |
| 5 12.34500 |
| 4 12.3450 |
| 3 12.345 |
| 2 12.34 |
| 1 12.3 |
| *) |
| |
| PROCEDURE ToDecimalPlaces (s: String; n: CARDINAL) : String ; |
| VAR |
| point: INTEGER ; |
| BEGIN |
| Assert(IsDigit(char(s, 0)) OR (char(s, 0)='.'), __FILE__, __LINE__, __FUNCTION__) ; |
| point := Index(s, '.', 0) ; |
| IF point<0 |
| THEN |
| IF n>0 |
| THEN |
| RETURN( ConCat(ConCat(s, Mark(InitStringChar('.'))), Mult(Mark(InitStringChar('0')), n)) ) |
| ELSE |
| RETURN( s ) |
| END |
| END ; |
| s := doDecimalPlaces(s, n) ; |
| (* if the last character is '.' remove it *) |
| IF (DynamicStrings.Length(s)>0) AND (char(s, -1)='.') |
| THEN |
| RETURN( Slice(Mark(s), 0, -1) ) |
| ELSE |
| RETURN( s ) |
| END |
| END ToDecimalPlaces ; |
| |
| |
| (* |
| doDecimalPlaces - returns a string which is accurate to |
| n decimal places. It returns a new String |
| and, s, will be destroyed. |
| *) |
| |
| PROCEDURE doDecimalPlaces (s: String; n: CARDINAL) : String ; |
| VAR |
| i, l, |
| point : INTEGER ; |
| t, |
| tenths, |
| hundreths: String ; |
| BEGIN |
| l := DynamicStrings.Length(s) ; |
| i := 0 ; |
| (* remove '.' *) |
| point := Index(s, '.', 0) ; |
| IF point=0 |
| THEN |
| s := Slice(Mark(s), 1, 0) |
| ELSIF point<l |
| THEN |
| s := ConCat(Slice(Mark(s), 0, point), |
| Mark(Slice(Mark(s), point+1, 0))) |
| ELSE |
| s := Slice(Mark(s), 0, point) |
| END ; |
| l := DynamicStrings.Length(s) ; |
| i := 0 ; |
| IF l>0 |
| THEN |
| (* skip over leading zeros *) |
| WHILE (i<l) AND (char(s, i)='0') DO |
| INC(i) |
| END ; |
| (* was the string full of zeros? *) |
| IF (i=l) AND (char(s, i-1)='0') |
| THEN |
| s := KillString(s) ; |
| s := ConCat(InitString('0.'), Mark(Mult(Mark(InitStringChar('0')), n))) ; |
| RETURN( s ) |
| END |
| END ; |
| (* add a leading zero in case we need to overflow the carry *) |
| (* insert leading zero *) |
| s := ConCat(InitStringChar('0'), Mark(s)) ; |
| INC(point) ; (* and move point position to correct place *) |
| l := DynamicStrings.Length(s) ; (* update new length *) |
| i := point ; |
| WHILE (n>1) AND (i<l) DO |
| DEC(n) ; |
| INC(i) |
| END ; |
| IF i+3<=l |
| THEN |
| t := Dup(s) ; |
| hundreths := Slice(Mark(s), i+1, i+3) ; |
| s := t ; |
| IF stoc(hundreths)>=50 |
| THEN |
| s := carryOne(Mark(s), i) |
| END ; |
| hundreths := KillString(hundreths) |
| ELSIF i+2<=l |
| THEN |
| t := Dup(s) ; |
| tenths := Slice(Mark(s), i+1, i+2) ; |
| s := t ; |
| IF stoc(tenths)>=5 |
| THEN |
| s := carryOne(Mark(s), i) |
| END ; |
| tenths := KillString(tenths) |
| END ; |
| (* check whether we need to remove the leading zero *) |
| IF char(s, 0)='0' |
| THEN |
| s := Slice(Mark(s), 1, 0) ; |
| DEC(l) ; |
| DEC(point) |
| END ; |
| IF i<l |
| THEN |
| s := Slice(Mark(s), 0, i) ; |
| l := DynamicStrings.Length(s) ; |
| IF l<point |
| THEN |
| s := ConCat(s, Mult(Mark(InitStringChar('0')), point-l)) |
| END |
| END ; |
| (* re-insert the point *) |
| IF point>=0 |
| THEN |
| IF point=0 |
| THEN |
| s := ConCat(InitStringChar('.'), Mark(s)) |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, point), '.'), |
| Mark(Slice(Mark(s), point, 0))) |
| END |
| END ; |
| RETURN( s ) |
| END doDecimalPlaces ; |
| |
| |
| (* |
| ToSigFig - returns a floating point or base 10 integer |
| string which is accurate to, n, significant |
| figures. It will return a new String |
| and, s, will be destroyed. |
| |
| |
| So: 12.345 |
| |
| rounded to the following significant figures yields |
| |
| 5 12.345 |
| 4 12.34 |
| 3 12.3 |
| 2 12 |
| 1 10 |
| *) |
| |
| PROCEDURE ToSigFig (s: String; n: CARDINAL) : String ; |
| VAR |
| point: INTEGER ; |
| poTen: CARDINAL ; |
| BEGIN |
| Assert(IsDigit(char(s, 0)) OR (char(s, 0)='.'), __FILE__, __LINE__, __FUNCTION__) ; |
| point := Index(s, '.', 0) ; |
| IF point<0 |
| THEN |
| poTen := DynamicStrings.Length(s) |
| ELSE |
| poTen := point |
| END ; |
| s := doSigFig(s, n) ; |
| (* if the last character is '.' remove it *) |
| IF (DynamicStrings.Length(s)>0) AND (char(s, -1)='.') |
| THEN |
| RETURN( Slice(Mark(s), 0, -1) ) |
| ELSE |
| IF poTen>DynamicStrings.Length(s) |
| THEN |
| s := ConCat(s, Mark(Mult(Mark(InitStringChar('0')), poTen-DynamicStrings.Length(s)))) |
| END ; |
| RETURN( s ) |
| END |
| END ToSigFig ; |
| |
| |
| (* |
| doSigFig - returns a string which is accurate to |
| n decimal places. It returns a new String |
| and, s, will be destroyed. |
| *) |
| |
| PROCEDURE doSigFig (s: String; n: CARDINAL) : String ; |
| VAR |
| i, l, z, |
| point : INTEGER ; |
| t, |
| tenths, |
| hundreths: String ; |
| BEGIN |
| l := DynamicStrings.Length(s) ; |
| i := 0 ; |
| (* remove '.' *) |
| point := Index(s, '.', 0) ; |
| IF point>=0 |
| THEN |
| IF point=0 |
| THEN |
| s := Slice(Mark(s), 1, 0) |
| ELSIF point<l |
| THEN |
| s := ConCat(Slice(Mark(s), 0, point), |
| Mark(Slice(Mark(s), point+1, 0))) |
| ELSE |
| s := Slice(Mark(s), 0, point) |
| END |
| ELSE |
| s := Dup(Mark(s)) |
| END ; |
| l := DynamicStrings.Length(s) ; |
| i := 0 ; |
| IF l>0 |
| THEN |
| (* skip over leading zeros *) |
| WHILE (i<l) AND (char(s, i)='0') DO |
| INC(i) |
| END ; |
| (* was the string full of zeros? *) |
| IF (i=l) AND (char(s, i-1)='0') |
| THEN |
| (* truncate string *) |
| s := Slice(Mark(s), 0, n) ; |
| i := n |
| END |
| END ; |
| (* add a leading zero in case we need to overflow the carry *) |
| z := i ; (* remember where we inserted zero *) |
| IF z=0 |
| THEN |
| s := ConCat(InitStringChar('0'), Mark(s)) |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, i), '0'), |
| Mark(Slice(Mark(s), i, 0))) |
| END ; |
| INC(n) ; (* and increase the number of sig figs needed *) |
| l := DynamicStrings.Length(s) ; |
| WHILE (n>1) AND (i<l) DO |
| DEC(n) ; |
| INC(i) |
| END ; |
| IF i+3<=l |
| THEN |
| t := Dup(s) ; |
| hundreths := Slice(Mark(s), i+1, i+3) ; |
| s := t ; |
| IF stoc(hundreths)>=50 |
| THEN |
| s := carryOne(Mark(s), i) |
| END ; |
| hundreths := KillString(hundreths) |
| ELSIF i+2<=l |
| THEN |
| t := Dup(s) ; |
| tenths := Slice(Mark(s), i+1, i+2) ; |
| s := t ; |
| IF stoc(tenths)>=5 |
| THEN |
| s := carryOne(Mark(s), i) |
| END ; |
| tenths := KillString(tenths) |
| END ; |
| (* check whether we need to remove the leading zero *) |
| IF char(s, z)='0' |
| THEN |
| IF z=0 |
| THEN |
| s := Slice(Mark(s), z+1, 0) |
| ELSE |
| s := ConCat(Slice(Mark(s), 0, z), |
| Mark(Slice(Mark(s), z+1, 0))) |
| END ; |
| l := DynamicStrings.Length(s) |
| ELSE |
| INC(point) |
| END ; |
| IF i<l |
| THEN |
| s := Slice(Mark(s), 0, i) ; |
| l := DynamicStrings.Length(s) ; |
| IF l<point |
| THEN |
| s := ConCat(s, Mult(Mark(InitStringChar('0')), point-l)) |
| END |
| END ; |
| (* re-insert the point *) |
| IF point>=0 |
| THEN |
| IF point=0 |
| THEN |
| s := ConCat(InitStringChar('.'), Mark(s)) |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, point), '.'), |
| Mark(Slice(Mark(s), point, 0))) |
| END |
| END ; |
| RETURN( s ) |
| END doSigFig ; |
| |
| |
| (* |
| carryOne - add a carry at position, i. |
| *) |
| |
| PROCEDURE carryOne (s: String; i: CARDINAL) : String ; |
| BEGIN |
| IF i>=0 |
| THEN |
| IF IsDigit(char(s, i)) |
| THEN |
| IF char(s, i)='9' |
| THEN |
| IF i=0 |
| THEN |
| s := ConCat(InitStringChar('1'), Mark(s)) ; |
| RETURN s |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, i), '0'), |
| Mark(Slice(Mark(s), i+1, 0))) ; |
| RETURN carryOne(s, i-1) |
| END |
| ELSE |
| IF i=0 |
| THEN |
| s := ConCat(InitStringChar(CHR(ORD(char(s, i))+1)), |
| Mark(Slice(Mark(s), i+1, 0))) |
| ELSE |
| s := ConCat(ConCatChar(Slice(Mark(s), 0, i), |
| CHR(ORD(char(s, i))+1)), |
| Mark(Slice(Mark(s), i+1, 0))) |
| END |
| END |
| END |
| END ; |
| RETURN s |
| END carryOne ; |
| |
| |
| END StringConvert. |
