home *** CD-ROM | disk | FTP | other *** search
/ Programmer's ROM - The Computer Language Library / programmersrom.iso / ada / math / m36test.src < prev    next >
Encoding:
Text File  |  1988-05-03  |  79.9 KB  |  2,271 lines
  1. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  2. --sample.txt
  3. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  4. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  5. with TEXT_IO; use TEXT_IO;
  6.  
  7. procedure PRINT_SOME_TARGET_SHORT_FLOAT_RESULTS is
  8. --
  9. --  This procedure prompts the user for several operands and
  10. --  then prints the results of selected TARGET_SHORT_FLOAT operations.
  11. --
  12.    B_RESULT : BOOLEAN;
  13.    LAST : POSITIVE;
  14.    NO_DATA : EXCEPTION;
  15.    POWER : INTEGER;
  16.    RESULTS_STRING : STRING (1..TARGET_SHORT_FLOAT_DIGITS+7);
  17.    SF1, SF2 : TARGET_SHORT_FLOAT;
  18.    SFRESULT, SFRESULT1 : TARGET_SHORT_FLOAT;
  19.  
  20.    procedure GET_TARGET_SHORT_FLOAT_OPERANDS is
  21.    -- 
  22.    --  Get two TARGET_SHORT_FLOAT operands plus an Integer number for
  23.    --  use as a power in a exponentiation operation
  24.    --   
  25.       CNT, CNT1 : NATURAL;
  26.       DONE : BOOLEAN := FALSE;
  27.       EXIT_MENU : exception;
  28.       OP_STRING : STRING (1..80);
  29.    begin
  30.       loop
  31.          begin
  32.             PUT_LINE("MACHINE ARITHMETIC EMULATION");
  33.             PUT_LINE("TARGET_SHORT_FLOAT OPERATIONS");
  34.             PUT_LINE("OPERAND INPUT");
  35.             NEW_LINE;
  36.             TEXT_IO.PUT("OP1 ? ");
  37.             GET_LINE(OP_STRING, CNT);
  38.             if CNT = 0 then
  39.                raise EXIT_MENU;
  40.             end if;
  41.    
  42.             GET (OP_STRING(1..CNT),SF1,LAST);
  43.  
  44.             NEW_LINE;
  45.             TEXT_IO.PUT("POWER ? ");
  46.             GET_LINE(OP_STRING, CNT);
  47.             if CNT = 0 then
  48.                raise EXIT_MENU;
  49.             end if;
  50.  
  51.             INTEGER_IO.GET (OP_STRING(1..CNT),POWER,CNT1);        
  52.                -- no INTEGER'value function implemented
  53.  
  54.             NEW_LINE;
  55.             TEXT_IO.PUT("OP2 ? ");
  56.             GET_LINE(OP_STRING, CNT);
  57.             if CNT = 0 then
  58.                raise EXIT_MENU;
  59.             end if;
  60.  
  61.             GET (OP_STRING(1..CNT),SF2,LAST);
  62.  
  63.             DONE := TRUE;
  64.  
  65.          exception
  66.             when EXIT_MENU =>
  67.                raise NO_DATA;
  68.  
  69.             when others =>
  70.                PUT_LINE("*** ILLEGAL DATA ***");
  71.                NEW_LINE;
  72.                TEXT_IO.PUT("return to continue ...");
  73.  
  74.          end;
  75.  
  76.          if DONE then
  77.             exit;
  78.          end if;
  79.       end loop;
  80.  
  81.    end GET_TARGET_SHORT_FLOAT_OPERANDS;
  82.  
  83.  
  84. begin
  85.  
  86.    -- get the operands
  87.    GET_TARGET_SHORT_FLOAT_OPERANDS;
  88.  
  89.    -- print the results of TARGET_SHORT_FLOAT "+"
  90.    TEXT_IO.PUT("OP1 + OP2                = ");
  91.    SFRESULT := SF1 + SF2;
  92.    PUT(RESULTS_STRING,SFRESULT);
  93.    PUT_LINE(RESULTS_STRING);
  94.  
  95.    -- print the results of TARGET_SHORT_FLOAT "-"
  96.    TEXT_IO.PUT("OP1 - OP2                = ");
  97.    SFRESULT := SF1 - SF2;
  98.    PUT(RESULTS_STRING,SFRESULT);
  99.    PUT_LINE(RESULTS_STRING);
  100.  
  101.    -- print the results of TARGET_SHORT_FLOAT "*"
  102.    TEXT_IO.PUT("OP1 * OP2                = ");
  103.    SFRESULT := SF1 * SF2;
  104.    PUT(RESULTS_STRING,SFRESULT);
  105.    PUT_LINE(RESULTS_STRING);
  106.  
  107.    -- print the results of TARGET_SHORT_FLOAT "/"
  108.    TEXT_IO.PUT("OP1 / OP2                = ");
  109.    SFRESULT := SF1 / SF2;
  110.    PUT(RESULTS_STRING,SFRESULT);
  111.    PUT_LINE(RESULTS_STRING);
  112.  
  113.    -- print the results of TARGET_SHORT_FLOAT ">"
  114.    TEXT_IO.PUT("OP1 > OP2                = ");
  115.    B_RESULT := SF1 > SF2;
  116.    TEXT_IO.PUT(BOOLEAN'image(B_RESULT));
  117.    NEW_LINE;
  118.  
  119.    -- print the results of TARGET_SHORT_FLOAT "**"
  120.    TEXT_IO.PUT("OP1 ** POWER             = ");
  121.    SFRESULT1 := SF1 ** POWER;
  122.    PUT(RESULTS_STRING,SFRESULT1);
  123.    PUT_LINE(RESULTS_STRING);
  124.  
  125. end PRINT_SOME_TARGET_SHORT_FLOAT_RESULTS;
  126. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  127. --testall.txt
  128. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  129. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  130. with TESTTI; use TESTTI;
  131. with TESTTSF; use TESTTSF;
  132. with TESTTLF; use TESTTLF;
  133. with TEXT_IO; use TEXT_IO;
  134. use INTEGER_IO; 
  135. use FLOAT_IO;
  136.  
  137. procedure TESTALL is
  138.  
  139.    procedure GET_OPERATION_TYPE is
  140.    begin
  141.       loop
  142.          NEW_SCREEN;
  143.          TEXT_IO.PUT_LINE("MACHINE ARITHMETIC EMULATION");
  144.          TEXT_IO.PUT_LINE("OPERATION SELECTION MENU");
  145.          TEXT_IO.NEW_LINE;
  146.          TEXT_IO.NEW_LINE;
  147.          TEXT_IO.PUT_LINE("A => ADD/SUBTRACT OPERATIONS");
  148.          TEXT_IO.NEW_LINE;
  149.          TEXT_IO.PUT_LINE("B => MULTIPLY/DIVIDE OPERATIONS");
  150.          TEXT_IO.NEW_LINE;
  151.          TEXT_IO.PUT_LINE("C => COMPARISION OPERATIONS");
  152.          TEXT_IO.NEW_LINE;
  153.          TEXT_IO.PUT_LINE("D => MODULO/REMAINDER OPERATIONS");
  154.          TEXT_IO.NEW_LINE;
  155.          TEXT_IO.PUT_LINE("E => ALL OF ABOVE OPERATIONS");
  156.          TEXT_IO.NEW_LINE;
  157.          TEXT_IO.PUT_LINE("F => EXPONENTIATION OPERATIONS");
  158.          TEXT_IO.NEW_LINE;
  159.          TEXT_IO.NEW_LINE;
  160.          TEXT_IO.PUT_LINE("X => EXIT TO MAIN MENU");
  161.          TEXT_IO.NEW_LINE;
  162.          TEXT_IO.PUT("SELECTION ? ");
  163.          TEXT_IO.GET(OPERATION_TYPE);
  164.  
  165.          case OPERATION_TYPE is
  166.             when 'a'|'b'|'c'|'e'|'f' =>
  167.                exit;
  168.             when 'A'|'B'|'C'|'E'|'F' =>
  169.                exit;
  170.  
  171.             when 'd' | 'D' =>
  172.                if (OPERAND_TYPE = 'a') or (OPERAND_TYPE = 'A') then
  173.                   exit;
  174.                else
  175.                   TEXT_IO.PUT_LINE("*** MODULO/REMAINDER OPERATIONS ARE " &
  176.                            "INVALID FOR REALS ***");
  177.  
  178.                   TEXT_IO.PUT("return to continue ...");
  179.                   TEXT_IO.GET_LINE(DUMMY,CNT);
  180.                end if;
  181.  
  182.             when 'x' | 'X' =>
  183.                raise NO_DATA;
  184.                exit;
  185.  
  186.             when others =>
  187.                TEXT_IO.PUT_LINE("*** ILLEGAL DATA ***");
  188.  
  189.                TEXT_IO.PUT("return to continue ...");
  190.                TEXT_IO.GET_LINE(DUMMY,CNT);
  191.  
  192.          end case;
  193.  
  194.       end loop;
  195.  
  196.    end GET_OPERATION_TYPE;
  197.  
  198.    begin
  199.  
  200.       CREATE(LOG_FILE,OUT_FILE,"LOGFILE.MAE");
  201.       INT_GET_AND_PUT_FLAG := TRUE;
  202.       SHORT_AFT := TARGET_SHORT_FLOAT_DIGITS-1;
  203.       SHORT_EXP := 3;
  204.       LONG_AFT := TARGET_LONG_FLOAT_DIGITS-1;
  205.       LONG_EXP := 3;
  206.       
  207.       loop
  208.       begin
  209.          NEW_SCREEN;
  210.          TEXT_IO.PUT_LINE("MACHINE ARITHMETIC EMULATION");
  211.          TEXT_IO.PUT_LINE("MAIN MENU");
  212.          TEXT_IO.NEW_LINE;
  213.          TEXT_IO.PUT_LINE("A => INTEGER OPERATIONS");
  214.          TEXT_IO.NEW_LINE;
  215.          TEXT_IO.PUT_LINE("B => SHORT FLOAT OPERATIONS");
  216.          TEXT_IO.NEW_LINE;
  217.          TEXT_IO.PUT_LINE("C => LONG FLOAT OPERATIONS");
  218.          TEXT_IO.NEW_LINE;
  219.          TEXT_IO.PUT_LINE("Q => SET INTEGER_IO TO GET AND PUT");
  220.          TEXT_IO.PUT_LINE("R => SET INTEGER_IO TO VALUE AND IMAGE");
  221.          TEXT_IO.NEW_LINE;
  222.          TEXT_IO.PUT_LINE("S => RESET PUT PARAMETERS TO DEFAULT");
  223.          TEXT_IO.PUT_LINE("T => SET PUT PARAMETERS");
  224.          TEXT_IO.NEW_LINE;
  225.          TEXT_IO.PUT_LINE("U => TURN ON SYSTEM RESULT TRACE");
  226.          TEXT_IO.PUT_LINE("V => SHUT OFF SYSTEM RESULT TRACE");
  227.          TEXT_IO.NEW_LINE;
  228.          TEXT_IO.PUT_LINE("X => QUIT");
  229.          TEXT_IO.NEW_LINE;
  230.          TEXT_IO.PUT("SELECTION ? ");
  231.          TEXT_IO.GET(OPERAND_TYPE);
  232.  
  233.          case OPERAND_TYPE is
  234.  
  235.             when 'a' | 'A' =>
  236.                loop
  237.                begin
  238.                   DONE := FALSE;
  239.                   GET_OPERATION_TYPE;
  240.                   GET_INTEGER_OPERANDS;
  241.                   PUT_INTEGER_RESULTS;
  242.  
  243.                exception
  244.                   when NO_DATA =>
  245.                      DONE := TRUE;
  246.                end;
  247.                   if DONE then
  248.                      exit;
  249.                   end if;
  250.                end loop;
  251.  
  252.             when 'b' | 'B' =>
  253.                loop
  254.                begin
  255.                   DONE := FALSE;
  256.                   GET_OPERATION_TYPE;
  257.                   GET_SHORT_FLOAT_OPERANDS;
  258.                   PUT_SHORT_FLOAT_RESULTS;
  259.  
  260.                exception
  261.                   when NO_DATA =>
  262.                      DONE := TRUE;
  263.                end;
  264.                   if DONE then
  265.                      exit;
  266.                   end if;
  267.                end loop;
  268.  
  269.             when 'c' | 'C' =>
  270.                loop
  271.                begin
  272.                   DONE := FALSE;
  273.                   GET_OPERATION_TYPE;
  274.                   GET_LONG_FLOAT_OPERANDS;
  275.                   PUT_LONG_FLOAT_RESULTS;
  276.  
  277.                exception
  278.                   when NO_DATA =>
  279.                      DONE := TRUE;
  280.                end;
  281.                   if DONE then
  282.                      exit;
  283.                   end if;
  284.                end loop;
  285.  
  286.             when 'q' | 'Q' =>
  287.                INT_GET_AND_PUT_FLAG := TRUE;
  288.  
  289.             when 'r' | 'R' =>
  290.                INT_GET_AND_PUT_FLAG := FALSE;
  291.  
  292.             when 's' | 'S' =>
  293.                SHORT_AFT := TARGET_SHORT_FLOAT_DIGITS-1;
  294.                SHORT_EXP := 3;
  295.                LONG_AFT := TARGET_LONG_FLOAT_DIGITS-1;
  296.                LONG_EXP := 3;
  297.  
  298.             when 't' | 'T' =>
  299.                NEW_SCREEN;
  300.                TEXT_IO.PUT("SHORT FLOAT AFT ? ");
  301.                GET(SHORT_AFT);
  302.                GET_LINE(DUMMY, CNT);
  303.                TEXT_IO.PUT("SHORT FLOAT EXP ? ");
  304.                GET(SHORT_EXP);
  305.                GET_LINE(DUMMY, CNT);
  306.                TEXT_IO.PUT("LONG FLOAT AFT ? ");
  307.                GET(LONG_AFT);
  308.                GET_LINE(DUMMY, CNT);
  309.                TEXT_IO.PUT("LONG FLOAT EXP ? ");
  310.                GET(LONG_EXP);
  311.                GET_LINE(DUMMY, CNT);
  312.  
  313.             when 'u' | 'U' =>
  314.                INTEGER_COMPARE := TRUE;
  315.                FLOAT_COMPARE := TRUE;
  316.  
  317.             when 'v' | 'V' =>
  318.                INTEGER_COMPARE := FALSE;
  319.                FLOAT_COMPARE := FALSE;
  320.  
  321.             when 'x' | 'X' =>
  322.                raise END_OF_PROGRAM;
  323.  
  324.             when others =>
  325.                TEXT_IO.PUT_LINE("*** ILLEGAL DATA ***");
  326.  
  327.                TEXT_IO.PUT("return to continue ...");
  328.                TEXT_IO.GET_LINE(DUMMY,CNT);
  329.  
  330.                null;
  331.  
  332.          end case;
  333.  
  334.       end;
  335.       end loop;
  336.  
  337.    exception
  338.       when others =>
  339.          CLOSE(LOG_FILE);
  340.  
  341. end TESTALL;
  342. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  343. --testatb.txt
  344. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  345. with MACHINE_ARITHMETIC_EMULATION;
  346. use MACHINE_ARITHMETIC_EMULATION;
  347. with TEXT_IO; use TEXT_IO;
  348. use INTEGER_IO; 
  349.  
  350. procedure TESTATB is
  351.  
  352.   OP_STRING : STRING (1 .. 24);
  353.   DUMMY : STRING (1 .. 3);
  354.   COUNT, COUNT1, COUNT2 : NATURAL;
  355.  
  356.  
  357.    procedure PUT(ITEM : BOOLEAN) is
  358.    begin
  359.       if ITEM then
  360.          TEXT_IO.PUT("TRUE");
  361.       else
  362.          TEXT_IO.PUT("FALSE");
  363.       end if;
  364.    end PUT;
  365.    
  366.    procedure PUT(FILE_NAME : FILE_TYPE; ITEM : BOOLEAN) is
  367.    begin
  368.       if ITEM then
  369.          PUT(FILE_NAME,"TRUE");
  370.       else
  371.          PUT(FILE_NAME,"FALSE");
  372.       end if;
  373.    end PUT;
  374.  
  375.  
  376. begin
  377.  
  378.  
  379.   PUT_LINE("INTEGER ATTRIBUTES ");
  380.   NEW_LINE;
  381.   TEXT_IO.PUT("LAST    : ");
  382.   PUT(OP_STRING,TARGET_INTEGER_LAST);
  383.   PUT(OP_STRING);
  384.   NEW_LINE;
  385.   TEXT_IO.PUT("FIRST   : ");
  386.   PUT(OP_STRING,TARGET_INTEGER_FIRST);
  387.   PUT(OP_STRING);
  388.   NEW_LINE;
  389.   NEW_LINE;
  390.   TEXT_IO.PUT(" return to continue ... ");
  391.   GET_LINE(DUMMY, COUNT);
  392.   NEW_LINE;
  393.   NEW_LINE;
  394.   NEW_LINE;
  395.   PUT_LINE("SHORT FLOAT ATTRIBUTES ");
  396.   NEW_LINE;
  397.   TEXT_IO.PUT("EPSILON : ");
  398.   PUT(OP_STRING,TARGET_SHORT_FLOAT_EPSILON);
  399.   PUT(OP_STRING);
  400.   NEW_LINE;
  401.   TEXT_IO.PUT("LARGE   : ");
  402.   PUT(OP_STRING,TARGET_SHORT_FLOAT_LARGE);
  403.   PUT(OP_STRING);
  404.   NEW_LINE;
  405.   TEXT_IO.PUT("SMALL   : ");
  406.   PUT(OP_STRING,TARGET_SHORT_FLOAT_SMALL);
  407.   PUT(OP_STRING);
  408.   NEW_LINE;
  409.   TEXT_IO.PUT("LAST    : ");
  410.   PUT(OP_STRING,TARGET_SHORT_FLOAT_LAST);
  411.   PUT(OP_STRING);
  412.   NEW_LINE;
  413.   TEXT_IO.PUT("FIRST   : ");
  414.   PUT(OP_STRING,TARGET_SHORT_FLOAT_FIRST);
  415.   PUT(OP_STRING);
  416.   NEW_LINE;
  417.   TEXT_IO.PUT("DIGITS  : ");
  418.   PUT(TARGET_SHORT_FLOAT_DIGITS);
  419.   NEW_LINE;
  420.   TEXT_IO.PUT("EMAX    : ");
  421.   PUT(TARGET_SHORT_FLOAT_EMAX);
  422.   NEW_LINE;
  423.   TEXT_IO.PUT("M_EMAX  : ");
  424.   PUT(TARGET_SHORT_FLOAT_MACHINE_EMAX);
  425.   NEW_LINE;
  426.   TEXT_IO.PUT("M_EMIN  : ");
  427.   PUT(TARGET_SHORT_FLOAT_MACHINE_EMIN);
  428.   NEW_LINE;
  429.   TEXT_IO.PUT("MANTISSA: ");
  430.   PUT(TARGET_SHORT_FLOAT_MACHINE_MANTISSA);
  431.   NEW_LINE;
  432.   TEXT_IO.PUT("OVERFLOW: ");
  433.   PUT(TARGET_SHORT_FLOAT_MACHINE_OVERFLOWS);
  434.   NEW_LINE;
  435.   TEXT_IO.PUT("RADIX   : ");
  436.   PUT(TARGET_SHORT_FLOAT_MACHINE_RADIX);
  437.   NEW_LINE;
  438.   TEXT_IO.PUT("ROUNDS  : ");
  439.   PUT(TARGET_SHORT_FLOAT_MACHINE_ROUNDS);
  440.   NEW_LINE;
  441.   TEXT_IO.PUT("SAF EMAX: ");
  442.   PUT(TARGET_SHORT_FLOAT_SAFE_EMAX);
  443.   NEW_LINE;
  444.   NEW_LINE;
  445.   TEXT_IO.PUT(" return to continue ... ");
  446.   GET_LINE(DUMMY, COUNT);
  447.   NEW_LINE;
  448.   NEW_LINE;
  449.   NEW_LINE;
  450.   PUT_LINE("LONG FLOAT ATTRIBUTES ");
  451.   NEW_LINE;
  452.   TEXT_IO.PUT("EPSILON : ");
  453.   PUT(OP_STRING,TARGET_LONG_FLOAT_EPSILON);
  454.   PUT(OP_STRING);
  455.   NEW_LINE;
  456.   TEXT_IO.PUT("LARGE   : ");
  457.   PUT(OP_STRING,TARGET_LONG_FLOAT_LARGE);
  458.   PUT(OP_STRING);
  459.   NEW_LINE;
  460.   TEXT_IO.PUT("SMALL   : ");
  461.   PUT(OP_STRING,TARGET_LONG_FLOAT_SMALL);
  462.   PUT(OP_STRING);
  463.   NEW_LINE;
  464.   TEXT_IO.PUT("LAST    : ");
  465.   PUT(OP_STRING,TARGET_LONG_FLOAT_LAST);
  466.   PUT(OP_STRING);
  467.   NEW_LINE;
  468.   TEXT_IO.PUT("FIRST   : ");
  469.   PUT(OP_STRING,TARGET_LONG_FLOAT_FIRST);
  470.   PUT(OP_STRING);
  471.   NEW_LINE;
  472.   TEXT_IO.PUT("DIGITS  : ");
  473.   PUT(TARGET_LONG_FLOAT_DIGITS);
  474.   NEW_LINE;
  475.   TEXT_IO.PUT("EMAX    : ");
  476.   PUT(TARGET_LONG_FLOAT_EMAX);
  477.   NEW_LINE;
  478.   TEXT_IO.PUT("M_EMAX  : ");
  479.   PUT(TARGET_LONG_FLOAT_MACHINE_EMAX);
  480.   NEW_LINE;
  481.   TEXT_IO.PUT("M_EMIN  : ");
  482.   PUT(TARGET_LONG_FLOAT_MACHINE_EMIN);
  483.   NEW_LINE;
  484.   TEXT_IO.PUT("MANTISSA: ");
  485.   PUT(TARGET_LONG_FLOAT_MACHINE_MANTISSA);
  486.   NEW_LINE;
  487.   TEXT_IO.PUT("OVERFLOW: ");
  488.   PUT(TARGET_LONG_FLOAT_MACHINE_OVERFLOWS);
  489.   NEW_LINE;
  490.   TEXT_IO.PUT("RADIX   : ");
  491.   PUT(TARGET_LONG_FLOAT_MACHINE_RADIX);
  492.   NEW_LINE;
  493.   TEXT_IO.PUT("ROUNDS  : ");
  494.   PUT(TARGET_LONG_FLOAT_MACHINE_ROUNDS);
  495.   NEW_LINE;
  496.   TEXT_IO.PUT("SAF EMAX: ");
  497.   PUT(TARGET_LONG_FLOAT_SAFE_EMAX);
  498.   NEW_LINE;
  499.   NEW_LINE;
  500.  
  501. end TESTATB;
  502. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  503. --testti.txt
  504. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  505. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  506. with TEXT_IO; use TEXT_IO;
  507. use INTEGER_IO; 
  508. use FLOAT_IO;
  509.  
  510. package TESTTI is
  511.  
  512.    OP1, OP2 : TARGET_INTEGER;
  513.    RESULT, RESULT1, RESULT2 : TARGET_INTEGER;
  514.    B_RESULT : BOOLEAN;
  515.    SF1, SF2 : TARGET_SHORT_FLOAT;
  516.    SFRESULT, SFRESULT1, SFRESULT2 : TARGET_SHORT_FLOAT;
  517.    LF1, LF2 : TARGET_LONG_FLOAT;
  518.    LFRESULT, LFRESULT1, LFRESULT2 : TARGET_LONG_FLOAT;
  519.    INT1, INT2 : INTEGER;
  520.    INTRESULT, INTRESULT1, INTRESULT2 : INTEGER;
  521.    INTB_RESULT : BOOLEAN;
  522.    FP1, FP2 : FLOAT;
  523.    FPRESULT, FPRESULT1, FPRESULT2 : FLOAT;
  524.    FPB_RESULT : BOOLEAN;
  525.    S_CHAR : CHARACTER;
  526.    OP_STRING : STRING (1 .. 12);
  527.    EMPTY_STRING : STRING (1 .. 24) := "                        ";
  528.    DUMMY : STRING (1 .. 3);
  529.    POWER : INTEGER;
  530.    CNT, CNT1 : NATURAL;
  531.    INTEGER_COMPARE, FLOAT_COMPARE, DONE : BOOLEAN := FALSE;
  532.    OPERATION_TYPE, OPERAND_TYPE : CHARACTER;
  533.    END_OF_PROGRAM, EXIT_MENU, NO_DATA : EXCEPTION;
  534.    SHORT_AFT, SHORT_EXP, LONG_AFT, LONG_EXP : INTEGER;
  535.    INT_GET_AND_PUT_FLAG : BOOLEAN := TRUE;
  536.  
  537.    LOG_FILE : FILE_TYPE;
  538.  
  539.    procedure PUT(ITEM : BOOLEAN);
  540.    
  541.    procedure PUT(FILE_NAME : FILE_TYPE; ITEM : BOOLEAN);
  542.  
  543.    procedure NEW_SCREEN;
  544.  
  545.    procedure GET_INTEGER_OPERANDS;
  546.  
  547.    procedure PUT_INTEGER_RESULTS;
  548.  
  549. end TESTTI;
  550.  
  551. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  552. with TEXT_IO; use TEXT_IO;
  553. use INTEGER_IO; 
  554. use FLOAT_IO;
  555.  
  556. package body TESTTI is
  557.  
  558.    procedure PUT(ITEM : BOOLEAN) is
  559.    begin
  560.       if ITEM then
  561.          TEXT_IO.PUT("TRUE");
  562.       else
  563.          TEXT_IO.PUT("FALSE");
  564.       end if;
  565.    end PUT;
  566.    
  567.    procedure PUT(FILE_NAME : FILE_TYPE; ITEM : BOOLEAN) is
  568.    begin
  569.       if ITEM then
  570.          PUT(FILE_NAME,"TRUE");
  571.       else
  572.          PUT(FILE_NAME,"FALSE");
  573.       end if;
  574.    end PUT;
  575.  
  576.    procedure NEW_SCREEN is
  577.    begin
  578.       for I in 1 .. 24 loop
  579.          NEW_LINE;
  580.       end loop;
  581.    end NEW_SCREEN;
  582.  
  583.    procedure GET_INTEGER_OPERANDS is
  584.       DONE : BOOLEAN := FALSE;
  585.    begin
  586.       loop
  587.       begin
  588.          NEW_SCREEN;
  589.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  590.          PUT_LINE("INTEGER OPERATIONS");
  591.          PUT_LINE("OPERAND INPUT");
  592.          NEW_LINE;
  593.          NEW_LINE;
  594.          TEXT_IO.PUT("OP1 ? ");
  595.          OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  596.          GET_LINE(OP_STRING, CNT);
  597.          if CNT = 0 then
  598.             raise EXIT_MENU;
  599.          end if;
  600.  
  601.          if INT_GET_AND_PUT_FLAG then
  602.             GET(OP_STRING(1..CNT), OP1, CNT1);
  603.          else
  604.             OP1 := TARGET_INTEGER_VALUE(OP_STRING(1..CNT));
  605.          end if;
  606.  
  607.          if INTEGER_COMPARE then
  608.             GET(OP_STRING(1..CNT),INT1,CNT1);
  609.          end if;
  610.  
  611.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  612.             NEW_LINE;
  613.             TEXT_IO.PUT("POWER ? ");
  614.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  615.             GET_LINE(OP_STRING, CNT);
  616.             if CNT = 0 then
  617.                raise EXIT_MENU;
  618.             end if;
  619.  
  620.             GET(OP_STRING(1..CNT),POWER,CNT1);
  621.          else
  622.             NEW_LINE;
  623.             TEXT_IO.PUT("OP2 ? ");
  624.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  625.             GET_LINE(OP_STRING, CNT);
  626.             if CNT = 0 then
  627.                raise EXIT_MENU;
  628.             end if;
  629.  
  630.             if INT_GET_AND_PUT_FLAG then
  631.                GET(OP_STRING(1..CNT), OP2, CNT1);
  632.             else
  633.                OP2 := TARGET_INTEGER_VALUE(OP_STRING(1..CNT));
  634.             end if;
  635.  
  636.             if INTEGER_COMPARE then
  637.                GET(OP_STRING(1..CNT),INT2,CNT1);
  638.             end if;
  639.          end if;
  640.  
  641.          DONE := TRUE;
  642.  
  643.       exception
  644.          when EXIT_MENU =>
  645.             raise NO_DATA;
  646.  
  647.          when others =>
  648.             PUT_LINE("*** ILLEGAL DATA ***");
  649.             NEW_LINE;
  650.             TEXT_IO.PUT("return to continue ...");
  651.             GET_LINE(DUMMY,CNT);
  652.  
  653.          end;
  654.  
  655.          if DONE then
  656.             exit;
  657.          end if;
  658.       end loop;
  659.  
  660.    end GET_INTEGER_OPERANDS;
  661.  
  662.  
  663.    procedure PUT_INTEGER_RESULTS is
  664.    begin
  665.          NEW_SCREEN;
  666.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  667.          PUT_LINE("INTEGER OPERATIONS RESULTS");
  668.          PUT_LINE(LOG_FILE,"INTEGER OPERATIONS RESULTS");
  669.          NEW_LINE;
  670.          NEW_LINE(LOG_FILE);
  671.  
  672.          TEXT_IO.PUT("OP1                      = ");
  673.          PUT(LOG_FILE,"OP1                      = ");
  674.          if INT_GET_AND_PUT_FLAG then
  675.             PUT(OP_STRING, OP1);
  676.             PUT_LINE(OP_STRING);
  677.             PUT_LINE(LOG_FILE,OP_STRING);
  678.          else
  679.             PUT_LINE(TARGET_INTEGER_IMAGE(OP1));
  680.             PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(OP1));
  681.          end if;
  682.          if INTEGER_COMPARE then
  683.             TEXT_IO.PUT("SYSTEM OP1               = ");
  684.             PUT(LOG_FILE,"SYSTEM OP1               = ");
  685.             if INT_GET_AND_PUT_FLAG then
  686.                PUT(OP_STRING, INT1);
  687.                PUT_LINE(OP_STRING);
  688.                PUT_LINE(LOG_FILE,OP_STRING);
  689.             else
  690.                PUT_LINE(INTEGER'IMAGE(INT1));
  691.                PUT_LINE(LOG_FILE,INTEGER'IMAGE(INT1));
  692.             end if;
  693.          end if;
  694.  
  695.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  696.             TEXT_IO.PUT("POWER                    = ");
  697.             PUT(LOG_FILE,"POWER                    = ");
  698.             PUT(POWER);
  699.             PUT(LOG_FILE,POWER);
  700.             NEW_LINE;
  701.             NEW_LINE(LOG_FILE);
  702.             if INTEGER_COMPARE then
  703.                TEXT_IO.PUT("SYSTEM POWER             = ");
  704.                PUT(LOG_FILE,"SYSTEM POWER             = ");
  705.                PUT(POWER);
  706.                PUT(LOG_FILE,POWER);
  707.                NEW_LINE;
  708.                NEW_LINE(LOG_FILE);
  709.             end if;
  710.          else
  711.             TEXT_IO.PUT("OP2                      = ");
  712.             PUT(LOG_FILE,"OP2                      = ");
  713.             if INT_GET_AND_PUT_FLAG then
  714.                PUT(OP_STRING, OP2);
  715.                PUT_LINE(OP_STRING);
  716.                PUT_LINE(LOG_FILE,OP_STRING);
  717.             else
  718.                PUT_LINE(TARGET_INTEGER_IMAGE(OP2));
  719.                PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(OP2));
  720.             end if;
  721.             if INTEGER_COMPARE then
  722.                TEXT_IO.PUT("SYSTEM OP2               = ");
  723.                PUT(LOG_FILE,"SYSTEM OP2               = ");
  724.                if INT_GET_AND_PUT_FLAG then
  725.                   PUT(OP_STRING, INT2);
  726.                   PUT_LINE(OP_STRING);
  727.                   PUT_LINE(LOG_FILE,OP_STRING);
  728.                else
  729.                   PUT_LINE(INTEGER'IMAGE(INT2));
  730.                   PUT_LINE(LOG_FILE,INTEGER'IMAGE(INT2));
  731.                end if;
  732.             end if;
  733.          end if;
  734.          NEW_LINE;
  735.          NEW_LINE(LOG_FILE);
  736.  
  737.          case OPERATION_TYPE is
  738.             when 'A' | 'a'  =>
  739.                TEXT_IO.PUT("OP1 + OP2                = ");
  740.                PUT(LOG_FILE,"OP1 + OP2                = ");
  741.                RESULT := OP1 + OP2;
  742.                if INT_GET_AND_PUT_FLAG then
  743.                   PUT(OP_STRING, RESULT);
  744.                   PUT_LINE(OP_STRING);
  745.                   PUT_LINE(LOG_FILE,OP_STRING);
  746.                else
  747.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  748.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  749.                end if;
  750.                if INTEGER_COMPARE then
  751.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  752.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  753.                   INTRESULT := INT1 + INT2;
  754.                   if INT_GET_AND_PUT_FLAG then
  755.                      PUT(OP_STRING, INTRESULT);
  756.                      PUT_LINE(OP_STRING);
  757.                      PUT_LINE(LOG_FILE,OP_STRING);
  758.                   else
  759.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  760.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  761.                   end if;
  762.                end if;
  763.                NEW_LINE;
  764.                NEW_LINE(LOG_FILE);
  765.  
  766.                TEXT_IO.PUT("OP1 - OP2                = ");
  767.                PUT(LOG_FILE,"OP1 - OP2                = ");
  768.                RESULT := OP1 - OP2;
  769.                if INT_GET_AND_PUT_FLAG then
  770.                   PUT(OP_STRING, RESULT);
  771.                   PUT_LINE(OP_STRING);
  772.                   PUT_LINE(LOG_FILE,OP_STRING);
  773.                else
  774.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  775.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  776.                end if;
  777.                if INTEGER_COMPARE then
  778.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  779.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  780.                   INTRESULT := INT1 - INT2;
  781.                   if INT_GET_AND_PUT_FLAG then
  782.                      PUT(OP_STRING, INTRESULT);
  783.                      PUT_LINE(OP_STRING);
  784.                      PUT_LINE(LOG_FILE,OP_STRING);
  785.                   else
  786.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  787.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  788.                   end if;
  789.                end if;
  790.                NEW_LINE;
  791.                NEW_LINE(LOG_FILE);
  792.  
  793.                TEXT_IO.PUT("OP2 - OP1                = ");
  794.                PUT(LOG_FILE,"OP2 - OP1                = ");
  795.                RESULT := OP2 - OP1;
  796.                if INT_GET_AND_PUT_FLAG then
  797.                   PUT(OP_STRING, RESULT);
  798.                   PUT_LINE(OP_STRING);
  799.                   PUT_LINE(LOG_FILE,OP_STRING);
  800.                else
  801.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  802.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  803.                end if;
  804.                if INTEGER_COMPARE then
  805.                   TEXT_IO.PUT("SYSTEM OP2 - OP1         = ");
  806.                   PUT(LOG_FILE,"SYSTEM OP2 - OP1         = ");
  807.                   INTRESULT := INT2 - INT1;
  808.                   if INT_GET_AND_PUT_FLAG then
  809.                      PUT(OP_STRING, INTRESULT);
  810.                      PUT_LINE(OP_STRING);
  811.                      PUT_LINE(LOG_FILE,OP_STRING);
  812.                   else
  813.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  814.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  815.                   end if;
  816.                end if;
  817.                NEW_LINE;
  818.                NEW_LINE(LOG_FILE);
  819.  
  820.             when 'B' | 'b' =>
  821.                TEXT_IO.PUT("OP1 * OP2                = ");
  822.                PUT(LOG_FILE,"OP1 * OP2                = ");
  823.                RESULT := OP1 * OP2;
  824.                if INT_GET_AND_PUT_FLAG then
  825.                   PUT(OP_STRING, RESULT);
  826.                   PUT_LINE(OP_STRING);
  827.                   PUT_LINE(LOG_FILE,OP_STRING);
  828.                else
  829.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  830.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  831.                end if;
  832.                if INTEGER_COMPARE then
  833.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  834.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  835.                   INTRESULT := INT1 * INT2;
  836.                   if INT_GET_AND_PUT_FLAG then
  837.                      PUT(OP_STRING, INTRESULT);
  838.                      PUT_LINE(OP_STRING);
  839.                      PUT_LINE(LOG_FILE,OP_STRING);
  840.                   else
  841.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  842.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  843.                   end if;
  844.                end if;
  845.                NEW_LINE;
  846.                NEW_LINE(LOG_FILE);
  847.  
  848.                TEXT_IO.PUT("OP1 / OP2                = ");
  849.                PUT(LOG_FILE,"OP1 / OP2                = ");
  850.                RESULT := OP1 / OP2;
  851.                if INT_GET_AND_PUT_FLAG then
  852.                   PUT(OP_STRING, RESULT);
  853.                   PUT_LINE(OP_STRING);
  854.                   PUT_LINE(LOG_FILE,OP_STRING);
  855.                else
  856.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  857.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  858.                end if;
  859.                if INTEGER_COMPARE then
  860.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  861.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  862.                   INTRESULT := INT1 / INT2;
  863.                   if INT_GET_AND_PUT_FLAG then
  864.                      PUT(OP_STRING, INTRESULT);
  865.                      PUT_LINE(OP_STRING);
  866.                      PUT_LINE(LOG_FILE,OP_STRING);
  867.                   else
  868.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  869.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  870.                   end if;
  871.                end if;
  872.                NEW_LINE;
  873.                NEW_LINE(LOG_FILE);
  874.  
  875.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  876.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  877.                RESULT := RESULT * OP2;
  878.                if INT_GET_AND_PUT_FLAG then
  879.                   PUT(OP_STRING, RESULT);
  880.                   PUT_LINE(OP_STRING);
  881.                   PUT_LINE(LOG_FILE,OP_STRING);
  882.                else
  883.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  884.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  885.                end if;
  886.                if INTEGER_COMPARE then
  887.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  888.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  889.                   INTRESULT := INTRESULT * INT2;
  890.                   if INT_GET_AND_PUT_FLAG then
  891.                      PUT(OP_STRING, INTRESULT);
  892.                      PUT_LINE(OP_STRING);
  893.                      PUT_LINE(LOG_FILE,OP_STRING);
  894.                   else
  895.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  896.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  897.                   end if;
  898.                end if;
  899.                NEW_LINE;
  900.                NEW_LINE(LOG_FILE);
  901.  
  902.             when 'C' | 'c' =>
  903.                TEXT_IO.PUT("OP1 > OP2                = ");
  904.                PUT(LOG_FILE,"OP1 > OP2                = ");
  905.                B_RESULT := OP1 > OP2;
  906.                PUT(B_RESULT);
  907.                PUT(LOG_FILE,B_RESULT);
  908.                NEW_LINE;
  909.                NEW_LINE(LOG_FILE);
  910.                if INTEGER_COMPARE then
  911.                   TEXT_IO.PUT("SYSTEM OP1 > OP2         = ");
  912.                   PUT(LOG_FILE,"SYSTEM OP1 > OP2         = ");
  913.                   INTB_RESULT := INT1 > INT2;
  914.                   PUT(INTB_RESULT);
  915.                   PUT(LOG_FILE,INTB_RESULT);
  916.                   NEW_LINE;
  917.                   NEW_LINE(LOG_FILE);
  918.                end if;
  919.                NEW_LINE;
  920.                NEW_LINE(LOG_FILE);
  921.  
  922.                TEXT_IO.PUT("OP1 >= OP2               = ");
  923.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  924.                B_RESULT := OP1 >= OP2;
  925.                PUT(B_RESULT);
  926.                PUT(LOG_FILE,B_RESULT);
  927.                NEW_LINE;
  928.                NEW_LINE(LOG_FILE);
  929.                if INTEGER_COMPARE then
  930.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  931.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  932.                   INTB_RESULT := INT1 >= INT2;
  933.                   PUT(INTB_RESULT);
  934.                   PUT(LOG_FILE,INTB_RESULT);
  935.                   NEW_LINE;
  936.                   NEW_LINE(LOG_FILE);
  937.                end if;
  938.                NEW_LINE;
  939.                NEW_LINE(LOG_FILE);
  940.  
  941.                TEXT_IO.PUT("OP1 < OP2                = ");
  942.                PUT(LOG_FILE,"OP1 < OP2                = ");
  943.                B_RESULT := OP1 < OP2;
  944.                PUT(B_RESULT);
  945.                PUT(LOG_FILE,B_RESULT);
  946.                NEW_LINE;
  947.                NEW_LINE(LOG_FILE);
  948.                if INTEGER_COMPARE then
  949.                   TEXT_IO.PUT("SYSTEM OP1 < OP2         = ");
  950.                   PUT(LOG_FILE,"SYSTEM OP1 < OP2         = ");
  951.                   INTB_RESULT := INT1 < INT2;
  952.                   PUT(INTB_RESULT);
  953.                   PUT(LOG_FILE,INTB_RESULT);
  954.                   NEW_LINE;
  955.                   NEW_LINE(LOG_FILE);
  956.                end if;
  957.                NEW_LINE;
  958.                NEW_LINE(LOG_FILE);
  959.  
  960.                TEXT_IO.PUT("OP1 <= OP2               = ");
  961.                PUT(LOG_FILE,"OP1 <= OP2               = ");
  962.                B_RESULT := OP1 <= OP2;
  963.                PUT(B_RESULT);
  964.                PUT(LOG_FILE,B_RESULT);
  965.                NEW_LINE;
  966.                NEW_LINE(LOG_FILE);
  967.                if INTEGER_COMPARE then
  968.                   TEXT_IO.PUT("SYSTEM OP1 <= OP2        = ");
  969.                   PUT(LOG_FILE,"SYSTEM OP1 <= OP2        = ");
  970.                   INTB_RESULT := INT1 <= INT2;
  971.                   PUT(INTB_RESULT);
  972.                   PUT(LOG_FILE,INTB_RESULT);
  973.                   NEW_LINE;
  974.                   NEW_LINE(LOG_FILE);
  975.                end if;
  976.                NEW_LINE;
  977.                NEW_LINE(LOG_FILE);
  978.  
  979.             when 'D' | 'd' =>
  980.                TEXT_IO.PUT("OP1 rem OP2              = ");
  981.                PUT(LOG_FILE,"OP1 rem OP2              = ");
  982.                RESULT := OP1 rem OP2;
  983.                if INT_GET_AND_PUT_FLAG then
  984.                   PUT(OP_STRING, RESULT);
  985.                   PUT_LINE(OP_STRING);
  986.                   PUT_LINE(LOG_FILE,OP_STRING);
  987.                else
  988.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  989.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  990.                end if;
  991.                if INTEGER_COMPARE then
  992.                   TEXT_IO.PUT("SYSTEM OP1 rem OP2       = ");
  993.                   PUT(LOG_FILE,"SYSTEM OP1 rem OP2       = ");
  994.                   INTRESULT := INT1 rem INT2;
  995.                   if INT_GET_AND_PUT_FLAG then
  996.                      PUT(OP_STRING, INTRESULT);
  997.                      PUT_LINE(OP_STRING);
  998.                      PUT_LINE(LOG_FILE,OP_STRING);
  999.                   else
  1000.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1001.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1002.                   end if;
  1003.                end if;
  1004.                NEW_LINE;
  1005.                NEW_LINE(LOG_FILE);
  1006.  
  1007.                TEXT_IO.PUT("OP1 mod OP2              = ");
  1008.                PUT(LOG_FILE,"OP1 mod OP2              = ");
  1009.                RESULT := OP1 mod OP2;
  1010.                if INT_GET_AND_PUT_FLAG then
  1011.                   PUT(OP_STRING, RESULT);
  1012.                   PUT_LINE(OP_STRING);
  1013.                   PUT_LINE(LOG_FILE,OP_STRING);
  1014.                else
  1015.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1016.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1017.                end if;
  1018.                if INTEGER_COMPARE then
  1019.                   INTRESULT := INT1 mod INT2;
  1020.                   TEXT_IO.PUT("SYSTEM OP1 mod OP2       = ");
  1021.                   PUT(LOG_FILE,"SYSTEM OP1 mod OP2       = ");
  1022.                   if INT_GET_AND_PUT_FLAG then
  1023.                      PUT(OP_STRING, INTRESULT);
  1024.                      PUT_LINE(OP_STRING);
  1025.                      PUT_LINE(LOG_FILE,OP_STRING);
  1026.                   else
  1027.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1028.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1029.                   end if;
  1030.                end if;
  1031.                NEW_LINE;
  1032.                NEW_LINE(LOG_FILE);
  1033.  
  1034.             when 'E' | 'e' =>
  1035.                TEXT_IO.PUT("OP1 >= OP2               = ");
  1036.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  1037.                B_RESULT := OP1 >= OP2;
  1038.                PUT(B_RESULT);
  1039.                PUT(LOG_FILE,B_RESULT);
  1040.                NEW_LINE;
  1041.                NEW_LINE(LOG_FILE);
  1042.                if INTEGER_COMPARE then
  1043.                   INTB_RESULT := INT1 >= INT2;
  1044.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  1045.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  1046.                   PUT(INTB_RESULT);
  1047.                   PUT(LOG_FILE,INTB_RESULT);
  1048.                   NEW_LINE;
  1049.                   NEW_LINE(LOG_FILE);
  1050.                end if;
  1051.                NEW_LINE;
  1052.                NEW_LINE(LOG_FILE);
  1053.  
  1054.                TEXT_IO.PUT("OP1 + OP2                = ");
  1055.                PUT(LOG_FILE,"OP1 + OP2                = ");
  1056.                RESULT := OP1 + OP2;
  1057.                if INT_GET_AND_PUT_FLAG then
  1058.                   PUT(OP_STRING, RESULT);
  1059.                   PUT_LINE(OP_STRING);
  1060.                   PUT_LINE(LOG_FILE,OP_STRING);
  1061.                else
  1062.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1063.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1064.                end if;
  1065.                if INTEGER_COMPARE then
  1066.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  1067.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  1068.                   INTRESULT := INT1 + INT2;
  1069.                   if INT_GET_AND_PUT_FLAG then
  1070.                      PUT(OP_STRING, INTRESULT);
  1071.                      PUT_LINE(OP_STRING);
  1072.                      PUT_LINE(LOG_FILE,OP_STRING);
  1073.                   else
  1074.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1075.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1076.                   end if;
  1077.                end if;
  1078.                NEW_LINE;
  1079.                NEW_LINE(LOG_FILE);
  1080.  
  1081.                TEXT_IO.PUT("OP1 - OP2                = ");
  1082.                PUT(LOG_FILE,"OP1 - OP2                = ");
  1083.                RESULT := OP1 - OP2;
  1084.                if INT_GET_AND_PUT_FLAG then
  1085.                   PUT(OP_STRING, RESULT);
  1086.                   PUT_LINE(OP_STRING);
  1087.                   PUT_LINE(LOG_FILE,OP_STRING);
  1088.                else
  1089.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1090.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1091.                end if;
  1092.                if INTEGER_COMPARE then
  1093.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  1094.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  1095.                   INTRESULT := INT1 - INT2;
  1096.                   if INT_GET_AND_PUT_FLAG then
  1097.                      PUT(OP_STRING, INTRESULT);
  1098.                      PUT_LINE(OP_STRING);
  1099.                      PUT_LINE(LOG_FILE,OP_STRING);
  1100.                   else
  1101.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1102.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1103.                   end if;
  1104.                end if;
  1105.                NEW_LINE;
  1106.                NEW_LINE(LOG_FILE);
  1107.  
  1108.                TEXT_IO.PUT("OP1 * OP2                = ");
  1109.                PUT(LOG_FILE,"OP1 * OP2                = ");
  1110.                RESULT := OP1 * OP2;
  1111.                if INT_GET_AND_PUT_FLAG then
  1112.                   PUT(OP_STRING, RESULT);
  1113.                   PUT_LINE(OP_STRING);
  1114.                   PUT_LINE(LOG_FILE,OP_STRING);
  1115.                else
  1116.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1117.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1118.                end if;
  1119.                if INTEGER_COMPARE then
  1120.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  1121.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  1122.                   INTRESULT := INT1 * INT2;
  1123.                   if INT_GET_AND_PUT_FLAG then
  1124.                      PUT(OP_STRING, INTRESULT);
  1125.                      PUT_LINE(OP_STRING);
  1126.                      PUT_LINE(LOG_FILE,OP_STRING);
  1127.                   else
  1128.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1129.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1130.                   end if;
  1131.                end if;
  1132.                NEW_LINE;
  1133.                NEW_LINE(LOG_FILE);
  1134.  
  1135.                TEXT_IO.PUT("OP1 / OP2                = ");
  1136.                PUT(LOG_FILE,"OP1 / OP2                = ");
  1137.                RESULT := OP1 / OP2;
  1138.                if INT_GET_AND_PUT_FLAG then
  1139.                   PUT(OP_STRING, RESULT);
  1140.                   PUT_LINE(OP_STRING);
  1141.                   PUT_LINE(LOG_FILE,OP_STRING);
  1142.                else
  1143.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1144.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1145.                end if;
  1146.                if INTEGER_COMPARE then
  1147.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  1148.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  1149.                   INTRESULT := INT1 / INT2;
  1150.                   if INT_GET_AND_PUT_FLAG then
  1151.                      PUT(OP_STRING, INTRESULT);
  1152.                      PUT_LINE(OP_STRING);
  1153.                      PUT_LINE(LOG_FILE,OP_STRING);
  1154.                   else
  1155.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1156.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1157.                   end if;
  1158.                end if;
  1159.                NEW_LINE;
  1160.                NEW_LINE(LOG_FILE);
  1161.  
  1162.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  1163.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  1164.                RESULT := RESULT * OP2;
  1165.                if INT_GET_AND_PUT_FLAG then
  1166.                   PUT(OP_STRING, RESULT);
  1167.                   PUT_LINE(OP_STRING);
  1168.                   PUT_LINE(LOG_FILE,OP_STRING);
  1169.                else
  1170.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT));
  1171.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT));
  1172.                end if;
  1173.                if INTEGER_COMPARE then
  1174.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  1175.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  1176.                   INTRESULT := INTRESULT * INT2;
  1177.                   if INT_GET_AND_PUT_FLAG then
  1178.                      PUT(OP_STRING, INTRESULT);
  1179.                      PUT_LINE(OP_STRING);
  1180.                      PUT_LINE(LOG_FILE,OP_STRING);
  1181.                   else
  1182.                      PUT_LINE(INTEGER'IMAGE(INTRESULT));
  1183.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT));
  1184.                   end if;
  1185.                end if;
  1186.                NEW_LINE;
  1187.                NEW_LINE(LOG_FILE);
  1188.  
  1189.             when 'F' | 'f' =>
  1190.                TEXT_IO.PUT("OP1 ** POWER             = ");
  1191.                PUT(LOG_FILE,"OP1 ** POWER             = ");
  1192.                RESULT1 := OP1 ** POWER;
  1193.                if INT_GET_AND_PUT_FLAG then
  1194.                   PUT(OP_STRING, RESULT1);
  1195.                   PUT_LINE(OP_STRING);
  1196.                   PUT_LINE(LOG_FILE,OP_STRING);
  1197.                else
  1198.                   PUT_LINE(TARGET_INTEGER_IMAGE(RESULT1));
  1199.                   PUT_LINE(LOG_FILE,TARGET_INTEGER_IMAGE(RESULT1));
  1200.                end if;
  1201.                if INTEGER_COMPARE then
  1202.                   TEXT_IO.PUT("SYSTEM OP1 ** POWER      = ");
  1203.                   PUT(LOG_FILE,"SYSTEM OP1 ** POWER      = ");
  1204.                   INTRESULT1 := INT1 ** POWER;
  1205.                   if INT_GET_AND_PUT_FLAG then
  1206.                      PUT(OP_STRING, INTRESULT1);
  1207.                      PUT_LINE(OP_STRING);
  1208.                      PUT_LINE(LOG_FILE,OP_STRING);
  1209.                   else
  1210.                      PUT_LINE(INTEGER'IMAGE(INTRESULT1));
  1211.                      PUT_LINE(LOG_FILE,INTEGER'IMAGE(INTRESULT1));
  1212.                   end if;
  1213.                end if;
  1214.                NEW_LINE;
  1215.                NEW_LINE(LOG_FILE);
  1216.  
  1217.             when others =>
  1218.                null;
  1219.  
  1220.          end case;
  1221.  
  1222.          TEXT_IO.PUT("return to continue ...");
  1223.          GET_LINE(DUMMY,CNT);
  1224.  
  1225.    exception
  1226.       when others =>
  1227.          NEW_LINE;
  1228.          NEW_LINE(LOG_FILE);
  1229.          PUT_LINE("*** EXCEPTION CONDITION RAISED ***");
  1230.          PUT_LINE(LOG_FILE,"*** EXCEPTION CONDITION RAISED ***");
  1231.          NEW_LINE;
  1232.          NEW_LINE(LOG_FILE);
  1233.  
  1234.          TEXT_IO.PUT("return to continue ...");
  1235.          GET_LINE(DUMMY,CNT);
  1236.  
  1237.  
  1238.  
  1239.    end PUT_INTEGER_RESULTS;
  1240.  
  1241. end TESTTI;
  1242. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  1243. --testtlf.txt
  1244. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  1245. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  1246. with TESTTI; use TESTTI;
  1247. with TEXT_IO; use TEXT_IO;
  1248. use INTEGER_IO; 
  1249. use FLOAT_IO;
  1250.  
  1251. package TESTTLF is
  1252.  
  1253.    procedure GET_LONG_FLOAT_OPERANDS;
  1254.  
  1255.    procedure PUT_LONG_FLOAT_RESULTS;
  1256.  
  1257. end TESTTLF;
  1258.  
  1259. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  1260. with TESTTI; use TESTTI;
  1261. with TEXT_IO; use TEXT_IO;
  1262. use INTEGER_IO; 
  1263. use FLOAT_IO;
  1264.  
  1265. package body TESTTLF is
  1266.    OP_STRING : STRING (1 .. 24);
  1267.  
  1268.    procedure GET_LONG_FLOAT_OPERANDS is
  1269.       DONE : BOOLEAN := FALSE;
  1270.    begin
  1271.       loop
  1272.       begin
  1273.          NEW_SCREEN;
  1274.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  1275.          PUT_LINE("LONG_FLOAT OPERATIONS");
  1276.          PUT_LINE("OPERAND INPUT");
  1277.          NEW_LINE;
  1278.          NEW_LINE;
  1279.          TEXT_IO.PUT("OP1 ? ");
  1280.          OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1281.          GET_LINE(OP_STRING, CNT);
  1282.          if CNT = 0 then
  1283.             raise EXIT_MENU;
  1284.          end if;
  1285.  
  1286.          GET(OP_STRING(1..CNT), LF1, CNT1);
  1287.          if FLOAT_COMPARE then
  1288.             GET(OP_STRING(1..CNT),FP1,CNT1);
  1289.          end if;
  1290.  
  1291.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  1292.             NEW_LINE;
  1293.             TEXT_IO.PUT("POWER ? ");
  1294.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1295.             GET_LINE(OP_STRING, CNT);
  1296.             if CNT = 0 then
  1297.                raise EXIT_MENU;
  1298.             end if;
  1299.  
  1300.             GET(OP_STRING(1..CNT),POWER,CNT1);
  1301.          else
  1302.             NEW_LINE;
  1303.             TEXT_IO.PUT("OP2 ? ");
  1304.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1305.             GET_LINE(OP_STRING, CNT);
  1306.             if CNT = 0 then
  1307.                raise EXIT_MENU;
  1308.             end if;
  1309.  
  1310.             GET(OP_STRING(1..CNT), LF2, CNT1);
  1311.             if FLOAT_COMPARE then
  1312.                GET(OP_STRING(1..CNT),FP2,CNT1);
  1313.             end if;
  1314.          end if;
  1315.  
  1316.          DONE := TRUE;
  1317.  
  1318.       exception
  1319.          when EXIT_MENU =>
  1320.             raise NO_DATA;
  1321.  
  1322.          when others =>
  1323.             PUT_LINE("*** ILLEGAL DATA ***");
  1324.             NEW_LINE;
  1325.             TEXT_IO.PUT("return to continue ...");
  1326.             GET_LINE(DUMMY,CNT);
  1327.  
  1328.          end;
  1329.  
  1330.          if DONE then
  1331.             exit;
  1332.          end if;
  1333.       end loop;
  1334.  
  1335.    end GET_LONG_FLOAT_OPERANDS;
  1336.  
  1337.  
  1338.    procedure PUT_LONG_FLOAT_RESULTS is
  1339.    begin
  1340.          NEW_SCREEN;
  1341.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  1342.          PUT_LINE("LONG_FLOAT OPERATIONS RESULTS");
  1343.          PUT_LINE(LOG_FILE,"LONG_FLOAT OPERATIONS RESULTS");
  1344.          NEW_LINE;
  1345.          NEW_LINE(LOG_FILE);
  1346.  
  1347.          TEXT_IO.PUT("OP1                      = ");
  1348.          PUT(LOG_FILE,"OP1                      = ");
  1349.          PUT(OP_STRING, LF1, LONG_AFT, LONG_EXP);
  1350.          PUT_LINE(OP_STRING);
  1351.          PUT_LINE(LOG_FILE, OP_STRING);
  1352.          if INTEGER_COMPARE then
  1353.             TEXT_IO.PUT("SYSTEM OP1               = ");
  1354.             PUT(LOG_FILE,"SYSTEM OP1               = ");
  1355.             PUT(OP_STRING, FP1, LONG_AFT, LONG_EXP);
  1356.             PUT_LINE(OP_STRING);
  1357.             PUT_LINE(LOG_FILE, OP_STRING);
  1358.          end if;
  1359.  
  1360.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  1361.             TEXT_IO.PUT("POWER                    = ");
  1362.             PUT(LOG_FILE,"POWER                    = ");
  1363.             PUT(POWER);
  1364.             PUT(LOG_FILE,POWER);
  1365.             NEW_LINE;
  1366.             NEW_LINE(LOG_FILE);
  1367.             if INTEGER_COMPARE then
  1368.                TEXT_IO.PUT("SYSTEM POWER             = ");
  1369.                PUT(LOG_FILE,"SYSTEM POWER             = ");
  1370.                PUT(POWER);
  1371.                PUT(LOG_FILE,POWER);
  1372.                NEW_LINE;
  1373.                NEW_LINE(LOG_FILE);
  1374.             end if;
  1375.          else
  1376.             TEXT_IO.PUT("OP2                      = ");
  1377.             PUT(LOG_FILE,"OP2                      = ");
  1378.             PUT(OP_STRING, LF2, LONG_AFT, LONG_EXP);
  1379.             PUT_LINE(OP_STRING);
  1380.             PUT_LINE(LOG_FILE, OP_STRING);
  1381.             if FLOAT_COMPARE then
  1382.                TEXT_IO.PUT("SYSTEM OP2               = ");
  1383.                PUT(LOG_FILE,"SYSTEM OP2               = ");
  1384.                PUT(OP_STRING, FP2, LONG_AFT, LONG_EXP);
  1385.                PUT_LINE(OP_STRING);
  1386.                PUT_LINE(LOG_FILE, OP_STRING);
  1387.             end if;
  1388.          end if;
  1389.          NEW_LINE;
  1390.          NEW_LINE(LOG_FILE);
  1391.  
  1392.          case OPERATION_TYPE is
  1393.             when 'A' | 'a' =>
  1394.                TEXT_IO.PUT("OP1 + OP2                = ");
  1395.                PUT(LOG_FILE,"OP1 + OP2                = ");
  1396.                LFRESULT := LF1 + LF2;
  1397.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1398.                PUT_LINE(OP_STRING);
  1399.                PUT_LINE(LOG_FILE, OP_STRING);
  1400.                if FLOAT_COMPARE then
  1401.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  1402.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  1403.                   FPRESULT := FP1 + FP2;
  1404.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1405.                   PUT_LINE(OP_STRING);
  1406.                   PUT_LINE(LOG_FILE, OP_STRING);
  1407.                end if;
  1408.                NEW_LINE;
  1409.                NEW_LINE(LOG_FILE);
  1410.  
  1411.                TEXT_IO.PUT("OP1 - OP2                = ");
  1412.                PUT(LOG_FILE,"OP1 - OP2                = ");
  1413.                LFRESULT := LF1 - LF2;
  1414.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1415.                PUT_LINE(OP_STRING);
  1416.                PUT_LINE(LOG_FILE, OP_STRING);
  1417.                if FLOAT_COMPARE then
  1418.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  1419.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  1420.                   FPRESULT := FP1 - FP2;
  1421.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1422.                   PUT_LINE(OP_STRING);
  1423.                   PUT_LINE(LOG_FILE, OP_STRING);
  1424.                end if;
  1425.                NEW_LINE;
  1426.                NEW_LINE(LOG_FILE);
  1427.  
  1428.                TEXT_IO.PUT("OP2 - OP1                = ");
  1429.                PUT(LOG_FILE,"OP2 - OP1                = ");
  1430.                LFRESULT := LF2 - LF1;
  1431.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1432.                PUT_LINE(OP_STRING);
  1433.                PUT_LINE(LOG_FILE, OP_STRING);
  1434.                if FLOAT_COMPARE then
  1435.                   TEXT_IO.PUT("SYSTEM OP2 - OP1         = ");
  1436.                   PUT(LOG_FILE,"SYSTEM OP2 - OP1         = ");
  1437.                   FPRESULT := FP2 - FP1;
  1438.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1439.                   PUT_LINE(OP_STRING);
  1440.                   PUT_LINE(LOG_FILE, OP_STRING);
  1441.                end if;
  1442.                NEW_LINE;
  1443.                NEW_LINE(LOG_FILE);
  1444.  
  1445.             when 'B' | 'b' =>
  1446.                TEXT_IO.PUT("OP1 * OP2                = ");
  1447.                PUT(LOG_FILE,"OP1 * OP2                = ");
  1448.                LFRESULT := LF1 * LF2;
  1449.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1450.                PUT_LINE(OP_STRING);
  1451.                PUT_LINE(LOG_FILE, OP_STRING);
  1452.                if FLOAT_COMPARE then
  1453.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  1454.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  1455.                   FPRESULT := FP1 * FP2;
  1456.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1457.                   PUT_LINE(OP_STRING);
  1458.                   PUT_LINE(LOG_FILE, OP_STRING);
  1459.                end if;
  1460.                NEW_LINE;
  1461.                NEW_LINE(LOG_FILE);
  1462.  
  1463.                TEXT_IO.PUT("OP1 / OP2                = ");
  1464.                PUT(LOG_FILE,"OP1 / OP2                = ");
  1465.                LFRESULT := LF1 / LF2;
  1466.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1467.                PUT_LINE(OP_STRING);
  1468.                PUT_LINE(LOG_FILE, OP_STRING);
  1469.                if FLOAT_COMPARE then
  1470.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  1471.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  1472.                   FPRESULT := FP1 / FP2;
  1473.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1474.                   PUT_LINE(OP_STRING);
  1475.                   PUT_LINE(LOG_FILE, OP_STRING);
  1476.                end if;
  1477.                NEW_LINE;
  1478.                NEW_LINE(LOG_FILE);
  1479.  
  1480.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  1481.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  1482.                LFRESULT := LFRESULT * LF2;
  1483.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1484.                PUT_LINE(OP_STRING);
  1485.                PUT_LINE(LOG_FILE, OP_STRING);
  1486.                if FLOAT_COMPARE then
  1487.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  1488.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  1489.                   FPRESULT := FPRESULT * FP2;
  1490.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1491.                   PUT_LINE(OP_STRING);
  1492.                   PUT_LINE(LOG_FILE, OP_STRING);
  1493.                end if;
  1494.                NEW_LINE;
  1495.                NEW_LINE(LOG_FILE);
  1496.  
  1497.             when 'C' | 'c' =>
  1498.                TEXT_IO.PUT("OP1 > OP2                = ");
  1499.                PUT(LOG_FILE,"OP1 > OP2                = ");
  1500.                B_RESULT := LF1 > LF2;
  1501.                PUT(B_RESULT);
  1502.                PUT(LOG_FILE,B_RESULT);
  1503.                NEW_LINE;
  1504.                NEW_LINE(LOG_FILE);
  1505.                if FLOAT_COMPARE then
  1506.                   TEXT_IO.PUT("SYSTEM OP1 > OP2         = ");
  1507.                   PUT(LOG_FILE,"SYSTEM OP1 > OP2         = ");
  1508.                   FPB_RESULT := FP1 > FP2;
  1509.                   PUT(FPB_RESULT);
  1510.                   PUT(LOG_FILE,FPB_RESULT);
  1511.                   NEW_LINE;
  1512.                   NEW_LINE(LOG_FILE);
  1513.                end if;
  1514.                NEW_LINE;
  1515.                NEW_LINE(LOG_FILE);
  1516.  
  1517.                TEXT_IO.PUT("OP1 >= OP2               = ");
  1518.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  1519.                B_RESULT := LF1 >= LF2;
  1520.                PUT(B_RESULT);
  1521.                PUT(LOG_FILE,B_RESULT);
  1522.                NEW_LINE;
  1523.                NEW_LINE(LOG_FILE);
  1524.                if FLOAT_COMPARE then
  1525.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  1526.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  1527.                   FPB_RESULT := FP1 >= FP2;
  1528.                   PUT(FPB_RESULT);
  1529.                   PUT(LOG_FILE,FPB_RESULT);
  1530.                   NEW_LINE;
  1531.                   NEW_LINE(LOG_FILE);
  1532.                end if;
  1533.                NEW_LINE;
  1534.                NEW_LINE(LOG_FILE);
  1535.  
  1536.                TEXT_IO.PUT("OP1 < OP2                = ");
  1537.                PUT(LOG_FILE,"OP1 < OP2                = ");
  1538.                B_RESULT := LF1 < LF2;
  1539.                PUT(B_RESULT);
  1540.                PUT(LOG_FILE,B_RESULT);
  1541.                NEW_LINE;
  1542.                NEW_LINE(LOG_FILE);
  1543.                if FLOAT_COMPARE then
  1544.                   TEXT_IO.PUT("SYSTEM OP1 < OP2         = ");
  1545.                   PUT(LOG_FILE,"SYSTEM OP1 < OP2         = ");
  1546.                   FPB_RESULT := FP1 < FP2;
  1547.                   PUT(FPB_RESULT);
  1548.                   PUT(LOG_FILE,FPB_RESULT);
  1549.                   NEW_LINE;
  1550.                   NEW_LINE(LOG_FILE);
  1551.                end if;
  1552.                NEW_LINE;
  1553.                NEW_LINE(LOG_FILE);
  1554.  
  1555.                TEXT_IO.PUT("OP1 <= OP2               = ");
  1556.                PUT(LOG_FILE,"OP1 <= OP2               = ");
  1557.                B_RESULT := LF1 <= LF2;
  1558.                PUT(B_RESULT);
  1559.                PUT(LOG_FILE,B_RESULT);
  1560.                NEW_LINE;
  1561.                NEW_LINE(LOG_FILE);
  1562.                if FLOAT_COMPARE then
  1563.                   TEXT_IO.PUT("SYSTEM OP1 <= OP2        = ");
  1564.                   PUT(LOG_FILE,"SYSTEM OP1 <= OP2        = ");
  1565.                   FPB_RESULT := FP1 <= FP2;
  1566.                   PUT(FPB_RESULT);
  1567.                   PUT(LOG_FILE,FPB_RESULT);
  1568.                   NEW_LINE;
  1569.                   NEW_LINE(LOG_FILE);
  1570.                end if;
  1571.                NEW_LINE;
  1572.                NEW_LINE(LOG_FILE);
  1573.  
  1574.             when 'E' | 'e' =>
  1575.                TEXT_IO.PUT("OP1 >= OP2               = ");
  1576.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  1577.                B_RESULT := LF1 >= LF2;
  1578.                PUT(B_RESULT);
  1579.                PUT(LOG_FILE,B_RESULT);
  1580.                NEW_LINE;
  1581.                NEW_LINE(LOG_FILE);
  1582.                if FLOAT_COMPARE then
  1583.                   FPB_RESULT := FP1 >= FP2;
  1584.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  1585.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  1586.                   PUT(FPB_RESULT);
  1587.                   PUT(LOG_FILE,FPB_RESULT);
  1588.                   NEW_LINE;
  1589.                   NEW_LINE(LOG_FILE);
  1590.                end if;
  1591.                NEW_LINE;
  1592.                NEW_LINE(LOG_FILE);
  1593.  
  1594.                TEXT_IO.PUT("OP1 + OP2                = ");
  1595.                PUT(LOG_FILE,"OP1 + OP2                = ");
  1596.                LFRESULT := LF1 + LF2;
  1597.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1598.                PUT_LINE(OP_STRING);
  1599.                PUT_LINE(LOG_FILE, OP_STRING);
  1600.                if FLOAT_COMPARE then
  1601.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  1602.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  1603.                   FPRESULT := FP1 + FP2;
  1604.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1605.                   PUT_LINE(OP_STRING);
  1606.                   PUT_LINE(LOG_FILE, OP_STRING);
  1607.                end if;
  1608.                NEW_LINE;
  1609.                NEW_LINE(LOG_FILE);
  1610.  
  1611.                TEXT_IO.PUT("OP1 - OP2                = ");
  1612.                PUT(LOG_FILE,"OP1 - OP2                = ");
  1613.                LFRESULT := LF1 - LF2;
  1614.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1615.                PUT_LINE(OP_STRING);
  1616.                PUT_LINE(LOG_FILE, OP_STRING);
  1617.                if FLOAT_COMPARE then
  1618.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  1619.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  1620.                   FPRESULT := FP1 - FP2;
  1621.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1622.                   PUT_LINE(OP_STRING);
  1623.                   PUT_LINE(LOG_FILE, OP_STRING);
  1624.                end if;
  1625.                NEW_LINE;
  1626.                NEW_LINE(LOG_FILE);
  1627.  
  1628.                TEXT_IO.PUT("OP1 * OP2                = ");
  1629.                PUT(LOG_FILE,"OP1 * OP2                = ");
  1630.                LFRESULT := LF1 * LF2;
  1631.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1632.                PUT_LINE(OP_STRING);
  1633.                PUT_LINE(LOG_FILE, OP_STRING);
  1634.                if FLOAT_COMPARE then
  1635.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  1636.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  1637.                   FPRESULT := FP1 * FP2;
  1638.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1639.                   PUT_LINE(OP_STRING);
  1640.                   PUT_LINE(LOG_FILE, OP_STRING);
  1641.                end if;
  1642.                NEW_LINE;
  1643.                NEW_LINE(LOG_FILE);
  1644.  
  1645.                TEXT_IO.PUT("OP1 / OP2                = ");
  1646.                PUT(LOG_FILE,"OP1 / OP2                = ");
  1647.                LFRESULT := LF1 / LF2;
  1648.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1649.                PUT_LINE(OP_STRING);
  1650.                PUT_LINE(LOG_FILE, OP_STRING);
  1651.                if FLOAT_COMPARE then
  1652.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  1653.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  1654.                   FPRESULT := FP1 / FP2;
  1655.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1656.                   PUT_LINE(OP_STRING);
  1657.                   PUT_LINE(LOG_FILE, OP_STRING);
  1658.                end if;
  1659.                NEW_LINE;
  1660.                NEW_LINE(LOG_FILE);
  1661.  
  1662.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  1663.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  1664.                LFRESULT := LFRESULT * LF2;
  1665.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1666.                PUT_LINE(OP_STRING);
  1667.                PUT_LINE(LOG_FILE, OP_STRING);
  1668.                if FLOAT_COMPARE then
  1669.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  1670.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  1671.                   FPRESULT := FPRESULT * FP2;
  1672.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1673.                   PUT_LINE(OP_STRING);
  1674.                   PUT_LINE(LOG_FILE, OP_STRING);
  1675.                end if;
  1676.                NEW_LINE;
  1677.                NEW_LINE(LOG_FILE);
  1678.  
  1679.             when 'F' | 'f' =>
  1680.                TEXT_IO.PUT("OP1 ** POWER             = ");
  1681.                PUT(LOG_FILE,"OP1 ** POWER             = ");
  1682.                LFRESULT1 := LF1 ** POWER;
  1683.                PUT(OP_STRING, LFRESULT1, LONG_AFT, LONG_EXP);
  1684.                PUT_LINE(OP_STRING);
  1685.                PUT_LINE(LOG_FILE, OP_STRING);
  1686.                if FLOAT_COMPARE then
  1687.                   TEXT_IO.PUT("SYSTEM OP1 ** POWER      = ");
  1688.                   PUT(LOG_FILE,"SYSTEM OP1 ** POWER      = ");
  1689.                   FPRESULT1 := FP1 ** POWER;
  1690.                   PUT(OP_STRING, FPRESULT1, LONG_AFT, LONG_EXP);
  1691.                   PUT_LINE(OP_STRING);
  1692.                   PUT_LINE(LOG_FILE, OP_STRING);
  1693.                end if;
  1694.                NEW_LINE;
  1695.                NEW_LINE(LOG_FILE);
  1696.  
  1697.                TEXT_IO.PUT("OP1 ** -POWER            = ");
  1698.                PUT(LOG_FILE,"OP1 ** -POWER            = ");
  1699.                LFRESULT2 := LF1 ** (-POWER);
  1700.                PUT(OP_STRING, LFRESULT2, LONG_AFT, LONG_EXP);
  1701.                PUT_LINE(OP_STRING);
  1702.                PUT_LINE(LOG_FILE, OP_STRING);
  1703.                if FLOAT_COMPARE then
  1704.                   TEXT_IO.PUT("SYSTEM OP1 ** -POWER     = ");
  1705.                   PUT(LOG_FILE,"SYSTEM OP1 ** -POWER     = ");
  1706.                   FPRESULT2 := FP1 ** (-POWER);
  1707.                   PUT(OP_STRING, FPRESULT2, LONG_AFT, LONG_EXP);
  1708.                   PUT_LINE(OP_STRING);
  1709.                   PUT_LINE(LOG_FILE, OP_STRING);
  1710.                end if;
  1711.                NEW_LINE;
  1712.                NEW_LINE(LOG_FILE);
  1713.  
  1714.                TEXT_IO.PUT("RESULT1 * RESULT2        = ");
  1715.                PUT(LOG_FILE,"RESULT1 * RESULT2        = ");
  1716.                LFRESULT := LFRESULT1 * LFRESULT2;
  1717.                PUT(OP_STRING, LFRESULT, LONG_AFT, LONG_EXP);
  1718.                PUT_LINE(OP_STRING);
  1719.                PUT_LINE(LOG_FILE, OP_STRING);
  1720.                if FLOAT_COMPARE then
  1721.                   TEXT_IO.PUT("SYSTEM RESULT1 * RESULT2 = ");
  1722.                   PUT(LOG_FILE,"SYSTEM RESULT1 * RESULT2 = ");
  1723.                   FPRESULT := FPRESULT1 * FPRESULT2;
  1724.                   PUT(OP_STRING, FPRESULT, LONG_AFT, LONG_EXP);
  1725.                   PUT_LINE(OP_STRING);
  1726.                   PUT_LINE(LOG_FILE, OP_STRING);
  1727.                end if;
  1728.                NEW_LINE;
  1729.                NEW_LINE(LOG_FILE);
  1730.  
  1731.             when others =>
  1732.                null;
  1733.  
  1734.          end case;
  1735.  
  1736.          TEXT_IO.PUT("return to continue ...");
  1737.          GET_LINE(DUMMY,CNT);
  1738.  
  1739.    exception
  1740.       when others =>
  1741.          NEW_LINE;
  1742.          NEW_LINE(LOG_FILE);
  1743.          PUT_LINE("*** EXCEPTION CONDITION RAISED ***");
  1744.          PUT_LINE(LOG_FILE,"*** EXCEPTION CONDITION RAISED ***");
  1745.          NEW_LINE;
  1746.          NEW_LINE(LOG_FILE);
  1747.  
  1748.          TEXT_IO.PUT("return to continue ...");
  1749.          GET_LINE(DUMMY,CNT);
  1750.  
  1751.  
  1752.  
  1753.    end PUT_LONG_FLOAT_RESULTS;
  1754.  
  1755. end TESTTLF;
  1756. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  1757. --testtsf.txt
  1758. --::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  1759. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  1760. with TESTTI; use TESTTI;
  1761. with TEXT_IO; use TEXT_IO;
  1762. use INTEGER_IO; 
  1763. use FLOAT_IO;
  1764.  
  1765. package TESTTSF is
  1766.  
  1767.    procedure GET_SHORT_FLOAT_OPERANDS;
  1768.  
  1769.    procedure PUT_SHORT_FLOAT_RESULTS;
  1770.  
  1771. end TESTTSF;
  1772.  
  1773. with MACHINE_ARITHMETIC_EMULATION; use MACHINE_ARITHMETIC_EMULATION;
  1774. with TESTTI; use TESTTI;
  1775. with TEXT_IO; use TEXT_IO;
  1776. use INTEGER_IO; 
  1777. use FLOAT_IO;
  1778.  
  1779. package body TESTTSF is
  1780.    OP_STRING : STRING (1 .. 14);
  1781.  
  1782.    procedure GET_SHORT_FLOAT_OPERANDS is
  1783.       DONE : BOOLEAN := FALSE;
  1784.    begin
  1785.       loop
  1786.       begin
  1787.          NEW_SCREEN;
  1788.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  1789.          PUT_LINE("SHORT_FLOAT OPERATIONS");
  1790.          PUT_LINE("OPERAND INPUT");
  1791.          NEW_LINE;
  1792.          NEW_LINE;
  1793.          TEXT_IO.PUT("OP1 ? ");
  1794.          OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1795.          GET_LINE(OP_STRING, CNT);
  1796.          if CNT = 0 then
  1797.             raise EXIT_MENU;
  1798.          end if;
  1799.  
  1800.          GET(OP_STRING(1..CNT), SF1, CNT1);
  1801.          if FLOAT_COMPARE then
  1802.             GET(OP_STRING(1..CNT),FP1,CNT1);
  1803.          end if;
  1804.  
  1805.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  1806.             NEW_LINE;
  1807.             TEXT_IO.PUT("POWER ? ");
  1808.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1809.             GET_LINE(OP_STRING, CNT);
  1810.             if CNT = 0 then
  1811.                raise EXIT_MENU;
  1812.             end if;
  1813.  
  1814.             GET(OP_STRING(1..CNT),POWER,CNT1);
  1815.          else
  1816.             NEW_LINE;
  1817.             TEXT_IO.PUT("OP2 ? ");
  1818.             OP_STRING := EMPTY_STRING(1 .. OP_STRING'length);
  1819.             GET_LINE(OP_STRING, CNT);
  1820.             if CNT = 0 then
  1821.                raise EXIT_MENU;
  1822.             end if;
  1823.  
  1824.             GET(OP_STRING(1..CNT), SF2, CNT1);
  1825.             if FLOAT_COMPARE then
  1826.                GET(OP_STRING(1..CNT),FP2,CNT1);
  1827.             end if;
  1828.          end if;
  1829.  
  1830.          DONE := TRUE;
  1831.  
  1832.       exception
  1833.          when EXIT_MENU =>
  1834.             raise NO_DATA;
  1835.  
  1836.          when others =>
  1837.             PUT_LINE("*** ILLEGAL DATA ***");
  1838.             NEW_LINE;
  1839.             TEXT_IO.PUT("return to continue ...");
  1840.             GET_LINE(DUMMY,CNT);
  1841.  
  1842.          end;
  1843.  
  1844.          if DONE then
  1845.             exit;
  1846.          end if;
  1847.       end loop;
  1848.  
  1849.    end GET_SHORT_FLOAT_OPERANDS;
  1850.  
  1851.  
  1852.    procedure PUT_SHORT_FLOAT_RESULTS is
  1853.    begin
  1854.          NEW_SCREEN;
  1855.          PUT_LINE("MACHINE ARITHMETIC EMULATION");
  1856.          PUT_LINE("SHORT_FLOAT OPERATIONS RESULTS");
  1857.          PUT_LINE(LOG_FILE,"SHORT_FLOAT OPERATIONS RESULTS");
  1858.          NEW_LINE;
  1859.          NEW_LINE(LOG_FILE);
  1860.  
  1861.          TEXT_IO.PUT("OP1                      = ");
  1862.          PUT(LOG_FILE,"OP1                      = ");
  1863.          PUT(OP_STRING, SF1, SHORT_AFT, SHORT_EXP);
  1864.          PUT_LINE(OP_STRING);
  1865.          PUT_LINE(LOG_FILE, OP_STRING);
  1866.          if INTEGER_COMPARE then
  1867.             TEXT_IO.PUT("SYSTEM OP1               = ");
  1868.             PUT(LOG_FILE,"SYSTEM OP1               = ");
  1869.             PUT(OP_STRING, FP1, SHORT_AFT, SHORT_EXP);
  1870.             PUT_LINE(OP_STRING);
  1871.             PUT_LINE(LOG_FILE, OP_STRING);
  1872.          end if;
  1873.  
  1874.          if (OPERATION_TYPE = 'f') or (OPERATION_TYPE = 'F') then
  1875.             TEXT_IO.PUT("POWER                    = ");
  1876.             PUT(LOG_FILE,"POWER                    = ");
  1877.             PUT(POWER);
  1878.             PUT(LOG_FILE,POWER);
  1879.             NEW_LINE;
  1880.             NEW_LINE(LOG_FILE);
  1881.             if INTEGER_COMPARE then
  1882.                TEXT_IO.PUT("SYSTEM POWER             = ");
  1883.                PUT(LOG_FILE,"SYSTEM POWER             = ");
  1884.                PUT(POWER);
  1885.                PUT(LOG_FILE,POWER);
  1886.                NEW_LINE;
  1887.                NEW_LINE(LOG_FILE);
  1888.             end if;
  1889.          else
  1890.             TEXT_IO.PUT("OP2                      = ");
  1891.             PUT(LOG_FILE,"OP2                      = ");
  1892.             PUT(OP_STRING, SF2, SHORT_AFT, SHORT_EXP);
  1893.             PUT_LINE(OP_STRING);
  1894.             PUT_LINE(LOG_FILE, OP_STRING);
  1895.             if FLOAT_COMPARE then
  1896.                TEXT_IO.PUT("SYSTEM OP2               = ");
  1897.                PUT(LOG_FILE,"SYSTEM OP2               = ");
  1898.                PUT(OP_STRING, FP2, SHORT_AFT, SHORT_EXP);
  1899.                PUT_LINE(OP_STRING);
  1900.                PUT_LINE(LOG_FILE, OP_STRING);
  1901.             end if;
  1902.          end if;
  1903.          NEW_LINE;
  1904.          NEW_LINE(LOG_FILE);
  1905.  
  1906.          case OPERATION_TYPE is
  1907.             when 'A' | 'a' =>
  1908.                TEXT_IO.PUT("OP1 + OP2                = ");
  1909.                PUT(LOG_FILE,"OP1 + OP2                = ");
  1910.                SFRESULT := SF1 + SF2;
  1911.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1912.                PUT_LINE(OP_STRING);
  1913.                PUT_LINE(LOG_FILE, OP_STRING);
  1914.                if FLOAT_COMPARE then
  1915.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  1916.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  1917.                   FPRESULT := FP1 + FP2;
  1918.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  1919.                   PUT_LINE(OP_STRING);
  1920.                   PUT_LINE(LOG_FILE, OP_STRING);
  1921.                end if;
  1922.                NEW_LINE;
  1923.                NEW_LINE(LOG_FILE);
  1924.  
  1925.                TEXT_IO.PUT("OP1 - OP2                = ");
  1926.                PUT(LOG_FILE,"OP1 - OP2                = ");
  1927.                SFRESULT := SF1 - SF2;
  1928.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1929.                PUT_LINE(OP_STRING);
  1930.                PUT_LINE(LOG_FILE, OP_STRING);
  1931.                if FLOAT_COMPARE then
  1932.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  1933.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  1934.                   FPRESULT := FP1 - FP2;
  1935.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  1936.                   PUT_LINE(OP_STRING);
  1937.                   PUT_LINE(LOG_FILE, OP_STRING);
  1938.                end if;
  1939.                NEW_LINE;
  1940.                NEW_LINE(LOG_FILE);
  1941.  
  1942.                TEXT_IO.PUT("OP2 - OP1                = ");
  1943.                PUT(LOG_FILE,"OP2 - OP1                = ");
  1944.                SFRESULT := SF2 - SF1;
  1945.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1946.                PUT_LINE(OP_STRING);
  1947.                PUT_LINE(LOG_FILE, OP_STRING);
  1948.                if FLOAT_COMPARE then
  1949.                   TEXT_IO.PUT("SYSTEM OP2 - OP1         = ");
  1950.                   PUT(LOG_FILE,"SYSTEM OP2 - OP1         = ");
  1951.                   FPRESULT := FP2 - FP1;
  1952.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  1953.                   PUT_LINE(OP_STRING);
  1954.                   PUT_LINE(LOG_FILE, OP_STRING);
  1955.                end if;
  1956.                NEW_LINE;
  1957.                NEW_LINE(LOG_FILE);
  1958.  
  1959.             when 'B' | 'b' =>
  1960.                TEXT_IO.PUT("OP1 * OP2                = ");
  1961.                PUT(LOG_FILE,"OP1 * OP2                = ");
  1962.                SFRESULT := SF1 * SF2;
  1963.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1964.                PUT_LINE(OP_STRING);
  1965.                PUT_LINE(LOG_FILE, OP_STRING);
  1966.                if FLOAT_COMPARE then
  1967.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  1968.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  1969.                   FPRESULT := FP1 * FP2;
  1970.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  1971.                   PUT_LINE(OP_STRING);
  1972.                   PUT_LINE(LOG_FILE, OP_STRING);
  1973.                end if;
  1974.                NEW_LINE;
  1975.                NEW_LINE(LOG_FILE);
  1976.  
  1977.                TEXT_IO.PUT("OP1 / OP2                = ");
  1978.                PUT(LOG_FILE,"OP1 / OP2                = ");
  1979.                SFRESULT := SF1 / SF2;
  1980.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1981.                PUT_LINE(OP_STRING);
  1982.                PUT_LINE(LOG_FILE, OP_STRING);
  1983.                if FLOAT_COMPARE then
  1984.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  1985.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  1986.                   FPRESULT := FP1 / FP2;
  1987.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  1988.                   PUT_LINE(OP_STRING);
  1989.                   PUT_LINE(LOG_FILE, OP_STRING);
  1990.                end if;
  1991.                NEW_LINE;
  1992.                NEW_LINE(LOG_FILE);
  1993.  
  1994.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  1995.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  1996.                SFRESULT := SFRESULT * SF2;
  1997.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  1998.                PUT_LINE(OP_STRING);
  1999.                PUT_LINE(LOG_FILE, OP_STRING);
  2000.                if FLOAT_COMPARE then
  2001.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  2002.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  2003.                   FPRESULT := FPRESULT * FP2;
  2004.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2005.                   PUT_LINE(OP_STRING);
  2006.                   PUT_LINE(LOG_FILE, OP_STRING);
  2007.                end if;
  2008.                NEW_LINE;
  2009.                NEW_LINE(LOG_FILE);
  2010.  
  2011.             when 'C' | 'c' =>
  2012.                TEXT_IO.PUT("OP1 > OP2                = ");
  2013.                PUT(LOG_FILE,"OP1 > OP2                = ");
  2014.                B_RESULT := SF1 > SF2;
  2015.                PUT(B_RESULT);
  2016.                PUT(LOG_FILE,B_RESULT);
  2017.                NEW_LINE;
  2018.                NEW_LINE(LOG_FILE);
  2019.                if FLOAT_COMPARE then
  2020.                   TEXT_IO.PUT("SYSTEM OP1 > OP2         = ");
  2021.                   PUT(LOG_FILE,"SYSTEM OP1 > OP2         = ");
  2022.                   FPB_RESULT := FP1 > FP2;
  2023.                   PUT(FPB_RESULT);
  2024.                   PUT(LOG_FILE,FPB_RESULT);
  2025.                   NEW_LINE;
  2026.                   NEW_LINE(LOG_FILE);
  2027.                end if;
  2028.                NEW_LINE;
  2029.                NEW_LINE(LOG_FILE);
  2030.  
  2031.                TEXT_IO.PUT("OP1 >= OP2               = ");
  2032.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  2033.                B_RESULT := SF1 >= SF2;
  2034.                PUT(B_RESULT);
  2035.                PUT(LOG_FILE,B_RESULT);
  2036.                NEW_LINE;
  2037.                NEW_LINE(LOG_FILE);
  2038.                if FLOAT_COMPARE then
  2039.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  2040.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  2041.                   FPB_RESULT := FP1 >= FP2;
  2042.                   PUT(FPB_RESULT);
  2043.                   PUT(LOG_FILE,FPB_RESULT);
  2044.                   NEW_LINE;
  2045.                   NEW_LINE(LOG_FILE);
  2046.                end if;
  2047.                NEW_LINE;
  2048.                NEW_LINE(LOG_FILE);
  2049.  
  2050.                TEXT_IO.PUT("OP1 < OP2                = ");
  2051.                PUT(LOG_FILE,"OP1 < OP2                = ");
  2052.                B_RESULT := SF1 < SF2;
  2053.                PUT(B_RESULT);
  2054.                PUT(LOG_FILE,B_RESULT);
  2055.                NEW_LINE;
  2056.                NEW_LINE(LOG_FILE);
  2057.                if FLOAT_COMPARE then
  2058.                   TEXT_IO.PUT("SYSTEM OP1 < OP2         = ");
  2059.                   PUT(LOG_FILE,"SYSTEM OP1 < OP2         = ");
  2060.                   FPB_RESULT := FP1 < FP2;
  2061.                   PUT(FPB_RESULT);
  2062.                   PUT(LOG_FILE,FPB_RESULT);
  2063.                   NEW_LINE;
  2064.                   NEW_LINE(LOG_FILE);
  2065.                end if;
  2066.                NEW_LINE;
  2067.                NEW_LINE(LOG_FILE);
  2068.  
  2069.                TEXT_IO.PUT("OP1 <= OP2               = ");
  2070.                PUT(LOG_FILE,"OP1 <= OP2               = ");
  2071.                B_RESULT := SF1 <= SF2;
  2072.                PUT(B_RESULT);
  2073.                PUT(LOG_FILE,B_RESULT);
  2074.                NEW_LINE;
  2075.                NEW_LINE(LOG_FILE);
  2076.                if FLOAT_COMPARE then
  2077.                   TEXT_IO.PUT("SYSTEM OP1 <= OP2        = ");
  2078.                   PUT(LOG_FILE,"SYSTEM OP1 <= OP2        = ");
  2079.                   FPB_RESULT := FP1 <= FP2;
  2080.                   PUT(FPB_RESULT);
  2081.                   PUT(LOG_FILE,FPB_RESULT);
  2082.                   NEW_LINE;
  2083.                   NEW_LINE(LOG_FILE);
  2084.                end if;
  2085.                NEW_LINE;
  2086.                NEW_LINE(LOG_FILE);
  2087.  
  2088.             when 'E' | 'e' =>
  2089.                TEXT_IO.PUT("OP1 >= OP2               = ");
  2090.                PUT(LOG_FILE,"OP1 >= OP2               = ");
  2091.                B_RESULT := SF1 >= SF2;
  2092.                PUT(B_RESULT);
  2093.                PUT(LOG_FILE,B_RESULT);
  2094.                NEW_LINE;
  2095.                NEW_LINE(LOG_FILE);
  2096.                if FLOAT_COMPARE then
  2097.                   FPB_RESULT := FP1 >= FP2;
  2098.                   TEXT_IO.PUT("SYSTEM OP1 >= OP2        = ");
  2099.                   PUT(LOG_FILE,"SYSTEM OP1 >= OP2        = ");
  2100.                   PUT(FPB_RESULT);
  2101.                   PUT(LOG_FILE,FPB_RESULT);
  2102.                   NEW_LINE;
  2103.                   NEW_LINE(LOG_FILE);
  2104.                end if;
  2105.                NEW_LINE;
  2106.                NEW_LINE(LOG_FILE);
  2107.  
  2108.                TEXT_IO.PUT("OP1 + OP2                = ");
  2109.                PUT(LOG_FILE,"OP1 + OP2                = ");
  2110.                SFRESULT := SF1 + SF2;
  2111.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2112.                PUT_LINE(OP_STRING);
  2113.                PUT_LINE(LOG_FILE, OP_STRING);
  2114.                if FLOAT_COMPARE then
  2115.                   TEXT_IO.PUT("SYSTEM OP1 + OP2         = ");
  2116.                   PUT(LOG_FILE,"SYSTEM OP1 + OP2         = ");
  2117.                   FPRESULT := FP1 + FP2;
  2118.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2119.                   PUT_LINE(OP_STRING);
  2120.                   PUT_LINE(LOG_FILE, OP_STRING);
  2121.                end if;
  2122.                NEW_LINE;
  2123.                NEW_LINE(LOG_FILE);
  2124.  
  2125.                TEXT_IO.PUT("OP1 - OP2                = ");
  2126.                PUT(LOG_FILE,"OP1 - OP2                = ");
  2127.                SFRESULT := SF1 - SF2;
  2128.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2129.                PUT_LINE(OP_STRING);
  2130.                PUT_LINE(LOG_FILE, OP_STRING);
  2131.                if FLOAT_COMPARE then
  2132.                   TEXT_IO.PUT("SYSTEM OP1 - OP2         = ");
  2133.                   PUT(LOG_FILE,"SYSTEM OP1 - OP2         = ");
  2134.                   FPRESULT := FP1 - FP2;
  2135.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2136.                   PUT_LINE(OP_STRING);
  2137.                   PUT_LINE(LOG_FILE, OP_STRING);
  2138.                end if;
  2139.                NEW_LINE;
  2140.                NEW_LINE(LOG_FILE);
  2141.  
  2142.                TEXT_IO.PUT("OP1 * OP2                = ");
  2143.                PUT(LOG_FILE,"OP1 * OP2                = ");
  2144.                SFRESULT := SF1 * SF2;
  2145.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2146.                PUT_LINE(OP_STRING);
  2147.                PUT_LINE(LOG_FILE, OP_STRING);
  2148.                if FLOAT_COMPARE then
  2149.                   TEXT_IO.PUT("SYSTEM OP1 * OP2         = ");
  2150.                   PUT(LOG_FILE,"SYSTEM OP1 * OP2         = ");
  2151.                   FPRESULT := FP1 * FP2;
  2152.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2153.                   PUT_LINE(OP_STRING);
  2154.                   PUT_LINE(LOG_FILE, OP_STRING);
  2155.                end if;
  2156.                NEW_LINE;
  2157.                NEW_LINE(LOG_FILE);
  2158.  
  2159.                TEXT_IO.PUT("OP1 / OP2                = ");
  2160.                PUT(LOG_FILE,"OP1 / OP2                = ");
  2161.                SFRESULT := SF1 / SF2;
  2162.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2163.                PUT_LINE(OP_STRING);
  2164.                PUT_LINE(LOG_FILE, OP_STRING);
  2165.                if FLOAT_COMPARE then
  2166.                   TEXT_IO.PUT("SYSTEM OP1 / OP2         = ");
  2167.                   PUT(LOG_FILE,"SYSTEM OP1 / OP2         = ");
  2168.                   FPRESULT := FP1 / FP2;
  2169.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2170.                   PUT_LINE(OP_STRING);
  2171.                   PUT_LINE(LOG_FILE, OP_STRING);
  2172.                end if;
  2173.                NEW_LINE;
  2174.                NEW_LINE(LOG_FILE);
  2175.  
  2176.                TEXT_IO.PUT("(OP1 / OP2) * OP2        = ");
  2177.                PUT(LOG_FILE,"(OP1 / OP2) * OP2        = ");
  2178.                SFRESULT := SFRESULT * SF2;
  2179.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2180.                PUT_LINE(OP_STRING);
  2181.                PUT_LINE(LOG_FILE, OP_STRING);
  2182.                if FLOAT_COMPARE then
  2183.                   TEXT_IO.PUT("SYSTEM (OP1 / OP2) * OP2 = ");
  2184.                   PUT(LOG_FILE,"SYSTEM (OP1 / OP2) * OP2 = ");
  2185.                   FPRESULT := FPRESULT * FP2;
  2186.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2187.                   PUT_LINE(OP_STRING);
  2188.                   PUT_LINE(LOG_FILE, OP_STRING);
  2189.                end if;
  2190.                NEW_LINE;
  2191.                NEW_LINE(LOG_FILE);
  2192.  
  2193.             when 'F' | 'f' =>
  2194.                TEXT_IO.PUT("OP1 ** POWER             = ");
  2195.                PUT(LOG_FILE,"OP1 ** POWER             = ");
  2196.                SFRESULT1 := SF1 ** POWER;
  2197.                PUT(OP_STRING, SFRESULT1, SHORT_AFT, SHORT_EXP);
  2198.                PUT_LINE(OP_STRING);
  2199.                PUT_LINE(LOG_FILE, OP_STRING);
  2200.                if FLOAT_COMPARE then
  2201.                   TEXT_IO.PUT("SYSTEM OP1 ** POWER      = ");
  2202.                   PUT(LOG_FILE,"SYSTEM OP1 ** POWER      = ");
  2203.                   FPRESULT1 := FP1 ** POWER;
  2204.                   PUT(OP_STRING, FPRESULT1, SHORT_AFT, SHORT_EXP);
  2205.                   PUT_LINE(OP_STRING);
  2206.                   PUT_LINE(LOG_FILE, OP_STRING);
  2207.                end if;
  2208.                NEW_LINE;
  2209.                NEW_LINE(LOG_FILE);
  2210.  
  2211.                TEXT_IO.PUT("OP1 ** -POWER            = ");
  2212.                PUT(LOG_FILE,"OP1 ** -POWER            = ");
  2213.                SFRESULT2 := SF1 ** (-POWER);
  2214.                PUT(OP_STRING, SFRESULT2, SHORT_AFT, SHORT_EXP);
  2215.                PUT_LINE(OP_STRING);
  2216.                PUT_LINE(LOG_FILE, OP_STRING);
  2217.                if FLOAT_COMPARE then
  2218.                   TEXT_IO.PUT("SYSTEM OP1 ** -POWER     = ");
  2219.                   PUT(LOG_FILE,"SYSTEM OP1 ** -POWER     = ");
  2220.                   FPRESULT2 := FP1 ** (-POWER);
  2221.                   PUT(OP_STRING, FPRESULT2, SHORT_AFT, SHORT_EXP);
  2222.                   PUT_LINE(OP_STRING);
  2223.                   PUT_LINE(LOG_FILE, OP_STRING);
  2224.                end if;
  2225.                NEW_LINE;
  2226.                NEW_LINE(LOG_FILE);
  2227.  
  2228.                TEXT_IO.PUT("RESULT1 * RESULT2        = ");
  2229.                PUT(LOG_FILE,"RESULT1 * RESULT2        = ");
  2230.                SFRESULT := SFRESULT1 * SFRESULT2;
  2231.                PUT(OP_STRING, SFRESULT, SHORT_AFT, SHORT_EXP);
  2232.                PUT_LINE(OP_STRING);
  2233.                PUT_LINE(LOG_FILE, OP_STRING);
  2234.                if FLOAT_COMPARE then
  2235.                   TEXT_IO.PUT("SYSTEM RESULT1 * RESULT2 = ");
  2236.                   PUT(LOG_FILE,"SYSTEM RESULT1 * RESULT2 = ");
  2237.                   FPRESULT := FPRESULT1 * FPRESULT2;
  2238.                   PUT(OP_STRING, FPRESULT, SHORT_AFT, SHORT_EXP);
  2239.                   PUT_LINE(OP_STRING);
  2240.                   PUT_LINE(LOG_FILE, OP_STRING);
  2241.                end if;
  2242.                NEW_LINE;
  2243.                NEW_LINE(LOG_FILE);
  2244.  
  2245.             when others =>
  2246.                null;
  2247.  
  2248.          end case;
  2249.  
  2250.          TEXT_IO.PUT("return to continue ...");
  2251.          GET_LINE(DUMMY,CNT);
  2252.  
  2253.    exception
  2254.       when others =>
  2255.          NEW_LINE;
  2256.          NEW_LINE(LOG_FILE);
  2257.          PUT_LINE("*** EXCEPTION CONDITION RAISED ***");
  2258.          PUT_LINE(LOG_FILE,"*** EXCEPTION CONDITION RAISED ***");
  2259.          NEW_LINE;
  2260.          NEW_LINE(LOG_FILE);
  2261.  
  2262.          TEXT_IO.PUT("return to continue ...");
  2263.          GET_LINE(DUMMY,CNT);
  2264.  
  2265.  
  2266.  
  2267.    end PUT_SHORT_FLOAT_RESULTS;
  2268.  
  2269. end TESTTSF;
  2270.  
  2271.