added more calculate function

Author: jeanlego

ODIN_II/SRC/ast_elaborate.c

@@ -1,6 +1,5 @@
 /*
 Copyright (c) 2009 Peter Andrew Jamieson ([email protected])
-
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
@@ -9,10 +8,8 @@ copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:
-
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
-
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -342,4 +339,4 @@ info_ast_visit_t *constantFold(ast_node_t *node)
 	}
 
 	return node_details;
-}
+}

ODIN_II/SRC/ast_elaborate.h

@@ -970,32 +970,6 @@ char *make_module_param_name(ast_node_t *module_param_list, char *module_name)
 }
 
 
-/*---------------------------------------------------------------------------------------------
- * (function: calculate)
- * Calculate binary operations
- *-------------------------------------------------------------------------------------------*/
-long calculate(long operand0, long operand1, short type)
-{
-	long result = 0;
-	switch(type){
-		case ADD:
-			result = operand0 + operand1;
-			break;
-		case MINUS:
-			result = operand0 - operand1;
-			break;
-		case MULTIPLY:
-			result = operand0 * operand1;
-			break;
-		case DIVIDE:
-			result = operand0 / operand1;
-			break;
-		default:
-			break;
-	}
-	return result;
-}
-
 /*---------------------------------------------------------------------------------------------
  * (function: move_ast_node)
  * move node from src to dest
@@ -1048,3 +1022,99 @@ ast_node_t *ast_node_deep_copy(ast_node_t *node){
 
 	return node_copy;
 }
+
+
+/*---------------------------------------------------------------------------------------------
+ * (function: calculate)
+ * Calculate binary operations
+ *-------------------------------------------------------------------------------------------*/
+long calculate(long operand0, long operand1, short type){
+	long result = 0;
+	long long temp =calculate_binary((long long) operand0, (long long) operand1,type);
+	if(!(temp & WRONG_CALCULATION)){
+		return (long) temp;
+	}
+	return result;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ * (function: calculate_unary)
+ *-------------------------------------------------------------------------------------------*/
+long long calculate_unary(long long operand_0, short type_of_ops){
+	if(operand_0 !=  WRONG_CALCULATION){
+		switch (type_of_ops){
+			case LOGICAL_NOT:
+				return !operand_0;
+			case BITWISE_NOT:
+				return ~operand_0;
+			case MINUS:
+				return -operand_0;
+			default:
+				break;
+		}
+	}
+	return WRONG_CALCULATION;
+}
+
+/*---------------------------------------------------------------------------------------------
+ * (function: calculate_binary)
+ *-------------------------------------------------------------------------------------------*/
+long long calculate_binary(long long operand_0, long long operand_1, short type_of_ops){
+	if(!(operand_0 & WRONG_CALCULATION) && !(operand_1 & WRONG_CALCULATION)){
+		switch (type_of_ops){
+			case ADD:
+				return operand_0 + operand_1;
+			case MINUS:
+				return operand_0 - operand_1;
+			case MULTIPLY:
+				return operand_0 * operand_1;
+			case DIVIDE:
+				return operand_0 / operand_1;
+			case BITWISE_XOR:
+				return operand_0 ^ operand_1;
+			case BITWISE_XNOR:
+				return ~(operand_0 ^ operand_1);
+			case BITWISE_AND:
+				return operand_0 & operand_1;
+			case BITWISE_NAND:
+				return ~(operand_0 & operand_1);
+			case BITWISE_OR:
+				return operand_0 | operand_1;
+			case BITWISE_NOR:
+				return ~(operand_0 | operand_1);
+			case SL:
+				return operand_0 << operand_1;
+			case SR:
+				return operand_0 >> operand_1;
+			case LOGICAL_AND:
+				return operand_0 && operand_1;
+			case LOGICAL_OR:
+				return operand_0 || operand_1;
+			default:
+				break;
+		}
+	}
+	return WRONG_CALCULATION;
+}
+
+/*---------------------------------------------------------------------------------------------
+ * (function: node_is_constant)
+ *-------------------------------------------------------------------------------------------*/
+long long node_is_constant(ast_node_t *node){
+	if (node != NULL && node->type == NUMBERS){
+		/* check if it's a constant depending on the number type */
+		switch (node->types.number.base){
+			case DEC: case HEX: case OCT: case BIN:
+				if (node->types.number.value == -1){
+					break;
+				}
+			case(LONG_LONG):
+				return (long long) node->types.number.value;
+				break;
+            default:
+				break;
+		}
+	}
+	return WRONG_CALCULATION;
+}

ODIN_II/SRC/ast_optimizations.c

@@ -24,6 +24,10 @@ char_list_t *get_name_of_pins_with_prefix(ast_node_t *var_node, char *instance_n
 ast_node_t *resolve_node(char *module_name, ast_node_t *node);
 char *make_module_param_name(ast_node_t *module_param_list, char *module_name);
 long calculate(long operand0, long operand1, short type);
+long long calculate_unary(long long operand_0, short type_of_ops);
+long long calculate_binary(long long operand_0,long long operand_1 , short type_of_ops);
+
 void move_ast_node(ast_node_t *src, ast_node_t *dest, ast_node_t *node);
 
 ast_node_t *ast_node_deep_copy(ast_node_t *node);
+long long node_is_constant(ast_node_t *node);

ODIN_II/SRC/ast_util.c

@@ -68,6 +68,12 @@ typedef struct chain_information_t_t chain_information_t;
 #define ACTIVATION_ERROR -7
 /* for errors in the netlist simulation */
 #define SIMULATION_ERROR -8
+/* for errors in the calculation 
+*	largest hex value it can take 
+*	avoids using include limit.h since it may (or may not) conflict with naming.
+*	also keep it "portable" is long long reall necessary tho? long would suffice and c99 wouldnt be essential
+*/
+# define WRONG_CALCULATION (long long)1 << (sizeof(long long)*8-1)
 
 /* unique numbers to mark the nodes as we DFS traverse the netlist */
 #define PARTIAL_MAP_TRAVERSE_VALUE 10