**********************************************************************                                                                                                                                                                                     
* COPYRIGHT 1995 THE UNIVERSITY OF DELAWARE. ALL RIGHTS RESERVED.                                                                                                                                                                                          
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *                                                                                                                                                                                      
*                                                                                                                                                                                                                                                          
* TITLE......: <MFU0015:EXAMPLE OF Mosaic forms                                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
* PROGRAMMER.: Fenimore,John        ORIG. PROG..: Fenimore,John                                                                                                                                                                                            
* LAST UPDATE: 07/06/95             DATE WRITTEN: April 1995                                                                                                                                                                                               
*                                                                                                                                                                                                                                                          
* USERVIEWS:                                                                                                                                                                                                                                               
* CALLS....: NATSVAL                                                                                                                                                                                                                                       
**********************************************************************                                                                                                                                                                                     
**     SUBPROGRAM MFU0015   use HTML to mosaic with a POST form                                                                                                                                                                                            
**                                                                                                                                                                                                                                                         
**     Use write(1) for debug info  and write(2) for logging                                                                                                                                                                                               
**     Improved answer parsing and storage   4/95                                                                                                                                                                                                          
**     Improved answer parsing for multi selection boxes  7/6/95                                                                                                                                                                                           
**                                                                                                                                                                                                                                                         
**  This routine uses multiple sends of 252 chars or less                                                                                                                                                                                                  
** Depending on what you are sending it maybe be more efficient                                                                                                                                                                                            
** to build bigger sends (up to the size of #SCRIPT) thereby                                                                                                                                                                                               
** sending less packets.                                                                                                                                                                                                                                   
**   1/25/95 - 2PM,IBM 600e - .03 CPU sec to recv request and send form                                                                                                                                                                                    
** .05 CPU sec to recv answer, process, and return answer to answer                                                                                                                                                                                        
** this does not include any CPU used by TCPIP address space                                                                                                                                                                                               
**                                                                                                                                                                                                                                                         
**                                                                                                                                                                                                                                                         
**     ASCII      CR = 0D   LF = 0A   TAB = 09  PERIOD = 2E                                                                                                                                                                                                
**     EBCDIC     CR = 0D   LF = 15   TAB = 05  PERIOD = 4B                                                                                                                                                                                                
**                                                                                                                                                                                                                                                         
 DEFINE DATA                                                                                                                                                                                                                                               
 PARAMETER                                                                                                                                                                                                                                                 
 1  #SCRIPT          (A1 / 1:4080)                                                                                                                                                                                                                         
 1  REDEFINE    #SCRIPT      /* max 17 a240 areas                                                                                                                                                                                                          
   2  #SCRIP01     (A252)    /* 252 make long text easier                                                                                                                                                                                                  
   2  #SCRIP02     (A252)                                                                                                                                                                                                                                  
   2  #SCRIP03     (A252)                                                                                                                                                                                                                                  
   2  #SCRIP04     (A252)                                                                                                                                                                                                                                  
   2  #SCRIP05     (A252)                                                                                                                                                                                                                                  
**                                                                                                                                                                                                                                                         
 1  REDEFINE   #SCRIPT                                                                                                                                                                                                                                     
   2  #LINE       (1:51)                                                                                                                                                                                                                                   
     3 #LTEXT      (A80)                                                                                                                                                                                                                                   
     3 REDEFINE #LTEXT                                                                                                                                                                                                                                     
       4 #LTEXT-78 (A78)                                                                                                                                                                                                                                   
       4 #NEWLINE  (A2)           /* NEWLINE CHAR OR #NULL FOR LAST                                                                                                                                                                                        
     3 REDEFINE #LTEXT                                                                                                                                                                                                                                     
       4 #LTEXT-CHAR  (A1/1:80)                                                                                                                                                                                                                            
**                                                                                                                                                                                                                                                         
 1 #DATAIN        (A128)         /* the 128 bytes after MFU####                                                                                                                                                                                            
**                                                                                                                                                                                                                                                         
 PARAMETER USING MFPDA2           /* 2/3/95  NATSVP stuff                                                                                                                                                                                                  
**                                                                                                                                                                                                                                                         
*********************************************************************                                                                                                                                                                                      
 LOCAL     USING MFLDA1                                                                                                                                                                                                                                    
**********************************************************************                                                                                                                                                                                     
 LOCAL                                                                                                                                                                                                                                                     
 1 #I             (N5)                                                                                                                                                                                                                                     
 1 #I1            (N5)                                                                                                                                                                                                                                     
 1 #JS            (N5)  /* 4/14/95  #script    subscript                                                                                                                                                                                                   
 1 #JA            (N5)  /* 4/14/95  #ans-datg  subscript                                                                                                                                                                                                   
 1 #JA-END        (N5)  /* 4/14/95  #ans-datg  end of field subscript                                                                                                                                                                                      
 1 #I3            (N5)  /* 7/6/95  used in  multi section                                                                                                                                                                                                  
 1 #K             (N5)                                                                                                                                                                                                                                     
 1 #I2            (N5)  /* used in  REPLACE-ASCIIHEX subroutine                                                                                                                                                                                            
 1 #IFLG1         (N1)  /* do/skip the bypass of POST stuff                                                                                                                                                                                                
***                                                                                                                                                                                                                                                        
* 1 #DQU          (A1) INIT <H'7F'> /* double quote in the LDA                                                                                                                                                                                             
***                                                                                                                                                                                                                                                        
 1  #DPARM         (A128)                                                                                                                                                                                                                                  
 1  REDEFINE #DPARM                                                                                                                                                                                                                                        
   2 #DPR          (A1 / 1:128)                                                                                                                                                                                                                            
 1  REDEFINE #DPARM                                                                                                                                                                                                                                        
   2  #DATSLASH    (A1)                                                                                                                                                                                                                                    
   2  #ANSNUM      (A8)    /*   ans####b  or frm####b   b=blank                                                                                                                                                                                            
   2  #ANSHTTP     (A8)    /*   HTTP/1.0                                                                                                                                                                                                                   
   2  #ANSCRLF     (A2)                                                                                                                                                                                                                                    
   2  #ANSDATA     (A1)                                                                                                                                                                                                                                    
   2  #ENTDATA     (A108)                                                                                                                                                                                                                                  
*                                                                                                                                                                                                                                                          
** 1  #ANS-DAT (A60 / 1:13)  /* old fixed length definition                                                                                                                                                                                                
**************************************************************                                                                                                                                                                                             
*                                                                                                                                                                                                                                                          
 1  #ANS-DAT-FIELD-LENGTHS                                                                                                                                                                                                                                 
   2  #ANS-FLEN-01    (N5)    INIT<60>                                                                                                                                                                                                                     
   2  #ANS-FLEN-02    (N5)    INIT<40>                                                                                                                                                                                                                     
   2  #ANS-FLEN-03    (N5)    INIT<70>                                                                                                                                                                                                                     
   2  #ANS-FLEN-04    (N5)    INIT<20>                                                                                                                                                                                                                     
   2  #ANS-FLEN-05    (N5)    INIT<10>                                                                                                                                                                                                                     
   2  #ANS-FLEN-06    (N5)    INIT<30>                                                                                                                                                                                                                     
   2  #ANS-FLEN-07    (N5)    INIT<15>                                                                                                                                                                                                                     
   2  #ANS-FLEN-08    (N5)    INIT<15>                                                                                                                                                                                                                     
   2  #ANS-FLEN-09    (N5)    INIT<15>                                                                                                                                                                                                                     
   2  #ANS-FLEN-10-1  (N5)    INIT<15>     /*  4/27/95                                                                                                                                                                                                     
   2  #ANS-FLEN-10-2  (N5)    INIT<15>     /*  multiple                                                                                                                                                                                                    
   2  #ANS-FLEN-10-3  (N5)    INIT<15>     /*  selection                                                                                                                                                                                                   
   2  #ANS-FLEN-10-4  (N5)    INIT<15>     /*  box                                                                                                                                                                                                         
   2  #ANS-FLEN-10-5  (N5)    INIT<15>     /*                                                                                                                                                                                                              
   2  #ANS-FLEN-10-6  (N5)    INIT<15>     /*                                                                                                                                                                                                              
   2  #ANS-FLEN-10-7  (N5)    INIT<15>     /*                                                                                                                                                                                                              
   2  #ANS-FLEN-10-8  (N5)    INIT<15>     /*                                                                                                                                                                                                              
   2  #ANS-FLEN-11    (N5)    INIT<240>  /* long text in multiples 240                                                                                                                                                                                     
   2  #ANS-FLEN-12-1  (N5)    INIT<15>     /*  7/6/95                                                                                                                                                                                                      
   2  #ANS-FLEN-12-2  (N5)    INIT<15>     /*  7/6/95                                                                                                                                                                                                      
   2  #ANS-FLEN-12-3  (N5)    INIT<15>     /*  7/6/95                                                                                                                                                                                                      
   2  #ANS-FLEN-12-4  (N5)    INIT<15>     /*  7/6/95                                                                                                                                                                                                      
** 2  #ANS-FLEN-12-5  (N5)    INIT<15>     /*  7/6/95  try 4 of 6                                                                                                                                                                                          
** 2  #ANS-FLEN-12-6  (N5)    INIT<15>     /*  7/6/95                                                                                                                                                                                                      
   2  #ANS-FLEN-13    (N5)    INIT<480>                                                                                                                                                                                                                    
   2  #ANS-FLEN-14    (N5)    INIT<720>                                                                                                                                                                                                                    
*                                                                                                                                                                                                                                                          
 1  REDEFINE #ANS-DAT-FIELD-LENGTHS                                                                                                                                                                                                                        
      2  #ANS-FLEN    (N5 / 1:24)                                                                                                                                                                                                                          
**************************************************************                                                                                                                                                                                             
 1  #ANS-DATG  (A1 / 1:3000)  /* MUST BE EXTRACTED FROM #SCRIPT                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
 1  REDEFINE #ANS-DATG                                                                                                                                                                                                                                     
   2  #ANS-LNAME    (A60)     /* over these limits truncated                                                                                                                                                                                               
   2  #ANS-FNAME    (A40)                                                                                                                                                                                                                                  
   2  #ANS-EMAIL    (A70)                                                                                                                                                                                                                                  
   2  #ANS-PAYMT    (A20)                                                                                                                                                                                                                                  
   2  #ANS-CALLF    (A10)                                                                                                                                                                                                                                  
   2  #ANS-PSIZE    (A30)                                                                                                                                                                                                                                  
   2  #ANS-CHES1    (A15)                                                                                                                                                                                                                                  
   2  #ANS-CHES2    (A15)                                                                                                                                                                                                                                  
   2  #ANS-CHES3    (A15)                                                                                                                                                                                                                                  
   2  #ANS-PTOPS1   (A15)        /*  4/27/95                                                                                                                                                                                                               
   2  #ANS-PTOPS2   (A15)        /*  multiple                                                                                                                                                                                                              
   2  #ANS-PTOPS3   (A15)        /*  selection                                                                                                                                                                                                             
   2  #ANS-PTOPS4   (A15)        /*  box                                                                                                                                                                                                                   
   2  #ANS-PTOPS5   (A15)        /*                                                                                                                                                                                                                        
   2  #ANS-PTOPS6   (A15)        /*                                                                                                                                                                                                                        
   2  #ANS-PTOPS7   (A15)        /*                                                                                                                                                                                                                        
   2  #ANS-PTOPS8   (A15)        /*                                                                                                                                                                                                                        
*                                                                                                                                                                                                                                                          
   2  #ANS-LTEXT1A  (A240)                                                                                                                                                                                                                                 
*                                                                                                                                                                                                                                                          
   2  #ANS-OPTNS1   (A15)        /*  7/6/95  2nd multi select box                                                                                                                                                                                          
   2  #ANS-OPTNS2   (A15)        /*  7/6/95                                                                                                                                                                                                                
   2  #ANS-OPTNS3   (A15)        /*  7/6/95                                                                                                                                                                                                                
   2  #ANS-OPTNS4   (A15)        /*  7/6/95                                                                                                                                                                                                                
** 2  #ANS-OPTNS5   (A15)        /*  7/6/95  try 4 of 6 processing                                                                                                                                                                                         
** 2  #ANS-OPTNS6   (A15)        /*  7/6/95                                                                                                                                                                                                                
*                                                                                                                                                                                                                                                          
   2  #ANS-LTEXT2A  (A240)                                                                                                                                                                                                                                 
   2  #ANS-LTEXT2B  (A240)                                                                                                                                                                                                                                 
*                                                                                                                                                                                                                                                          
   2  #ANS-LTEXT3A  (A240)                                                                                                                                                                                                                                 
   2  #ANS-LTEXT3B  (A240)                                                                                                                                                                                                                                 
   2  #ANS-LTEXT3C  (A240)                                                                                                                                                                                                                                 
*                                                                                                                                                                                                                                                          
****** enhanced multi selection box logic fields    7/6/95   ********                                                                                                                                                                                      
*                                                                                                                                                                                                                                                          
*   #N-MULTI... fields are used to handle scroll boxes which allow                                                                                                                                                                                         
* more than one choice.  In this example we only have 2 multiple                                                                                                                                                                                           
* selection boxes -> #N-MULTI-FLD-CNT = 2 (allowed room for 5)                                                                                                                                                                                             
* The #N-MULTI-FLD's should be in ascending order.  In this example                                                                                                                                                                                        
* (1) = 10  and (2) = 12                                                                                                                                                                                                                                   
*                                                                                                                                                                                                                                                          
*   In this case #N-MULTI-FLD(1) points to the 10th field in the                                                                                                                                                                                           
* array of field names.                                                                                                                                                                                                                                    
*   You may select up to 8 toppings -> #N-MULTI-MAX(1)=8.  This must                                                                                                                                                                                       
* match the define data for #ANS-DATG fields #ANS-PTOPS1/2/3/../8                                                                                                                                                                                          
*                                                                                                                                                                                                                                                          
*   In this case #N-MULTI-FLD(2) points to the 12th field in the                                                                                                                                                                                           
* array of field names.                                                                                                                                                                                                                                    
*   You may select up to 4 extra options-> #N-MULTI-MAX(2)=4.This must                                                                                                                                                                                     
* match the define data for #ANS-DATG fields #ANS-OPTNS1/2/3/4   even                                                                                                                                                                                      
* though there are 6 options listed only 4 will be accepted.                                                                                                                                                                                               
* If more than 4 are selected the 4th position will hold the last                                                                                                                                                                                          
* selected option. (ie. pick 1,2,3,4,5,6  -> 1,2,3,6  retained)                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
 1  #N-MULTI-FLD-CNT   (N3)  INIT<1> /* actual # of multi select flds                                                                                                                                                                                      
*                                                                                                                                                                                                                                                          
 1  #N-MULTI-SELECT    (1:5)   /* 6/7/95 improved                                                                                                                                                                                                          
   2  #N-MULTI-FLD     (N3)    /* #N-FORM-NAME script (ptops=10)                                                                                                                                                                                           
   2  #N-MULTI-CNT     (N3)    /* init zero                                                                                                                                                                                                                
   2  #N-MULTI-MAX     (N3)    /* # of selects (ptops 8)                                                                                                                                                                                                   
*                                                                                                                                                                                                                                                          
**********  always double check field names with form ***************                                                                                                                                                                                      
*                                                                                                                                                                                                                                                          
*    field names are not required to be in the same order as the                                                                                                                                                                                           
*  form BUT these entries MUST CORRESPOND positionally with the                                                                                                                                                                                            
*  #ANS-DAT-FIELD-LENGTHS and the #ANS-DATG field definitions                                                                                                                                                                                              
*                                                                                                                                                                                                                                                          
 1  #N-TEST           (A5)             /*  save area for testing NAME                                                                                                                                                                                      
 1  REDEFINE  #N-TEST                                                                                                                                                                                                                                      
   2  #N-TST          (A1 / 1:5)                                                                                                                                                                                                                           
*                                                                                                                                                                                                                                                          
 1  #N-ARRAY                                                                                                                                                                                                                                               
   2   #NTXT1         (A5)  INIT<'lname'>   /* last name                                                                                                                                                                                                   
   2   #NTXT2         (A5)  INIT<'fname'>   /* first name                                                                                                                                                                                                  
   2   #NTXT3         (A5)  INIT<'email'>   /* email address                                                                                                                                                                                               
   2   #NTXT4         (A5)  INIT<'paymt'>   /* payment method                                                                                                                                                                                              
   2   #NTXT5         (A5)  INIT<'callf'>   /* call first ?                                                                                                                                                                                                
   2   #NTXT6         (A5)  INIT<'psize'>   /* size of pizza ordered                                                                                                                                                                                       
   2   #NTXT7         (A5)  INIT<'ches1'>   /* regular cheese                                                                                                                                                                                              
   2   #NTXT8         (A5)  INIT<'ches2'>   /* double  cheese                                                                                                                                                                                              
   2   #NTXT9         (A5)  INIT<'ches3'>   /* triple cheese                                                                                                                                                                                               
   2   #NTXT10        (A5)  INIT<'ptops'>   /* toppings                                                                                                                                                                                                    
   2   #NTXT11        (A5)  INIT<'ltxt1'>   /* 1st comment area                                                                                                                                                                                            
   2   #NTXT12        (A5)  INIT<'optns'>   /* 7/6/95 multi testing                                                                                                                                                                                        
   2   #NTXT13        (A5)  INIT<'ltxt2'>   /* 2nd comment area                                                                                                                                                                                            
   2   #NTXT14        (A5)  INIT<'ltxt3'>   /* 3rd comment area                                                                                                                                                                                            
   2   #NTXT15        (A5)  INIT<'ZZZZZ'>   /* end of table marker                                                                                                                                                                                         
*                                                                                                                                                                                                                                                          
 1  REDEFINE   #N-ARRAY                                                                                                                                                                                                                                    
   2  #N-FORM-NAME    (A5 / 1:15)                                                                                                                                                                                                                          
*                                                                                                                                                                                                                                                          
 1  #N-ASIZE          (N3)  INIT<15> /* num of #N-FORM-NAME entries                                                                                                                                                                                        
*                                                                                                                                                                                                                                                          
 1  #PLOG-LINE      (A129)    /*  WRITE a log to printer 2                                                                                                                                                                                                 
*                                                                                                                                                                                                                                                          
END-DEFINE                                                                                                                                                                                                                                                 
**********************************************************************                                                                                                                                                                                     
*   tabs, carriage returns, line feeds are translated to  "+"                                                                                                                                                                                              
* if you wish another character do a MOVE to #PERHF00 for TAB and/or                                                                                                                                                                                       
* #PERHF01 for LINE FEED and/or  #PERHF02                                                                                                                                                                                                                  
* for CARRIAGE RETURN  before processing POST input                                                                                                                                                                                                        
*                                                                                                                                                                                                                                                          
*   #PERHX00              A    2 INIT<'09'> /* tab  7/6/95                                                                                                                                                                                                 
*   #PERHF00              A    1 INIT<'+'> /* + BECOMES SPACE                                                                                                                                                                                              
*   #PERHX01              A    2 INIT<'0A'> /* LINE FEED                                                                                                                                                                                                   
*   #PERHF01              A    1 INIT<'+'> /* + BECOMES SPACE                                                                                                                                                                                              
*   #PERHX02              A    2 INIT<'0D'> /* CARRIAGE RETURN                                                                                                                                                                                             
*   #PERHF02              A    1 INIT<'+'> /* + BECOMES SPACE                                                                                                                                                                                              
*********************************************************************                                                                                                                                                                                      
******************* main routine ************************************                                                                                                                                                                                      
**********************************************************************                                                                                                                                                                                     
 FORMAT (1) LS=130                                                                                                                                                                                                                                         
 FORMAT (2) LS=130                                                                                                                                                                                                                                         
 MOVE #DATAIN      TO   #DPARM                                                                                                                                                                                                                             
 MOVE *DATN        TO   #DATN                                                                                                                                                                                                                              
 MOVE *TIMN        TO   #TIMN                                                                                                                                                                                                                              
 MOVE #IPADDR-B(1) TO   #XIP1   /* for U of D  128                                                                                                                                                                                                         
 MOVE #IPADDR-B(2) TO   #XIP2   /* for U of D  175                                                                                                                                                                                                         
 MOVE #IPADDR-B(3) TO   #XIP3   /* subnet                                                                                                                                                                                                                  
 MOVE #IPADDR-B(4) TO   #XIP4   /* machine ID on the subnet                                                                                                                                                                                                
*******************************************************************                                                                                                                                                                                        
*     added to use NEW multi selection box logic                                                                                                                                                                                                           
*     these values will vary from form to form                                                                                                                                                                                                             
 MOVE 2  TO #N-MULTI-FLD-CNT     /* 7/6/95                                                                                                                                                                                                                 
 MOVE 10 TO #N-MULTI-FLD(1)      /* 7/6/95                                                                                                                                                                                                                 
 MOVE 12 TO #N-MULTI-FLD(2)      /* 7/6/95                                                                                                                                                                                                                 
 MOVE 8  TO #N-MULTI-MAX(1)      /* 7/6/95                                                                                                                                                                                                                 
 MOVE 4  TO #N-MULTI-MAX(2)      /* 7/6/95                                                                                                                                                                                                                 
 MOVE 0  TO #N-MULTI-CNT(1)      /* 7/6/95                                                                                                                                                                                                                 
 MOVE 0  TO #N-MULTI-CNT(2)      /* 7/6/95                                                                                                                                                                                                                 
*******************************************************************                                                                                                                                                                                        
*                                                                                                                                                                                                                                                          
*  at this point you could accept/reject based on address                                                                                                                                                                                                  
*                                                                                                                                                                                                                                                          
*  for debug  record  ipadress of client and our current port                                                                                                                                                                                              
*                                                                                                                                                                                                                                                          
* WRITE(1) 'MFU0015'  #XIP1A '.' #XIP2A '.' #XIP3A '.' #XIP4A '  :'                                                                                                                                                                                        
*    #XTPORT '   ' #DATN-A #TIMN-A                                                                                                                                                                                                                         
* WRITE (1) #DPARM(AL=128)                                                                                                                                                                                                                                 
*                                                                                                                                                                                                                                                          
 IF  #ANSNUM  NE  'ans0001 '                                                                                                                                                                                                                               
   PERFORM SENDFORM          /* asssume  frm0001 and build FORM                                                                                                                                                                                            
   ESCAPE ROUTINE            /* return to main and send to client                                                                                                                                                                                          
 END-IF                                                                                                                                                                                                                                                    
*                                                                                                                                                                                                                                                          
 IF  #ANSDATA = #NULL        /* SOMETHING WRONG, NO POST ANSWERS                                                                                                                                                                                           
   RESET  #SCRIPT(*)                                                                                                                                                                                                                                       
   COMPRESS                                                                                                                                                                                                                                                
     '<HTML>'                                                                                                                                                                                                                                              
     '<TITLE> University Of Delaware Mosaic POST Form 1 </TITLE>'                                                                                                                                                                                          
     '<h3> Incompatible FORM contact MIS support  !! </h3>'                                                                                                                                                                                                
     '</HTML>'                                                                                                                                                                                                                                             
     H'0D15' '.' H'0D150000'                                                                                                                                                                                                                               
     INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                   
   MOVE ' ' TO #CTYPE       /* last send has EOM on end                                                                                                                                                                                                    
   ESCAPE ROUTINE                                                                                                                                                                                                                                          
 END-IF                                                                                                                                                                                                                                                    
*********** process the returned entry# fields **********************                                                                                                                                                                                      
*  WRITE (1) #LTEXT(1) / #LTEXT(2) / #LTEXT(3)  / #LTEXT(4)                                                                                                                                                                                                
*  WRITE (1) #LTEXT(5) / #LTEXT(6) / #LTEXT(7)   /* mime header                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
   WRITE (1) #LTEXT(7) / #LTEXT(8) /* end of MIME header + start ans                                                                                                                                                                                       
   WRITE (1) #LTEXT(9)  / #LTEXT(10) / #LTEXT(11)  / #LTEXT(12)                                                                                                                                                                                            
   WRITE (1) #LTEXT(13) / #LTEXT(14) / #LTEXT(15)  / #LTEXT(16)                                                                                                                                                                                            
   WRITE (1) #LTEXT(17) / #LTEXT(18) / #LTEXT(19)  / #LTEXT(20)                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
  PERFORM EXTRACT-ANSWER                                                                                                                                                                                                                                   
  WRITE (1) #ANS-PTOPS1 ' ' #ANS-PTOPS2 ' ' #ANS-PTOPS3 ' ' #ANS-PTOPS4                                                                                                                                                                                    
  WRITE (1) #ANS-PTOPS5 ' ' #ANS-PTOPS6 ' ' #ANS-PTOPS7 ' ' #ANS-PTOPS8                                                                                                                                                                                    
  WRITE (1) #ANS-OPTNS1 ' ' #ANS-OPTNS2 ' ' #ANS-OPTNS3 ' ' #ANS-OPTNS4                                                                                                                                                                                    
**WRITE (1) #ANS-OPTNS5                                                                                                                                                                                                                                    
*                                                                                                                                                                                                                                                          
  RESET #PLOG-LINE                                                                                                                                                                                                                                         
  COMPRESS 'MFU0015++***+' #XIP1A '.' #XIP2A '.' #XIP3A '.' #XIP4A                                                                                                                                                                                         
    '++' #HPORT  '++' #XTPORT '++ctype+=+' #CTYPE '++'                                                                                                                                                                                                     
    #DATN-A  '++'  #TIMN-A                                                                                                                                                                                                                                 
    INTO #PLOG-LINE LEAVING NO SPACE                                                                                                                                                                                                                       
  EXAMINE FULL #PLOG-LINE '+' REPLACE WITH ' '                                                                                                                                                                                                             
  WRITE (2) #PLOG-LINE                                                                                                                                                                                                                                     
**                                                                                                                                                                                                                                                         
  RESET #PLOG-LINE                                                                                                                                                                                                                                         
  COMPRESS 'MFU0015++lname=+' #ANS-LNAME                                                                                                                                                                                                                   
    '++fname=+' #ANS-FNAME                                                                                                                                                                                                                                 
    '++email=+' #ANS-EMAIL  INTO #PLOG-LINE LEAVING NO SPACE                                                                                                                                                                                               
  EXAMINE FULL #PLOG-LINE '+' REPLACE WITH ' '                                                                                                                                                                                                             
  WRITE (2) #PLOG-LINE                                                                                                                                                                                                                                     
**                                                                                                                                                                                                                                                         
  RESET #PLOG-LINE                                                                                                                                                                                                                                         
  COMPRESS 'MFU0015++paymt=+' #ANS-PAYMT                                                                                                                                                                                                                   
    '++callf=+' #ANS-CALLF                                                                                                                                                                                                                                 
    '++psize=+' #ANS-PSIZE  INTO #PLOG-LINE LEAVING NO SPACE                                                                                                                                                                                               
  EXAMINE FULL #PLOG-LINE '+' REPLACE WITH ' '                                                                                                                                                                                                             
  WRITE (2) #PLOG-LINE                                                                                                                                                                                                                                     
**                                                                                                                                                                                                                                                         
  RESET #PLOG-LINE                                                                                                                                                                                                                                         
  COMPRESS 'MFU0015++ches1=+' #ANS-CHES1                                                                                                                                                                                                                   
    '++ches2=+' #ANS-CHES2                                                                                                                                                                                                                                 
    '++ches3=+' #ANS-CHES3  INTO #PLOG-LINE LEAVING NO SPACE                                                                                                                                                                                               
  EXAMINE FULL #PLOG-LINE '+' REPLACE WITH ' '                                                                                                                                                                                                             
  WRITE (2) #PLOG-LINE                                                                                                                                                                                                                                     
**                                                                                                                                                                                                                                                         
  RESET #PLOG-LINE                                                                                                                                                                                                                                         
  COMPRESS 'MFU0015++toppings=+' #ANS-PTOPS1 ','                                                                                                                                                                                                           
    #ANS-PTOPS2  ',' #ANS-PTOPS3 ',' #ANS-PTOPS4 ','                                                                                                                                                                                                       
    #ANS-PTOPS5  ',' #ANS-PTOPS6 ',' #ANS-PTOPS7 ','                                                                                                                                                                                                       
    #ANS-PTOPS8  ','                                                                                                                                                                                                                                       
    INTO #PLOG-LINE    /*  LEAVING NO SPACE                                                                                                                                                                                                                
  EXAMINE FULL #PLOG-LINE '+' REPLACE WITH ' '                                                                                                                                                                                                             
  WRITE (2) #PLOG-LINE                                                                                                                                                                                                                                     
**                                                                                                                                                                                                                                                         
*                                                                                                                                                                                                                                                          
**************************************************************                                                                                                                                                                                             
*********** respond based on Form data  **********************                                                                                                                                                                                             
**************************************************************                                                                                                                                                                                             
*                                                                                                                                                                                                                                                          
 RESET  #SCRIPT(*)  /* clear out the entire 4080 byte buffer                                                                                                                                                                                               
 COMPRESS                                                                                                                                                                                                                                                  
   '<HTML>'                                                                                                                                                                                                                                                
   '<TITLE> University Of Delaware Mosaic POST Form 1 </TITLE>'                                                                                                                                                                                            
   '<h3> Natural Dynamically Generated Answer Demo Form 1 </h3>'                                                                                                                                                                                           
   '<! invisible comments are ok for text but meaningless here.>'                                                                                                                                                                                          
   H'0000'                                                                                                                                                                                                                                                 
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 MOVE 'M' TO #CTYPE  /* send but do not close, more to come                                                                                                                                                                                                
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01   /* clear out the 252 area we are using                                                                                                                                                                                                  
 COMPRESS                                                                                                                                                                                                                                                  
   '<P><PRE>++A Person named++'                                                                                                                                                                                                                            
   #ANS-FNAME '+' #ANS-LNAME                                                                                                                                                                                                                               
   '++ordered a+'  #ANS-PSIZE  '+Pizza.  <BR>'                                                                                                                                                                                                             
   'Email address is ++' #ANS-EMAIL                                                                                                                                                                                                                        
   H'0000'                                                                                                                                                                                                                                                 
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* send but do not close, more to come                                                                                                                                                                                                
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS                                                                                                                                                                                                                                                  
   '+and+' #ANS-PAYMT '+will be used for payment.<BR>'                                                                                                                                                                                                     
   'The pizza is topped with ++'                                                                                                                                                                                                                           
   #ANS-CHES1 '++' #ANS-CHES2 '++' #ANS-CHES3                                                                                                                                                                                                              
   '++and++'                                                                                                                                                                                                                                               
   H'0000'                                                                                                                                                                                                                                                 
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* send but do not close, more to come                                                                                                                                                                                                
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS                                                                                                                                                                                                                                                  
   #ANS-PTOPS1 '+' #ANS-PTOPS2 '+' #ANS-PTOPS3 '+'                                                                                                                                                                                                         
   #ANS-PTOPS4 '+' #ANS-PTOPS5 '+' #ANS-PTOPS6 '+'                                                                                                                                                                                                         
   #ANS-PTOPS7 '+' #ANS-PTOPS8                                                                                                                                                                                                                             
   '<P>' 'Your extra test options :<BR>'                                                                                                                                                                                                                   
   H'0000'                                                                                                                                                                                                                                                 
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* send but do not close, more to come                                                                                                                                                                                                
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************    7/6/95                                                                                                                                                                                                                               
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS                                                                                                                                                                                                                                                  
   #ANS-OPTNS1 '+' #ANS-OPTNS2 '+' #ANS-OPTNS3 '+'                                                                                                                                                                                                         
   #ANS-OPTNS4                                                                                                                                                                                                                                             
   '<P>' 'Your comments were :<BR>'                                                                                                                                                                                                                        
   H'0000'                                                                                                                                                                                                                                                 
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* send but do not close, more to come                                                                                                                                                                                                
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS '<P>'  #ANS-LTEXT1A                                                                                                                                                                                                                              
   H'0000'  INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                            
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* last send is done by the main program                                                                                                                                                                                              
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS   '<P>'  #ANS-LTEXT2A                                                                                                                                                                                                                            
   H'0000'  INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                            
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* last send is done by the main program                                                                                                                                                                                              
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
****                                                                                                                                                                                                                                                       
 IF #ANS-LTEXT2B > '        '                                                                                                                                                                                                                              
   RESET  #SCRIP01                                                                                                                                                                                                                                         
   COMPRESS  #ANS-LTEXT2B                                                                                                                                                                                                                                  
     H'0000' INTO #SCRIP01 LEAVING NO SPACE                                                                                                                                                                                                                
   EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                              
   MOVE 'M' TO #CTYPE  /* last send done by the main program                                                                                                                                                                                               
   CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                    
 END-IF                                                                                                                                                                                                                                                    
******************                                                                                                                                                                                                                                         
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS   '<P>'  #ANS-LTEXT3A                                                                                                                                                                                                                            
   H'0000'  INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                            
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'M' TO #CTYPE  /* last send done by the main program                                                                                                                                                                                                 
 CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                      
****                                                                                                                                                                                                                                                       
 IF #ANS-LTEXT3B > '        '                                                                                                                                                                                                                              
   RESET  #SCRIP01                                                                                                                                                                                                                                         
   COMPRESS   #ANS-LTEXT3B                                                                                                                                                                                                                                 
     H'0000'  INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                          
   EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                              
   MOVE 'M' TO #CTYPE  /* last send done by the main program                                                                                                                                                                                               
   CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                    
 END-IF                                                                                                                                                                                                                                                    
****                                                                                                                                                                                                                                                       
 IF #ANS-LTEXT3C > '        '                                                                                                                                                                                                                              
   RESET  #SCRIP01                                                                                                                                                                                                                                         
   COMPRESS   #ANS-LTEXT3C                                                                                                                                                                                                                                 
     H'0000'  INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                          
   EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                              
   MOVE 'M' TO #CTYPE  /* last send done by the main program                                                                                                                                                                                               
   CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                    
 END-IF                                                                                                                                                                                                                                                    
***********  prepare last send and retunr to main ****                                                                                                                                                                                                     
 RESET  #SCRIP01                                                                                                                                                                                                                                           
 COMPRESS                                                                                                                                                                                                                                                  
   '<P> </HTML>'  H'0D150000'                                                                                                                                                                                                                              
   INTO  #SCRIP01     LEAVING NO SPACE                                                                                                                                                                                                                     
 EXAMINE FULL #SCRIP01 '+' REPLACE WITH ' '                                                                                                                                                                                                                
 MOVE 'L' TO #CTYPE        /* last send is done by the main program                                                                                                                                                                                        
*                                                                                                                                                                                                                                                          
 ESCAPE ROUTINE                                                                                                                                                                                                                                            
*                                                                                                                                                                                                                                                          
************************************************************                                                                                                                                                                                               
************************************************************                                                                                                                                                                                               
******  extract the fields from the returned data  *********                                                                                                                                                                                               
*                                                                                                                                                                                                                                                          
*   Looking for h'0d150d15' in front of 1st answer field                                                                                                                                                                                                   
* -> if we find a h'15' followed by a h'0d' that should be it                                                                                                                                                                                              
*   SPECIAL chars in text will be %0A->line feed, %2C->comma,                                                                                                                                                                                              
* %0D->car return, ... ie. % follow by the ASCII hex !!!                                                                                                                                                                                                   
*   double check &name= against the #N-ARRAY when adjusting                                                                                                                                                                                                
* ANSWER indexing   2/8/95                                                                                                                                                                                                                                 
*   improved 4/14/95 to handle long and short answers intermixed                                                                                                                                                                                           
* all table driven by the #ANS... define data areas !!!!                                                                                                                                                                                                   
*                                                                                                                                                                                                                                                          
DEFINE SUBROUTINE  EXTRACT-ANSWER                                                                                                                                                                                                                          
 RESET #ANS-DATG(*)                                                                                                                                                                                                                                        
 MOVE  0 TO  #I1       /* target field index                                                                                                                                                                                                               
 MOVE  0 TO  #IFLG1    /* need to skip MIME header stuff                                                                                                                                                                                                   
 MOVE  0 TO  #JS       /* #SCRIPT subscript                                                                                                                                                                                                                
 MOVE  0 TO  #JA       /* #ANS-DATG subscript  4/14/95                                                                                                                                                                                                     
 MOVE  0 TO  #JA-END   /* #ANS-DATG end of current field subscript                                                                                                                                                                                         
 REPEAT  WHILE  #JS < 4079                                                                                                                                                                                                                                 
   ADD 1 TO #JS                   /* move pointer along (past =)                                                                                                                                                                                           
*                                                                                                                                                                                                                                                          
*        initial positioning past mime header                                                                                                                                                                                                              
*                                                                                                                                                                                                                                                          
   IF (#I1 EQ 0 ) AND (#IFLG1  EQ  0)                                                                                                                                                                                                                      
     IF #SCRIPT(#JS) NE  #LF      /* line feed                                                                                                                                                                                                             
       ESCAPE TOP                /* no -> get next char                                                                                                                                                                                                    
     ELSE                                                                                                                                                                                                                                                  
       IF  #SCRIPT(#JS+1) NE #CR  /* carraiage return                                                                                                                                                                                                      
         ESCAPE TOP              /* no -> get next char                                                                                                                                                                                                    
       ELSE                                                                                                                                                                                                                                                
* 4/27   MOVE  1  TO #I1         /* index for 1st answer field                                                                                                                                                                                             
* 4/27   ADD   8  TO #JS         /* pt past #LF#CR#LFlname                                                                                                                                                                                                 
* 4/27   MOVE  1  TO  #JA        /* first #ans-datg pointer 4/15                                                                                                                                                                                           
* 4/27   COMPUTE #JA-END = #JA + #ANS-FLEN(1) /* first end pointer                                                                                                                                                                                         
         ADD   3  TO #JS           /* pt past #LF#CR#LF          4/27                                                                                                                                                                                      
         PERFORM FIELD-NAME-CHECK  /*  setup pts to answer area  4/27                                                                                                                                                                                      
         ADD 5 TO #JS              /* move pointer along (xxxxx) 4/27                                                                                                                                                                                      
         ESCAPE TOP               /* get next char (should be = sign)                                                                                                                                                                                      
       END-IF                                                                                                                                                                                                                                              
     END-IF                                                                                                                                                                                                                                                
   END-IF                                                                                                                                                                                                                                                  
*                                                                                                                                                                                                                                                          
   IF #SCRIPT(#JS)  EQ '&'               /* marker between answers                                                                                                                                                                                         
     IF #SCRIPT(#JS + 1) EQ  #NULL  OR                  /* 4/27/95                                                                                                                                                                                         
       (#SCRIPT(#JS + 1 ) EQ #CR )                      /* 4/27/95                                                                                                                                                                                         
       ESCAPE TOP     /* bad input skip &               /* 4/27/95                                                                                                                                                                                         
     END-IF                                             /* 4/27/95                                                                                                                                                                                         
     ADD 1 TO #JS              /* point past &                                                                                                                                                                                                             
     PERFORM FIELD-NAME-CHECK  /*  setup pointers to answer area                                                                                                                                                                                           
     ADD 5 TO #JS              /* move pointer along (xxxxx)                                                                                                                                                                                               
     ESCAPE TOP                /* get next char                                                                                                                                                                                                            
   END-IF                                                                                                                                                                                                                                                  
*                                                                                                                                                                                                                                                          
*    once we are into the answers we should not see another                                                                                                                                                                                                
*  CR LF until the END of all the answers                                                                                                                                                                                                                  
*    DO NOT pickup the CR LF on the end as answer data !!                                                                                                                                                                                                  
*                                                                                                                                                                                                                                                          
   IF #SCRIPT(#JS)  EQ  #NULL  OR                                                                                                                                                                                                                          
     (#SCRIPT(#JS) EQ #CR   AND  #SCRIPT(#JS +1)  EQ #LF)                                                                                                                                                                                                  
     IF  #CTYPE NE 'R'       /* more data waiting for us in NATSVAL                                                                                                                                                                                        
       ESCAPE ROUTINE        /* no -> we have all the answers                                                                                                                                                                                              
     ELSE                                                                                                                                                                                                                                                  
       MOVE  0  TO #JS      /* restart at beginning of new #SCRIPT                                                                                                                                                                                         
       MOVE  1  TO #IFLG1   /* do not try to skip MIME header                                                                                                                                                                                              
       MOVE ALL #NULL TO #SCRIPT(*)                                                                                                                                                                                                                        
       CALL 'NATSVAL' #HPORT #TPORT #IPADDR #CTYPE #SCRIP01                                                                                                                                                                                                
       ESCAPE TOP          /* go to top of repeat loop                                                                                                                                                                                                     
     END-IF                                                                                                                                                                                                                                                
   END-IF