************************************************************************        
************************************************************************        
                                                                                
      PROGRAM LIBWORK                                                           
************************************************************************        
*                                                                      *        
*  BEARBEITEN DER DETAILS EINER LIBRARY-FAMILIE.                       *        
*                                                                      *        
*  USER-, LIBRARY- UND MODELL-PARMS AUS FT05 (IN DIESER REIHENFOLGE):  *        
*  --------------------                                                *        
*     *PRJ  <PRJ>                                                      *        
*     *GRP  <GRP>                                                      *        
*     *USR  <USR>                                                      *        
*     *ACCT <ACCT>                                                     *        
*     *PWD  <PWD>                                                      *        
*                                                                      *        
*     *LIB  <LIBDSN>                                                   *        
*     *FAM  <FAMILY>                                                   *        
*                                                                      *        
*     *DSN  <DSN>                                                      *        
*     *MOD *<MODEL>                                                    *        
*                                                                      *        
*  BEARBEITUNGSAUFTRÄGE (ALTERNATIV)                                   *        
*  --------------------                                                *        
*     *REA                                                             *        
*     *WRI                                                             *        
*                                                                      *        
*  *REA - LESEN ALLER DETAILS EINER FAMILY IN EIN MODELL               *        
*  *WRI - SCHREIBEN ALLER DETAILS EINES MODELLS IN EINE FAMILY         *        
*                                                                      *        
*  ACHTUNG: IM TEST KONNTEN MIT *REA NUR KNAPP 1500 DETAILS EINGELESEN *        
*           WERDEN. DANACH IST DER INDEX EINES SPEZIAL-MODELLS VOLL.   *        
*          (LONDAT=6200KB, LONIND=1684KB)                              *        
*                                                                      *        
************************************************************************        
*                                                           *          *        
*  . AUTOR : DBB                                            *          *        
*    FIRMA : MRO                                            *          *        
*    TEL.  : 069/8305-2876                                  * 26.04.95 *        
*                                                           *          *        
*  . PROGRAMMIERSPRACHE : VS-FORTRAN V2R4M0                 *          *        
*  . FAMILY KÖNNEN AUCH BLANKS BEINHALTEN                   * 23.05.95 *        
*  . Aufnahme von Warning / Ignore DetailReadProblem        * 27.09.97 *        
*                                                           *          *        
************************************************** 27.09.97 ** DBb *****        
                                                                                
      IMPLICIT NONE                                                             
                                                                                
*-----------------------------------------------------------------------        
*  VARIABLEN-DEKLARATIONEN                                                      
*-----------------------------------------------------------------------        
      CHARACTER*8   ACCT                                                        
      CHARACTER*8   DDN                                                         
      CHARACTER*16  DETID                                                       
      CHARACTER*44  DSN                                                         
      INTEGER       DUMMY                                                       
      CHARACTER*6   DUMMY6                                                      
      CHARACTER*24  DUMMY24                                                     
      CHARACTER*80  DUMMY80                                                     
      LOGICAL*4     EOF                                                         
      CHARACTER*24  FAMILY                                                      
      LOGICAL       FOUND                                                       
      CHARACTER*8   GRP                                                         
*     INTEGER       LDATA                                                       
      CHARACTER*8   LIBDDN                                                      
      CHARACTER*44  LIBDSN                                                      
*     INTEGER       LINDEX                                                      
      CHARACTER*70  LMSG(10)                                                    
      INTEGER       KEYWLEN                                                     
      CHARACTER*80  KEYW                                                        
      CHARACTER*70  MODELID                                                     
      INTEGER       NBRELEM                                                     
      INTEGER       NMSG                                                        
      CHARACTER*8   PRJ                                                         
      CHARACTER*8   PWD                                                         
      INTEGER       READY                                                       
      CHARACTER*80  REST                                                        
      INTEGER       RESTLEN                                                     
      INTEGER       RET                                                         
      INTEGER*4     RETI4(12)                                                   
      REAL*8        RETR8(12)                                                   
      INTEGER*4     RETLCHAR(5)                                                 
      CHARACTER*80  RETCHAR(5)                                                  
      CHARACTER*35  SMSG                                                        
      LOGICAL       UPDATED                                                     
      CHARACTER*8   USR                                                         
      LOGICAL       WARNING
      INTEGER       WSP                                                         
      INTEGER       WSPTYP                                                      
      CHARACTER*80  ZEILE                                                       
                                                                                
*-----------------------------------------------------------------------        
*  PROGRAMM-RUMPF                                                               
*-----------------------------------------------------------------------        
*     WRITE(6,*) 'LIBWORK 1:'
      RET     = 0                                                               
	 WARNING = .FALSE.
*                                                CATGEO-ENV. AUFBAUEN           
      CALL CATGEO                                                               
*                                                FEHLERVAR. INITIAL.            
      CALL RETINI                                                               
                                                                                
*-----------------------------------------------------------------------        
*  LOGON-PARAMETER LESEN, ANMELDUNG AN CATIA                                    
*-----------------------------------------------------------------------        
*                                                ANMELDUNG AN CATIA             
      CALL CLOGON (5, 6, EOF,                                                   
     -             PRJ, GRP, USR, ACCT, PWD,                                    
     -             RET, *998)                                                   
*                                                NÄCHSTE PARAMETERZEILE         
      CALL GETLINE (5, 6, EOF, ZEILE, RET, *998)                                
                                                                                
*-----------------------------------------------------------------------        
*  LIBRARY-PARAMETER LESEN, LIBRARY CURRENT SETZEN                              
*-----------------------------------------------------------------------        
*                                                LIBDSN LESEN                   
      CALL GETKEYW (80, ZEILE, 4, '*LIB', EOF,                                  
     -              DUMMY, DUMMY80, RESTLEN, REST, RET, *998)                   
      CALL GETWORD (RESTLEN, REST,                                              
     -              DUMMY, LIBDSN, RET, *998)                                   
*                                                NÄCHSTE PARAMETERZEILE         
      CALL GETLINE (5, 6, EOF, ZEILE, RET, *998)                                
                                                                                
*-----------------------------------------------------------------------        
*                                                LIBRARY ALLOKIEREN             
      CALL GIFDDN ('LIBRARY ', LIBDSN, LIBDDN, DUMMY6, RET, *998)               
      CALL GIFALL ('LIBRARY ', LIBDDN, 'XXX', DUMMY, RET, *998)                 
*                                                LIBRARY-ENV. SETZEN            
      CALL GILIBR (LIBDDN, 9, 10, RET, *997)                                    
                                                                                
*-----------------------------------------------------------------------        
*                                                FAMILY LESEN                   
      CALL GETKEYW (80, ZEILE, 4, '*FAM', EOF,                                  
     -              DUMMY, DUMMY80, RESTLEN, REST, RET, *996)                   
      CALL GETCHR  (RESTLEN, REST,                                              
     -              24, FAMILY, RET, *996)                                  
*                                                NÄCHSTE PARAMETERZEILE         
      CALL GETLINE (5, 6, EOF, ZEILE, RET, *996)                                
                                                                                
*-----------------------------------------------------------------------        
*  MODELL-PARAMETER LESEN, MODELL ALLOKIEREN                                    
*-----------------------------------------------------------------------        
*                                                DSN LESEN                      
      CALL GETKEYW (80, ZEILE, 4, '*DSN', EOF,                                  
     -              DUMMY, DUMMY80, RESTLEN, REST, RET, *996)                   
      CALL GETWORD (RESTLEN, REST,                                              
     -              DUMMY, DSN, RET, *996)                                      
*                                                NÄCHSTE PARAMETERZEILE         
      CALL GETLINE (5, 6, EOF, ZEILE, RET, *996)                                
                                                                                
*-----------------------------------------------------------------------        
*                                                DSN ALLOKIEREN                 
      CALL GIFDDN ('MODEL   ', DSN, DDN, DUMMY6, RET, *996)                     
      CALL GIFALL ('MODEL   ', DDN, 'XXX', DUMMY, RET, *996)                    
                                                                                
*-----------------------------------------------------------------------        
*                                                MODELID LESEN                  
      CALL GETKEYW (80, ZEILE, 4, '*MOD', EOF,                                  
     -              DUMMY, DUMMY80, RESTLEN, REST, RET, *995)                   
*                                                GGF. 2. ZEILE NACHHOLEN        
      IF (REST .EQ. ' ') THEN                                                   
        CALL GETLINE (5, 6, EOF, ZEILE, RET, *995)                              
        RESTLEN = 80                                                            
        REST = ZEILE                                                            
      ENDIF                                                                     
      CALL GETCHR  (RESTLEN, REST, 70,                                          
     -              MODELID, RET, *995)                                         
*                                                NÄCHSTE PARAMETERZEILE         
      CALL GETLINE (5, 6, EOF, ZEILE, RET, *995)                                
                                                                                
*-----------------------------------------------------------------------        
*                                                MODELL LESEN                   
      DUMMY80 = MODELID                                                         
      CALL GIMREA (1, DDN, DUMMY80,                                             
*                                                LINDEX+LDATA AUS CATIA.dcls    
*    -             1684*128, 6200*128,                                          
     -             5000*128, 15000*128,                                      
     -             RET, *100)                                                   
      IF (.FALSE.) THEN                                                         
  100   IF (RET .NE. 1994) GOTO 995                                             
        RET = 20110                                                             
        RETLCHAR(1) = 24                                                        
        RETCHAR(1)  = DSN                                                       
        RETLCHAR(2) = 70                                                        
        RETCHAR(2)  = MODELID                                                   
        CALL RETSETX ('LIBWORK ',                                               
     -                 0, RETI4,                                                
     -                 0, RETR8,                                                
     -                 2, RETLCHAR, RETCHAR,                                    
     -                 RET)                                                     
        GOTO 995                                                                
      ENDIF                                                                     
      UPDATED = .FALSE.                                                         
                                                                                
*-----------------------------------------------------------------------        
*  BEARBEITUNGSAUFTRÄGE LESEN UND AUSFÜHREN                                     
*-----------------------------------------------------------------------        
      FOUND = .TRUE.                                                            
      DO WHILE ((.NOT. EOF) .AND. (FOUND))                                      
                                                                                
        FOUND = .FALSE.                                                         
        CALL GETKEYW (80, ZEILE, 0, DUMMY80, EOF,                               
     -                KEYWLEN, KEYW, RESTLEN, REST, RET, *995)                  
                                                                                
*-----------------------------------------------------------------------        
        IF ((.NOT. FOUND)               .AND.                                   
     -      (KEYW(1:KEYWLEN) .EQ. '*REA')   ) THEN                              
*                                                DETAILS AUS FAMILY LES.        
          FOUND = .TRUE.                                                        
          UPDATED = .TRUE.                                                      
*                                                ERSTES DETAIL                  
          DETID = ' '                                                           
          CALL GLSOBJ (FAMILY, DETID,                                           
     -                 DETID, READY, RET, *994)                                 
*                                                ÜBER FAMILY                    
          NBRELEM = 0                                                           
          DO WHILE (READY .NE. 1)                                               
            WRITE (6,*) 'DETAIL :', DETID                                       
*                                                DETAIL LESEN                   
            CALL GLRDET (1, DETID,                                              
*    -                   WSP, DUMMY24, RET, *994)                               
     -                   WSP, DUMMY24, RET, *102)                               
*                                                DETAIL DROPPEN                 
            CALL GICEXT (1, WSP,                                                
     -                   RET, *994)                                             
            NBRELEM = NBRELEM+1                                                 
            IF (.FALSE.) THEN
 102          WARNING = .TRUE.
              CALL RETPUSH('LIBWORK ', RET)
              CALL RETPUT ('LIBWORK ', RET)
              RET = 0
		    CALL RETINI
            ENDIF
*                                                NÄCHSTES DETAIL                
            CALL GLSOBJ (FAMILY, DETID,                                         
     -                   DETID, READY, RET, *994)                               
          ENDDO                                                                 
          WRITE (6,*) NBRELEM, 'DETAILS AUS LIBRARY GELESEN.'                   
*                                                NÄCHSTE PARAMETERZEILE         
          CALL GETLINE (5, 6, EOF, ZEILE, RET, *994)                            
        ENDIF                                                                   
                                                                                
*-----------------------------------------------------------------------        
        IF ((.NOT. FOUND)               .AND.                                   
     -      (KEYW(1:KEYWLEN) .EQ. '*WRI')   ) THEN                              
*                                                DETAILS IN FAMILY SCHR.        
          FOUND = .TRUE.                                                        
*                                                ERSTER WORKSPACE               
          DUMMY = WSP                                                           
          CALL GISWSP (1, DUMMY,                                                
     -                 WSP, WSPTYP, READY, RET, *994)                           
*                                                ÜBER WORKSPACES                
          NBRELEM = 0                                                           
          DO WHILE (READY .NE. 1)                                               
            IF (WSPTYP .NE. 1) THEN                                             
*                                                DETAIL-ID BESTIMMEN            
              DETID = ' '                                                       
              CALL GIRIDE (1, WSP,                                              
     -                     DUMMY, DETID, RET, *994)                             
              WRITE (6,*) 'DETAIL :', DETID                                     
*                                                DETAIL SCHREIBEN               
              CALL GLWDET (1, WSP, FAMILY,                                      
     -                     RET, *101)                                           
              NBRELEM = NBRELEM+1                                               
              IF (.FALSE.) THEN                                                 
  101           IF (RET .NE. 6998) GOTO 994                                     
                CALL RETMSG (SMSG, NMSG, LMSG)                                  
                IF (LMSG(1)(28:57) .NE.                                         
     -             'OBJECT NAME ALREADY IN LIBRARY') GOTO 994                   
                RET = 0                                                         
                CALL RETINI                                                     
*                                                DETAIL UPDATEN                 
                CALL GLUDET (1, WSP,                                            
     -                       RET, *994)                                         
                NBRELEM = NBRELEM+1                                             
              ENDIF                                                             
            ENDIF                                                               
*                                                NÄCHSTER WORKSPACE             
            DUMMY = WSP                                                         
            CALL GISWSP (1, DUMMY,                                              
     -                   WSP, WSPTYP, READY, RET, *994)                         
          ENDDO                                                                 
          WRITE (6,*) NBRELEM, 'DETAILS IN LIBRARY GESCHRIEBEN.'                
*                                                NÄCHSTE PARAMETERZEILE         
          CALL GETLINE (5, 6, EOF, ZEILE, RET, *994)                            
        ENDIF                                                                   
                                                                                
*-----------------------------------------------------------------------        
        IF (.NOT. FOUND) THEN                                                   
          RET = 20017                                                           
          RETLCHAR(1) = 1                                                       
          RETCHAR(1)  = '?'                                                     
          CALL RETSETX ('LIBWORK ',                                             
     -                   0, RETI4,                                              
     -                   0, RETR8,                                              
     -                   1, RETLCHAR, RETCHAR,                                  
     -                   RET)                                                   
          GOTO 995                                                              
        ENDIF                                                                   
                                                                                
      ENDDO                                                                     
                                                                                
*-----------------------------------------------------------------------        
*  UMGEBUNG FREIGEBEN / RÜCKSETZEN                                              
*-----------------------------------------------------------------------        
      IF (UPDATED) THEN                                                         
*                                                MODELL SCHREIBEN ...           
        DUMMY80 = MODELID                                                       
        CALL GIMWRI (1, DDN, DUMMY80, 1, 1, RET, *994)                          
      ELSE                                                                      
*                                                ... ODER DEALLOKIEREN          
        CALL GIMDEL (1, RET, *995)                                              
      ENDIF                                                                     
*                                                DSN DEALLOKIEREN               
      CALL GIFRES (DDN, RET, *996)                                              
*                                                LIBRARY-ENV. FREE              
      CALL GLFREE (RET, *997)                                                   
*                                                LIBRARY DEALLOKIEREN           
      CALL GIFRES (LIBDDN, RET, *998)                                           

      IF (WARNING)
     -  CALL STOP (4)
                                                                                
************************************************************************        
      STOP                                                                      
*                                                FEHLERBEHANDLUNG               
  994 CALL GIMDEL (1, DUMMY, *995)                                              
  995 CALL GIFRES (DDN, DUMMY, *996)                                            
  996 CALL GLFREE (DUMMY, *997)                                                 
  997 CALL GIFRES (LIBDDN, DUMMY, *998)                                         
  998 CALL RETPUSH ('LIBWORK ', RET)                                            
      CALL RETPUT  ('LIBWORK ', RET)                                            
  999 CALL STOP(8)                                                              
                                                                                
      END