WebSVN – Vertical – Diff – /branches/metal/vertlib/expression.c

 /* expression.h */
 /* contains the type declarations for expression handling information  */
 /*
  * $Id: expression.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $
+ *
  * $Log: expression.c,v $
  * Revision 1.1.1.1  2003/11/04 23:34:57  mjames
  * Imported into local repositrory
+ *
  * Mike put it here
+ *
+ *
  * Revision 1.20  2000/10/12  15:32:18  15:32:18  mjames (Mike James)
  * Removed <cr>
  *
  * Revision 1.19  2000/10/04  10:37:04  10:37:04  mjames (Mike James)
  * Modified for Vertical2 : support COMPONENTS and SIGNALS
  *
  * Revision 1.19  2000/10/04  10:37:04  10:37:04  mjames (Mike James)
  * Part of Release PSAVAT01
  *
  * Revision 1.18  2000/10/02  11:04:12  11:04:12  mjames (Mike James)
  * new_vhdl
  *
  * Revision 1.17  2000/09/27  14:42:12  14:42:12  mjames (Mike James)
  * Part of Release Sep_27_ST_2000
  *
  * Revision 1.16  2000/09/21  10:15:42  10:15:42  mjames (Mike James)
  * Part of Release Sep21Alpha
  *
  * Revision 1.15  2000/08/25  09:57:10  09:57:10  mjames (Mike James)
  * Part of Release Aug25_alpha
  *
  * Revision 1.14  2000/08/16  08:57:27  08:57:27  mjames (Mike James)
  * Part of Release CD01_Aug2000
  *
  * Revision 1.13  2000/08/14  14:45:08  14:45:08  mjames (Mike James)
  * Part of Release Aug_14_2000
  *
  * Revision 1.12  2000/08/11  08:30:28  08:30:28  mjames (Mike James)
  * Part of Release Aug_11_2000
  *
  * Revision 1.11  2000/08/09  10:31:42  10:31:42  mjames (Mike James)
  * Part of Release Aug__9_2000
  *
  * Revision 1.10  2000/05/31  11:42:50  11:42:50  mjames (Mike James)
  * Part of Release May_31_2000
  *
  * Revision 1.9  2000/05/08  17:01:34  17:01:34  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.8  2000/05/08  16:59:27  16:59:27  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.7  2000/05/08  16:57:03  16:57:03  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.6  2000/03/08  16:18:56  16:18:56  mjames (Mike James)
  * New version including PC
  *
  * Revision 1.3  2000/01/20  15:58:42  15:58:42  mjames (Mike James)
  * Part of Release R22
  *
  * Revision 1.2  99/12/22  11:15:23  11:15:23  mjames (Mike James)
  * Part of Release Dec_22_1999
  *
  * Revision 1.1  99/06/25  14:34:45  14:34:45  mjames (Mike James)
  * Initial revision
  *
  *  */
-#include "expression.h"
-#include "acf_yacc.h"
-#include "cmdlog.h"
-#include "cmdparse.h"
-#include "database.h"
-#include "generic.h"
-#include "vertcl_main.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include "vertcl_main.h"
+#include "expression.h"
+#include "generic.h"
+#include "database.h"
+#include "cmdparse.h"
+#include "cmdlog.h"
+#include "acf_yacc.h"
 /* place reference to a 'C' variable at the end of the tree branch */
-expression_t *compile_variable_reference (int *v, char *s)
+expression_t * compile_variable_reference(int *v,char * s ) {
-{
-        expression_t *p;
+  expression_t * p;
-        p = calloc (1, sizeof (expression_t));
+  p = calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = EXP_VAR_REF;
+    p->left.ip  = v;
+    p->right.s = s;
+    }
+  return p;
+  }
-        if (p)
-        {
-                p->opcode = EXP_VAR_REF;
-                p->left.ip = v;
-                p->right.s = s;
-        }
-        return p;
-}
-/* place an integer  constant at the end of the tree branch */
-expression_t *compile_constant (int k)
-{
-        expression_t *p;
-        p = calloc (1, sizeof (expression_t));
+/* place an integer  constant at the end of the tree branch */
+expression_t * compile_constant(int k ) {
-        if (p)
+  expression_t * p;
+  p = calloc(1,sizeof(expression_t));
-        {
+  if(p) {
-                p->opcode = EXP_CONSTANT;
+    p->opcode = EXP_CONSTANT;
-                p->left.i = k;
+    p->left.i  = k;
-                p->right.s = NULL;
+    p->right.s = NULL;
-        }
+    }
-        return p;
+  return p;
-}
+  }
 /* place a boolean constant at the end of the tree branch */
-expression_t *compile_boolean_constant (int k)
+expression_t * compile_boolean_constant(int k ) {
-{
-        expression_t *p;
+  expression_t * p;
-        p = calloc (1, sizeof (expression_t));
+  p = calloc(1,sizeof(expression_t));
-        if (p)
-        {
+  if(p) {
-                p->opcode = EXP_BOOLEAN;
+    p->opcode = EXP_BOOLEAN;
-                p->left.i = k;
+    p->left.i  = k;
-                p->right.s = NULL;
+    p->right.s = NULL;
-        }
+    }
-        return p;
+  return p;
-}
+  }
 /* this is where the user types some arbitrary string which is a numeric constant */
-expression_t *compile_constant_string (int k, char *s)
+expression_t * compile_constant_string(int k,char * s ) {
-{
-        expression_t *p;
+  expression_t * p;
-        p = calloc (1, sizeof (expression_t));
+  p = calloc(1,sizeof(expression_t));
-        if (p)
-        {
+  if(p) {
-                p->opcode = EXP_CONSTANT;
+    p->opcode = EXP_CONSTANT;
-                p->left.i = k;
+    p->left.i  = k;
-                p->right.s = ISNULLSTR (s) ? NULL : strdup (s);
+    p->right.s = ISNULLSTR(s)?NULL:strdup(s);
-        }
+    }
-        return p;
+  return p;
-}
+  }
 /* this is where the user types some arbitrary string which is a boolean constant */
-expression_t *compile_boolean_constant_string (int k, char *s)
+expression_t * compile_boolean_constant_string(int k,char * s ) {
+  expression_t * p;
+  p = calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = EXP_BOOLEAN;
+    p->left.i  = k;
+    p->right.s = ISNULLSTR(s)?NULL:strdup(s);
+    }
+  return p;
+  }
-{
+/* this compiles a reference to the variable */
+expression_t * compile_variable(generic_info_t * generic , char * valname) {
-        expression_t *p;
+  expression_t * p;
-        p = calloc (1, sizeof (expression_t));
+  p = calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode   = EXP_VARIABLE;
+    p->left.g   = generic;
+    p->right.s  = valname;
+    }
+  return p;
+  }
+expression_t * compile_string(char * s) {
+  expression_t * p;
+  p = (expression_t *)calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = EXP_STRING;
+    p->left.s = ISNULLSTR(s)?NULL:strdup(s);
+    }
+  return p;
+  }
+expression_t * compile_char(char c) {
+  expression_t * p;
+  p = (expression_t *)calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = EXP_CHAR;
+    p->left.i = c;
+    }
+  return p;
+  }
+expression_t * compile_reference(char * s) {
+  expression_t * p;
+  p = (expression_t *)calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = EXP_UNDEF_VAR;
+    p->right.s = ISNULLSTR(s)?NULL:strdup(s);
+    }
+  return p;
+  }
+expression_t * compile_expression(int opcode,
+       expression_t * l,
+       expression_t * r ) {
+  expression_t * p;
+  p = (expression_t *)calloc(1,sizeof(expression_t));
+  if(p) {
+    p->opcode = opcode;
+    p->left.e  = l;
+    p->right.e = r;
+    }
+  return p;
+  }
-        if (p)
-        {
-                p->opcode = EXP_BOOLEAN;
-                p->left.i = k;
-                p->right.s = ISNULLSTR (s) ? NULL : strdup (s);
-        }
-        return p;
-}
-/* this compiles a reference to the variable */
-expression_t *compile_variable (generic_info_t *generic, char *valname)
-{
-        expression_t *p;
-        p = calloc (1, sizeof (expression_t));
-        if (p)
-        {
-                p->opcode = EXP_VARIABLE;
-                p->left.g = generic;
-                p->right.s = valname;
-        }
-        return p;
-}
-expression_t *compile_string (char *s)
-{
-        expression_t *p;
-        p = (expression_t *) calloc (1, sizeof (expression_t));
-        if (p)
-        {
-                p->opcode = EXP_STRING;
-                p->left.s = ISNULLSTR (s) ? NULL : strdup (s);
-        }
-        return p;
-}
-expression_t *compile_char (char c)
-{
-        expression_t *p;
-        p = (expression_t *) calloc (1, sizeof (expression_t));
-        if (p)
+void print_expression(FILE * f,expression_t * e ,
-        {
+                      generic_print_style recurse_generics) {
-                p->opcode = EXP_CHAR;
+  if (!e) {
-                p->left.i = c;
+     fprintf(f,"(NULL)");
-        }
+     return;
-        return p;
+     }
-}
+  switch (e->opcode) {
+    case EXP_UNDEF_VAR :
-expression_t *compile_reference (char *s)
+      if (e->right.s)
-{
+        fprintf(f,"%s",e->right.s);
-        expression_t *p;
+      break;
-        p = (expression_t *) calloc (1, sizeof (expression_t));
+    case EXP_STRING :
+      if (e->left.s)
-        if (p)
+        fprintf(f,"\"%s\"",e->left.s);
-        {
+      break;
-                p->opcode = EXP_UNDEF_VAR;
+    case EXP_CHAR :
-                p->right.s = ISNULLSTR (s) ? NULL : strdup (s);
+        fprintf(f,"\'%c\'",e->left.i);
-        }
+      break;
-        return p;
+    case EXP_CONSTANT :
-}
+      if (e->right.s)
+        fprintf(f,"%s",e->right.s);
-expression_t *compile_expression (int opcode, expression_t *l, expression_t *r)
+      else
-{
+        fprintf(f,"%d",e->left.i);
-        expression_t *p;
+      break;
-        p = (expression_t *) calloc (1, sizeof (expression_t));
+    case EXP_VAR_REF :
-        if (p)
+/*      if (e->right.s)
-        {
+        fprintf(f,"%s",e->right.s);
-                p->opcode = opcode;
+      else */
-                p->left.e = l;
+        fprintf(f,"%d",*(e->left.ip));
-                p->right.e = r;
+      break;
-        }
+    case EXP_BOOLEAN :
-        return p;
+      if (e->right.s)
-}
+        fprintf(f,"%s",e->right.s);
+      else
-void print_expression (FILE *f, expression_t *e, generic_print_style recurse_generics)
+        fprintf(f,"%s",e->left.i?"true":"false");
-{
+      break;
-        if (!e)
+    case EXP_VARIABLE :
-        {
+      if (e->left.g) {
-                fprintf (f, "(NULL)");
+        if(recurse_generics!=NO_RECURSE &&
-                return;
+           e->left.g->expr  &&
-        }
+           (recurse_generics==RECURSE_NUMBER || e->left.g->expr->opcode != EXP_CONSTANT)) {
-        switch (e->opcode)
+          fprintf(f,"(");
-        {
+          print_expression(f, e->left.g->expr,recurse_generics);
-        case EXP_UNDEF_VAR:
+          fprintf(f,")");
-                if (e->right.s)
+          }
-                        fprintf (f, "%s", e->right.s);
+        else
-                break;
+          fprintf(f,"%s",e->right.s);
-        case EXP_STRING:
+        }
-                if (e->left.s)
+      else
-                        fprintf (f, "\"%s\"", e->left.s);
+        fprintf(f,"((%s))",e->right.s);
-                break;
-        case EXP_CHAR:
+      break;
-                fprintf (f, "\'%c\'", e->left.i);
+    case UMINUS:
-                break;
+      fprintf(f,"(-");
-        case EXP_CONSTANT:
+      if(e->left.e->opcode != EXP_CONSTANT)
-                if (e->right.s)
+         fprintf(f,"(");
-                        fprintf (f, "%s", e->right.s);
+      print_expression(f,e->left.e,recurse_generics);
-                else
+      if(e->left.e->opcode != EXP_CONSTANT)
-                        fprintf (f, "%d", e->left.i);
+         fprintf(f,")");
-                break;
+      fprintf(f,")");
-        case EXP_VAR_REF:
+      break;
-                /*      if (e->right.s)
+    case '~':
-                        fprintf(f,"%s",e->right.s);
+      fprintf(f,"(~");
-                      else */
+      if(e->left.e->opcode != EXP_CONSTANT)
-                fprintf (f, "%d", *(e->left.ip));
+         fprintf(f,"(");
-                break;
+      print_expression(f,e->left.e,recurse_generics);
-        case EXP_BOOLEAN:
+      if(e->left.e->opcode != EXP_CONSTANT)
-                if (e->right.s)
+         fprintf(f,")");
-                        fprintf (f, "%s", e->right.s);
+      fprintf(f,")");
-                else
+      break;
-                        fprintf (f, "%s", e->left.i ? "true" : "false");
+    case '!':
-                break;
+      fprintf(f,"(!");
-        case EXP_VARIABLE:
+      if(e->left.e->opcode != EXP_CONSTANT)
-                if (e->left.g)
+         fprintf(f,"(");
-                {
+      print_expression(f,e->left.e,recurse_generics);
-                        if (recurse_generics != NO_RECURSE && e->left.g->expr &&
+      if(e->left.e->opcode != EXP_CONSTANT)
-                            (recurse_generics == RECURSE_NUMBER ||
+         fprintf(f,")");
-                             e->left.g->expr->opcode != EXP_CONSTANT))
+      fprintf(f,")");
-                        {
+      break;
-                                fprintf (f, "(");
+    case '(' :
-                                print_expression (f, e->left.g->expr, recurse_generics);
+      fprintf(f,"(");
-                                fprintf (f, ")");
+      print_expression(f,e->left.e,recurse_generics);
-                        }
+      fprintf(f,")");
-                        else
+      break;
-                                fprintf (f, "%s", e->right.s);
+    case '+' :
-                }
+    case '-' :
-                else
+    case '*' :
-                        fprintf (f, "((%s))", e->right.s);
+    case '/' :
+    case '%' :
-                break;
+    case '^' :
-        case UMINUS:
+    case '?' :
-                fprintf (f, "(-");
+    case ':' :
-                if (e->left.e->opcode != EXP_CONSTANT)
+    case '>' :
-                        fprintf (f, "(");
+    case '<' :
-                print_expression (f, e->left.e, recurse_generics);
+    case '&' :
-                if (e->left.e->opcode != EXP_CONSTANT)
+    case '|' :
-                        fprintf (f, ")");
-                fprintf (f, ")");
+      print_expression(f,e->left.e,recurse_generics);
-                break;
+      fprintf(f,"%c",e->opcode);
-        case '~':
+      print_expression(f,e->right.e,recurse_generics);
-                fprintf (f, "(~");
-                if (e->left.e->opcode != EXP_CONSTANT)
+      break;
-                        fprintf (f, "(");
+    case SHL :
-                print_expression (f, e->left.e, recurse_generics);
+      print_expression(f,e->left.e,recurse_generics);
-                if (e->left.e->opcode != EXP_CONSTANT)
+      fprintf(f,"<<");
-                        fprintf (f, ")");
+      print_expression(f,e->right.e,recurse_generics);
-                fprintf (f, ")");
+      break;
-                break;
+    case SHR :
-        case '!':
+      print_expression(f,e->left.e,recurse_generics);
-                fprintf (f, "(!");
+      fprintf(f,">>");
-                if (e->left.e->opcode != EXP_CONSTANT)
+      print_expression(f,e->right.e,recurse_generics);
-                        fprintf (f, "(");
+      break;
-                print_expression (f, e->left.e, recurse_generics);
+    case EQ_EQ :
-                if (e->left.e->opcode != EXP_CONSTANT)
+      print_expression(f,e->left.e,recurse_generics);
-                        fprintf (f, ")");
+      fprintf(f,"==");
-                fprintf (f, ")");
+      print_expression(f,e->right.e,recurse_generics);
-                break;
+      break;
-        case '(':
+    case N_EQ :
-                fprintf (f, "(");
+      print_expression(f,e->left.e,recurse_generics);
-                print_expression (f, e->left.e, recurse_generics);
+      fprintf(f,"!=");
-                fprintf (f, ")");
+      print_expression(f,e->right.e,recurse_generics);
-                break;
+      break;
-        case '+':
+    case LOG_AND :
-        case '-':
+      print_expression(f,e->left.e,recurse_generics);
-        case '*':
+      fprintf(f,"&&");
-        case '/':
+      print_expression(f,e->right.e,recurse_generics);
-        case '%':
+      break;
-        case '^':
+    case LOG_OR :
-        case '?':
+      print_expression(f,e->left.e,recurse_generics);
-        case ':':
+      fprintf(f,"||");
-        case '>':
+      print_expression(f,e->right.e,recurse_generics);
-        case '<':
+      break;
-        case '&':
+    case TO_POW :
-        case '|':
+      print_expression(f,e->left.e,recurse_generics);
+      fprintf(f,"**");
-                print_expression (f, e->left.e, recurse_generics);
+      print_expression(f,e->right.e,recurse_generics);
-                fprintf (f, "%c", e->opcode);
+      break;
-                print_expression (f, e->right.e, recurse_generics);
+    default :
+      fprintf(f,"(?? expression ERROR : OPCODE 0x%X)",e->opcode);
-                break;
-        case SHL:
+      }
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "<<");
+  }
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case SHR:
-                print_expression (f, e->left.e, recurse_generics);
+/* a range is permitted at the top level of an expression */
-                fprintf (f, ">>");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case EQ_EQ:
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "==");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case N_EQ:
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "!=");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case LOG_AND:
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "&&");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case LOG_OR:
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "||");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        case TO_POW:
-                print_expression (f, e->left.e, recurse_generics);
-                fprintf (f, "**");
-                print_expression (f, e->right.e, recurse_generics);
-                break;
-        default:
-                fprintf (f, "(?? expression ERROR : OPCODE 0x%X)", e->opcode);
-        }
-}
-/* a range is permitted at the top level of an expression */
 /* if there is no expression return */
-void print_range_expression (FILE *f, expression_t *e, generic_print_style recurse_generics)
+void print_range_expression(FILE * f, expression_t * e,generic_print_style recurse_generics) {
-{
+  if (!e) return;
-        if (!e)
+  switch (e->opcode) {
-                return;
+    case TO :
-        switch (e->opcode)
+      fprintf(f,"(");
-        {
+      print_expression(f,e->left.e,recurse_generics);
-        case TO:
+      fprintf(f," TO ");
-                fprintf (f, "(");
+      print_expression(f,e->right.e,recurse_generics);
-                print_expression (f, e->left.e, recurse_generics);
+      fprintf(f,")");
-                fprintf (f, " TO ");
+    break;
-                print_expression (f, e->right.e, recurse_generics);
-                fprintf (f, ")");
+    case DOWNTO :
-                break;
+      fprintf(f,"(");
+      print_expression(f,e->left.e,recurse_generics);
-        case DOWNTO:
+      fprintf(f," DOWNTO ");
-                fprintf (f, "(");
+      print_expression(f,e->right.e,recurse_generics);
-                print_expression (f, e->left.e, recurse_generics);
+      fprintf(f,")");
-                fprintf (f, " DOWNTO ");
+    break;
-                print_expression (f, e->right.e, recurse_generics);
-                fprintf (f, ")");
+    case EXP_VARIABLE :
-                break;
+      if (e->left.g) {
+        if(recurse_generics != NO_RECURSE)
-        case EXP_VARIABLE:
+          print_range_expression(f, e->left.g->expr,recurse_generics);
-                if (e->left.g)
+        else
-                {
+          fprintf(f,"(%s)",e->right.s);
-                        if (recurse_generics != NO_RECURSE)
+        }
-                                print_range_expression (f, e->left.g->expr, recurse_generics);
+      else
-                        else
+        fprintf(f,"((??%s))",e->right.s);
-                                fprintf (f, "(%s)", e->right.s);
-                }
+      break;
-                else
-                        fprintf (f, "((??%s))", e->right.s);
-                break;
+    default :
+      /* handle the expressions down each level of the hierarchy */
-        default:
+/*      fprintf(f,"("); */
-                /* handle the expressions down each level of the hierarchy */
+      print_expression(f,e,recurse_generics);
-                /*      fprintf(f,"("); */
+/*      fprintf(f,")"); */
-                print_expression (f, e, recurse_generics);
+    }
-                /*      fprintf(f,")"); */
+  }
-        }
-}
-void print_msg_expression (FILE *f, char *s, expression_t *e)
+void print_msg_expression(FILE * f,char * s, expression_t *e) {
-{
+  fprintf(f,"%s '",s);
-        fprintf (f, "%s '", s);
+  print_range_expression(f,e,NO_RECURSE);
-        print_range_expression (f, e, NO_RECURSE);
+  fprintf(f,"'\n");
-        fprintf (f, "'\n");
+  }
-}
-/* evaluate an integer expression : checking local generics if they are available  */
-int eval_expression (expression_t *e, generic_info_t **chip_generics)
+/* evaluate an integer expression : checking local generics if they are available  */
-{
+int eval_expression(expression_t * e,generic_info_t ** chip_generics ) {
-        int r = 0;
+  int r = 0;
-        if (!e)
+  if (!e) return 0;
-                return 0;
+  switch (e->opcode) {
-        switch (e->opcode)
+    case EXP_CONSTANT :
-        {
+    case EXP_BOOLEAN:
-        case EXP_CONSTANT:
+      r = e->left.i;
-        case EXP_BOOLEAN:
+      break;
-                r = e->left.i;
+    case EXP_VAR_REF :
-                break;
+      r = *(e->left.ip);
-        case EXP_VAR_REF:
+      break;
-                r = *(e->left.ip);
+    /* when evaluating expression, if a generic in scope is found then the
-                break;
+       generic will be updated : ends up creating and cross-linking a
-        /* when evaluating expression, if a generic in scope is found then the
+       partition generic */
-           generic will be updated : ends up creating and cross-linking a
+    case EXP_UNDEF_VAR :
-           partition generic */
+      {
-        case EXP_UNDEF_VAR:
+      generic_info_t * gen;
-        {
+      gen = NULL;
-                generic_info_t *gen;
+      if (chip_generics)
-                gen = NULL;
+        {
-                if (chip_generics)
+        gen = get_generic_ref(chip_generics,e->right.s);
-                {
+        }
-                        gen = get_generic_ref (chip_generics, e->right.s);
+        /* search outwards */
-                }
+      if (!gen)
-                /* search outwards */
+        {
-                if (!gen)
+        gen = get_generic_ref(&global_generics,e->right.s);
-                {
+        }
-                        gen = get_generic_ref (&global_generics, e->right.s);
+      if (!gen)
-                }
+        {/* scope is external not local */
-                if (!gen)
+        expr_ref_t * link;
-                { /* scope is external not local */
+        gen = get_generic_ref(&partition_generics,e->right.s);
-                        expr_ref_t *link;
+        /* if no partition generic appears, make one */
-                        gen = get_generic_ref (&partition_generics, e->right.s);
+        if(!gen)
-                        /* if no partition generic appears, make one */
+          {
-                        if (!gen)
+          generic_info_t newgen;
-                        {
+          newgen.typename  = "integer";
-                                generic_info_t newgen;
+          newgen.name = e->right.s;
-                                newgen.typename = "integer";
-                                newgen.name = e->right.s;
+          newgen.valid     = 1;
+          newgen.expr      = compile_constant(0);
-                                newgen.valid = 1;
+          newgen.g_type    = IS_INTEGER;
-                                newgen.expr = compile_constant (0);
+          newgen.g_class   = DEFINED;
-                                newgen.g_type = IS_INTEGER;
-                                newgen.g_class = DEFINED;
+          gen = set_generic_value(&partition_generics, &newgen);
+          }
-                                gen = set_generic_value (&partition_generics, &newgen);
+        if(gen)
-                        }
+          {
-                        if (gen)
+          link = calloc(1,sizeof(expr_ref_t));
-                        {
+          }
-                                link = calloc (1, sizeof (expr_ref_t));
+        if(gen && link)
-                        }
+          {
-                        if (gen && link)
+          link -> expr_ref = gen -> expr_ref;
-                        {
+          gen  -> expr_ref = link;
-                                link->expr_ref = gen->expr_ref;
+          link -> expr     = e;
-                                gen->expr_ref = link;
+          }
-                                link->expr = e;
+        }
-                        }
+      if(gen)
-                }
+        {
-                if (gen)
+        e->opcode = EXP_VARIABLE;
-                {
+        e->left.g = gen;
-                        e->opcode = EXP_VARIABLE;
+/* having located a valid generic then try to link it up */
-                        e->left.g = gen;
-                        /* having located a valid generic then try to link it up */
+/* duplicate code borrowed from below. Avoiding 'goto' !! */
-                        /* duplicate code borrowed from below. Avoiding 'goto' !! */
+        eval_gen_expression(gen);
-                        eval_gen_expression (gen);
+        if( gen->g_type==IS_ATTRIBUTE || gen->g_type==IS_INTEGER) {
-                        if (gen->g_type == IS_ATTRIBUTE || gen->g_type == IS_INTEGER)
+          r = eval_expression(gen->expr,chip_generics);
-                        {
-                                r = eval_expression (gen->expr, chip_generics);
 #if defined DEBUG_EXPRESSION
-                                printf ("eval %s = %d\n", gen->name, r);
+          printf("eval %s = %d\n",gen->name,r);
 #endif
-                        }
+          }
-                        else
-                        {
+        else {
-                                Log (
-                                    LOG_ERROR,
-                                    "#Error : generic %s has non integer type (code %d)\n",
+          Log(LOG_ERROR,"#Error : generic %s has non integer type (code %d)\n",gen->name,gen->g_type);
-                                    gen->name,
-                                    gen->g_type);
-                                r = 0;
+          r= 0;
-                        }
+          }
-                }
+        }
-                else
+      else
-                {
+        {
-                        Log (LOG_ERROR, "# symbol '%s' is not defined\n", e->right.s);
+        Log(LOG_ERROR,"# symbol '%s' is not defined\n",e->right.s);
-                }
+        }
-        }
+      }
-        break;
+      break;
-        case EXP_VARIABLE:
+    case EXP_VARIABLE :
-        {
+      {
-                generic_info_t *gen;
+      generic_info_t * gen;
-                gen = e->left.g;
+      gen = e->left.g;
-                if (gen)
-                {
+      if (gen) {
-                        eval_gen_expression (gen);
+        eval_gen_expression(gen);
-                        if (gen->g_type == IS_ATTRIBUTE || gen->g_type == IS_INTEGER)
+        if( gen->g_type==IS_ATTRIBUTE || gen->g_type==IS_INTEGER) {
-                        {
-                                r = eval_expression (gen->expr, chip_generics);
+          r = eval_expression(gen->expr,chip_generics);
 #if defined DEBUG_EXPRESSION
-                                printf ("eval %s = %d\n", gen->name, r);
+          printf("eval %s = %d\n",gen->name,r);
 #endif
-                        }
+          }
-                        else
+        else {
-                        {
+          Log(LOG_ERROR,"#Error : generic %s has non integer type (code %d)\n",gen->name,gen->g_type);
-                                Log (
+          r= 0;
-                                    LOG_ERROR,
+          }
-                                    "#Error : generic %s has non integer type (code %d)\n",
+        }
-                                    gen->name,
-                                    gen->g_type);
+      else
-                                r = 0;
+         Log(LOG_ERROR,"#Error : generic '%s' not found\n",e->right.s);
-                        }
+      }
-                }
+      break;
+    case EXP_CHAR   :
-                else
+      r= e->left.i;
-                        Log (LOG_ERROR, "#Error : generic '%s' not found\n", e->right.s);
+      break;
-        }
+    case EXP_STRING :
-        break;
+      r= 0;
-        case EXP_CHAR:
+      break;
-                r = e->left.i;
+    case '(' :
-                break;
+      r= eval_expression(e->left.e,chip_generics);
-        case EXP_STRING:
+      break;
-                r = 0;
+    case UMINUS :
-                break;
+      r= 0-eval_expression(e->left.e,chip_generics);
-        case '(':
+      break;
-                r = eval_expression (e->left.e, chip_generics);
+    case '~' :
-                break;
+      r= ~eval_expression(e->left.e,chip_generics);
-        case UMINUS:
+      break;
-                r = 0 - eval_expression (e->left.e, chip_generics);
+    case '!' :
-                break;
+      r= !eval_expression(e->left.e,chip_generics);
-        case '~':
+      break;
-                r = ~eval_expression (e->left.e, chip_generics);
+    case '+' :
-                break;
+      r= eval_expression(e->left.e,chip_generics)+eval_expression(e->right.e,chip_generics);
-        case '!':
+      break;
-                r = !eval_expression (e->left.e, chip_generics);
+    case '-' :
-                break;
+      r= eval_expression(e->left.e,chip_generics)-eval_expression(e->right.e,chip_generics);
-        case '+':
+      break;
-                r = eval_expression (e->left.e, chip_generics) +
+     case '*' :
-                    eval_expression (e->right.e, chip_generics);
+      r= eval_expression(e->left.e,chip_generics)*eval_expression(e->right.e,chip_generics);
-                break;
+      break;
-        case '-':
+     case '/' :
-                r = eval_expression (e->left.e, chip_generics) -
+      {
-                    eval_expression (e->right.e, chip_generics);
+      int rhs;
-                break;
+      rhs = eval_expression(e->right.e,chip_generics);
-        case '*':
+      if(rhs)
-                r = eval_expression (e->left.e, chip_generics) *
+        {
-                    eval_expression (e->right.e, chip_generics);
+        r= eval_expression(e->left.e,chip_generics)/rhs;
-                break;
+        }
-        case '/':
+      else
         {
-                int rhs;
+        Log(LOG_ERROR,"# ERROR: Division by 0\n");
-                rhs = eval_expression (e->right.e, chip_generics);
+        r=0;
-                if (rhs)
+        };
-                {
+      }
-                        r = eval_expression (e->left.e, chip_generics) / rhs;
+      break;
-                }
+     case '%' :
-                else
+      {
-                {
+      int rhs;
-                        Log (LOG_ERROR, "# ERROR: Division by 0\n");
+      rhs = eval_expression(e->right.e,chip_generics);
-                        r = 0;
+      if(rhs)
-                };
+        {
-        }
+        r= eval_expression(e->left.e,chip_generics)%rhs;
-        break;
+        }
-        case '%':
+      else
         {
-                int rhs;
+        Log(LOG_ERROR,"# ERROR: Modulus by 0\n");
-                rhs = eval_expression (e->right.e, chip_generics);
+        r=0;
-                if (rhs)
+        };
-                {
+      }
-                        r = eval_expression (e->left.e, chip_generics) % rhs;
+      break;
-                }
+     case '^' :
-                else
+      r= eval_expression(e->left.e,chip_generics)^eval_expression(e->right.e,chip_generics);
-                {
+      break;
-                        Log (LOG_ERROR, "# ERROR: Modulus by 0\n");
+     case '|' :
-                        r = 0;
+      r= eval_expression(e->left.e,chip_generics)|eval_expression(e->right.e,chip_generics);
-                };
+      break;
-        }
+     case '&' :
-        break;
+      r= eval_expression(e->left.e,chip_generics)&eval_expression(e->right.e,chip_generics);
-        case '^':
+      break;
-                r = eval_expression (e->left.e, chip_generics) ^
+     case '>' :
-                    eval_expression (e->right.e, chip_generics);
+      r= eval_expression(e->left.e,chip_generics)>eval_expression(e->right.e,chip_generics);
-                break;
+      break;
-        case '|':
+     case '<' :
-                r = eval_expression (e->left.e, chip_generics) |
+      r= eval_expression(e->left.e,chip_generics)<eval_expression(e->right.e,chip_generics);
-                    eval_expression (e->right.e, chip_generics);
+      break;
-                break;
+     case EQ_EQ :
-        case '&':
+      r= eval_expression(e->left.e,chip_generics)==eval_expression(e->right.e,chip_generics);
-                r = eval_expression (e->left.e, chip_generics) &
+      break;
-                    eval_expression (e->right.e, chip_generics);
+     case N_EQ:
-                break;
+      r= eval_expression(e->left.e,chip_generics)!=eval_expression(e->right.e,chip_generics);
-        case '>':
+      break;
-                r = eval_expression (e->left.e, chip_generics) >
+     case LOG_OR:
-                    eval_expression (e->right.e, chip_generics);
+      r= eval_expression(e->left.e,chip_generics)||eval_expression(e->right.e,chip_generics);
-                break;
+      break;
-        case '<':
+     case LOG_AND:
-                r = eval_expression (e->left.e, chip_generics) <
+      r= eval_expression(e->left.e,chip_generics)&&eval_expression(e->right.e,chip_generics);
-                    eval_expression (e->right.e, chip_generics);
+      break;
-                break;
+     case SHL :
-        case EQ_EQ:
+      r= eval_expression(e->left.e,chip_generics)<<eval_expression(e->right.e,chip_generics);
-                r = eval_expression (e->left.e, chip_generics) ==
+      break;
-                    eval_expression (e->right.e, chip_generics);
+     case SHR :
-                break;
+      r= eval_expression(e->left.e,chip_generics)>>eval_expression(e->right.e,chip_generics);
-        case N_EQ:
+      break;
-                r = eval_expression (e->left.e, chip_generics) !=
+     case '?' :
-                    eval_expression (e->right.e, chip_generics);
+      r= eval_expression(e->left.e,chip_generics) ? eval_expression(e->right.e->left.e,chip_generics) :
-                break;
+                                                    eval_expression(e->right.e->right.e,chip_generics) ;
-        case LOG_OR:
+      break;
-                r = eval_expression (e->left.e, chip_generics) ||
+     case TO_POW : {
-                    eval_expression (e->right.e, chip_generics);
+       int i,y,x;
-                break;
+       x = eval_expression(e->left.e,chip_generics);
-        case LOG_AND:
+       y = eval_expression(e->right.e,chip_generics);
-                r = eval_expression (e->left.e, chip_generics) &&
+       if (y==0)  /* x**0 = 1 */
-                    eval_expression (e->right.e, chip_generics);
+         r=1;
-                break;
+       else if (y<0 ) /* negative powers */
-        case SHL:
+         r=0;
-                r = eval_expression (e->left.e, chip_generics)
+       else {
-                    << eval_expression (e->right.e, chip_generics);
+         i = y; /* limit power */
-                break;
+         if (i > 32) {
-        case SHR:
+           Log(LOG_ERROR,"arithmetic power of: %d ** %d : %d > 32: limited to 32\n",x,y,y);
-                r = eval_expression (e->left.e, chip_generics) >>
+           i = 32; }
-                    eval_expression (e->right.e, chip_generics);
+         r = x;
-                break;
+         while(--i)
-        case '?':
+           r *= x;
-                r = eval_expression (e->left.e, chip_generics)
+         }
-                        ? eval_expression (e->right.e->left.e, chip_generics)
+       }
-                        : eval_expression (e->right.e->right.e, chip_generics);
+    break;
-                break;
+     default :
-        case TO_POW:
+       Log(LOG_ERROR,"#Error : expression : illegal operator (%d)\n",e->opcode);
-        {
+      }
-                int i, y, x;
+/*  printf("(%d)",r); */
-                x = eval_expression (e->left.e, chip_generics);
+   return r;
-                y = eval_expression (e->right.e, chip_generics);
+  }
-                if (y == 0) /* x**0 = 1 */
-                        r = 1;
-                else if (y < 0) /* negative powers */
-                        r = 0;
+int eval_vhdl_expression(expression_t * expr,
-                else
+                         int * high,
-                {
+                         int * low ) {
-                        i = y; /* limit power */
+  int rc;
-                        if (i > 32)
-                        {
+  generic_info_t ** chip_generics = NULL; /* no local search scope, order of declaration should ensure that
-                                Log (
+                                           generics are defined before use */
-                                    LOG_ERROR,
-                                    "arithmetic power of: %d ** %d : %d > 32: limited to 32\n",
+  if (!expr) return 0;
-                                    x,
+/* my be range at top level in variable */
-                                    y,
+  if(expr->opcode == EXP_VARIABLE)
-                                    y);
+    expr = expr->left.g->expr;
-                                i = 32;
-                        }
+  if (!expr) return 0;
-                        r = x;
-                        while (--i)
+  switch (expr->opcode) {
-                                r *= x;
-                }
-        }
-        break;
+    case TO:
-        default:
+      *high = eval_expression(expr->left.e,chip_generics);
-                Log (LOG_ERROR, "#Error : expression : illegal operator (%d)\n", e->opcode);
+      *low  = eval_expression(expr->right.e,chip_generics);
-        }
+      rc = TO;
-        /*  printf("(%d)",r); */
+    break;
-        return r;
-}
+    case DOWNTO:
+      *high = eval_expression(expr->left.e,chip_generics);
-int eval_vhdl_expression (expression_t *expr, int *high, int *low)
+      *low  = eval_expression(expr->right.e,chip_generics);
-{
+      rc = DOWNTO;
-        int rc;
+    break;
-        generic_info_t **chip_generics =
-            NULL; /* no local search scope, order of declaration should ensure that
+    default:
-                   generics are defined before use */
+      /* handle the expressions down each level of the hierarchy */
+      *high = eval_expression(expr,chip_generics);
-        if (!expr)
+      *low  = *high;
-                return 0;
+      rc = IS_INTEGER;
-        /* my be range at top level in variable */
+    break;
-        if (expr->opcode == EXP_VARIABLE)
+    }
-                expr = expr->left.g->expr;
-        if (!expr)
-                return 0;
-        switch (expr->opcode)
-        {
-        case TO:
-                *high = eval_expression (expr->left.e, chip_generics);
-                *low = eval_expression (expr->right.e, chip_generics);
-                rc = TO;
-                break;
-        case DOWNTO:
-                *high = eval_expression (expr->left.e, chip_generics);
-                *low = eval_expression (expr->right.e, chip_generics);
-                rc = DOWNTO;
-                break;
-        default:
-                /* handle the expressions down each level of the hierarchy */
-                *high = eval_expression (expr, chip_generics);
-                *low = *high;
-                rc = IS_INTEGER;
-                break;
-        }
 #if defined DEBUG_EXPRESSION
-        print_msg_expression (stdout, "eval vhdl ", expr);
+  print_msg_expression(stdout,"eval vhdl ",expr);
-        printf ("high %d low %d rc %d\n", *high, *low, rc);
+  printf("high %d low %d rc %d\n",
+      *high,*low,
+      rc );
 #endif
-        return rc;
+  return rc;
+  }
-}
-int eval_gen_expression (generic_info_t *gen)
+int eval_gen_expression(
-{
+       generic_info_t * gen) {
 #if defined NEED_EVAL_GEN
-        expression_t *exp;
+  expression_t * exp;
-        if (gen)
+  if (gen) {
-        {
-                exp = gen->expr;
+    exp = gen->expr;
-                /*    printf("Ptr %p: ",exp); */
+/*    printf("Ptr %p: ",exp); */
-                if (exp)
-                {
+    if (exp) {
-                        switch (exp->opcode)
+      switch (exp->opcode) {
-                        {
-                        case EXP_STRING:
+        case EXP_STRING :
-                                gen->valuename = exp->left.s;
+          gen->valuename = exp->left.s;
-                                gen->g_type = IS_STRING;
+          gen->g_type    = IS_STRING;
-                                gen->valid = 1;
+          gen->valid     = 1;
-                                break;
+          break;
-                        case TO:
+        case TO :
-                                gen->valid = 1;
+          gen->valid = 1;
-                                gen->g_type = TO;
+          gen->g_type = TO;
-                                break;
+          break;
-                        case DOWNTO:
+        case DOWNTO :
-                                gen->valid = 1;
+          gen->valid = 1;
-                                gen->g_type = DOWNTO;
+          gen->g_type = DOWNTO;
-                                break;
+        break;
-                        default:
+        default :
-                                /* handle the expressions down each level of the hierarchy */
+      /* handle the expressions down each level of the hierarchy */
-                                gen->valid = 1;
+          gen->valid = 1;
-                                gen->g_type = IS_INTEGER;
+          gen->g_type = IS_INTEGER;
-                        }
+        }
-                        gen->g_class = DEFINED;
+      gen->g_class = DEFINED;
-                        return gen->g_type;
+      return gen->g_type;
-                }
+      }
-        }
+    }
-        return NO_VALUE;
+  return NO_VALUE;
 #else
-        return gen->g_type;
+  return gen->g_type;
 #endif
-}
+  }
 /* delete any expression pointed to */
-void free_expression (expression_t *ptr)
+void free_expression(expression_t * ptr) {
-{
-        if (!ptr)
+  if (!ptr)
-                return;
+    return;
-        switch (ptr->opcode)
+  switch(ptr->opcode) {
-        {
-        case EXP_STRING:
+    case EXP_STRING:
-                if (ptr->left.s)
+      if(ptr->left.s)
-                        free (ptr->left.s);
+        free(ptr->left.s);
-        case EXP_CONSTANT:
+    case EXP_CONSTANT:
-        case EXP_BOOLEAN:
+    case EXP_BOOLEAN:
-        case EXP_VARIABLE:
+    case EXP_VARIABLE:
-        case EXP_VAR_REF:
+    case EXP_VAR_REF:
-                if (ptr->right.s)
+      if(ptr->right.s)
-                        free (ptr->right.s); /* remove string */
+        free(ptr->right.s); /* remove string */
-                break;
+      break;
-        default:
+    default:
-                if (ptr->left.e)
+      if (ptr->left.e)
-                        free_expression (ptr->left.e);
+        free_expression(ptr->left.e);
-                if (ptr->right.e)
+      if (ptr->right.e)
-                        free_expression (ptr->right.e);
+        free_expression(ptr->right.e);
-                break;
+      break;
-        }
+    }
-        free (ptr);
+  free(ptr);
-}
+  }
 /* copy the expression, fixing up the references to local generic constants
    at the same time . Need to */
-expression_t *copy_expression (expression_t *ptr, socket_t *skt)
+expression_t * copy_expression(expression_t * ptr,socket_t * skt) {
-{
-        expression_t *copy;
+  expression_t * copy;
-        if (!ptr)
+  if(!ptr)
-                return NULL;
+    return NULL;
-        switch (ptr->opcode)
+  switch(ptr->opcode) {
-        {
-        case EXP_CONSTANT:
+    case EXP_CONSTANT :
-        case EXP_BOOLEAN:
+    case EXP_BOOLEAN :
-        case EXP_STRING:
+    case EXP_STRING :
-        case EXP_VAR_REF:
+    case EXP_VAR_REF:
-        case EXP_VARIABLE:
+    case EXP_VARIABLE:
-        case EXP_CHAR:
+    case EXP_CHAR:
-                return ptr; /* no copy needed as this is a terminal node that cannot change */
+      return ptr;  /* no copy needed as this is a terminal node that cannot change */
-                break;
+      break;
-                /* duplicate undefined references so each induvidual expression is fixed up */
+/* duplicate undefined references so each induvidual expression is fixed up */
-        case EXP_UNDEF_VAR:
+    case EXP_UNDEF_VAR:
-                copy = calloc (1, sizeof (expression_t));
+        copy = calloc(1,sizeof(expression_t));
-                *copy = *ptr;
+        *copy = *ptr;
-                return copy;
+      return copy;
-                break;
+      break;
-        default:
+    default:
-                return compile_expression (
+      return compile_expression(ptr->opcode,
-                    ptr->opcode,
-                    copy_expression (ptr->left.e, skt),
+        copy_expression(ptr->left.e,skt),
-                    copy_expression (ptr->right.e, skt));
+        copy_expression(ptr->right.e,skt));
-                break;
+      break;
-        }
+      }
-        return NULL;
+    return NULL;
+    }
-}
-struct vhdl *copy_vhdl (vhdl_t *vhdl, socket_t *skt)
+struct vhdl * copy_vhdl(vhdl_t * vhdl,socket_t * skt) {
-{
-        vhdl_t *new_vhdl;
+  vhdl_t * new_vhdl;
-        if (!vhdl)
+  if(!vhdl)
-                return NULL;
+    return NULL;
-        new_vhdl = calloc (1, sizeof (vhdl_t));
+  new_vhdl = calloc(1,sizeof(vhdl_t));
-        *new_vhdl = *vhdl;
+  *new_vhdl = *vhdl;
-        new_vhdl->expr = copy_expression (vhdl->expr, skt);
+  new_vhdl->expr = copy_expression(vhdl->expr,skt);
-        new_vhdl->default_expr = copy_expression (vhdl->default_expr, skt);
+  new_vhdl->default_expr = copy_expression(vhdl->default_expr,skt);
 #if defined DEBUG_EXPRESSION
-        printf ("Type = %s\n", vhdl->basetype);
+  printf("Type = %s\n",vhdl->basetype);
-        print_msg_expression (stdout, "Copied expr", new_vhdl->expr);
+  print_msg_expression(stdout,"Copied expr",new_vhdl->expr);
-        print_msg_expression (stdout, "Copied default", new_vhdl->default_expr);
+  print_msg_expression(stdout,"Copied default",new_vhdl->default_expr);
 #endif
-        return new_vhdl;
+  return new_vhdl;
+  }
-}

Subversion Repositories Vertical

(root)/branches/metal/vertlib/expression.c – Rev 2 → 11