home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / strings.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-19  |  4.5 KB  |  200 lines
  1. /***
  2.   Stringroutinen
  3.   (c) 1991  Elmar Warken
  4. ***/
  5.  
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include "interp.h"
  11.  
  12. /* Benötigte Globalvariablen */
  13. extern    PRGZEILE    *FirstLine;        /* erste Interpreterzeile */
  14. extern    PRGZEILE    *ActLine;        /* aktuelle interpretierte Zeile */
  15. extern    char        *LinePos;        /* Zeilenposition der aktuellen Zeile*/
  16. extern    int        Steuer;            /* der aufrufenden Routine wird mit-    */
  17. extern    VAR        *FirstVar;        /* Zeiger auf die erste Variable */
  18.                                     /* geteilt, um was es sich handelt.         */
  19. extern    char    ScanBuffer[ZEILENLAENGE]; /* Ergebnisbuffer des Scanners */
  20.  
  21. /** String setzen, Fehlermeldung, wenn zu lang **/
  22. int SetVarStr(char *name,char *str)
  23. {
  24.   VAR *Variable;
  25.  
  26.   if ((Variable = IsVariable (name)) == NULL)
  27.   {
  28.     DefVarStr(name,80);
  29.     Variable = IsVariable (name);
  30.   }
  31.   if (Variable->VarType==STRING) 
  32.   {
  33.     if (Variable->VarWert.dim1 >= strlen(str))
  34.       strcpy (Variable->VarWert.variable.text,str);
  35.     else {
  36.       serror("Zugewiesener String zu lang! ");
  37.       return(FALSE);
  38.     }
  39.   }
  40.   else {
  41.     serror("Falscher Variablentyp ! ");
  42.     return(FALSE);
  43.   }
  44.   return(OK);
  45. }
  46.  
  47. /** String setzen, str wird abgeschnitten,
  48.     wenn zu wenig Speicher reserviert ist. **/
  49. int SetVarStr2(char *name,char *str)
  50. {
  51.   VAR *Variable;
  52.  
  53.   if ((Variable = IsVariable (name)) == NULL)
  54.   {
  55.     DefVarStr(name,80);
  56.     Variable = IsVariable (name);
  57.   }
  58.   if (Variable->VarType==STRING) 
  59.     strncpy (Variable->VarWert.variable.text,str,Variable->VarWert.dim1);
  60.   else {
  61.     serror("Falscher Variablentyp! ");
  62.     return(FALSE);
  63.   }
  64.   return(OK);
  65. }
  66.  
  67. int DefVarStr (char *name, int size)
  68. {
  69.   VAR *Variable;
  70.  
  71.   if ((Variable = IsVariable (name)) != NULL) {
  72.     if (Variable->VarType==STRING)
  73.     {
  74.       free(Variable->VarWert.variable.text);
  75.       Variable->VarWert.dim1 = size;
  76.       if ((Variable->VarWert.variable.text=malloc(size+1))==NULL) {
  77.         printf ("\n Kein Speicherplatz mehr für den String! ");
  78.         return(FALSE);
  79.       }
  80.       return(OK);
  81.     }
  82.     else { 
  83.       serror(" Falscher Typ für Stringlängenänderung! "); 
  84.       return(FALSE); 
  85.     }
  86.   }
  87.   else if ((Variable = malloc(sizeof (VAR))) == NULL) {
  88.     printf ("\n Kein Speicherplatz mehr für die Variable! ");
  89.     return(FALSE);
  90.   }
  91.  
  92.   if ((Variable->VarWert.variable.text=malloc(size+1))==NULL) {
  93.     printf ("\n Kein Speicherplatz mehr für den String! ");
  94.     return(FALSE);
  95.   }
  96.   strcpy (Variable->VarName,name);    
  97.   Variable->VarType = STRING;            
  98.   Variable->NextVar = FirstVar;
  99.   Variable->VarWert.dim1 = size;
  100.   FirstVar = Variable;        
  101.   return(OK);
  102. }
  103.  
  104. /* cstrset() Zuweisen eines Strings einer Variablen */
  105. int cstrset(void)
  106. {
  107.   char VarName[50];
  108.   char *str;
  109.  
  110.   Scan();
  111.   if (Steuer == ALPHA) {
  112.     strcpy (VarName,ScanBuffer);    
  113.     Scan ();
  114.     if ((Steuer == SONDER) && (*ScanBuffer == '=')) {
  115.       if (GetStringParam(&str))
  116.     SetVarStr(VarName,str);
  117.       else serror ("String(variable) erwartet! ");    
  118.     } else serror ("Zuweisung erwartet! ");
  119.   } else serror ("Variablenname erwartet! ");
  120.  
  121.   return (OK);
  122. }
  123.  
  124. /* cstrdef() Speicherplatzreservierung für einen String 
  125.    opt. Parameter : Zeichenzahl, default : 300 */
  126.  
  127. int cstrdef(void)
  128. {
  129.   char VarName[50];
  130.   int size;
  131.  
  132.   Scan();
  133.   if (Steuer == ALPHA) {
  134.     strcpy (VarName,ScanBuffer);
  135.     Scan();
  136.     if (Steuer==ZIFFER) 
  137.       size=atoi(ScanBuffer);
  138.     else size=300;            
  139.     DefVarStr (VarName,size);
  140.   } else serror("Variablenname erwartet! ");
  141.  
  142.   return(OK);
  143. }
  144.  
  145. /* cstrtoi() String wird in Integer/Long (Flotype) umgewandelt. 
  146.    Syntax : strtoi STRVAR INTVAR */
  147.  
  148. int cstrtoi(void) 
  149. {
  150.   char *s,str[20];
  151.   long *val;
  152.  
  153.   if (GetStringParam(&s) && strcpy(str,s) &&
  154.       GetNumbVarParam(&val))
  155.   {
  156.     *val=atol(str);
  157.     return(OK);
  158.   } 
  159.   serror(" bei 'strtoi' !" );
  160.   return(FALSE);
  161. }
  162.  
  163. /* citostr() Long (Flotype) in string umwandeln 
  164.    Syntax : itostr INTVAR STRVAR */
  165.  
  166. int citostr(void) 
  167. {
  168.   char *str;
  169.   long val;
  170.   char help[10];
  171.  
  172.   if (GetIntegerParam(&val) &&
  173.       GetVarNameParam(&str) )
  174.   {
  175.     ltoa(val,help,10);
  176.     if (SetVarStr2(str,help))
  177.       return(OK);
  178.   } 
  179.   serror(" bei 'itostr' !" );
  180.   return(FALSE);
  181.  
  182. }
  183.  
  184. int creadln(void)       
  185. {
  186.   char VarName[50],eingabe[300];
  187.  
  188.   Scan();
  189.   if (Steuer == ALPHA) {
  190.     strcpy (VarName,ScanBuffer);    
  191.     gets(eingabe);
  192.  
  193.     /*** ohne Längenüberprüfung: ***/
  194.  
  195.     SetVarStr(VarName,eingabe);
  196.   } else serror ("Variablenname erwartet! ");
  197.  
  198.   return (OK);
  199. }
  200.