32 integer,
intent(in) :: lunit, lun, lundx
33 integer iprt, lud, ildx, imdx
41 call status(lundx,lud,ildx,imdx)
45 if (lunit==lundx)
then
48 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
49 write ( unit=errstr, fmt=
'(A,A,I3,A)' )
'BUFRLIB: READDX - READING BUFR DICTIONARY TABLE FROM ', &
50 'INPUT BUFR FILE IN UNIT ', lundx,
' INTO INTERNAL ARRAYS'
52 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
60 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
61 write ( unit=errstr, fmt=
'(A,A,I3,A,A,I3)' )
'BUFRLIB: READDX - COPYING BUFR DCTY TBL FROM INTERNAL ', &
62 'ARRAYS ASSOC. W/ INPUT UNIT ', lundx,
' TO THOSE ASSOC. W/ UNIT ', lunit
64 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
72 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
73 write ( unit=errstr, fmt=
'(A,A,I3,A,A,I3)' )
'BUFRLIB: READDX - COPYING BUFR DCTY TBL FROM INTERNAL ', &
74 'ARRAYS ASSOC. W/ OUTPUT UNIT ', lundx,
' TO THOSE ASSOC. W/ UNIT ', lunit
76 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
84 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
85 write ( unit=errstr, fmt=
'(A,A,I3,A)' )
'BUFRLIB: READDX - READING BUFR DICTIONARY TABLE FROM ', &
86 'USER-SUPPLIED TEXT FILE IN UNIT ', lundx,
' INTO INTERNAL ARRAYS'
88 call errwrt(
'++++++++++++BUFR ARCHIVE LIBRARY+++++++++++++++')
94 call bort(
'BUFRLIB: READDX - CANNOT DETERMINE SOURCE OF INPUT DICTIONARY TABLE')
128 integer,
intent(in) :: lunit, lun
129 integer iprt, ict, ier, idxmsg, iupbs3
144 do while ( .not. done )
146 if ( ier == -1 )
then
152 else if ( ier == -2 )
then
153 call bort(
'BUFRLIB: RDBFDX - ERROR READING A BUFR DICTIONARY MESSAGE')
154 else if ( idxmsg(
mgwa) /= 1 )
then
159 else if ( iupbs3(
mgwa,
'NSUB') == 0 )
then
170 if ( iprt >= 2 )
then
171 call errwrt(
'+++++++++++++++++++++++++++++++++++++++++++++++++')
172 write ( unit=errstr, fmt=
'(A,I3,A)' )
'BUFRLIB: RDBFDX - STORED NEW DX TABLE CONSISTING OF (', ict,
') MESSAGES;'
174 errstr =
'WILL APPLY THIS TABLE TO ALL SUBSEQUENT DATA IN FILE UNTIL NEXT DX TABLE IS FOUND'
176 call errwrt(
'+++++++++++++++++++++++++++++++++++++++++++++++++')
202 integer,
intent(in) :: lundx, lun
203 integer ios, iret, n, numbck, nemock, igetntbi
205 character*128 bort_str1
206 character*156 bort_str2
209 character*6 numb, nmb2
220 read(lundx,
'(A80)', iostat = ios) card
226 if(card(1: 1)==
'*') cycle
227 if(card(3:10)==
'--------') cycle
228 if(card(3:10)==
' ') cycle
229 if(card(3:10)==
'MNEMONIC') cycle
230 if(card(3:10)==
'TABLE D') cycle
231 if(card(3:10)==
'TABLE B') cycle
233 if(card(12:12)==
'|' .and. card(21:21)==
'|')
then
239 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
240 write(bort_str2,
'(18X,"MNEMONIC ",A," IN USER DICTIONARY HAS INVALID CHARACTERS")') nemo
241 call bort2(bort_str1,bort_str2)
245 if(nmb2(1:1)==
'A') nmb2(1:1) =
'3'
248 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
249 write(bort_str2,
'(18X,"DESCRIPTOR NUMBER ",A," IN USER '// &
250 'DICTIONARY HAS AN INVALID FIRST CHARACTER (F VALUE) - MUST BE A, 0 OR 3")') numb
251 call bort2(bort_str1,bort_str2)
254 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
255 write(bort_str2,
'(18X,"DESCRIPTOR NUMBER ",A," IN USER '// &
256 'DICTIONARY HAS NON-NUMERIC VALUES IN CHARACTERS 2-6 (X AND Y VALUES)")') numb
257 call bort2(bort_str1,bort_str2)
260 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
261 write(bort_str2,
'(18X,"DESCRIPTOR NUMBER ",A," IN USER '// &
262 'DICTIONARY HAS INVALID NUMBER IN CHARACTERS 2-3 (X VALUE) - MUST BE BETWEEN 00 AND 63")') numb
263 call bort2(bort_str1,bort_str2)
266 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
267 write(bort_str2,
'(18X,"DESCRIPTOR NUMBER ",A," IN USER '// &
268 'DICTIONARY HAS INVALID NUMBER IN CHARACTERS 4-6 (Y VALUE) - MUST BE BETWEEN 000 AND 255")') numb
269 call bort2(bort_str1,bort_str2)
272 if(numb(1:1)==
'A')
then
274 n = igetntbi( lun,
'A' )
275 call stntbia ( n, lun, numb, nemo, card(23:) )
276 if (
idna(n,lun,1) == 11 )
then
277 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
278 write(bort_str2,
'(18X,"USER-DEFINED MESSAGE TYPE ""011"" IS RESERVED FOR DICTIONARY MESSAGES")')
279 call bort2(bort_str1,bort_str2)
285 if(numb(1:1)==
'0')
then
287 call stntbi ( igetntbi(lun,
'B'), lun, numb, nemo, card(23:) )
291 if(numb(1:1)==
'3')
then
293 call stntbi ( igetntbi(lun,
'D'), lun, numb, nemo, card(23:) )
297 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
298 write(bort_str2,
'(18X,"DESCRIPTOR NUMBER ",A," IN USER '// &
299 'DICTIONARY HAS AN INVALID FIRST CHARACTER (F VALUE) - MUST BE A, 0 OR 3")') numb
300 call bort2(bort_str1,bort_str2)
304 if(card(12:12)==
'|' .and. card(19:19)/=
'|')
then
310 if(card(12:12)==
'|' .and. card(19:19)==
'|')
then
317 write(bort_str1,
'("BUFRLIB: RDUSDX - CARD READ IN IS: ",A)') card
318 write(bort_str2,
'(18X,"THIS CARD HAS A BAD FORMAT - IT IS NOT RECOGNIZED BY THIS SUBROUTINE")')
319 call bort2(bort_str1,bort_str2)
334 use modv_vars,
only: reps, idnr
338 integer,
intent(in) :: lun
339 integer maxtgs, maxtag, ntag, idn, jdn, iseq, irep, i, j, n, itab, iret, ier, numr, nemock
341 character*128 bort_str1, bort_str2
343 character*80,
intent(in) :: card
344 character*12 atag, tags(250)
345 character*8 nemo, nema, nemb
346 character*6 adn30, clemon
363 call nemtab(lun,nemo,idn,tab,iseq)
365 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
366 write(bort_str2,
'(18X,"MNEMONIC ",A," IS NOT A TABLE D ENTRY (UNDEFINED, TAB=",A,")")') nemo,tab
367 call bort2(bort_str1,bort_str2)
369 call parstr(seqs,tags,maxtgs,ntag,
' ',.true.)
371 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
372 write(bort_str2,
'(18X,"TABLE D SEQUENCE (PARENT) MNEMONIC ",A," DOES NOT CONTAIN ANY CHILD MNEMONICS")') nemo
373 call bort2(bort_str1,bort_str2)
383 if(atag(1:1)==reps(i))
then
388 if(atag(j:j)==reps(i+5))
then
393 call strnum(atag(j+1:maxtag),numr,ier)
394 if(i==1 .and. numr<=0)
then
395 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
396 write(bort_str2,
'(9X,"TBL D MNEM. ",A," CONTAINS REG. REPL. '// &
397 'CHILD MNEM. ",A," W/ INVALID # OF REPLICATIONS (",I3,") AFTER 2ND QUOTE")') nemo,tags(n),numr
398 call bort2(bort_str1,bort_str2)
400 if(i==1 .and. numr>255)
then
401 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
402 write(bort_str2,
'(18X,"TBL D MNEM. ",A," CONTAINS REG. REPL. '// &
403 'CHILD MNEM. ",A," W/ # OF REPLICATIONS (",I3,") > LIMIT OF 255")') nemo,tags(n),numr
404 call bort2(bort_str1,bort_str2)
406 if(i/=1 .and. numr/=0)
then
407 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
408 write(bort_str2,
'(18X,"TBL D MNEM. ",A," CONTAINS DELAYED REPL. '// &
409 'CHILD MNEM. ",A," W/ # OF REPL. (",I3,") SPECIFIED - A NO-NO")') nemo,tags(n),numr
410 call bort2(bort_str1,bort_str2)
417 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
418 write(bort_str2,
'(18X,"TABLE D SEQUENCE (PARENT) MNEMONIC ",A,'// &
419 '" CONTAINS A BADLY FORMED CHILD MNEMONIC ",A)') nemo,tags(n)
420 call bort2(bort_str1,bort_str2)
428 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
429 write(bort_str2,
'(18X,"TABLE D (PARENT) MNEMONIC ",A," CONTAINS'// &
430 ' A CHILD MNEMONIC ",A," NOT BETWEEN 1 & 8 CHARACTERS")') nemo,tags(n)
431 call bort2(bort_str1,bort_str2)
434 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
435 write(bort_str2,
'(18X,"TABLE D (PARENT) MNEMONIC ",A," CONTAINS'// &
436 ' A CHILD MNEMONIC ",A," WITH INVALID CHARACTERS")') nemo,tags(n)
437 call bort2(bort_str1,bort_str2)
439 call nemtab(lun,atag,idn,tab,iret)
444 if(tab==
'B' .and. irep/=0)
then
445 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
446 write(bort_str2,
'(18X,"TABLE D (PARENT) MNEMONIC ",A," CONTAINS'// &
447 ' A REPLICATED CHILD TABLE B MNEMONIC ",A," - A NO-NO")') nemo,tags(n)
448 call bort2(bort_str1,bort_str2)
450 if(atag(1:1)==
'.')
then
455 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
456 write(bort_str2,
'(18X,"TBL D (PARENT) MNEM. ",A," CONTAINS A '// &
457 '''FOLLOWING VALUE'' MNEMONIC WHICH IS LAST IN THE STRING")') nemo
458 call bort2(bort_str1,bort_str2)
460 nemb = tags(n+1)(1:8)
461 call numtab(lun,idn,nema,tab,itab)
462 call nemtab(lun,nemb,jdn,tab,iret)
465 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
466 write(bort_str2,
'(18X,"TBL D (PARENT) MNEM. ",A," CONTAINS AN '// &
467 'INVALID ''FOLLOWING VALUE'' MNEMONIC ",A,"(SHOULD BE ",A,")")') nemo,tags(n),nema
468 call bort2(bort_str1,bort_str2)
471 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
472 write(bort_str2,
'(18X,"TBL D (PARENT) MNEM. ",A,", THE MNEM. ",'// &
473 'A," FOLLOWING A ''FOLLOWING VALUE'' MNEM. IS NOT A TBL B ENTRY")') nemo,nemb
474 call bort2(bort_str1,bort_str2)
478 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
479 write(bort_str2,
'(18X,"TABLE D SEQUENCE (PARENT) MNEMONIC ",A,'// &
480 '" CONTAINS A CHILD MNEMONIC ",A," NOT FOUND IN ANY TABLE")') nemo,tags(n)
481 call bort2(bort_str1,bort_str2)
485 if(irep>0)
call pktdd(iseq,lun,idnr(irep)+numr,iret)
487 clemon = adn30(idnr(irep)+numr,6)
488 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
489 write(bort_str2,
'(9X,"TBL D (PARENT) MNEM. ",A," - BAD RETURN '// &
490 'FROM PKTDD TRYING TO STORE REPL. DESC. ",A,", SEE PREV. WARNING MSG")') nemo,clemon
491 call bort2(bort_str1,bort_str2)
493 call pktdd(iseq,lun,idn,iret)
495 write(bort_str1,
'("BUFRLIB: SEQSDX - CARD READ IN IS: ",A)') card
496 write(bort_str2,
'(9X,"TBL D (PARENT) MNEM. ",A," - BAD RETURN '// &
497 'FROM PKTDD TRYING TO STORE CHILD MNEM. ",A,", SEE PREV. WARNING MSG")') nemo,tags(n)
498 call bort2(bort_str1,bort_str2)
521 integer,
intent(in) :: lun
522 integer idsn, iele, iret
524 character*128 bort_str1, bort_str2
525 character*80,
intent(in) :: card
527 character*11 refr, refr_orig
529 character*4 scal, scal_orig
530 character*3 bitw, bitw_orig
547 call nemtab(lun,nemo,idsn,tab,iele)
549 write(bort_str1,
'("BUFRLIB: ELEMDX - CARD READ IN IS: ",A)') card
550 write(bort_str2,
'(18X,"MNEMONIC ",A," IS NOT A TABLE B ENTRY (UNDEFINED, TAB=",A,")")') nemo,tab
551 call bort2(bort_str1,bort_str2)
558 write(bort_str1,
'("BUFRLIB: ELEMDX - CARD READ IN IS: ",A)') card
559 write(bort_str2,
'(18X,"UNITS FIELD IS EMPTY")')
560 call bort2(bort_str1,bort_str2)
562 tabb(iele,lun)(71:94) = unit
565 call jstnum(scal,sign,iret)
567 write(bort_str1,
'("BUFRLIB: ELEMDX - CARD READ IN IS: ",A)') card
568 write(bort_str2,
'(18X,"PARSED SCALE VALUE (=",A,") IS NOT NUMERIC")') scal_orig
569 call bort2(bort_str1,bort_str2)
571 tabb(iele,lun)(95:95) = sign
572 tabb(iele,lun)(96:98) = scal(1:3)
575 call jstnum(refr,sign,iret)
577 write(bort_str1,
'("BUFRLIB: ELEMDX - CARD READ IN IS: ",A)') card
578 write(bort_str2,
'(18X,"PARSED REFERENCE VALUE (=",A,") IS NOT NUMERIC")') refr_orig
579 call bort2(bort_str1,bort_str2)
581 tabb(iele,lun)( 99: 99) = sign
582 tabb(iele,lun)(100:109) = refr(1:10)
585 call jstnum(bitw,sign,iret)
586 if(iret/=0 .or. sign==
'-')
then
587 write(bort_str1,
'("BUFRLIB: ELEMDX - CARD READ IN IS: ",A)') card
588 write(bort_str2,
'(18X,"PARSED BIT WIDTH VALUE (=",A,") IS NOT NUMERIC")') bitw_orig
589 call bort2(bort_str1,bort_str2)
591 tabb(iele,lun)(110:112) = bitw
607 use modv_vars,
only: idnr
613 integer,
intent(in) :: lun, ioi
614 integer ibct, ipd1, ipd2, ipd3, ipd4, ninib, ninid, n, i, iret, ifxy
616 character*8 inib(6,5),inid(5)
619 common /padesc/ ibct, ipd1, ipd2, ipd3, ipd4
621 data inib /
'------',
'BYTCNT ',
'BYTES ',
'+0',
'+0',
'16', &
622 '------',
'BITPAD ',
'NONE ',
'+0',
'+0',
'1 ', &
623 '031000',
'DRF1BIT ',
'NUMERIC',
'+0',
'+0',
'1 ', &
624 '031001',
'DRF8BIT ',
'NUMERIC',
'+0',
'+0',
'8 ', &
625 '031002',
'DRF16BIT',
'NUMERIC',
'+0',
'+0',
'16'/
651 call pktdd(i,lun,0,iret)
658 inib(1,1) = adn30(ibct,6)
659 inib(1,2) = adn30(ipd4,6)
663 idnb(i,lun) = ifxy(inib(1,i))
664 tabb(i,lun)( 1: 6) = inib(1,i)(1:6)
665 tabb(i,lun)( 7: 70) = inib(2,i)
666 tabb(i,lun)( 71: 94) = inib(3,i)
667 tabb(i,lun)( 95: 98) = inib(4,i)(1:4)
668 tabb(i,lun)( 99:109) = inib(5,i)
669 tabb(i,lun)(110:112) = inib(6,i)(1:3)
674 idnd(n,lun) = idnr(i)
675 tabd(n,lun)(1: 6) = adn30(idnr(i),6)
676 tabd(n,lun)(7:70) = inid(i)
677 call pktdd(n,lun,idnr(1),iret)
678 call pktdd(n,lun,idnr(i+5),iret)
696 subroutine dxmini(mbay,mbyt,mb4,mba,mbb,mbd)
698 use modv_vars,
only: mxmsgld4
702 integer,
intent(out) :: mbay(*), mbyt, mb4, mba, mbb, mbd
703 integer maxdx, idxv, nxstr, ldxa, ldxb, ldxd, ld30, mtyp, msbt, mbit, ih, id, im, iy, i, nsub, idxs, ldxs, &
704 nby0, nby1, nby2, nby3, nby4, nby5, iupm
706 character*128 bort_str
709 common /dxtab/ maxdx, idxv, nxstr(10), ldxa(10), ldxb(10), ldxd(10), ld30(10), dxstr(10)
736 nby3 = 7 + nxstr(idxs) + 1
739 mbyt = nby0+nby1+nby2+nby3+nby4+nby5
741 if(mod(nby3,2)/=0)
call bort (
'BUFRLIB: DXMINI - LENGTH OF SECTION 3 IS NOT A MULTIPLE OF 2')
745 call pkc(
'BUFR' , 4 , mbay,mbit)
746 call pkb( mbyt , 24 , mbay,mbit)
747 call pkb( 3 , 8 , mbay,mbit)
751 call pkb( nby1 , 24 , mbay,mbit)
752 call pkb( 0 , 8 , mbay,mbit)
753 call pkb( 3 , 8 , mbay,mbit)
754 call pkb( 7 , 8 , mbay,mbit)
755 call pkb( 0 , 8 , mbay,mbit)
756 call pkb( 0 , 8 , mbay,mbit)
757 call pkb( mtyp , 8 , mbay,mbit)
758 call pkb( msbt , 8 , mbay,mbit)
759 call pkb( 36 , 8 , mbay,mbit)
760 call pkb( idxv , 8 , mbay,mbit)
761 call pkb( iy , 8 , mbay,mbit)
762 call pkb( im , 8 , mbay,mbit)
763 call pkb( id , 8 , mbay,mbit)
764 call pkb( ih , 8 , mbay,mbit)
765 call pkb( 0 , 8 , mbay,mbit)
766 call pkb( 0 , 8 , mbay,mbit)
770 call pkb( nby3 , 24 , mbay,mbit)
771 call pkb( 0 , 8 , mbay,mbit)
772 call pkb( 1 , 16 , mbay,mbit)
773 call pkb( 2**7 , 8 , mbay,mbit)
775 call pkb(iupm(dxstr(idxs)(i:i),8),8,mbay,mbit)
777 call pkb( 0 , 8 , mbay,mbit)
782 call pkb( nby4 , 24 , mbay,mbit)
783 call pkb( 0 , 8 , mbay,mbit)
785 call pkb( 0 , 8 , mbay,mbit)
787 call pkb( 0 , 8 , mbay,mbit)
789 call pkb( 0 , 8 , mbay,mbit)
791 if(mbit/8+nby5/=mbyt)
then
792 write(bort_str,
'("BUFRLIB: DXMINI - NUMBER OF BYTES STORED FOR '// &
793 'A MESSAGE (",I6,") IS NOT THE SAME AS FIRST CALCULATED, MBYT (",I6)') mbit/8+nby5,mbyt
815 integer,
intent(in) :: lunit, lun, lundx
817 character*128 bort_str
821 if(lunit==lundx)
then
822 write(bort_str,
'("BUFRLIB: WRITDX - FILES CONTAINING BUFR DATA '// &
823 'AND DICTIONARY TABLE CANNOT BE THE SAME (HERE BOTH SHARE FORTRAN UNIT NUMBER ",I3,")")') lunit
829 call readdx(lunit,lun,lundx)
851 use modv_vars,
only: im8b
858 integer,
intent(in) :: lundx, lunot
859 integer maxdx, idxv, nxstr, ldxa, ldxb, ldxd, ld30, my_lundx, my_lunot, ldx, lot, il, im, lda, ldb, ldd, l30, nseq, &
860 mbit, mbyt, mby4, mbya, mbyb, mbyd, i, j, jj, idn, lend, len0, len1, len2, l3, l4, l5,
iupb,
iupm
862 common /dxtab/ maxdx, idxv, nxstr(10), ldxa(10), ldxb(10), ldxd(10), ld30(10), dxstr(10)
874 call x84(lundx,my_lundx,1)
875 call x84(lunot,my_lunot,1)
876 call wrdxtb(my_lundx,my_lunot)
884 call status(lunot,lot,il,im)
885 if(il==0)
call bort(
'BUFRLIB: WRDXTB - OUTPUT BUFR FILE IS CLOSED, IT MUST BE OPEN FOR OUTPUT')
886 if(il<0)
call bort(
'BUFRLIB: WRDXTB - OUTPUT BUFR FILE IS OPEN FOR INPUT, IT MUST BE OPEN FOR OUTPUT')
888 call status(lundx,ldx,il,im)
889 if(il==0)
call bort(
'BUFRLIB: WRDXTB - DX TABLE FILE IS CLOSED, IT MUST BE OPEN')
893 if(lundx/=lunot)
call cpbfdx(ldx,lot)
945 nseq =
iupm(
tabd(i,lot)(ldd+1:ldd+1),8)
946 lend = ldd+1 + l30*nseq
976 mbit = (len0+len1+len2+4)*8
991 use modv_vars,
only: maxcd
997 integer,
intent(in) :: lun, mesg(*)
998 integer maxdx, idxv, nxstr, ldxa, ldxb, ldxd, ld30, ldxbd(10), ldxbe(10), ja, jb, idxs, i3, i, j, n, nd, ndd, idn, &
999 jbit, len0, len1, len2, len3, l4, l5, lda, ldb, ldd, ldbd, ldbe, l30, ia, la, ib, lb, id, ld, iret, &
1000 ifxy, iupb, iupbs01, igetntbi, idn30
1002 character*128 bort_str
1003 character*128 tabb1, tabb2
1009 character*6 numb, cidn
1011 common /dxtab/ maxdx, idxv, nxstr(10), ldxa(10), ldxb(10), ldxd(10), ld30(10), dxstr(10)
1013 data ldxbd /38, 70, 8*0/
1014 data ldxbe /42, 42, 8*0/
1017 ja(i) = ia+1+lda*(i-1)
1018 jb(i) = ib+1+ldb*(i-1)
1022 idxs = iupbs01(mesg,
'MSBT')+1
1023 if(idxs>idxv+1) idxs = iupbs01(mesg,
'MTVL')+1
1024 if(ldxa(idxs)==0 .or. ldxb(idxs)==0 .or. ldxd(idxs)==0)
call bort(
'BUFRLIB: STBFDX - UNEXPECTED DICTIONARY '// &
1025 'MESSAGE SUBTYPE OR LOCAL VERSION NUMBER (E.G., L.V.N. HIGHER THAN KNOWN)')
1027 call getlens(mesg,3,len0,len1,len2,len3,l4,l5)
1031 call upc(dxcmp,nxstr(idxs),mesg,jbit,.false.)
1032 if(dxcmp/=dxstr(idxs))
call bort(
'BUFRLIB: STBFDX - UNEXPECTED DICTIONARY MESSAGE CONTENTS')
1044 la = iupb(mesg,ia,8)
1046 lb = iupb(mesg,ib,8)
1048 ld = iupb(mesg,id,8)
1053 n = igetntbi(lun,
'A')
1055 call upc(
taba(n,lun),lda,mesg,jbit,.true.)
1056 numb =
' '//
taba(n,lun)(1:3)
1057 nemo =
taba(n,lun)(4:11)
1058 cseq =
taba(n,lun)(13:67)
1059 call stntbia(n,lun,numb,nemo,cseq)
1065 n = igetntbi(lun,
'B')
1067 call upc(tabb1,ldbd,mesg,jbit,.true.)
1068 jbit = 8*(jb(i)+ldbd-1)
1069 call upc(tabb2,ldbe,mesg,jbit,.true.)
1070 tabb(n,lun) = tabb1(1:ldxbd(idxv+1))//tabb2(1:ldxbe(idxv+1))
1071 numb =
tabb(n,lun)(1:6)
1072 nemo =
tabb(n,lun)(7:14)
1073 call nenubd(nemo,numb,lun)
1074 idnb(n,lun) = ifxy(numb)
1075 unit =
tabb(n,lun)(71:94)
1077 tabb(n,lun)(71:94) = unit
1084 n = igetntbi(lun,
'D')
1086 call upc(
tabd(n,lun),ldd,mesg,jbit,.true.)
1087 numb =
tabd(n,lun)(1:6)
1088 nemo =
tabd(n,lun)(7:14)
1089 call nenubd(nemo,numb,lun)
1090 idnd(n,lun) = ifxy(numb)
1091 nd = iupb(mesg,id+ldd+1,8)
1093 write(bort_str,
'("BUFRLIB: STBFDX - NUMBER OF DESCRIPTORS IN '// &
1094 'TABLE D ENTRY ",A," IN BUFR TABLE (",I4,") EXCEEDS THE LIMIT (",I4,")")') nemo,nd,maxcd
1098 ndd = id+ldd+2 + (j-1)*l30
1100 call upc(cidn,l30,mesg,jbit,.true.)
1101 idn = idn30(cidn,l30)
1102 call pktdd(n,lun,idn,iret)
1103 if(iret<0)
call bort(
'BUFRLIB: STBFDX - BAD RETURN FROM BUFRLIB ROUTINE PKTDD, SEE PREVIOUS WARNING MESSAGE')
1105 id = id+ldd+1 + nd*l30
1106 if(iupb(mesg,id+1,8)==0) id = id+1
1122 integer function idxmsg( mesg )
result( iret )
1126 integer,
intent(in) :: mesg(*)
1132 if ( (
iupbs01(mesg,
'MTYP')==11) .and. &
1158 integer,
intent(in) :: lun
1161 character,
intent(in) :: ctb
1162 character*128 bort_str
1164 if ( ctb ==
'A' )
then
1165 iret =
ntba(lun) + 1
1167 else if ( ctb ==
'B' )
then
1168 iret =
ntbb(lun) + 1
1171 iret =
ntbd(lun) + 1
1174 if ( iret > imax )
then
1175 write(bort_str,
'("BUFRLIB: IGETNTBI - NUMBER OF INTERNAL TABLE",A1," ENTRIES EXCEEDS THE LIMIT (",I4,")")') ctb, imax
1202 integer,
intent(in) :: lun
1203 integer,
intent(out) :: mtyp, msbt, inod
1206 character*(*),
intent(in) :: nemo
1207 character*128 bort_str
1214 if(
taba(i,lun)(4:11)==nemo)
then
1215 mtyp =
idna(i,lun,1)
1216 msbt =
idna(i,lun,2)
1218 if(mtyp<0 .or. mtyp>255)
then
1219 write(bort_str,
'("BUFRLIB: NEMTBAX - INVALID MESSAGE TYPE (",I4,") RETURNED FOR MENMONIC ",A)') mtyp, nemo
1222 if(msbt<0 .or. msbt>255)
then
1223 write(bort_str,
'("BUFRLIB: NEMTBAX - INVALID MESSAGE SUBTYPE (",I4,") RETURNED FOR MENMONIC ",A)') msbt, nemo
1250 integer,
intent(in) :: lun
1251 integer,
intent(out) :: mtyp, msbt, inod
1253 character*(*),
intent(in) :: nemo
1254 character*128 bort_str
1258 call nemtbax(lun,nemo,mtyp,msbt,inod)
1260 write(bort_str,
'("BUFRLIB: NEMTBA - CAN''T FIND MNEMONIC ",A)') nemo
1277 subroutine nemtbb(lun,itab,unit,iscl,iref,ibit)
1283 integer,
intent(in) :: lun, itab
1284 integer,
intent(out) :: iscl, iref, ibit
1287 character*128 bort_str
1288 character*24,
intent(out) :: unit
1291 if(itab<=0 .or. itab>
ntbb(lun))
then
1292 write(bort_str,
'("BUFRLIB: NEMTBB - ITAB (",I7,") NOT FOUND IN TABLE B")') itab
1298 idn =
idnb(itab,lun)
1299 nemo =
tabb(itab,lun)( 7:14)
1300 unit =
tabb(itab,lun)(71:94)
1301 call strnum(
tabb(itab,lun)( 95: 98),iscl,ierns)
1302 call strnum(
tabb(itab,lun)( 99:109),iref,ierns)
1303 call strnum(
tabb(itab,lun)(110:112),ibit,ierns)
1307 if(unit(1:5)/=
'CCITT' .and. ibit>32)
then
1308 write(bort_str,
'("BUFRLIB: NEMTBB - BIT WIDTH FOR NON-CHARACTER TABLE B MNEMONIC ",A," (",I7,") IS > 32")') nemo,ibit
1311 if(unit(1:5)==
'CCITT' .and. mod(ibit,8)/=0)
then
1312 write(bort_str,
'("BUFRLIB: NEMTBB - BIT WIDTH FOR CHARACTER TABLE B MNEMONIC ",A," (",I7,") IS NOT A MULTIPLE OF 8")') &
1345 subroutine nemtbd(lun,itab,nseq,nems,irps,knts)
1347 use modv_vars,
only: maxcd
1353 integer,
intent(in) :: lun, itab
1354 integer,
intent(out) :: nseq, irps(*), knts(*)
1355 integer i, j, ndsc, idsc, iret
1357 character*128 bort_str
1358 character*8,
intent(out) :: nems(*)
1359 character*8 nemo, nemt, nemf
1362 if(itab<=0 .or. itab>
ntbd(lun))
then
1363 write(bort_str,
'("BUFRLIB: NEMTBD - ITAB (",I7,") NOT FOUND IN TABLE D")') itab
1379 nemo =
tabd(itab,lun)(7:14)
1380 idsc =
idnd(itab,lun)
1381 call uptdd(itab,lun,0,ndsc)
1386 if(nseq+1>maxcd)
then
1387 write(bort_str,
'("BUFRLIB: NEMTBD - THERE ARE MORE THAN '// &
1388 '(",I4,") DESCRIPTORS (THE LIMIT) IN TABLE D SEQUENCE MNEMONIC ",A)') maxcd, nemo
1391 call uptdd(itab,lun,j,idsc)
1392 call numtab(lun,idsc,nemt,tab,iret)
1397 knts(nseq+1) = abs(iret)
1402 elseif(tab==
'F')
then
1405 elseif(tab==
'D'.or.tab==
'C')
then
1408 elseif(tab==
'B')
then
1410 if((nemt(1:1)==
'.').and.(j<ndsc))
then
1412 call uptdd(itab,lun,j+1,idsc)
1413 call numtab(lun,idsc,nemf,tab,iret)
1445 recursive subroutine nemdefs ( lunit, nemo, celem, cunit, iret )
1447 use modv_vars,
only: im8b
1453 integer,
intent(in) :: lunit
1454 integer,
intent(out) :: iret
1455 integer my_lunit, lun, il, im, idn, iloc, ls
1457 character*(*),
intent(in) :: nemo
1458 character*(*),
intent(out) :: celem, cunit
1465 call x84 ( lunit, my_lunit, 1 )
1466 call nemdefs ( my_lunit, nemo, celem, cunit, iret )
1467 call x48 ( iret, iret, 1 )
1476 call status( lunit, lun, il, im )
1477 if ( il == 0 )
return
1481 call nemtab( lun, nemo, idn, tab, iloc )
1482 if ( ( iloc == 0 ) .or. ( tab /=
'B' ) )
return
1487 ls = min(len(celem),55)
1488 celem(1:ls) =
tabb(iloc,lun)(16:15+ls)
1491 ls = min(len(cunit),24)
1492 cunit(1:ls) =
tabb(iloc,lun)(71:70+ls)
1519 character,
intent(in) :: nemo*8, numb*6
1520 character*128 bort_str
1522 integer,
intent(in) :: lun
1526 if(numb==
tabb(n,lun)(1:6))
then
1527 write(bort_str,
'("BUFRLIB: NENUBD - TABLE B FXY VALUE (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') numb
1530 if(nemo==
tabb(n,lun)(7:14))
then
1531 write(bort_str,
'("BUFRLIB: NENUBD - TABLE B MNEMONIC (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') nemo
1537 if(numb==
tabd(n,lun)(1:6))
then
1538 write(bort_str,
'("BUFRLIB: NENUBD - TABLE D FXY VALUE (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') numb
1541 if(nemo==
tabd(n,lun)(7:14))
then
1542 write(bort_str,
'("BUFRLIB: NENUBD - TABLE D MNEMONIC (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') nemo
1565 integer,
intent(in) :: n, lun
1566 integer i, mtyp, msbt
1568 character*(*),
intent(in) :: numb, nemo, celsq
1569 character*128 bort_str
1574 if(numb(4:6)==
taba(i,lun)(1:3))
then
1575 write(bort_str,
'("BUFRLIB: STNTBIA - TABLE A FXY VALUE (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') numb
1578 if(nemo(1:8)==
taba(i,lun)(4:11))
then
1579 write(bort_str,
'("BUFRLIB: STNTBIA - TABLE A MNEMONIC (",A,") HAS ALREADY BEEN DEFINED (DUPLICATE)")') nemo
1586 taba(n,lun)(1:3) = numb(4:6)
1587 taba(n,lun)(4:11) = nemo(1:8)
1588 taba(n,lun)(13:67) = celsq(1:55)
1592 if ( verify( nemo(3:8),
'1234567890' ) == 0 )
then
1594 read ( nemo,
'(2X,2I3)') mtyp, msbt
1595 idna(n,lun,1) = mtyp
1596 idna(n,lun,2) = msbt
1599 read ( numb(4:6),
'(I3)')
idna(n,lun,1)
1620 subroutine stntbi ( n, lun, numb, nemo, celsq )
1626 integer,
intent(in) :: n, lun
1629 character*(*),
intent(in) :: numb, nemo, celsq
1631 call nenubd ( nemo, numb, lun )
1633 if ( numb(1:1) ==
'0')
then
1634 idnb(n,lun) = ifxy(numb)
1635 tabb(n,lun)(1:6) = numb(1:6)
1636 tabb(n,lun)(7:14) = nemo(1:8)
1637 tabb(n,lun)(16:70) = celsq(1:55)
1640 idnd(n,lun) = ifxy(numb)
1641 tabd(n,lun)(1:6) = numb(1:6)
1642 tabd(n,lun)(7:14) = nemo(1:8)
1643 tabd(n,lun)(16:70) = celsq(1:55)
1667 use modv_vars,
only: maxcd
1673 integer,
intent(in) :: id, lun, idn
1674 integer,
intent(out) :: iret
1675 integer maxdx, idxv, nxstr, ldxa, ldxb, ldxd, ld30, iprt, ldd, nd, idm, iupm
1677 character*128 errstr
1680 common /dxtab/ maxdx, idxv, nxstr(10), ldxa(10), ldxb(10), ldxd(10), ld30(10), dxstr(10)
1685 ldd = ldxd(idxv+1)+1
1689 call ipkm(
tabd(id,lun)(ldd:ldd),1,0)
1696 nd = iupm(
tabd(id,lun)(ldd:ldd),8)
1698 if(nd<0 .or. nd==maxcd)
then
1700 call errwrt(
'+++++++++++++++++++++WARNING+++++++++++++++++++++++')
1702 write ( unit=errstr, fmt=
'(A,I4,A)' )
'BUFRLIB: PKTDD - BAD COUNTER VALUE (=', nd,
') - RETURN WITH IRET = -1'
1704 write ( unit=errstr, fmt=
'(A,I4,A,A)' )
'BUFRLIB: PKTDD - MAXIMUM NUMBER OF CHILD MNEMONICS (=', &
1705 maxcd,
') ALREADY STORED FOR THIS PARENT - RETURN WITH IRET = -1'
1708 call errwrt(
'+++++++++++++++++++++WARNING+++++++++++++++++++++++')
1715 call ipkm(
tabd(id,lun)(ldd:ldd),1,nd)
1721 idm = ldd+1 + (nd-1)*2
1722 call ipkm(
tabd(id,lun)(idm:idm),2,idn)
1725 end subroutine pktdd
1746 integer,
intent(in) :: id, lun, ient
1747 integer,
intent(out) :: iret
1748 integer maxdx, idxv, nxstr, ldxa, ldxb, ldxd, ld30, ldd, ndsc, idsc, iupm
1750 character*128 bort_str
1753 common /dxtab/ maxdx, idxv, nxstr(10), ldxa(10), ldxb(10), ldxd(10), ld30(10), dxstr(10)
1757 ldd = ldxd(idxv+1)+1
1758 ndsc = iupm(
tabd(id,lun)(ldd:ldd),8)
1762 elseif(ient<0 .or. ient>ndsc)
then
1763 write(bort_str,
'("BUFRLIB: UPTDD - VALUE OF THIRD ARGUMENT IENT (INPUT) IS OUT OF RANGE (IENT =",I4,")")') ient
1769 idsc = ldd+1 + (ient-1)*2
1770 iret = iupm(
tabd(id,lun)(idsc:idsc),16)
1773 end subroutine uptdd
1798 character*8,
intent(inout) :: nem1
1799 character*8,
intent(in) :: nem2
1808 if(nem1(i:i)==
'.')
then
1809 nem1(i:i) = nem2(j:j)
subroutine bort(str)
Log an error message, then abort the application program.
subroutine bort2(str1, str2)
Log two error messages, then abort the application program.
recursive integer function iupb(mbay, nbyt, nbit)
Decode an integer value from within a specified number of bits of an integer array,...
recursive integer function iupm(cbay, nbits)
Decode an integer value from within a specified number of bits of a character string,...
subroutine upc(chr, nchr, ibay, ibit, cnvnull)
Decode a character string from within a specified number of bytes of an integer array,...
subroutine pkc(chr, nchr, ibay, ibit)
Encode a character string within a specified number of bytes of an integer array, starting at the bit...
recursive subroutine ipkm(cbay, nbyt, n)
Encode an integer value within a specified number of bytes of a character string, up to a maximum of ...
subroutine pkb(nval, nbits, ibay, ibit)
Encode an integer value within a specified number of bits of an integer array, starting at the bit im...
subroutine cpbfdx(lud, lun)
Copy all of the DX BUFR table information from one unit to another within internal memory.
subroutine elemdx(card, lun)
Decode the scale factor, reference value, bit width and units (i.e., the "elements") from a Table B m...
subroutine nemtbb(lun, itab, unit, iscl, iref, ibit)
Get information about a Table B descriptor from the internal DX BUFR tables.
subroutine dxmini(mbay, mbyt, mb4, mba, mbb, mbd)
Initialize a DX BUFR tables (dictionary) message, writing all the preliminary information into Sectio...
subroutine nemtba(lun, nemo, mtyp, msbt, inod)
Get information about a Table A descriptor from the internal DX BUFR tables.
subroutine rdusdx(lundx, lun)
Read and parse a file containing a user-supplied DX BUFR table in character format,...
subroutine rsvfvm(nem1, nem2)
Process a "following value" mnemonic.
subroutine seqsdx(card, lun)
Decode the Table D sequence information from a mnemonic definition card that was previously read from...
recursive subroutine wrdxtb(lundx, lunot)
Generate one or more BUFR messages from the DX BUFR tables information associated with a given BUFR f...
subroutine nemtbax(lun, nemo, mtyp, msbt, inod)
Get information about a Table A descriptor from the internal DX BUFR tables.
subroutine nemtbd(lun, itab, nseq, nems, irps, knts)
Get information about a Table D descriptor from the internal DX BUFR tables.
subroutine stntbi(n, lun, numb, nemo, celsq)
Store a new entry within internal BUFR Table B or D.
subroutine pktdd(id, lun, idn, iret)
Store information about a child mnemonic within the internal BUFR Table D.
subroutine stntbia(n, lun, numb, nemo, celsq)
Store a new entry within internal BUFR Table A.
subroutine stbfdx(lun, mesg)
Copy a DX BUFR tables message into the internal memory arrays in module moda_tababd.
subroutine writdx(lunit, lun, lundx)
Write DX BUFR table (dictionary) messages to the beginning of an output BUFR file in lunit.
recursive subroutine nemdefs(lunit, nemo, celem, cunit, iret)
Get the element name and units associated with a Table B descriptor.
integer function igetntbi(lun, ctb)
Get the next available index for storing an entry within a specified internal DX BUFR table.
subroutine readdx(lunit, lun, lundx)
Initialize modules moda_tababd and moda_msgcwd with DX BUFR (dictionary) tables.
subroutine dxinit(lun, ioi)
Clear out the internal arrays (in module moda_tababd) holding the DX BUFR table, then optionally init...
subroutine nenubd(nemo, numb, lun)
Confirm that a mnemonic and FXY value haven't already been defined.
integer function idxmsg(mesg)
Check whether a BUFR message contains DX BUFR tables information that was generated by the NCEPLIBS-b...
subroutine uptdd(id, lun, ient, iret)
Get the WMO bit-wise representation of the FXY value corresponding to a child mnemonic in a Table D s...
subroutine rdbfdx(lunit, lun)
Beginning at the current file pointer location within lunit, read a complete DX BUFR table into inter...
subroutine errwrt(str)
Specify a custom location for the logging of error and diagnostic messages generated by the NCEPLIBS-...
subroutine nemtab(lun, nemo, idn, tab, iret)
Get information about a descriptor, based on a mnemonic.
subroutine numtab(lun, idn, nemo, tab, iret)
Get information about a descriptor, based on the WMO bit-wise representation of an FXY value.
character *(*) function adn30(idn, ldn)
Convert an FXY value from its WMO bit-wise representation to a character string of length 5 or 6.
subroutine makestab
Build the entire internal jump/link table within module moda_tables, using all of the internal BUFR t...
subroutine jstnum(str, sign, iret)
Left-justify a character string containing an encoded integer, by removing all leading blanks and any...
recursive subroutine strnum(str, num, iret)
Decode an integer from a character string.
subroutine capit(str)
Capitalize all of the alphabetic characters in a string.
Wrap C NCEPLIBS-bufr functions so they can be called from within the Fortran part of the library.
Declare an array used by various subroutines and functions to hold a temporary working copy of a BUFR...
integer, dimension(:), allocatable mgwa
Temporary working copy of BUFR message.
Declare arrays and variables used to store DX BUFR tables internally for multiple file IDs.
integer, dimension(:), allocatable ntba
Number of Table A entries for each file ID (up to a maximum of maxtba, whose value is stored in array...
character *600, dimension(:,:), allocatable tabd
Table D entries for each file ID.
character *128, dimension(:,:), allocatable taba
Table A entries for each file ID.
integer, dimension(:,:), allocatable mtab
Entries within jump/link table corresponding to taba.
integer, dimension(:,:,:), allocatable idna
Message types (in array element 1) and subtypes (in array element 2) corresponding to taba.
integer, dimension(:), allocatable ntbd
Number of Table D entries for each file ID (up to a maximum of maxtbd, whose value is stored in array...
integer, dimension(:), allocatable ntbb
Number of Table B entries for each file ID (up to a maximum of maxtbb, whose value is stored in array...
integer, dimension(:,:), allocatable idnd
WMO bit-wise representations of the FXY values corresponding to tabd.
integer, dimension(:,:), allocatable idnb
WMO bit-wise representations of the FXY values corresponding to tabb.
character *128, dimension(:,:), allocatable tabb
Table B entries for each file ID.
recursive subroutine status(lunit, lun, il, im)
Check whether a specified Fortran logical unit number is currently connected to the NCEPLIBS-bufr sof...
logical function msgfull(msiz, itoadd, mxsiz)
Check whether the current data subset in the internal arrays will fit within the current BUFR message...
recursive subroutine getlens(mbay, ll, len0, len1, len2, len3, len4, len5)
Read the section lengths of a BUFR message, up to a specified point in the message.
subroutine rdmsgw(lunit, mesg, iret)
Read the next BUFR message from logical unit lunit as an array of integer words.
subroutine msgwrt(lunit, mesg, mgbyt)
Perform final checks and updates on a BUFR message before writing it to a specified Fortran logical u...
recursive integer function iupbs01(mbay, s01mnem)
Read a specified value from within Section 0 or Section 1 of a BUFR message.
subroutine parstr(str, tags, mtag, ntag, sep, limit80)
Parse a string containing one or more substrings into an array of substrings.
subroutine x48(iin4, iout8, nval)
Encode one or more 4-byte integer values as 8-byte integer values.
subroutine x84(iin8, iout4, nval)
Encode one or more 8-byte integer values as 4-byte integer values.