LnSOS BOOT 1.1
SOS.KERNEL SOS KRNLI/O ERROR FILE 'SOS.KERNEL' NOT FOUND% INVALID KERNEL FILE: xةw,@ ȱlmi8# )! ) O ^ ±± *SOS.INTERP 4 ke 6 !
*SOS.KERNEL , V 6 ! a .SOS.STATE.TEXT 8 !
-STR2REAL.CODE 1 !2 -STR2REAL.TEXT ) P !0 %SEG.T j ' Ÿ/
{ /MUSIC.TEST.CODEf ) ) /MUSIC.TEST.TEXTb ( ( *MUSIC.TEXT E 8 . . )DISK.INFO j +( @, 68 *SOS.DRIVER 4 ' Z .SOS.HEART.TEXT ! III.PCL.13 u '
DISKNAME.DAT 6 6 FLASHNAME.DAT
G 6 6 HELLO 6 / *HELLO.TEXT 6 *MENU.MAKER
} & > *MUSIC.CODE A >dLԡm#i 㰼m#i ЕOLԡȱfg hi
!dLԡ 憦
Ljmkm l y`2 Lԡ8(Je稽)ʈ@L
!"#$%&'()*+,-./ ----------------------------------
| Routine : kill_character
| Purpose : Remove all occurences of a character from a string
| Input : a_string - String to remove characters from
| char_to_kill - Character to remove
| Output : a_{ =====================================================================
||| UTILITY ROUTINES |||
===================================================================== }
{ ----------------------------------- g_UserIsDone : BOOLEAN; { User termination flag }
g_NumericString : t_String; { User's numeric string }
g_FPValue : t_FPNumber; { Conversion result }
g_FPError : t_FPError; { Conversion error }
{ A floating point number }
t_FPError = (fp_None, { Error - None }
fp_NullString, { Error - Empty string }
fp_BadCharacter); { Error - Invalid string character }
VAR
*************************************************************** }
PROGRAM Convert_String_to_REAL; {$I-}
CONST
k_Debug = TRUE; { Enable or disable debugger }
TYPE
t_String = STRING[63]; { A string }
t_FPNumber = REAL; *
* 12e+9 *
* .12345 *
* *
****** * *
* <+|->
<.> [<+|->] *
* *
* Examples: -123.456E-7 t value. *
* An error is returned if the string is invalid. *
* *
* String format: *
omputer....: Apple /// *
* *
* Purpose.....: Convert a string representing a floating point *
* number into a floating poin *
* Author......: David T. Craig [736 Edgewater, Wichita KS 67230] *
* Date........: 1985 *
* Language....: Apple /// Pascal 1.1 *
* C
{ *********************************************************************
* *
* Program.....: Convert_String_to_REAL *
* string - String with specified character removed
--------------------------------------------------------------------- }
PROCEDURE kill_character(VAR a_string : t_String;
char_to_kill : CHAR);
VAR
char_string : STRING[1]; { A character string }
BEGIN { kill_character }
IF (LENGTH(a_string) > 0) THEN
BEGIN
char_string := '?'; { Setup kill character string }
char_string[1] := char_to_kill;
WHIs }
tail : t_String; { Tail (fraction) digits }
exp_sign : t_Sign; { Sign of exponent digits }
exponent : t_String; { Exponent digits }
{ --------------------------------------------------------------------- positive);
VAR
result_number : t_FPNumber; { Result of conversion }
c_index : INTEGER; { String character index }
head_sign : t_Sign; { Sign of head digits }
head : t_String; { Head digit VAR error : t_FPError)
: t_FPNumber;
{ String format: <+|-><.><+|-> }
TYPE
t_Sign = (negative, { Number sign }
the
| converted value, else the converted value is unspecified.
--------------------------------------------------------------------- }
FUNCTION string_to_number( num_string : t_String;
r
| Purpose : Convert a numeric string to a floating point value
| Input : num_string - Numeric string to convert
| Output : error - Conversion error result (fp_NoError --> ok)
| If no error occures, then string_to_number returns =======
||| STRING TO NUMBER CONVERSION ROUTINE |||
===================================================================== }
{ ---------------------------------------------------------------------
| Routine : string_to_numbe fp_BadCharacter : e_phrase := 'Invalid character in string';
END;
IF (LENGTH(e_phrase) > 0) THEN
WRITELN('*** ERROR : ',e_phrase);
END; { show_FP_error }
{ ==============================================================Error phrase }
BEGIN { show_FP_error }
CASE fp_error OF
fp_None : e_phrase := ''; { All is well }
fp_NullString : e_phrase := 'String is empty';
rsion error
| Input : fp_error - Error which occured
| Output : Error phrase displayed
--------------------------------------------------------------------- }
PROCEDURE show_FP_error(fp_error : t_FPError);
VAR
e_phrase : t_String; { c_index - 1;
END;
UNTIL (c_index = 0);
END;
END; { uppercase_string }
{ ---------------------------------------------------------------------
| Routine : show_FP_error
| Purpose : Display floating point string conve IF ((a_string[c_index] >= 'a') AND
(a_string[c_index] <= 'z')) THEN
a_string[c_index] := CHR(ORD(a_string[c_index]) -
ORD('a') + ORD('A'));
c_index :=_string(VAR a_string : t_String);
VAR
c_index : 0..255; { String character index }
BEGIN { uppercase_string }
IF (LENGTH(a_string) > 0) THEN
BEGIN
c_index := LENGTH(a_string);
REPEAT
BEGIN
Uppercase all lower case letters in a string
| Input : a_string - String to uppercase
| Output : a_string - String with all lowercase letters uppercased
--------------------------------------------------------------------- }
PROCEDURE uppercaseLE (POS(char_string,a_string) > 0) DO
DELETE(a_string,POS(char_string,a_string),1);
END;
END; { kill_character }
{ ---------------------------------------------------------------------
| Routine : uppercase_string
| Purpose : }
PROCEDURE bump_char_index;
BEGIN { bump_char_index }
c_index := c_index + 1;
END; { bump_char_index }
{ --------------------------------------------------------------------- }
FUNCTION get_character : CHAR;
BEGIN { get_character }
get_character := num_string[c_index];
END; { get_character }
{ --------------------------------------------------------------------- }
FUNCTION valid_character(VAR fp_error : t_FPError) : BOOLEAN;
B { Point at the next character }
terminator_found := FALSE;
IF NOT(end_of_string) THEN { Parse the following digits }
REPEAT
BEGIN
IF NOT(valid_character(fp_error)) THEN
terminator_foundng);
VAR
terminator_found : BOOLEAN;
BEGIN { get_digits }
fp_error := fp_None; { Initialize return error }
a_string := '?'; { Parse the 1st digit }
a_string[1] := get_character;
bump_char_index; get_sign := positive;
bump_char_index;
END; { get_sign }
{ --------------------------------------------------------------------- }
PROCEDURE get_digits(VAR fp_error : t_FPError;
VAR a_string : t_Stri; { e_found }
{ --------------------------------------------------------------------- }
FUNCTION get_sign : t_Sign;
BEGIN { get_sign }
IF (get_character = '-') THEN
get_sign := negative
ELSE
IF NOT(end_of_string) THEN
BEGIN
IF valid_character(fp_error) THEN
e_found := (get_character = 'E')
ELSE
e_found := FALSE;
END
ELSE
e_found := FALSE;
ENDLSE
period_found := FALSE;
END; { period_found }
{ --------------------------------------------------------------------- }
FUNCTION e_found(VAR fp_error : t_FPError) : BOOLEAN;
BEGIN { e_found }
fp_error := fp_None;
fp_error := fp_None;
IF NOT(end_of_string) THEN
BEGIN
IF valid_character(fp_error) THEN
period_found := (get_character = '.')
ELSE
period_found := FALSE;
END
E ELSE
digit_found := FALSE;
END; { digit_found }
{ --------------------------------------------------------------------- }
FUNCTION period_found(VAR fp_error : t_FPError) : BOOLEAN;
BEGIN { period_found }
}
fp_error := fp_None;
IF NOT(end_of_string) THEN
BEGIN
IF valid_character(fp_error) THEN
digit_found := (get_character IN ['0'..'9'])
ELSE
digit_found := FALSE;
END
FALSE;
END
ELSE
sign_found := FALSE;
END; { sign_found }
{ --------------------------------------------------------------------- }
FUNCTION digit_found(VAR fp_error : t_FPError) : BOOLEAN;
BEGIN { digit_found BEGIN { sign_found }
fp_error := fp_None;
IF NOT(end_of_string) THEN
BEGIN
IF valid_character(fp_error) THEN
sign_found := (get_character IN ['-','+'])
ELSE
sign_found := nd_of_string }
end_of_string := (c_index > LENGTH(num_string));
END; { end_of_string }
{ --------------------------------------------------------------------- }
FUNCTION sign_found(VAR fp_error : t_FPError) : BOOLEAN;
valid_character := FALSE;
fp_error := fp_BadCharacter;
END;
END; { valid_character }
{ --------------------------------------------------------------------- }
FUNCTION end_of_string : BOOLEAN;
BEGIN { eEGIN { valid_character }
IF get_character IN ['+','-','0'..'9','.','E']
THEN
BEGIN
valid_character := TRUE;
fp_error := fp_None;
END
ELSE
BEGIN
:= TRUE
ELSE
BEGIN
IF NOT(digit_found(fp_error)) THEN
terminator_found := TRUE
ELSE
BEGIN
a_string := CONCAT(a_string,'?');
a_string[LENGTH(a_string)] := get_character;
bump_char_index;
END;
END;
END;
UN;
WRITELN('DEBUG: tail = "',tail,'"');
WRITE ('DEBUG: exp_sign = '); show_sign(exp_sign);
WRITELN('DEBUG: exponent = "',exponent,'"');
END; { bug_show_number_parts }
{ ------------------------------------------------ositive THEN
WRITELN('+')
ELSE
WRITELN('-');
END; { show_sign }
BEGIN { bug_show_number_parts }
WRITE ('DEBUG: head_sign = '); show_sign(head_sign);
WRITELN('DEBUG: head = "',head,'"') END; { compute_number_from_parts }
{ --------------------------------------------------------------------- }
PROCEDURE bug_show_number_parts;
PROCEDURE show_sign(the_sign : t_Sign);
BEGIN { show_sign }
IF the_sign = p0 THEN
compute_number_from_parts :=
(head_number + tail_number) * (PWROFTEN(TRUNC(exp_number)))
(ELSE
*compute_number_from_parts :=
,(head_number + tail_number) / (PWROFTEN(-TRUNC(exp_number)));
xp_sign = negative) THEN
exp_number := -exp_number;
IF k_Debug THEN
WRITELN('DEBUG: exp_number (FP) = ',exp_number:15:7);
{ Combine the head, tail, and exponent parts into a single number }
(IF TRUNC(exp_number) >= := digit_power - 1;
num_digit := ORD(exponent[digit]) - ORD('0');
exp_number := exp_number + num_digit*(PWROFTEN(digit_power));
digit := digit + 1;
END;
UNTIL (digit_power = 0);
IF (e WRITELN('DEBUG: tail_number (FP) = ',tail_number:15:7);
{ Compute the exponent part }
exp_number := 0.0;
digit_power := LENGTH(exponent);
digit := 1;
REPEAT
BEGIN
digit_powergit + 1;
digit_power := digit_power + 1;
END;
UNTIL (digit_power > LENGTH(tail));
IF (head_sign = negative) THEN
tail_number := -tail_number;
IF k_Debug THEN
er := 0.0;
digit_power := 1;
digit := 1;
REPEAT
BEGIN
num_digit := ORD(tail[digit]) - ORD('0');
tail_number := tail_number + num_digit/(PWROFTEN(digit_power));
digit := diIL (digit_power = 0);
IF (head_sign = negative) THEN
head_number := -head_number;
IF k_Debug THEN
WRITELN('DEBUG: head number (FP) = ',head_number:15:7);
{ Compute the tail (fraction) part }
tail_numb BEGIN
digit_power := digit_power - 1;
num_digit := ORD(head[digit]) - ORD('0');
head_number := head_number + num_digit*(PWROFTEN(digit_power));
digit := digit + 1;
END;
UNT num_digit : INTEGER; { Numeric value of a digit }
BEGIN { compute_number_from_parts }
{ Compute the head part }
head_number := 0.0;
digit_power := LENGTH(head);
digit := 1;
REPEAT
FP number }
tail_number : t_FPNumber; { Tail part FP number }
exp_number : t_FPNumber; { Exponent part FP number }
digit_power : INTEGER; { Digit power value }
digit : INTEGER; { Digit index in string }
TIL end_of_string OR terminator_found;
END; { get_digits }
{ --------------------------------------------------------------------- }
FUNCTION compute_number_from_parts : t_FPNumber;
VAR
head_number : t_FPNumber; { Head part --------------------- }
BEGIN { string_to_number }
error := fp_NullString; { Initialize return parameters }
result_number := 0.0;
kill_character(num_string,' '); { Remove all Spaces }
IF (LENGTH(num_string) > 0) THEN
BEGIN
error := fp_None; { All is well, so far }
{ Initialize numeric string parts (+0.0E+0 = 0)}
head_sign := positive;
head := '0';
tail := '0';
END. { Convert_String_to_REAL }
{ =====================================================================
||| FINIS |||
===================================================================== }
show_FP_error(g_FPError)
ELSE
WRITELN('g_NumericString = ',g_FPValue:15:7);
END;
END;
UNTIL g_UserIsDone;
{ Aufwiedersehen }
WRITELN;
WRITELN('That''s all, Folks...');
READLN(g_NumericString);
g_UserIsDone := (LENGTH(g_NumericString) = 0);
IF NOT(g_UserIsDone) THEN
BEGIN
g_FPValue := string_to_number(g_NumericString,g_FPError);
IF (g_FPError <> fp_None) THEN
END;
{ Fetch user strings until the user is done, and convert each fetched }
{ string to a floating point value. }
REPEAT
BEGIN
WRITE('Enter a numeric string [Press to Quit] ? '); { Introduce yourself to the user }
WRITELN('String to REAL number converter [David Craig - 1985]');
WRITELN;
IF k_Debug THEN { Introduce the debugger (if he's present) }
BEGIN
WRITELN('Debugger installed');
WRITELN;
===========================================================
||| THE MAIN EVENT |||
===================================================================== }
BEGIN { Convert_String_to_REAL }
IF k_Debug THEN bug_show_number_parts;
result_number := compute_number_from_parts;
END;
END;
string_to_number := result_number; { Return result to caller }
END; { string_to_number }
{ ========== IF (error = fp_None) THEN
IF digit_found(error) THEN
get_digits(error,exponent);
END;
{ Compute floating point value from parsed parts }
IF (error = fp_None) THEN
BEGIN
IF (error = fp_None) THEN { Extract 'E' <+|-> }
IF e_found(error) THEN
BEGIN
bump_char_index;
IF sign_found(error) THEN
exp_sign := get_sign;
_None) THEN { Extract head/tail period }
IF period_found(error) THEN
bump_char_index;
IF (error = fp_None) THEN { Extract tail digits }
IF digit_found(error) THEN
get_digits(error,tail);
IF sign_found(error) THEN { Extract head sign }
head_sign := get_sign;
IF (error = fp_None) THEN { Extract head digits }
IF digit_found(error) THEN
get_digits(error,head);
IF (error = fp exp_sign := positive;
exponent := '0';
{ Parse string into the appropriate parts }
uppercase_string(num_string); { Handle only majuscule letters }
c_index := 1; { Start at the first string character }
> CONVERTS O ^ C (צDebugger installed צ2Enter a numeric string [Press to Quit] ? ? ëꓡF$&