home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / neubef.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-07  |  32.9 KB  |  1,670 lines
  1. /* neubef.c
  2. In diesem File befinden sich die NEUEN Befehle des
  3. Interpreters.
  4. (c) 1990 Markus Merle & TOOLBOX
  5. */
  6.  
  7. #include <dos.h>
  8. #include <alloc.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <conio.h>
  13. #include "interp.h"
  14. #include "neuutil.h"
  15.  
  16. void str_ins(unsigned char *str, int w, int l, char c,unsigned char *pic);
  17. void str_del(unsigned char *str, int w, int l,unsigned char *pic);
  18. int dezmove(unsigned char *str, unsigned char *pic);
  19. int nummove(unsigned char *str);
  20. int dezset(unsigned char *str, unsigned char *pic);
  21. int datum_pruef(char *str);
  22.  
  23.  
  24. /* Benötigte Globalvariablen */
  25. extern PRGZEILE *FirstLine;  /* erste Interpreterzeile */
  26. extern PRGZEILE *ActLine;  /* aktuelle interpretierte Zeile */
  27. extern char  *LinePos;  /* Zeilenposition der aktuellen Zeile*/
  28. extern  int             Steuer;                 /* der aufrufenden Routine wird mit-    */
  29. int c_lastkey=10;                                                                        /* geteilt, um was es sich handelt.             */
  30. extern char ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  31.  
  32.  
  33. /*      chilfe
  34.  Hilfebildschirm anzeigen.
  35.  */
  36.  
  37. extern  TOKBEF  TokBefDesc[];
  38.  
  39. int
  40. chilfe()
  41. {
  42.  static unsigned char seite[4], zeile[85], s_screen[4003], s_buffer[30];
  43.  unsigned char        *z, such[21],pic[21];
  44.  int                  laenge, anzahl, taste, weiter=1, loop, pos=0;
  45.  int                  i,alles=1,ii,jj,kk,out[8];
  46.  long                 dpos[100];
  47.  FILE                 *hilfe;      /* Hilfedatei */
  48.  
  49.  
  50.  if((hilfe = fopen("hilfe.txl", "rb")) == NULL)
  51.   {
  52.   printf("\n<hilfe>  Fehler beim Eröffnen der Hilfedatei  < HILFE.TXL >\n");
  53.   cls();
  54.   return(OK);
  55.   }
  56.  
  57.  
  58.  Scan();
  59.  if(Steuer == ZIFFER)
  60.   Scan();
  61.  
  62.  if ((Steuer == STRING || Steuer == ALPHA) && strcmp(ScanBuffer,"hilfe") != 0)
  63.   {
  64.   for (i=0;(TokBefDesc[i].function != NULL) &&
  65.   ((alles=strcmp(TokBefDesc[i].Befehl,ScanBuffer)) != 0);i++)
  66.    ;
  67.   }
  68.  savescreen(0,0,24,79,s_screen);
  69.  out[0]=ESC;
  70.  out[1]=PGUP;
  71.  out[2]=PGDN;
  72.  out[3]=CRUP;
  73.  out[4]=CRDN;
  74.  out[5]=F1;
  75.  out[6]='\0';
  76.  strcpy(pic,"XXXXXXXXXXXXXXXXXXXX");
  77.  pos       = 0;
  78.  dpos[pos] = 0L;
  79.  anzahl    = 0;
  80.  loop      = 1;
  81.  laenge    = 0;
  82.  
  83.  if(!alles)
  84.   {
  85.  
  86.   s_buffer[0]='<';
  87.   s_buffer[1]='\0';
  88.   strcat(s_buffer,ScanBuffer);
  89.   ii=strlen(s_buffer);
  90.   s_buffer[ii++]='>';
  91.   s_buffer[ii]='\0';
  92.  
  93.  
  94.   fseek(hilfe,0L,0);
  95.   while(!feof(hilfe) && loop)
  96.    {
  97.    fgets(zeile,185,hilfe);     /* Zeile lesen */
  98.    if (!feof(hilfe))
  99.     {
  100.     laenge+=strlen(zeile);
  101.     for(ii=0; zeile[ii] != '\0'; ++ii)
  102.      {
  103.      for(jj=ii, kk=0; s_buffer[kk] != '\0'
  104.      && zeile[jj] == s_buffer[kk]; ++jj, ++kk)
  105.       ;
  106.      if(s_buffer[kk] == '\0')
  107.       {
  108.       laenge-=strlen(zeile);
  109.       loop=0;
  110.       break;
  111.       }
  112.      }
  113.     }
  114.    else
  115.     {
  116.     printf("\n<hilfe>  Keine Hilfe zum Befehl gefunden !\n");
  117.     warte();
  118.     laenge=0;
  119.     break;
  120.     }
  121.    }
  122.   }
  123.  
  124.  dpos[pos]=(long) laenge;
  125.  
  126.  while(weiter)  /* Solange nicht ESC */
  127.   {
  128.   fseek(hilfe,(long)dpos[pos],0);
  129.   anzahl = 1;
  130.   laenge = 0;
  131.   loop   = 1;
  132.   itoa(pos+1,seite,10);
  133.   cls();
  134.   zeig(0,2,"**** TXL-Hilfe     Seite :      ****");
  135.   zeig(0,29,seite);
  136.   while( anzahl <= 23 && loop)
  137.    {
  138.    anzahl++;
  139.    if (!feof(hilfe) && loop)
  140.     {
  141.     fgets(zeile,185,hilfe);     /* Zeile lesen */
  142.     if (!feof(hilfe))
  143.      {
  144.      laenge+=strlen(zeile);
  145.      if ( (z=strchr(zeile,13)) != NULL )
  146.       *z='\0';
  147.      if( strchr(zeile,'|') == NULL )
  148.       zeig(anzahl,0,zeile);
  149.      else
  150.       loop=0;
  151.      }
  152.     }
  153.    }
  154.  
  155.   if(pos < 100)
  156.    pos=pos+1;
  157.   dpos[pos]= dpos[pos - 1] + (long)laenge;
  158.  
  159.   loop=1;
  160.   while(loop)
  161.    {
  162.    loop  = 0;
  163.    zeig(24,0,"Suche  <                    >      <ESC> Ende   <F1> Hilfe");
  164.    strcpy(such,"                    ");
  165.    lese(24,8,such,pic,out);
  166.    switch((int)_lastkey)
  167.     {
  168.     case ENTER :
  169.      alltrim(such,such);
  170.      if(strlen(such) <=1)
  171.       {
  172.       pos-=1;
  173.       break;
  174.       }
  175.      for (i=0;(TokBefDesc[i].function != NULL) &&
  176.      ((alles=strcmp(TokBefDesc[i].Befehl,such)) != 0);i++)
  177.       ;
  178.      if(!alles)
  179.       {
  180.  
  181.       s_buffer[0]='<';
  182.       s_buffer[1]='\0';
  183.       strcat(s_buffer,such);
  184.       ii=strlen(s_buffer);
  185.       s_buffer[ii++]='>';
  186.       s_buffer[ii]='\0';
  187.  
  188.  
  189.       fseek(hilfe,0L,0);
  190.       loop=1;
  191.       laenge=0;
  192.       while(!feof(hilfe) && loop)
  193.        {
  194.        fgets(zeile,185,hilfe);     /* Zeile lesen */
  195.        if (!feof(hilfe))
  196.         {
  197.         laenge+=strlen(zeile);
  198.         for(ii=0; zeile[ii] != '\0'; ++ii)
  199.          {
  200.          for(jj=ii, kk=0; s_buffer[kk] != '\0'
  201.          && zeile[jj] == s_buffer[kk]; ++jj, ++kk)
  202.           ;
  203.          if(s_buffer[kk] == '\0')
  204.           {
  205.           laenge-=strlen(zeile);
  206.           loop=0;
  207.           break;
  208.           }
  209.          }
  210.         }
  211.        else
  212.         {
  213.         loop=0;
  214.         printf("\n<hilfe>  Keine Hilfe zum Befehl gefunden !     Taste drücken für weiter \n");
  215.         warte();
  216.         dpos[0]=0L;
  217.         pos=0;
  218.         laenge=0;
  219.         break;
  220.         }
  221.        }
  222.       pos=0;
  223.       dpos[0]= (long) laenge;
  224.       }
  225.      else
  226.       {
  227.       dpos[0]=0L;
  228.       pos=0;
  229.       }
  230.  
  231.      break;
  232.  
  233.     case PGDN  :
  234.     case CRDN  :
  235.      if(!feof(hilfe))
  236.       {
  237.       if(pos==0)
  238.        pos=1;
  239.       loop=0;
  240.       break;
  241.       }
  242.      loop=1;
  243.      break;
  244.  
  245.     case PGUP  :
  246.     case CRUP  :
  247.      if (pos > 1)
  248.       {
  249.       pos=pos-2;
  250.       loop=0;
  251.       break;
  252.       }
  253.      loop=1;
  254.      break;
  255.  
  256.     case HOME  :
  257.      dpos[0]=0L;
  258.      pos=0;
  259.      break;
  260.  
  261.     case ESC   :
  262.      weiter=0;
  263.      loop=0;
  264.      break;
  265.  
  266.     case F1    :
  267.      cls();
  268.      zeig(0,2, "╔═════════════════════════════════════════╗");
  269.      zeig(1,2, "║           Hilfe zur TXL-Hilfe           ║");
  270.      zeig(2,2, "╟─────────────────────────────────────────╢");
  271.      zeig(3,2, "║                                         ║");
  272.      zeig(4,2, "║  Pfeiltaste rauf   : eine Seite zurück  ║");
  273.      zeig(5,2, "║             runter : eine Seite weiter  ║");
  274.      zeig(6,2, "║                                         ║");
  275.      zeig(7,2, "║  ESC               : Hilfe verlassen    ║");
  276.      zeig(8,2, "║                                         ║");
  277.      zeig(9,2, "║                                         ║");
  278.      zeig(10,2,"║  Suche :                                ║");
  279.      zeig(11,2,"║            Geben Sie den Befehl ein,    ║");
  280.      zeig(12,2,"║            von welchem die Hilfe        ║");
  281.      zeig(13,2,"║            erscheinen soll.             ║");
  282.      zeig(14,2,"║                                         ║");
  283.      zeig(15,2,"╚═════════════════════════════════════════╝");
  284.      zeig(18,5,"Taste drücken für weiter");
  285.      warte();
  286.      pos-=1;
  287.      break;
  288.  
  289.     default    :
  290.      loop=1;
  291.     }
  292.    }
  293.   }
  294.  
  295.  fclose(hilfe);            /* Hilfedatei schließen */
  296.  cls();
  297.  restscreen(0,0,24,79,s_screen);
  298.  return (OK);
  299. }
  300.  
  301.  
  302. /* ****************************************************
  303.  CZEIG();
  304.  
  305.  Zeigt einen Sting am Bildschirm in der
  306.  Farbe die Sie mit set_farbe() eingestellt haben.
  307.  
  308.  zeig  n1  n2  str
  309.  
  310.  n1    = Zeile     (0 - 24)
  311.  n2    = Spalte    (0 - 79)
  312.  str   = Ausgabetext/Variable
  313.  
  314. */
  315.  
  316. int
  317. czeig()
  318.  
  319. {
  320.  VAR         *Variable;
  321.  long z,s;
  322.  unsigned char str[81], pic[81];
  323.  int i,y,len,weiter=FALSE;
  324.  
  325.  
  326.  if (!iparam(&z,"Zeig"))
  327.  return(FALSE);
  328.  
  329.  if(z < 0 || z > 24)
  330.  {
  331.  pperror ("Zeile 0-24","Zeig");
  332.  return(FALSE);
  333.  }
  334.  
  335.  if (!iparam(&s,"Zeig"))
  336.  return(FALSE);
  337.  
  338.  if(s<0 || s>79)
  339.  {
  340.  pperror ("Spalte 0-79","Zeig");
  341.  return(FALSE);
  342.  }
  343.  
  344.  if (!allstrparam(str,(80-s),"Zeig"))
  345.   return(FALSE);
  346.  
  347.  if (ParamVar)
  348.  {
  349.   Scan();
  350.   switch (Steuer)
  351.      {
  352.   case ALPHA:
  353.   if(strcmp(ParamName,ScanBuffer)!=0)
  354.    {
  355.    pperror ("{ungültige Ausgabemaske}","Zeig");
  356.    return(FALSE);
  357.    }
  358.   break;
  359.  
  360.   case STRING:
  361.   strncpy(pic,ScanBuffer,(80-s));
  362.   pic[80-s]='\0';
  363.   weiter=OK;
  364.   break;
  365.  
  366.   case EOLCHAR:
  367.   break;
  368.  
  369.   default:
  370.   pperror("{ungültige Ausgabemaske}","Zeig");
  371.   return(FALSE);
  372.   }
  373.  
  374.   if (weiter)
  375.   {
  376.    if (ParamType == FLONUM)
  377.    dezset(str,pic);
  378.  
  379.    y   = strlen(pic);
  380.    len = strlen(str);
  381.  
  382.    if (len < y)
  383.    {
  384.    if (ParamType == STRING)
  385.     {
  386.     pic[len]='\0';
  387.     y=len;
  388.     }
  389.    else
  390.     {
  391.     for(i=len;i<y;i++)
  392.      str_ins(str,0,y,' ',pic);
  393.     str[y]='\0';
  394.     }
  395.    }
  396.  
  397.    if ((len=strlen(str)) > y)
  398.    {
  399.    if(ParamType != STRING)
  400.     {
  401.     for(i=y-1,len--;i>=0;i--,len--)
  402.      str[i]=str[len];
  403.     }
  404.    str[y]='\0';
  405.    }
  406.   }
  407.   }
  408.  
  409.  zeig(z,s,str);
  410.  return(OK);
  411.  
  412. }
  413.  
  414.  
  415. /* *******************************************************
  416.  Zeichnet eine Box auf den Bildschirm.
  417.  Parameter :   o,ol,u,ur    obere Zeile, Spalte untere Zeile, Spalte
  418.                *tab         Boxstring "╔═╗║╝═╚║ "
  419.  
  420.                zB.          "abcdefgh#"           abbbc
  421.                                                   d###h
  422.                                                   gfffe
  423.  
  424.  
  425. */
  426.  
  427. int
  428. cbox(void)
  429.  
  430. {
  431.  long o,ol,u,ur;
  432.  unsigned char tab[10];
  433.  
  434.  if (!iparam(&o,"Box"))
  435.  return(FALSE);
  436.  
  437.   if(o < 0 || o > 24)
  438.  {
  439.  pperror ("Obere Zeile 0-24","Box");
  440.  return(FALSE);
  441.  }
  442.  
  443.  if (!iparam(&ol,"Box"))
  444.  return(FALSE);
  445.  
  446.   if(ol < 0 || ol > 79)
  447.  {
  448.  pperror ("Obere Spalte 0-79","Box");
  449.  return(FALSE);
  450.  }
  451.  
  452.  if (!iparam(&u,"Box"))
  453.  return(FALSE);
  454.  
  455.   if(u < o || u > 24)
  456.  {
  457.  pperror ("Untere Zeile 0-24","Box");
  458.  return(FALSE);
  459.  }
  460.  
  461.  if (!iparam(&ur,"Box"))
  462.  return(FALSE);
  463.  
  464.   if(ur < ol || ur > 79)
  465.  {
  466.  pperror ("Untere Spalte 0-79","Box");
  467.  return(FALSE);
  468.  }
  469.  
  470.   if (!strparam(tab,9,"Box"))
  471.   return(FALSE);
  472.  
  473.   if (box(o,ol,u,ur,tab))
  474.  return(OK);
  475.  
  476.   pperror("Ungültige Parameter","Box");
  477.   return(FALSE);
  478. }
  479.  
  480. /**********************************************************************
  481.  
  482.  Sellt die Farbe ein, die für zeig(),cls(), menu(), box() ect.
  483.  verwendet werden soll.
  484.  
  485.  setfarbe  n1  n2
  486.  
  487.  n1 = Vordergrundfarbe
  488.  n2 = Hintergrundfarbe
  489.  
  490.  
  491.   Die möglichen Farben :
  492.  
  493.      0 schwarz
  494.      1 rot
  495.      2 grün
  496.      3 gelb
  497.      4 blau
  498.      5 magenta
  499.      6 cyan
  500.      7 weiss
  501.  
  502. */
  503.  
  504. int
  505. csetfarbe()
  506.  
  507. {
  508.  long v,h;
  509.  
  510.   if (!iparam(&v,"SetFarbe"))
  511.   return(FALSE);
  512.  
  513.  if(v < 0 || v > 7)
  514.   {
  515.   pperror ("Vordergrund 0-7","SetFarbe");
  516.   return(FALSE);
  517.   }
  518.  
  519.   if (!iparam(&h,"SetFarbe"))
  520.   return(FALSE);
  521.  
  522.    if(h < 0 || h > 7)
  523.   {
  524.   pperror ("Hintergrund 0-7","SetFarbe");
  525.   return(FALSE);
  526.   }
  527.  
  528.  set_color(v,h);
  529.  return(OK);
  530. }
  531.  
  532.  
  533. /* ****************************************************
  534.  ATTRIBUT
  535.  Parameter   o,ol,u,ur   Bildschirmkoordinaten
  536.     vom Bildschirmausschmitt,
  537.     in dem die Farbattribute
  538.     geändert werden sollen.
  539.  
  540.       v           Vordergrundfarbe.
  541.       h           Hintergrundfarbe.
  542. */
  543.  
  544. int
  545. cattribut(void)
  546.  
  547. {
  548.  long o,ol,u,ur,v,h;
  549.  
  550.  
  551.  if (!iparam(&o,"Attribut"))
  552.  return(FALSE);
  553.  
  554.  if(o < 0 || o > 24)
  555.  {
  556.  pperror ("Obere Zeile 0-24","Attribut");
  557.  return(FALSE);
  558.  }
  559.  
  560.  if (!iparam(&ol,"Attribut"))
  561.  return(FALSE);
  562.  
  563.  if(ol < 0 || ol > 79)
  564.  {
  565.  pperror ("Obere Spalte 0-79","Attribut");
  566.  return(FALSE);
  567.  }
  568.  
  569.  if (!iparam(&u,"Attribut"))
  570.  return(FALSE);
  571.  
  572.  if(u < o || u > 24)
  573.  {
  574.  pperror ("Untere Zeile 0-24","Attribut");
  575.  return(FALSE);
  576.  }
  577.  
  578.  if (!iparam(&ur,"Attribut"))
  579.  return(FALSE);
  580.  
  581.  if(ur < ol || ur > 79)
  582.  {
  583.  pperror ("Untere Spalte 0-79","Attribut");
  584.  return(FALSE);
  585.  }
  586.  
  587.  if (!iparam(&v,"Attribut"))
  588.  return(FALSE);
  589.  
  590.  if(v < 0 || v > 7)
  591.  {
  592.  pperror ("Vordergrund 0-7","Attribut");
  593.  return(FALSE);
  594.  }
  595.  
  596.  if (!iparam(&h,"Attribut"))
  597.  return(FALSE);
  598.  
  599.  if(h < 0 || h > 7)
  600.  {
  601.  pperror ("Hintergrund 0-7","Attribut");
  602.  return(FALSE);
  603.  }
  604.  
  605.  set_attr(o,ol,u,ur,v,h);
  606.  return(OK);
  607.  
  608. }
  609.  
  610.  
  611. /* ****************************************************
  612.  Löscht den Bildschirm. ( Farbe von setfarbe )
  613.  lösch
  614. */
  615.  
  616. int
  617. cloesch()
  618.  
  619. {
  620. unsigned char str[81];
  621. long         i,o,ol,u,ur,laenge;
  622. VAR         *Variable;
  623.  
  624.  Scan();
  625.  switch (Steuer)
  626.  {
  627.  case ALPHA:
  628.   if(strcmp(ScanBuffer,"loesch")==0)
  629.    {
  630.    cls();
  631.    return(OK);
  632.    }
  633.  
  634.   /* wenn es eine Variable gibt, merken! */
  635.   if ((Variable = IsVariable (ScanBuffer)) != NULL)
  636.    {
  637.    if(Variable->VarType == ZIFFER)
  638.     o=Variable->VarWert.variable.integer;
  639.    else
  640.     {
  641.     pperror ("{falscher Interger-Typ}","Loesch");
  642.     return(FALSE);
  643.     }
  644.    }
  645.   else
  646.    {
  647.    pperror ("{ungültiger oder kein Var-Name}","Loesch");
  648.    return(FALSE);
  649.    }
  650.   break;
  651.  
  652.  case EOLCHAR:
  653.   cls();
  654.   return(OK);
  655.  
  656.  case ZIFFER:
  657.   o=atol(ScanBuffer);
  658.   break;
  659.  
  660.  default :
  661.   pperror ("{ungültiger Parameter}","Loesch");
  662.   return(FALSE);
  663.  }
  664.  
  665.  if(o < 0 || o > 24)
  666.  {
  667.  pperror ("Obere Zeile 0-24","Loesch");
  668.  return(FALSE);
  669.  }
  670.  
  671.  if (!iparam(&ol,"Loesch"))
  672.  return(FALSE);
  673.  
  674.  if(ol < 0 || ol > 79)
  675.  {
  676.  pperror ("Obere Spalte 0-79","Loesch");
  677.  return(FALSE);
  678.  }
  679.  
  680.  if (!iparam(&u,"Loesch"))
  681.  return(FALSE);
  682.  
  683.  if(u < o || u > 24)
  684.  {
  685.  pperror ("Untere Zeile 0-24","Loesch");
  686.  return(FALSE);
  687.  }
  688.  
  689.  if (!iparam(&ur,"Loesch"))
  690.  return(FALSE);
  691.  
  692.  if(ur < ol || ur > 79)
  693.  {
  694.  pperror ("Untere Spalte 0-79","Loesch");
  695.  return(FALSE);
  696.  }
  697.  
  698.  laenge=ur-ol;
  699.  if(laenge>79)
  700.  laenge=79;
  701.  
  702.  if(ol==0 && ur==79)
  703.  {
  704.  if(o==0 && u==24)
  705.   cls();
  706.  else
  707.   for(i=o;i<=u;i++)
  708.    clrline(i);
  709.  return(OK);
  710.  }
  711.  
  712.  for(i=0;i<=laenge;i++)
  713.  str[i]=' ';
  714.  str[i]='\0';
  715.  
  716.  for(i=o;i<=u;i++)
  717.  zeig(i,ol,str);
  718.  
  719.  return(OK);
  720. }
  721.  
  722. /* ****************************************************
  723.  Erzeugt einen Piepton
  724. */
  725. int cpiep()
  726. {
  727.   int i;
  728.   for (i=100; i<=900; i+=2)
  729.       {
  730.        sound(i);
  731.        delay(2);
  732.        nosound();
  733.       }
  734. return(OK);
  735. }
  736.  
  737. /*     cinfo: Versionsnummer des TXL-Interpreters */
  738.  
  739. int
  740. cinfo ()
  741. {
  742.        printf ("\n ╔══════════════════════════════════════════════════════════════════════════╗\n");
  743.        printf (" ║ %s %s                                         ║\n",COPYRIGHT,VERSION);
  744.        printf (" ║ An dem Interpreter sowie den Spracherweiterungen waren bisher beteiligt: ║\n");
  745.        printf (" ║ Michael Beising, Markus Merle, Kurt Bauer, Ralf Morgenstern,             ║\n");
  746.        printf (" ║ Elmar Warken und Ulrich Schmitz.                                         ║\n");
  747.        printf (" ╚══════════════════════════════════════════════════════════════════════════╝\n");
  748. return (OK);
  749. }
  750.  
  751.  
  752. /* ****************************************************
  753.  Erzeugt einen Gruß an Gerald, den Daddelking
  754. */
  755. int cgerald()
  756. {
  757. printf("\nEinen Gruß an das größte Spielkalb der Galaxis\n");
  758.   (void)cpiep();
  759.   (void)cpiep();
  760.   (void)cpiep();
  761. return(OK);
  762. }
  763.  
  764. /*****************************************************
  765.  Gibt alle verfügbaren Kommandos aus
  766. */
  767. int
  768. ccommands()
  769. {
  770. int i=0;
  771.  printf("\n\nFolgende Befehle sind unter dem TXL-Interpreter verfügbar :\n");
  772.  printf("-----------------------------------------------------------\n");
  773.  while( (char *)TokBefDesc[i].Befehl != NULL )
  774.       {
  775.        printf("%s\t",(char *)TokBefDesc[i++].Befehl);
  776.       }
  777.  printf("\n\n");
  778. return(OK);
  779. }
  780.  
  781. /*****************************************************
  782.  Wartet auf einen Tastendruck
  783. */
  784.  
  785. int
  786. cpause()
  787.  
  788. {
  789.  c_lastkey=lesech();
  790.  return(OK);
  791. }
  792.  
  793. /* ****************************************************
  794.  Führt Dosbefehl aus
  795. */
  796.  
  797. int
  798. cdos()
  799.  
  800. {
  801.  VAR         *Variable;
  802.  Scan();
  803.  switch (Steuer)
  804.      {
  805.      case ALPHA:
  806.   if(strcmp(ScanBuffer,"dos")==0)
  807.    {
  808.    strcpy(ScanBuffer,"Command.com");
  809.    break;
  810.    }
  811.  
  812.   /* wenn es eine Variable gibt, merken! */
  813.   if ((Variable = IsVariable (ScanBuffer)) != NULL)
  814.    {
  815.    if(Variable->VarType == STRING)
  816.      strcpy(ScanBuffer,Variable->VarWert.variable.text);
  817.    else
  818.     {
  819.     serror (" Syntax-Fehler ! < dos {falscher Var-Typ} >");
  820.     return(FALSE);
  821.     }
  822.    }
  823.   else
  824.    {
  825.    serror (" Syntax-Fehler ! < dos {ungültiger Var-Name} >");
  826.    return(FALSE);
  827.    }
  828.   break;
  829.  
  830.      case EOLCHAR:
  831.   strcpy(ScanBuffer,"Command.com");
  832.   break;
  833.  
  834.      case STRING:
  835.   break;
  836.  
  837.      default :
  838.   serror (" Syntax-Fehler!  < dos > oder < dos Str-Variable > oder < dos 'Befehle' >");
  839.   return(FALSE);
  840.      }
  841.  
  842.  
  843.  
  844.  
  845.  system(ScanBuffer);
  846.  return(OK);
  847. }
  848.  
  849. /*****************************************************
  850.  Sichert den Bildschirm in eine Variable.
  851.  
  852.  Parameter   o,ol,u,ur   Bildschirmkoordinaten
  853.     vom Bildschirmausschmitt,
  854.     der gesichert werden soll.
  855.  
  856.       *tab        String in den der Bildschirm
  857.     gesichert werden soll.
  858.     Die Länge des Sting's errechnet sich
  859.     durch folgende Formel :
  860.  
  861.     ( (ur-ol+1) * (u-o+1) ) * 2 + 1
  862.           oder
  863.     (Anzahl Sicherungszeichen) * 2 + 1
  864.  
  865.  
  866.          zB.    012345678901234567890.....
  867.          1
  868.          2        abcdefg
  869.          3        ABCDEFG
  870.          .
  871.          .
  872.  
  873.          Stringlänge = ( (15-9+1) * (3-2+1) ) * 2 + 1
  874.          oder          14 * 2 + 1
  875.  
  876.          sbild 2 9 3 15 buffer
  877.  
  878. */
  879.  
  880. int
  881. csbild()
  882.  
  883. {
  884.  long          laenge,o,ol,u,ur;
  885.  unsigned char *tab;
  886.  VAR           *Variable;
  887.  
  888.  
  889.  if (!iparam(&o,"sBild"))
  890.  return(FALSE);
  891.  
  892.   if(o < 0 || o > 24)
  893.  {
  894.  pperror ("Obere Zeile 0-24","sBild");
  895.  return(FALSE);
  896.  }
  897.  
  898.  if (!iparam(&ol,"sBild"))
  899.  return(FALSE);
  900.  
  901.   if(ol < 0 || ol > 79)
  902.  {
  903.  pperror ("Obere Spalte 0-79","sBild");
  904.  return(FALSE);
  905.  }
  906.  
  907.  if (!iparam(&u,"sBild"))
  908.  return(FALSE);
  909.  
  910.   if(u < o || u > 24)
  911.  {
  912.  pperror ("Untere Zeile 0-24","sBild");
  913.  return(FALSE);
  914.  }
  915.  
  916.  if (!iparam(&ur,"sBild"))
  917.  return(FALSE);
  918.  
  919.  if(ur < ol || ur > 79)
  920.  {
  921.  pperror ("Untere Spalte 0-79","sBild");
  922.  return(FALSE);
  923.  }
  924.  
  925.  Scan();
  926.  switch (Steuer)
  927.   {
  928.   case ALPHA:
  929.    /* wenn es eine Variable gibt, merken! */
  930.    if ((Variable = IsVariable (ScanBuffer)) != NULL)
  931.     {
  932.     switch (Variable->VarType)
  933.      {
  934.      case STRING:
  935.       tab=Variable->VarWert.variable.text;
  936.       break;
  937.      default:
  938.       pperror ("{falscher String-Typ}","sBild");
  939.       return(FALSE);
  940.      }
  941.     }
  942.    else
  943.     {
  944.     pperror ("{ungültiger oder keine Var-Name}","sBild");
  945.     return(FALSE);
  946.     }
  947.    break;
  948.  
  949.   default :
  950.    pperror ("{ungültiger Parameter}","sBild");
  951.    return(FALSE);
  952.   }
  953.  
  954.  
  955.  laenge = 2 * (ur-ol+1) * (u-o+1) + 5;
  956.  if( Variable->VarWert.dim1 < laenge )
  957.  {
  958.  if( (Variable->VarWert.variable.text = realloc(Variable->VarWert.variable.text,laenge)) == NULL )
  959.   {
  960.   printf("\n <sbild>  Nicht genügend Speicherplatz !");
  961.   return(FALSE);
  962.   }
  963.  Variable->VarWert.dim1 = laenge;
  964.  tab=Variable->VarWert.variable.text;
  965.  }
  966.  
  967.  savescreen(o,ol,u,ur,tab);
  968.  return(OK);
  969. }
  970.  
  971. /*****************************************************
  972.  Stellt den Bildschirm aus eine Variable wieder her.
  973.  
  974.  Parameter   o,ol,u,ur   Bildschirmkoordinaten
  975.     vom Bildschirmausschmitt,
  976.     der gesichert werden soll.
  977.  
  978.       *tab        String in den der Bildschirm
  979.     gesichert wurede.
  980.  
  981.          zB.    012345678901234567890.....
  982.          1
  983.          2        abcdefg
  984.          3        ABCDEFG
  985.          .
  986.          .
  987.  
  988.  
  989.          rbild 2 9 3 15 buffer
  990.  
  991. */
  992.  
  993. int
  994. crbild(void)
  995.  
  996. {
  997.  long o,ol,u,ur;
  998.  char *tab;
  999.  VAR *Variable;
  1000.  
  1001.  if (!iparam(&o,"rBild"))
  1002.  return(FALSE);
  1003.  
  1004.   if(o < 0 || o > 24)
  1005.  {
  1006.  pperror ("Obere Zeile 0-24","rBild");
  1007.  return(FALSE);
  1008.  }
  1009.  
  1010.  if (!iparam(&ol,"rBild"))
  1011.  return(FALSE);
  1012.  
  1013.   if(ol < 0 || ol > 79)
  1014.  {
  1015.  pperror ("Obere Spalte 0-79","rBild");
  1016.  return(FALSE);
  1017.  }
  1018.  
  1019.  if (!iparam(&u,"rBild"))
  1020.  return(FALSE);
  1021.  
  1022.   if(u < o || u > 24)
  1023.  {
  1024.  pperror ("Untere Zeile 0-24","rBild");
  1025.  return(FALSE);
  1026.  }
  1027.  
  1028.  if (!iparam(&ur,"rBild"))
  1029.  return(FALSE);
  1030.  
  1031.  if(ur < ol || ur > 79)
  1032.  {
  1033.  pperror ("Untere Spalte 0-79","rBild");
  1034.  return(FALSE);
  1035.  }
  1036.  
  1037.  
  1038.  Scan();
  1039.  switch (Steuer)
  1040.   {
  1041.   case ALPHA:
  1042.    /* wenn es eine Variable gibt, merken! */
  1043.    if ((Variable = IsVariable (ScanBuffer)) != NULL)
  1044.     {
  1045.     switch (Variable->VarType)
  1046.      {
  1047.      case STRING:
  1048.       tab=Variable->VarWert.variable.text;
  1049.       break;
  1050.      default:
  1051.       pperror ("{falscher String-Typ}","rBild");
  1052.       return(FALSE);
  1053.      }
  1054.     }
  1055.    else
  1056.     {
  1057.     pperror ("{ungültiger oder keine Var-Name}","rBild");
  1058.     return(FALSE);
  1059.     }
  1060.    break;
  1061.  
  1062.   default :
  1063.    pperror ("{ungültiger Parameter}","rBild");
  1064.    return(FALSE);
  1065.   }
  1066.  
  1067.  
  1068.   restscreen(o,ol,u,ur,tab);
  1069.   return(OK);
  1070.  
  1071.  }
  1072.  
  1073.  
  1074. /* ************************************************************
  1075.  String vom Bildschirm einlesen.
  1076.  
  1077.  Parameter :    zeile,spalte      Position am Bildschirm.
  1078.          *str              String der Eingelesen werden soll.
  1079.          *pic              Maske für Eingabe.
  1080.  
  1081.       Jedes Maskenzeichen ergibt eine
  1082.       Eingabestelle.
  1083.  
  1084.       9    =  alle Zeichen die in zeichen9
  1085.        definiert sind. (1234567890.-)
  1086.  
  1087.       D    =  Datum einlesen
  1088.       "DD.DD.DD"  = TT.MM.JJ
  1089.       "DD.DD.DDD" = TT.MM.JJJJ
  1090.  
  1091.       X    =  Zeichen > 31 und < 224
  1092.  
  1093.      ' '   =  An dieser Position im
  1094.      '.'      String können keine Daten
  1095.        eingegeben werden.
  1096.  
  1097.      Sezial :
  1098.  
  1099.      @X    = Maske wird automatisch
  1100.       auf Stringlänge erstellt.
  1101.  
  1102.      @D    = Maske wird automatisch
  1103.       auf TT.MM.JJJJ erstellt.
  1104.  
  1105.  Abbruch  :  immer mit ENTER , ESC , Pfeiltasten und Funktionstasten.
  1106.       ( Abbruch kann mit IFTASTE erfragt werden ! )
  1107.  
  1108.  Return   :  OK , FALSE
  1109.       (Es wird der Orginalstring verändert !)
  1110.  
  1111.  
  1112.  
  1113. */
  1114.  
  1115. int
  1116. clese(void)
  1117.  
  1118. {
  1119. int i = 0;
  1120. int y = 0;
  1121. int len=0,Ende=0,ret=OK;
  1122. int loeschen=0;
  1123. char *a;
  1124. VAR  *Variable;
  1125. long z,s;
  1126. int zeile, spalte,fixnum=0,flonum=0,string=0,datum=0;
  1127. unsigned char str[102], pic[102], org[102], var[NAMLEN];
  1128.  
  1129.  
  1130.  if (!iparam(&z,"Lese"))
  1131.  return(FALSE);
  1132.  
  1133.   if(z < 0 || z > 24)
  1134.  {
  1135.  pperror ("Zeile 0-24","Lese");
  1136.  return(FALSE);
  1137.  }
  1138.  
  1139.  if (!iparam(&s,"Lese"))
  1140.  return(FALSE);
  1141.  
  1142.   if(s < 0 || s > 79)
  1143.  {
  1144.  pperror ("Spalte 0-79","Lese");
  1145.  return(FALSE);
  1146.  }
  1147.  
  1148.  zeile =(int)z;
  1149.  spalte=(int)s;
  1150.  
  1151.  Scan();
  1152.  switch (Steuer)
  1153.      {
  1154.      case ALPHA:
  1155.   /* wenn es eine Variable gibt, merken! */
  1156.   if ((Variable = IsVariable (ScanBuffer)) != NULL)
  1157.    {
  1158.    switch (Variable->VarType)
  1159.     {
  1160.     case STRING:
  1161.      string=1;
  1162.      strcpy(var,ScanBuffer);
  1163.      strncpy(str,Variable->VarWert.variable.text,(80-spalte));
  1164.      str[80-spalte]='\0';
  1165.      len=Variable->VarWert.dim1;
  1166.      break;
  1167.     case FIXNUM:
  1168.      fixnum=1;
  1169.      loeschen=1;
  1170.      strcpy(var,ScanBuffer);
  1171.      ltoa(Variable->VarWert.variable.integer,str,10);
  1172.      break;
  1173.     case FLONUM:
  1174.      flonum=1;
  1175.      loeschen=1;
  1176.      strcpy(var,ScanBuffer);
  1177.      sprintf(str,"%lf",Variable->VarWert.variable.Flotype);
  1178.      break;
  1179.     default:
  1180.      pperror ("{Var-Typ nicht Implementiert}","Lese");
  1181.      return(FALSE);
  1182.     }
  1183.    }
  1184.   else
  1185.    {
  1186.    pperror ("{ungültiger oder kein Var-Name}","Lese");
  1187.    return(FALSE);
  1188.    }
  1189.   break;
  1190.  
  1191.  
  1192.      default :
  1193.       pperror ("{keine Variable angegeben","Lese");
  1194.       return(FALSE);
  1195.      }
  1196.  
  1197.  if (!strparam(pic,(80-spalte),"Lese"))
  1198.  return(FALSE);
  1199.  
  1200.  if (pic[0]=='@')  /* Eingabemaske wird automatisch erstellt */
  1201.  {
  1202.  if(!string)
  1203.   {
  1204.   pperror("Masken-Fehler ! { @X oder @D nur gültig bei Str-Var}","Lese");
  1205.   return(FALSE);
  1206.   }
  1207.  
  1208.  switch (pic[1])
  1209.   {
  1210.   case 'X':
  1211.    len=strlen(str);
  1212.    if(len>(80-spalte))
  1213.     len=(80-spalte);
  1214.    for(i=0;i<len;i++)
  1215.     pic[i]='X';
  1216.    pic[len]='\0';
  1217.    break;
  1218.  
  1219.   case 'D':
  1220.    if(len > 9)
  1221.     {
  1222.     for(i=0;i<10;i++)
  1223.      {
  1224.      if(i==2 || i==5)
  1225.       pic[i]='.';
  1226.      else
  1227.       pic[i]='D';
  1228.      }
  1229.     pic[10]='\0';
  1230.     }
  1231.    else
  1232.     {
  1233.     pperror("Masken-Fehler @D ! { Str-Var ist zu klein }","Lese");
  1234.     return(FALSE);
  1235.     }
  1236.    break;
  1237.  
  1238.   default:
  1239.    pperror("Masken-Fehler ! { @X oder @D }","Lese");
  1240.    return(FALSE);
  1241.   }
  1242.  }
  1243.  
  1244.  
  1245.  if(charsuch(pic,'D') != 0)
  1246.  datum=1;
  1247.  
  1248.  if (flonum)
  1249.  dezset(str,pic);
  1250.  
  1251.  y   = strlen(pic);
  1252.  len = strlen(str);
  1253.  
  1254.  if (fixnum && (i=charsuch(pic,'.')) != 0)
  1255.  pic[i-1]='9';
  1256.  
  1257.  if (len < y)
  1258.  {
  1259.  if (string)
  1260.   {
  1261.   pic[len]='\0';
  1262.   y=len;
  1263.   }
  1264.  else
  1265.   {
  1266.   for(i=len;i<y;i++)
  1267.    str_ins(str,0,y,' ',pic);
  1268.   str[y]='\0';
  1269.   }
  1270.  }
  1271.  
  1272.  if ((len=strlen(str)) > y)
  1273.  {
  1274.  if(!string)
  1275.   {
  1276.   for(i=y-1,len--;i>=0;i--,len--)
  1277.    str[i]=str[len];
  1278.   }
  1279.  str[y]='\0';
  1280.  }
  1281.  
  1282.  strcpy(org,str);
  1283.  len=y-1;
  1284.  i=0;
  1285.  
  1286.  if(pic[0]==' ' || pic[0]=='.')
  1287.  for(;i < y && (pic[0]==' ' || pic[0]=='.');i++)
  1288.   ;
  1289.  if(i==y)
  1290.  {
  1291.  pperror("Keine oder falsche Eingabemaske !","Lese");
  1292.  return(FALSE);
  1293.  }
  1294.  
  1295.  zeig(zeile,spalte,str);
  1296.  setcr(zeile,spalte+i);
  1297.  
  1298.  while (!Ende)
  1299.  {
  1300.  c_lastkey=lesech();
  1301.  
  1302.  if ((int) c_lastkey > 9000 || i == y )
  1303.  
  1304.   switch(c_lastkey)
  1305.    {
  1306.    case ENTER :
  1307.  
  1308.     ret=OK;
  1309.     if(datum)
  1310.      if(!datum_pruef(str))
  1311.       {
  1312.       putch(7);
  1313.       break;
  1314.       }
  1315.     if(flonum)
  1316.      dezmove(str,pic);
  1317.     if(fixnum)
  1318.      nummove(str);
  1319.  
  1320.     if ((Variable = IsVariable (var)) != NULL)
  1321.      {
  1322.      switch (Variable->VarType)
  1323.       {
  1324.       case STRING:
  1325.        strcpy(Variable->VarWert.variable.text,str);
  1326.        break;
  1327.       case FIXNUM:
  1328.        Variable->VarWert.variable.integer=atol(str);
  1329.        break;
  1330.       case FLONUM:
  1331.        Variable->VarWert.variable.Flotype=atof(str);
  1332.        break;
  1333.       default:
  1334.        pperror ("{Var-Typ ist nicht Implementiert}","Lese");
  1335.        ret=FALSE;
  1336.       }
  1337.      }
  1338.     else
  1339.      {
  1340.      pperror ("{Var-Name nicht gefunden !}","Lese");
  1341.      ret=FALSE;
  1342.      }
  1343.  
  1344.     Ende=1;
  1345.     break;
  1346.  
  1347.    case CRLI :      /* linker Cursor */
  1348.     if (i > 0)
  1349.      i--;
  1350.     for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--)
  1351.      ;
  1352.     zeig(zeile,spalte,str);
  1353.     setcr(zeile, spalte+i);
  1354.     break;
  1355.  
  1356.    case CRRE :      /* rechter Cursor */
  1357.     if (i < y-1)
  1358.      i++;
  1359.     for(;(pic[i] == ' ' || pic[i]=='.') && i < y-1;i++)
  1360.      ;
  1361.     zeig(zeile,spalte,str);
  1362.     setcr(zeile, spalte+i);
  1363.     break;
  1364.  
  1365.    case END :      /* End */
  1366.     i = y-1;
  1367.     for(;str[i] == ' ' && i > 0;i--);
  1368.     i++;
  1369.     for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--)
  1370.      ;
  1371.     if(i>=y)
  1372.      i=y-1;
  1373.     zeig(zeile,spalte,str);
  1374.     setcr(zeile,spalte+i);
  1375.     break;
  1376.  
  1377.    case HOME :      /* Home */
  1378.     i = 0;
  1379.     for(;(pic[i] == ' ' || pic[i] == '.') && i < y-1;i++)
  1380.      ;
  1381.     zeig(zeile,spalte,str);
  1382.     setcr(zeile,spalte+i);
  1383.     break;
  1384.  
  1385.    case DEL :      /* Del */
  1386.     str_del(str,i,y,pic);
  1387.     zeig(zeile, spalte, str);
  1388.     setcr(zeile,spalte+i);
  1389.     break;
  1390.  
  1391.    case BKSP  :      /* Backspace */
  1392.     if (i > 0)
  1393.      {
  1394.      i--;
  1395.      for(;(pic[i] == ' ' || pic[i] == '.') && i > 0;i--)
  1396.       ;
  1397.      str_del(str,i,y,pic);
  1398.      zeig(zeile, spalte, str);
  1399.      setcr(zeile,spalte+i);
  1400.      }
  1401.     break;
  1402.  
  1403.    case INS :      /* Ins */
  1404.     str_ins(str,i,y,' ',pic);
  1405.     zeig(zeile, spalte, str);
  1406.     setcr(zeile,spalte+i);
  1407.     break;
  1408.  
  1409.    case ESC :      /* ESC = Orginalzustand herstellen  */
  1410.     strcpy(str,org);
  1411.     Ende=1;
  1412.     ret=OK;
  1413.     break;
  1414.  
  1415.    default :
  1416.     if (c_lastkey >= F1 && c_lastkey <= AF10)
  1417.      {
  1418.      ret=OK;
  1419.      if(flonum)
  1420.       dezmove(str,pic);
  1421.      if(fixnum)
  1422.       nummove(str);
  1423.      if(datum)
  1424.       if(!datum_pruef(str))
  1425.        {
  1426.        putch(7);
  1427.        break;
  1428.        }
  1429.      if ((Variable = IsVariable (var)) != NULL)
  1430.       {
  1431.       switch (Variable->VarType)
  1432.        {
  1433.        case STRING:
  1434.         strcpy(Variable->VarWert.variable.text,str);
  1435.         break;
  1436.        case FIXNUM:
  1437.         Variable->VarWert.variable.integer=atol(str);
  1438.         break;
  1439.        case FLONUM:
  1440.         Variable->VarWert.variable.Flotype=atof(str);
  1441.         break;
  1442.        default:
  1443.         pperror ("{Var-Typ ist nicht Implementiert}","Lese");
  1444.         ret=FALSE;
  1445.        }
  1446.       }
  1447.      else
  1448.       {
  1449.       pperror ("Var-Name nicht gefunden !","Lese");
  1450.       ret=FALSE;
  1451.       }
  1452.      Ende=1;
  1453.      break;
  1454.      }
  1455.     else
  1456.      break;
  1457.    }
  1458.   else
  1459.    switch(pic[i])
  1460.    {
  1461.    case 'X' :
  1462.  
  1463.     if(!string)
  1464.      {
  1465.      putch(7);
  1466.      break;
  1467.      }
  1468.  
  1469.     if (c_lastkey > 31 && c_lastkey < 224)
  1470.      {
  1471.      zeigz(zeile,spalte+i,c_lastkey);
  1472.      str[i] = c_lastkey;
  1473.      i++;
  1474.      for(;pic[i] == ' ' && i < y;i++)
  1475.       ;
  1476.      if(i>=y)
  1477.       i=y-1;
  1478.      zeig(zeile,spalte,str);
  1479.      setcr(zeile,spalte+i);
  1480.      }
  1481.     else
  1482.      putch(7);
  1483.     break;
  1484.  
  1485.    case '9' :
  1486.     if(c_lastkey == '.' && !flonum)
  1487.      {
  1488.      putch(7);
  1489.      break;
  1490.      }
  1491.     a = strchr(zeichen9, c_lastkey);
  1492.     if (a != NULL)
  1493.      {
  1494.      if(loeschen)
  1495.       {
  1496.       loeschen=0;
  1497.       for(;len>=0;len--)
  1498.        if(str[len]!='.')
  1499.         str[len]=' ';
  1500.       }
  1501.      if(c_lastkey == '.')
  1502.       {
  1503.       if( (charsuch(pic,'.')-1) < i)
  1504.        {
  1505.        putch(7);
  1506.        break;
  1507.        }
  1508.       str[i]='.';
  1509.       if( (i=dezmove(str,pic)) == 0)
  1510.        {
  1511.        putch(7);
  1512.        break;
  1513.        }
  1514.       i=0;
  1515.       for(;pic[i] != '.' && i < y;i++)
  1516.        ;
  1517.       i++;
  1518.       if(i>=y)
  1519.        i=y-1;
  1520.       zeig(zeile,spalte,str);
  1521.       setcr(zeile, spalte+i);
  1522.       }
  1523.      else
  1524.       {
  1525.       zeigz(zeile,spalte+i,c_lastkey);
  1526.       str[i] = c_lastkey;
  1527.       i++;
  1528.       for(;(pic[i] == ' ' || pic[i] == '.') && i < y;i++)
  1529.        ;
  1530.       if(i>=y)
  1531.        i=y-1;
  1532.       zeig(zeile,spalte,str);
  1533.       setcr(zeile, spalte+i);
  1534.       }
  1535.      }
  1536.     else
  1537.      putch(7);
  1538.     break;
  1539.  
  1540.    case 'D' :
  1541.     a = strchr(zeichenD, c_lastkey);
  1542.     if (a != NULL)
  1543.      {
  1544.      zeigz(zeile,spalte+i,c_lastkey);
  1545.      str[i] = c_lastkey;
  1546.      i++;
  1547.      for(;(pic[i] == ' ' || pic[i] == '.') && i < y;i++)
  1548.       ;
  1549.      if(i>=y)
  1550.       i=y-1;
  1551.      zeig(zeile,spalte,str);
  1552.      setcr(zeile, spalte+i);
  1553.      }
  1554.     else
  1555.      putch(7);
  1556.     break;
  1557.  
  1558.    case ' ':
  1559.    case '.':
  1560.     for(;(pic[i] == ' ' || pic[i] == '.') && i < y;i++)
  1561.      ;
  1562.     if(i>=y)
  1563.      i=y-1;
  1564.     putch(7);
  1565.     setcr(zeile, spalte+i);
  1566.     break;
  1567.  
  1568.    default :
  1569.      setcr(24,0);
  1570.      pperror("Falsches Zeichen in der Eingabemaske !","Lese");
  1571.      return(FALSE);
  1572.  
  1573.    }
  1574.  }
  1575.  
  1576.  zeig(zeile,spalte,str);
  1577.  setcr(24,0);
  1578.  return(ret);
  1579.  
  1580. }
  1581.  
  1582. /******************************************************************************
  1583.               Interne Function für clese()
  1584.  
  1585.         Tag je Monat bei normalem und bei Schaltjahr
  1586. */
  1587.  
  1588. static int tage_monat[2][13] = {
  1589.    {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},              /* normales Jahr */
  1590.    {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};             /* Schaltjahr */
  1591.  
  1592.  
  1593. /* Funktion Feld Prüfung für Datumsfeld der Form TT.MM.JJJJ oder TT.MM.JJ
  1594.    Parameter:  Datums-String
  1595.    Ergebnis:   OK oder FALSE
  1596. */
  1597.  
  1598. int         datum_pruef(char *str)
  1599.  
  1600. {
  1601.    char  *p_buff = str;                                              /* Editierbuffer holen */
  1602.    int   ergebnis = FALSE;                                           /* Funktionsergebnis */
  1603.    int   schaltjahr;                                                 /* Flag Schaltjahr */
  1604.    int   tag;                                                        /* Tag */
  1605.    int   monat;                                                      /* Monat */
  1606.    int   jahr;                                                       /* Jahr */
  1607.    char  buffer[5];                                                  /* Hilfsbuffer */
  1608.  
  1609.    buffer[2] = '\0';                                                 /* Hilfsbuffer abschließen */
  1610.    memcpy(buffer, p_buff, 2);                                        /* Tag in Buffer kopieren */
  1611.    tag = atoi(buffer);                                               /* und wandeln */
  1612.    memcpy(buffer, p_buff + 3, 2);                                    /* Monat in Buffer kopieren */
  1613.    monat = atoi(buffer);                                             /* und wandeln */
  1614.    if (strlen(str) > 8)
  1615.       {
  1616.       strcpy(buffer,"    ");                                         /* Hilfsbuffer abschließen */
  1617.       memcpy(buffer, p_buff + 6, 4);                                 /* Jahr in Buffer kopieren */
  1618.       jahr=0;
  1619.       }
  1620.    else
  1621.       {
  1622.       strcpy(buffer,"  ");                                           /* Hilfsbuffer abschließen */
  1623.       memcpy(buffer, p_buff + 6, 4);                                 /* Jahr in Buffer kopieren */
  1624.       jahr=1900;               /*  !!! Bei Jahrhunderwechsel ANPASSEN  !!!  */
  1625.       }
  1626.    jahr += atoi(buffer);                                             /* und wandeln */
  1627.    schaltjahr = jahr % 4 == 0 && jahr % 100 != 0 || jahr % 400 == 0; /* Schaltjahr */
  1628.    if((0 < tag ) && (tag <= tage_monat[schaltjahr][monat]))          /* Tag im Monat erlaubt */
  1629.       if((0 < monat) && (monat <= 12))                               /* und Monat 1 bis 12 */
  1630.          ergebnis = OK;                                              /* Feld ok */
  1631.    return(ergebnis);                                                 /* Ergebnis zurückgeben */
  1632. }
  1633.  
  1634.  
  1635.  
  1636. /* ************************************************************
  1637.  Abbruchtaste von clese() und cpause() abfragen.
  1638.  Tastenwert ist aus INTERP.H zu entnehmen !
  1639. */
  1640. int
  1641. ciftaste()
  1642.  
  1643. {
  1644. int  taste =0;
  1645. long result=0;
  1646.  
  1647.  if (!iparam(&result,"IfTaste"))
  1648.  return(FALSE);
  1649.  
  1650.  if((int)result==c_lastkey)
  1651.  taste=1;
  1652.  
  1653.  /* Wenn Bedingung nicht erfüllt, dann übernächste Zeile */
  1654.  
  1655.  if (taste) {
  1656.    ActLine = ActLine->NextZeile; /* Dann-Zeile auswählen */
  1657.    LinePos = ActLine->Zeile;             /* Zeilenanfang */
  1658.    result = InterpLine ();               /* Dann-Zweig ausführen */
  1659.    ActLine = ActLine->NextZeile;
  1660.  }
  1661.  else
  1662.  if (ActLine->NextZeile)
  1663.   ActLine = ActLine->NextZeile;       /* Sonst-Zweig ausführen */
  1664.  else
  1665.   serror ("<iftaste>  Kein Sonst-Zweig vorhanden! ");
  1666.  
  1667.  return (OK);
  1668.  
  1669. }
  1670.