with  TEXT_IO;                        use TEXT_IO;
with  INTEGER_TEXT_IO;                use INTEGER_TEXT_IO;
with  FLOAT_TEXT_IO;                  use FLOAT_TEXT_IO;
with  UATL_DATA_TYPES;                use UATL_DATA_TYPES;
with  UATL_BUILDER_DATA;              use UATL_BUILDER_DATA;
with  UATL_PROCEDURE_BUILDER_DATA;    use UATL_PROCEDURE_BUILDER_DATA;
with  INTERFACE_DATA_TYPES_DRIVERS;   use INTERFACE_DATA_TYPES_DRIVERS;   
with  FUNCTIONAL_INSTRUMENT_CONTROL_TYPES;  
   use FUNCTIONAL_INSTRUMENT_CONTROL_TYPES;
with  UATL_INTERACTIVE_IO;            use UATL_INTERACTIVE_IO;
with TEST_MANAGER_SCREEN_DISPLAY;     use TEST_MANAGER_SCREEN_DISPLAY;

package body  UATL_FIC_BUILDER  is

   APPLY_AC_ACTION       : constant STRING := "APPLY_AC_FREQUENCY";
   APPLY_SWEPT_AC_ACTION : constant STRING := "APPLY_SWEPT_AC_FREQUENCY";
   MEASURE_AC_V_ACTION   : constant STRING := "MEASURE_AC_VOLTAGE";
   MEASURE_AC_C_ACTION   : constant STRING := "MEASURE_AC_CURRENT";
   MEASURE_AC_F_ACTION   : constant STRING := "MEASURE_AC_FREQUENCY";
   MEASURE_AC_P_ACTION   : constant STRING := "MEASURE_AC_POWER";
   APPLY_DC_ACTION       : constant STRING := "APPLY_DC_VOLTAGE";
   APPLY_SWEPT_DC_ACTION : constant STRING := "APPLY_SWEPT_DC_VOLTAGE";
   MEASURE_DC_V_ACTION   : constant STRING := "MEASURE_DC_VOLTAGE";
   MEASURE_DC_C_ACTION   : constant STRING := "MEASURE_DC_CURRENT";
   REMOVE_ACTION         : constant STRING := "REMOVE";
   LOGICAL_ACTION        : constant STRING := "LOGICAL_TRANSLATION";
   DEVICE_ACTION         : constant STRING := "DEVICE_TRANSLATION";

   type Y_N is (Y,N);
   procedure GET is new GET_ENUMERATED(Y_N);

   type NEW_HERTZ  is new FLOAT range HERTZ'first..HERTZ'last;
   package NEW_HERTZ_IO is new FLOAT_IO(NEW_HERTZ);
   use NEW_HERTZ_IO;
   procedure  GET  is new GET_FLOAT(NEW_HERTZ);

   type NEW_DBM     is new FLOAT range DBM'first..DBM'last;
   package NEW_DBM_IO is new FLOAT_IO(NEW_DBM);
   use NEW_DBM_IO;
   procedure  GET  is new GET_FLOAT(NEW_DBM);

   type NEW_SECONDS is new FLOAT range SECONDS'first..SECONDS'last;
   package NEW_SECONDS_IO is new FLOAT_IO(NEW_SECONDS);
   use NEW_SECONDS_IO;
   procedure  GET  is new GET_FLOAT(NEW_SECONDS);

   type NEW_VOLTS   is new FLOAT range VOLTS'first..VOLTS'last;
   package NEW_VOLTS_IO is new FLOAT_IO(NEW_VOLTS);
   use NEW_VOLTS_IO;
   procedure  GET  is new GET_FLOAT(NEW_VOLTS);

   type NEW_AMPERES is new FLOAT range  AMPERES'first..AMPERES'last;
   package NEW_AMPERES_IO is new FLOAT_IO(NEW_AMPERES);
   use NEW_AMPERES_IO;
   procedure  GET  is new GET_FLOAT(NEW_AMPERES);

   type NEW_WATTS   is new FLOAT range WATTS'first..WATTS'last;
   package NEW_WATTS_IO is new FLOAT_IO(NEW_WATTS);
   use NEW_WATTS_IO;
   procedure  GET  is new GET_FLOAT(NEW_WATTS);

   type NEW_OHMS    is new FLOAT range  OHMS'first..OHMS'last;
   package NEW_OHMS_IO is new FLOAT_IO(NEW_OHMS);
   use NEW_OHMS_IO;
   procedure  GET  is new GET_FLOAT(NEW_OHMS);

   type VARIABLE_TYPES is (HERTZ,
                           DBM,
                           SECONDS,
                           VOLTS,
                           AMPERES,
                           WATTS,
                           OHMS,
                           METERS,
                           DRIVER_STATUS);

   package VARIABLE_TYPES_IO is new ENUMERATION_IO(VARIABLE_TYPES);
   use VARIABLE_TYPES_IO;

   IN_STRING    : STRING(1..80);
   IN_LENGTH    : NATURAL;

   S_STRING     : STRING(1..80);
   S_LENGTH     : NATURAL;

   LOG_DEV      : LOGICAL_DEVICE;
   FREQ         : NEW_HERTZ;
   START_FREQ   : NEW_HERTZ;
   STOP_FREQ    : NEW_HERTZ;
   FREQ_STEP    : NEW_HERTZ;
   STEP_TIME    : DURATION;
   PWR          : NEW_DBM;
   VOLT         : NEW_VOLTS;
   START_VOLT   : NEW_VOLTS;
   STOP_VOLT    : NEW_VOLTS;
   VOLT_STEP    : NEW_VOLTS;
   AMP          : NEW_AMPERES;
   OME          : NEW_OHMS;
   YN           : Y_N;
   FLOAT_STRING : STRING(1..12);
   DEVICE_COUNT : INTEGER := 0;

   MENU_FIC_TOP : LIST(1..3) := 
      (new STRING'("Functions"),
       new STRING'("Signals"),
       new STRING'("Exit"));

   MENU_FIC_FNC : LIST(1..6) := 
      (new STRING'("Apply"),
       new STRING'("Measure"),
       new STRING'("Remove"),
       new STRING'("Begin Test Block"),      
       new STRING'("End Test Block"),      
       new STRING'("Exit"));

   MENU_FIC_SIG : LIST(1..5) := 
      (new STRING'("AC Signal"),
       new STRING'("Swept AC Signal"),
       new STRING'("DC Signal"),
       new STRING'("Swept DC Signal"),      
       new STRING'("Exit"));

   MENU_FIC_APP : LIST(1..5) := 
      (new STRING'("Apply AC Frequency"),
       new STRING'("Apply Swept AC Signal"),
       new STRING'("Apply DC Signal"),
       new STRING'("Apply Swept DC Signal"),      
       new STRING'("Exit"));

   MENU_FIC_MEA : LIST(1..7) := 
      (new STRING'("Measure AC Frequency"),
       new STRING'("Measure AC Power"),
       new STRING'("Measure AC Voltage"),
       new STRING'("Measure AC Current"),      
       new STRING'("Measure DC Voltage"),      
       new STRING'("Measure DC Current"),      
       new STRING'("Exit"));

   MENU_FIC_AC  : LIST(1..6) := 
      (new STRING'("Apply AC Frequency"),
       new STRING'("Measure AC Frequency"),
       new STRING'("Measure AC Power"),
       new STRING'("Measure AC Voltage"),      
       new STRING'("Measure AC Current"),      
       new STRING'("Exit"));

   MENU_FIC_SAC  : LIST(1..2) := 
      (new STRING'("Apply Swept AC Frequency"),
       new STRING'("Exit"));


   MENU_FIC_DC  : LIST(1..4) := 
      (new STRING'("Apply DC Voltage"),
       new STRING'("Measure DC Voltage"),
       new STRING'("Measure DC Current"),      
       new STRING'("Exit"));

   MENU_FIC_SDC  : LIST(1..2) := 
      (new STRING'("Apply Swept DC Voltage"),
       new STRING'("Exit"));

   type DEVICE_LIST is array (POSITIVE range <>) of LOGICAL_DEVICE;
   DEVICES : DEVICE_LIST
               (1..INTEGER(LOGICAL_DEVICE'pos(LOGICAL_DEVICE'last)+1));
   NAMES   : LIST (1..INTEGER(LOGICAL_DEVICE'pos(LOGICAL_DEVICE'last)+1));

   procedure  GET  is new GET_INTEGER(NATURAL);

   package ID_TYPE_IO           is new INTEGER_IO(ID_TYPE);
   use ID_TYPE_IO;

   procedure  GET  is new GET_INTEGER(ID_TYPE);

   package TIMING_IO            is new FIXED_IO(DURATION);
   use TIMING_IO;

   procedure  GET  is new GET_FIXED(DURATION);

   package LOG_IO is new ENUMERATION_IO(LOGICAL_DEVICE);
   use LOG_IO;

   procedure  GET  is new GET_ENUMERATED(LOGICAL_DEVICE);

   function INSTRUMENT_CHOICE(TITTLE : in STRING) return LOGICAL_DEVICE is
      CHOICE : INTEGER;
   begin  
      loop
         CHOICE := DISPLAY_MENU_AND_GET_SELECTION
                      (TITTLE & " - SELECT AVAILABLE RESOURCE",NAMES);
      exit when CHOICE < NAMES'length;
      end loop;
      return DEVICES(CHOICE);
   end INSTRUMENT_CHOICE;

   procedure CHECK_FOR_NEW_VARIABLE (VAR_NAME : in STRING;
                                     VAR_TYPE : in VARIABLE_TYPES) is
      NEW_VAR : BOOLEAN := TRUE;
   begin
      for I in 1..VAR_NUMBER loop
         if VAR_NAME = VAR_NAMES(I)(1..VAR_LENGTHS(I)) then
            NEW_VAR := FALSE;
            exit;
         end if;
      end loop;
      if NEW_VAR then
         VAR_NUMBER                                := VAR_NUMBER + 1;
         VAR_NAMES(VAR_NUMBER)(1..VAR_NAME'length) := VAR_NAME;
         VAR_LENGTHS(VAR_NUMBER)                   := VAR_NAME'length;        
         PUT_LINE(DECL_FILE,FIRST_INDENT & VAR_NAME & COLON & 
                            VARIABLE_TYPES'image(VAR_TYPE) & SEMICOLON);
      end if;       
   end CHECK_FOR_NEW_VARIABLE;

   procedure CREATE_APPLY_AC_FREQUENCY is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(APPLY_AC_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Apply AC Frequency ********");
      NEW_LINE(2);
      GET
("         Enter frequency to apply [Hz]: ",FREQ);

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_APPLY_AC_FREQUENCY);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      PUT(FLOAT_STRING,FREQ);
      PUT(TEST_FILE,NESTING(NEST).all & FREQ_PARM & FLOAT_STRING);

      NEW_LINE;
      GET(
 "         Set power level? [y/n]:        ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter power level [dBm]:       ",PWR);
         PUT_LINE(TEST_FILE,COMMA);
         PUT(FLOAT_STRING,PWR);
         PUT(TEST_FILE,NESTING(NEST).all & POWER_PARM & FLOAT_STRING);
      end if;

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);


      PUT_LINE(TEST_FILE,COMMA);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_APPLY_AC_FREQUENCY;

   procedure CREATE_APPLY_SWEPT_AC_FREQUENCY is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(APPLY_SWEPT_AC_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Apply Swept AC Frequency ********");
      NEW_LINE(2);
      GET
("         Enter start frequency [Hz]: ",START_FREQ);
      NEW_LINE;
      GET
("         Enter stop frequency [Hz]:  ",STOP_FREQ);
      NEW_LINE;
      GET
("         Enter frequency step [Hz]:  ",FREQ_STEP);
      NEW_LINE;
      GET
("         Enter step duration [S]:    ",STEP_TIME);

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_APPLY_SWEPT_AC_FREQUENCY);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      PUT(FLOAT_STRING,START_FREQ);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & START_FREQ_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(FLOAT_STRING,STOP_FREQ);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STOP_FREQ_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(FLOAT_STRING,FREQ_STEP);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & FREQ_STEP_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(DURATION_TEXT,STEP_TIME);
      PUT(TEST_FILE,NESTING(NEST).all & STEP_DUR_PARM & DURATION_TEXT);

      NEW_LINE;
      GET(
 "         Set power level? [y/n]:        ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter power level [dBm]:    ",PWR);
         PUT_LINE(TEST_FILE,COMMA);
         PUT(FLOAT_STRING,PWR);
         PUT(TEST_FILE,NESTING(NEST).all & POWER_PARM & FLOAT_STRING);
      end if;

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,COMMA);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);

   end CREATE_APPLY_SWEPT_AC_FREQUENCY;

   procedure CREATE_APPLY_DC_VOLTAGE is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(APPLY_DC_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Apply DC Voltage ********");
      NEW_LINE(2);
      GET
("         Enter voltage to apply [V]:       ",VOLT);
      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_APPLY_DC_VOLTAGE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      PUT(FLOAT_STRING,VOLT);
      PUT(TEST_FILE,NESTING(NEST).all & VOLT_PARM & FLOAT_STRING);
      NEW_LINE;
      GET(
 "         Set maximum current level? [y/n]: ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter maximum current level [A]:  ",AMP);
         PUT_LINE(TEST_FILE,COMMA);
         PUT(FLOAT_STRING,AMP);
         PUT(TEST_FILE,NESTING(NEST).all & MAX_CURRENT_PARM & FLOAT_STRING);
      end if;

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,COMMA);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_APPLY_DC_VOLTAGE;

   procedure CREATE_APPLY_SWEPT_DC_VOLTAGE is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(APPLY_SWEPT_DC_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Apply Swept DC Voltage ********");
      NEW_LINE(2);
      GET
("         Enter start voltage [V]:   ",START_VOLT);
      NEW_LINE;
      GET
("         Enter stop voltage [V]:    ",STOP_VOLT);
      NEW_LINE;
      GET
("         Enter voltage step [V]:    ",VOLT_STEP);
      NEW_LINE;
      GET
("         Enter step duration [S]:   ",STEP_TIME);

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_APPLY_SWEPT_DC_VOLTAGE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      PUT(FLOAT_STRING,START_VOLT);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & START_VOLT_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(FLOAT_STRING,STOP_VOLT);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STOP_VOLT_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(FLOAT_STRING,VOLT_STEP);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & VOLT_STEP_PARM & FLOAT_STRING & 
                         COMMA);
      PUT(DURATION_TEXT,STEP_TIME);
      PUT(TEST_FILE,NESTING(NEST).all & STEP_DUR_PARM & DURATION_TEXT);

      NEW_LINE;
      GET(
 "         Set maximum current level? [y/n]: ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter maximum current level [A]:  ",AMP);
         PUT_LINE(TEST_FILE,COMMA);
         PUT(FLOAT_STRING,AMP);
         PUT(TEST_FILE,NESTING(NEST).all & MAX_CURRENT_PARM & FLOAT_STRING);
      end if;

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,COMMA);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);

   end CREATE_APPLY_SWEPT_DC_VOLTAGE;

                        
   procedure CREATE_MEASURE_AC_FREQUENCY is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_AC_F_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure AC Frequency ********");
      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_AC_FREQUENCY);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);

      NEW_LINE(2);
      GET(
 "         Use frequency range? [y/n]:        ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter start frequency [Hz]:        ",START_FREQ);
         NEW_LINE;
         GET
("         Enter stop frequency [Hz]:         ",STOP_FREQ);
         PUT(FLOAT_STRING,START_FREQ);
         PUT_LINE(TEST_FILE,NESTING(NEST).all & START_FREQ_PARM & 
                            FLOAT_STRING & COMMA);
         PUT(FLOAT_STRING,STOP_FREQ);
         PUT_LINE(TEST_FILE,NESTING(NEST).all & STOP_FREQ_PARM & FLOAT_STRING & 
                            COMMA);
      end if;

      NEW_LINE;
      PUT
("         Enter measured frequency variable: ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),HERTZ);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & MEAS_FREQ_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);

   end CREATE_MEASURE_AC_FREQUENCY;

   procedure CREATE_MEASURE_AC_POWER is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_AC_P_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure AC Power ********");

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_AC_POWER);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);

      NEW_LINE(2);
      GET(
 "         Use reference frequency? [y/n]:    ",YN);
      if YN = Y then
         NEW_LINE;
         GET
("         Enter reference frequency [Hz]:    ",FREQ);
         PUT(FLOAT_STRING,FREQ);
         PUT_LINE(TEST_FILE,NESTING(NEST).all & FREQ_PARM & FLOAT_STRING & 
                            COMMA);
      end if;
      NEW_LINE;
      PUT
("         Enter measured power variable:     ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),DBM);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & POWER_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_MEASURE_AC_POWER;

   procedure CREATE_MEASURE_AC_VOLTAGE is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_AC_V_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure AC Voltage ********");

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_AC_VOLTAGE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      NEW_LINE(2);
      PUT
("         Enter measured voltage variable:   ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),VOLTS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & VOLT_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_MEASURE_AC_VOLTAGE;

   procedure CREATE_MEASURE_AC_CURRENT is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_AC_C_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure AC Current ********");

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_AC_CURRENT);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      NEW_LINE(2);
      PUT
("         Enter measured current variable:   ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),AMPERES);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & CURRENT_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_MEASURE_AC_CURRENT;


   procedure CREATE_MEASURE_DC_VOLTAGE is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_DC_V_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure DC Voltage ********");

      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_DC_VOLTAGE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      NEW_LINE(2);
      PUT
("         Enter measured voltage variable:   ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),VOLTS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & VOLT_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_MEASURE_DC_VOLTAGE;

   procedure CREATE_MEASURE_DC_CURRENT is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(MEASURE_DC_C_ACTION);
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Measure DC Current ********");
      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_MEASURE_DC_CURRENT);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      NEW_LINE(2);
      PUT
("         Enter measured current variable:   ");
      GET_LINE(IN_STRING,IN_LENGTH);

      CHECK_FOR_NEW_VARIABLE(IN_STRING(1..IN_LENGTH),AMPERES);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & CURRENT_PARM & 
                         IN_STRING(1..IN_LENGTH) & COMMA);

      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);
   end CREATE_MEASURE_DC_CURRENT;

   procedure CREATE_REMOVE is
   begin
      LOG_DEV := INSTRUMENT_CHOICE(REMOVE_ACTION);
      CLEAR_SCREEN;
      NEW_LINE(TEST_FILE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & CALL_REMOVE);
      PUT_LINE(TEST_FILE,NESTING(NEST).all & USING_PARM & 
                         LOGICAL_DEVICE'image(LOG_DEV) & COMMA);
      NEW_LINE;
      PUT
("         Enter return status variable: ");
      GET_LINE(S_STRING,S_LENGTH);

      CHECK_FOR_NEW_VARIABLE(S_STRING(1..S_LENGTH),DRIVER_STATUS);

      PUT_LINE(TEST_FILE,NESTING(NEST).all & STATUS_PARM & 
                         S_STRING(1..S_LENGTH) & PAREN_SEMI);

   end CREATE_REMOVE;

   procedure SET_RESOURCE_LIST (BLOCK_TYPE : in STRING) is
      COUNT : INTEGER;
      DEV   : LOGICAL_DEVICE;
   begin
      NEW_LINE(3);
      GET("         How many resources do you want?: ",COUNT);
      if COUNT = 1 then
         PUT(TEST_FILE,ONE_ARROW);
      end if;
      NEW_LINE(TEST_FILE);
      for I in 1..COUNT loop
         DEV := INSTRUMENT_CHOICE(BLOCK_TYPE & ONE_SPACE & "-" &
                                  INTEGER'image(I));
         PUT(TEST_FILE,NESTING(NEST).all & SECOND_INDENT & 
                       LOGICAL_DEVICE'image(DEV));
         if I < COUNT then
            PUT_LINE(TEST_FILE,COMMA);
         end if;
      end loop;            
      PUT_LINE(TEST_FILE,RIGHT_PAREN & PAREN_SEMI);
   end SET_RESOURCE_LIST;

   procedure CREATE_TEST_BEGIN is
   begin
      CLEAR_SCREEN;
      PUT_STRING(4,1,
 "         ******** Begin Test Block ********");
      NEW_LINE(TEST_FILE);
      PUT(TEST_FILE,NESTING(NEST).all & CALL_BEGIN_TEST_BLOCK & LEFT_PAREN);
      SET_RESOURCE_LIST("BEGIN TEST BLOCK");
   end CREATE_TEST_BEGIN;

   procedure CREATE_TEST_END is
   begin
     CLEAR_SCREEN;
     PUT_STRING(4,1,
 "         ******** End Test Block ********");
      NEW_LINE(TEST_FILE);
      PUT(TEST_FILE,NESTING(NEST).all & CALL_END_TEST_BLOCK & LEFT_PAREN);
      SET_RESOURCE_LIST("END TEST BLOCK");
   end CREATE_TEST_END;

   procedure  CREATE_FIC_CALLS  is
      TOP_CHOICE    : POSITIVE;
      CHOICE        : POSITIVE;
      NEXT_CHOICE   : POSITIVE;
   begin
      loop

         TOP_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                          "FUNCTIONAL INSTRUMENT CONTROL",MENU_FIC_TOP);

         case TOP_CHOICE is
            when 1 =>
               loop
                  CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                               "FUNCTIONAL INSTRUMENT CONTROL - FUNCTIONS",
                                MENU_FIC_FNC);

                  -- Case on selection made

                  case  CHOICE  is
                     when  1 =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                      "FIC - APPLY FUNCTIONS",
                                       MENU_FIC_APP);

                           -- Case on choice 

                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_APPLY_AC_FREQUENCY;
                              when  2 =>
                                 CREATE_APPLY_SWEPT_AC_FREQUENCY;
                              when  3 =>
                                 CREATE_APPLY_DC_VOLTAGE;
                              when  4 =>
                                 CREATE_APPLY_SWEPT_DC_VOLTAGE;
                              when  5  =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;
 
                     when  2  =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                      "FIC - MEASURE FUNCTIONS",
                                       MENU_FIC_MEA);

                           -- Case on choice 

                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_MEASURE_AC_FREQUENCY;
                              when  2 =>
                                 CREATE_MEASURE_AC_POWER;
                              when  3 =>
                                 CREATE_MEASURE_AC_VOLTAGE;
                              when  4 =>
                                 CREATE_MEASURE_AC_CURRENT;
                              when  5 =>
                                 CREATE_MEASURE_DC_VOLTAGE;
                              when  6 =>
                                 CREATE_MEASURE_DC_CURRENT;
                              when  7  =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;

                     when  3  =>
                        CREATE_REMOVE;
                     when  4  =>
                        CREATE_TEST_BEGIN;
                     when  5  =>
                        CREATE_TEST_END;
                     when  6  =>
                        exit;
                     when others => 
                        null;
                  end case;
               end loop;

            when  2  =>
               loop
                  CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                               "FUNCTIONAL INSTRUMENT CONTROL - SIGNALS",
                                MENU_FIC_SIG);

                  -- Case on selection made

                  case  CHOICE  is
                     when  1 =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                      "FIC - AC SIGNAL FUNCTIONS",
                                       MENU_FIC_AC);

                           -- Case on choice 
        
                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_APPLY_AC_FREQUENCY;
                              when  2 =>
                                 CREATE_MEASURE_AC_FREQUENCY;
                              when  3 =>
                                 CREATE_MEASURE_AC_POWER;
                              when  4 =>
                                 CREATE_MEASURE_AC_VOLTAGE;
                              when  5 =>
                                 CREATE_MEASURE_AC_CURRENT;
                              when  6  =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;

                     when  2 =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                      "FIC - SWEPT AC SIGNAL FUNCTIONS",
                                       MENU_FIC_SAC);

                           -- Case on choice 
 
                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_APPLY_SWEPT_AC_FREQUENCY;
                              when  2 =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;

                     when  3 =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                      "FIC - DC SIGNAL FUNCTIONS",
                                       MENU_FIC_DC);

                           -- Case on choice 
 
                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_APPLY_DC_VOLTAGE;
                              when  2 =>
                                 CREATE_MEASURE_DC_VOLTAGE;
                              when  3 =>
                                 CREATE_MEASURE_DC_CURRENT;
                              when  4  =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;
 
                     when  4 =>
                        loop
                           NEXT_CHOICE := DISPLAY_MENU_AND_GET_SELECTION(
                                           "FIC - SWEPT DC SIGNAL FUNCTIONS",
                                            MENU_FIC_DC);

                           -- Case on choice 

                           case  NEXT_CHOICE  is
                              when  1 =>
                                 CREATE_APPLY_SWEPT_DC_VOLTAGE;
                              when  2  =>
                                 exit;
                              when  others =>
                                 null;
                           end case;
                        end loop;

                     when  5  =>
                        exit;
                     when others => 
                        null;
                  end case;
               end loop;

            when  3 =>
               exit;
            when  others =>
               null;
         end case;

      end loop;

   end  CREATE_FIC_CALLS;

begin

   for DEV in LOGICAL_DEVICE loop
      DEVICE_COUNT := DEVICE_COUNT + 1;
      DEVICES(DEVICE_COUNT) := DEV;
      NAMES(DEVICE_COUNT)   := new STRING'(LOGICAL_DEVICE'image(DEV));
   end loop;

end  UATL_FIC_BUILDER;