$DEBUG PAGELENGTH(55)

/***********************/
/*                     */
/*  E X $ L O C A T E  */
/*                     */
/***********************/

M$EX$LOCATE: DO;

/****************************************************/
/*                                                  */
/* OPERATION :                                      */
/*                                                  */
/*  1. Get input file name.                         */
/*  2. Get segment names and address. If no address */
/*      is given, it is assumed that the segment    */
/*      immidiately follows the previous one. If no */
/*      segment is given, operation stops.          */
/*  3. Get switches.                                */
/*  4. Get list file name, if needed                */
/*                                                  */
/* LAST UPDATED - 30.5.82  DROR                     */
/*                                                  */
/****************************************************/

$NOLIST
$INCLUDE(COMMON.DCL)
$INCLUDE(ISIS.DCL)
$INCLUDE(:F1:ISISIO.DCL)
$INCLUDE(STRING.DCL)
$LIST

GET$FNAME: PROCEDURE(NAME$P,TYPE,WILDCARD,NULLNAME,EXTPNT) EXTERNAL;
   DECLARE
       NAME$P ADDRESS,
       TYPE BYTE,
       WILDCARD BOOLEAN,
       NULLNAME BOOLEAN,
       EXTPNT BOOLEAN;
END GET$FNAME;

GET$PARM: PROCEDURE(PARM$P,ALL) EXTERNAL;
   DECLARE
      PARM$P ADDRESS,
      ALL BOOLEAN;
END GET$PARM;

SWITCH: PROCEDURE(YESNO$P,MSG$P) EXTERNAL;
   DECLARE
      YESNO$P ADDRESS,
      MSG$P ADDRESS;
END SWITCH;

DECLARE MSG$FILL$IN(1) BYTE EXTERNAL;
DECLARE MSG$OPTIONS(1) BYTE EXTERNAL;
DECLARE MSG$FILE$OR$RETURN(1) BYTE EXTERNAL;
DECLARE MSG$CLR$AFTER$FNAME(1) BYTE EXTERNAL;
DECLARE MSG$C$RGT1(1) BYTE EXTERNAL;
DECLARE MSG$SEGMENTS(1) BYTE EXTERNAL;
DECLARE MSG$SEGMENT(1) BYTE EXTERNAL;
DECLARE MSG$ADDRESS(1) BYTE EXTERNAL;
DECLARE
   ECOMP1 STRING EXTERNAL,
   ECOMP2 STRING EXTERNAL,
   ECOMP3 STRING EXTERNAL,
   ECOMP4 STRING EXTERNAL,
   ECOMP5 STRING EXTERNAL,
   ECOMP6 STRING EXTERNAL;

EX$LOCATE: PROCEDURE (COM$LINE$P,COM$TYPE$P) PUBLIC;
   DECLARE
      COM$LINE$P ADDRESS,
      COM$TYPE$P ADDRESS;
   DECLARE
      (COM$LINE BASED COM$LINE$P) STRING,
      (COM$TYPE BASED COM$TYPE$P) BYTE;
   DECLARE
      NAME STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(15) BYTE
         );
   DECLARE SEGMENTS(10) STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(32) BYTE
         );
   DECLARE
      ADDR STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(15) BYTE
         );
   DECLARE
      YESNO STRUCTURE(
         L BYTE,
         D(6) BYTE
         );
   DECLARE
      SWITCHES(6) STRUCTURE(
         COMP$P ADDRESS,
         LIST$FLAG BOOLEAN
         ) DATA (
            .COMP14,
            FALSE,
            .COMP9,
            TRUE,
            .COMP10,
            TRUE,
            .COMP11,
            TRUE,
            .COMP12,
            TRUE,
            .COMP13,
            FALSE
            );
   DECLARE
      COMP1 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(8) BYTE
         ) DATA (7,7,'LOCATE ',0);
   DECLARE
      COMP8 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(7) BYTE
         ) DATA (6,6,'ORDER(',0);
   DECLARE
      COMP9 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(5) BYTE
         ) DATA (4,4,' MAP',0);
   DECLARE
      COMP10 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(9) BYTE
         ) DATA (8,8,' SYMBOLS',0);
   DECLARE
      COMP11 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(9) BYTE
         ) DATA (8,8,' PUBLICS',0);
   DECLARE
      COMP12 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(7) BYTE
         ) DATA (6,6,' LINES',0);
   DECLARE
      COMP13 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(7) BYTE
         ) DATA (6,6,' PURGE',0);
   DECLARE
      COMP14 STRUCTURE(
         ML ADDRESS,
         L ADDRESS,
         D(10) BYTE
         ) DATA (9,9,' RESTART0',0);
   DECLARE MSG1(*) BYTE DATA(
      LF,
      '--- LOCATE AN 8080 / 8085 OBJECT FILE ---',CR,LF,
      LF,
      '  INPUT FILE',CR,LF,
      '..............',CR,
      0);
   DECLARE MSG6(*) BYTE DATA(
      CR,LF,LF,
      'LIST FILE',CR,LF,
      ':CO:              ( Type RETURN for default file )',CR,
      0);
   DECLARE MSG7(*) BYTE DATA(
      'Insrsert a jump to the start of the program at location 0',CR,LF,
      'Print a memory map',CR,LF,
      'Print symbols',CR,LF,
      'Print public symbols',CR,LF,
      'Print line numbers and their addresses',CR,LF,
      'Delete symbol table from output object file',CR,LF,
      0);
   DECLARE MSG8(*) BYTE DATA(
      '   ( NOTE - ASM-80 and PL/M-80 segments are',
      ' CODE,STACK,DATA,and MEMORY )',CR,LF,
      0);
   DECLARE
      LIST$FLAG BOOLEAN,
      I BYTE,
      J BYTE;

   CALL MSG$OUT(.MSG$FILL$IN);
   CALL MSG$OUT(.MSG1);
   COM$LINE.L=0;
   CALL APPEND$S(.COM$LINE,.COMP1);
   CALL GET$FNAME(.NAME,1,FALSE,FALSE,FALSE);   /* INPUT FILE */
   CALL APPEND$S(.COM$LINE,.NAME);
   CALL APPEND$S(.COM$LINE,.ECOMP1);
   CALL MSG$OUT(.MSG$SEGMENTS);
   CALL MSG$OUT(.MSG8);
   DO I=0 TO LAST(SEGMENTS);
      SEGMENTS(I).ML=31;
   END;
   ADDR.ML=14;
   I=0;
   J=0;
   SEGMENTS(0).L=1;
   DO WHILE (SEGMENTS(J).L>0) AND (I<LENGTH(SEGMENTS));
      J=I;
      CALL MSG$OUT(.MSG$SEGMENT);
      CALL GET$PARM(.SEGMENTS(I),TRUE);  /* SEGMENT NAME */
      IF SEGMENTS(I).L>0
         THEN DO;
            CALL MSG$OUT(.MSG$C$RGT1);
            CALL MSG$OUT(.MSG$CLR$AFTER$FNAME);
            CALL MSG$OUT(.MSG$ADDRESS);
            CALL GET$PARM(.ADDR,FALSE);  /* ADDRESS */
            IF ADDR.L>0
               THEN DO;
                  CALL MSG$OUT(.MSG$CLR$AFTER$FNAME);
                  CALL APPEND$S(.COM$LINE,.SEGMENTS(I));
                  CALL APPEND$S(.COM$LINE,.ECOMP2);
                  CALL APPEND$S(.COM$LINE,.ADDR);
                  CALL APPEND$S(.COM$LINE,.ECOMP4);
                  CALL APPEND$S(.COM$LINE,.ECOMP1);
               END;
               ELSE DO;
                  CALL MSG$OUT(.(CLR$LIN,CR,0));
               END;
            I=I+1;
         END;
   END;
   IF I>0
      THEN DO;
         CALL APPEND$S(.COM$LINE,.COMP8);
         DO J=0 TO I-1;
            CALL APPEND$S(.COM$LINE,.ECOMP1);
            CALL APPEND$S(.COM$LINE,.SEGMENTS(J));
            CALL APPEND$S(.COM$LINE,.ECOMP6);
         END;
      END;
   COM$LINE.L=COM$LINE.L-1;
   CALL APPEND$S(.COM$LINE,.ECOMP4);
   CALL APPEND$S(.COM$LINE,.ECOMP1);
   CALL MSG$OUT(.(CLR$LIN,CR,LF,LF,0));
   YESNO.L=6;
   DO I=0 TO LAST(YESNO.D);
      YESNO.D(I)=0;
   END;
   CALL SWITCH(.YESNO,.MSG7);
   LIST$FLAG=FALSE;
   DO I=0 TO LAST(YESNO.D);
      IF YESNO.D(I)=1
         THEN DO;
            CALL APPEND$S(.COM$LINE,SWITCHES(I).COMP$P);
            IF SWITCHES(I).LIST$FLAG
               THEN LIST$FLAG=TRUE;
         END;
   END;
   IF LIST$FLAG
      THEN DO;
         CALL MSG$OUT(.MSG6);
         CALL GET$FNAME(.NAME,3,FALSE,TRUE,FALSE);
         IF NAME.L>0
            THEN DO;
               CALL APPEND$S(.COM$LINE,.ECOMP3);
               CALL APPEND$S(.COM$LINE,.NAME);
               CALL APPEND$S(.COM$LINE,.ECOMP4);
            END;
      END;
   CALL APPEND$S(.COM$LINE,.ECOMP5);
   CALL MSG$OUT(.(CLR$SCRN,0));
   COM$TYPE=2;

END EX$LOCATE;



END M$EX$LOCATE;