Professional Documents
Culture Documents
Introduction to Subfiles Basically subfiles are display-file-concept. Whenever we have to display some tabular data we have two options Define as many required fields Here, We can define as many fields as we wish to display at a time. For example if we have to display 15 sets of customer number, customer name at a time, total 30 fields need to be defined. Each field with unique name so the names of fields of screen would typically be $CusNam1, $CusName2....$CusName15. Similarly the customer numbers. This much is fine, we can handle it very easily. But what if the number of rows the table is too large say 1500 instead of 15. In that situation the programming will become a mess!. Use Subfiles Subfiles in a sense are display physical file, with several limitations. However, subfiles do free you up from defining innumerable fields. In the case discussed above, you need to define only two fields $CusName and $CusNo. That's all. Few of the limitations of subfiles as compared to physical files are as under
Subfiles are not objects. They are not files where you store data permanently. A maximum 9999 records can be written to a subfile at a time. A subfile can be used to store data only during runtime. You end the program you clear the subfile data. Several PF opcodes will not work with subfiles. Only READC and CHAIN and UPDATE are allowed opcodes. Subfiles can be CHAINed using record numbers only. You can not DELETE any subfile record. You can only UPDATE it. You need to remove it from subfile, you have to clear the subfile and reload all the records minus the delete record.
Some points in the above discussion might seem foreing to you. But do not mind you will learn each of them when you read the EDITABLE subfiles. Anyway this much is good for starting!
How subfiles are handled in ILE RPG IV Subfile processing in ILE RPG IV is a two step process. 1. Loading the subfile: First of all a subfile needs to be loaded before it can be further used in an ILE RPG IV program. By loading we mean adding records to subfile by explicitly WRITEing to the subfile. (There are certain conditions where you can achieve writing in some other way by using SFLINZ keyword.) 2. Displaying the subfile: Once a subfile is loaded with records you are free to use it. The subfile once loaded is ready to be displayed. Display part is important because we have to do lots of work when we process the user inputs. Hence by displaying a subfile we will mean that processing the user inputs. After all their is nothing difficult if we would have to just display a subfile! (EXFMT control Format. That's all!) Types of subfiles Before learning anything else let us learn the types of subfiles. We will learn the subfile concepts of these types one by one. 1. Load all Subfile: All records (Upto 9999) are loaded into subfiles at a time. 2. Expandable Subfile: Records, fitting one page in number, are loaded at a time. They are added to the already loaded records of the subfile. 3. Single Page Subfile: Only that many records are loaded at time which can fit on a sinble page. These records are cleared whenever new records are loaded.
Subfile Terminology
Subfiles structure, Anatomy of a subfile A subfile basically has two parts (Two record Formats) 1. Control Format: As the name suggests, a control format is the record format which controls the behavior of the subfile which it controls. Once control format can be associated with subfile record format only. The control format typically controls the Page size, Subfile Size, Function key definitions, Display control etc. and some optional features like + or More... sign when there're more records in a subfile. 2. Subfile Record Format: A subfile record format consists of the iterating fields. That's all those tabular fields are defined inside the subfile record format. Having known a little about subfiles, let us see a sample record format source of a subfile. Example of a typical subfile of a Display file Basic terms of a subfile Page Size: Page size of a subfile is the number of records which are to be displayed at a time. The page number is specified in the control format of a subfile by keyword SFLPAGE as you can see in the example above. Subfile Size: Subfile size is the initial number of records which are to be loaded in the subfile. The subfile size is specified by SFLSIZ keyword. The numbers of records specified by the subfile size are loaded in contiguous memory location. You may load more records than you specify in subfile size (Upto 9999) however they will not be contiguously placed in memory. Contiguous memory placement of subfile records results in higher performance. ROLLUP: At any time only a limited number of records are displayed on the screen. In a subfile the maximum number of records displayed is equal to the page size of subfile. To view next records we have to press the ROLLUP key. This key sometimes is "Page Up" and sometimes "Page Down". ROLLUP is a keyword also which is defined in control format of a subfile and marks the expandable subfile when defined without ROLLDOWN. ROLLDOWN: To view the previous records after pressing the ROLLUP key, we press the ROLLDOWN key. ROLLDOWN is a keyword also, its explicitly defined in Single Page subfiles along with ROLLUP keyword in control format.
The source code with explanation of the ILE RPG program to process the load all subfile in the above example is given below.
** **Declare the display file which contains the subfile ** FFilename++IPEASF.....L.....A.Device+.Keywords+++++++++++++++++++++++ FLOAD_ALL CF E WorkStn ** ** Declare the relative record number (RRN) for the subfile. Notice ** the keyword used to declare subfile. ** F SFILE(LOADALLSF:W@Rrn1) ** ** Define the RRN of subfile (Typically 4 or 5 length with zero ** decimal places depending on how you handle it. If it's likely to ** reach 10000 then declare the length as 5 otherwise 4.) ** DW@Rrn1 S 4 0 Inz ** CL0N01Factor1+++++++Opcode&ExtExtended-factor2++++++++++++ C DoW *INKA = *Off ** ** Execute subroutine to load the subfile ** C ExSr #LodSfl ** ** ExFmt the CONTROL FORMAT of the subfile. ** C ExFmt LOADALLCF C EndDo ** ** Free up resources and return ** C Eval *InLr = *On C Return ** ** The subroutine #LODSFL ** C #LODSFL BegSr ** ** Clear the subfile. Clearing a subfile involves the following four ** statements. ** 1. Swicth on the SFLCLR indicator ** 2. Write to the control format ** 3. Swicth off the SFLCLR indicator ** 4. Reset the RRN to zero (Or one). ** The fourth statement actually is not related to subfile. However, ** we generally reset this value while clearing the subfile itself. ** C Eval *In(50) = *On C Write LOADALLCF C Eval *In(50) = *Off C Eval W@Rrn1 = *Zeros ** ** Set a looping condition. This condition may be based on anything.
** But in any case just ensure that RRN does not exceed 9999. ** C DoW W@Rrn1 < 9999 ** ** Increment the RRN to mark a new record of subfile. Remember that ** the variable corresponding to RRN should not be less than one (1) a ** nd it should never exceed 9999. ** C Eval W@Rrn1 += 1 ** ** Populate the fields defined in the subfiles. To load a blank subfil ** e we can just intialize the subfile fields. ** C Eval $CusNo = W@Rrn1 ** ** Perform actual write to the subfile. Notice that each write actuall ** y adds a record to the subfile. ** C Write LOADALLSF C EndDo ** C EndSr
R EXPANDCF SFLCTL(EXPANDSF) ** ** Function keys are defined in the record format. ** A CA01 A CA05 ** ** Declare the page size and subfile size ** A SFLPAG(15) A SFLSIZ(16) ** ** Declare the function SFLCLR. We need this function to clear a ** subfile. ** A 50 SFLCLR ** ** The SFLDSP and SFLDSPCTL functions are necessary to display ** subfile. ** A SFLDSP A SFLDSPCTL ** ** Declare the ROLLUP key. The number inside the bracket is the ** indicator which would be set on when ROLLUP key has been press ** ed. ** A ROLLUP(60) ** ** The SFLRCDNBR is the subfile record number. SFLRCDNBR is a ** hidden filed. This is used here to display the last page ** whenever a new page is loaded. The name and data type of this ** field has been kept same as the RRN of this subfile in the ** program. This ensures that we do not have to explicitly populate ** this field. This field automatically contains the last RRN ** of the subfile which always would be on the last page. ** Caution: SFLRCDNBR variable can not be zero, so ensure that ** you do not display the subfile when it is zero. ** A W@RRN1 4 0H SFLRCDNBR ** ** Define the control format fields. Generally the heading and ** subfile specific instructions are given here. ** A 1 26' Customer Display ' A DSPATR(RI) A 2 02'F1=Exit F5=Refresh' A 4 02'Id' A DSPATR(UL) A 4 10'Customer Name' A DSPATR(UL)
/**** The program to process the above subfile. Currently only one field is being populated ***/
**
** Declare the display file which contains the expandable subfile ** FFilename++IPEASF.....L.....A.Device+.Keywords+++++++++++++++++++++++ FEXPANDSFL CF E WorkStn ** ** Declare the relative record number (RRN) for the subfile. Notice ** the keyword used to declare subfile. ** F SFILE(EXPANDSF:W@Rrn1) ** ** Define the RRN of subfile (Typically 4 or 5 length with zero ** decimal places depending on how you handle it. If it's likely to ** reach 10000 then declare the length as 5 otherwise 4.) ** DW@Rrn1 S 4 0 Inz ** ** Define a couter variable to keep track of number of record ** to subfile at any time. ** DW@Counter S 2 0 Inz ** ** Execute subroutine to clear the subfile. The subfile is to ** ed everytime the screen is refreshed. ** CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len+ C ExSr #ClrSfl ** ** Load the first page of the subfile. ** C ExSr #LodSfl ** C DoW *INKA = *Off ** ** ExFmt the CONTROL FORMAT of the subfile. ** C ExFmt ExpandCF ** C Select C When *INKE = *On ** ** Execute subroutine to load the subfile after clearing it. ** C ExSr #ClrSfl C ExSr #LodSfl ** C When *In(60) = *On ** ** Execute subroutine to load the next page of subfile. ** C ExSr #LodSfl C EndSl ** C EndDo ** ** Free up resources and return ** C Eval *InLr = *On
Return ** ** The subroutine #LODSFL ** ** C #CLRSFL BegSr ** ** Clear the subfile. Clearing a subfile involves the following four ** statements. ** 1. Swicth on the SFLCLR indicator ** 2. Write to the control format ** 3. Swicth off the SFLCLR indicator ** 4. Reset the RRN to zero (Or one). ** C Eval *In(50) = *On C Write ExpandCF C Eval *In(50) = *Off C Eval W@Rrn1 = *Zeros C EndSr C #LODSFL BegSr ** ** Reset the counter ** C Eval W@Counter = *Zeros ** ** Set a looping condition. This condition this time will be based on ** the page size. You can club it with any other condition you require ** However, the number of records loaded at a time should ideally not ** exceed the page size. ** C DoW W@Counter < 15 ** ** Increment the counter to keep track of number of record written at ** a time to the subfile. This count should not exceed the page size. ** C Eval W@Counter += 1 ** ** Increment the RRN to mark a new record of subfile. Remember that ** the variable corresponding to RRN should not be less than one (1) a ** nd it should never exceed 9999. You may add a check here to confirm ** that the RRN is within the valid range. ** C Eval W@Rrn1 += 1 ** ** Populate the fields defined in the subfiles. To load a blank subfil ** e we can just intialize the subfile fields. ** C Eval $CusNo = W@Rrn1 ** ** Perform actual write to the subfile. Notice that each write actuall ** y adds a record to the subfile. ** C Write ExpandSF C EndDo ** C EndSr
** Declare the function SFLCLR. We need this function to clear a ** subfile. ** A 50 SFLCLR ** ** The SFLDSP and SFLDSPCTL functions are necessary to display ** subfile. ** A SFLDSP A SFLDSPCTL ** ** Declare the ROLLUP key. The number inside the bracket is the ** indicator which would be set on when ROLLUP key has been press ** ed. ** A ROLLUP(60) ** ** Declare the ROLLDOWN key. The number inside the bracket is the ** indicator which would be set on when ROLLDOWN key has been press ** ed. ** A ROLLDOWN(61) ** ** The SFLRCDNBR is the subfile record number. SFLRCDNBR is a ** hidden filed. This is used here to display the last page ** whenever a new page is loaded. The name and data type of this ** field has been kept same as the RRN of this subfile in the ** program. This ensures that we do not have to explicitly popula ** te this field. This field automatically contains the last RRN ** of the subfile which always would be on the last page. ** Caution: SFLRCDNBR variable can not be zero, so ensure that ** you do not display the subfile when it is zero. ** A W@RRN1 4 0H SFLRCDNBR ** ** Define the control format fields. Generally the heading and ** subfile specific instructions are given here. ** A 1 26' Customer Display ' A DSPATR(RI) A 2 02'F1=Exit F5=Refresh' A 4 02'Id' A DSPATR(UL) A 4 10'Customer Name' A DSPATR(UL)
The RPG IV (ILE RPG) program which processes the above subfile is given below. Notice that the function key F5 to refresh the page (Meaning reloading the subfile from beginning) has not been implemented. You can try it as an excercise.
** ** Declare the display file which contains the SINGLE PAGE subfile **
FFilename++IPEASF.....L.....A.Device+.Keywords++++++++++++++++++++++ FSingleSFL CF E WorkStn ** ** Declare the relative record number (RRN) for the subfile. Notice ** the keyword used to declare subfile. ** F SFILE(SINGLESF:W@Rrn1) ** ** Define the RRN of subfile (Typically 4 or 5 length with zero ** decimal places depending on how you handle it. If it's likely to ** reach 10000 then declare the length as 5 otherwise 4.) ** DW@Rrn1 S 4 0 Inz ** ** Define a couter variable to keep track of number of records written ** to subfile at any time. ** DW@Counter S 2 0 Inz ** ** Define the variable to store the last displayed value ** DW@LastVal S 4 0 Inz ** ** Load the first page of the subfile. ** CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len++D+HiLoEq C ExSr #NextPage ** C DoW *INKA = *Off ** ** ** ExFmt the CONTROL FORMAT of the subfile. ** C ExFmt SINGLECF ** C Select ** ** Indicator 60 is set on by the as400 system when ROLLUP is pressed ** C When *In(60) = *On ** ** Execute subroutine to load the next page of subfile ** C ExSr #NextPage ** ** Indicator 60 is set on by the as400 system when ROLLDOWN is pressed ** C When *In(61) = *On ** ** Execute subroutine to load the next page of subfile, if this is not ** the first page of the subfile. ** C If W@LastVal > 15 C ExSr #PrevPage C EndIf ** C EndSl
EndDo ** ** Free up resources and return ** C Eval *InLr = *On C Return ** ** The subroutine #CLRSFL to clear the subfile and reset the RRN ** C #CLRSFL BegSr ** ** Clear the subfile. Clearing a subfile involves the following four ** statements. ** 1. Swicth on the SFLCLR indicator ** 2. Write to the control format ** 3. Swicth off the SFLCLR indicator ** 4. Reset the RRN to zero (Or one). ** C Eval *In(50) = *On C Write SINGLECF C Eval *In(50) = *Off C Eval W@Rrn1 = *Zeros C EndSr ** ** Subroutine to process the ROLLUP key. ** C #NextPage BegSr ** ** The subfile is to be cleared every time a new page is loaded. ** C ExSr #ClrSfl ** ** Reset the counter ** C Eval W@Counter = *Zeros ** ** Set a looping condition. This condition will be based on the page ** size. You can club it with any other condition you require, However ** , the number of records loaded at a time should ideally not exceed ** the page size. ** C DoW W@Counter < 15 ** ** Increment the counter to keep track of number of record written at ** a time to the subfile. This count should not exceed the page size. ** C Eval W@Counter += 1 ** ** Increment the RRN to mark a new record of subfile. Remember that ** the variable corresponding to RRN should not be less than one (1) a ** nd it should never exceed 9999. You may add a check here to confirm ** that the RRN is within the valid range. ** C Eval W@Rrn1 += 1 ** ** In single page subfiles, the last and first values of a subfile are
**
** are very important to keep track of the records currently being ** displayed. Here, we are storing the last value only. We will subtr** act 15 to get the first record ** C Eval W@LastVal += 1 ** ** Populate the fields defined in the subfiles. To load a blank subfil ** e we can just intialize the subfile fields. ** C Eval $CusNo = W@LastVal ** ** Perform actual write to the subfile. Notice that each write actuall ** y adds a record to the subfile just like in case of any other type ** of subfile! ** C Write SINGLESF C EndDo C EndSr ** ** Load the previous page of the subfile. ** C #PrevPage BegSr ** ** The subfile is to be cleared every time a new page is loaded. ** C ExSr #ClrSfl ** ** Reset the counters, Retrieve the value of the first record of the ** subfile. Here we are sutracting the page size from the last value. ** This is OK here, but in practical situation where we do not have ** such straight-forward relationship we do the followings ** 1. Store the key values in variables each time the subfile is loded ** 2. Chain the first record of the subfile and retrieve the required ** value. ** C Eval W@Counter = 15 C Eval W@LastVal -= 15 ** C DoW W@Counter > 0 And W@LastVal > 0 ** C Eval W@Counter -= 1 ** C Eval W@Rrn1 += 1 ** ** Populate the fields defined in the subfiles. We populate the custom ** er number by the last displayed value - the RRN. ** C Eval $CusNo = W@LastVal - W@Counter ** ** Perform actual write to the subfile. Notice that each write actuall ** y adds a record to the subfile. ** C Write SINGLESF C EndDo ** C EndSr
CHAIN or READC. Off course using CHAIN requires more CPU time as you read the subfile record by record. Here is a few guidelines which you may find helpful to make up your mind. 1. Whenever possible use READC. This significantly reducess CPU time if the number of records in the subfile is in thousands. However, If you are not comfortable using READC. You can go for CHAIN. 2. Always use READC when you know beforehand that your users might not be directly connected to the AS400 server using LAN. If the application you are writing is to be used over internet, even a small fraction of time saved means a lot. 3. If you are not so comfortable with using READC and you do not expect your subfile to contain more than 100, 200 records. You can opt for CHAIN. 4. There are times when there are no alternative to CHAIN. Like when you decide to CHAIN the last record of the single page subfile to load the next page of subfile. However, use CHAIN as scarcly as possible. That's use CHAIN when you specifically know the record number(RRN) of the record you are interested in. Note:- Lots of programs in RPG III use CHAIN only. But we can almost always find an elegant alternative to CHAIN. Example of an Editable subfile Processing in RPG IV. OK, in the example below we will be using the same subfile DDS we have been using in our examples thruoghout this book. However, there will be a few modifications needed to make the subfile editable. For this, we change the field types to Both. In the example below, we will be using READC only. No CHAIN. This is to help you understand and RETAIN the concept of READC. We may write a separate program to demonstarate CHAIN for the sake of completion of subfile Tutorial. (And also for a few (very few in fact) cases where READC might not be used) Here is the source code of DDS of the subfile. The changes from a trivial subfile has been written in bold.
AAN01N02N03T.Name++++++RLen++TDpBLinPosFunctions+++++++++++++++++++ A R EDITSF SFL A 56 SFLNXTCHG ** ** Declare fields as we would do in case of normal record format. ** A $CUSNO 4Y 0B 5 02TEXT('Customer Number') A 30 DSPATR(RI PC) ** A $CUSNAME 20A B 5 10TEXT('Customer Name') A 31 DSPATR(RI PC) ** ** Control Format of the subfile. Notice the usage of function ** SFLCTL. The name of the subfile has been given here to associa
** this control format with a specific subfile. ** A R EDITCF SFLCTL(EDITSF) ** ** Function keys are defined in the record format. ** A CA01 A CA05 ** ** Declare the page size and subfile size ** A SFLPAG(15) A SFLSIZ(16) ** ** Declare the function SFLCLR. We need this function to clear a ** subfile. ** A 50 SFLCLR ** ** The SFLDSP and SFLDSPCTL functions are necessary to display ** subfile. This time the SFLDSP function is indicator based. This is ** to handle the situation when no record is loaded into the subfile. ** A 40 SFLDSP A SFLDSPCTL ** ** Declare the ROLLUP key. The number inside the bracket is the ** indicator which would be set on when ROLLUP key has been press ** ed. ** A ROLLUP(60) ** ** The SFLRCDNBR is required to display the last loaded screen. ** A W@RRN1 4 0H SFLRCDNBR ** ** Define the control format fields. Generally the heading and ** subfile specific instructions are given here. ** A 1 26' Customer Display ' A DSPATR(RI) A 2 02'F1=Exit F5=Refresh' A 4 02'Id' A DSPATR(UL) A 4 10'Customer Name' A DSPATR(UL)
About the program: This program is supposed to the followings. 1. Read a file and display all the availabe records in an expandable subfile. 2. The subfile is to be editable 3. The user will be allowed to change the values in the subfile record. Program will validate the changed records for blanks and zeros. 4. Program will reverse image the records in error.
5. All records will be updated at one go, when there are no errors in any of the changed records. For the time being we are not displaying the specific error messages. We will do that after we read the message subfiles and how to process messages in an RPG IV program. But... but... but... Before we go to the source code of the RPG IV program, let us learn the SFLNXTCHG function. SFLNXTCHG: This function is read as "Subfile next change"... indicator. Actually we associate an indicator with this function. This associtated indicator is set on by the AS400 system whenever, a subfile record is changed. Actually our READC reads only those subfile records for which the SFLNXTCHG indicator is set on. The READC operation set off this indicator. The SFLNXTCHG indicator is of extreme use when we are dealing a subfile with READC. This concept is actually all you should try to master. You learn the concept of SFLNXTCHG and you are done with subfiles! We can also force the AS/400 system to read a specific subfile record. We can achieve this by setting the indicator associated with any record to on. Another important point about SFLNXTCHG indicator, you can safely assume that for each subfile record we have a separate indicator. You can switch off or on this indicator as per your wish, but to associate an indicator's present value (On or Off) with any specific record, you need to UPDATE that subfile record. The UPDATE of subfile is exactly similar to that of a Physical file or logical file and hence to UPDATE a subfile you must have successfully read a record of that record (Using CHAIN or READC). Now, the actual program source,
** ** Declare the customer master file. ** FFilename++IPEASF.....L.....A.Device+.Keywords++++++++++++++++++++++ FCustMast UF E Disk ** FEDITABLESFCF E WorkStn ** ** Declare the relative record number (RRN) for the subfile. ** F SFILE(EDITSF:W@Rrn1) ** DW@Rrn1 S 4 0 Inz ** ** Variable to store the last RRN of the subfile (Maximum RRN). ** DName+++++++++++ETDsFrom+++To/L+++IDc.Keywords+++++++++++++++++++++++++
DW@LstRrn S 4 0 Inz ** ** Define a couter variable to keep track of number of records written ** to subfile at any time. ** DW@Counter S 2 0 Inz ** ** Indicator to indicate whether the first page is to be loaded. ** DW@FstPage S 1 Inz('1') ** ** Indicator to indicate whether the last record has been displayed. ** DW@LstRcd S 1 ** ** Error flag ** DW@Error S 1 Inz('N') ** ** Execute subroutine to clear the subfile. The subfile is to be clear ** ed everytime the screen is refreshed. ** C ExSr #ClrSfl ** ** Load the first page of the subfile. ** C ExSr #LodSfl ** C DoW *INKA = *Off ** ** ExFmt the CONTROL FORMAT of the subfile. ** C ExFmt EditCF CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len++D+ C Select C When *INKA = *On C Iter ** C When *INKE = *On ** ** Execute subroutine to load the subfile after clearing it. ** C ExSr #ClrSfl ** C Eval W@FstPage = *On ** C ExSr #LodSfl ** C When *In(60) = *On C If W@LstRcd = *Off ** ** Execute subroutine to load the next page of subfile. ** C ExSr #LodSfl C EndIf ** ** When enter has been pressed to update the database with screen
** values ** C C C C C C C C C C C C ** Other If ExSr If ExSr Eval ExSr ExSr EndIf EndIf EndSl EndDo W@Rrn1 > *Zeros #Validate W@Error <> 'Y' #Update W@FstPage = *On #ClrSfl #LodSfl
**
** ** ** **
C Eval *InLr = *On C Return ******************************************************************** ** ** The subroutine #LODSFL ** C #CLRSFL BegSr ** ** Clear the subfile. ** C Eval *In(50) = *On C Write EditCF C Eval *In(50) = *Off C Eval W@Rrn1 = *Zeros C Eval W@LstRrn = *Zeros C EndSr ********************************************************************* C #LODSFL BegSr ** ** Reset the counter ** C Eval W@Counter = *Zeros C Eval W@Rrn1 = W@LstRrn ** ** Set the cursor to read the first record of the physical file. If ** the subfile is to be loaded for the first time. ** C If W@FstPage = *On C 1 SetLl CustMast01 C Read CustMast01 90 C EndIf ** C DoW W@Counter < 15 And *In(90) = *Off ** ** Increment the counter to keep track of number of record written at ** a time to the subfile. This count should not exceed the page size. **
Eval W@Counter += 1 ** ** Increment the RRN to mark a new record of subfile. ** C Eval W@Rrn1 += 1 ** ** Populate the fields defined in the subfiles. ** C Eval $CusNo = CustNo C Eval $CusName = CustName ** ** Perform actual write to the subfile. Notice that each write actuall ** y adds a record to the subfile. ** C Write EditSF ** ** Read the next record from the physical file. ** C Read CustMast01 90 C EndDo ** ** The subfile is never to be displayed if no records are loaded into ** it. For this purpose, the SFLDSP indicator is set on only if some ** record has been written to it (W@Rrn1 > *Zeros). ** C If W@Rrn1 = *Zeros C Eval *In(40) = *Off C Else C Eval *In(40) = *On C EndIf ** C Eval W@LstRcd = *In(90) C Eval W@LstRrn = W@Rrn1 ** C EndSr *********************************************************************** C #Validate BegSr C Eval W@Error = 'N' C ReadC EDITSF 90 ** C DoW *In(90) = *Off ** C If $CusNo = *Zeros C Eval *In(30) = *On C Eval W@Error = 'Y' C EndIf ** C If $CusName = *Blanks C Eval *In(31) = *On C Eval W@Error = 'Y' C EndIf ** C Eval *In(56) = *On C Update EDITSF C Eval *In(30) = *Off C Eval *In(31) = *Off CL0N01Factor1+++++++Opcode&ExtFactor2+++++++Result++++++++Len++D+HiLoEq
C C
ReadC EndDo
EDITSF
90
** C EndSr *********************************************************************** C #Update BegSr C ReadC EDITSF 90 C DoW *In(90) = *Off C W@Rrn1 Chain CustMast01 C Eval CustNo = $CusNo C Eval CustName = $CusName C Update CustMast01 C ReadC EDITSF 90 C EndDo C EndSr ****************** End of data ****************************************