WPCV% 2B[ Z Courier 12cpi 12cpi (M)!|destige Elite 12cpi (D)Prestige Elite 12cpi Bold (D)HP LaserJet IIIHPLASIII.PRSd6X@8;,\,y@!|d2'MvpkCourier 12cpiPrestige Elite 12cpi (D)LASIII.PRSd6X@8;,\,Bj@a8DocumentgDocument Style StyleXX` `  ` a4DocumentgDocument Style Style . a6DocumentgDocument Style Style GX  2$k*v:ta5DocumentgDocument Style Style }X(# a2DocumentgDocument Style Style<o   ?  A.  a7DocumentgDocument Style StyleyXX` ` (#` BibliogrphyBibliography:X (# 2V   :a1Right ParRight-Aligned Paragraph Numbers:`S@ I.  X(# a2Right ParRight-Aligned Paragraph Numbers C @` A. ` ` (#` a3DocumentgDocument Style Style B b  ?  1.  a3Right ParRight-Aligned Paragraph Numbers L! ` ` @P 1. ` `  (# 2$   T a4Right ParRight-Aligned Paragraph Numbers Uj` `  @ a. ` (# a5Right ParRight-Aligned Paragraph Numbers _o` `  @h(1)  hh#(#h a6Right ParRight-Aligned Paragraph Numbersh` `  hh#@$(a) hh#((# a7Right ParRight-Aligned Paragraph NumberspfJ` `  hh#(@*i) (h-(# 2&V / + &a8Right ParRight-Aligned Paragraph NumbersyW"3!` `  hh#(-@p/a) -pp2(#p a1DocumentgDocument Style StyleXqq   l ^) I. ׃  Doc InitInitialize Document Style  0*0*  I. A. 1. a.(1)(a) i) a) I. 1. A. a.(1)(a) i) a)DocumentgTech InitInitialize Technical Style. k I. A. 1. a.(1)(a) i) a) 1 .1 .1 .1 .1 .1 .1 .1 Technical2Xfa5TechnicalTechnical Document Style)WD (1) . a6TechnicalTechnical Document Style)D (a) . a2TechnicalTechnical Document Style<6  ?  A.   a3TechnicalTechnical Document Style9Wg  2  1.   2aUa4TechnicalTechnical Document Style8bv{ 2  a.   a1TechnicalTechnical Document StyleF!<  ?  I.   a7TechnicalTechnical Document Style(@D i) . a8TechnicalTechnical Document Style(D a) . 2E XeAPleadingHeader for numbered pleading paperP@n   $] X X` hp x (#%'0*,.8135@8:pQ@uSddd,'dp,`QtTddd,EdphQQHMH `MV/VCT1[J[J`MeM`M,CC,,,/N```CTT,EJJTTT66T44CCT4,,CCT11TTRReCC`C[{{QQK,CC4"``C`F``C充C,,`O``````````x,CcTJT`cC,T`CTM`hV``````````H``````oYQh`9O```````C```````;````;```````````````````````````````````````````,```,```,```,`````````````cJTHJCcHM>Q9`MeH% YCcEyJ`JT9eM`MOHOO;T>[Hm^`@j[ceJ>M MHHeHJe[[,,TTTTTTTJJJJJJJJJJJJJJJJJJJ>>>>>>>MMMMMMMMMMMMMMMMMMMM MMMMMMMHHHHHHHHHHHHeeeeeeeeeeeeeeeeeeee,McM`%e[cC;,Courier 12cpiPrestige Elite 12cpi (D)Prestige Elite 12cpi Bold (D)Prestige Elite 12cpi Italic (D)Wmdp@>pQ@uSddd,'dp,`QtTddd,EdphQQHdd!T,,,eQTxP7Ped!T,,,xxTp?7s4ddd,d6X@J'@Courier 12cpiPrestige Elite 12cpi (D)Prestige Elite 12cpi Bold (D)Prestige Elite 12cpi Italic (D)Univers (Scalable)Univers Bold (Scalable)Line Draw 12cpi (Full-Cr)2"%w P3tS"m'^,,ETTe,,,T,,,,TTTTTTTTTT,,EcT^`MJc`%JYHy`eOhVVT```[Q,,,CC,HMHMH1MM H tMMMM/C1MJtJJ@CCC,TTTTT,,,,TTTTTTCTQ cHcHcHcHcHr^HMHMHMHMH% % % % `MeMeMeMeM`M`M`M`M[JcH`MeMeM[J`MOMcHcHcH^H^H^H^H`MMHMHMHMHcMcMcMcMcMcM`M`M% % % % o@JYHH H H H4H%`M```M`MeMeMyV/V/V/VCVCVCVCT1T1T1`M`M`M`M`M`Mt[JQ@Q@Q@`MH `MV/VCT1[J[J`MeM`M,CC,,,/N```CTT,EJJTTT66T44CCT4,,CCT11TTRReCC`C[{{QQK,CC4"``C`J``C充C,,`Q``````````x,CcTOTmc@,T`JTM`h[``````````C``````tYQh`9O```````C```````C````C```````````````````````````````````````````,```,```,```,`````````````cMTOJCcMMCQ>`MeQ%#YCcCyO`J`@eMmQOMQV>T>[O{``J{`mhMCM##MOOhMVh[`,,TTTTTTTMMMMMMMMMMMMMMMMMMMCCCCCCCMMMMMMMMMMMMMMMMMMMM############MMMMMMMOOOOOOOOOOOOhhhhhhhhhhhhhhhhhhhh,QcM`%e[mC;,2T%#dp@>pQWm@#X` hp x (#%'0*,.8135@8:pQWm@#Programmers Reference Manual for FIPS PUB 123 Function Library Appendix E: FIPS PUB 123 Function Library Sample Programs    tT 3/93` `  $hh*06pp<B  HxxN T EՊ .Appendix E " FIPS PUB 123 Function Library Sample Programs  0*$$  tT E.` ` FIPS PUB 123 FUNCTION LIBRARY SAMPLE PROGRAMS(#` ` ` This appendix provides the information necessary to install, compile, link, and execute the four sample programs (sam_prg2, samprg2b, sam_prg3, and samprg3b) provided with the FIPS PUB 123 Function Library.(#`  tT4 E.1` ` INSTALLATION/EXECUTION PROCEDURES(#`  tT E.1.1` ` MSDOS(#` ` ` During the installation of the FIPS PUB 123 Function Library, the  uT sample programs were copied to fips123\f123app or a userspecified directory. If it is necessary to reinstall these programs, you may do so by loading the FIPS PUB 123 diskette and entering the command(#`  uT ` `  <drive> :load123 é d <f123dir> f123app/*.* (#  tT ` ` where <drive> is the appropriate input device drive and <f123dir> is the directory path.(#`  uT ` ` Compile and link the sample programs using the cl and link commands, respectively, as described for compiling and linking an application program in paragraph 2.1.3.(#` ` ` The sample programs are interactive and are invoked by typing the name of the executable for the individual sample programs. Enter the desired filenames when prompted by the sample programs.(#` +#0*$$Ԍ tT E.1.2` ` UNIX(#` ` ` During the installation of the FIPS PUB 123 Function Library, the  uT sample programs were copied to fips123/f123app or a userspecified directory. If it is necessary to reinstall these programs, you may do so by loading the FIPS PUB 123 Function Library diskette or tape and entering the following:(#`  uTa ` `   cd <f123dir>(#  uT ` `   tar é xvo<#> f123app(#  tT ` ` where <f123dir> is the directory path and <#> is the appropriate input device number.(#` ` ` Compile and link the sample programs using a makefile, as described for compiling and linking an application program in paragraph 2.2.3.(#` ` ` The sample programs are interactive and are invoked by typing the name of the executable for the individual sample programs. Enter the desired filenames when prompted by the sample programs.(#`  tT E.1.3` ` MVS ` ` To be provided at a later date. #0*$$  tT E.2` ` SAMPLE PROGRAMS(#` ` ` The sample programs provided are complete, real programs, developed to exercise the functionality of the FIPS PUB 123 Function Library. The programs were written in ANSI standard C.(#` ` ` Input to the sample programs are data descriptive files (DDFs) conforming to the FIPS PUB 123 standard. Output from the sample programs are either an output DDF conforming to the FIPS PUB 123 or an output report file containing annotated record data. The FIPS PUB 123 output DDF may differ slightly from the input DDF but the data will be preserved. The annotated record data in an output report file identify records, fields, and subfields of the data descriptive record (DDR) and data records (DRs) read from the input file. The report file may include retrieved data descriptions of records, fields, and subfields.(#` ` ` The names of the input, output, and report files for the sample programs must be entered by the user at the appropriate prompts.(#` ` ` The following paragraphs provide details regarding the sample programs and their operation.(#`  tT E.2.1` ` Sample Program 2 (SAM_PRG2)(#` ` ` Sample Program 2 (SAM_PRG2) executes the intermediate level functions to read and write the individual fields of a DDR and DRs. Additional processing shows how a DDR field can be erased by subfields and how an application can backup by DR fields. The functions exercised are:(#` (#0*$$Ԍ tT ` `  o$ bak123fld()0    tT, ` `  o$ beg123file()    tT ` `  o$ beg123rec()0 6   tT  ` `  o$ end123ddrec()    tTL ` `  o$ end123file() 6   tTx ` `  o$ end123rec()   tT ` `  o$ er123ddsfld()   tT ` `  o$ rd123ddfld()   tT! ` `  o$ rd123fld() (#0*$$Ԍ tT ` `  o$ wr123ddfld()   tT, ` `  o$ wr123fld() .  tT E.2.1.1` ` Input(#` ` ` Sample Program 2 requires an input file conforming to FIPS PUB 123.(#`  tT4 E.2.1.2` ` Output(#` ` ` Sample Program 2 produces a DDF conforming to FIPS PUB 123. No output report file is created. Error messages are written to the standard output device (monitor). Refer to paragraph E.3 for error message handling.(#`  tTh E.2.1.3` ` Source Code ` ` Section E.4.1 contains a complete source code listing for Sample Program 2.(#`  tTD E.2.2` ` Sample Program 2B (SAMPRG2B) ` ` Sample Program 2B (SAMPRG2B) executes the intermediate level functions to retrieve the data descriptions of the last DR and DR field read or written. The data descriptions consist of the labeled and formatted record and field information based upon the DDR. The functions exercised are:(#`  tT ` `  oX$ bak123rec()  6pp<(#  tT ` `  o$ end123file() (#  uT! ` ` X oX$ chk123fld() (#  tT)# ` `  o` $ chk123rec() (#)#0*$$Ԍ tT ` ` X oX$ end123ddrec() (#  tT, ` `  o` $ end123file() (#  tTX ` `  o` $ rd123ddrec() (#  tT ` `  o` $ rd123fld() (#  tT ` `  o` $ wr123ddrec() (#  tT ` `  o` $ wr123fld() (#  tT ` `  o` $ wr123rec() . (#  tT` E.2.2.1` ` Input(#` ` ` Sample Program 2B requires an input DDF conforming to FIPS PUB 123.(#`  tT E.2.2.2` ` Output(#` ` ` Sample Program 2B produces a DDF conforming to FIPS PUB 123 and an output report file. The report file contains the annotated DDR, the DRs, and the data descriptions for each record read and written. Data descriptions for the DR fields of every 23rd DR are included. Error messages are written to the standard output device (monitor). Refer to paragraph E.3 for error message handling. See figure E1 for an example of the report file generated by sample program 2B.(#` q ! xx)<dd'mxx*a'mp  tT #dp@>pQWm@# !Figure E1 Sample Program 2B Report. #TxP7QP#X` hp x (#%'0*,.8135@8:pQWm@# Figure E1Continued Sample 2B Report.#TxP7QP# X, X` hp x (#%'0*,.8135@8:pQWm@# Figure E1Continued Sample 2B Report.#TxP7QP#X` hp x (#%'0*,.8135@8:pQWm@# !Figure E2 Sample Program 3B Report. #TxP7QP# X,   dB * DDR = ( Note: Data Descriptive Record is normally located here but was removed due to its size.) ************ START OF RECORD * DR = 00172 D 00051 45040001000600000CATS01150000600001CSIDIDENGLEN ELLEN GLEN ELLEN BOUNDARIES (24,25)  * RECORD DESCRIPTION = 0100;&DDF RECORD IDENTIFIER2600;&CATALOG/SPATIAL DOMAIN*MODN!NAME!TYPE!DOMN!MAP !THEM!COMT(7A) * RECORD LENGTH = 172 * LEADER IDENTIFIER = D ************ START OF RECORD * DR = 00148 D 00077 45040001000600000PNTS000800006SADR002600014LNID00310004000008N0PN7 541771.07 4247326.13L1LE4EL1LE5SL1LE19E * RECORD DESCRIPTION = 0100;&DDF RECORD IDENTIFIER1600;&POINT-NODEMODN!OBRP!OBID(2A,I)2600;&Spatial Address*Easting!Northing(R)2600;&foreign id*MODN!OBRP!OBID!USAG(2A,I,A) * RECORD LENGTH = 148 * LEADER IDENTIFIER = D * NEXT RECORD DESCRIPTION = 0100;&DDF RECORD IDENTIFIER1600;&POINT-NODEMODN!OBRP!OBID(2A,I)2600;&Spatial Address*Easting!Northing(R)2600;&foreign id*MODN!OBRP!OBID!USAG(2A,I,A) * NEXT RECORD LENGTH = 148 * NEXT LEADER IDENTIFIER = D ****** START OF FIELD * DR FIELD = 00008 * FIELD TAG = 0001 * FIELD LENGTH = 6 * FIELD NAME = DDF RECORD IDENTIFIER * FIELD CONTROL = 0100;& * FIELD LABELS = * FIELD FORMATS = K0 n!xJ</dd'mx0**'mk#dp@>pQWm@# Figure E2Continued Sample Program 3B Report. #TxP7QP# X,  * NEXT FIELD TAG = PNTS * NEXT FIELD LENGTH = 8 * NEXT FIELD NAME = POINT-NODE * NEXT FIELD CONTROL = 1600;& * NEXT FIELD LABELS = MODN!OBRP!OBID * NEXT FIELD FORMATS = (2A,I) *** START OF SUBFIELDS * DR SUBFIELD = 00008 * SUBFIELD TAG = 0001 * SUBFIELD DESCRIPTION = * SUBFIELD FORMAT = * NEXT SUBFIELD TAG = PNTS * NEXT SUBFIELD DESCR. = MODN * NEXT SUBFIELD FORMAT = A ****** START OF FIELD * DR FIELD = N0PN7 * FIELD TAG = PNTS * FIELD LENGTH = 8 * FIELD NAME = POINT-NODE * FIELD CONTROL = 1600;& * FIELD LABELS = MODN!OBRP!OBID * FIELD FORMATS = (2A,I) * NEXT FIELD TAG = SADR * NEXT FIELD LENGTH = 26 * NEXT FIELD NAME = Spatial Address * NEXT FIELD CONTROL = 2600;& * NEXT FIELD LABELS = *Easting!Northing * NEXT FIELD FORMATS = (R) *** START OF SUBFIELDS * DR SUBFIELD = N0 * SUBFIELD TAG = PNTS * SUBFIELD DESCRIPTION = MODN * SUBFIELD FORMAT = A * NEXT SUBFIELD TAG = PNTS * NEXT SUBFIELD DESCR. = OBRP * NEXT SUBFIELD FORMAT = A 0D n!xJ<dd'mx0**'mk#dp@>pQWm@# Figure E2Continued Sample Program 3B Report.  X, X` hp x (#%'0*,.8135@8:pQWm@#` (#HSAM_PRG2.C EXE.4.1` ` Sample Program 2 (SAM_PRG2.C) Source Code#d6X@J'@#(#`  ***************************************************************************** ** ** INVOCATION NAME: SAM123PRG2 ** ** PURPOSE: TO EXECUTE INTERMEDIATE LEVEL ROUTINES OF THE SDTS ACCESS ** SOFTWARE TASK: ** ** RD123DDFLD ** WR123DDFLD ** BEG123REC ** RD123FLD ** WR123FLD ** BAK123FLD ** ** NOTE: AFTER PROGRAM EXECUTION, THE INPUT AND OUTPUT FILES SHOULD ** BE VISUALLY INSPECTED. THE OUTPUT FILE WILL DIFFER SLIGHTLY ** BUT THE INFORMATION WILL BE PRESERVED. ** ** INVOCATION METHOD: SAM_PRG2 ** ** ARGUMENT LIST: NONE ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** BAK123FLD() BACKS UP TO BEGINNING OF LAST FIELD READ OR WRITTEN ** BEG123FILE() OPENS A DATA FILE AND BEGIN ANY NECESSARY OVERHEAD ** BEG123REC() BEGINS A DATA RECORD ** END123DDREC() ENDS A DATA DESCRIPTIVE RECORD ** END123FILE() CLOSES A DATA FILE ** END123REC() ENDS A DATA RECORD ** ER123DDSFLD() ERASES A SUBFIELD FROM A DATA DESCRIPTIVE RECORD ** RD123DDFLD() READS THE NEXT DATA DESCRIPTIVE FIELD ** RD123FLD() READS THE NEXT FIELD ** WR123DDFLD() WRITES THE NEXT DATA DESCRIPTIVE FIELD ** WR123FLD() WRITES THE NEXT FIELD ** ** INTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** CLOS_FILS() CLOSES BOTH OF THE INPUT AND OUTPUT FILES ** ** INTERNAL VARIABLES: ** NAME TYPE DESCRIPTION ** BAK_DR INT DESIGNATED DR NUMBER TO BE PROCESSED ** PRIOR TO BACKING UP BY FIELDS ** BK_STAT INT BACK UP STATUS INDICATOR ** 0 = FAILURE ** 1 = OKAY ** 2 = START OF RECORD ** 3 = END OF RECORD ** 4 = END OF FILE ** 5 = END OF FIELD ** 6 = START OF FIELD#0*$$Ԍ** BYTLEN INT NUMBER OF BYTES IN CHARACTER STRING ** CCS[4] CHAR CODE CHARACTER SET INDICATOR ** DRS INT DATA RECORDS COUNTER ** ER_STAT INT ERASURE STATUS INDICATOR (SAME VALUE ** RANGE AS BACK UP STATUS) ** FNIN[100] CHAR FILE NAME OF INPUT FILE ** FPIN PTR FILE POINTER TO READ FILE ** FNOUT[100] CHAR FILE NAME OF OUTPUT FILE ** FPOUT PTR FILE POINTER TO WRITE FILE ** I INT LOOP CONTROL VARIABLE ** ICE CHAR IN-LINE CODE EXTENSION INDICATOR ** INT_LEVEL INT INTERCHANGE LEVEL ** LEADID CHAR LEADER IDENTIFIER ** OPTION INT WRITE OPTION INDICATOR (SAME VALUE RANGE ** AS BACK UP STATUS) ** PRV_STAT INT PREVIOUS READ STATUS INDICATOR (SAME ** VALUE RANGE AS BACK UP STATUS) ** STATUS INT READ STATUS INDICATOR (SAME VALUE RANGE ** AS BACK UP STATUS) ** TAG[10] CHAR INTERNAL NAME OF AN ASSOCIATED FIELD ** ** GLOBAL REFERENCES: NONE ** ** GLOBAL VARIABLES: ** NAME TYPE USE DESCRIPTION ** CSTRNG[5000] CHAR I/O GLOBAL CHARACTER STRING USED FOR ** PROCESSING ** ** GLOBAL CONSTANTS: ** NAME TYPE DESCRIPTION ** BAKFIT INT NUMBER OF ITERATIONS OF FUNCTION ** BAK123FLD() ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** P. HODGES 05/24/90 INITIAL PROLOG ** P. HODGES 05/24/90 INITIAL PDL ** P. HODGES 06/12/90 INITIAL CODE ** L. MCMILLION 01/25/91 MODIFIED CODE TO REFLECT CHANGES IN ** FUNCTIONS SINCE INITIAL DESIGN OF ** TEST PROGRAM ** J. TAYLOR 92DR005 06/02/92 CHANGED CALLING SEQUENCES OF BINARY ** HANDLING FUNCTIONS ** J. TAYLOR TASK 40 10/22/92 MODIFIED TO BACK UP READ AND WRITE ** FILES TO THE SAME SPOT ** ** PDL: ** ** INITIALIZE PREVIOUS READ STATUS TO END OF RECORD ** INITIALIZE READ STATUS TO OUT OF BOUNDS ** INITIALIZE DESIGNATED DR NUMBER TO BE PROCESSED BEFORE BACKING UP ** INITIALIZE DR COUNTER TO ZERO ** PROMPT USER FOR INPUT FILE NAME ** CALL BEG123FILE() FOR INPUT FILE { READ } ** IF BEG123FILE() FAILED ** THEN#0*$$Ԍ** PRINT ERROR MESSAGE ** ENDIF ** PROMPT USER FOR OUTPUT FILE NAME ** CALL BEG123FILE() FOR OUTPUT FILE { WRITE } ** IF BEG123FILE() FAILED ** THEN ** CALL END123FILE() TO CLOSE INPUT FILE ** ENDIF ** ** WHILE LAST DATA DESCRIPTIVE FIELD OF RECORD NOT INDICATED AND ** NOT EOF DO ** CALL RD123DDFLD() FOR INPUT FILE ** IF RD123DDFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES ** ENDIF ** IF PREVIOUS READ STATUS INDICATES END OF RECORD ** THEN ** SET WRITE OPTION TO START OF RECORD ** ELSE IF READ STATUS IS END OF FIELD ** THEN ** SET WRITE OPTION TO START OF FIELD ** ELSE ** SET WRITE OPTION TO READ STATUS ** ENDIF ** SET PREVIOUS READ STATUS TO READ STATUS ** CALL WR123DDFLD() FOR OUTPUT FILE ** IF WR123DDFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** INITIALIZE ERASURE STATUS TO OUT OF BOUNDS ** WHILE BEGINNING OF DDR FIELD NOT ERASED ** CALL ER123DDSFLD() TO ERASE DDR SUBFIELD ** IF ER123DDSFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ENDWHILE ** CALL WR123DDFLD() TO REWRITE DDR FIELD FOR OUTPUT FILE ** IF WR123DDFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ENDWHILE ** CALL END123DDREC() FOR OUTPUT FILE ** IF END123DDREC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ** REINITIALIZE READ STATUS TO OUT OF BOUNDS ** WHILE EOF NOT INDICATED FOR INPUT FILE DO ** INCREMENT DR COUNTER ** RESET READ STATUS TO OUT OF BOUNDS ** CALL BEG123REC() FOR OUTPUT FILE#0*$$Ԍ** IF BEG123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** INITIALIZE PREVIOUS READ STATUS TO END OF RECORD ** WHILE END OF RECORD NOT INDICATED FOR INPUT FILE AND NOT EOF DO ** CALL RD123FLD() FOR INPUT FILE ** IF RD123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** IF PREVIOUS READ STATUS IS END OF RECORD ** THEN ** SET WRITE OPTION TO START OF RECORD ** ELSE ** SET WRITE OPTION TO READ STATUS ** ENDIF ** SET PREVIOUS READ STATUS TO READ STATUS ** CALL WR123FLD() FOR OUTPUT FILE ** IF WR123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** IF DESIGNATED DR FOR BACKING UP BY FIELDS WAS PROCESSED OR ** END OF FILE WAS REACHED AND HAVE NOT BACKED UP ** THEN ** CALL END123REC() FOR OUTPUT FILE ** IF END123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ** FOR NUMBER OF FIELDS TO BACK UP DO ** CALL BAK123FLD() FOR INPUT FILE ** IF BAK123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** IF NOT END OF RECORD ** THEN ** CALL BAK123FLD() FOR OUTPUT FILE ** IF BAK123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ENDIF ** ENDFOR ** ** IF BACK UP STATUS IS END OF RECORD ** THEN ** SET PREVIOUS READ STATUS TO END OF RECORD ** ELSE ** SET PREVIOUS READ STATUS TO OUT OF BOUNDS ** ENDIF ** SET DESIGNATED DR NUMBER FOR BACKING UP TO ZERO ** RESET READ STATUS TO OUT OF BOUNDS#0*$$Ԍ** ENDIF ** ENDWHILE ** ENDWHILE ** ** CALL END123REC() FOR OUTPUT FILE ** IF END123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ** STOP ** END ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ #include "stc123.h" /* INTERNAL FUNCTION PROTOTYPE */ int clos_fils(FILE *, FILE *); /* GLOBAL CONSTANTS */ #define BAKFIT 10 /* GLOBAL DECLARATION */ char cstrng[5000]; int main(void) { /* INTERNAL VARIABLES */ FILE *fpin; FILE *fpout; char ccs[4]; char fnin[100]; char fnout[100]; char ice; char leadid; char tag[10]; int bk_stat; int er_stat; int i; int option; int prv_stat = 3; int status = -1; long bak_dr = 48; long bytlen; long drs = 0; long int_level; /* PROMPT USER FOR INPUT FILE NAME */ printf("%s\n","ENTER input file name:");#0*$$Ԍ scanf("%s",fnin); /* CALL BEG123FILE() FOR INPUT FILE { READ } */ if (!beg123file(fnin,'R',&int_level,&ice,ccs,&fpin)) { printf("%s\n","Unable to open input file; processing terminated"); exit(1); } /* PROMPT USER FOR OUTPUT FILE NAME */ printf("%s\n","ENTER output file name:"); scanf ("%s",fnout); /* CALL BEG123FILE() FOR OUTPUT FILE { WRITE } */ if (!beg123file(fnout,'W',&int_level,&ice,ccs,&fpout)) { printf("%s\n","Unable to open output file; processing terminated"); /* CALL END123FILE TO CLOSE INPUT FILE */ if (!end123file(&fpin)) printf("%s\n","Unable to close input file"); exit(1); } /* WHILE LAST DATA DESCRIPTIVE FIELD OF RECORD NOT INDICATED AND NOT EOF DO */ while (status != 3 && status != 4) { /* CALL RD123DDFLD() FOR INPUT FILE */ if (!rd123ddfld(fpin,tag,cstrng,&status)) { printf("%s%d\n","Unable to read DDR field; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF PREVIOUS READ STATUS INDICATES END OF RECORD */ if (prv_stat == 3) /* SET WRITE OPTION TO START OF RECORD */ option = 2; /* ELSE IF READ STATUS IS END OF FIELD */ else if (status == 5) /* SET WRITE OPTION TO START OF FIELD */ option = 6; else /* SET WRITE OPTION TO READ STATUS */ option = status; /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status;#0*$$Ԍ /* CALL WR123DDFLD() FOR OUTPUT FILE */ if (!wr123ddfld(fpout,tag,cstrng,option)) { printf("%s%d\n","Unable to write DDR field; OPTION = ",option); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* INITIALIZE ERASURE STATUS TO OUT OF BOUNDS */ er_stat = -1; /* WHILE BEGINNING OF DDR FIELD NOT ERASED */ while (er_stat != 6 && er_stat != 2) { /* CALL ER123DDSFLD() TO ERASE DDR SUBFIELD */ if (!er123ddsfld(fpout,&er_stat)) { printf("%s%d\n","Unable to erase DDR subfield; STATUS = ", er_stat); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } } /* CALL WR123DDFLD() TO REWRITE DDR FIELD TO OUTPUT FILE */ if (!wr123ddfld(fpout,tag,cstrng,option)) { printf("%s%d\n","Unable to rewrite DDR field; OPTION = ",option); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } } /* CALL END123DDREC() FOR OUTPUT FILE */ if (!end123ddrec(fpout)) { printf("%s\n","Unable to end Data Descriptive Record"); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* REINITIALIZE READ STATUS TO OUT OF BOUNDS */ status = -1; /* WHILE EOF NOT INDICATED FOR INPUT FILE DO */ while (status != 4) { /* INCREMENT DR COUNTER */ ++drs; /* RESET READ STATUS TO OUT OF BOUNDS */ status = -1;#0*$$Ԍ /* CALL BEG123REC() FOR OUTPUT FILE */ if (!beg123rec(fpout)) { printf("%s\n","Unable to begin output Data Record"); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* INITIALIZE PREVIOUS READ STATUS TO END OF RECORD */ prv_stat = 3; /* WHILE END OF RECORD NOT INDICATED FOR INPUT FILE AND NOT EOF DO */ while (status != 3 && status != 4) { /* CALL RD123FLD() FOR INPUT FILE */ if (!rd123fld(fpin,tag,&leadid,cstrng,&bytlen,&status)) { printf("%s%d\n","Unable to read DR field; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF PREVIOUS READ STATUS IS END OF RECORD */ if (prv_stat == 3) { /* SET WRITE OPTION TO START OF RECORD */ option = 2; } else /* SET WRITE OPTION TO READ STATUS */ option = status; /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status; /* CALL WR123FLD() FOR OUTPUT FILE */ if (!wr123fld(fpout,tag,leadid,cstrng,bytlen,option)) { printf("%s%d\n","Unable to write DR field; OPTION = ",option); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF DESIGNATED DR FOR BACKING UP BY FIELDS WAS PROCESSED OR END OF FILE WAS REACHED AND HAVE NOT BACKED UP */ if ((drs == bak_dr && status == 3) || (status == 4 && bak_dr)) { /* CALL END123REC() FOR OUTPUT FILE */ if (!end123rec(fpout)) { #0*$$Ԍ printf("%s\n","Unable to end Data Record"); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* FOR NUMBER OF FIELDS TO BACK UP DO */ for (i = 1; i <= BAKFIT; i++) { /* CALL BAK123FLD() FOR INPUT FILE */ if (!bak123fld (fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR field within ", "the input file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF NOT END OF RECORD */ if (bk_stat != 3) { /* CALL BAK123FLD() FOR OUTPUT FILE */ if (!bak123fld(fpout,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR field ", "within the output file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } } } /* IF BACK UP STATUS IS END OF RECORD */ if (bk_stat == 3) /* SET PREVIOUS READ STATUS TO END OF RECORD */ prv_stat = 3; else /* SET PREVIOUS READ STATUS TO OUT OF BOUNDS */ prv_stat = -1; /* SET DESIGNATED DR NUMBER FOR BACKING UP TO ZERO */ bak_dr = 0; /* RESET READ STATUS TO OUT OF BOUNDS */ status = -1; } }# 0*$$Ԍ } /* CALL END123REC() FOR OUTPUT FILE */ if (!end123rec(fpout)) { printf("%s\n","Unable to end Data Record"); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ clos_fils(fpin,fpout); /* STOP/END */ return(1); } ***************************************************************************** ** ** INVOCATION NAME: CLOS_FILS ** ** PURPOSE: TO CLOSE BOTH THE INPUT AND OUTPUT FILES ** ** INVOCATION METHOD: CLOS_FILS(FPI,FPO) ** ** ARGUMENT LIST: ** NAME TYPE USE DESCRIPTION ** FPI PTR I FILE POINTER TO INPUT FILE ** FPO PTR I FILE POINTER TO OUTPUT FILE ** CLOS_FILS() LOGICAL O RETURN STATUS ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** END123FILE() CLOSES A DATA FILE ** ** INTERNAL VARIABLES: NONE ** ** GLOBAL REFERENCES: NONE ** ** GLOBAL VARIABLES: NONE ** ** GLOBAL CONSTANTS: NONE ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** L. MCMILLION 01/25/91 INITIAL PROLOG ** L. MCMILLION 01/25/91 INITIAL PDL ** L. MCMILLION 01/25/91 INITIAL CODE ** ** PDL: ** ** CALL END123FILE() TO CLOSE THE INPUT FILE ** IF END123FILE() FAILED ** THEN#!0*$$Ԍ** PRINT ERROR MESSAGE ** ENDIF ** CALL END123FILE() TO CLOSE THE OUTPUT FILE ** IF END123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** ** RETURN SUCCESS ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ int clos_fils(fpi,fpo) FILE *fpi; FILE *fpo; { /* CALL END123FILE() FOR INPUT FILE */ if (!end123file(&fpi)) printf("%s\n","Unable to close input file"); /* CALL END123FILE() FOR OUTPUT FILE */ if (!end123file(&fpo)) printf("%s\n","Unable to close output file"); /* RETURN SUCCESS */ return(1); } "0*$$  tT 96h& tT #dp@>pQWm@#` (#HSAMPRG2B.C Eh#dp@>pQWm@#E.4.2` ` Sample Program 2B (SAMPRG2B.C) Source Code#d6X@J'@#(#` *************************************************************************** ** ** INVOCATION NAME: SAM123PRG2B ** ** PURPOSE: TO RETRIEVE DATA DESCRIPTIVE INFORMATION FOR ** FIELDS AND SUBFIELDS: ** ** CHK123FLD ** CHK123REC ** ** NOTE: AFTER PROGRAM EXECUTION, THE SDTS FORMAT OUTPUT FILE ** AND THE OUTPUT REPORT FILE SHOULD BE VISUALLY ** INSPECTED AGAINST THE ORIGINAL SDTS FORMAT INPUT FILE. ** THE OUTPUT FILES WILL DIFFER SLIGHTLY, BUT THE ** INFORMATION WILL BE PRESERVED. ** ** INVOCATION METHOD: SAMPRG2B ** ** ARGUMENT LIST: NONE ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** BAK123REC() BACKS UP TO BEGINNING OF LAST RECORD READ OR WRITTEN ** BEG123FILE() OPENS A DATA FILE AND PERFORM ANY NECESSARY OVERHEAD ** CHK123FLD() GETS DESCRIPTION FOR LAST FIELD READ ** CHK123REC() GETS DESCRIPTION FOR LAST READ RECORD ** END123DDREC() ENDS A DATA DESCRIPTIVE RECORD ** END123FILE() CLOSES A DATA FILE ** RD123DDREC() READS THE NEXT DATA DESCRIPTIVE RECORD ** RD123FLD() READS THE NEXT FIELD ** RD123REC() READS THE NEXT RECORD ** WR123DDREC() WRITES THE NEXT DATA DESCRIPTIVE RECORD ** WR123FLD() WRITES THE NEXT FIELD ** WR123REC() WRITES THE NEXT RECORD ** ** INTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** CLOS_FILS() CLOSES ALL FILES ** ** INTERNAL VARIABLES: ** NAME TYPE DESCRIPTION ** BK_STAT INT BACK UP STATUS ** 0 = FAILURE ** 1 = OKAY ** 2 = START OF RECORD ** 3 = END OF RECORD ** 4 = END OF FILE (DR) ** 5 = END OF FIELD ** 6 = START OF FIELD ** BYTLEN INT NUMBER OF CHARACTERS IN STRING ** CCS[4] CHAR CODE CHARACTER SET INDICATOR ** FDCNTRL[10] CHAR FIELD CONTROL$#0*$$Ԍ** FDLEN[10] CHAR FIELD LENGTH ** FDNAME[] PTR FIELD NAME ** FNIN[100] CHAR FILE NAME OF SDTS FORMAT INPUT FILE ** FPIN PTR FILE POINTER OF SDTS FORMAT INPUT FILE ** FNOUT[100] CHAR FILE NAME OF OUTPUT FILE ** FPOUT PTR FILE POINTER OF OUTPUT REPORT FILE ** FNREP[100] CHAR FILE NAME OF OUTPUT REPORT FILE ** FPREP PTR FILE POINTER TO OUTPUT REPORT FILE ** ICE CHAR INLINE CODE EXTENSION INDICATOR ** INT_LEVEL INT INTERCHANGE LEVEL ** LEADID CHAR LEADER IDENTIFIER ** OPTION INT WRITE OPTION (SAME VALUE RANGE AS BACK ** UP STATUS) ** PRV_STAT INT PREVIOUS READ STATUS (SAME VALUE RANGE AS  s4" **` `  $hh* BACK UP STATUS) ** REC_CNT INT RECORD COUNTER ** RECLEN INT RECORD LENGTH ** STATUS INT READ STATUS (SAME VALUE RANGE AS BACK ** UP STATUS) ** TAG[10] CHAR TAG FIELD ** ** GLOBAL REFERENCES: NONE ** ** GLOBAL VARIABLES ** NAME TYPE USE DESCRIPTION ** CSTRNG[5000] CHAR I/O CHARACTER STRING FOR PROCESSING ** DESCR[5000] CHAR I/O RECORD/FIELD DESCRIPTION ** FMTS[500] CHAR I/O FORMAT ** LABLS[500] CHAR I/O LABELS ** ** GLOBAL CONSTANTS: ** NAME TYPE DESCRIPTION ** RAND_NUM INT RANDOM NUMBER ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** P. HODGES 05/24/90 INITIAL PROLOG ** P. HODGES 05/24/90 INITIAL PDL ** P. HODGES 06/14/90 INITIAL CODE ** L. MCMILLION 02/01/91 MODIFIED CODE TO REFLECT CHANGES IN ** IN FUNCTIONS SINCE INITIAL DESIGN ** OF TEST PROGRAM ** J. TAYLOR 92DR005 06/02/92 CHANGED CALLING SEQUENCES OF BINARY ** HANDLING FUNCTIONS ** ** PDL: ** ** PROMPT USER FOR INPUT FILE NAME ** CALL BEG123FILE() FOR INPUT FILE { READ } ** IF BEG123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** PROMPT USER FOR OUTPUT FILE NAME ** CALL BEG123FILE() FOR OUTPUT FILE { WRITE } ** IF BEG123FILE() FAILED#$0*$$Ԍ** THEN ** CALL END123FILE TO CLOSE INPUT FILE ** ENDIF ** ** PROMPT USER FOR OUTPUT REPORT FILE NAME ** OPEN OUTPUT REPORT FILE ** IF CAN NOT OPEN OUTPUT REPORT FILE ** THEN ** CALL END123FILE() TO CLOSE INPUT FILE ** CALL END123FILE() TO CLOSE OUTPUT FILE ** ENDIF ** ** CALL RD123DDREC() TO INPUT DATA DESCRIPTIVE RECORD ** IF RD123DDREC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE INPUT DATA DESCRIPTIVE RECORD TO OUTPUT REPORT FILE ** CALL WR123DDREC() TO OUTPUT DATA DESCRIPTIVE RECORD ** IF WR123DDREC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** CALL END123DDREC() TO END THE DATA DESCRIPTIVE RECORD ** IF END123DDREC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** ** RESET STATUS TO OUT OF BOUNDS ** WHILE NOT EOF FOR INPUT FILE DO ** CALL RD123REC() TO READ A DATA RECORD ** IF RD123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** INCREMENT RECORD COUNTER ** WRITE RETRIEVED DATA RECORD STRING TO OUTPUT REPORT FILE ** CALL CHK123REC() TO RETRIEVE DESCRIPTION OF INPUT RECORD ** IF CHK123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE INPUT RECORD DESCRIPTION TO OUTPUT REPORT FILE ** CALL WR123REC() TO WRITE A DATA RECORD ** IF WR123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** CALL CHK123REC() TO RETRIEVE DESCRIPTION OF OUTPUT RECORD ** IF CHK123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE OUTPUT RECORD DESCRIPTION TO OUTPUT REPORT FILE ** IF REC_CNT EQUALS RAND_NUM#%0*$$Ԍ** THEN ** RESET REC_CNT TO ZERO ** CALL BAK123REC() TO BACK UP TO BEGINNING OF DATA RECORD IN ** THE INPUT FILE ** IF BAK123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** CALL BAK123REC() TO BACK UP TO BEGINNING OF DATA RECORD IN ** THE OUTPUT FILE ** IF BAK123REC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** ** RESET STATUS TO OUT OF BOUNDS ** INITIALIZE PREVIOUS STATUS TO END OF RECORD ** WHILE NOT END OF RECORD AND NOT EOF DO ** CALL RD123FLD() TO READ DATA RECORD FIELD ** IF RD123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE RETRIEVED DATA RECORD FIELD TO OUTPUT REPORT FILE ** CALL CHK123FLD() TO RETRIEVE DESCRIPTION OF INPUT FIELD ** IF CHK123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE INPUT FIELD DESCRIPTION TO OUTPUT REPORT FILE ** RELEASE FIELD NAME ** IF PREVIOUS READ STATUS IS OUT OF BOUNDS ** THEN ** SET WRITE OPTION TO START OF RECORD ** ELSE ** SET WRITE OPTION TO READ STATUS ** ENDIF ** SET PREVIOUS READ STATUS TO READ STATUS ** CALL WR123FLD() TO WRITE DATA RECORD FIELD ** IF WR123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** CALL CHK123FLD() TO RETRIEVE DESCRIPTION OF OUTPUT FIELD ** IF CHK123FLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE ALL FILES ** ENDIF ** WRITE OUTPUT FIELD DESCRIPTION TO OUTPUT REPORT FILE ** RELEASE FIELD NAME ** ENDWHILE ** ENDIF ** ENDWHILE ** ** CALL CLOS_FILS() TO CLOSE ALL FILES ** #&0*$$Ԍ** STOP ** END ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ #include "stc123.h" /* INTERNAL FUNCTION PROTOTYPE */ int clos_fils(FILE *, FILE *, FILE *); /* GLOBAL CONSTANTS */ #define RAND_NUM 23 /* GLOBAL VARIABLES */ char cstrng[5000]; char descr[5000]; char fmts[500]; char labls[500]; int main (void) { /* LOCAL VARIABLES */ FILE *fpin; FILE *fpout; FILE *fprep; char ccs[4]; char fdcntrl[10]; char fdlen[10]; char *fdname; char fnin[100]; char fnout[100]; char fnrep[100]; char ice; char leadid; char tag[10]; int bk_stat; int option; int prv_stat; int status; int rec_cnt = 0; long bytlen; long int_level; long reclen; /* PROMPT USER FOR INPUT FILE NAME */ printf("%s\n","ENTER input file name:"); scanf("%s",fnin); /* CALL BEG123FILE() FOR INPUT FILE { READ } */ if (!beg123file(fnin,'R',&int_level,&ice,ccs,&fpin)) { printf("%s\n","Unable to open input file; processing terminated");#'0*$$Ԍ exit(1); } /* PROMPT USER FOR OUTPUT FILE NAME */ printf("%s\n","ENTER output file name:"); scanf("%s",fnout); /* CALL BEG123FILE() FOR OUTPUT FILE { WRITE } */ if (!beg123file(fnout,'W',&int_level,&ice,ccs,&fpout)) { printf("%s\n","Unable to open output file; processing terminated"); /* CALL END123FILE() TO CLOSE INPUT FILE */ if (!end123file(&fpin)) printf("%s\n","Unable to close input file"); exit(1); } /* PROMPT USER FOR OUTPUT REPORT FILE NAME */ printf("%s\n","ENTER output report file name:"); scanf("%s",fnrep); /* OPEN OUTPUT REPORT FILE */ if ((fprep = fopen(fnrep,"w")) == NULL) { printf("%s\n","Unable to open output report file; processing terminated"); /* CALL END123FILE() TO CLOSE INPUT AND OUTPUT FILES */ if (!end123file(&fpin)) printf("%s\n","Unable to close input file"); if (!end123file(&fpout)) printf("%s\n","Unable to close output file"); exit(1); } /* CALL RD123DDREC() TO INPUT DATA DESCRIPTIVE RECORD */ if (!rd123ddrec(fpin,cstrng,&status)) { printf("%s%d\n","Unable to read Data Descriptive Record; STATUS = ", status); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE INPUT DATA DESCRIPTIVE RECORD TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","DDR READ = ",cstrng); /* CALL WR123DDREC() TO OUTPUT DATA DESCRIPTIVE RECORD -- USE SAME STATUS FROM RD123DDREC() */ if (!wr123ddrec(fpout,cstrng,&status)) { printf("%s%d\n","Unable to write Data Descriptive Record; STATUS = ", status); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); }#(0*$$Ԍ /* CALL END123DDREC() TO END THE OUTPUT DATA DESRIPTIVE RECORD */ if (!end123ddrec(fpout)) { printf("%s\n","Unable to end Data Descriptive Record"); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* RESET STATUS TO OUT OF BOUNDS */ status = -1; /* WHILE NOT EOF FOR INPUT FILE DO */ while (status != 4) { fprintf(fprep,"\n\n%s\n\n","**************** START OF RECORD"); /* CALL RD123REC() TO READ A DATA RECORD */ if (!rd123rec(fpin,cstrng,&bytlen,&status)) { printf("%s%d\n","Unable to read Data Record; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* INCREMENT RECORD COUNTER */ rec_cnt++; /* WRITE RETRIEVED DATA RECORD STRING TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n\n","DATA RECORD READ = ",cstrng); /* CALL CHK123REC() TO RETRIEVE DESCRIPTION OF INPUT RECORD */ if (!chk123rec(fpin,&reclen,&leadid,descr)) { printf("%s\n","Unable to retrieve input Data Record description"); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE INPUT RECORD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"\t%s\n","* INPUT RECORD DESCRIPTION"); fprintf(fprep,"\t%s%s\n","RECORD DESCRIPTION = ",descr); fprintf(fprep,"\t%s%ld\n","RECORD LENGTH = ",reclen); fprintf(fprep,"\t%s%c\n\n","LEADER IDENTIFIER = ",leadid); /* CALL WR123REC() TO WRITE A DATA RECORD -- USE SAME STATUS FROM RD123REC() */ if (!wr123rec(fpout,cstrng,bytlen,&status)) { printf("%s%d\n","Unable to write Data Record; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE ALL FILES */#)0*$$Ԍ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* CALL CHK123REC() TO RETRIEVE DESCRIPTION OF OUTPUT RECORD */ if (!chk123rec(fpout,&reclen,&leadid,descr)) { printf("%s\n","Unable to retrieve output Data Record description"); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE OUTPUT RECORD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"\t%s\n","* OUTPUT RECORD DESCRIPTION"); fprintf(fprep,"\t%s%s\n","RECORD DESCRIPTION = ",descr); fprintf(fprep,"\t%s%ld\n","RECORD LENGTH = ",reclen); fprintf(fprep,"\t%s%c\n\n","LEADER IDENTIFIER = ",leadid); if ( rec_cnt == RAND_NUM ) { /* RESET REC_CNT TO ZERO */ rec_cnt = 0; /* CALL BAK123REC() TO BACK UP TO BEGINNING OF INPUT DATA RECORD */ if (!bak123rec(fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one Data Record within the ", "input file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* CALL BAK123REC() TO BACK UP TO BEGINNING OF OUTPUT DATA RECORD */ if (!bak123rec(fpout,&bk_stat)) { printf("%s%s%d\n","Unable to backup one Data Record within the ", "output file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* RESET STATUS TO OUT OF BOUNDS */ status = -1; /* INITIALIZE PEVIOUS STATUS TO END OF RECORD */ prv_stat = 3; /* WHILE NOT END OF RECORD AND NOT EOF DO */ while (status != 4 && status != 3) { fprintf(fprep,"\n%s\n","*** START OF FIELD ***"); /* CALL RD123FLD() TO READ DATA RECORD FIELD */ if (!rd123fld(fpin,tag,&leadid,cstrng,&bytlen,&status)) {#*0*$$Ԍ printf("%s%d\n","Unable to read DR field; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE RETRIEVED DATA RECORD FIELD TO OUTPUT REPORT FILE */ fprintf(fprep,"\t%s\n","* INPUT DATA FIELD"); fprintf(fprep,"\t%s%s\n","TAG = ",tag); fprintf(fprep,"\t%s%c\n","LEADID = ",leadid); fprintf(fprep,"\t%s%s\n","FIELD = ",cstrng); /* CALL CHK123FLD() TO RETRIEVE DESCRIPTION OF INPUT FIELD */ if (!chk123fld(fpin,tag,fdlen,&fdname,fdcntrl,fmts,labls)) { printf("%s%s\n","Unable to retrieve input DR field ", "description"); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE INPUT FIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"\t%s\n","* INPUT FIELD DESCRIPTION"); fprintf(fprep,"\t%s%s\n","TAG = ",tag); fprintf(fprep,"\t%s%s\n","FIELD LENGTH = ",fdlen); fprintf(fprep,"\t%s%s\n","FIELD NAME = ",fdname); fprintf(fprep,"\t%s%s\n","FIELD CONTROL = ",fdcntrl); fprintf(fprep,"\t%s%s\n","FORMAT = ",fmts); fprintf(fprep,"\t%s%s\n","LABELS = ",labls); /* RELEASE FIELD NAME */ free(fdname); /* IF PREVIOUS READ STATUS IS OUT OF BOUNDS */ if (prv_stat == 3) /* SET WRITE OPTION TO START OF RECORD */ option = 2; else /* SET WRITE OPTION TO READ STATUS */ option = status; /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status; /* CALL WR123FLD() TO WRITE DATA RECORD FIELD */ if (!wr123fld(fpout,tag,leadid,cstrng,bytlen,option)) { printf("%s%d\n","Unable to write DR field; OPTION = ", option); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1);#+0*$$Ԍ } /* CALL CHK123FLD() TO RETRIEVE DESCRIPTION OF OUTPUT FIELD */ if (!chk123fld(fpout,tag,fdlen,&fdname,fdcntrl,fmts,labls)) { printf("%s\n","Unable to retrieve output DR field description"); /* CALL CLOS_FILS() TO CLOSE ALL FILES */ if (clos_fils(fpin,fpout,fprep)) exit(1); } /* WRITE OUTPUT FIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"\t%s\n","* OUTPUT FIELD DESCRIPTION"); fprintf(fprep,"\t%s%s\n","TAG = ",tag); fprintf(fprep,"\t%s%s\n","FIELD LENGTH = ",fdlen); fprintf(fprep,"\t%s%s\n","FIELD NAME = ",fdname); fprintf(fprep,"\t%s%s\n","FIELD CONTROL = ",fdcntrl); fprintf(fprep,"\t%s%s\n","FORMAT = ",fmts); fprintf(fprep,"\t%s%s\n","LABELS = ",labls); /* RELEASE FIELD NAME */ free(fdname); } } } /* CALL CLOS_FILS() TO CLOSE ALL FILES */ clos_fils(fpin,fpout,fprep); /* STOP/END */ return(1); } ***************************************************************************** ** ** INVOCATION NAME: CLOS_FILS ** ** PURPOSE: TO CLOSE ALL FILES ** ** INVOCATION METHOD: CLOS_FILS(FPI,FPO,FPR) ** ** ARGUMENT LIST: ** NAME TYPE USE DESCRIPTION ** FPI PTR I FILE POINTER TO INPUT FILE ** FPO PTR I FILE POINTER TO OUTPUT FILE ** FPR PTR I FILE POINTER TO OUTPUT REPORT FILE ** CLOS_FILS() LOGICAL O RETURN STATUS ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** END123FILE() CLOSES A DATA FILE ** ** INTERNAL VARIABLES: NONE ** ** GLOBAL REFERENCES: NONE#,0*$$Ԍ** ** GLOBAL VARIABLES: NONE ** ** GLOBAL CONSTANTS: NONE ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** L. MCMILLION 01/25/91 INITIAL PROLOG ** L. MCMILLION 01/25/91 INITIAL PDL ** L. MCMILLION 01/25/91 INITIAL CODE ** ** PDL: ** ** CALL END123FILE() TO CLOSE THE INPUT FILE ** IF END123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** CALL END123FILE() TO CLOSE THE OUTPUT FILE ** IF END123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** CLOSE THE OUTPUT REPORT FILE ** IF CLOSE OUTPUT REPORT FILE FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** ** RETURN SUCCESS ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ int clos_fils(fpi,fpo,fpr) FILE *fpi; FILE *fpo; FILE *fpr; { /* CALL END123FILE() FOR INPUT FILE */ if (!end123file(&fpi)) printf("%s\n","Unable to close input file"); /* CALL END123FILE() FOR OUTPUT FILE */ if (!end123file(&fpo)) printf("%s\n","Unable to close output file"); /* CLOSE OUTPUT REPORT FILE */ if (fclose(fpr)) printf("%s\n","Unable to close output report file"); /* RETURN SUCCESS */ return(1); }#-0*$$  tT &hp tT #dp@>pQWm@#` (#HSAM_PRG3.C Eh#dp@>pQWm@#E.4.3` ` Sample Program 3 (SAM_PRG3.C) Source Code#d6X@J'@# ***************************************************************************** ** ** INVOCATION NAME: SAM123PRG3 ** ** PURPOSE: TO EXECUTE COMPLETE LEVEL ROUTINES OF THE SDTS ACCESS ** SOFTWARE: ** ** BEG123DDSFLD <- RENAMED TO RD123SDDSFLD ** WR123DDSFLD ** ** ER123DDSFLD ** RD123SFLD ** WR123SFLD ** BAK123SFLD ** ** NOTE: AFTER PROGRAM EXECUTION, THE INPUT AND OUTPUT FILES SHOULD ** BE VISUALLY INSPECTED. THEY WILL DIFFER SLIGHTLY, BUT ** THE INFORMATION WILL BE PRESERVED. ** ** INVOCATION METHOD: SAM_PRG3 ** ** ARGUMENT LIST: NONE ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** BAK123SFLD() BACK UP TO BEGINNING OF LAST SUBFIELD READ OR ** WRITTEN ** BEG123FILE() OPEN A DATA FILE AND BEGIN ANY NECESSARY OVERHEAD ** END123DDREC() ENDS THE DATA DESCRIPTIVE RECORD ** END123FILE() CLOSES A DATA FILE ** ER123DDSFLD() ERASE THE LAST DATA DESCRIPTIVE SUBFIELD WRITTEN ** RD123DDSFLD() READ THE NEXT DATA DESCRIPTIVE SUBFIELD ** RD123SFLD() READ THE NEXT SUBFIELD ** WR123DDSFLD() WRITE THE NEXT DATA DESCRIPTIVE SUBFIELD ** WR123SFLD() WRITE THE NEXT SUBFIELD ** ** INTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** CLOS_FILS() CLOSES BOTH OF THE INPUT AND OUTPUT FILES ** ** INTERNAL VARIABLES: ** NAME TYPE DESCRIPTION ** BK_STAT INT BACK UP STATUS INDICATOR ** 0 = FAILURE ** 1 = OKAY ** 2 = START OF RECORD ** 3 = END OF RECORD ** 4 = END OF FILE (DR) ** 5 = END OF FIELD ** 6 = START OF FIELD ** BYTLEN INT NUMBER OF CHARACTERS IN STRING$.0*$$Ԍ** CCS[4] CHAR CODE CHARACTER SET INDICATOR ** ER_STAT INT ERASURE STATUS INDICATOR (SAME VALUE RANGE ** AS BACK UP STATUS) ** FPIN PTR FILE POINTER FOR INPUT FILE ** FPOUT PTR FILE POINTER FOR OUTPUT FILE ** FNIN[100] CHAR FILE NAME FOR INPUT FILE ** FNOUT[100] CHAR FILE NAME FOR OUTPUT FILE ** ICE CHAR INLINE CODE EXTENSION INDICATOR ** INT_LEVEL INT INTERCHANGE LEVEL ** LEADID CHAR LEADER IDENTIFIER ** OPTION INT WRITE OPTION INDICATOR (SAME VALUE RANGE AS ** BACK UP STATUS) ** PRV_STAT INT PREVIOUS READ STATUS INDICATOR (SAME VALUE ** RANGE AS BACK UP STATUS) ** SBF_CNT INT SUBFIELD COUNTER ** STATUS INT READ STATUS INDICATOR (SAME VALUE RANGE AS ** BACK UP STATUS) ** TAG[10] CHAR INTERNAL NAME OF AN ASSOCIATED FIELD ** ** GLOBAL REFERENCES: ** NAME TYPE USE DESCRIPTION ** CSTRNG[5000] CHAR I/O GLOBAL CHARACTER STRING USED FOR ** PROCESSING ** ** GLOBAL CONSTANTS: ** NAME TYPE DESCRIPTION ** RAND_NUM INT RANDOM NUMBER ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** P. HODGES 05/24/90 INITIAL PROLOG ** P. HODGES 05/24/90 INITIAL PDL ** A. DEWITT 07/25/90 INITIAL CODE ** L. MCMILLION 02/11/91 MODIFIED CODE TO REFLECT CHANGES IN ** FUNCTIONS SINCE INITIAL DESIGN OF ** TEST PROGRAM ** J. TAYLOR 92DR005 06/03/92 CHANGED CALLING SEQUENCE TO BINARY ** HANDLING FUNCTIONS ** L. MCMILLION TASK #40 12/23/92 INITIALIZED PREVIOUS STATUS TO END- ** OF-RECORD ** J. TAYLOR TASK 55 03/17/93 MODIFIED READ STATUS TO WRITE OPTION ** CONVERSION TO HANDLE RECORDS WITH ** SINGLE ELEMENTARY FIELDS ** ** PDL: ** ** INITIALIZE BACK UP STATUS TO OUT OF BOUNDS ** INITIALIZE ERASURE STATUS TO OUT OF BOUNDS ** INITIALIZE SUBFIELD COUNT TO ZERO ** PROMPT USER FOR NAME OF INPUT FILE ** CALL BEG123FILE() FOR INPUT FILE ** PROMPT USER FOR NAME OF OUTPUT FILE ** CALL BEG123FILE() FOR OUTPUT FILE ** IF BEG123FILE() FAILED ** THEN ** CALL END123FILE() TO CLOSE INPUT FILE#/0*$$Ԍ** ENDIF ** ** INITIALIZE READ STATUS TO OUT OF BOUNDS ** INITIALIZE PREV_STAT TO END OF RECORD ** WHILE NOT END OF DATA DESCRIPTIVE RECORD AND NOT EOF DO ** CALL RD123DDSFLD() TO READ SUBFIELD FROM INPUT FILE ** IF RD123DDSFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** IF PREVIOUS READ STATUS IS END OF RECORD ** THEN ** SET WRITE OPTION TO START OF RECORD ** ELSE IF PREVIOUS READ STATUS IS END OF FIELD ** THEN ** SET WRITE OPTION TO START OF FIELD ** ELSE ** SET WRITE OPTION TO READ STATUS ** ENDIF ** SET PREVIOUS READ STATUS TO READ STATUS ** CALL WR123DDSFLD() TO WRITE SUBFIELD TO OUTPUT FILE ** IF WR123DDSFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** CALL ER123DDSFLD() TO "UN-WRITE" SUBFIELD ** IF ER123DDSFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** CALL WR123DDSFLD TO WRITE SUBFIELD (AGAIN) TO OUTPUT FILE ** { USE ERASURE STATUS FOR WRITE OPTION } ** IF WR123DDSFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ENDWHILE ** CALL END123DDREC() TO END THE DATA DESCRIPTIVE RECORD ** IF END123DDREC() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ** RESET READ STATUS TO OUT OF BOUNDS ** RESET PREVIOUS READ STATUS TO END OF RECORD ** WHILE NOT END OF FILE DO ** CALL RD123SFLD() TO READ SUBFIELD FROM INPUT FILE ** IF RD123SFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** INCREMENT SBF_CNT ** { CONVERT READ STATUS TO WRITE OPTION } ** IF STATUS IS END OF RECORD ** THEN ** IF PREVIOUS READ STATUS IS END OF RECORD #00*$$Ԍ** THEN ** SET OPTION TO START OF RECORD ** ELSE IF PREVIOUS STATUS IS END OF FIELD ** SET OPTION EQUAL TO START OF FIELD ** ELSE IF PREVIOUS STATUS IS START OF RECORD ** THEN ** SET OPTION TO TO START OF FIELD ** ELSE ** SET OPTION TO STATUS ** ENDIF ** ELSE IF STATUS IS END OF FIELD ** THEN ** IF PREVIOUS STATUS IS END OF FIELD OR PREVIOUS STATUS IS START OF ** RECORD ** THEN ** SET OPTION EQUAL TO START OF FIELD ** ELSE IF PREVIOUS STATUS IS END OF RECORD ** THEN ** SET OPTION TO START OF RECORD ** ELSE ** SET OPTION TO STATUS ** ENDIF ** ELSE IF STATUS IS END OF FILE ** THEN ** IF PREVIOUS STATUS IS END OF FIELD OR PREVIOUS STATUS IS START ** OF RECORD ** THEN ** SET OPTION TO START OF FIELD ** ELSE ** SET OPTION TO STATUS ** ENDIF ** ELSE ** SET OPTION TO STATUS ** ENDIF ** SET PREVIOUS READ STATUS TO READ STATUS ** ** CALL WR123SFLD() TO WRITE SUBFIELD TO OUTPUT FILE ** IF WR123SFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** IF SBF_CNT EQUALS RAND_NUM ** THEN ** RESET SBF_CNT TO ZERO ** CALL BAK123SFLD() FOR INPUT FILE ** IF BAK123SFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** CALL BAK123SFLD() FOR OUTPUT FILE ** IF BAK123SFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** CALL RD123SFLD() TO REREAD SUBFIELD FROM INPUT FILE ** IF RD123SFLD() FAILED#10*$$Ԍ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** CALL WR123SFLD() TO REWRITE SUBFIELD TO OUTPUT FILE { USE OPTION } ** IF WR123SFLD() FAILED ** THEN ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ENDIF ** ENDIF ** ENDWHILE ** ** CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES ** ** STOP ** END ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ #include "stc123.h" /* INTERNAL FUNCTION PROTOTYPE */ int clos_fils(FILE *, FILE *); #define RAND_NUM 53 /* GLOBAL VARIABLES */ char cstrng[5000]; int main(void) { FILE *fpin; FILE *fpout; char fnin[100]; char fnout[100]; char ice; char ccs[4]; char tag[10]; char leadid; long bytlen; long int_level; int bk_stat = -1; int er_stat = -1; int option; int prv_stat; int sbf_cnt = 0; int status; /* PROMPT USER FOR NAME OF INPUT FILE */ printf("%s\n","ENTER input file name:"); scanf("%s",fnin); /* CALL BEG123FILE() FOR INPUT FILE */ if (!beg123file(fnin,'R',&int_level,&ice,ccs,&fpin)) { #20*$$Ԍ printf("%s\n","Unable to open input file; processing terminated"); exit(1); } /* PROMPT USER FOR NAME OF OUTPUT FILE */ printf("%s\n","ENTER output file name:"); scanf("%s",fnout); /* CALL BEG123FILE() FOR OUTPUT FILE */ if (!beg123file(fnout,'W',&int_level,&ice,ccs,&fpout)) { printf("%s\n","Unable to open output file; processing terminated"); /* CALL END123FILE() TO CLOSE INPUT FILE */ if (!end123file(&fpin)) printf("%s\n","Unable to close input file"); exit(1); } /* INITIALIZE READ STATUS TO OUT OF BOUNDS */ status = -1; /* INITIALIZE PREV_STAT TO END OF RECORD */ prv_stat = 3; /* WHILE NOT END OF DATA DESCRIPTIVE RECORD AND NOT EOF DO */ while (status != 3 && status != 4) { /* CALL RD123DDSFLD() TO READ SUBFIELD FROM INPUT FILE */ if (!rd123ddsfld(fpin,tag,cstrng,&status)) { printf("%s%d\n","Unable to read DDR subfield; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF PREVIOUS READ STATUS IS END OF RECORD */ if (prv_stat == 3) /* SET WRITE OPTION TO START OF RECORD */ option = 2; /* ELSE IF PREVIOUS READ STATUS IS END OF FIELD */ else if (prv_stat == 5) /* SET WRITE OPTION TO START OF FIELD */ option = 6; else /* SET WRITE OPTION TO READ STATUS */ option = status; /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status; #30*$$Ԍ /* CALL WR123DDSFLD() TO WRITE SUBFIELD TO OUTPUT FILE */ if (!wr123ddsfld(fpout,tag,cstrng,option)) { printf("%s%d\n","Unable to write DDR subfield; OPTION = ",option); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* CALL ER123DDSFLD() TO "UN-WRITE" SUBFIELD */ if (!er123ddsfld(fpout,&er_stat)) { printf("%s%d\n","Unable to erase DDR subfield; STATUS = ",er_stat); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* CALL WR123DDSFLD TO WRITE SUBFIELD (AGAIN) TO OUTPUT FILE -- USE ERASURE STATUS FOR WRITE OPTION -- */ if (!wr123ddsfld(fpout,tag,cstrng,er_stat)) { printf("%s%d\n","Unable to rewrite DDR subfield; OPTION = ",er_stat); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } } /* CALL END123DDREC() TO END THE OUTPUT DATA DESRIPTIVE RECORD */ if (!end123ddrec(fpout)) { printf("%s\n","Unable to end Data Descriptive Record"); /* CALL CLOS_FILS() TO CLOSE BOTH THE INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* RESET READ STATUS TO OUT OF BOUNDS */ status = -1; /* INITIALIZE PRV_STAT TO END OF REOCORD */ prv_stat = 3; /* WHILE NOT END OF FILE DO */ while (status != 4) { /* CALL RD123SFLD() TO READ SUBFIELD FROM INPUT FILE */ if (!rd123sfld(fpin,tag,&leadid,cstrng,&bytlen,&status)) { printf("%s%d\n","Unable to read DR subfield; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); }#40*$$Ԍ /* INCREMENT SBF_CNT */ sbf_cnt++; /* { CONVERT READ STATUS TO WRITE OPTION } */ /* IF STATUS IS END OF RECORD */ if (status == 3) { /* IF PREVIOUS READ STATUS IS END OF RECORD */ if (prv_stat == 3) { /* SET OPTION TO START OF RECORD */ option = 2; } /* ELSE IF PREVIOUS STATUS IS END OF FIELD */ else if ( prv_stat == 5) { /* SET OPTION EQAUL TO START OF FIELD */ option = 6; } /* ELSE IF PREVIOUS STATUS IS START OF RECORD */ else if ( prv_stat == 2) { /* SET OPTION EQUAL TO START OF FIELD */ option = 6; } /* SET OPTION TO STATUS */ else option = status; } /* ELSE IF STATUS IS END OF FIELD */ else if (status == 5) { /* IF PREVIOUS STATUS IS END OF FIELD OR PREVIOUS STATUS IS START OF RECORD */ if (prv_stat == 5 || prv_stat == 2) { /* SET OPTION EQUAL TO START OF FIELD */ option = 6; } /* ELSE IF PREVIOUS STATUS IS END OF RECORD */ else if ( prv_stat == 3) { /* SET OPTION TO START OF RECORD */ option = 2; } /* ELSE SET OPTION TO STATUS */ else option = status; } /* ELSE IF STATUS IS END OF FILE */ else if (status == 4) { /* IF PREVIOUS STATUS IS END OF FIELD OR PREVIOUS STATUS IS START#50*$$Ԍ OF RECORD, SET OPTION TO START OF FIELD */ if (prv_stat == 5 || prv_stat == 2) option = 6; /* SET OPTION EQUAL TO STATUS */ else option = status; } /* ELSE SET OPTION TO STATUS */ else option = status; /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status; /* CALL WR123SFLD() TO WRITE SUBFIELD TO OUTPUT FILE */ if (!wr123sfld(fpout,tag,leadid,cstrng,bytlen,option)) { printf("%s%d\n","Unable to write DR subfield; OPTION = ",option); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* IF SBF_CNT EQUALS RAND_NUM */ if (sbf_cnt == RAND_NUM) { /* RESET SBF_CNT TO ZERO */ sbf_cnt = 0; /* CALL BAK123SFLD() FOR INPUT FILE */ if (!bak123sfld(fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR subfield within ", "the input file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* CALL BAK123SFLD() FOR OUTPUT FILE */ if (!bak123sfld(fpout,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR subfield within ", "the output file; STATUS = ",bk_stat); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } /* CALL RD123SFLD() TO REREAD SUBFIELD FROM INPUT FILE */ if (!rd123sfld(fpin,tag,&leadid,cstrng,&bytlen,&status)) { printf("%s%d\n","Unable to reread DR subfield; STATUS = ",status); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1);#60*$$Ԍ } /* CALL WR123SFLD() TO REWRITE SUBFIELD TO OUTPUT FILE -- USE OPTION -- */ if (!wr123sfld(fpout,tag,leadid,cstrng,bytlen,option)) { printf("%s%d\n","Unable to rewrite DR subfield; OPTION = ", bk_stat); /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ if (clos_fils(fpin,fpout)) exit(1); } } } /* CALL CLOS_FILS() TO CLOSE BOTH INPUT AND OUTPUT FILES */ clos_fils(fpin,fpout); /* STOP/EXIT */ return (1); } ***************************************************************************** ** ** INVOCATION NAME: CLOS_FILS ** ** PURPOSE: TO CLOSE BOTH THE INPUT AND OUTPUT FILES ** ** INVOCATION METHOD: CLOS_FILS(FPI,FPO) ** ** ARGUMENT LIST: ** NAME TYPE USE DESCRIPTION ** FPI PTR I FILE POINTER TO INPUT FILE ** FPO PTR I FILE POINTER TO OUTPUT FILE ** CLOS_FILS() LOGICAL O RETURN STATUS ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** END123FILE() CLOSES A DATA FILE ** ** INTERNAL VARIABLES: NONE ** ** GLOBAL REFERENCES: NONE ** ** GLOBAL VARIABLES: NONE ** ** GLOBAL CONSTANTS: NONE ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** L. MCMILLION 02/11/91 INITIAL PROLOG ** L. MCMILLION 02/11/91 INITIAL PDL ** L. MCMILLION 02/11/91 INITIAL CODE ** ** PDL: #70*$$Ԍ** ** CALL END123FILE() TO CLOSE THE INPUT FILE ** IF END123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** CALL END123FILE() TO CLOSE THE OUTPUT FILE ** IF END123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** ** RETURN SUCCESS ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ int clos_fils(fpi,fpo) FILE *fpi; FILE *fpo; { /* CALL END123FILE() FOR INPUT FILE */ if (!end123file(&fpi)) printf("%s\n","Unable to close input file"); /* CALL END123FILE() FOR OUTPUT FILE */ if (!end123file(&fpo)) printf("%s\n","Unable to close output file"); /* RETURN SUCCESS */ return(1); } .80*$$  tT ph# tT #dp@>pQWm@#` (#HSAMPRG3B.C Eh#dp@>pQWm@#E.4.4` ` Sample Program 3B (SAMPRG3B.C) Source Code#d6X@J'@# *************************************************************************** ** ** INVOCATION NAME: SAM123PRG3B ** ** PURPOSE: TO RETRIEVE INFORMATION FOR RECORDS, FIELDS, ** AND SUBFIELDS AT CURRENT AND NEXT ACCESS: ** ** CHK123REC ** CHK123FLD ** CHK123SFLD ** CHK123NREC ** CHK123NFLD ** CHK123NSFLD ** ** INVOCATION METHOD: SAMPRG3B ** ** ARGUMENT LIST: NONE ** ** EXTERNAL FUNCTION REFERENCES: ** NAME DESCRIPTION ** BAK123FLD() BACKS UP TO BEGINNING OF LAST FIELD READ OR WRITTEN ** BAK123REC() BACKS UP TO BEGINNING OF LAST RECORD READ OR WRITTEN ** BAK123SFLD() BACKS UP TO BEGINNING OF LAST SUBFIELD READ OR WRITTEN ** BEG123FILE() OPENS A DATA FILE AND PERFORM ANY NECESSARY OVERHEAD ** CHK123FLD() GETS DESCRIPTION FOR LAST READ FIELD ** CHK123NFLD() GETS DESCRIPTION OF NEXT FIELD TO READ OR WRITE ** CHK123NREC() GETS DESCRIPTION OF NEXT RECORD TO READ OR WRITE ** CHK123NSFLD() GETS DESCRIPTION OF NEXT SUBFIELD TO READ OR WRITE ** CHK123REC() GETS DESCRIPTION FOR LAST READ RECORD ** CHK123SFLD() GETS DESCRIPTION FOR LAST READ SUBFIELD ** END123FILE() CLOSES A DATA FILE ** RD123DDREC() READS THE NEXT DATA DESCRIPTIVE RECORD ** RD123FLD() READS THE NEXT FIELD ** RD123REC() READS THE NEXT RECORD ** RD123SFLD() READS THE NEXT SUBFIELD ** ** INTERNAL VARIABLES: ** NAME TYPE DESCRIPTION ** BK_STAT INT BACK UP STATUS INDICATOR ** 0 = FAILURE ** 1 = OKAY ** 2 = START OF RECORD ** 3 = END OF RECORD ** 4 = END OF FILE ** 5 = END OF FIELD ** 6 = START OF FIELD ** BYTLEN INT NUMBER OF CHARACTERS IN STRING ** CCS[4] CHAR CODE CHARACTER SET INDICATOR ** DR_CNT INT DATA RECORD COUNTER ** FDCNTRL[10] CHAR FIELD CONTROL ** FDLEN[10] CHAR FIELD LENGTH ** FDNAME[] PTR FIELD NAME$90*$$Ԍ** FNIN[100] CHAR FILE NAME FOR INPUT FILE ** FNREP[100] CHAR FILE NAME FOR OUTPUT REPORT FILE ** FPIN PTR FILE POINTER FOR INPUT FILE (SDTS FORMAT) ** FPREP PTR FILE POINTER FOR OUTPUT REPORT FILE ** ICE CHAR INLINE CODE EXTENSION INDICATOR ** INT_LEVEL INT INTERCHANGE LEVEL ** LEADID CHAR LEADER IDENTIFIER ** PRV_STAT INT PREVIOUS READ STATUS INDICATOR (SAME VALUE ** RANGE AS BACK UP STATUS) ** RECLEN INT RECORD LENGTH ** STATUS INT READ STATUS INDICATOR (SAME VALUE RANGE AS ** BACK UP STATUS) ** TAG[10] CHAR INTERNAL NAME OF AN ASSOCIATED FIELD ** ** GLOBAL REFERENCES: ** NAME TYPE DESCRIPTION ** DESCR[5000] CHAR DESCRIPTION OF A RECORD, FIELD, OR SUBFIELD ** FRMTS[500] CHAR FORMAT STRING ** LABLS[500] CHAR LABELS STRING ** STRING[5000] CHAR RECORD, FIELD, OR SUBFIELD READ ** ** GLOBAL CONSTANTS: ** NAME TYPE DESCRIPTION ** RAND_DR INT RANDOM DATA RECORD NUMBER ** ** CHANGE HISTORY: ** AUTHOR CHANGE_ID DATE CHANGE SUMMARY ** P. HODGES 05/24/90 INITIAL PROLOG ** P. HODGES 05/24/90 INITIAL PDL ** P. HODGES 07/03/90 INITIAL CODE ** L. MCMILLION 02/11/91 MODIFIED CODE TO REFLECT CHANGES ** IN FUNCTIONS SINCE INITIAL DESIGN ** OF TEST PROGRAM ** J. TAYLOR 92DR005 06/04/92 CHANGED CALLING SEQUENCES FOR BINARY ** HANDLING FUNCTIONS ** L. MCMILLION TASK #40 12/23/92 UPDATED PROLOG PER QC ** ** PDL: ** ** INITIALIZE DR COUNTER TO ZERO ** PROMPT USER FOR NAME OF INPUT FILE ** CALL BEG123FILE() FOR INPUT FILE ** IF BEG123FILE() FAILED ** THEN ** PRINT ERROR MESSAGE ** ENDIF ** PROMPT USER FOR NAME OF OUTPUT REPORT FILE ** OPEN OUTPUT REPORT FILE ** IF CAN NOT OPEN OUTPUT REPORT FILE ** THEN ** CALL END123FILE() TO CLOSE INPUT FILE ** ENDIF ** ** CALL RD123DDREC() TO READ DATA DESCRIPTIVE RECORD ** WRITE DATA DESCRIPTIVE RECORD TO OUTPUT REPORT FILE **#:0*$$Ԍ** INITIALIZE READ STATUS TO OUT OF BOUNDS ** WHILE NOT END OF INPUT FILE DO ** INCREMENT DR COUNTER ** CALL RD123REC() TO READ A DATA RECORD ** WRITE DATA RECORD TO OUTPUT REPORT FILE ** CALL CHK123REC() TO RETRIEVE RECORD DESCRIPTION ** WRITE DESCRIPTION TO OUTPUT REPORT FILE ** ** IF DATA RECORD COUNTER IS A MULTIPLE OF RANDOM DATA RECORD NUMBER ** THEN ** CALL CHK123NREC() TO RETRIEVE NEXT RECORD DESCRIPTION ** WRITE NEXT RECORD DESCRIPTION TO OUTPUT REPORT FILE ** CALL BAK123REC() TO BACK UP TO BEGINNING OF RECORD ** RESET READ STATUS TO OUT OF BOUNDS ** WHILE NOT END OF RECORD NOR END OF FILE DO ** CALL RD123FLD() TO READ A DATA RECORD FIELD ** WRITE DATA RECORD FIELD TO OUTPUT REPORT FILE ** CALL CHK123FLD() TO RETRIEVE FIELD DESCRIPTION ** WRITE FIELD DESCRIPTION TO OUTPUT REPORT FILE ** RELEASE DYNAMICALLY ALLOCATED FIELD NAME ** CALL CHK123NFLD() TO RETRIEVE NEXT FIELD DESCRIPTION ** WRITE NEXT FIELD DESCRIPTION TO OUTPUT REPORT FILE ** RELEASE DYNAMICALLY ALLOCATED FIELD NAME ** CALL BAK123FLD() TO BACK UP TO BEGINNING OF FIELD ** RESET READ STATUS TO OUT OF BOUNDS ** WHILE NOT END OF FIELD, NOR END OF RECORD, NOR EOF DO ** SET PREVIOUS READ STATUS TO READ STATUS ** CALL RD123SFLD() TO READ SUBFIELD ** IF PREVIOUS READ STATUS IS START OF RECORD ** THEN ** IF READ STATUS IS START OF RECORD, OR START OF FIELD, ** OR END OF FIELD ** THEN ** CALL BAK123SFLD() TO BACK UP TO BEGINNING OF LAST ** SUBFIELD READ ** CALL BAK123SFLD() TO BACK UP TO BEGINNING OF PREVIOUS ** SUBFIELD ** CALL RD123SFLD() TO READ SUBFIELD ** SET READ STATUS TO END OF FIELD ** ENDIF ** ELSE SAME FIELD ** WRITE SUBFIELD TO OUTPUT REPORT FILE ** CALL CHK123SFLD() TO RETRIEVE SUBFIELD DESCRIPTION ** WRITE SUBFIELD DESCRIPTION TO OUTPUT REPORT FILE ** CALL CHK123NSFLD() TO RETRIEVE NEXT SUBFIELD DESCRIPTION ** WRITE NEXT SUBFIELD DESCRIPTION TO OUTPUT REPORT FILE ** ENDIF ** ENDWHILE ** ENDWHILE ** ENDIF ** ENDWHILE ** ** CALL END123FILE() FOR INPUT FILE ** CLOSE OUTPUT REPORT FILE ** ** STOP#;0*$$Ԍ** END ** ****************************************************************************** ** CODE SECTION ** ******************************************************************************/ #include "stc123.h" #define RAND_DR 17 /* GLOBAL DECLARATIONS */ char descr[5000]; char frmts[500]; char labls[500]; char string[5000]; int main(void) { FILE *fpin; FILE *fprep; char ccs[4]; char fdcntrl[10]; char fdlen[10]; char *fdname; char fnin[100]; char fnrep[100]; char ice; char leadid; char tag[10]; int bk_stat; int prv_stat; int status; long bytlen; long dr_cnt = 0; long int_level; long reclen; /* PROMPT USER FOR NAME OF INPUT FILE */ printf("%s\n","ENTER input file name:"); scanf("%s",fnin); /* CALL BEG123FILE() FOR INPUT FILE */ if (!beg123file(fnin,'R',&int_level,&ice,ccs,&fpin)) { printf("%s\n","Unable to open input file; processing terminated"); exit(1); } /* PROMPT USER FOR NAME OF OUTPUT REPORT FILE */ printf("%s\n","ENTER output report file name:"); scanf("%s",fnrep); /* OPEN OUTPUT REPORT FILE */ if ((fprep = fopen(fnrep,"w")) == NULL) { printf("%s%s\n","Unable to open output report file; ",#<0*$$Ԍ "processing terminated"); /* CALL END123FILE() TO CLOSE INPUT AND OUTPUT FILES */ if (!end123file(&fpin)) printf("%s\n","Unable to close input file"); exit(1); } /* CALL RD123DDREC() TO READ DATA DESCRIPTIVE RECORD */ if (!rd123ddrec(fpin,string,&status)) { printf("%s%d\n","Unable to read Data Descriptive Record; STATUS = ", status); exit(1); } /* WRITE DATA DESCRIPTIVE RECORD TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* DDR = ",string); /* INITIALIZE READ STATUS TO OUT OF BOUNDS */ status = -1; /* WHILE NOT END OF INPUT FILE DO */ while (status != 4) { /* INCREMENT DR COUNTER */ ++dr_cnt; fprintf(fprep,"\n%s\n","************ START OF RECORD"); /* CALL RD123REC() TO READ A DATA RECORD */ if(!rd123rec(fpin,string,&bytlen,&status)) { printf("%s%d\n","Unable to read Data Record; STATUS = ",status); exit(1); } /* WRITE DATA RECORD TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n\n","* DR = ",string); /* CALL CHK123REC() TO RETRIEVE RECORD DESCRIPTION */ if (!chk123rec(fpin,&reclen,&leadid,descr)){ printf("%s\n","Unable to retrieve input Data Record description"); exit(1); } /* WRITE DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* RECORD DESCRIPTION = ",descr); fprintf(fprep,"%s%ld\n","* RECORD LENGTH = ",reclen); fprintf(fprep,"%s%c\n","* LEADER IDENTIFIER = ",leadid); /* IF DATA RECORD NUMBER IS A MULTIPLE OF RANDOM DATA RECORD NUMBER */ if (!(dr_cnt % RAND_DR)) { /* CALL CHK123NREC() TO RETRIEVE NEXT RECORD DESCRIPTION */ if (!chk123nrec(fpin,&reclen,&leadid,descr)){#=0*$$Ԍ printf("%s%s\n","Unable to retrieve next input Data Record ", "description"); exit(1); } /* WRITE NEXT RECORD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"\n%s%s\n","* NEXT RECORD DESCRIPTION = ",descr); fprintf(fprep,"%s%ld\n","* NEXT RECORD LENGTH = ",reclen); fprintf(fprep,"%s%c\n\n","* NEXT LEADER IDENTIFIER = ",leadid); /* CALL BAK123REC() TO BACK UP TO BEGINNING OF RECORD */ if (!bak123rec(fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one Data Record within the ", "input file; STATUS = ",bk_stat); exit(1); } /* RESET READ STATUS TO OUT OF BOUNDS */ status = -1; /* WHILE NOT END OF RECORD NOR END OF FILE DO */ while (status != 3 && status != 4) { fprintf(fprep,"%s\n","****** START OF FIELD "); /* CALL RD123FLD() TO READ A DATA RECORD FIELD */ if (!rd123fld(fpin,tag,&leadid,string,&bytlen,&status)){ printf("%s%d\n","Unable to read DR field; STATUS = ",status); exit(1); } /* WRITE DATA RECORD FIELD TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* DR FIELD = ",string); /* CALL CHK123FLD() TO RETRIEVE FIELD DESCRIPTION */ if (!chk123fld(fpin,tag,fdlen,&fdname,fdcntrl,frmts,labls)){ printf("%s\n","Unable to retrieve input DR field description"); exit(1); } /* WRITE FIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* FIELD TAG = ",tag); fprintf(fprep,"%s%s\n","* FIELD LENGTH = ",fdlen); fprintf(fprep,"%s%s\n","* FIELD NAME = ",fdname); fprintf(fprep,"%s%s\n","* FIELD CONTROL = ",fdcntrl); fprintf(fprep,"%s%s\n","* FIELD LABELS = ",labls); fprintf(fprep,"%s%s\n\n","* FIELD FORMATS = ",frmts); /* RELEASE DYNAMICALLY ALLOCATED FIELD NAME */ free(fdname); /* CALL CHK123NFLD() TO RETRIEVE NEXT FIELD DESCRIPTION */ if (!chk123nfld(fpin,tag,fdlen,&fdname,fdcntrl,frmts,labls)){#>0*$$Ԍ printf("%s%s\n","Unable to retrieve next input DR field ", "description"); exit(1); } /* WRITE NEXT FIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* NEXT FIELD TAG = ",tag); fprintf(fprep,"%s%s\n","* NEXT FIELD LENGTH = ",fdlen); fprintf(fprep,"%s%s\n","* NEXT FIELD NAME = ",fdname); fprintf(fprep,"%s%s\n","* NEXT FIELD CONTROL = ",fdcntrl); fprintf(fprep,"%s%s\n","* NEXT FIELD LABELS = ",labls); fprintf(fprep,"%s%s\n\n","* NEXT FIELD FORMATS = ",frmts); /* RELEASE DYNAMICALLY ALLOCATED FIELD NAME */ free(fdname); /* CALL BAK123FLD() TO BACK UP TO BEGINNING OF FIELD */ if (!bak123fld(fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR field within the ", "input file; STATUS = ",bk_stat); exit(1); } /* RESET READ STATUS TO OUT OF BOUNDS */ status = -1; fprintf(fprep,"%s\n","*** START OF SUBFIELDS"); /* WHILE NOT END OF FIELD, NOR END OF RECORD, NOR EOF DO */ while (status != 5 && status != 3 && status != 4) { /* SET PREVIOUS READ STATUS TO READ STATUS */ prv_stat = status; /* CALL RD123SFLD() TO READ SUBFIELD */ if(!rd123sfld(fpin,tag,&leadid,string,&bytlen,&status)) { printf("%s%d\n","Unable to read DR subfield; STATUS = ", status); exit(1); } /* IF PREVIOUS READ STATUS IS START OF RECORD */ if (prv_stat == 2) { /* IF READ STATUS IS START OF RECORD, OR START OF FIELD, OR END OF FIELD */ if (status == 2 || status == 6 || status == 5) { /* CALL BAK123SFLD() TO BACK UP TO BEGINNING OF LAST SUBFIELD READ */ if (!bak123sfld(fpin,&bk_stat)) { #?0*$$Ԍ printf("%s%s%d\n","Unable to backup one DR ", "subfield within the input file; STATUS = ",bk_stat); exit(1); } /* CALL BAK123SFLD() TO BACK UP TO BEGINNING OF PREVIOUS SUBFIELD */ if (!bak123sfld(fpin,&bk_stat)) { printf("%s%s%d\n","Unable to backup one DR ", "subfield within the input file; STATUS = ",bk_stat); exit(1); } /* CALL RD123SFLD() TO READ SUBFIELD */ if(!rd123sfld(fpin,tag,&leadid,string,&bytlen,&status)) { printf("%s%s%d\n","Unable to read DR subfield; ", "STATUS = ",status); exit(1); } /* SET STATUS TO END OF FIELD */ status = 5; } } /* ELSE SAME FIELD */ else { /* WRITE SUBFIELD TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* DR SUBFIELD = ",string); /* CALL CHK123SFLD() TO RETRIEVE SUBFIELD DESCRIPTION */ if (!chk123sfld(fpin,tag,descr,frmts)){ printf("%s%s\n","Unable to retrieve input DR subfield", " description"); exit(1); } /* WRITE SUBFIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* SUBFIELD TAG = ",tag ); fprintf(fprep,"%s%s\n","* SUBFIELD DESCRIPTION = ",descr); fprintf(fprep,"%s%s\n\n","* SUBFIELD FORMAT = ",frmts ); /* CALL CHK123NSFLD() TO RETRIEVE NEXT SUBFIELD DESCRIPTION */ if (!chk123nsfld(fpin,tag,descr,frmts)){ printf("%s%s\n","Unable to retrieve next input DR ", "subfield description"); exit(1);#@0*$$Ԍ } /* WRITE NEXT SUBFIELD DESCRIPTION TO OUTPUT REPORT FILE */ fprintf(fprep,"%s%s\n","* NEXT SUBFIELD TAG = ",tag ); fprintf(fprep,"%s%s\n","* NEXT SUBFIELD DESCR. = ",descr); fprintf(fprep,"%s%s\n\n","* NEXT SUBFIELD FORMAT = ",frmts ); } } } } } /* CALL END123FILE() FOR INPUT FILE */ if (!end123file(&fpin)){ printf("%s\n","Unable to close input file"); exit(1); } /* CLOSE OUTPUT REPORT FILE */ if (fclose(fprep)) { printf("%s\n","Unable to close output report file"); exit(1); } /* STOP/EXIT */ return(1); }