home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / SCREDIT2.ZIP / SCREDIT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-06  |  59.4 KB  |  2,315 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <dos.h>
  5. #include <bios.h>
  6. #include <string.h>
  7. #include <math.h>
  8. #include <ctype.h>
  9. #include <alloc.h>
  10.  
  11. typedef union
  12.     {
  13.     int ch;
  14.     struct{
  15.        unsigned char lsb;
  16.        unsigned char msb;
  17.        } byte;
  18.     }keyindef;
  19. static keyindef shiftstat = 0;
  20.  
  21. typedef union
  22.   {
  23.   struct s1
  24.       {
  25.       char           filler;
  26.       char           s_name         [128] [17];
  27.       unsigned char  s_number       [128];
  28.       int            s_recordnumber [128];
  29.       int            s_fieldsrecno  [128];
  30.       int            s_rangerecno   [128];
  31.       unsigned char  s_first        [128];
  32.       unsigned char  s_count        [128];
  33.       unsigned char  s_compiledind  [128];
  34.       int            s_rangerecnext;
  35.       int            s_rangelinenext;
  36.       int            s_sfiled;
  37.       }A;
  38.   struct s2
  39.       {
  40.       char           filler;
  41.       char           s_video     [3840];
  42.       char           s_workarray [80] [2];
  43.       }B;
  44.   struct s3
  45.       {
  46.       char          filler;
  47.       unsigned char s_fieldname     [128] [17];
  48.       unsigned char s_row           [128];
  49.       unsigned char s_col           [128];
  50.       unsigned char s_len           [128];
  51.       unsigned char s_type          [128];
  52.       unsigned char s_prev          [128];
  53.       unsigned char s_next          [128];
  54.       unsigned char s_datalen       [128];
  55.       unsigned char s_normalbg      [128];
  56.       unsigned char s_normalfg      [128];
  57.       unsigned char s_promptbg      [128];
  58.       unsigned char s_promptfg      [128];
  59.       unsigned char s_displaybg     [128];
  60.       unsigned char s_displayfg     [128];
  61.       unsigned int  s_rangenextrec  [128];
  62.       unsigned char s_rangenextline [128];
  63.       }C;
  64.   struct s4
  65.       {
  66.       char          filler;
  67.       char          s_rangelist [51] [79];
  68.       int           s_rangerec  [51];
  69.       unsigned char s_rangeline [51];
  70.       }D;
  71.   } s_rec_def;
  72.  
  73. static FILE *s_file;
  74. extern s_rec_def *s_indx, *s_record, *s_field;
  75.  
  76. static int   S_FieldPtr [128];
  77. static char *S_BuffPtr  [128];
  78. static char *S_WorkArea;
  79. extern int long S_CursorOld;
  80. extern enum S_Cursors {S_OFF,S_BOLD,S_NORMAL,S_GETCURSOR};
  81. extern enum S_Cursors S_Cursor;
  82. extern unsigned char S_Sound;
  83. extern unsigned char S_NumLock;
  84. extern unsigned char S_Fkey;
  85. extern unsigned char S_Shift;
  86. extern unsigned char S_Alt;
  87. extern unsigned char S_Ctrl;
  88. extern unsigned char S_Esc;
  89. extern unsigned char S_F1;
  90. extern unsigned char S_F2;
  91. extern unsigned char S_F3;
  92. extern unsigned char S_F4;
  93. extern unsigned char S_F5;
  94. extern unsigned char S_F6;
  95. extern unsigned char S_F7;
  96. extern unsigned char S_F8;
  97. extern unsigned char S_F9;
  98. extern unsigned char S_F10;
  99. extern unsigned char S_F11;
  100. extern unsigned char S_F12;
  101. extern unsigned char S_Enter;
  102. extern unsigned char S_BkSp;
  103. extern unsigned char S_Home;
  104. extern unsigned char S_Up;
  105. extern unsigned char S_PgUp;
  106. extern unsigned char S_Left;
  107. extern unsigned char S_Right;
  108. extern unsigned char S_End;
  109. extern unsigned char S_Down;
  110. extern unsigned char S_PgDn;
  111. extern unsigned char S_Ins;
  112. extern unsigned char S_Del;
  113. extern unsigned char S_Tab;
  114. extern unsigned char S_ShowStatus;
  115. extern unsigned char S_ScrollLock;
  116. extern unsigned char S_Caps;
  117. extern unsigned char S_LeftShift;
  118. extern unsigned char S_RightShift;
  119. extern unsigned char S_InsertMode;
  120. extern unsigned char S_InsertKey;
  121. extern unsigned char S_DeleteKey;
  122. extern unsigned char S_BackSpace;
  123. extern int  S_FirstField;
  124. extern int  S_Point;
  125. extern int  S_Freq;
  126. extern int  S_Dur;
  127. extern unsigned char
  128.        S_WorkStr [81],
  129.        S_Msg     [81],
  130.        S_EditStr [81],
  131.        S_Blanks  [81],
  132.        S_Ch;
  133.  
  134. extern unsigned char S_ChangeScreen;
  135. extern unsigned char S_FirstTime;
  136. extern unsigned char S_Sound_Hold;
  137. extern unsigned char S_Mono;
  138. extern unsigned char S_UpCase;
  139. extern unsigned char S_Validate_Finished;
  140. extern unsigned char S_ScreenValid;
  141. extern unsigned char S_Wait;
  142. extern unsigned char S_LeftArrow;
  143. extern unsigned char S_RightArrow;
  144. extern unsigned char S_PosLastChar;
  145. extern int
  146.   S_RecNo,
  147.   S_ValidateLine,
  148.   S_ValidateField,
  149.   S_Str_Pos,
  150.   S_Attrib,
  151.   S_MessBg,
  152.   S_MessFg,
  153.   S_NormBg,
  154.   S_NormFg,
  155.   S_Num,
  156.   S_F_Key,
  157.   S_Direction,
  158.   S_Decimal,
  159.   S_PointHold,
  160.   S_FieldNum,
  161.   S_Sub,
  162.   S_CurrLine,
  163.   S_NextRec;
  164.  
  165. extern unsigned char
  166.   S_NewStr       [81],
  167.   S_Padding      [81],
  168.   S_WorkAttrib   [81],
  169.   S_NormAttrib   [81],
  170.   S_StatusPrev   [41],
  171.   S_StatusLine   [41],
  172.   S_StatusAttrib [41],
  173.   S_Ins_Str      [2],
  174.   S_NextLine,
  175.   S_Reverse,
  176.   S_Skip,
  177.   S_Matched,
  178.   S_Min_Max_Loaded,
  179.   S_EndofLine,
  180.   S_InsideIf,
  181.   S_CurStr[81],
  182.   S_EditStrHold[81],
  183.   S_CompMin[81],
  184.   S_CompMax[81],
  185.   S_CompField[81],
  186.   S_OpCode[81],
  187.   S_OpCode1[81];
  188.  
  189. extern double
  190.   S_Round [8],
  191.   S_Numeric,
  192.   S_CompMin_Numeric,
  193.   S_CompMax_Numeric;
  194.  
  195. int s_pos(char *string1,char *string2)
  196. {
  197. unsigned long X,Y,Z;
  198. char s1 [80];
  199. char s2 [80];
  200. strcpy(s1,string1);
  201. strcpy(s2,string2);
  202. X = (unsigned long) strstr(s1,s2);
  203. Y = (unsigned long) &s1;
  204. Z = X - Y;
  205. if  (X==0) return -1;
  206. else return Z;
  207. }
  208.  
  209.  
  210.  
  211. void s_delete(char *string1, int startpos,int count)
  212. {
  213. unsigned long x,y,z;
  214. char s1 [80];
  215. strcpy(s1,string1);
  216. if  (startpos < strlen(s1))
  217.     {
  218.     z = startpos + count;
  219.     if  (z > strlen(s1)) count = strlen(s1)-startpos;
  220.     string1[startpos]=0;
  221.     strcat(string1,(char*)&s1[startpos + count]);
  222.     }
  223. }
  224.  
  225. void s_insert(char *string1,
  226.               char *string2,
  227.               int  insertpoint,
  228.               int  maxlength)
  229. {
  230. unsigned long X,Y,Z;
  231. char s1 [160];
  232. char s2 [80];
  233. char s3 [80];
  234.  
  235. if ((insertpoint > -1) && (insertpoint <= strlen(string1)))
  236.    {
  237.    strcpy(s3,(char *)&string1[insertpoint]);
  238.    string1[insertpoint]=0;
  239.    strcpy(s1,string1);
  240.    strcpy(s2,string2);
  241.    strcat(s1,s2);
  242.    strcat(s1,s3);
  243.    s1[maxlength]=0;
  244.    strcpy(string1,s1);
  245.    }
  246. }
  247.  
  248.  
  249. void s_copy(char *string1, char *string2,int startpos, int count)
  250. {
  251. unsigned long X,Y,Z;
  252. char s1 [160];
  253. char s2 [80];
  254. char s3 [80];
  255. if (startpos < strlen(string1))
  256.    {
  257.    strcpy(s1,string1);
  258.    s1[startpos + count] = 0;
  259.    strcpy(string2,(char *)&s1[startpos]);
  260.    }
  261. }
  262.  
  263. int s_strlen(char *target_string)
  264. {
  265. int x,y,z;
  266.  
  267. x=strlen(target_string);
  268. while ((target_string[x-1]<33)&&(x>=0)) x--;
  269. if  (x>-1) x++;
  270. return x;
  271. }
  272.  
  273. int S_PutScrMem(row,col,len,source)
  274.     char *source;
  275.     int  row,col,len;
  276.     {
  277.     int b_row,b_col;
  278.  
  279.     if (len>160)
  280.        {
  281.        b_row=len/160;
  282.        b_col=len - (b_row*160);
  283.        b_row += (row - 1);
  284.        if  (b_col==0)
  285.            b_col = 80;
  286.        }
  287.     else
  288.        {
  289.        b_row = row;
  290.        b_col = col + (len/2);
  291.        }
  292.     return puttext(col,row,b_col,b_row,source);
  293.     }
  294.  
  295.  
  296.  
  297.  
  298.  
  299. int S_GetScrMem(row,col,len,destination)
  300.     char *destination;
  301.     int  row,col,len;
  302.     {
  303.     int b_row, b_col;
  304.  
  305.     if (len>160)
  306.        {
  307.        b_row=len/160;
  308.        b_col=len - (b_row*160);
  309.        b_row += (row - 1);
  310.        if  (b_col==0)
  311.            b_col = 80;
  312.        }
  313.     else
  314.        {
  315.        b_row = row;
  316.        b_col = col + (len/2);
  317.        }
  318.     return gettext(col,row,b_col,b_row,destination);
  319.     }
  320.  
  321.  
  322.  
  323.  
  324.  
  325. void S_ResetKeyFlags ()
  326.    {
  327.    S_F1     = 0;
  328.    S_F2     = 0;
  329.    S_F3     = 0;
  330.    S_F4     = 0;
  331.    S_F5     = 0;
  332.    S_F6     = 0;
  333.    S_F7     = 0;
  334.    S_F8     = 0;
  335.    S_F9     = 0;
  336.    S_F10    = 0;
  337.    S_F11    = 0;
  338.    S_F12    = 0;
  339.    S_Home   = 0;
  340.    S_End    = 0;
  341.    S_PgUp   = 0;
  342.    S_PgDn   = 0;
  343.    S_Left   = 0;
  344.    S_Right  = 0;
  345.    S_Up     = 0;
  346.    S_Down   = 0;
  347.    S_Del    = 0;
  348.    S_Tab    = 0;
  349.    S_BkSp   = 0;
  350.    S_Esc    = 0;
  351.    S_Ctrl   = 0;
  352.    S_Enter  = 0;
  353.    S_Fkey   = 0;
  354.    S_Alt    = 0;
  355.    S_Shift  = 0;
  356.    S_Ins    = 0;
  357.    }
  358.  
  359.  
  360.  
  361.  
  362. void S_SetCursor(S)
  363.    char S;
  364.    {
  365.    union REGS in,out;
  366.  
  367.    in.h.ah = 1;
  368.    in.h.bh = 0;
  369.  
  370.    if  (S==0)
  371.        in.x.cx = 4096;
  372.    if  (S==1)
  373.        in.x.cx = 15;
  374.    if  (S==2)
  375.        in.x.cx = S_CursorOld;
  376.    if  (S==3)
  377.        in.h.ah = 3;
  378.  
  379.    int86(0x10,&in,&out);
  380.  
  381.    if  (S==3)
  382.        S_CursorOld = out.x.cx;
  383.    }
  384.  
  385.  
  386.  
  387. void S_Init()
  388.     {
  389.     struct text_info r;
  390.     int loop1,loop2,loop3;
  391.  
  392.     S_CursorOld = 1543;
  393.     if (S_FirstTime)
  394.        {
  395.        s_indx      = (s_rec_def *) farmalloc (sizeof(*s_indx));
  396.        s_record    = (s_rec_def *) farmalloc (sizeof(*s_record));
  397.        s_field     = (s_rec_def *) farmalloc (sizeof(*s_field));
  398.        S_SetCursor (S_GETCURSOR);
  399.        S_FirstTime = 0;
  400.        }
  401.     S_SetCursor(S_OFF);
  402.  
  403.     S_MessBg       = 4;
  404.     S_MessFg       = 15;
  405.     S_NormBg       = 0;
  406.     S_NormFg       = 2;
  407.     S_Sound        = 1;
  408.     S_Freq         = 300;
  409.     S_Dur          = 100;
  410.     S_PosLastChar  = 0;
  411.     S_ChangeScreen = 1;
  412.     S_Ch           = 0;
  413.     S_Point        = 0;
  414.     S_Direction    = 1;
  415.     S_F_Key        = 0;
  416.     S_RecNo        = 0;
  417.     S_ValidateLine = 0;
  418.     S_InsertKey    = 0;
  419.     S_DeleteKey    = 0;
  420.     S_BackSpace    = 0;
  421.     S_LeftArrow    = 0;
  422.     S_RightArrow   = 0;
  423.     S_Cursor       = S_NORMAL;
  424.  
  425.     for (loop1=0;loop1<81;loop1++)
  426.         S_Msg[loop1] = 0;
  427.  
  428.     for (loop1=0;loop1<81;loop1++)
  429.         S_Blanks[loop1] = 32;
  430.     S_Blanks[80] = 0;
  431.  
  432.     strcpy(S_StatusLine,"[Insert] [Caps] [Num Lock] [Scroll Lock]");
  433.     strcpy(S_NormAttrib,S_Msg);
  434.     strcpy(S_NewStr,S_Msg);
  435.     strcpy(S_Padding,S_Msg);
  436.  
  437.     gettextinfo(&r);
  438.     textmode(r.currmode);
  439.     if ((!s_indx)||(!s_record)||(!s_field))
  440.        {
  441.        cprintf("Unable to allocate far memory..\r\n");
  442.        exit (1);
  443.        }
  444.     S_ResetKeyFlags();
  445.     }
  446.  
  447.  
  448. void S_OpenScreenFile (char *screenfilename)
  449.     {
  450.     int loop1,loop2,loop3;
  451.  
  452.     if (S_FirstTime) S_Init();
  453.  
  454.     if ((s_file = fopen(screenfilename,"rb")) == NULL)
  455.        {
  456.        cprintf("open up of %s failed\r\n",screenfilename);
  457.        exit (1);
  458.        }
  459.  
  460.     if (fseek(s_file,0L,0) != 0)
  461.        {
  462.        puts("seek failed ");
  463.        exit (1);
  464.        }
  465.  
  466.    if (fread(s_indx,sizeof(*s_indx),1,s_file) < 1)
  467.       {
  468.       puts("read failed ");
  469.       exit (1);
  470.       }
  471.    for (loop1=0;loop1 < s_indx->A.s_sfiled;loop1++)
  472.        {
  473.        loop2 = s_indx->A.s_name[loop1][0];
  474.        for (loop3=1;loop3 < (loop2+2);loop3++)
  475.        s_indx->A.s_name[loop1][loop3-1]=s_indx->A.s_name[loop1][loop3];
  476.        s_indx->A.s_name[loop1][loop2]=0;
  477.        }
  478.    }
  479.  
  480.  
  481.  
  482.  
  483. void S_CloseScreenFile()
  484.    {
  485.    if  (S_FirstTime) S_Init();
  486.    fclose(s_file);
  487.    S_SetCursor(S_NORMAL);
  488.    farfree(s_indx);
  489.    farfree(s_record);
  490.    farfree(s_field);
  491.    S_FirstTime = 1;
  492.    }
  493.  
  494.  
  495.  
  496. void S_Beep(int t,int l)
  497.    {
  498.    if  (S_Sound > 0)
  499.        {
  500.        sound(t);
  501.        delay(l);
  502.        nosound();
  503.        }
  504.    }
  505.  
  506. void S_Write (int Row, int Col, int Len,char *Source, char *Attribs)
  507.    {
  508.    int X,Y,Ptr,Ch;
  509.    for (Ptr=0;Ptr<=Len;Ptr++)
  510.        {
  511.        s_record->B.s_workarray[Ptr][0]=Source[Ptr];
  512.        s_record->B.s_workarray[Ptr][1]=Attribs[Ptr];
  513.        }
  514.    S_PutScrMem(Row,Col,(Len*2),&s_record->B.s_workarray);
  515.    for (Ptr=1;Ptr<81;Ptr++)
  516.        S_NormAttrib[Ptr]=0;
  517.    }
  518.  
  519.  
  520.  
  521.  
  522. void S_DisplayMessage(Bg,Fg,Msg)
  523.    int
  524.      Bg,
  525.      Fg;
  526.    char
  527.      Msg [81];
  528.    {
  529.    int Msg_Len,W,X,Y;
  530.    if  (S_FirstTime) S_Init();
  531.    strcpy(S_Padding,S_Blanks);
  532.    strcpy(S_WorkAttrib,S_Blanks);
  533.    Msg_Len = strlen(Msg);
  534.    Y       = (80 - Msg_Len)/2;
  535.    W       = 0;
  536.    for (X=0;X<80;X++)
  537.        {
  538.        if  (X<Y)
  539.            S_WorkAttrib[X] = 2;
  540.        else
  541.            if  (X>((Y+Msg_Len)-1))
  542.                S_WorkAttrib[X] = 2;
  543.            else
  544.                {
  545.                S_WorkAttrib[X]=(Bg*16)+Fg;
  546.                S_Padding   [X]=Msg[W];
  547.                W++;
  548.                }
  549.        }
  550.    if (strlen(Msg)>0)
  551.       S_Beep(S_Freq,S_Dur);
  552.    S_Write(25,1,80,S_Padding,S_WorkAttrib);
  553.    S_Msg[0]=0;
  554.    }
  555.  
  556.  
  557.  
  558. void S_Store_Buf_Loc(char *ScrName, char *ScrBuff)
  559.    {
  560.    int X,Y,Z;
  561.    if  (S_FirstTime) S_Init();
  562.    for (X=0;X<s_indx->A.s_sfiled;X++)
  563.        {
  564.        if  (strcmp(strupr(ScrName),strupr(s_indx->A.s_name[X]))==0)
  565.            {
  566.            S_BuffPtr [X] = ScrBuff;
  567.        break;
  568.            }
  569.        }
  570.    }
  571.  
  572.  
  573.  
  574.  
  575. void S_LoadScreen(char *ScrName)
  576.    {
  577.    int A,B,X,Y,Z;
  578.    int RR;
  579.    long rec;
  580.    if  (S_FirstTime) S_Init();
  581.    S_Num = -1;
  582.    for (X=0;X<s_indx->A.s_sfiled;X++)
  583.        {
  584.        if (strcmp(strupr(ScrName),strupr(s_indx->A.s_name[X]))==0)
  585.            {
  586.            S_Num = X;
  587.            break;
  588.            }
  589.        }
  590.  
  591.    S_Msg[0]=0;
  592.  
  593.    if  (S_Num==-1)
  594.        {
  595.        strcpy(S_Msg,"<               > has not been found");
  596.        Y=1;
  597.        for (X=0;ScrName[X]!=NULL;X++)
  598.            S_Msg[Y++]=ScrName[X];
  599.        }
  600.    if  (s_indx->A.s_compiledind[S_Num]==0)
  601.        {
  602.        strcpy(S_Msg,"<               > has not been compiled");
  603.        Y=1;
  604.        for (X=0;ScrName[X]!=NULL;X++)
  605.            S_Msg[Y++]=ScrName[X];
  606.        }
  607.    if  (S_Msg[0]>0)
  608.        {
  609.        S_DisplayMessage(S_MessBg,S_MessFg,S_Msg);
  610.        S_CloseScreenFile();
  611.        exit(1);
  612.        }
  613.  
  614.    S_WorkArea = S_BuffPtr[S_Num];
  615.  
  616.    rec = (s_indx->A.s_recordnumber[S_Num])*sizeof(*s_record);
  617.  
  618.    fseek(s_file,rec,0);
  619.    fread(s_record,sizeof(*s_record),1,s_file);
  620.  
  621.    S_FirstField = 0;
  622.    if  (s_indx->A.s_fieldsrecno[S_Num])
  623.        {
  624.        rec = (s_indx->A.s_fieldsrecno[S_Num])*sizeof(*s_record);
  625.        fseek(s_file,rec,0);
  626.        fread(s_field,sizeof(*s_field),1,s_file);
  627.        S_FirstField = (s_indx->A.s_first[S_Num])-1;
  628.        S_Point      = 0;
  629.        for (X=0;X<s_indx->A.s_count[S_Num];X++)
  630.            {
  631.            Y = s_field->C.s_fieldname[X][0];
  632.            movmem(&s_field->C.s_fieldname[X][1],
  633.                   &s_field->C.s_fieldname[X][0],16);
  634.  
  635.            s_field->C.s_fieldname[X][Y]=0;
  636.            S_FieldPtr[X] = S_Point;
  637.  
  638.            if  ((s_field->C.s_type[X]==8)  ||
  639.                 (s_field->C.s_type[X]==9)  ||
  640.                 (s_field->C.s_type[X]==98) ||
  641.                 (s_field->C.s_type[X]==99))
  642.                S_Point = S_Point + s_field->C.s_len[X]+1;
  643.            else
  644.                S_Point = S_Point + sizeof((double)0);
  645.  
  646.            A = (s_field->C.s_col[X]+s_field->C.s_len[X])*2;
  647.            B = (s_field->C.s_row[X]-1)*160;
  648.  
  649.            for (Z=((s_field->C.s_col[X]-1)*2);Z<=A;Z+=2)
  650.                s_record->B.s_video[B+Z]=32;
  651.            }
  652.        }
  653.    if  (S_ChangeScreen)
  654.        {
  655.        puttext(1,1,80,24,&s_record->B.s_video[0]);
  656.        S_Point = S_FirstField;
  657.        }
  658.    else
  659.        S_ChangeScreen = 1;
  660.    }
  661.  
  662.  
  663.  
  664.  
  665. void S_DisplayScreenField(int R,int C,int T,int L,int DL,
  666.                           int DF,int DB,int NF,int NB,char *S)
  667.    {
  668.    int           Attr,x,y,z,l;
  669.    char          Wk[80];
  670.    double        *Dbl;
  671.    unsigned char BackColor, ForColor;
  672.  
  673.    if  (S_FirstTime) S_Init();
  674.    strcpy(S_EditStr,S);
  675.    DL = strlen(S_EditStr);
  676.  
  677.    if  (DL>0)
  678.        Attr = (DB * 16) + DF;
  679.    else
  680.        Attr = (NB * 16) + NF;
  681.  
  682.    setmem(S_NormAttrib,80,Attr);
  683.  
  684.    l = (L - strlen(S_EditStr))+1;
  685.  
  686.    if (l > 0)
  687.       {
  688.       movmem(&S_Blanks,&S_Padding,80);
  689.       S_Padding[l]=0;
  690.       }
  691.    else
  692.       {
  693.       S_Padding[0]=32;
  694.       S_Padding[1]=0;
  695.       }
  696.  
  697.    if ((T > 89)&&(T<98)) T-=89;
  698.    Wk[0]=0;
  699.    if  (T<8)
  700.        {
  701.        strcpy(Wk,S_Padding);
  702.        strcat(Wk,S_EditStr);
  703.        strcat(Wk," ");
  704.        }
  705.    else
  706.        {
  707.        strcat(Wk,S_EditStr);
  708.        strcat(Wk,S_Padding);
  709.        }
  710.  
  711.    S_Write(R,C,L+1,Wk,S_NormAttrib);
  712.  
  713.    }
  714.  
  715.  
  716.  
  717.  
  718.  
  719. void S_FillScreen()
  720. {
  721. int  Sign,DecPos,S_PointHold,Screen_Point,p,x,y,z,C;
  722. unsigned char WorkAttrib;
  723. double dbl_work, rounding, *Dbl;
  724.  
  725. S_PointHold = S_Point;
  726. S_Point     = 0;
  727.  
  728. while (S_Point < s_indx->A.s_count[S_Num])
  729.    {
  730.    S_Decimal = (s_field->C.s_type[S_Point]>89) ?
  731.                (s_field->C.s_type[S_Point] - 90): s_field->C.s_type[S_Point];
  732.  
  733.    if  (S_Decimal > 7)
  734.        {
  735.        strcpy(S_EditStr,(char*)&S_WorkArea[(int)S_FieldPtr[S_Point]]);
  736.        s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  737.        }
  738.    else
  739.        {
  740.        dbl_work = *((double *)(S_WorkArea+S_FieldPtr[S_Point]));
  741.        if  (dbl_work!=0)
  742.            {
  743.            rounding = (dbl_work<0)?(0-S_Round[S_Decimal]):S_Round[S_Decimal];
  744.            strcpy(S_EditStr,ecvt((dbl_work+rounding),20,&DecPos,&Sign));
  745.            while (DecPos<1)
  746.                {
  747.                s_insert(S_EditStr,"0",0,20);
  748.                DecPos++;
  749.                }
  750.            s_insert(S_EditStr,".",DecPos,80);
  751.            while (S_EditStr[0]=='0') s_delete(S_EditStr,0,1);
  752.            if  (Sign)
  753.                s_insert(S_EditStr,"-",0,80);
  754.            }
  755.        else
  756.            strcpy(S_EditStr,".000000");
  757.        S_EditStr[(s_pos(S_EditStr,".")+S_Decimal)]=0;
  758.        if  (S_EditStr[0]==0)
  759.            {
  760.            S_EditStr[0]='0';
  761.            S_EditStr[1]=0;
  762.            }
  763.        x = strlen(S_EditStr);
  764.        y = x - s_field->C.s_len[S_Point];
  765.  
  766.        if  (y>0)
  767.            while (y--)
  768.                {
  769.                s_delete(S_EditStr,0,1);
  770.                x--;
  771.                }
  772.        s_field->C.s_datalen[S_Point] = x;
  773.        }
  774.  
  775.    Screen_Point = ((s_field->C.s_row[S_Point]-1)*160)
  776.                 + ((s_field->C.s_col[S_Point]-1)*2);
  777.  
  778.    if  (s_field->C.s_datalen[S_Point]>0)
  779.        WorkAttrib = (s_field->C.s_displaybg[S_Point] * 16)
  780.                   + s_field->C.s_displayfg[S_Point];
  781.    else
  782.        WorkAttrib = (s_field->C.s_normalbg[S_Point] * 16)
  783.                   +  s_field->C.s_normalfg[S_Point];
  784.  
  785.    p=0;
  786.    x=((s_field->C.s_len[S_Point])+2)*2;
  787.    y=(s_field->C.s_datalen[S_Point])*2;
  788.    if (S_Decimal > 7)
  789.       {
  790.       C=0;
  791.       while (C<x)
  792.           {
  793.           if  (C>0)
  794.               s_record->B.s_video[Screen_Point+C]=
  795.                    (C<=y)? S_EditStr[p++]:32;
  796.           else
  797.               s_record->B.s_video[Screen_Point+C]=32;
  798.           C++;
  799.           s_record->B.s_video[Screen_Point+C]= WorkAttrib;
  800.           C++;
  801.           }
  802.       }
  803.    else
  804.       {
  805.       z=(x-y)-4;
  806.       C=0;
  807.       while (C<x)
  808.           {
  809.           if  (C>0)
  810.               s_record->B.s_video[Screen_Point+C]= (C>z)?S_EditStr[p++]:32;
  811.           else
  812.               s_record->B.s_video[Screen_Point+C]=32;
  813.           C++;
  814.           s_record->B.s_video[Screen_Point+C]= WorkAttrib;
  815.           C++;
  816.           }
  817.       }
  818.    S_Point++;
  819.    }
  820.  
  821. puttext(1,1,80,24,&s_record->B.s_video[0]);
  822. S_Point = S_PointHold;
  823. }
  824.  
  825.  
  826.  
  827. void S_GetKey()
  828.    {
  829.    static int C_nt;
  830.    static unsigned char Two_Keys, Toggle,KeyDetected;
  831.    char ch;
  832.    typedef union
  833.        {
  834.        int ch;
  835.        struct{
  836.       unsigned char lsb;
  837.           unsigned char msb;
  838.           } byte;
  839.        }keyindef;
  840.  
  841.    keyindef keyin;
  842.    keyindef shiftstat;
  843.  
  844.    S_ResetKeyFlags();
  845.  
  846.    if  (S_Msg[0]!=0)
  847.        S_DisplayMessage(S_MessBg,S_MessFg,S_Msg);
  848.  
  849.    do
  850.        {
  851.        Two_Keys    = 0;
  852.        Toggle      = 0;
  853.        KeyDetected = 0;
  854.        keyin.ch    = 0;
  855.        while (!KeyDetected)
  856.            {
  857.            while ((!KeyDetected)&&(!Two_Keys)&&(!Toggle))
  858.                {
  859.                shiftstat.ch = bioskey(2);
  860.                C_nt = 0;
  861.                if  (shiftstat.byte.lsb & 1) C_nt++;
  862.                if  (shiftstat.byte.lsb & 2) C_nt++;
  863.                if  (shiftstat.byte.lsb & 4) C_nt++;
  864.                if  (shiftstat.byte.lsb & 8) C_nt++;
  865.                if  (C_nt > 1)
  866.                    Two_Keys = 1;
  867.  
  868.                if  (shiftstat.byte.lsb & 16)
  869.                    {
  870.                    if (!S_ScrollLock) Toggle = 1;
  871.                    }
  872.                else
  873.                    if  (S_ScrollLock) Toggle = 1;
  874.  
  875.                if  (shiftstat.byte.lsb & 33)
  876.                    {
  877.                    if (!S_NumLock)   Toggle = 1;
  878.                    }
  879.                else
  880.                    if  (S_NumLock) Toggle = 1;
  881.  
  882.                if  (shiftstat.byte.lsb & 64)
  883.                    {
  884.                    if (!S_Caps)    Toggle = 1;
  885.                    }
  886.                else
  887.                    if (S_Caps)     Toggle = 1;
  888.  
  889.                if  (shiftstat.byte.lsb & 128)
  890.                    {
  891.                    if (!S_InsertMode) Toggle = 1;
  892.                    }
  893.                else
  894.                    if  (S_InsertMode) Toggle = 1;
  895.                if (!bioskey(1)==0) KeyDetected = 1;
  896.                }
  897.  
  898.            if  (KeyDetected)
  899.                keyin.ch = bioskey(0);
  900.  
  901.            S_RightShift = 0;
  902.            S_LeftShift  = 0;
  903.            S_Shift      = 0;
  904.            S_ScrollLock = 0;
  905.            S_Caps       = 0;
  906.            S_InsertMode = 0;
  907.            S_NumLock    = 0;
  908.            C_nt         = 0;
  909.  
  910.            if  (shiftstat.byte.lsb & 1){S_RightShift = 1; C_nt++; S_Shift = 1;}
  911.            if  (shiftstat.byte.lsb & 2){S_LeftShift  = 1; C_nt++; S_Shift = 1;}
  912.            if  (shiftstat.byte.lsb & 4){S_Ctrl       = 1; C_nt++;}
  913.            if  (shiftstat.byte.lsb & 8){S_Alt        = 1; C_nt++;}
  914.            if  (shiftstat.byte.lsb & 16)  S_ScrollLock = 1;
  915.            if  (shiftstat.byte.lsb & 32)  S_NumLock    = 1;
  916.            if  (shiftstat.byte.lsb & 64)  S_Caps       = 1;
  917.            if  (shiftstat.byte.lsb & 128) S_InsertMode = 1;
  918.  
  919.            if  (Two_Keys)
  920.                {
  921.                keyin.ch    = 0;
  922.                S_Ch        = 0;
  923.                S_Fkey      = 1;
  924.                goto Exit;
  925.                }
  926.  
  927.            if  (S_ShowStatus)
  928.                {
  929.                memset(S_StatusAttrib,2,40);
  930.                if  (S_InsertMode) memset(S_StatusAttrib,32,8);
  931.                if  (S_Caps)       memset(&S_StatusAttrib[9],32,6);
  932.                if  (S_NumLock)    memset(&S_StatusAttrib[16],32,10);
  933.                if  (S_ScrollLock) memset(&S_StatusAttrib[27],32,13);
  934.                setmem(S_Padding,80,32);
  935.                setmem(S_WorkAttrib,80,0);
  936.                memmove((char *)&S_Padding[21],S_StatusLine,40);
  937.                memmove((char *)&S_WorkAttrib[21],S_StatusAttrib,40);
  938.                S_Write(25,1,80,S_Padding,S_WorkAttrib);
  939.                Toggle = 0;
  940.                }
  941.            }
  942.        }
  943.    while (keyin.ch == 0);
  944.  
  945.    if  ((S_Ctrl) && (keyin.byte.lsb > 0) && (keyin.byte.lsb < 29))
  946.        {
  947.        S_Fkey = 1;
  948.        ch     = keyin.byte.lsb + 64;
  949.        goto Exit;
  950.        }
  951.  
  952.    ch = 0;
  953.  
  954.    if  ((keyin.byte.lsb == 0)&&(keyin.byte.msb>0))
  955.        {
  956.        S_Fkey = 1;
  957.        switch (keyin.byte.msb){
  958.          case 59 : S_F1   = 1; break; /* regular fkeys */
  959.          case 60 : S_F2   = 1; break;
  960.          case 61 : S_F3   = 1; break;
  961.          case 62 : S_F4   = 1; break;
  962.          case 63 : S_F5   = 1; break;
  963.          case 64 : S_F6   = 1; break;
  964.          case 65 : S_F7   = 1; break;
  965.          case 66 : S_F8   = 1; break;
  966.          case 67 : S_F9   = 1; break;
  967.          case 68 : S_F10  = 1; break;
  968.          case 133: S_F11  = 1; break;
  969.          case 134: S_F12  = 1; break;
  970.          case 84 : S_F1   = 1; break; /* shifted fkeys */
  971.          case 85 : S_F2   = 1; break;
  972.          case 86 : S_F3   = 1; break;
  973.          case 87 : S_F4   = 1; break;
  974.          case 88 : S_F5   = 1; break;
  975.          case 89 : S_F6   = 1; break;
  976.          case 90 : S_F7   = 1; break;
  977.          case 91 : S_F8   = 1; break;
  978.          case 92 : S_F9   = 1; break;
  979.          case 93 : S_F10  = 1; break;
  980.          case 135: S_F11  = 1; break;
  981.          case 136: S_F12  = 1; break;
  982.          case 94 : S_F1   = 1; break; /* control fkeys */
  983.          case 95 : S_F2   = 1; break;
  984.          case 96 : S_F3   = 1; break;
  985.          case 97 : S_F4   = 1; break;
  986.          case 98 : S_F5   = 1; break;
  987.          case 99 : S_F6   = 1; break;
  988.          case 100: S_F7   = 1; break;
  989.          case 101: S_F8   = 1; break;
  990.          case 102: S_F9   = 1; break;
  991.          case 103: S_F10  = 1; break;
  992.          case 137: S_F11  = 1; break;
  993.          case 138: S_F12  = 1; break;
  994.          case 104: S_F1   = 1; break; /* alt fkeys */
  995.          case 105: S_F2   = 1; break;
  996.          case 106: S_F3   = 1; break;
  997.          case 107: S_F4   = 1; break;
  998.          case 108: S_F5   = 1; break;
  999.          case 109: S_F6   = 1; break;
  1000.          case 110: S_F7   = 1; break;
  1001.          case 111: S_F8   = 1; break;
  1002.          case 112: S_F9   = 1; break;
  1003.          case 113: S_F10  = 1; break;
  1004.          case 139: S_F11  = 1; break;
  1005.          case 140: S_F12  = 1; break;
  1006.          case 71 : S_Home = 1; break; /* regular & shift cursor keys */
  1007.          case 79 : S_End  = 1; break;
  1008.          case 73 : S_PgUp = 1; break;
  1009.          case 81 : S_PgDn = 1; break;
  1010.          case 75 : S_Left = 1; break;
  1011.          case 77 : S_Right= 1; break;
  1012.          case 72 : S_Up   = 1; break;
  1013.          case 80 : S_Down = 1; break;
  1014.          case 82 : S_Ins  = 1; break;
  1015.          case 83 : S_Del  = 1; break;
  1016.          case 15 : S_Tab  = 1; break;
  1017.          case 119: S_Home = 1; break; /* control cursor control keys */
  1018.          case 117: S_End  = 1; break;
  1019.          case 132: S_PgUp = 1; break;
  1020.          case 118: S_PgDn = 1; break;
  1021.          case 115: S_Left = 1; break;
  1022.          case 116: S_Right= 1; break;
  1023.          case 16 : ch     = 'Q'; break; /* alt alpha keys */
  1024.          case 17 : ch     = 'W'; break;
  1025.          case 18 : ch     = 'E'; break;
  1026.      case 19 : ch     = 'R'; break;
  1027.      case 20 : ch     = 'T'; break;
  1028.      case 21 : ch     = 'Y'; break;
  1029.      case 22 : ch     = 'U'; break;
  1030.      case 23 : ch     = 'I'; break;
  1031.      case 24 : ch     = 'O'; break;
  1032.          case 25 : ch     = 'P'; break;
  1033.          case 30 : ch     = 'A'; break;
  1034.      case 31 : ch     = 'S'; break;
  1035.      case 32 : ch     = 'D'; break;
  1036.      case 33 : ch     = 'F'; break;
  1037.      case 34 : ch     = 'G'; break;
  1038.      case 35 : ch     = 'H'; break;
  1039.      case 36 : ch     = 'J'; break;
  1040.      case 37 : ch     = 'K'; break;
  1041.      case 38 : ch     = 'L'; break;
  1042.      case 44 : ch     = 'Z'; break;
  1043.      case 45 : ch     = 'X'; break;
  1044.      case 46 : ch     = 'C'; break;
  1045.      case 47 : ch     = 'V'; break;
  1046.      case 48 : ch     = 'B'; break;
  1047.      case 49 : ch     = 'N'; break;
  1048.      case 50 : ch     = 'M'; break;
  1049.      case 129: ch     = '0'; break;
  1050.      case 120: ch     = '1'; break;
  1051.      case 121: ch     = '2'; break;
  1052.      case 122: ch     = '3'; break;
  1053.      case 123: ch     = '4'; break;
  1054.      case 124: ch     = '5'; break;
  1055.      case 125: ch     = '6'; break;
  1056.      case 126: ch     = '7'; break;
  1057.      case 127: ch     = '8'; break;
  1058.      case 128: ch     = '9'; break;
  1059.      case 130: ch     = '-'; break;
  1060.      case 131: ch     = '='; break;
  1061.      case 114: ch     = '*'; break;
  1062.          }
  1063.        }
  1064.    if  ((keyin.byte.msb != 0) &&
  1065.         (!S_Alt))
  1066.        {
  1067.        switch (keyin.byte.lsb)
  1068.            {
  1069.            case   9 : {S_Tab   = 1;break;}
  1070.            case   8 : {S_BkSp  = 1;break;}
  1071.            case 127 : {S_BkSp  = 1;break;}
  1072.            case  27 : {S_Esc   = 1;break;}
  1073.            case  13 : {S_Enter = 1;break;}
  1074.            default  : ch = keyin.byte.lsb;
  1075.            }
  1076.        if  ((S_Tab)||(S_BkSp)||(S_Esc)||(S_Enter))
  1077.            S_Fkey = 1;
  1078.        }
  1079.    Exit:
  1080.    S_Ch = ch;
  1081.    }
  1082.  
  1083.  
  1084.  
  1085.  
  1086.  
  1087.  
  1088. void S_Get_Field_Value(int S_Point)
  1089.    {
  1090.    int    DecPos,Sign,x,y,z;
  1091.    double dbl_work,rounding;
  1092.  
  1093.    S_Decimal = (s_field->C.s_type[S_Point]>89) ?
  1094.                (s_field->C.s_type[S_Point] - 90): s_field->C.s_type[S_Point];
  1095.  
  1096.    if  (S_Decimal > 7)
  1097.        strcpy(S_EditStr,(char*)&S_WorkArea[(int)S_FieldPtr[S_Point]]);
  1098.    else
  1099.        {
  1100.        dbl_work = *((double *)(S_WorkArea+S_FieldPtr[S_Point]));
  1101.        if  (dbl_work!=0)
  1102.            {
  1103.            rounding = (dbl_work<0)?(0-S_Round[S_Decimal]):S_Round[S_Decimal];
  1104.            strcpy(S_EditStr,(char *)ecvt((dbl_work+rounding),
  1105.                   20,&DecPos,&Sign));
  1106.            while (DecPos<0)
  1107.                {
  1108.                s_insert(S_EditStr,"0",0,20);
  1109.                DecPos++;
  1110.                }
  1111.            s_insert(S_EditStr,".",DecPos,80);
  1112.            while (S_EditStr[0]=='0') s_delete(S_EditStr,0,1);
  1113.            if  (Sign)
  1114.                s_insert(S_EditStr,"-",0,80);
  1115.            }
  1116.        else
  1117.            strcpy(S_EditStr,".000000");
  1118.        S_EditStr[(s_pos(S_EditStr,".")+S_Decimal)]=0;
  1119.        if  (S_EditStr[0]==0)
  1120.            {
  1121.            S_EditStr[0]='0';
  1122.            S_EditStr[1]=0;
  1123.            }
  1124.        x = strlen(S_EditStr);
  1125.        y = x - s_field->C.s_len[S_Point];
  1126.  
  1127.        if  (y>0)
  1128.            while (y--)
  1129.                {
  1130.                s_delete(S_EditStr,0,1);
  1131.                x--;
  1132.                }
  1133.        s_field->C.s_datalen[S_Point] = x;
  1134.        }
  1135.    }
  1136.  
  1137.  
  1138.  
  1139.  
  1140.  
  1141. void S_EditString (int R, int C, int T, int L, int B,
  1142.                    int F, int DB, int DF, int NB, int NF,
  1143.                    int HR, int HL, char *S)
  1144.    {
  1145.    int    x,y,z;
  1146.    static char   S_CurString[160];
  1147.    double DoubleWork;
  1148.    long   rec;
  1149.  
  1150.    if  (S_FirstTime) S_Init();
  1151.    S_SetCursor(S_Cursor);
  1152.  
  1153.    if  ( (s_pos("0.000000",S)==0) || (s_pos(".000000",S)==0) )
  1154.        S[0]=0;
  1155.  
  1156.    S_Str_Pos = 1;
  1157.  
  1158.    strcpy(S_Ins_Str," ");
  1159.  
  1160.    S_Attrib  = (B*16)+F;
  1161.    S_Reverse = (S_Attrib > 16) ? 15:((7*16)+F);
  1162.  
  1163.    strcpy(S_WorkStr,S_Blanks);
  1164.  
  1165.    x = 0;
  1166.  
  1167.    while (S[x]!=0) S_WorkStr[x]=S[x++];
  1168.    S_WorkStr[L]=0;
  1169.    S_Str_Pos = 1;
  1170.    if  (S_PosLastChar)
  1171.        {
  1172.        S_Str_Pos = s_strlen(S)-1;
  1173.        if (S_Str_Pos < 0)
  1174.           S_Str_Pos = 1;
  1175.        else
  1176.           if (S_Str_Pos < L) S_Str_Pos++;
  1177.        }
  1178.    S_PosLastChar = 0;
  1179.  
  1180.    S_ResetKeyFlags();
  1181.  
  1182.  
  1183.    while ((!S_Enter)&&(!S_Tab)&&(!S_Esc)&&(!S_Fkey))
  1184.        {
  1185.        setmem(S_CurString,160,0);
  1186.        S_CurString[0]=32;
  1187.        S_CurString[1]=S_Attrib;
  1188.        x = 0;
  1189.        y = 0;
  1190.        while (x<L)
  1191.           {
  1192.           y = (x*2)+2;
  1193.           S_CurString[y]   =S_WorkStr[x];
  1194.           S_CurString[y+1] =S_Attrib;
  1195.           x++;
  1196.           }
  1197.        y = (x*2)+2;
  1198.        S_CurString[y]  =32;
  1199.        S_CurString[y+1]=S_Attrib;
  1200.  
  1201.        S_CurString[(S_Str_Pos*2)+1]=S_Reverse;
  1202.        puttext(C,R,C+(L+1),R,(char *)&S_CurString);
  1203.        gotoxy((C+S_Str_Pos),R);
  1204.  
  1205.        S_GetKey();
  1206.  
  1207.        S_CurString[(S_Str_Pos*2)+1]=S_Attrib;
  1208.  
  1209.        puttext(C,R,C+(L+1),R,(char *)&S_CurString);
  1210.  
  1211.        if  (S_Ins)
  1212.            {
  1213.            S_Ins  = 0;
  1214.            S_Fkey = 0;
  1215.            continue;
  1216.            }
  1217.  
  1218.        if  ((S_Left)||(S_BkSp))
  1219.            {
  1220.            if  (S_Str_Pos > 1)
  1221.                {
  1222.                S_Str_Pos--;
  1223.                if  (S_BkSp) S_Del = 1;
  1224.                }
  1225.            else
  1226.                {
  1227.                if  (S_Left)
  1228.                    {
  1229.                    S_Shift       = 1;
  1230.                    S_Tab         = 1;
  1231.                    S_PosLastChar = 1;
  1232.                    }
  1233.                }
  1234.            S_Left  = 0;
  1235.            S_BkSp  = 0;
  1236.            S_Fkey  = 0;
  1237.            if  (!S_Del) continue;
  1238.            }
  1239.  
  1240.        if  (S_Right)
  1241.            {
  1242.            if  (S_Str_Pos < L)
  1243.                {
  1244.                if  (T>7)
  1245.                    S_Str_Pos++;
  1246.                else
  1247.                    {
  1248.                    if  (S_Str_Pos==(s_strlen(S_WorkStr)+1))
  1249.                        S_Tab = 1;
  1250.                    else
  1251.                        S_Str_Pos++;
  1252.                    }
  1253.                }
  1254.            else
  1255.                S_Tab = 1;
  1256.            S_Shift = 0;
  1257.            S_Right = 0;
  1258.            S_Fkey  = 0;
  1259.            continue;
  1260.            }
  1261.  
  1262.        if  (S_Del)
  1263.            {
  1264.            if  (s_strlen(S_WorkStr)>-1)
  1265.                {
  1266.                s_delete(S_WorkStr,(S_Str_Pos-1),1);
  1267.                strcat(S_WorkStr," ");
  1268.                }
  1269.            S_Fkey = 0;
  1270.            continue;
  1271.            }
  1272.  
  1273.        if  ((S_Ch > 31)&&(S_Ch < 128))
  1274.            {
  1275.            if  (T<8)
  1276.                {
  1277.                if  (S_Ch=='?')
  1278.                    {
  1279.                    if  (S_Str_Pos > 1) S_Ch = 0;
  1280.                    }
  1281.                else
  1282.                    {
  1283.                    if  (((S_Ch=='-')&&(S_Str_Pos>1))||
  1284.                 ((S_Ch=='.')&&(T==0))||
  1285.                 ((S_Ch!='.')&&(S_Ch!='-')&&((S_Ch<'0')||(S_Ch>'9'))))
  1286.                    S_Ch = 0;
  1287.                    }
  1288.                }
  1289.            if  (T==8)
  1290.                {
  1291.                if  (S_Ch=='?')
  1292.                    {
  1293.                    if  (S_Str_Pos > 1) S_Ch = 0;
  1294.                    }
  1295.                else
  1296.                    {
  1297.                if  ((S_Ch!=32)&&
  1298.                         ((S_Ch<'A')||(S_Ch>'Z'))&&
  1299.                 ((S_Ch<'a')||(S_Ch>'z')))
  1300.                    S_Ch = 0;
  1301.                    }
  1302.                }
  1303.            if  (S_Ch>0)
  1304.                {
  1305.                if  (S_InsertMode)
  1306.                    {
  1307.                    S_Ins_Str[0]=S_Ch;
  1308.                    S_Ins_Str[1]=0;
  1309.                    s_insert(S_WorkStr,S_Ins_Str,(S_Str_Pos-1),L);
  1310.                    S_WorkStr[L]=0;
  1311.                    if  (S_Str_Pos < L)
  1312.                        S_Str_Pos++;
  1313.                    else
  1314.                        {
  1315.                        S_Tab  =1;
  1316.                        S_Shift=0;
  1317.                        }
  1318.                    continue;
  1319.                    }
  1320.                else
  1321.                    {
  1322.                    S_WorkStr[S_Str_Pos-1]=S_Ch;
  1323.                    if  (S_Str_Pos < L)
  1324.                        S_Str_Pos++;
  1325.                    else
  1326.                        {
  1327.                        S_Tab  =1;
  1328.                        S_Shift=0;
  1329.                        }
  1330.                    continue;
  1331.                    }
  1332.                }
  1333.            }
  1334.        if  (((S_Enter)||(S_Tab))&&(S_WorkStr[0] == '?'))
  1335.            {
  1336.            S_Msg[0] = 0;
  1337.            if  (HR > 0)
  1338.                {
  1339.                rec = HR * sizeof(*s_record);
  1340.                fseek(s_file,rec,0);
  1341.                fread(s_indx,sizeof(*s_field),1,s_file);
  1342.                if  (s_indx->D.s_rangelist[HL-1][1]=='H')
  1343.                    {
  1344.                    s_indx->D.s_rangelist[HL-1][s_indx->D.s_rangelist[HL-1][0]]=0;
  1345.                    strcpy(S_Msg,&s_indx->D.s_rangelist[HL-1][6]);
  1346.                    }
  1347.                rec = 0;
  1348.                fseek(s_file,rec,0);
  1349.                fread(s_indx,sizeof(*s_field),1,s_file);
  1350.                for (x=0;x < s_indx->A.s_sfiled;x++)
  1351.                    {
  1352.                    y = s_indx->A.s_name[x][0];
  1353.                    for (z=1;z< (y+2);z++)
  1354.                        s_indx->A.s_name[x][z-1]=
  1355.                        s_indx->A.s_name[x][z];
  1356.                    s_indx->A.s_name[x][y]=0;
  1357.                    }
  1358.                }
  1359.            if (S_Msg[0] == 0)
  1360.                strcpy(S_Msg," No Help is available for this field ");
  1361.            S_Str_Pos = S_Str_Pos - 1;
  1362.            strcpy(S_WorkStr,&S_WorkStr[1]);
  1363.            S_Enter = 0;
  1364.            S_Tab   = 0;
  1365.            S_Wait  = 1;
  1366.            S_Fkey  = 0;
  1367.            }
  1368.        }
  1369.  
  1370.    S_SetCursor(S_OFF);
  1371.    strcpy(S_EditStr,S_WorkStr);
  1372.    if  (s_strlen(S_WorkStr)>-1)
  1373.        S_EditStr[s_strlen(S_WorkStr)]=0;
  1374.    if  (T<8)
  1375.        {
  1376.        y=strlen(S_EditStr);
  1377.        while ((y>0)&&(S_EditStr[y-1]<33))
  1378.           {
  1379.           S_EditStr[y-1]=0;
  1380.           y--;
  1381.           }
  1382.        if  (strchr(S_EditStr,'.')==NULL)
  1383.            strcat(S_EditStr,".000000");
  1384.        else
  1385.            strcat(S_EditStr,"000000");
  1386.        S_EditStr[s_pos(S_EditStr,".")+T]=0;
  1387.        S_Str_Pos = (S_EditStr[0]=='-')?1:0;
  1388.        while ((S_EditStr[0]==32)||(strlen(S_EditStr)>L))
  1389.          s_delete(S_EditStr,S_Str_Pos,1);
  1390.        if  (strcmp("-",S_EditStr)==0) S_EditStr[0]=0;
  1391.        }
  1392.    strcpy(S_NewStr,S_EditStr);
  1393.    S_WorkStr[0]=32;
  1394.    S_WorkStr[1]=0;
  1395.    strcat(S_WorkStr,S_EditStr);
  1396.    strcat(S_WorkStr," ");
  1397.    S_DisplayScreenField(R,C,T,L,strlen(S_WorkStr),DF,DB,NF,NB,S_WorkStr);
  1398.    strcpy(S_EditStr,S_NewStr);
  1399.    }
  1400.  
  1401.  
  1402.  
  1403. void S_Find_Min_and_Max()
  1404. {
  1405. int C1, C2, s_len;
  1406.  
  1407. S_CompMin[0]=0;
  1408. S_CompMax[0]=0;
  1409. C1 = 0;
  1410. C2 = 0;
  1411.  
  1412. s_len=strlen(S_CurStr);
  1413.  
  1414. S_Min_Max_Loaded = 0;
  1415. S_EndofLine    = 0;
  1416.  
  1417. while (!S_Min_Max_Loaded)
  1418.     {
  1419.     S_Sub++;
  1420.     if  (S_Sub<s_len)
  1421.         {
  1422.         if  (S_CurStr[S_Sub]==94)
  1423.             {
  1424.             S_Sub++;
  1425.             S_CompMax[C2++]=S_CurStr[S_Sub];
  1426.             }
  1427.         else
  1428.             {
  1429.             if  (S_CurStr[S_Sub]==39)
  1430.                 {
  1431.                 if  (S_CompMax[0]==0)
  1432.                     strcpy(S_CompMax,S_CompMin);
  1433.                 S_Min_Max_Loaded = 1;
  1434.                 }
  1435.             else
  1436.                 {
  1437.                 if  (S_CompMax[0]==0)
  1438.                     {
  1439.                     S_CompMin[C1++]=S_CurStr[S_Sub];
  1440.                     S_CompMin[C1]=0;
  1441.                     }
  1442.                 else
  1443.                     {
  1444.                     S_CompMax[C2++]=S_CurStr[S_Sub];
  1445.                     S_CompMax[C2]=0;
  1446.                     }
  1447.                 }
  1448.             }
  1449.         if  ((S_CompMin[0]==92)||(S_CompMin[0]==61))
  1450.             S_Min_Max_Loaded = 1;
  1451.         }
  1452.     else
  1453.         {
  1454.         S_Min_Max_Loaded=1;
  1455.         S_EndofLine   =1;
  1456.         }
  1457.     }
  1458. if  (S_UpCase)
  1459.     {
  1460.     strcpy(S_CompMin,strupr(S_CompMin));
  1461.     strcpy(S_CompMax,strupr(S_CompMax));
  1462.     }
  1463. }
  1464.  
  1465.  
  1466. void S_ReadNextRangeRec()
  1467. {
  1468. long rec;
  1469.  
  1470. S_CurrLine = S_NextLine;
  1471.  
  1472. if  (S_RecNo != S_NextRec)
  1473.     {
  1474.     rec = (S_NextRec)*sizeof(*s_record);
  1475.     fseek(s_file,rec,0);
  1476.     fread(s_record,sizeof(*s_record),1,s_file);
  1477.     S_RecNo = S_NextRec;
  1478.     }
  1479.  
  1480. S_NextRec   = s_record->D.s_rangerec [S_CurrLine];
  1481. S_NextLine  = s_record->D.s_rangeline[S_CurrLine]-1;
  1482. movmem(&s_record->D.s_rangelist[S_CurrLine][1],&S_CurStr,
  1483.        s_record->D.s_rangelist[S_CurrLine][0]);
  1484. S_CurStr[s_record->D.s_rangelist[S_CurrLine][0]]=0;
  1485. S_Sub = (S_InsideIf) ? 4:1;
  1486. S_CompMin[0]=0;
  1487. S_CompMax[0]=0;
  1488.  
  1489. }
  1490.  
  1491.  
  1492.  
  1493. void S_ProcessDate()
  1494. {
  1495. char
  1496.    DateMask[40],
  1497.    TestMonth[3],
  1498.    TestDay[3],
  1499.    TestYear[5],
  1500.    CheckMonth,
  1501.    CheckDay,
  1502.    CheckYear;
  1503. int
  1504.    x,y,z,
  1505.    WorkMonth,
  1506.    WorkDay,
  1507.    WorkYear,
  1508.    WorkNum;
  1509.  
  1510. CheckMonth   = 0;
  1511. CheckDay     = 0;
  1512. CheckYear    = 0;
  1513. WorkMonth    = 0;
  1514. WorkDay      = 0;
  1515. WorkYear     = 0;
  1516. S_Msg[0]     = 0;
  1517. x = (S_InsideIf) ? 8:5;
  1518. z = x;
  1519. y = 0;
  1520.  
  1521. while (S_CurStr[x]!=0)
  1522.     {
  1523.     switch (S_CurStr[x])
  1524.         {
  1525.         case 'D':{
  1526.                  if  (!isdigit(S_EditStr[y]))
  1527.                      {
  1528.                      strcpy(S_Msg,"Day contains a invalid character for <");
  1529.                      strcat(S_Msg,(char *)&S_CurStr[z]);
  1530.                      strcat(S_Msg,"> Format");
  1531.                      goto Exit_Point;
  1532.                      }
  1533.                  CheckDay++;
  1534.                  TestDay[CheckDay-1]=S_EditStr[y];
  1535.                  TestDay[CheckDay]  =0;
  1536.                  break;
  1537.                  }
  1538.         case 'M':{
  1539.                  if  (!isdigit(S_EditStr[y]))
  1540.                      {
  1541.                      strcpy(S_Msg,"Month contains a invalid character for <");
  1542.                      strcat(S_Msg,(char *)&S_CurStr[z]);
  1543.                      strcat(S_Msg,"> Format");
  1544.                      goto Exit_Point;
  1545.                      }
  1546.                  CheckMonth++;
  1547.                  TestMonth[CheckMonth-1]=S_EditStr[y];
  1548.                  TestMonth[CheckMonth]  =0;
  1549.                  break;
  1550.                  }
  1551.         case 'Y':{
  1552.                  if  (!isdigit(S_EditStr[y]))
  1553.                      {
  1554.                      strcpy(S_Msg,"Year contains a invalid character for <");
  1555.                      strcat(S_Msg,(char *)&S_CurStr[z]);
  1556.                      strcat(S_Msg,"> Format");
  1557.                      goto Exit_Point;
  1558.                      }
  1559.                  CheckYear++;
  1560.                  TestYear[CheckYear-1]=S_EditStr[y];
  1561.                  TestYear[CheckYear]  =0;
  1562.                  break;
  1563.                  }
  1564.         default :{
  1565.                  if  (S_EditStr[y]!=S_CurStr[x])
  1566.                      {
  1567.                      strcpy(S_Msg,"Please enter date in <");
  1568.                      strcat(S_Msg,(char *)&S_CurStr[z]);
  1569.                      strcat(S_Msg,"> Format");
  1570.                      goto Exit_Point;
  1571.                      }
  1572.                  }
  1573.         }
  1574.     y++;
  1575.     x++;
  1576.     }
  1577.  
  1578. if  (S_EditStr[y]!=0)
  1579.     {
  1580.     strcpy(S_Msg,"You have keyed to many charactes for <");
  1581.     strcat(S_Msg,(char *)&S_CurStr[z]);
  1582.     strcat(S_Msg,"> Format");
  1583.     goto Exit_Point;
  1584.     }
  1585.  
  1586. WorkDay   = (CheckDay  >0) ? atoi(TestDay)  :0;
  1587. WorkMonth = (CheckMonth>0) ? atoi(TestMonth):0;
  1588. WorkYear  = (CheckYear >0) ? atoi(TestYear) :0;
  1589. WorkNum   = (WorkYear/4);
  1590. WorkNum  *= 4;
  1591. WorkNum  -= WorkYear;
  1592.  
  1593. if  ((CheckMonth>0)&&((WorkMonth < 1)||(WorkMonth>12)))
  1594.     {
  1595.     strcpy(S_Msg,"You have keyed a invalid Month. Use 1 thru 12 only");
  1596.     goto Exit_Point;
  1597.     }
  1598.  
  1599. if  (CheckDay>0)
  1600.     {
  1601.     if  ((WorkMonth==4)||(WorkMonth==6)||(WorkMonth==9)||(WorkMonth==11))
  1602.         {
  1603.         if  (WorkDay>30)
  1604.             {
  1605.             strcpy(S_Msg,"This month can have only 30 days or less");
  1606.             goto Exit_Point;
  1607.             }
  1608.         }
  1609.     else
  1610.         {
  1611.         if  ((WorkMonth!=2)&&(WorkDay>31))
  1612.             {
  1613.             strcpy(S_Msg,"This month can have only 31 days or less");
  1614.             goto Exit_Point;
  1615.             }
  1616.         else
  1617.             {
  1618.             if  (WorkMonth == 2)
  1619.                 {
  1620.                 if  (WorkNum==0)
  1621.                     {
  1622.                     if  (WorkDay>29)
  1623.                         {
  1624.                         strcpy(S_Msg,"February can have only 29 days or less");
  1625.                         goto Exit_Point;
  1626.                         }
  1627.                     }
  1628.                 else
  1629.                     {
  1630.                     if  (WorkDay>28)
  1631.                         {
  1632.                         strcpy(S_Msg,"February can have only 28 days or less");
  1633.                         goto Exit_Point;
  1634.                         }
  1635.                     }
  1636.                 }
  1637.             }
  1638.         }
  1639.     }
  1640.  
  1641. if  ((CheckYear>0)&&(WorkYear<1))
  1642.     {
  1643.     strcpy(S_Msg,"Year must have a value greater than zero.");
  1644.     goto Exit_Point;
  1645.     }
  1646.  
  1647. Exit_Point:
  1648.  
  1649. if  (S_Msg[0]!=0)
  1650.     {
  1651.     S_ScreenValid       = 0;
  1652.     S_Validate_Finished = 1;
  1653.     S_PointHold         = 0;
  1654.     S_Skip              = 1;
  1655.     }
  1656. }
  1657.  
  1658.  
  1659.  
  1660. void S_ProcessIn()
  1661. {
  1662. int x,y,z;
  1663.  
  1664. S_Decimal = (s_field->C.s_type[S_Point]>89)
  1665.           ? (s_field->C.s_type[S_Point] - 90)
  1666.           : s_field->C.s_type[S_Point];
  1667.  
  1668. S_Matched    = 0;
  1669. S_CompMin[0] = 0;
  1670.  
  1671. if  (!S_Matched)
  1672.     {
  1673.     while ((!S_Matched)&&(S_CompMin[0]!=92)&&(S_CompMin[0]!='='))
  1674.         {
  1675.         S_Find_Min_and_Max();
  1676.         if  ((S_CompMin[0]!=92)&&(S_CompMin[0]!='=')&&(!S_EndofLine))
  1677.             {
  1678.             if  (S_Decimal < 8)
  1679.                 {
  1680.                 S_Numeric       = atof(S_EditStr);
  1681.                 S_CompMin_Numeric = atof(S_CompMin);
  1682.                 S_CompMax_Numeric = atof(S_CompMax);
  1683.                 if  ((S_Numeric >= S_CompMin_Numeric) &&
  1684.                     (S_Numeric  <= S_CompMax_Numeric))
  1685.                     S_Matched = 1;
  1686.                 }
  1687.             else
  1688.                 {
  1689.                 if  ((strcmp(S_EditStr,S_CompMin)>=0) &&
  1690.                     (strcmp(S_EditStr,S_CompMax)<=0))
  1691.                     S_Matched = 1;
  1692.                 }
  1693.             }
  1694.         if  ((S_EndofLine) && ((S_CompMin[0]==0) && (S_CompMax[0]==0)))
  1695.             {
  1696.             S_ReadNextRangeRec();
  1697.             while ((S_CurStr[S_Sub]!=39)&&
  1698.                    (S_CurStr[S_Sub]!=92)&&
  1699.                    (S_CurStr[S_Sub++]!='='));
  1700.             if  ((S_CurStr[S_Sub]==92)||(S_CurStr[S_Sub]=='='))
  1701.                 {
  1702.                 S_CompMin[0]=S_CurStr[S_Sub];
  1703.                 S_CompMin[1]=0;
  1704.                 }
  1705.             }
  1706.         }
  1707.     }
  1708.  
  1709. if  (S_Matched)
  1710.     {
  1711.     while ((S_CurStr[S_Sub]!=92)&&(S_CurStr[S_Sub]!='='))
  1712.         {
  1713.         S_Sub=0;
  1714.         while ((S_CurStr[S_Sub]!=0)&&
  1715.                (S_CurStr[S_Sub]!=92)&&
  1716.                (S_CurStr[S_Sub]!='=')) S_Sub++;
  1717.         if  ((S_CurStr[S_Sub]!=92)&&(S_CurStr[S_Sub]!='='))
  1718.             {
  1719.             S_ReadNextRangeRec();
  1720.             S_Sub=0;
  1721.             }
  1722.         }
  1723.     if  (S_CurStr[S_Sub]=='=')
  1724.         {
  1725.         S_ScreenValid       = 0;
  1726.         S_Validate_Finished = 1;
  1727.         S_PointHold         = 0;
  1728.         x                   = strlen(S_CurStr);
  1729.         s_copy(S_CurStr,S_Msg,S_Sub+1,x-S_Sub);
  1730.         }
  1731.     else
  1732.         {
  1733.         S_OpCode[0]=0;
  1734.         S_Matched = 0;
  1735.         }
  1736.     }
  1737. else
  1738.     {
  1739.     if  (S_CurStr[S_Sub]==92)
  1740.         {
  1741.         S_ScreenValid       = 0;
  1742.         S_Validate_Finished = 1;
  1743.         S_PointHold         = 0;
  1744.         x                   = strlen(S_CurStr);
  1745.         s_copy(S_CurStr,S_Msg,S_Sub+1,x-S_Sub);
  1746.         }
  1747.     else
  1748.         S_OpCode[0]=0;
  1749.     }
  1750. }
  1751.  
  1752.  
  1753.  
  1754. void S_Processif()
  1755. {
  1756. int c,x,y,z;
  1757. S_Matched = 0;
  1758. S_CompMin[0]=0;
  1759. S_CompMax[0]=0;
  1760. S_EndofLine =0;
  1761.  
  1762. while (strcmp(S_CompMin,"THEN")!=0)
  1763.    {
  1764.    if  (S_EndofLine)
  1765.        {
  1766.        S_ReadNextRangeRec();
  1767.        S_Sub=0;
  1768.        while ((S_CurStr[S_Sub]!=0)&&(S_CurStr[S_Sub]!=39)) S_Sub++;
  1769.        }
  1770.  
  1771.    if  (S_CurStr[3]=='N')
  1772.        {
  1773.        x = 7;
  1774.        S_OpCode1[0]='N';
  1775.        }
  1776.    else
  1777.        {
  1778.        x = 3;
  1779.        S_OpCode1[0]=0;
  1780.        }
  1781.  
  1782.    y=0;
  1783.    while (x>0)
  1784.        {
  1785.        if  ((S_CurStr[x]!=39)&&(S_CurStr[x]!=32))
  1786.            S_CompField[y++]=S_CurStr[x++];
  1787.        else
  1788.            x=0;
  1789.        S_CompField[y]=0;
  1790.        }
  1791.  
  1792.    strupr(S_CompField);
  1793.  
  1794.    S_FieldNum = 0;
  1795.    x        = 1;
  1796.    while (x)
  1797.        {
  1798.        if  (S_FieldNum == s_indx->A.s_count[S_Num])
  1799.            {
  1800.            S_FieldNum = -1;
  1801.            x        = 0;
  1802.            }
  1803.        else
  1804.            if  (strcmp(S_CompField,strupr(s_field->C.s_fieldname[S_FieldNum]))==0)
  1805.                x=0;
  1806.            else
  1807.                S_FieldNum++;
  1808.        }
  1809.  
  1810.    S_CompMin[0]=0;
  1811.    S_CompMax[0]=0;
  1812.  
  1813.    if  (S_FieldNum > -1)
  1814.        S_Get_Field_Value(S_FieldNum);
  1815.    else
  1816.        strcpy(S_CompMin,"THEN");
  1817.  
  1818.    if  (S_UpCase)
  1819.        strupr(S_EditStr);
  1820.  
  1821.    S_Decimal = (s_field->C.s_type[S_FieldNum]>89) ?
  1822.                (s_field->C.s_type[S_FieldNum] - 90): s_field->C.s_type[S_FieldNum];
  1823.  
  1824.  
  1825.    S_EndofLine = 0;
  1826.    while ((strcmp(S_CompMin,"AND")!=0)&&
  1827.        (strcmp(S_CompMin,"OR")!=0)&&
  1828.        (strcmp(S_CompMin,"THEN")!=0))
  1829.        {
  1830.        if  (S_EndofLine)
  1831.            {
  1832.            S_ReadNextRangeRec();
  1833.            S_Sub=0;
  1834.            while ((S_CurStr[S_Sub]!=0)&&(S_CurStr[S_Sub]!=39)) S_Sub++;
  1835.            }
  1836.        S_Find_Min_and_Max();
  1837.        if  ((strcmp(S_CompMin,"AND")!=0)&&
  1838.             (strcmp(S_CompMin,"OR")!=0) &&
  1839.             (strcmp(S_CompMin,"THEN")!=0))
  1840.            {
  1841.            if  (S_Decimal<7)
  1842.                {
  1843.                S_Numeric         = atof(S_EditStr);
  1844.                S_CompMin_Numeric = atof(S_CompMin);
  1845.                S_CompMax_Numeric = atof(S_CompMax);
  1846.                if  (S_OpCode1[0]=='N')
  1847.                    {
  1848.                    if  ((S_Numeric < S_CompMin_Numeric)||
  1849.                         (S_Numeric > S_CompMax_Numeric))
  1850.                         S_Matched = 1;
  1851.                    }
  1852.                else
  1853.                    {
  1854.                    if  ((S_Numeric >= S_CompMin_Numeric)&&
  1855.                         (S_Numeric <= S_CompMax_Numeric))
  1856.                         S_Matched = 1;
  1857.                    }
  1858.                }
  1859.            else
  1860.                {
  1861.                if  (S_OpCode1[0]=='N')
  1862.                    {
  1863.                    if  ((strcmp(S_EditStr,S_CompMin)<0)||
  1864.                         (strcmp(S_EditStr,S_CompMax)>0))
  1865.                        S_Matched = 1;
  1866.                    }
  1867.                else
  1868.                    if  ((strcmp(S_EditStr,S_CompMin)>=0)&&
  1869.                         (strcmp(S_EditStr,S_CompMax)<=0))
  1870.                        S_Matched = 1;
  1871.  
  1872.                }
  1873.            }
  1874.        }
  1875.    if  (strcmp(S_CompMin,"AND")==0)
  1876.        {
  1877.        if  (!S_Matched)
  1878.            {
  1879.            S_CompMin[0]=0;
  1880.            while ((strcmp(S_CompMin,"OR")!=0)
  1881.                &&(strcmp(S_CompMin,"THEN")!=0))
  1882.                {
  1883.                S_ReadNextRangeRec();
  1884.                S_Sub=0;
  1885.                while ((S_CurStr[S_Sub]!=0)&&(S_CurStr[S_Sub]!=39)) S_Sub++;
  1886.                S_CompMin[0]=0;
  1887.                while ((strcmp(S_CompMin,"AND")!=0)
  1888.                    &&(strcmp(S_CompMin,"OR")!=0)
  1889.                    &&(strcmp(S_CompMin,"THEN")!=0))
  1890.                    S_Find_Min_and_Max();
  1891.                }
  1892.            if  (strcmp(S_CompMin,"OR")==0)
  1893.                S_CompMin[0]=0;
  1894.            }
  1895.        else
  1896.            {
  1897.            S_CompMin[0] = 0;
  1898.            S_Matched    = 0;
  1899.            }
  1900.        }
  1901.    else
  1902.        {
  1903.        if  (strcmp(S_CompMin,"OR")==0)
  1904.            {
  1905.            if  (S_Matched)
  1906.                {
  1907.                while (strcmp(S_CompMin,"THEN")!=0)
  1908.                    {
  1909.                    S_ReadNextRangeRec();
  1910.                    S_Sub=0;
  1911.                    while ((S_CurStr[S_Sub]!=0)&&(S_CurStr[S_Sub]!=39)) S_Sub++;
  1912.                    while ((strcmp(S_CompMin,"AND")!=0)
  1913.                        &&(strcmp(S_CompMin,"OR")!=0)
  1914.                        &&(strcmp(S_CompMin,"THEN")!=0))
  1915.                        S_Find_Min_and_Max();
  1916.                    }
  1917.                }
  1918.            else
  1919.                S_CompMin[0]=0;
  1920.            }
  1921.        }
  1922.    }
  1923.  
  1924.  
  1925. strcpy(S_EditStr,S_EditStrHold);
  1926.  
  1927. if  (S_Matched)
  1928.     {
  1929.     S_Matched  = 0;
  1930.     S_InsideIf = 1;
  1931.     while ((S_ScreenValid)&&(S_CurStr[0]!='E')&&(!S_Skip))
  1932.         {
  1933.         S_ReadNextRangeRec();
  1934.         if  (S_CurStr[0]!='E')
  1935.             {
  1936.             switch (S_CurStr[3])
  1937.                 {
  1938.                 case 'D' : {S_ProcessDate();break;}
  1939.                 case 'I' : {S_Sub=0;
  1940.                            while ((S_CurStr[S_Sub]!=0)&&
  1941.                                 (S_CurStr[S_Sub]!=39)) S_Sub++;
  1942.                            S_ProcessIn();
  1943.                            break;
  1944.                            }
  1945.                 case 'S' : {S_Skip = 1;break;}
  1946.                 case 'E' : {S_ScreenValid = 0;
  1947.                            strcpy(S_Msg,&S_CurStr[9]);
  1948.                            }
  1949.                 }
  1950.             }
  1951.         }
  1952.     S_InsideIf = 0;
  1953.     }
  1954. while (strcmp(S_CurStr,"ENDIF")!=0)
  1955.     S_ReadNextRangeRec();
  1956.  
  1957. }
  1958.  
  1959.  
  1960. void S_Validate_Location()
  1961. {
  1962. int x,y,z;
  1963.  
  1964. S_UpCase         = 0;
  1965. S_InsideIf       = 0;
  1966. S_Matched        = 0;
  1967. S_Skip           = 0;
  1968. S_OpCode[0]      = 0;
  1969. S_CurrLine       = 9999;
  1970. while ((S_NextRec)&&(!S_Skip))
  1971.     {
  1972.     S_ReadNextRangeRec();
  1973.     if  (S_CurStr[0] == 'I') /* check for IN or if */
  1974.         {
  1975.         S_Sub = s_pos(S_CurStr,"'");
  1976.         if  (S_CurStr[1] == 'F')
  1977.             S_Processif();
  1978.         else
  1979.             S_ProcessIn();
  1980.         if  (S_Validate_Finished)
  1981.             S_NextRec = 0;
  1982.         }
  1983.     if  (S_CurStr[0] == 'U') /* check for Upshift key word */
  1984.         {
  1985.         if  (S_CurStr[10] == 'N') /* if ON */
  1986.             {
  1987.             S_UpCase = 1;
  1988.             strupr(S_EditStr);
  1989.             }
  1990.         else
  1991.             {
  1992.             S_UpCase = 0;      /* if Off */
  1993.             strcpy(S_EditStr,S_NewStr);
  1994.             }
  1995.         strcpy(S_EditStrHold,S_EditStr);
  1996.         }
  1997.     if  ((S_CurStr[0] == 'R')||(S_CurStr[0] == 'S'))
  1998.         {
  1999.         x = strlen(S_EditStr);
  2000.         while ((x>0)&&(S_EditStr[x-1]<33))
  2001.             {
  2002.             S_EditStr[x-1]=0;
  2003.             x++;
  2004.             }
  2005.         if  (S_EditStr[0]==0)
  2006.             {
  2007.             if  (S_CurStr[0]=='S')
  2008.                 S_NextRec = 0;
  2009.             if  (S_CurStr[0]=='R')
  2010.                 {
  2011.                 S_Sub = 0;
  2012.                 while ((S_CurStr[S_Sub]!=0)&&(S_CurStr[S_Sub]!=39)) S_Sub++;
  2013.                 if  (S_CurStr[S_Sub]==39)
  2014.                     strcpy(S_Msg,(char *)&S_CurStr[S_Sub]);
  2015.                 else
  2016.                     strcpy(S_Msg,"** This field is required **");
  2017.                 S_ScreenValid = 0;
  2018.                 S_NextRec = 0;
  2019.                 }
  2020.             }
  2021.         }
  2022.     if  (S_CurStr[0]=='D') /* Process Date pattern */
  2023.         S_ProcessDate();
  2024.     }
  2025. }
  2026.  
  2027.  
  2028.  
  2029.  
  2030. void S_ValidateScreen()
  2031. {
  2032. S_Point             = 0;
  2033. S_PointHold         = 0;
  2034. S_RecNo             = 9999;
  2035. S_UpCase            = 0;
  2036. S_Validate_Finished = 0;
  2037.  
  2038. if  (S_ValidateField > -1)
  2039.     S_Point = S_ValidateField;
  2040.  
  2041. while (!S_Validate_Finished)
  2042.    {
  2043.    if  (S_Point < s_indx->A.s_count[S_Num])
  2044.        {
  2045.  
  2046.        S_NextRec  = s_field->C.s_rangenextrec [S_Point];
  2047.        S_NextLine = s_field->C.s_rangenextline[S_Point]-1;
  2048.  
  2049.        if  (S_NextRec)
  2050.            {
  2051.            S_PointHold   = S_Point;
  2052.            S_ScreenValid = 1;
  2053.            S_Get_Field_Value(S_Point);
  2054.            strcpy(S_EditStrHold,S_EditStr);
  2055.            strcpy(S_NewStr,S_EditStr);
  2056.            S_Validate_Location();
  2057.            if  ((!S_ScreenValid)||(S_ValidateField > -1))
  2058.                {
  2059.                S_Validate_Finished = 1;
  2060.                S_ResetKeyFlags();
  2061.                S_Point--;
  2062.                }
  2063.            }
  2064.        S_Point++;
  2065.        }
  2066.    else
  2067.        {
  2068.        S_Validate_Finished = 1;
  2069.        }
  2070.    }
  2071.  
  2072. S_ChangeScreen = 0;
  2073. S_PointHold    = S_Point;
  2074.  
  2075. strcpy(S_NewStr,S_Msg);
  2076. S_LoadScreen(s_indx->A.s_name[S_Num]);
  2077. strcpy(S_Msg,S_NewStr);
  2078.  
  2079. S_Point = S_PointHold;
  2080.  
  2081. S_ValidateField = -1;
  2082. }
  2083.  
  2084.  
  2085.  
  2086. void S_NextKey()
  2087. {
  2088. char ShowStatusHold;
  2089. if  (S_FirstTime) S_Init();
  2090. ShowStatusHold = S_ShowStatus;
  2091. S_Wait         = 0;
  2092. S_GetKey();
  2093. S_ShowStatus = ShowStatusHold;
  2094. }
  2095.  
  2096.  
  2097.  
  2098.  
  2099. void S_ReadKey()
  2100. {
  2101. if  (S_FirstTime) S_Init();
  2102. if  (s_indx->A.s_count[S_Num] > 0)
  2103.     S_FillScreen();
  2104. if  (S_Msg[0]!=0)
  2105.     S_Wait=1;
  2106. S_GetKey();
  2107. }
  2108.  
  2109.  
  2110.  
  2111.  
  2112. void S_ReadField()
  2113. {
  2114. double *Dbl;
  2115. int x,y;
  2116. if  (S_FirstTime) S_Init();
  2117. if  (s_indx->A.s_count[S_Num] > 0)
  2118.     S_FillScreen();
  2119.  
  2120. if  ((S_Point < 0) || (S_Point > s_indx->A.s_count[S_Num]))
  2121.     {
  2122.     strcpy(S_Msg," Field number in S_Point is out of range ");
  2123.     S_ReadKey();
  2124.     goto Exit_Proc;
  2125.     }
  2126.  
  2127. if  (s_field->C.s_type[S_Point] > 9)
  2128.     {
  2129.     strcpy(S_Msg," Cannot read a DISPLAY only field - Any key to continue ");
  2130.     S_ReadKey();
  2131.     goto Exit_Proc;
  2132.     }
  2133.  
  2134. S_PointHold   = S_Point;
  2135. S_ScreenValid = 0;
  2136. S_ResetKeyFlags();
  2137.  
  2138. while ((!S_ScreenValid)&&(!S_Fkey))
  2139.     {
  2140.     if  (S_Msg[0]!=0)
  2141.     S_Wait=1;
  2142.  
  2143.     S_Get_Field_Value(S_Point);
  2144.  
  2145.     while ((!S_Enter)&&(S_PointHold == S_Point)&&(!S_Fkey))
  2146.         {
  2147.         S_EditString(s_field->C.s_row[S_Point],
  2148.                      s_field->C.s_col[S_Point],
  2149.                      s_field->C.s_type[S_Point],
  2150.                      s_field->C.s_len[S_Point],
  2151.                      s_field->C.s_promptbg[S_Point],
  2152.                      s_field->C.s_promptfg[S_Point],
  2153.                      s_field->C.s_displaybg[S_Point],
  2154.                      s_field->C.s_displayfg[S_Point],
  2155.                      s_field->C.s_normalbg[S_Point],
  2156.                      s_field->C.s_normalfg[S_Point],
  2157.                      s_field->C.s_rangenextrec[S_Point],
  2158.                      s_field->C.s_rangenextline[S_Point],
  2159.                      S_EditStr);
  2160.  
  2161.         s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  2162.  
  2163.         if  ((s_field->C.s_type[S_Point] < 8) ||
  2164.              ((s_field->C.s_type[S_Point] > 89)&&
  2165.               (s_field->C.s_type[S_Point] < 98)))
  2166.              {
  2167.              x=0;
  2168.              y=0;
  2169.              while (S_EditStr[x]!=0)
  2170.                  if (S_EditStr[x++]=='.') {y=1;break;};
  2171.              if  (y==0)
  2172.                  strcat(S_EditStr,".0 ");
  2173.              else
  2174.                  strcat(S_EditStr,"0 ");
  2175.              Dbl = (double *)(S_WorkArea+S_FieldPtr[S_Point]);
  2176.              *Dbl=atof(S_EditStr);
  2177.              }
  2178.          else
  2179.              {
  2180.              y=strlen(S_EditStr);
  2181.              while ((y>0)&&(S_EditStr[y-1]<33))
  2182.                  {
  2183.                  S_EditStr[y-1]=0;
  2184.                  y--;
  2185.                  }
  2186.              strcpy((char *)S_WorkArea+S_FieldPtr[S_Point],S_EditStr);
  2187.              }
  2188.         if  (S_Tab) S_Fkey = 1;
  2189.         }
  2190.  
  2191.     S_Point = S_PointHold;
  2192.  
  2193.     if  ((S_Tab)||(S_Enter)||(S_LeftArrow)||(S_RightArrow))
  2194.         {
  2195.         if  (s_field->C.s_rangenextrec[S_Point]>0)
  2196.             {
  2197.             S_ValidateField = S_Point;
  2198.             S_ValidateScreen();
  2199.             S_ValidateField = 0;
  2200.             if  (!S_ScreenValid)
  2201.                 S_ResetKeyFlags();
  2202.             }
  2203.         else
  2204.             if  ((strlen(S_EditStr) > s_field->C.s_len[S_Point])||(S_Enter))
  2205.                 S_ScreenValid = 1;
  2206.         }
  2207.    }
  2208. Exit_Proc:
  2209. delay(0);
  2210. }
  2211.  
  2212.  
  2213.  
  2214.  
  2215. void S_ReadScreen()
  2216.    {
  2217.    int x,y;
  2218.    double *Dbl;
  2219.    if  (S_FirstTime) S_Init();
  2220.    switch (s_indx->A.s_compiledind[S_Num])
  2221.        {
  2222.        case 1 : {S_ReadKey();break;}
  2223.        case 2 : {S_ReadKey();break;}
  2224.        case 3 : {
  2225.                 S_ScreenValid   = 0;
  2226.                 S_ValidateField = -1;
  2227.                 do
  2228.                   {
  2229.                   S_FillScreen();
  2230.                   if  (S_Msg[0]!=0) S_Wait=1;
  2231.  
  2232.                   S_PointHold = -99;
  2233.  
  2234.                   if  ((S_Point > s_indx->A.s_count[S_Num])||(S_Point < 0))
  2235.                       S_Point = (s_indx->A.s_first[S_Num]-1);
  2236.  
  2237.                   do
  2238.                      {
  2239.                      if  (S_PointHold != S_Point)
  2240.                          {
  2241.                          while (s_field->C.s_type[S_Point] > 9)
  2242.                              {
  2243.                              S_Point = (S_Direction > 0)
  2244.                                      ? s_field->C.s_next[S_Point]-1
  2245.                                      : s_field->C.s_prev[S_Point]-1;
  2246.                              }
  2247.                           S_PointHold = S_Point;
  2248.                           }
  2249.                      S_Get_Field_Value(S_Point);
  2250.  
  2251.                      S_Direction = 1;
  2252.                      S_EditString(s_field->C.s_row[S_Point],
  2253.                           s_field->C.s_col[S_Point],
  2254.                           s_field->C.s_type[S_Point],
  2255.                           s_field->C.s_len[S_Point],
  2256.                           s_field->C.s_promptbg[S_Point],
  2257.                           s_field->C.s_promptfg[S_Point],
  2258.                           s_field->C.s_displaybg[S_Point],
  2259.                           s_field->C.s_displayfg[S_Point],
  2260.                           s_field->C.s_normalbg[S_Point],
  2261.                           s_field->C.s_normalfg[S_Point],
  2262.                           s_field->C.s_rangenextrec[S_Point],
  2263.                           s_field->C.s_rangenextline[S_Point],
  2264.                           S_EditStr);
  2265.  
  2266.                      s_field->C.s_datalen[S_Point] = strlen(S_EditStr);
  2267.  
  2268.                      if  ((s_field->C.s_type[S_Point] < 8) ||
  2269.                           ((s_field->C.s_type[S_Point] > 89)&&
  2270.                            (s_field->C.s_type[S_Point] < 98)))
  2271.                           {
  2272.                           x=0;
  2273.                           y=0;
  2274.                           while (S_EditStr[x]!=0)
  2275.                               if (S_EditStr[x++]=='.') {y=1;break;};
  2276.                           if  (y==0)
  2277.                               strcat(S_EditStr,".0 ");
  2278.                           else
  2279.                               strcat(S_EditStr,"0 ");
  2280.                           Dbl = (double *)(S_WorkArea+S_FieldPtr[S_Point]);
  2281.                           *Dbl=atof(S_EditStr);
  2282.                           }
  2283.                       else
  2284.                           {
  2285.                           y=strlen(S_EditStr);
  2286.                           while ((y>0)&&(S_EditStr[y-1]<33))
  2287.                               {
  2288.                               S_EditStr[y-1]=0;
  2289.                               y--;
  2290.                               }
  2291.                           strcpy((char *)S_WorkArea+S_FieldPtr[S_Point],
  2292.                                  S_EditStr);
  2293.                           }
  2294.                      if  (S_Tab)
  2295.                          {
  2296.                          S_Direction = (S_Shift) ? -1:1;
  2297.                          S_Point = (S_Direction > 0)
  2298.                               ? (s_field->C.s_next[S_Point]-1)
  2299.                               : (s_field->C.s_prev[S_Point]-1);
  2300.                          S_Fkey  = 0;
  2301.                          S_Shift = 0;
  2302.                          }
  2303.                      }
  2304.                   while ((!S_Enter) && (!S_Fkey));
  2305.  
  2306.                   if  (S_Enter)
  2307.                        S_ValidateScreen();
  2308.                   }
  2309.                 while ((!S_ScreenValid)&&(!S_Fkey));
  2310.                 if  (S_Enter)
  2311.                     S_Point=-1;
  2312.                 }
  2313.        }
  2314.    }
  2315.