C
C              **************************************************
C              *                 A L P A C K                    *
C              *                                                *
C              * ALADDIN STANDARD INTERFACE SUBROUTINE PACKAGE  *
C              **************************************************
C
C                  VERSION 1.0    30/04/1989
C
C     ORIGINAL VERSION DESIGNED AND WRITTEN BY R. A. HULSE, OF THE
C     PRINCETON UNIVERSITY, PLASMA PHYSICS LABORATORY.
C     [REFERENCE: "THE ALADDIN ATOMIC PHYSICS DATABASE SYSTEM,"
C      PP. 63-72 IN 'ATOMIC PROCESSES IN PLASMAS,' AIP CONFERENCE
C      PROCEEDINGS 206, EDS. Y.K. KIM AND R.C. ELTON, AMERICAN INSTITUTE
C      OF PHYSICS, NEW YORK, 1990].
C
C-------------------------------------------------------------------------------
C
C     REV. 2/03/89 BY J.J.SMITH IAEA ATOMIC AND MOLECULAR DATA UNIT
C          MAXIMUM LABEL LENGTH CHANGED FROM 20 TO 40 CHARACTERS
C          VARIABLE ILABEL MODIFIED
C
C#############################################################################
C
      SUBROUTINE ALREAD(KLUDF, KESEQN, KEOF, KERMSG)
C
C                        ************************
C                        * READ ENTRY FROM FILE *
C                        ************************
C
C     FIND AND READ THE NEXT ENTRY IN DATA FILE (LOGICAL UNIT NUMBER KLUDF)
C     INTO THE ENTRY BUFFER ARRAY EBUFF.  ALL LINES IN THE DATA FILE MUST BE
C     VALID ALADDIN FORMAT ENTRY LINES, EXCEPT THAT LINES AT THE START OF
C     THE FILE ARE IGNORED UNTIL THE FIRST VALID ALADDIN ENTRY IS FOUND,
C     BEGINNING WITH A "$" IN COLUMN 1.  THESE FIRST LINES CAN THUS BE USED AS
C     HEADER COMMENTS FOR THE DATA FILE.  ONCE READ INTO THE EBUFF BUFFER
C     ARRAY, THE ENTRY IS PARSED BY CALLING THE STANDARD PARSING ROUTINE ALPARS.
C
C     THE ENTRY SEQUENCE NUMBER KESEQN IS AUTOMATICALLY INCREMENTED BY THIS
C     ROUTINE, BUT MUST BE INITIALIZED AS ZERO BY THE CALLING ROUTINE AT THE
C     START OF A DATA FILE.  KESEQN .NE. 0 ON ENTRY IMPLIES THAT THIS IS A
C     SUBSEQUENT READ ON A DATA FILE ALREADY READ BY THIS ROUTINE, AND HENCE
C     THE ENTRY LINE DATA ARRAY EBUFF HAS THE FIRST LINE OF THE NEXT ENTRY
C     AVAILABLE AT POSTION NELN + 1.  ENCOUNTERING AN END OF FILE TERMINATING
C     THE CURRENT ENTRY IS NOTED BY SETTING THE STORED FIRST LINE OF THE
C     "NEXT ENTRY" AS THE STRING '$EOF'.  CALLS TO READ THE NEXT ENTRY WITH
C     THIS FLAG PRESENT CAUSE A RETURN WITH THE LAST ENTRY STILL IN PLACE AND
C     KEOF SET .TRUE.  ERROR MESSAGES ARE RETURNED THROUGH THE STRING KERMSG;
C     KERMSG = ' ' INDICATES NO ERRORS.
C
C-------------------------------------------------------------------------------
C
C     NOTE: THIS IS A STANDARD ALADDIN ROUTINE; IT INTERFACES ONLY THROUGH
C           THE SUBROUTINE CALL PASSED VARIABLES AND COMMON / ALENT /.
C
C-------------------------------------------------------------------------------
C
C------------------------------------------------------------------------------
      CHARACTER*(*) KERMSG
      CHARACTER*40 ILABEL
      LOGICAL KEOF
C
C-------------------------------------------------------------------------------
C
      INCLUDE 'ALPCOM.FOR'
C
C*******************************************************************************
C
C     IF THE ENTRY SEQUENCE NUMBER IS ZERO, THIS IS THE FIRST READ
C     OF A NEW DATA FILE.  SKIP POSSIBLE HEADER COMMENTS TO FIND FIRST
C     LINE OF FIRST ENTRY.  OTHERWISE, SHIFT THE PREVIOUSLY READ FIRST
C     LINE OF THE NEXT ENTRY INTO THE FIRST LINE POSITION.
C
      KEOF = .FALSE.
C
      IF(KESEQN .EQ. 0) THEN
C
 100    READ(KLUDF, '(A)', IOSTAT=IRDERR, END=110) EBUFF(1)
 110    CONTINUE
C
        IF(IRDERR .NE. 0) THEN
          KERMSG = ' NO ENTRIES IN FILE OR OTHER READ ERROR'
          RETURN
        ENDIF
C
        IF(EBUFF(1)(1:1) .NE. '$') GO TO 100
C
      ELSE IF(EBUFF(NELN+1) .EQ. '$EOF') THEN
        KEOF = .TRUE.
        KERMSG = ' '
        RETURN
C
      ELSE
C
C       MOVE FIRST LINE OF NEXT ENTRY (BUFFERED IN AT END OF CURRENT ENTRY)
C       INTO FIRST LINE POSITION BEFORE READING REST OF ENTRY FROM FILE
C
        EBUFF(1) = EBUFF(NELN+1)
C
      ENDIF
C
C     THE FIRST LINE OF THE NEW ENTRY IS NOW IN PLACE;
C     INCREMENT THE ENTRY SEQUENCE NUMBER AND INTIALIZE THE ENTRY LINE COUNTER
C
      KESEQN = KESEQN + 1
      NELN = 1
C
C     LOOP TO ADD ALL LINES FOR THIS ENTRY INTO EBUFF, PLUS THE FIRST
C     LINE OF THE NEXT ENTRY IS READ IN ORDER TO FIND THE '$' LABEL.
C     THIS EXTRA LINE IS HELD IN ORDER JUST AFTER THIS ENTRY IN EBUFF(NELN+1).
C     OCCURENCE OF AN END OF FILE IS FLAGGED BY SPECIAL LINE ENTRY '$EOF'
C
  200 IF(NELN .GE. NELNMX) THEN
        KERMSG = ' ENTRY DATA LINE ARRAY OVERFLOW'
        RETURN
      ENDIF
C
      NELN = NELN + 1
C
      READ(KLUDF, '(A)', IOSTAT=IRDERR, END=220) EBUFF(NELN)
  220 CONTINUE
C
      IF(IRDERR .GT. 0) THEN
        KERMSG = ' DATA FILE READ ERROR'
        RETURN
      ENDIF
C
      IF(IRDERR .LT. 0) EBUFF(NELN) = '$EOF'
C
C     IF '$' IN COLUMN 1 THIS IS THE FIRST LINE OF THE NEXT ENTRY
C
      IF(EBUFF(NELN)(1:1) .NE. '$') GO TO 200
C
C     DECREMENT NELN TO POINT TO LAST LINE OF THIS ENTRY
C
      NELN = NELN - 1
C
C-------------------------------------------------------------------------------
C
C     USE STANDARD ALADDIN PARSER TO PARSE THIS ENTRY INTO STANDARD
C     LABELS AND POINTERS; NOTE THAT THESE CAN BE RE-INTERPRETED OR
C     THE ENTRY RE-READ DIFFERENTLY LATER BY NON-STANDARD ACCESS ROUTINES.
C
      CALL ALPARS(KERMSG)
C
      RETURN
      END
C
C#############################################################################
C
      SUBROUTINE ALPARS(KERMSG)
C
C                      ***************************
C                      * ALADDIN STANDARD PARSER *
C                      ***************************
C
C     PARSE THE DATABASE FILE ENTRY LINES CONTAINED IN THE BUFFER EBUFF
C     INTO HIERARCHICAL LABELS AND BOOLEAN LABELS, PLUS POINTERS TO
C     POSSIBLE COMMENT LINES AND THE COEFFICIENT LINES IN THE ENTRY.
C     KERMSG RETURNS ERROR MESSAGES; KERMSG = ' ' INDICATES NO ERRORS.
C
C-------------------------------------------------------------------------------
C
C     NOTE: THIS IS A ALADDIN STANDARD ROUTINE, WHICH INTERFACES ONLY THROUGH
C           THE SUBROUTINE CALL PASSED VARIABLE AND COMMON / ALENT /.
C
C-------------------------------------------------------------------------------
C     REV. 2/03/89 BY J.J.SMITH IAEA ATOMIC AND MOLECULAR DATA UNIT
C          MAXIMUM LABEL LENGTH CHANGED FROM 20 TO 40 CHARACTERS
C          VARIABLE ILABEL MODIFIED
C
C------------------------------------------------------------------------------
C
      INCLUDE 'ALPCOM.FOR'
C
C-------------------------------------------------------------------------------
C
      CHARACTER*(*) KERMSG
      CHARACTER*40 ILABEL
C
C-------------------------------------------------------------------------------
C
C     INITIALIZE LINE AND CHARACTER POINTERS AT THE START OF THE ENTRY
C
      ILPTR = 1
      ICPTR = 1
C
C     INITIALIZE RETURN QUANTITIES
C
      NHL = 0
      NBL = 0
      NCMLN = 0
      NCFLN = 0
      KERMSG = ' '
C
C-------------------------------------------------------------------------------
C
C     THE ACCESS LABEL (WITH '$' PREFIX) IS ALWAYS FIRST BOOLEAN LABEL
C
      CALL ALXLBL(EBUFF, NELN, ILPTR, ICPTR, ILABEL, ILBLNC, IFLAG)
C
      IF(IFLAG .NE. 0 .OR. ILABEL(1:1) .NE. '$') THEN
        KERMSG = ' INVALID ACCESS LABEL LINE'
        RETURN
      ENDIF
C
      NBL = 1
      BL(1) = ILABEL
C
C-------------------------------------------------------------------------------
C
C     HIERARCHICAL LABEL SEARCH AND STORE LOOP
C
  100 CALL ALXLBL(EBUFF, NELN, ILPTR, ICPTR, ILABEL, ILBLNC, IFLAG)
C
C     ACT ON HIERACRCHICAL LABEL SEARCH ERROR FLAGS
C
C     0 = OK
C     -1 = LABEL TRUNCATED; ERROR RETURN
C     1 = END OF ENTRY REACHED WHILE STILL IN HL FIELD; ERROR RETURN
C
      IF(IFLAG .EQ. -1) THEN
        KERMSG = ' HIERARCHICAL LABEL "'//ILABEL//'" TRUNCATED'
        RETURN
      ENDIF
C
      IF(IFLAG .EQ. 1) THEN
C       KERMSG = ' PREMATURE END OF ENTRY, HIERARCHICAL LABEL FIELD'
        RETURN
      ENDIF
C
C     IF '&' OR '#' PREFIX HAS BEEN FOUND, MOVE TO BOOLEAN LABEL PROCESSING
C
      IF(ILABEL .EQ. '&') GO TO 200
      IF(ILABEL(1:1) .EQ. '#') GO TO 250
C
C     THIS IS ANOTHER HIERARCHICAL LABEL; STORE AND LOOP FOR NEXT LABEL
C
      IF(NHL .GE. NHLMX) THEN
        KERMSG = ' HIERARCHICAL LABEL ARRAY OVERFLOW'
        RETURN
      ENDIF
C
      NHL = NHL + 1
      HL(NHL) = ILABEL
      GO TO 100
C
C-------------------------------------------------------------------------------
C
C     BOOLEAN LABEL SEARCH AND STORE LOOP
C
C     NOTE THAT ACCESS LABEL HAS ALREADY BEEN STORED AS BL(1)
C
  200 CALL ALXLBL(EBUFF, NELN, ILPTR, ICPTR, ILABEL, ILBLNC, IFLAG)
C
C     ACT ON BOOLEAN LABEL SEARCH ERROR FLAGS
C
C     0 = OK
C     -1 = LABEL TRUNCATED; ERROR RETURN
C     1 = END OF ENTRY REACHED, ERROR RETURN
C
      IF(IFLAG .EQ. -1) THEN
        KERMSG = ' BOOLEAN LABEL "'//ILABEL//'" TRUNCATED'
        RETURN
      ENDIF
C
      IF(IFLAG .EQ. 1) THEN
        KERMSG = ' PREMATURE END OF ENTRY IN BOOLEAN LABEL FIELD'
        RETURN
      ENDIF
C
C     THIS IS ANOTHER BOOLEAN LABEL; STORE AND LOOP FOR NEXT LABEL
C
  250 IF(NBL .GE. NBLMX) THEN
        KERMSG = ' BOOLEAN LABEL ARRAY OVERFLOW'
        RETURN
      ENDIF
C
      NBL = NBL + 1
      BL(NBL) = ILABEL
C
C     IF THIS WAS A '#' PREFIX LABEL, END OF BOOLEAN FIELD;
C     MOVE TO COMMENT LINE PROCESSING
C
C     NOTE THAT THE EVALUATION LABEL (INCLUDING '#' PREFIX) IS ALWAYS
C     STORED AS THE LAST BOOLEAN LABEL
C
      IF(ILABEL(1:1) .NE. '#') GO TO 200
C
C-------------------------------------------------------------------------------
C
C     LOOK FOR COMMENT LINES, FLAGGED BY '!' IN COLUMN 1
C
      LCMPTR = ILPTR + 1
  300 ILPTR = ILPTR + 1
C
      IF(ILPTR .GT. NELN) THEN
C
C     NOTE THAT IT IS LEGAL TO HAVE NO COEFFICIENTS IN AN ENTRY
C
        NCMLN = NELN - LCMPTR + 1
        NCFLN = 0
        RETURN
      ENDIF
C
      IF(EBUFF(ILPTR)(1:1) .EQ. '!') GO TO 300
C
      LCFPTR = ILPTR
      NCMLN = LCFPTR - LCMPTR
      NCFLN = NELN - LCFPTR + 1
C
      RETURN
      END
C
C#############################################################################
C
      SUBROUTINE ALXLBL(KLINE, KNL, KLPTR, KCPTR,
     &                  KLABEL, KLBLNC, KFLAG)
C
C                     *********************************
C                     * EXTRACT BLANK-DELIMITED LABEL *
C                     *********************************
C
C     SEARCH FOR THE NEXT BLANK-DELIMITED LABEL STRING TO BE FOUND IN THE
C     CHARACTER DATA ARRAY KLINE (KNL LINES LONG), BEGINNING AT CHARACTER
C     POSITION KCPTR OF LINE KLPTR.  THE NEXT LABEL MAY START AT KCPTR OR
C     MAY BE PRECEEDED BY ANY NUMBER OF BLANKS.  IF KCPTR .GT. LEN(KLINE),
C     THE ROUTINE WILL START AT THE BEGINNING OF THE NEXT LINE.  THE
C     LABEL IS RETURNED IN KLABEL, ALONG WITH ITS NUMBER OF CHARACTERS, KLBLNC.
C     THE KLPTR AND KCPTR POINTERS ARE RETURNED POSITIONED READY FOR THE NEXT
C     CALL, 2 CHARACTERS AFTER THE END OF THE FOUND LABEL.  KFLAG = 0 FOR
C     NORMAL RETURNS, KFLAG = 1 WHEN NO MORE LABELS EXIST BEFORE THE END OF
C     THE KLINE ARRAY, KFLAG = -1 FOR LABEL TRUNCATED TO KLBLNC = LEN(KLABEL)
C     CHARACTERS TO FIT INTO KLABEL.
C
C-------------------------------------------------------------------------------
C
C     NOTE: THIS IS AN ALADDIN STANDARD SUBROUTINE, WHICH INTERFACES ONLY
C           THROUGH THE PASSED VARIABLES IN THE SUBROUTINE CALL.
C
C-------------------------------------------------------------------------------
C
      CHARACTER*(*) KLINE(KNL)
      CHARACTER*(*) KLABEL
C
C-------------------------------------------------------------------------------
C
C     MOVE TO NEXT LINE IF KCPTR POINTS BEYOND END OF THIS LINE;
C     RETURN WITH KFLAG = 1 IF THIS WOULD GO BEYOND END OF KLINE ARRAY
C
  100 IF(KCPTR .GT. LEN(KLINE(1))) THEN
        IF(KLPTR .LT. KNL) THEN
          KLPTR = KLPTR + 1
          KCPTR = 1
        ELSE
          KFLAG = 1
          RETURN
        ENDIF
      ENDIF
C
C-------------------------------------------------------------------------------
C
C     SEARCH FOR NEXT BLANK CHARACTER IN FIELD BEGINNING AT POINTER POSITION
C
      IBINDX= INDEX(KLINE(KLPTR)(KCPTR:), ' ')
C
      IF(IBINDX .EQ. 1) THEN
C
C     LEADING BLANK AT FIRST SEARCHED POSITION; INCREMENT POINTER AND TRY AGAIN
C
        KCPTR = KCPTR + 1
        GO TO 100
C
      ELSE IF(IBINDX .EQ. 0) THEN
C
C       NO BLANKS FOUND; LABEL MUST EXTEND TO END OF LINE, POSITION
C       END OF LABEL POINTER AT END OF LINE
C
        IEPTR = LEN(KLINE(KLPTR))
C
      ELSE
C
C       TRAILING BLANK FOUND AFTER LABEL; POSITION END OF LABEL POINTER
C       AT LAST CHARACTER OF LABEL, JUST BEFORE TRAILING BLANK
C
        IEPTR = KCPTR + IBINDX - 2
C
      ENDIF
C
C-------------------------------------------------------------------------------
C
C     LABEL FOUND; STARTS AT KCPTR, ENDS AT IEPTR
C
      KLABEL = KLINE(KLPTR)(KCPTR:IEPTR)
      KLBLNC = IEPTR - KCPTR + 1
C
C     FLAG SUCCESSFUL RETURN, OR -1 IF LABEL WAS TRUNCATED TO FIT IN KLABEL
C
      IF(KLBLNC .LE. LEN(KLABEL)) THEN
        KFLAG = 0
      ELSE
        KLBLNC = LEN(KLABEL)
        KFLAG = -1
      ENDIF
C
C     POSITION CHARACTER POINTER FOR EXIT AT POSITION JUST BEYOND THE
C     TRAILING BLANK; NOTE THAT IF THIS IS BEYOND THE END OF THE LINE,
C     THE NEXT CALL WILL SHIFT THE POINTERS AS REQUIRED
C
      KCPTR = IEPTR + 2
C
      RETURN
      END
C
C#############################################################################
C
      SUBROUTINE ALCOMP(KHSL, KNHSL, KBASL, KNBASL,
     &                 KBNSL, KNBNSL, KMATCH)
C
C                 *************************************
C                 * ALADDIN STANDARD LABEL COMPARATOR *
C                 *************************************
C
C     THIS ROUTINE TAKES THE SUPPLIED SEARCH LABELS AND DETERMINES IF
C     THE PARSED ENTRY CURRENTLY IN COMMON / ALENT / MATCHES THIS
C     SEARCH CRITERION.  IN ORDER TO DO SO, THE HIERARCHICAL LABELS
C     MUST MATCH EXACTLY, EXCEPT THAT "*" AS A SEARCH LABEL ACTS AS A
C     WILDCARD, MATCHING ANY ENTRY LABEL IN THAT POSITION.  THE "**"
C     WILDCARD EXTENDS THE WILDCARD MATCH TO ANY NUMBER OF HIERARCHICAL
C     LABELS TO THE RIGHT OF THAT POSITION.  BOOLEAN .AND. SEARCH LABELS
C     MUST APPEAR IN THE ENTRY BOOLEAN FIELD FOR A MATCH TO BE SUCCESSFUL,
C     WHILE BOOLEAN .NOT. SEARCH LABELS MUST *NOT* APPEAR IN THE ENTRY
C     FOR A SUCCESFUL MATCH.
C
C     NOTE: LABEL COMPARISONS ARE UPPER-CASE/LOWER-CASE INSENSITIVE, USING
C           THE LOGICAL FUNCTION ALCIEQ INSTEAD OF THE .EQ. OPERATOR
C
C     KHSL   HIERARCHICAL SEARCH LABELS
C     KNHSL  NUMBER OF HIERARCHICAL SEARCH LABELS
C     KBASL  BOOLEAN .AND. SEARCH LABELS
C     KNBASL NUMBER OF BOOLEAN .AND. SEARCH LABELS
C     KBNSL  BOOLEAN .NOT. SEARCH LABELS
C     KNBNSL NUMBER OF BOOLEAN .NOT. SEARCH LABELS
C
C     KMATCH LOGICAL .TRUE./.FALSE. RETURN ON A SUCCESFUL MATCH
C
C------------------------------------------------------------------------------
C
C     NOTE: THIS IS AN ALADDIN STANDARD SUBROUTINE.  IT INTERFACES ONLY
C           THROUGH THE SUBROUTINE CALL PASSED VARIABLES AND COMMON / ALENT/.
C
C------------------------------------------------------------------------------
C
      CHARACTER*(*) KHSL(1), KBASL(1), KBNSL(1)
      LOGICAL KMATCH
      LOGICAL ALCIEQ
      EXTERNAL ALCIEQ
C
      INCLUDE 'ALPCOM.FOR'
C
C     INITIALIZE RETURN SUCCESS FLAG AS FALSE TO SIMPLIFY RETURNS
C
      KMATCH = .FALSE.
C
C     DO HIERARCHICAL SEARCH LABEL COMPARISON IF THERE
C     ARE ANY HSL'S
C
      IF(KNHSL .GT. 0) THEN
      DO 100 JHSL = 1, KNHSL
C
C     '*' IN A HIERARCHICAL SEARCH LABEL POSITION IS A WILD CARD MATCH
C
      IF(KHSL(JHSL) .EQ. '*') GO TO 100
C
C     '**' IN A HIERARCHICAL SEARCH LABEL POSITION IS WILD CARD MATCH
C     TO REST OF HIERACHICAL SEARCH LABEL FIELD; PROCEED TO BOOLEAN SEARCH
C
      IF(KHSL(JHSL) .EQ. '**') GO TO 150
C
C     IF THIS POSITION DOES NOT MATCH, OR DOES NOT EXIST IN ENTRY,
C     THEN THIS ENTRY IS REJECTED; GET NEXT ENTRY
C
      IF(JHSL .GT. NHL) RETURN
      IF( .NOT. ALCIEQ(KHSL(JHSL), HL(JHSL)) ) RETURN
C
  100 CONTINUE
      ENDIF
C
C     ALL HIERARCHICAL SEARCH LABELS MATCH; HOWEVER, WITHOUT A "**" WILDCARD,
C     REJECT ENTRY IF IT HAS MORE HL THAN IN SEARCH REQUEST
C
      IF(NHL .GT. KNHSL) RETURN
C
C     ENTRY HAS MATCHED HIERARCHICAL SEARCH LABELS; PROCEED TO BOOLEAN SEARCH
C     SEARCH FAILS IF THERE ARE .AND. SEARCH LABELS AND NO ENTRY BL'S
C     SEARCH AUTOMATICALLY SUCCEEDS IF THER ARE NO SEARCH LABELS INPUT
C
  150 IF(KNBASL .GT. 0 .AND. NBL .EQ. 0) RETURN
      IF(KNBASL .GT. 0 .AND. NBL .GT. 0) THEN
C
      DO 300 JBASL = 1, KNBASL
C
      DO 200 JBL = 1, NBL
      IF( ALCIEQ(KBASL(JBASL), BL(JBL)) ) GO TO 300
  200 CONTINUE
C
C     COMPLETING .AND. LOOP WITHOUT A MATCH MEANS THIS ENTRY IS REJECTED
C
      RETURN
  300 CONTINUE
      ENDIF
C
      IF(KNBNSL .GT. 0 .AND. NBL .GT. 0) THEN
      DO 500 JBNSL = 1, KNBNSL
C
      DO 400 JBL = 1, NBL
C
C     A MATCH WITH A BOOLEAN .NOT. LABEL CAUSES REJECTION OF THIS ENTRY
C
      IF( ALCIEQ(KBNSL(JBNSL), BL(JBL)) ) RETURN
  400 CONTINUE
C
  500 CONTINUE
      ENDIF
C
C     THIS ENTRY SATISFIES ALL SEARCH CRITERIA
C
      KMATCH = .TRUE.
C
      RETURN
      END
      LOGICAL FUNCTION ALCIEQ(KA, KB)
C
C     CASE-INSENSITIVE CHARACTER STRING .EQ. FUNCTION
C
C     NOTE: INPUT STRINGS KA AND KB ARE LEFT UNCHANGED BY THIS ROUTINE
C
      CHARACTER*(*) KA, KB
      CHARACTER*132 IUCA, IUCB
      CHARACTER*26 IUC, ILC
C
      IUC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
      ILC = 'abcdefghijklmnopqrstuvwxyz'
C
C     CONVERT BOTH STRINGS TO UPPER CASE AND THEN COMPARE
C
      IUCA = KA
      DO 100 J = 1, LEN(KA)
      IDX = INDEX(ILC, KA(J:J))
      IF(IDX .NE. 0) IUCA(J:J) = IUC(IDX:IDX)
  100 CONTINUE
C
      IUCB = KB
      DO 200 J = 1, LEN(KB)
      IDX = INDEX(ILC, KB(J:J))
      IF(IDX .NE. 0) IUCB(J:J) = IUC(IDX:IDX)
  200 CONTINUE
C
      ALCIEQ = IUCA .EQ. IUCB
C
      RETURN
      END
C
C#############################################################################
C
      SUBROUTINE ALRECF(PCF, KNCF, KNCFMX, KERMSG)
C
C                  ****************************************
C                  * CONVERT COEFFICIENTS TO REAL NUMBERS *
C                  ****************************************
C
C     USING THE COEFFICIENT FIELD POINTERS IN COMMON / ALENT /,
C     PARSE THE COEFFICIENT LINES INTO REAL NUMBERS IN THE OUTPUT
C     ARRAY PCF.  KNCF RETURNS THE NUMBER OF COEFFICIENTS FOUND, WHILE
C     KNCFMX IS THE SUPPLIED DIMENSIONED LENGTH OF THE PCF ARRAY.
C     PROCESSING ERROR MESSAGES ARE RETURNED VIA KERMSG, WITH KERMSG = ' '
C     INDICATING NO ERRORS.
C
C                               **NOTE**
C
C     THE INDIVIDUAL COEFFICIENT VALUES ARE PARSED FROM THE COEFFICIENT
C     FIELD LINES AS BLANK-DELIMITED LABELS, USING THE ALXLBL ROUTINE.
C     THEREFORE, INDIVIDUAL DATA VALUES MUST BE BLANK DELIMITED (E.G.,
C     COMMAS ARE NOT VALID), AND MUST *NOT* CONTAIN ANY INTERNAL
C     BLANKS, OTHERWISE READ ERRORS WILL OCCUR !
C
C------------------------------------------------------------------------------
C
C     NOTE: THIS IS AN ALADDIN STANDARD SUBROUTINE.  IT INTERFACES USING
C           ONLY THE SUBROUTINE CALL PASSED VARIABLES AND COMMON / ALENT /.
C
C------------------------------------------------------------------------------
C
C     REV. 2/03/89 BY J.J.SMITH IAEA ATOMIC AND MOLECULAR DATA UNIT
C          PCF CHANGED FROM SINGLE TO DOUBLE PRECISION
C
C------------------------------------------------------------------------------
C
      DOUBLE PRECISION PCF(1)
      CHARACTER*(*) KERMSG
      CHARACTER*40 ILABEL
C
      INCLUDE 'ALPCOM.FOR'
C
      KERMSG = ' '
      KNCF = 0
      FEXTN = .TRUE.
C
      IF(NCFLN .EQ. 0) RETURN
C
      ILPTR = LCFPTR
      ICPTR = 1
C
  400 CALL ALXLBL(EBUFF, NELN, ILPTR, ICPTR, ILABEL, ILBLNC, IFLAG)
C
C     ACT ON LABEL SEARCH ERROR FLAGS
C
C     0 = OK
C     -1 = COEFFICIENT STRING TRUNCATED; ERROR RETURN
C     1 = END OF ENTRY REACHED PREMATURELY; ERROR RETURN
C
      IF(IFLAG .EQ. -1) THEN
        KERMSG = ' COEFFICIENT "'//ILABEL//'" TRUNCATED'
        RETURN
      ENDIF
C
      IF(IFLAG .EQ. 1) THEN
        IF(ILPTR .NE. NELN)
     &                 KERMSG = ' PREMATURE END OF COEFFICIENT FIELD'
        RETURN
      ENDIF
C
C     CONVERT THIS 'LABEL' TO A REAL NUMBER
C
      IF(KNCF .GE. KNCFMX) THEN
        KERMSG = ' COEFFICIENT ARRAY OVERFLOW'
        RETURN
      ENDIF
C
C     CHECK FOR THE LENGTH OF THE COEFFICIENT IF > 12 SET THE NUMBER
C     LENGTH FLAG TO TRUE.
C
      IF (ILBLNC .GT. 12) FEXTN =.FALSE.
C
      KNCF = KNCF + 1
      READ(ILABEL, '(BN,F20.0)', IOSTAT=ICFERR) PCF(KNCF)
C
C     IF NOT INTERNAL READ ERROR, LOOP BACK FOR NEXT COEFFICIENT
C     OTHERWISE, ERROR RETURN
C
      IF(ICFERR .EQ. 0) GO TO 400
C
      KERMSG = ' READ ERROR FOR COEFFICIENT "'//ILABEL//'"'
      RETURN
      END