apps/shell/shell_vars.c

   1 //#include <types.h>
   2 #include <string.h>
   3 #include <ctype.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6
   7 #include "shell_vars.h"
   8 #include "statements.h"
   9 #include "shell_defs.h"
  10
  11
  12 struct _shell_var{
  13         struct _shell_var *next;
  14         char *name;
  15         shell_value *value;
  16 }
  17 ;
  18
  19 typedef struct _shell_var shell_var;
  20
  21 static shell_var *var_list;
  22
  23 char *shell_strdup(const char *some_str)
  24 {
  25         char *result;
  26
  27         result = malloc(strlen(some_str) + 1);
  28
  29         if(result != NULL){
  30                 strcpy(result,some_str);
  31         }
  32
  33         return result;
  34 }
  35
  36 bool string_to_long_int(const char *str,long int *out)
  37 {
  38         const char *scanner = str;
  39         bool do_neg = false;
  40
  41         *out = 0;
  42
  43         if(*scanner == '-'){
  44                 do_neg = true;
  45                 scanner++;
  46         }
  47
  48         while ((*scanner != 0) && (isdigit(*scanner))){
  49
  50                 (*out) = (*out)*10 + (*scanner)-48;
  51                 scanner++;
  52
  53         }
  54
  55    if(do_neg) *out = -(*out);
  56
  57         return (*scanner != 0);
  58 }
  59
  60 void shell_value_free(shell_value *value)
  61 {
  62         if(!value->isnumber) free(value->value.val_text);
  63         free(value);
  64 }
  65
  66
  67 char *shell_value_to_char(shell_value *value)
  68 {
  69         if(value->isnumber){
  70                 char tmp[255];
  71                 sprintf(tmp,"%ld",value->value.val_number);
  72       return shell_strdup(tmp);
  73         } else {
  74                 return shell_strdup(value->value.val_text);
  75         }
  76 }
  77
  78 int shell_value_to_number(shell_value *value,long int *number)
  79 {
  80         if(value->isnumber){
  81                 *number = value->value.val_number;
  82                 return SHE_NO_ERROR;
  83         } else {
  84                 return string_to_long_int(value->value.val_text,number);
  85         }
  86 }
  87
  88 int shell_value_get_text(shell_value * value,char **text){
  89         if(value->isnumber) return SHE_INVALID_TYPE;
  90         *text = value->value.val_text;
  91         return SHE_NO_ERROR;
  92 }
  93
  94 int shell_value_get_number(shell_value *value,long int *number)
  95 {
  96         if(!value->isnumber) return SHE_INVALID_TYPE;
  97         *number = value->value.val_number;
  98         return SHE_NO_ERROR;
  99 }
 100
 101 // unused
 102 #if 0
 103 static void shell_var_free(shell_var *var)
 104 {
 105         shell_value_free(var->value);
 106         free(var->name);
 107         free(var);
 108 }
 109 #endif
 110
 111 shell_value *shell_value_init_number(long int value)
 112 {
 113         shell_value *current;
 114
 115         current = malloc(sizeof(shell_value));
 116         if(current == NULL) return NULL;
 117
 118         current->isnumber = true;
 119         current->value.val_number = value;
 120
 121         return  current;
 122 }
 123
 124
 125 shell_value *shell_value_init_text(const char *value)
 126 {
 127         shell_value *current;
 128
 129         current = malloc(sizeof(shell_value));
 130         if(current == NULL) goto err;
 131
 132         current->value.val_text = shell_strdup(value);
 133         if(current->value.val_text == NULL) goto err1;
 134
 135         current->isnumber = false;
 136
 137         return current;
 138 err1:
 139         free(current);
 140 err:
 141         return NULL;
 142 }
 143
 144
 145 int shell_value_set_text(shell_value *value,const char *new_value)
 146 {
 147         char *val = shell_strdup(new_value);
 148         if(val == NULL) return SHE_NO_MEMORY;
 149
 150         if(!value->isnumber) free(value->value.val_text);
 151
 152         value->value.val_text  = val;
 153         value->isnumber = false;
 154
 155         return SHE_NO_ERROR;
 156 }
 157
 158 int shell_value_set_number(shell_value *value,long int new_value)
 159 {
 160         if(!value->isnumber) free(value->value.val_text);
 161
 162         value->value.val_number = new_value;
 163         value->isnumber = true;
 164
 165         return SHE_NO_ERROR;
 166 }
 167
 168
 169
 170 shell_value *shell_value_clone(shell_value *var)
 171 {
 172         if(var->isnumber){
 173                 return shell_value_init_number(var->value.val_number);
 174         } else {
 175                 return shell_value_init_text(var->value.val_text);
 176         }
 177 }
 178
 179
 180
 181
 182
 183
 184 int shell_value_neg(shell_value *out)
 185 {
 186         long int value;
 187         int err;
 188
 189         err = shell_value_get_number(out,&value);
 190         if(err != SHE_NO_ERROR) return err;
 191
 192         err = shell_value_set_number(out,-value);
 193         return err;
 194 }
 195
 196
 197 // out = out .op. out
 198
 199 int shell_value_do_operation(shell_value *out,const shell_value *other,int oper_type)
 200 {
 201         long int i1;
 202         long int i2;
 203         long int i3;
 204         int err;
 205
 206         if(out->isnumber != other->isnumber) return SHE_INVALID_TYPE;
 207         if(out->isnumber){
 208
 209                 i1 = out->value.val_number;
 210                 i2 = other->value.val_number;
 211                 printf("%ld %ld %d",i1,i2,oper_type);
 212                 switch(oper_type){
 213                         case SVO_ADD       : i3 = i1+i2    ;break;
 214                         case SVO_SUB       : i3 = i1-i2    ;break;
 215                         case SVO_MUL       : i3 = i1*i2    ;break;
 216                         case SVO_DIV       : i3 = i1/i2    ;break;
 217                         case SVO_BIGGER    : i3 = i1>i2    ;break;
 218                         case SVO_LESS      : i3 = i1<i2    ;break;
 219                         case SVO_EQUAL     : i3 = i1 == i2 ;break;
 220                         case SVO_BIGGER_E  : i3 = i1 >=i2  ;break;
 221                         case SVO_LESS_E    : i3 = i1 <= i2 ;break;
 222                         case SVO_NOT_EQUAL : i3 = i1 != i2  ;break;
 223                         default: return SHE_INVALID_OPERATION;
 224                 }
 225
 226         } else {
 227
 228                 i1 = strcmp(out->value.val_text,other->value.val_text);
 229
 230                 switch(oper_type){
 231                         case SVO_EQUAL     : i3 = i1 == 0;break;
 232                         case SVO_BIGGER : i3 = i1 > 0;break;
 233                         case SVO_LESS           : i3 = i1 < 0;break;
 234                         case SVO_BIGGER_E : i3 = i1 >= 0;break;
 235                         case SVO_LESS_E : i3 = i1 <= 0;break;
 236                         case SVO_NOT_EQUAL: i3 = i1 != 0;break;
 237                         default : return SHE_INVALID_OPERATION;
 238                 }
 239         }
 240
 241         err =  shell_value_set_number(out,i3);
 242         return err;
 243 }
 244
 245
 246 //
 247 // init shell var
 248 //
 249
 250 static shell_var *shell_var_init_value(const char *name,shell_value *value)
 251 {
 252         shell_var *current;
 253
 254         current = malloc(sizeof(shell_var));
 255         if(current == NULL) goto err;
 256
 257         current->name = shell_strdup(name);
 258         if(current->name == NULL) goto err2;
 259
 260         current->value = value;
 261
 262         return current;
 263
 264         free(current->name);
 265 err2:
 266         free(current);
 267 err:
 268         return NULL;
 269 }
 270
 271
 272
 273
 274 //
 275 // Add shell variable
 276 //
 277
 278 static int shell_var_add(const char *var_name,shell_value *value)
 279 {
 280         shell_var *current;
 281
 282         current = shell_var_init_value(var_name,value);
 283
 284         current->next = var_list;
 285         var_list = current;
 286
 287         return SHE_NO_ERROR;
 288
 289         free(current->name);
 290         free(current);
 291         return SHE_NO_MEMORY;
 292 }
 293
 294
 295 static  shell_var * find_shell_var_by_name(const char *name)
 296 {
 297         shell_var *current;
 298
 299         current = var_list;
 300
 301         while((current != NULL) && (strcmp(current->name,name) != 0)) current = current->next;
 302
 303         return current;
 304 }
 305
 306
 307
 308
 309
 310 static int shell_var_set(const char *var_name,shell_value *value)
 311 {
 312         shell_var *current;
 313
 314         current = find_shell_var_by_name(var_name);
 315
 316
 317         if(current == NULL){
 318
 319         return shell_var_add(var_name,value);
 320
 321         }
 322
 323         shell_value_free(current->value);
 324         current->value = value;
 325
 326         return SHE_NO_ERROR;
 327 }
 328
 329 int shell_var_set_number(const char *var_name,long int number)
 330 {
 331         shell_value *value;
 332
 333         value = shell_value_init_number(number);
 334         if(value == NULL) return SHE_NO_MEMORY;
 335
 336         return shell_var_set(var_name,value);
 337 }
 338
 339
 340 int shell_var_set_text(const char *var_name,const char *text)
 341 {
 342         shell_value *value;
 343
 344         value = shell_value_init_text(text);
 345         if(value == NULL) return SHE_NO_MEMORY;
 346
 347         return shell_var_set(var_name,value);
 348 }
 349
 350
 351
 352 int set_shell_var_with_value(const char *var_name,shell_value *value)
 353 {
 354         return shell_var_set(var_name,shell_value_clone(value));
 355 }
 356
 357 shell_value *get_value_by_name(const char *name)
 358 {
 359         shell_var *current;
 360         shell_value *result = NULL;
 361
 362         current  = find_shell_var_by_name(name);
 363
 364         if(current != NULL) result = current->value;
 365
 366         return result;
 367 }
 368
 369
 370 void init_vars(void){
 371         var_list = NULL;
 372 }