1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #ifndef _FB_VARS_H
  27 #define _FB_VARS_H
  28 
  29 #include "config.h"
  30 
  31 #include <stdio.h>
  32 #include <sys/types.h>
  33 #ifdef HAVE_STDINT_H
  34 #include <stdint.h>
  35 #endif
  36 
  37 #ifdef  __cplusplus
  38 extern "C" {
  39 #endif
  40 
  41 /* Attribute Value Descriptor types */
  42 typedef enum avd_type {
  43         AVD_INVALID = 0,        /* avd is empty */
  44         AVD_VAL_BOOL,           /* avd contains a boolean_t */
  45         AVD_VARVAL_BOOL,        /* avd points to the boolean_t in a var_t */
  46         AVD_VAL_INT,            /* avd contains an fbint_t */
  47         AVD_VARVAL_INT,         /* avd points to the fbint_t in a var_t */
  48         AVD_VAL_STR,            /* avd contains a sting (*char) */
  49         AVD_VARVAL_STR,         /* avd points to a string in a var_t */
  50         AVD_VAL_DBL,            /* avd contains a double float */
  51         AVD_VARVAL_DBL,         /* avd points to the double in a var_t */
  52         AVD_IND_VAR,            /* avd points a var_t */
  53         AVD_IND_RANDVAR         /* avd points to the randdist_t associated */
  54                                 /* with a random type var_t */
  55 } avd_type_t;
  56 
  57 typedef uint64_t fbint_t;
  58 
  59 /* Attribute Value Descriptor */
  60 typedef struct avd {
  61         avd_type_t  avd_type;
  62         union {
  63                 boolean_t       boolval;
  64                 boolean_t       *boolptr;
  65                 fbint_t         intval;
  66                 fbint_t         *intptr;
  67                 double          dblval;
  68                 double          *dblptr;
  69                 char            *strval;
  70                 char            **strptr;
  71                 struct randdist *randptr;
  72                 struct var      *varptr;
  73         } avd_val;
  74 } *avd_t;
  75 
  76 #define AVD_IS_RANDOM(vp)       ((vp) && ((vp)->avd_type == AVD_IND_RANDVAR))
  77 #define AVD_IS_STRING(vp)       ((vp) && (((vp)->avd_type == AVD_VAL_STR) || \
  78                                 ((vp)->avd_type == AVD_VARVAL_STR)))
  79 #define AVD_IS_VAR(vp)          ((vp) && (((vp)->avd_type == AVD_IND_VAR) || \
  80                                 ((vp)->avd_type == AVD_VARVAL_INT) || \
  81                                 ((vp)->avd_type == AVD_VARVAL_DBL)))
  82 
  83 typedef struct var {
  84         char            *var_name;
  85         int             var_type;
  86         struct var      *var_next;
  87         union {
  88                 boolean_t       boolean;
  89                 fbint_t         integer;
  90                 double          dbl_flt;
  91                 char            *string;
  92                 struct randdist *randptr;
  93                 struct var      *varptr2;
  94         } var_val;
  95         struct var      *var_varptr1;
  96 } var_t;
  97 
  98 /* basic var types */
  99 #define VAR_TYPE_GLOBAL         0x0000  /* global variable */
 100 #define VAR_TYPE_DYNAMIC        0x1000  /* Dynamic variable */
 101 #define VAR_TYPE_RANDOM         0x2000  /* random variable */
 102 #define VAR_TYPE_LOCAL          0x3000  /* Local variable */
 103 #define VAR_TYPE_MASK           0xf000
 104 
 105 /* various var subtypes that a var can be set to */
 106 #define VAR_TYPE_BOOL_SET       0x0100  /* var contains a boolean */
 107 #define VAR_TYPE_INT_SET        0x0200  /* var contains an integer */
 108 #define VAR_TYPE_STR_SET        0x0300  /* var contains a string */
 109 #define VAR_TYPE_DBL_SET        0x0400  /* var contains a double */
 110 #define VAR_TYPE_RAND_SET       0x0500  /* var contains a randdist pointer */
 111 #define VAR_TYPE_INDVAR_SET     0x0700  /* var points to another variable(s) */
 112 #define VAR_TYPE_SET_MASK       0x0f00
 113 
 114 /* indirection to another variable or variables with binary op */
 115 #define VAR_IND_ASSIGN          0x0000  /* just assignment to another var */
 116 #define VAR_IND_BINOP_INT       0x0010  /* binary op with an integer */
 117 #define VAR_IND_BINOP_DBL       0x0020  /* binary op with a double float */
 118 #define VAR_IND_BINOP_VAR       0x0030  /* binary op with another var */
 119 #define VAR_INDBINOP_MASK       0x00f0
 120 
 121 
 122 #define VAR_IND_VAR_SUM_VC      0x0001  /* var sums var | cnst and *varptr1 */
 123 #define VAR_IND_VAR_DIF_VC      0x0002  /* var subs var | cnst and *varptr1 */
 124 #define VAR_IND_C_DIF_VAR       0x0003  /* var subs *varptr1 and constant */
 125 #define VAR_IND_VAR_MUL_VC      0x0005  /* var muls var | cnst and *varptr1 */
 126 #define VAR_IND_VAR_DIV_VC      0x0006  /* var divs var | cnst by *varptr1 */
 127 #define VAR_IND_C_DIV_VAR       0x0007  /* var divs *varptr1 by constant */
 128 #define VAR_INDVAR_MASK         0x000f
 129 
 130 /* Binary ops between an integer and a variable */
 131 #define VAR_IND_INT_SUM_IV      (VAR_IND_BINOP_INT | VAR_IND_VAR_SUM_VC)
 132 #define VAR_IND_IV_DIF_INT      (VAR_IND_BINOP_INT | VAR_IND_VAR_DIF_VC)
 133 #define VAR_IND_INT_DIF_IV      (VAR_IND_BINOP_INT | VAR_IND_C_DIF_VAR)
 134 #define VAR_IND_INT_MUL_IV      (VAR_IND_BINOP_INT | VAR_IND_VAR_MUL_VC)
 135 #define VAR_IND_IV_DIV_INT      (VAR_IND_BINOP_INT | VAR_IND_VAR_DIV_VC)
 136 #define VAR_IND_INT_DIV_IV      (VAR_IND_BINOP_INT | VAR_IND_C_DIV_VAR)
 137 
 138 /* Binary ops between a double float and a variable */
 139 #define VAR_IND_DBL_SUM_IV      (VAR_IND_BINOP_DBL | VAR_IND_VAR_SUM_VC)
 140 #define VAR_IND_IV_DIF_DBL      (VAR_IND_BINOP_DBL | VAR_IND_VAR_DIF_VC)
 141 #define VAR_IND_DBL_DIF_IV      (VAR_IND_BINOP_DBL | VAR_IND_C_DIF_VAR)
 142 #define VAR_IND_DBL_MUL_IV      (VAR_IND_BINOP_DBL | VAR_IND_VAR_MUL_VC)
 143 #define VAR_IND_IV_DIV_DBL      (VAR_IND_BINOP_DBL | VAR_IND_VAR_DIV_VC)
 144 #define VAR_IND_DBL_DIV_IV      (VAR_IND_BINOP_DBL | VAR_IND_C_DIV_VAR)
 145 
 146 /* Binary ops between two variables: varptr2 op varptr1 */
 147 #define VAR_IND_IV_SUM_IV       (VAR_IND_BINOP_VAR | VAR_IND_VAR_SUM_VC)
 148 #define VAR_IND_IV_DIF_IV       (VAR_IND_BINOP_VAR | VAR_IND_VAR_DIF_VC)
 149 #define VAR_IND_IV_MUL_IV       (VAR_IND_BINOP_VAR | VAR_IND_VAR_MUL_VC)
 150 #define VAR_IND_IV_DIV_IV       (VAR_IND_BINOP_VAR | VAR_IND_VAR_DIV_VC)
 151 
 152 #define VAR_HAS_BOOLEAN(vp) \
 153         (((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_BOOL_SET)
 154 
 155 #define VAR_HAS_INTEGER(vp) \
 156         (((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_INT_SET)
 157 
 158 #define VAR_HAS_DOUBLE(vp) \
 159         (((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_DBL_SET)
 160 
 161 #define VAR_HAS_STRING(vp) \
 162         (((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_STR_SET)
 163 
 164 #define VAR_HAS_RANDDIST(vp) \
 165         (((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_RAND_SET)
 166 
 167 #define VAR_HAS_INDVAR(vp) \
 168         ((((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_INDVAR_SET) && \
 169         (((vp)->var_type & VAR_INDBINOP_MASK) == VAR_IND_ASSIGN))
 170 
 171 #define VAR_HAS_BINOP(vp) \
 172         ((((vp)->var_type & VAR_TYPE_SET_MASK) == VAR_TYPE_INDVAR_SET) && \
 173         (((vp)->var_type & VAR_INDBINOP_MASK) != VAR_IND_ASSIGN))
 174 
 175 #define VAR_SET_BOOL(vp, val)   \
 176         {                       \
 177                 (vp)->var_val.boolean = (val); \
 178                 (vp)->var_type = \
 179                 (((vp)->var_type & (~VAR_TYPE_SET_MASK)) | VAR_TYPE_BOOL_SET);\
 180         }
 181 
 182 #define VAR_SET_INT(vp, val)    \
 183         {                       \
 184                 (vp)->var_val.integer = (val); \
 185                 (vp)->var_type = \
 186                 (((vp)->var_type & (~VAR_TYPE_SET_MASK)) | VAR_TYPE_INT_SET); \
 187         }
 188 
 189 #define VAR_SET_DBL(vp, val)    \
 190         {                       \
 191                 (vp)->var_val.dbl_flt = (val); \
 192                 (vp)->var_type = \
 193                     (((vp)->var_type & (~VAR_TYPE_SET_MASK)) | \
 194                     VAR_TYPE_DBL_SET); \
 195         }
 196 
 197 #define VAR_SET_STR(vp, val)    \
 198         {                       \
 199                 (vp)->var_val.string = (val); \
 200                 (vp)->var_type = \
 201                     (((vp)->var_type & (~VAR_TYPE_SET_MASK)) | \
 202                     VAR_TYPE_STR_SET); \
 203         }
 204 
 205 #define VAR_SET_RAND(vp, val)   \
 206         {                       \
 207                 (vp)->var_val.randptr = (val); \
 208                 (vp)->var_type = \
 209                     (((vp)->var_type & (~VAR_TYPE_SET_MASK)) | \
 210                     VAR_TYPE_RAND_SET); \
 211         }
 212 
 213 #define VAR_SET_INDVAR(vp, val) \
 214         {                       \
 215                 (vp)->var_varptr1 = (val); \
 216                 (vp)->var_type = \
 217                     (((vp)->var_type & (~(VAR_TYPE_SET_MASK | \
 218                     VAR_INDVAR_MASK))) | \
 219                     VAR_TYPE_INDVAR_SET); \
 220         }
 221 
 222 #define VAR_SET_BINOP_INDVAR(vp, val, st)       \
 223         {                       \
 224                 (vp)->var_varptr1 = (val); \
 225                 (vp)->var_type = \
 226                     (((vp)->var_type & (~(VAR_TYPE_SET_MASK | \
 227                     VAR_INDVAR_MASK))) | \
 228                     (VAR_TYPE_INDVAR_SET | st)); \
 229         }
 230 
 231 avd_t avd_bool_alloc(boolean_t bool);
 232 avd_t avd_int_alloc(fbint_t integer);
 233 avd_t avd_str_alloc(char *string);
 234 boolean_t avd_get_bool(avd_t);
 235 fbint_t avd_get_int(avd_t);
 236 double avd_get_dbl(avd_t);
 237 char *avd_get_str(avd_t);
 238 void avd_update(avd_t *avdp, var_t *lvar_list);
 239 avd_t var_ref_attr(char *name);
 240 int var_assign_boolean(char *name, boolean_t bool);
 241 int var_assign_integer(char *name, fbint_t integer);
 242 int var_assign_double(char *name, double dbl);
 243 int var_assign_string(char *name, char *string);
 244 int var_assign_var(char *name, char *string);
 245 int var_assign_op_var_int(char *name, int optype, char *src1, fbint_t src2);
 246 int var_assign_op_var_var(char *name, int optype, char *src1, char *src2);
 247 void var_update_comp_lvars(var_t *newlvar, var_t *proto_comp_vars,
 248     var_t *mstr_lvars);
 249 var_t *var_define_randvar(char *name);
 250 var_t *var_find_randvar(char *name);
 251 boolean_t var_to_boolean(char *name);
 252 fbint_t var_to_integer(char *name);
 253 double var_to_double(char *name);
 254 var_t *var_lvar_alloc_local(char *name);
 255 var_t *var_lvar_assign_boolean(char *name, boolean_t);
 256 var_t *var_lvar_assign_integer(char *name, fbint_t);
 257 var_t *var_lvar_assign_double(char *name, double);
 258 var_t *var_lvar_assign_string(char *name, char *string);
 259 var_t *var_lvar_assign_var(char *name, char *src_name);
 260 char *var_to_string(char *name);
 261 char *var_randvar_to_string(char *name, int param);
 262 int var_is_set4_randvar(char *name);
 263 
 264 #ifdef  __cplusplus
 265 }
 266 #endif
 267 
 268 #endif  /* _FB_VARS_H */