X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvisualization%2Fgalaktos%2Feval.c;h=e509326533a0b97c29e6f0642c2dcc7080bd30bb;hb=6ee1e193fd896ab9a4729fde14f009d9ce629815;hp=4ad7bc28676e1da682bc823e2eb82f770670178f;hpb=3305b049e7f587b23359a1c9047fb5763d19c1dc;p=vlc

diff --git a/modules/visualization/galaktos/eval.c b/modules/visualization/galaktos/eval.c
index 4ad7bc2867..e509326533 100644
--- a/modules/visualization/galaktos/eval.c
+++ b/modules/visualization/galaktos/eval.c
@@ -50,16 +50,16 @@ static inline double eval_val_expr(val_expr_t * val_expr);
 inline double eval_gen_expr(gen_expr_t * gen_expr) {
   double l;
 
-  if (gen_expr == NULL) 
-    	return 0;
- 	
+  if (gen_expr == NULL)
+        return 0;
+     
   switch(gen_expr->type) {
-  case VAL_T:  
+  case VAL_T:
     return eval_val_expr(gen_expr->item);
   case PREFUN_T:
     l = eval_prefun_expr(gen_expr->item);
     //if (EVAL_DEBUG) printf("eval_gen_expr: prefix function return value: %f\n", l);
-    return l;		
+    return l;        
   case TREE_T:
     return eval_tree_expr(gen_expr->item);
   default:
@@ -67,46 +67,46 @@ inline double eval_gen_expr(gen_expr_t * gen_expr) {
     printf("eval_gen_expr: general expression matched no cases!\n");
     #endif
     return EVAL_ERROR;
-  }  
-	
+  }
+    
 }
 
 /* Evaluates functions in prefix form */
 static inline double eval_prefun_expr(prefun_expr_t * prefun_expr) {
-	int i;
-       
-	
-	/* This is slightly less than safe, since
-	   who knows if the passed argument is valid. For 
-	   speed purposes we'll go with this */
-	double arg_list[prefun_expr->num_args];
-	
-	#ifdef EVAL_DEBUG 
-		printf("fn[");
-		fflush(stdout);
-	#endif
-	/* Evaluate each argument before calling the function itself */
-	for (i = 0; i < prefun_expr->num_args; i++) {
-		arg_list[i] = eval_gen_expr(prefun_expr->expr_list[i]);
-		#ifdef EVAL_DEBUG 
-			if (i < (prefun_expr->num_args - 1))
-				printf(", ");
-			fflush(stdout);
-		#endif
-	}
-	
-	#ifdef EVAL_DEBUG 
-		printf("]");
-		fflush(stdout);
-	#endif
-	
-	/* Now we call the function, passing a list of 	
-	   doubles as its argument */
-     
+    int i;
+ 
+    
+    /* This is slightly less than safe, since
+       who knows if the passed argument is valid. For
+       speed purposes we'll go with this */
+    double arg_list[prefun_expr->num_args];
+    
+    #ifdef EVAL_DEBUG
+        printf("fn[");
+        fflush(stdout);
+    #endif
+    /* Evaluate each argument before calling the function itself */
+    for (i = 0; i < prefun_expr->num_args; i++) {
+        arg_list[i] = eval_gen_expr(prefun_expr->expr_list[i]);
+        #ifdef EVAL_DEBUG
+            if (i < (prefun_expr->num_args - 1))
+                printf(", ");
+            fflush(stdout);
+        #endif
+    }
+    
+    #ifdef EVAL_DEBUG
+        printf("]");
+        fflush(stdout);
+    #endif
+    
+    /* Now we call the function, passing a list of     
+       doubles as its argument */
+ 
 
-     
-	return (prefun_expr->func_ptr)(arg_list);	
-}	
+ 
+    return (prefun_expr->func_ptr)(arg_list);    
+}    
 
 /* Evaluates a value expression */
 static inline double eval_val_expr(val_expr_t * val_expr) {
@@ -117,50 +117,50 @@ static inline double eval_val_expr(val_expr_t * val_expr) {
 
   /* Value is a constant, return the double value */
   if (val_expr->type == CONSTANT_TERM_T) {
-    #ifdef EVAL_DEBUG 
-		printf("%.4f", val_expr->term.constant);
-		fflush(stdout);
+    #ifdef EVAL_DEBUG
+        printf("%.4f", val_expr->term.constant);
+        fflush(stdout);
     #endif
     return (val_expr->term.constant);
   }
 
   /* Value is variable, dereference it */
   if (val_expr->type == PARAM_TERM_T) {
-   	switch (val_expr->term.param->type) {
-		
-	case P_TYPE_BOOL:
-		#ifdef EVAL_DEBUG 
-			printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
-			fflush(stdout);
-		#endif
-	       
-		  
-		return (double)(*((int*)(val_expr->term.param->engine_val)));
-	case P_TYPE_INT:
-		#ifdef EVAL_DEBUG 
-			printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
-			fflush(stdout);
-		#endif
-
-	     
-		return (double)(*((int*)(val_expr->term.param->engine_val)));
-	case P_TYPE_DOUBLE:		
-		#ifdef EVAL_DEBUG 
-			printf("(%s:%.4f)", val_expr->term.param->name, (*((double*)val_expr->term.param->engine_val)));
-			fflush(stdout);
-		#endif
-			
-		if (val_expr->term.param->matrix_flag | (val_expr->term.param->flags & P_FLAG_ALWAYS_MATRIX)) {
-		  if (mesh_j >= 0) {
-		    return (((double**)val_expr->term.param->matrix)[mesh_i][mesh_j]);
-		  }
-		  else {
-		    return (((double*)val_expr->term.param->matrix)[mesh_i]);
-		  }
-		}
-		return *((double*)(val_expr->term.param->engine_val));
-	default:
-	  return ERROR;	
+       switch (val_expr->term.param->type) {
+        
+    case P_TYPE_BOOL:
+        #ifdef EVAL_DEBUG
+            printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
+            fflush(stdout);
+        #endif
+    
+        
+        return (double)(*((int*)(val_expr->term.param->engine_val)));
+    case P_TYPE_INT:
+        #ifdef EVAL_DEBUG
+            printf("(%s:%.4f)", val_expr->term.param->name, (double)(*((int*)(val_expr->term.param->engine_val))));
+            fflush(stdout);
+        #endif
+
+    
+        return (double)(*((int*)(val_expr->term.param->engine_val)));
+    case P_TYPE_DOUBLE:        
+        #ifdef EVAL_DEBUG
+            printf("(%s:%.4f)", val_expr->term.param->name, (*((double*)val_expr->term.param->engine_val)));
+            fflush(stdout);
+        #endif
+            
+        if (val_expr->term.param->matrix_flag | (val_expr->term.param->flags & P_FLAG_ALWAYS_MATRIX)) {
+          if (mesh_j >= 0) {
+            return (((double**)val_expr->term.param->matrix)[mesh_i][mesh_j]);
+          }
+          else {
+            return (((double*)val_expr->term.param->matrix)[mesh_i]);
+          }
+        }
+        return *((double*)(val_expr->term.param->engine_val));
+    default:
+      return ERROR;    
     }
   }
   /* Unknown type, return failure */
@@ -169,107 +169,107 @@ static inline double eval_val_expr(val_expr_t * val_expr) {
 
 /* Evaluates an expression tree */
 static inline double eval_tree_expr(tree_expr_t * tree_expr) {
-		
-	double left_arg, right_arg;	
-	infix_op_t * infix_op;
-	
-	/* Shouldn't happen */
-	if (tree_expr == NULL)
-	  return EVAL_ERROR;
-
-	/* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
-	if (tree_expr->infix_op == NULL) {
-		if (tree_expr->gen_expr == NULL)
-			return 0;
-		else
-	  		return eval_gen_expr(tree_expr->gen_expr);
-	}
-	
-	/* Otherwise, this node is an infix operator. Evaluate
-	   accordingly */
-	
-	infix_op = (infix_op_t*)tree_expr->infix_op;	
-	#ifdef EVAL_DEBUG 
-		printf("(");
-		fflush(stdout);
-	#endif
-	
-	left_arg = eval_tree_expr(tree_expr->left);
-
-	#ifdef EVAL_DEBUG 
-		
-		switch (infix_op->type) {
-		case INFIX_ADD:
-			printf("+");
-			break;		
-		case INFIX_MINUS:
-			printf("-");
-			break;
-		case INFIX_MULT:
-			printf("*");
-			break;
-		case INFIX_MOD:
-			printf("%%");
-			break;
-		case INFIX_OR:
-			printf("|");
-			break;
-		case INFIX_AND:
-			printf("&");
-			break;
-		case INFIX_DIV:
-			printf("/");
-			break;
-		default:
-			printf("?");
-		}
-	
-	fflush(stdout);	
-	#endif
-	
-	right_arg = eval_tree_expr(tree_expr->right);
-	
-	#ifdef EVAL_DEBUG
-		printf(")");
-		fflush(stdout);
-	#endif
-	
-	switch (infix_op->type) {		
-	case INFIX_ADD:
-	  return (left_arg + right_arg);		
-	case INFIX_MINUS:
-		return (left_arg - right_arg);
-	case INFIX_MULT:
-		return (left_arg * right_arg);
-	case INFIX_MOD:
-	  if ((int)right_arg == 0) {
-	    #ifdef EVAL_DEBUG 
-	    printf("eval_tree_expr: modulo zero!\n");
-	    #endif
-	    return DIV_BY_ZERO; 
-	  }
-	  return ((int)left_arg % (int)right_arg);
-	case INFIX_OR:
-		return ((int)left_arg | (int)right_arg);
-	case INFIX_AND:
-		return ((int)left_arg & (int)right_arg);
-	case INFIX_DIV:
-	  if (right_arg == 0) {
-	    #ifdef EVAL_DEBUG 
-	    printf("eval_tree_expr: division by zero!\n");
-	    #endif
-	    return MAX_DOUBLE_SIZE;
-	  }		
-	  return (left_arg / right_arg);
-	default:
-          #ifdef EVAL_DEBUG 
-	    printf("eval_tree_expr: unknown infix operator!\n");
+        
+    double left_arg, right_arg;    
+    infix_op_t * infix_op;
+    
+    /* Shouldn't happen */
+    if (tree_expr == NULL)
+      return EVAL_ERROR;
+
+    /* A leaf node, evaluate the general expression. If the expression is null as well, return zero */
+    if (tree_expr->infix_op == NULL) {
+        if (tree_expr->gen_expr == NULL)
+            return 0;
+        else
+              return eval_gen_expr(tree_expr->gen_expr);
+    }
+    
+    /* Otherwise, this node is an infix operator. Evaluate
+       accordingly */
+    
+    infix_op = (infix_op_t*)tree_expr->infix_op;    
+    #ifdef EVAL_DEBUG
+        printf("(");
+        fflush(stdout);
+    #endif
+    
+    left_arg = eval_tree_expr(tree_expr->left);
+
+    #ifdef EVAL_DEBUG
+        
+        switch (infix_op->type) {
+        case INFIX_ADD:
+            printf("+");
+            break;        
+        case INFIX_MINUS:
+            printf("-");
+            break;
+        case INFIX_MULT:
+            printf("*");
+            break;
+        case INFIX_MOD:
+            printf("%%");
+            break;
+        case INFIX_OR:
+            printf("|");
+            break;
+        case INFIX_AND:
+            printf("&");
+            break;
+        case INFIX_DIV:
+            printf("/");
+            break;
+        default:
+            printf("?");
+        }
+    
+    fflush(stdout);    
+    #endif
+    
+    right_arg = eval_tree_expr(tree_expr->right);
+    
+    #ifdef EVAL_DEBUG
+        printf(")");
+        fflush(stdout);
+    #endif
+    
+    switch (infix_op->type) {        
+    case INFIX_ADD:
+      return (left_arg + right_arg);        
+    case INFIX_MINUS:
+        return (left_arg - right_arg);
+    case INFIX_MULT:
+        return (left_arg * right_arg);
+    case INFIX_MOD:
+      if ((int)right_arg == 0) {
+        #ifdef EVAL_DEBUG
+        printf("eval_tree_expr: modulo zero!\n");
+        #endif
+        return DIV_BY_ZERO;
+      }
+      return ((int)left_arg % (int)right_arg);
+    case INFIX_OR:
+        return ((int)left_arg | (int)right_arg);
+    case INFIX_AND:
+        return ((int)left_arg & (int)right_arg);
+    case INFIX_DIV:
+      if (right_arg == 0) {
+        #ifdef EVAL_DEBUG
+        printf("eval_tree_expr: division by zero!\n");
+        #endif
+        return MAX_DOUBLE_SIZE;
+      }        
+      return (left_arg / right_arg);
+    default:
+          #ifdef EVAL_DEBUG
+        printf("eval_tree_expr: unknown infix operator!\n");
           #endif
-		return ERROR;
-	}
-	
-	return ERROR;
-}	
+        return ERROR;
+    }
+    
+    return ERROR;
+}    
 
 /* Converts a double value to a general expression */
 gen_expr_t * const_to_expr(double val) {
@@ -277,18 +277,18 @@ gen_expr_t * const_to_expr(double val) {
   gen_expr_t * gen_expr;
   val_expr_t * val_expr;
   term_t term;
-  
+ 
   term.constant = val;
-    
+ 
   if ((val_expr = new_val_expr(CONSTANT_TERM_T, term)) == NULL)
     return NULL;
 
   gen_expr = new_gen_expr(VAL_T, (void*)val_expr);
 
   if (gen_expr == NULL) {
-	free_val_expr(val_expr);
+    free_val_expr(val_expr);
   }
-  
+ 
   return gen_expr;
 }
 
@@ -303,27 +303,27 @@ gen_expr_t * param_to_expr(param_t * param) {
     return NULL;
  
   /* This code is still a work in progress. We need
-     to figure out if the initial condition is used for 
+     to figure out if the initial condition is used for
      each per frame equation or not. I am guessing that
      it isn't, and it is thusly implemented this way */
-  
+ 
   /* Current guess of true behavior (08/01/03) note from carm
-     First try to use the per_pixel_expr (with cloning). 
+     First try to use the per_pixel_expr (with cloning).
      If it is null however, use the engine variable instead. */
-  
+ 
   /* 08/20/03 : Presets are now objects, as well as per pixel equations. This ends up
      making the parser handle the case where parameters are essentially per pixel equation
      substitutions */
-       
-  
+ 
+ 
   term.param = param;
   if ((val_expr = new_val_expr(PARAM_TERM_T, term)) == NULL)
     return NULL;
-  
+ 
   if ((gen_expr = new_gen_expr(VAL_T, (void*)val_expr)) == NULL) {
     free_val_expr(val_expr);
-	return NULL;	  
-  } 
+    return NULL;    
+  }
   return gen_expr;
 }
 
@@ -332,14 +332,14 @@ gen_expr_t * prefun_to_expr(double (*func_ptr)(), gen_expr_t ** expr_list, int n
 
   gen_expr_t * gen_expr;
   prefun_expr_t * prefun_expr;
-  
+ 
 
   /* Malloc a new prefix function expression */
   prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t));
 
   if (prefun_expr == NULL)
-	  return NULL;
-  
+      return NULL;
+ 
   prefun_expr->num_args = num_args;
   prefun_expr->func_ptr = func_ptr;
   prefun_expr->expr_list = expr_list;
@@ -347,24 +347,24 @@ gen_expr_t * prefun_to_expr(double (*func_ptr)(), gen_expr_t ** expr_list, int n
   gen_expr = new_gen_expr(PREFUN_T, (void*)prefun_expr);
 
   if (gen_expr == NULL)
-	  free_prefun_expr(prefun_expr);
-  
+      free_prefun_expr(prefun_expr);
+ 
   return gen_expr;
 }
 
 /* Creates a new tree expression */
 tree_expr_t * new_tree_expr(infix_op_t * infix_op, gen_expr_t * gen_expr, tree_expr_t * left, tree_expr_t * right) {
 
-		tree_expr_t * tree_expr;
-		tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t));
-	
-		if (tree_expr == NULL)
-			return NULL;
-		tree_expr->infix_op = infix_op;
-		tree_expr->gen_expr = gen_expr;
-		tree_expr->left = left;
-		tree_expr->right = right;
-		return tree_expr;
+        tree_expr_t * tree_expr;
+        tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t));
+    
+        if (tree_expr == NULL)
+            return NULL;
+        tree_expr->infix_op = infix_op;
+        tree_expr->gen_expr = gen_expr;
+        tree_expr->left = left;
+        tree_expr->right = right;
+        return tree_expr;
 }
 
 
@@ -386,39 +386,39 @@ val_expr_t * new_val_expr(int type, term_t term) {
 /* Creates a new general expression */
 gen_expr_t * new_gen_expr(int type, void * item) {
 
-	gen_expr_t * gen_expr;
+    gen_expr_t * gen_expr;
 
-	gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t));
-	if (gen_expr == NULL)
-		return NULL;
-	gen_expr->type = type;
-	gen_expr->item = item;	
+    gen_expr = (gen_expr_t*)malloc(sizeof(gen_expr_t));
+    if (gen_expr == NULL)
+        return NULL;
+    gen_expr->type = type;
+    gen_expr->item = item;    
 
-	return gen_expr;
+    return gen_expr;
 }
 
 /* Frees a general expression */
 int free_gen_expr(gen_expr_t * gen_expr) {
 
-	if (gen_expr == NULL)
-	 	return SUCCESS;
-	
-	switch (gen_expr->type) {
-	case VAL_T:
-		free_val_expr(gen_expr->item);
-		break;
-	case PREFUN_T:
-		free_prefun_expr(gen_expr->item);
-		break;
-	case TREE_T:
-		free_tree_expr(gen_expr->item);
-		break;
-	default:
-		return FAILURE;
-	}	
-
-	free(gen_expr);
-	return SUCCESS;
+    if (gen_expr == NULL)
+         return SUCCESS;
+    
+    switch (gen_expr->type) {
+    case VAL_T:
+        free_val_expr(gen_expr->item);
+        break;
+    case PREFUN_T:
+        free_prefun_expr(gen_expr->item);
+        break;
+    case TREE_T:
+        free_tree_expr(gen_expr->item);
+        break;
+    default:
+        return FAILURE;
+    }    
+
+    free(gen_expr);
+    return SUCCESS;
 
 }
 
@@ -426,52 +426,52 @@ int free_gen_expr(gen_expr_t * gen_expr) {
 /* Frees a function in prefix notation */
 int free_prefun_expr(prefun_expr_t * prefun_expr) {
 
-	int i;
-	if (prefun_expr == NULL)
-		return SUCCESS;
-	
-	/* Free every element in expression list */
-	for (i = 0 ; i < prefun_expr->num_args; i++) {
-		free_gen_expr(prefun_expr->expr_list[i]);
-	}
-
-	free(prefun_expr);
-	return SUCCESS;
+    int i;
+    if (prefun_expr == NULL)
+        return SUCCESS;
+    
+    /* Free every element in expression list */
+    for (i = 0 ; i < prefun_expr->num_args; i++) {
+        free_gen_expr(prefun_expr->expr_list[i]);
+    }
+
+    free(prefun_expr);
+    return SUCCESS;
 }
 
 /* Frees values of type VARIABLE and CONSTANT */
 int free_val_expr(val_expr_t * val_expr) {
 
-	if (val_expr == NULL)
-		return SUCCESS;	
-	
-	free(val_expr);
-	return SUCCESS;
+    if (val_expr == NULL)
+        return SUCCESS;    
+    
+    free(val_expr);
+    return SUCCESS;
 }
 
 /* Frees a tree expression */
 int free_tree_expr(tree_expr_t * tree_expr) {
 
-	if (tree_expr == NULL)
-		return SUCCESS;
-	
-	/* free left tree */
-	free_tree_expr(tree_expr->left);
-	
-	/* free general expression object */
-	free_gen_expr(tree_expr->gen_expr);
-	
-	/* Note that infix operators are always
-	   stored in memory unless the program 
-	   exits, so we don't remove them here */
-	
-	/* free right tree */
-	free_tree_expr(tree_expr->right);
-	
-	
-	/* finally, free the struct itself */
-	free(tree_expr);
-	return SUCCESS;
+    if (tree_expr == NULL)
+        return SUCCESS;
+    
+    /* free left tree */
+    free_tree_expr(tree_expr->left);
+    
+    /* free general expression object */
+    free_gen_expr(tree_expr->gen_expr);
+    
+    /* Note that infix operators are always
+       stored in memory unless the program
+       exits, so we don't remove them here */
+    
+    /* free right tree */
+    free_tree_expr(tree_expr->right);
+    
+    
+    /* finally, free the struct itself */
+    free(tree_expr);
+    return SUCCESS;
 }
 
 
@@ -479,19 +479,19 @@ int free_tree_expr(tree_expr_t * tree_expr) {
 /* Initializes all infix operators */
 int init_infix_ops() {
 
-	infix_add = new_infix_op(INFIX_ADD, 4);
-	infix_minus = new_infix_op(INFIX_MINUS, 3);
-	infix_div = new_infix_op(INFIX_DIV, 2);
-	infix_or = new_infix_op(INFIX_OR, 5);
-	infix_and = new_infix_op(INFIX_AND,4);
-	infix_mod = new_infix_op(INFIX_MOD, 1);
-	infix_mult = new_infix_op(INFIX_MULT, 2);
-	
-	/* Prefix operators */
-	infix_positive = new_infix_op(INFIX_ADD, 0);
-	infix_negative = new_infix_op(INFIX_MINUS, 0);
-
-	return SUCCESS;
+    infix_add = new_infix_op(INFIX_ADD, 4);
+    infix_minus = new_infix_op(INFIX_MINUS, 3);
+    infix_div = new_infix_op(INFIX_DIV, 2);
+    infix_or = new_infix_op(INFIX_OR, 5);
+    infix_and = new_infix_op(INFIX_AND,4);
+    infix_mod = new_infix_op(INFIX_MOD, 1);
+    infix_mult = new_infix_op(INFIX_MULT, 2);
+    
+    /* Prefix operators */
+    infix_positive = new_infix_op(INFIX_ADD, 0);
+    infix_negative = new_infix_op(INFIX_MINUS, 0);
+
+    return SUCCESS;
 }
 
 /* Destroys the infix operator list. This should
@@ -515,17 +515,17 @@ int destroy_infix_ops()
 /* Initializes an infix operator */
 infix_op_t * new_infix_op(int type, int precedence) {
 
-	infix_op_t * infix_op;
-	
-	infix_op = (infix_op_t*)malloc(sizeof(infix_op_t));
-	
-	if (infix_op == NULL)
-		return NULL;
-	
-	infix_op->type = type;
-	infix_op->precedence = precedence;
-	
-	return infix_op;
+    infix_op_t * infix_op;
+    
+    infix_op = (infix_op_t*)malloc(sizeof(infix_op_t));
+    
+    if (infix_op == NULL)
+        return NULL;
+    
+    infix_op->type = type;
+    infix_op->precedence = precedence;
+    
+    return infix_op;
 }
 
 
@@ -557,7 +557,7 @@ gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {
     }
     new_gen_expr->item = (void*)val_expr;
     break;
-    
+ 
   case PREFUN_T: /* prefix function expression */
     if ((prefun_expr = clone_prefun_expr((prefun_expr_t*)gen_expr->item)) == NULL) {
       free(new_gen_expr);
@@ -565,7 +565,7 @@ gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {
     }
     new_gen_expr->item = (void*)prefun_expr;
     break;
-    
+ 
   case TREE_T:  /* tree expression */
     if ((tree_expr = clone_tree_expr((tree_expr_t*)gen_expr->item)) == NULL) {
       free(new_gen_expr);
@@ -573,12 +573,12 @@ gen_expr_t * clone_gen_expr(gen_expr_t * gen_expr) {
     }
     new_gen_expr->item = (void*)tree_expr;
     break;
-    
+ 
   default: /* unknown type, ut oh.. */
     free(new_gen_expr);
     return NULL;
   }
-  
+ 
   return new_gen_expr; /* Return the new (cloned) general expression */
 }
 
@@ -591,11 +591,11 @@ tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr) {
   /* Null argument */
   if (tree_expr == NULL)
     return NULL;
-  
+ 
   /* Out of memory */
-  if ((new_tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t))) == NULL) 
+  if ((new_tree_expr = (tree_expr_t*)malloc(sizeof(tree_expr_t))) == NULL)
     return NULL;
-  
+ 
   /* Set each argument in tree_expr_t struct */
   new_tree_expr->infix_op = tree_expr->infix_op;  /* infix operators are in shared memory */
   new_tree_expr->gen_expr = clone_gen_expr(tree_expr->gen_expr); /* clone the general expression */
@@ -605,7 +605,7 @@ tree_expr_t * clone_tree_expr(tree_expr_t * tree_expr) {
   return new_tree_expr; /* Return the new (cloned) tree expression */
 }
 
-/* Clones a value expression, currently only passes the pointer to 
+/* Clones a value expression, currently only passes the pointer to
    the value that this object represents, not a pointer to a copy of the value */
 val_expr_t * clone_val_expr(val_expr_t * val_expr) {
 
@@ -614,15 +614,15 @@ val_expr_t * clone_val_expr(val_expr_t * val_expr) {
   /* Null argument */
   if (val_expr == NULL)
     return NULL;
-  
+ 
   /* Allocate space, check for out of memory */
-  if ((new_val_expr = (val_expr_t*)malloc(sizeof(val_expr_t))) == NULL) 
+  if ((new_val_expr = (val_expr_t*)malloc(sizeof(val_expr_t))) == NULL)
     return NULL;
 
   /* Set the values in the val_expr_t struct */
   new_val_expr->type = val_expr->type;
   new_val_expr->term = val_expr->term;
-  
+ 
   /* Return the new (cloned) value expression */
   return new_val_expr;
 }
@@ -632,15 +632,15 @@ prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr) {
 
   int i;
   prefun_expr_t * new_prefun_expr;
-  
+ 
   /* Null argument */
   if (prefun_expr == NULL)
     return NULL;
-  
+ 
   /* Out of memory */
-  if ((new_prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t))) == NULL) 
+  if ((new_prefun_expr = (prefun_expr_t*)malloc(sizeof(prefun_expr_t))) == NULL)
     return NULL;
-  
+ 
   /* Set the function argument paired with its number of arguments */
   new_prefun_expr->num_args = prefun_expr->num_args;
   new_prefun_expr->func_ptr = prefun_expr->func_ptr;
@@ -652,9 +652,9 @@ prefun_expr_t * clone_prefun_expr(prefun_expr_t * prefun_expr) {
   }
 
   /* Now copy each general expression from the argument expression list */
-  for (i = 0; i < new_prefun_expr->num_args;i++) 
+  for (i = 0; i < new_prefun_expr->num_args;i++)
     new_prefun_expr->expr_list[i] = clone_gen_expr(prefun_expr->expr_list[i]);
-  
+ 
   /* Finally, return the new (cloned) prefix function expression */
   return new_prefun_expr;
 }
@@ -666,7 +666,7 @@ void reset_engine_vars() {
   zoomexp= 1.0;
   rot= 0.0;
   warp= 0.0;
-  
+ 
   sx= 1.0;
   sy= 1.0;
   dx= 0.0;
@@ -674,9 +674,9 @@ void reset_engine_vars() {
   cx= 0.5;
   cy= 0.5;
 
-  
+ 
   decay=.98;
-  
+ 
   wave_r= 1.0;
   wave_g= 0.2;
   wave_b= 0.0;
@@ -705,7 +705,7 @@ void reset_engine_vars() {
   mv_y = 12.0;
   mv_dy = 0.02;
   mv_dx = 0.02;
-  
+ 
   meshx = 0;
   meshy = 0;