» Programm zur Berechnung algebraischer Ausdrücke durch rekursive Auswertung

// Eingabe-Beispiel:  (((105+46)*mpi())/2)+(2*140*sin(155.672 / 2))+(((105-46)*12.164*mpi())/180)
//auf dem Teminal:
//Eingabe(exit to end) der Aufgabe: (((105+46)*mpi())/2)+(2*140*sin(155.672 / 2))+(((105-46)*12.164*mpi())/180)
//Result=523.4296291

#include	<stdio.h>
#include	"evalx.h"	// Must be included error constants

extern	int	errorflg;	// declare external errorflg

int main(int argc, char **argv)
{
	double val;		  // declare double for result 
	int	exitflg = 0;
	char	str[180] = {0};  // storage for expression string

	while(1)
	{
		 // If expression was in command argument then
		 // Compute, print, then quit.
		 // Else, wait for an input to be typed, compute,
		 // print, then wait again.
		 
		if(argc > 1)
		 {
		  strcpy(str, argv[1]);
		  exitflg++;
		 }
		else
		 {
		  printf("Eingabe(exit to end) der Aufgabe: ");
		  scanf("%[^\n]", str);
		  clpuf();	
          del_strchar(str, ' ');  // entfernt Leerzeichen aus der Eingabe 
          del_strchar(str, '\t'); // entfernt Tabzeichen aus der Eingabe 		
		  if (strcmp (str, "exit") == 0) { printf("Programm beendet\n"); return 0; }
		 }
		val = evalx(str);	// Evaluate the expression
		if(exitflg)
		 {
		  return 0;
		 }
		if (errorflg == 0) printf("Result=%.10g\n", val); // NO ERROR, PRINT RESULT
        ZeigeFehler(errorflg);
	}

 return EXIT_SUCCESS;
}

#ifndef EVALX_INC_
#define EVALX_INC_ 1
/* These constants used for FIELD TYPE identification by class() */

#define OPCLASS 1       /* operator field ^ * / + - ( */
#define NMCLASS 2       /* numeric field */
#define FNCLASS 3       /* function name */
#define VACLASS 4       /* not used */
#define VRCLASS 4       /* not used */

#define	ERRFATAL  -1	/* FATAL ERROR */
#define	ERRSYNTAX 1	/* SYNTAX ERROR */
#define	ERROVFLOW 2	/* OVERFLOW ERROR */
#define	ERRSQRT   3	/* SQUARE ROOT OF NEG NUMBER ERROR */
#define	ERRFACT   4	/* FACTORIAL OF NEG or NUM > 33 ERROR */
#define	ERRFUNC   5	/* UNKNOWN FUNCTION ERROR */
#define	ERRILLVAR 6	/* ILLEGAL VARIABLE TYPE */

#define ANZAHLFUNKTIONEN 15  // in evalx.cpp struct tbl

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <math.h>       /* fabs */
#include <stdlib.h>     /* atof */

double evalx(char *ptr);	/* declare evalx() */
double fact(double n);
double mathcall(char s[]);
short cleanup(double opndstack[], char opstack[], int *n,int *o);
short unstack(double opndstack[], char opstack[],int *n, int *o);
short preced(char c);
short stackop(char op, double opndstack[], char opstack[],int *n,int *o);
double sqroot(double num);
double absolute(double num);
double rndgen(double num);
short any(int c, char *as);
int klasse(char **sptr, char *field);
short num(char c);
short alpha(char c);
double xcalc(double wert, int nummer);
void clpuf(void);
double radtograd(double boma);
double bogenmass(double grad);
void ZeigeFehler(int errorflg);
int delstrchar(char quelle[], int xpos);
int findechar(char quelle[], char gesucht);
int del_strchar(char quelle[], char gesucht);
short legdlm(int c);

#endif

/*	+-----------------------------------+
 *	|                                   |
 *	|              EVALX.C              |
 *	|                                   |
 *	+-----------------------------------+
 *
 *	Algebraic Expression Evaluator/Parser
 *
 *      James P. Hawkins  - WA2WHV
 *	P.O. Box 9146,
 * 	Trenton, NJ 08650
 *
 * calling format:
 *
 *	double value;
 *	double evalx();
 *	value = evalx(expstr)
 *
 *	where:
 *		expstr is the char string representing the expression
 *			to be evaluated. The string must be NULL terminated.
 *		The expression may contain digits representing decimal numbers
 *		or the following math functions:
 *			sin(expstr) - sine of an angle in radians
 *			cos(expstr) - cosine of an angle in radians
 *			exp(expstr) - exponentiate
 *			log(expstr) - natural log
 *			int(expstr) - integerize (truncate to right of dec .)
 *			sqr(expstr) - square root
 *			abs(expstr) - absolute value
 *			atn(expstr) - arctan
 *			rnd(expstr) - random number gen
 *			tan(expstr) - tangent of an angle
 *			fact(expstr) - factorial
 * 		expression may contain the operators:
 *			+   addition
 *			-   subtraction
 *			/   division
 *			*   multiplication
 *			()  parenthesis (can be nested)
 *			^   exponentiate
 *  Errors:
 *	Test errorflg for non-zero;
 *	See evalx.h for definitions of error constants.
 *
 */
#include	"evalx.h"

#define	STKSIZ	6	/* stack size */

// Leerzeichen und Tabzeichen werden mit del_strchar() direkt nach der Stringeingabe entfernt
//#define	skipspace() {while(*expptr == ' ' || *expptr == '\t') *expptr++;}

int	errorflg = 0;
char	*eoexpr;	/* Expression scan place holder */


/* -------------------------------------------------------------------- */
/*
 * Evaluate Expression - recursive
 * exps is pointer to ASCII expression string.
 */
double evalx(char *exps)
{
	char	*expptr;	/* expression string pointer */
	char 	field[80];	/* expression field */

	int	o, n,		/* indicies for opstack & opndstack */
		//savptr,		/* save stack for pointer */
		type,		/* field type returned by class */
		opflag;		/* set when operator encountered
				    cleared when variable or non-op
				     encountered. Used to deal with
				      unaries by forcing a 0.0 on the
					number stack */

	char	opstack[STKSIZ];	/* operator stack */
	double	opndstack[STKSIZ];	/* number stack		*/


	expptr = exps;	/* init expression string pointer */
	o = n = STKSIZ;	/* init operator and
			    variable stack pointer */
	opflag = 0;	/* init opflag */

	errorflg = 0;

	/*
	 * Scan expression string until NULL is encountered.
	 * Encounter of a paren calls this function recursively.
	 * Encounter of recognized functions calls mathcall() which
	 * determines which function to call based on the string name
	 * of the function.  The function may contain yet another
	 * algebraic expression and so on.
	 */
	while(*expptr != '\0')
	{
		if((type = klasse(&expptr, field)) < 0) /* get field and type */
		 {
		  errorflg = ERRSYNTAX;	/* EXPR SYNTAX */
		  errorflg = ERRFATAL;	/* FATAL ERROR */
 		  return(0.0);/* return zero on error */
		 }

		switch(type)
		{
		case NMCLASS:	/* NUMERIC FIELD */
			opndstack[--n] = atof(field);
			opflag = 0;
			break;
		case FNCLASS:	/* FUNCTION REFERENCE */
			opndstack[--n] = mathcall(field);
			opflag = 0;
			break;
		case OPCLASS:	/* OPERATOR */
			switch(*field)
			{
			case '(': /* begin of expres */
				opndstack[--n] = evalx(expptr);
				opflag = 0;
				expptr = eoexpr; /* put pointer
						   to correct place */
				break;
			case ')': /* end of express */
				/*
				 * eval the rest of the expr
				 * between the parens
				 */
				cleanup(opndstack,opstack,&n,&o);
				eoexpr = expptr;
				return(opndstack[n]);
				break;
			case '+':
			case '-':
			case '*':
			case '/':
			case '^':
				/*
				 * Handle unaries by forcing a 0.0 onto
				 * the opndstack before stacking the operator.
				 * This occurs when two operators in a row are
				 * encountered or the variable stack is empty
				 * when an operator encountered.
				 */
				if(opflag || n == STKSIZ)
					opndstack[--n] = 0.0;
				opflag = 1;
				stackop(*field,opndstack,opstack,&n,&o);
				break;
			default:
				break;
			}
			break;
		default:
			errorflg = ERRILLVAR;
			break;
		}
		/*
		 * Skip trailing white space so that
		 * test at top of this loop fails when
		 * it's supposed to.
		 */
		//skipspace();
	}	/* END OF WHILE LOOP */

	cleanup(opndstack,opstack, &n, &o);
	eoexpr = expptr; /* Save place */

 return(opndstack[n]);
}

/* -------------------------------------------------------------------- */
/*
 * //// STACK OPERATOR IF PRECIDENCE TEST IS PASSED ////
 */
short stackop(char op, double opndstack[], char opstack[],int *n,int *o)
{

	/*
	 * If precedence of current operator is
	 * HIGHER than the operator on top of the stack
	 * or the OPERATOR stack is EMPTY,
	 * the precedence test has "passed" so just push
	 * the current operator onto the operator stack.
	 */
	if(*o == STKSIZ)	/* if stack is empty */
	{
		opstack[--(*o)] = op;	/* stack operator precedence done only if stack NOT empty */
		return 0;
	}
	if(preced(op) > preced(opstack[*o]))
	{
		opstack[--(*o)] = op;
	}
	else
	{
		/*
		 * OTHERWISE if the current operator
		 * precedence is LESS than or EQUAL to the
		 * operator on the top of the stack
		 * "uopndstack" the operators from the operator
		 * stack until either the stack is empty
		 * or the precedence test passes
		 */
		while((preced(op) <= preced(opstack[*o])) && *o < STKSIZ)
		{
			if(unstack(opndstack,opstack,n,o) < 0)
			{
				return(-1); /* break loop if bad operator encountered */
			}
		}

		opstack[--(*o)] = op;
	}
 return 0;
}

/* -------------------------------------------------------------------- */
/*
 *
 * //// RETURN PRECEDENCE OF OPERATOR IN c ////
 */
short preced(char c)
{
static char olist[] = "+1-1*2/2^3"; /* list of operators & precedence */
	register int p;	/* scanning register */

	for(p=0; olist[p] != '\0'; p += 2)
	{
		if(c == olist[p])
		{
			return(olist[p+1] - '0');
		}
	}
	return(-1);	/* if we get here, we're in trouble! */
}

/* -------------------------------------------------------------------- */
/*
 * //// CLEANUP THE REST OF THE EXPRESSION ////
 *
 * "pop and do" operations on opstack until
 * stack empty
 */
short cleanup(double opndstack[], char opstack[], int *n,int *o)
{
short rewer = 0;	
	while(*o < STKSIZ)
	{
	   if(unstack(opndstack,opstack,n,o) < 0)
		{
			return(-1);	// break loop if bad operator encountered
		}
	}
 return rewer;
}

/* -------------------------------------------------------------------- */
/*
 * This is where the actual math operations are performed.
 *
 * Pop operater off top of opstack and perform that operation on
 * the top two numbers on opndstack.
 * Opndstack gets popped and result is left on top.
 * Then POP both stacks.
 */
short unstack(double opndstack[], char opstack[],int *n, int *o)
{
	switch(opstack[*o])
	{
		case '^': /* Exponentiate */
			opndstack[*n+1] = pow(opndstack[*n+1],opndstack[*n]);
			break;
		case '*': /* Multiply */
			opndstack[*n+1] = opndstack[*n+1] * opndstack[*n];
			break;
		case '/': /* Divide */
			if(opndstack[*n] == 0.0) /* catch overflow */
			{
				errorflg = ERROVFLOW; /* OVERFLOW ERR */
				break;
			}
			opndstack[*n+1] = opndstack[*n+1] / opndstack[*n];
			break;
		case '+': /* Add */
			opndstack[*n+1] = opndstack[*n+1] + opndstack[*n];
			break;
		case '-': /* Subtract */
			opndstack[*n+1] = opndstack[*n+1] - opndstack[*n];
			break;
		default:  /* Shouldn't get here, but flagged just ini case. */
			errorflg = ERRSYNTAX;
			return(-1);
			break;
	}
	(*n)++;		/* pop number stack */
	(*o)++;		/* pop operator stack */
	return(0);
}

/* --------------------------------------------------------------------- */
/*  SOME EXTRA FUNCTIONS                                                 */
/* --------------------------------------------------------------------- */
double _int(double num)
{
	long	trunc;	
	trunc=num;
	num=trunc;
	return(num);
}
/* --------------------------------------------------------------------- */
double sqroot(double num)
{
	if(num < 0.0)	
	{
		errorflg = ERRSQRT;
	}
	return(pow(num, 0.5));	
}

/* --------------------------------------------------------------------- */
/*
 * Abosulute value
 */
double absolute(double num)
{
 return(fabs(num));
}

/* --------------------------------------------------------------------- */
/*
 * Random number generator.
 */
double rndgen(double num)
{
	double	rndnum;
	rndnum = rand();	
	return((rndnum/32767.0) * num + 1);	
}

/* --------------------------------------------------------------------- */
/*
 * Factorial
 */
double fact(double n)
{
  long   l = n;
  double rewer = -1.0, erge;
      
	if(l>33 || l<0L)
	 {
	  errorflg = ERRFACT;
	  rewer = 0.0;
	  return rewer;
	 }

        if(l == 0 || l == 1)
	{
                return(1.0);
	}
      else
	   {
        rewer = l - 1.0;
		erge = l*fact(rewer);
		return erge;
	   }
}
/* --------------------------------------------------------------------- */

 // This is the math func string and routine
 // dispatch table. Each entry contains the text for the MATH FUNCTION
 //* in question and the address of the routine which services it.
 // Deklaration und Definition der Struktur
struct tbl
	{
		char cmdtxt[ANZAHLFUNKTIONEN];
		//double (*func)();
	};
//Initialisierung der Struktur-Variablen
struct tbl mathtbl[ANZAHLFUNKTIONEN] = {
	"sin", //Sinus Eingabe mit Grad
	"cos", //Cosinus Eingabe mit Grad
	"exp",
	"log",
	"int",
	"sqr",
	"abs",
	"atn", // Arcus Tangens Ausgabe in Grad
	"rnd",
 	"tan", //Tangens Eingabe mit Grad 
	"fact", // Bis hier original, danach erweitert
	"asn", // Arcus Sinus Ausgabe in Grad
	"acs", // Arcus Cosinus Ausgabe in Grad
	"mpi", // Zahl PI Eingabe als Funktion, bzw. 2* mpi() 
	"clg"  // log10
	};
	
/* -------------------------------------------------------------------- */
/*
 * ////// CALL MATH FUNCTION ////////
 *
 * callin format:
 *	value = mathcall(string);
 *
 *	where: value = floating point value returned by call
 *	       string = pointer to a null terminated string containong
 *			the func text and expression within () - 
 *			i.e. "sin(EXPRESSION TEXT)"
 */
double mathcall(char s[])
{
	char	funnam[10]; /* func name copied from 's'
				used for string search */
	register char *x; /* pointer to paren enclosed expression */
	
	double	value;	/* final value returned */
	double exvalue; /* value of expression before being operated
			     upon by the math func */
	register  int i;		/* index reg. for expediency */

	x = s;		/* set pointer to func string */
	/*
	 * copy the func name part up to the '('
	 * to use for a string search in the table of names
	 */
	for(i=0; *x != '(' ;)
	{
		funnam[i++] = *x++;
	}

	funnam[i] = '\0';	/* null terminate */

	 // compare each string in table with funnam
	 // when match is found, call using offset code
	 // if end-of-table (null) encountered return 0
	 
	for(i=0; i < ANZAHLFUNKTIONEN ; i++)
	{
		if(!(strcmp(funnam, mathtbl[i].cmdtxt)))
		{
			x++;
			exvalue = evalx(x); 
			value = xcalc(exvalue, i);  // Call the function!! 		//alt: value = (*mathtbl[i].func)(exvalue);
			return(value);
		}
	}
	errorflg = ERRFUNC;	/* unknown math function */
	return(0.0);	/* Return zero for unknown math functions */
}

double xcalc(double wert, int i)
{
 double rewer = 0;
  
 if(i == 0) rewer = sin(bogenmass(wert));
 if(i == 1) rewer = cos(bogenmass(wert));
 if(i == 2) rewer = exp(wert);  
 if(i == 3) rewer = log(wert);
 if(i == 4) rewer =_int(wert);
 if(i == 5) rewer = sqrt(wert);
 if(i == 6) rewer = fabs(wert);
 if(i == 7) rewer = radtograd(atan(wert));
 if(i == 8) rewer = rndgen(wert);
 if(i == 9) rewer = tan(bogenmass(wert));
 if(i == 10) rewer = fact(wert);
 if(i == 11) rewer = radtograd(asin(wert));
 if(i == 12) rewer = radtograd(acos(wert));
 if(i == 13) rewer = M_PI;
 if(i == 14) rewer = log10(wert);
 
return rewer;	
}

// deletes keyboard buffer
void clpuf(void)
 {
 while (getc(stdin) != '\n')
    ;
 }


// Wandelt Bogenmass in Grad um
double radtograd(double boma)
{
 double grad, pi = 3.141592653589793;

 grad = ((boma * 180) / pi);
 return grad;
}

// Wandelt grad in Bogenmass um
double bogenmass(double grad)
{
 double boma, pi = 3.141592653589793;

 boma = (grad * pi)  / 180;
 return boma;
}


void ZeigeFehler(int errorflg)
{
		/* Test error condition if any */
		switch(errorflg)
		{
		case	ERRFATAL:
			printf("Fatal error\n");
			break;
		case	ERRSYNTAX:
			printf("Syntax error\n");
			break;
		case	ERROVFLOW:
			printf("Overflow error\n");
			break;
		case	ERRSQRT:
			printf("Square root of neg number error\n");
			break;
		case	ERRFACT:
			printf("Factorial error\n");
			break;
		case	ERRFUNC:
			printf("Unknown math function error\n");
			break;
		case	ERRILLVAR:
			printf("Illegal variable error\n");
			break;
		default:
			break;
		}
	}	
	
int leg_dlm()
{
 int rewer = -1;

 return rewer;	
}	

#include	"evalx.h"
// int delstrchar(char quelle[], int xpos)
// int findechar(char quelle[], char gesucht)
// int del_strchar(char quelle[], char gesucht)


// Loescht aus einem c-String an xpos ein einzelnes char 
// Bei Erfolg Rueckgabewert = 0, sonst -1;
int delstrchar(char quelle[], int xpos)
{
 int wlen, i, rewer = -1;
 wlen  = strlen(quelle);
 
	
 if ((xpos >= 0) && (xpos < wlen))
 for( i = xpos; i < wlen; i++)
  {
   quelle[i] = quelle[i + 1]; 
   rewer = 0;
   //printf("*");
  }	
  
 return rewer; 
} 

// Loescht aus einem c-String an xpos ein einzelnes char 
// Bei Erfolg Rueckgabewert = 0, sonst -1;
int findechar(char quelle[], char gesucht)
{
 int wlen, i, rewer = -1;
 wlen  = strlen(quelle);
 
	
 for( i = 0; i < wlen; i++)
  {
   //printf("quelle[%d]=%c   gesucht=%c\n", i, quelle[i], gesucht);
   if(quelle[i] == gesucht) 
    {
     rewer = i;
     break;
   	}
  }	
  
 return rewer; 
} 


// Sucht in quelle das char gesucht und löscht alle vorkommenden chars
int del_strchar(char quelle[], char gesucht)
{
 int wlen, i, rewer = -1, gef = -1, erge = -1;
 wlen  = strlen(quelle);
 
 for( i = 0; i < wlen; i++)
  {
   gef = findechar(quelle, gesucht);
   erge = delstrchar(quelle, gef);
   if (erge != -1) rewer = 0;
   //printf("*");
  }	
  
 return rewer; 	
}

/*	+-----------------------------------+
 *	|                                   |
 *	|              CLASS.C              |
 *	|                                   |
 *	+-----------------------------------+
 *
 *	James. P. Hawkins - WA2WHV
 *	P.O. Box 9146,
 *	Trenton, NJ 08650
 *
 *      ALGEBRAIC EXPRESSION FIELD and OPERATOR CLASSIFIER
 *                 and SYNTAX CHECKER
 *		(LEXICAL analyzer of sorts)
 *
 *
 * calling format:
 *
 *	field class (or error) = class(&sptr, field);
 *
 *	where the ADDRESS of the Pointer sptr MUST be passed
 *		the input string pointer will be MODIFIED and
 *		LEFT at a point after the field just parsed
 *
 *		field = pointer to txtbuf where a null terminated copy
 *			of the field just parsed will be left
 *
 *		error code = negative of class
 *			(i.e. a certain type field was attempted
 *			 but something illegal happened
 */
#include	"evalx.h"

// the legdlm(X)  check for legal delimeters or null (end of string)   <------- Ersetzt durch Funktion
#define cpychr()	{*fptr++ = **sptr ; *sptr += 1; }
//#define legdlm(X) (any(X," ^*+/-)")  || (X =='\0')) <--------- ersetzt durch Funktion

// Skip white space macro 
//#define	skipspace()	{while(**sptr == ' ' || **sptr == '\t') *sptr +=1;}

/* -------------------------------------------------------------------- */
int klasse(char **sptr, char *field)  //char	**sptr == input string pointer char	*field == pointer to output field
{
	char *fptr;	// output field pointer
	int	pcnt;	// parenthesis best counter
	char delimiter[12] = {0};
	

	pcnt = 0;	    // init paren nest counter
	fptr = field;	// init output field pointer
	//skipspace();	// skip leading blanks and tabs  -->> werden jetzt direkt nach der Eingabe geloescht

	if(alpha(**sptr))	/* if 1st char is alpha */
	{
		cpychr();	/* copy first alpha */
		if(alpha(**sptr))	/* if second alpha it must be func */
		{
			 // Copy until first non-alphanumeric
			 // this must be a FUNCTION FIELD.
			 // The first non-alpha numeric must be a '('
			 
			while(alpha(**sptr) || num(**sptr))
			 {
			  cpychr();
			 }

			if(**sptr == '(') /* func name followed by '(' */
			{
				pcnt = 1; /* count first nest deep */
				cpychr(); /* copy initial '(' */
				
				 // Scan stuff inside of parens.
				 // parens must be balanced to terminate
				 // function field.
				 
				while(pcnt > 0 && **sptr != 0)
				{
					switch(**sptr)
					{
					case '(':
						pcnt += 1;
						break;
					case ')':
						pcnt -= 1;
						break;
					default:
						break;
					}
					cpychr();
				}

				if(**sptr == 0 && pcnt != 0)
				{
					*fptr='\0';
					
					 // line terminates before
					 // function defined.
					 
					return(-FNCLASS);
				}

				if(legdlm(**sptr))
				{
					*fptr = '\0'; /* null term */
					
					 // Return function klasse code
					
					return(FNCLASS);
				}
				else /* illegal delim */
				{
					return(-FNCLASS);
				}
			}
			else
			{
				return(-FNCLASS); /* function def without
						      '('  */
			}
		}
		else	/* VARIABLE OR VARIABLE ARRAY FIELD */
		{
			if(num(**sptr))
			{
				cpychr(); /* cpy numeric part of var name */
			}

			if(**sptr == '(') /* array paren? */
			{
				pcnt = 1;	/* init paren count */
				cpychr();	/* copy 1st paren */
				/*
				 * scan stuff inside of parens.
				 * parens must be balanced to terminate
				 * function field.
				 */
				while(pcnt > 0 && **sptr != 0)
				{
					switch(**sptr)
					{
					case '(':
						pcnt += 1;
						break;
					case ')':
						pcnt -= 1;
						break;
					default:
						break;
					}
					cpychr();
				}

				if(**sptr == 0 && pcnt != 0)
				{
					*fptr='\0';
					/*
					 * line terminates before array
					 * defined
					 */
					return(-VACLASS);
				}
				if(legdlm(**sptr))
				{
					*fptr = '\0'; /* null term */
					return(VACLASS);
				}
				else
				{
					*fptr = '\0';
					/* ill delim */
					return(-VACLASS);
				}
			}
			else /* VARIABLE NAME FIELD */
			{
				if(legdlm(**sptr)) // legal delimiter
		        {
					*fptr = '\0'; /* null term */
					return(VRCLASS);
				}
				else
				{
					return(-VRCLASS); /* ill delim */
				}
			}
		}
	}
	else /* EITHER NUMERIC OR OPERATOR FIELD */
	{
		if(num(**sptr) || **sptr == '.')
		{
			cpychr(); /* copy 1st dig of num */

			while(num(**sptr)) /* copy all consec dig */
			{
				cpychr();
			}

			if(**sptr == '.') /* embedded '.' is allowed */
			{
				cpychr();	/* copy '.' */
				while(num(**sptr)) /* get digits following
						      decimal point */
				{
					cpychr();
				}
			}
			if(**sptr == 'e' || **sptr == 'E')
			{
				cpychr();
				/*
				 * HANDLE EXPONENTIAL NOTATION TYPE
				 */
				if(**sptr == '+' || **sptr == '-')
				{
					cpychr();
					if(num(**sptr))
					{
						/* copy exponent */
						while(num(**sptr))
						{
							cpychr();
						}
					}
					else
					{
						return(-NMCLASS);
					}
				}
				else
				{
					return(-NMCLASS);
				}
			}
			if(legdlm(**sptr)) /* check for legal delim */
			{
				*fptr = '\0'; /* null term */
				return(NMCLASS); /* numeric */
			}
			else
			{
				return(-NMCLASS); /* ill delim */
			}
		}
		else /* OPERATOR FIELD */
		{
			strcpy(delimiter, "^*/+-()");
			if(any(**sptr, delimiter))
			{
				cpychr(); /* copy the operator */
				*fptr = '\0'; /* term with null */
				return(OPCLASS); /* operator */
			}
			else
			{
				return(-OPCLASS); /* illegal delim */
			}
		}
	}
}

/* ------------------------------------------------------------------- */
// TRUE IF ANY CHARS IN STRING as MATCH c
/* alt:
 * short any(int c, char *as)
{
	register char *s;

	s = as;
	while(*s)
	{
		if(*s++ == c)
		{
			return(1);
		}
	}
	return(0);
}*/
short any(int c, char *as)
{
 register char *s;
 //int slen = strlen(as);
	s = as;
	while(*s)
	{
		if(*s++ == c)
		{
			return(1);
		}
	}
	return(0);
}

/* ------------------------------------------------------------------- */

 // TRUE IF NUMERIC
short num(char c)
{
	if(c >= '0' && c <= '9')
	{
		return(1);
	}
	else
	{
		return(0);
	}
}

/* ------------------------------------------------------------------- */

 // TRUE IF ALPHA lower case 
short alpha(char c)
{
	if(c >= 'a' && c <= 'z')
	{
		return(1);
	}
	else
	{
		return(0);
	}
}

// Ersatz für Makro
short legdlm(int c)
{
 char andere[8] = {' ', '^', '*', '+', '/', '-', ')', '\0'};	
 int i, rewer = 0;

	
 for (i = 0; i < 8; i++)
  if (c == andere[i])
   rewer = 1;   
    
 return rewer;
}

Mach mit!