home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / array.c next >
Encoding:
C/C++ Source or Header  |  1991-02-13  |  6.2 KB  |  229 lines
  1. /*****************************************************************/
  2. /***** ARRAYS für TXL : Als Elemente STRINGS und Zahlen möglich **/
  3. /***** (c) Februar 1991 Elmar Warken *****************************/
  4. /*****************************************************************/
  5.  
  6. #include <mem.h> 
  7. #include <alloc.h>
  8. #include <string.h>
  9. #include "interp.h"
  10.  
  11. extern    VAR        *FirstVar;        /* Zeiger auf die erste Variable */
  12. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  13.  
  14. /***** Arraydefinition ******/
  15. /***** Syntax : DefArray <name> : d1 [,d2] [,d3] *****/
  16. int cDefArray(void)
  17. {
  18.   char *n,name[50];
  19.   long d1,d2,d3;
  20.   int dim;
  21.   VAR *Variable;
  22.   d1=d2=d3=dim=1;
  23.  
  24. /*** Parameter einlesen ***/
  25.  
  26.   if ( GetVarNameParam(&n) && strcpy(name,n) &&
  27.        GetSonderZeichen(':') &&
  28.        GetIntegerParam(&d1) )
  29.   { 
  30.     if (GetSonderZeichen(',') && GetIntegerParam(&d2))
  31.     {
  32.       dim=2;
  33.       if (GetSonderZeichen(',') && GetIntegerParam(&d3))
  34.     dim=3;
  35.     }
  36.   } else 
  37.   { 
  38.     serror(" Syntaxfehler bei DefArray! ");
  39.     return(FALSE);
  40.   }
  41.  
  42. /*** eigentliche Definition ***/
  43.  
  44.   if ((Variable = IsVariable (name)) != NULL) {
  45.     if (Variable->VarType==ARRAY)
  46.       free(Variable->VarWert.variable.feld);
  47.     else {
  48.       serror(" Falscher Typ bei Arrayredefinition ");
  49.       return(FALSE);
  50.     }
  51.   }
  52.   else 
  53.   {
  54.     if ((Variable = malloc(sizeof (VAR))) == NULL) {
  55.       serror ("\n Kein Speicherplatz mehr für die Variable! ");
  56.       return(FALSE);
  57.     }
  58.     Variable->NextVar = FirstVar;
  59.     FirstVar = Variable;         
  60.   }
  61.  
  62.   if ((Variable->VarWert.variable.feld
  63.     =malloc(sizeof(ARRAYVAR *)*d1*d2*d3))==NULL) 
  64.   {
  65.     serror ("\n Kein Speicherplatz mehr für das Array! ");
  66.     return(FALSE);
  67.   }
  68.  
  69.   setmem(Variable->VarWert.variable.feld,sizeof(ARRAYVAR *)*d1*d2*d3,0) ;
  70.  
  71.   strcpy (Variable->VarName,name);    
  72.   Variable->VarType = ARRAY;            
  73.   Variable->VarWert.dim1 = dim;
  74.  
  75.   Variable->VarWert.dimdef[0]=d1;
  76.   Variable->VarWert.dimdef[1]=d2;
  77.   Variable->VarWert.dimdef[2]=d3;
  78.  
  79.   return(OK);
  80. }
  81.  
  82. /** Hilfsprozedur ohne Fehlerabfrage **/
  83. ARRAYVAR **GetElem(VAR *Variable,int d1,int d2,int d3)
  84. {
  85.   ARRAYVAR **av;
  86.  
  87.   av=(ARRAYVAR **)Variable->VarWert.variable.feld;
  88.  
  89.   if ( (d1>Variable->VarWert.dimdef[0]) ||
  90.        (d2>Variable->VarWert.dimdef[1]) ||
  91.        (d2>Variable->VarWert.dimdef[2]) )
  92.     { d1=0; d2=0; d3=0; 
  93.       serror(" Versuch, Arraygrenzen zu überschreiten! ");
  94.     } /** bei Grenzüberschreitung : Feld (0,0,0) **/
  95.   else return( av+d1+
  96.          d2*Variable->VarWert.dimdef[0]+
  97.          d3*Variable->VarWert.dimdef[0]*Variable->VarWert.dimdef[1]
  98.     );
  99. }
  100.  
  101. /***** Arrayelement setzen ******/
  102. /***** Syntax : SetArrayElem <name> (d1 [,d2] [,d3]) = <VAR> *****/
  103. int cSetArrayElem(void)
  104. {
  105.   char *n1,*name2,name1[50];
  106.   long d1,d2,d3;
  107.   int dim;
  108.   VAR *Variable1, *Variable2;
  109.   ARRAYVAR **AV;
  110.  
  111.   d1=d2=d3=0; dim=1;
  112.   if ( GetVarNameParam(&n1) && strcpy(name1,n1) &&
  113.        GetSonderZeichen('(') &&
  114.        GetIntegerParam(&d1) )
  115.   {
  116.     if (GetSonderZeichen(',') && GetIntegerParam(&d2))
  117.     {
  118.       dim=2;
  119.       if (GetSonderZeichen(',') && GetIntegerParam(&d3))
  120.     dim=3;
  121.     }
  122.   } else 
  123.   { 
  124.     serror(" Syntaxfehler bei SetArrayElem! ");
  125.     return(FALSE);
  126.   }
  127.  
  128.   if ( ( *ScanBuffer == ')' || GetSonderZeichen(')') ) && 
  129.        GetSonderZeichen('=') &&
  130.        GetVarNameParam(&name2) && 
  131.        ( (Variable1 = IsVariable (name1)) != NULL) &&
  132.        ( (Variable2 = IsVariable (name2)) != NULL) &&
  133.        (Variable1->VarType==ARRAY) )
  134.   {
  135.     if (*(AV=GetElem(Variable1,d1,d2,d3))==NULL)
  136.     {
  137.       if ( (*AV=malloc(sizeof (ARRAYVAR))) == NULL)
  138.       {
  139.     serror(" SetArrayElem : Kein Speicherplatz mehr für Arrayelement. ");
  140.     return(FALSE);
  141.       }          
  142.       (*AV)->VarType=FIXNUM;
  143.     }  /*** Setzen des Arrayelementes : ***/
  144.     switch (Variable2->VarType)
  145.     {
  146.       case ARRAY   : serror(" SetArrayElem : Arrays nicht als Arrayelement möglich! ");
  147.              return(FALSE);
  148.       case STRING  : if ( (*AV)->VarType==STRING )
  149.                free( (*AV)->VarWert.variable.text );
  150.              if (((*AV)->VarWert.variable.text
  151.              =malloc(Variable2->VarWert.dim1+1))==NULL) {
  152.             serror ("\n Kein Speicherplatz mehr für den String! ");
  153.             return(FALSE);
  154.              }
  155.              strcpy((*AV)->VarWert.variable.text,
  156.             Variable2->VarWert.variable.text);
  157.              (*AV)->VarWert.dim1=Variable2->VarWert.dim1;
  158.              (*AV)->VarType=STRING;
  159.              break; 
  160.       default      : (*AV)->VarType=Variable2->VarType;
  161.              (*AV)->VarWert=Variable2->VarWert;
  162.     }
  163.     return(OK);
  164.   }
  165.   serror(" Syntaxfehler oder undefinierte Variable bei SetArrayElem ");
  166.   return(FALSE);
  167. }
  168.  
  169. /***** Arrayelement lesen ******/
  170. /***** Syntax : GetArrayElem <name> (d1 [,d2] [,d3]) -> <VAR> *****/
  171. int cGetArrayElem(void)
  172. {
  173.   char *n1,*name2,name1[50];
  174.   long d1,d2,d3;
  175.   int dim;
  176.   VAR *Variable1, *Variable2;
  177.   ARRAYVAR **AV;
  178.  
  179.   d1=d2=d3=0; dim=1;
  180.   if ( GetVarNameParam(&n1) && strcpy(name1,n1) &&
  181.        GetSonderZeichen('(') &&
  182.        GetIntegerParam(&d1) )
  183.   {
  184.     if (GetSonderZeichen(',') && GetIntegerParam(&d2))
  185.     {
  186.       dim=2;
  187.       if (GetSonderZeichen(',') && GetIntegerParam(&d3))
  188.     dim=3;
  189.     }
  190.   } else 
  191.   { 
  192.     serror(" Syntaxfehler bei GetArrayElem! ");
  193.     return(FALSE);
  194.   }
  195.  
  196.   if ( ( *ScanBuffer == ')' || GetSonderZeichen(')') ) && 
  197.        GetSonderZeichen('-') &&
  198.        GetSonderZeichen('>') &&
  199.        GetVarNameParam(&name2) && 
  200.        ( (Variable1 = IsVariable (name1)) != NULL) &&
  201.        (Variable1->VarType==ARRAY) )
  202.   {
  203.     if (*(AV=GetElem(Variable1,d1,d2,d3))==NULL)
  204.     {
  205.       serror(" Arrayelement undefiniert (GetArrayElem)! ");
  206.       return(FALSE);
  207.     }  /*** Setzen des Arrayelementes : ***/
  208.  
  209.     if ((Variable2 = IsVariable (name2)) == NULL) 
  210.     {
  211.       if ( (Variable2=malloc(sizeof(VAR))) == NULL)
  212.       {
  213.     serror(" GetArrayElem : Kein Speicherplatz mehr für Variable. ");
  214.     return(FALSE);
  215.       } else 
  216.       {    /*** Neue Variable anlegen ***/
  217.     strcpy(Variable2->VarName,name2);
  218.     Variable2->NextVar=FirstVar;
  219.     FirstVar=Variable2;
  220.       }
  221.     }
  222.  
  223.     Variable2->VarType=(*AV)->VarType;
  224.     Variable2->VarWert=(*AV)->VarWert;
  225.     return(OK);
  226.   }
  227.   serror(" Syntaxfehler oder undefinierte Variable bei GetArrayElem ");
  228.   return(FALSE);
  229. }