var_ops.c (8600B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 4 #include "var_ops.h" 5 6 #include "var.h" 7 #include "helper.h" 8 9 void var_pprint(var_cont* var) 10 { 11 if (var->type == G_STR) 12 { 13 var_data_str* data = var->data; 14 for (int i = 0; i < data->size; i++) printf("%c", data->v[i]); 15 printf("\n"); 16 } else 17 if (var->type == G_INT) 18 { 19 int val = var_data_get_G_INT(var); 20 printf("%i\n", val); 21 } else 22 if (var->type == G_FLOAT) 23 { 24 double val = var_data_get_G_FLOAT(var); 25 printf("%f\n", val); 26 } 27 } 28 29 var_cont* var_add_float(var_cont* A, var_cont* B) 30 { 31 var_cont* var = var_new(G_FLOAT); 32 double AV = var_data_get_G_FLOAT(A); 33 double BV = var_data_get_G_FLOAT(B); 34 35 double S = AV + BV; 36 37 var_data_float* data = var_data_alloc_G_FLOAT(S); 38 39 var_set(var, data, G_FLOAT); 40 41 return var; 42 } 43 var_cont* var_add_int(var_cont* A, var_cont* B) 44 { 45 var_cont* var = var_new(G_INT); 46 47 int AV = var_data_get_G_INT(A); 48 int BV = var_data_get_G_INT(B); 49 50 int S = AV + BV; 51 52 var_data_int* data = var_data_alloc_G_INT(S); 53 54 var_set(var, data, G_INT); 55 56 return var; 57 } 58 var_cont* var_add(var_cont* A, var_cont* B) 59 { 60 var_cont* rv; 61 62 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 63 if (A->type == G_INT && B->type == G_INT) 64 { 65 rv = var_add_int(A, B); 66 } else 67 if (A->type == G_FLOAT && B->type == G_FLOAT) 68 { 69 rv = var_add_float(A, B); 70 } 71 72 N_ASSERT(rv, "var_add\n"); 73 74 return rv; 75 } 76 77 var_cont* var_sub_float(var_cont* A, var_cont* B) 78 { 79 var_cont* var = var_new(G_FLOAT); 80 double AV = var_data_get_G_FLOAT(A); 81 double BV = var_data_get_G_FLOAT(B); 82 83 double S = AV - BV; 84 85 var_data_float* data = var_data_alloc_G_FLOAT(S); 86 87 var_set(var, data, G_FLOAT); 88 89 return var; 90 } 91 var_cont* var_sub_int(var_cont* A, var_cont* B) 92 { 93 var_cont* var = var_new(G_INT); 94 int AV = var_data_get_G_INT(A); 95 int BV = var_data_get_G_INT(B); 96 97 int S = AV - BV; 98 99 var_data_int* data = var_data_alloc_G_INT(S); 100 101 var_set(var, data, G_INT); 102 103 return var; 104 } 105 var_cont* var_sub(var_cont* A, var_cont* B) 106 { 107 var_cont* rv; 108 109 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 110 if (A->type == G_INT && B->type == G_INT) 111 { 112 rv = var_sub_int(A, B); 113 } else 114 if (A->type == G_FLOAT && B->type == G_FLOAT) 115 { 116 rv = var_sub_float(A, B); 117 } 118 119 N_ASSERT(rv, "var_sub\n"); 120 121 return rv; 122 } 123 124 var_cont* var_mult_float(var_cont* A, var_cont* B) 125 { 126 var_cont* var = var_new(G_FLOAT); 127 double AV = var_data_get_G_FLOAT(A); 128 double BV = var_data_get_G_FLOAT(B); 129 130 double S = AV * BV; 131 132 var_data_float* data = var_data_alloc_G_FLOAT(S); 133 134 var_set(var, data, G_FLOAT); 135 136 return var; 137 } 138 var_cont* var_mult_int(var_cont* A, var_cont* B) 139 { 140 var_cont* var = var_new(G_INT); 141 int AV = var_data_get_G_INT(A); 142 int BV = var_data_get_G_INT(B); 143 144 int S = AV * BV; 145 146 var_data_int* data = var_data_alloc_G_INT(S); 147 148 var_set(var, data, G_INT); 149 150 return var; 151 } 152 var_cont* var_mult(var_cont* A, var_cont* B) 153 { 154 var_cont* rv; 155 156 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 157 if (A->type == G_INT && B->type == G_INT) 158 { 159 rv = var_mult_int(A, B); 160 } else 161 if (A->type == G_FLOAT && B->type == G_FLOAT) 162 { 163 rv = var_mult_float(A, B); 164 } 165 166 N_ASSERT(rv, "var_mult\n"); 167 168 return rv; 169 } 170 171 var_cont* var_div_float(var_cont* A, var_cont* B) 172 { 173 var_cont* var = var_new(G_FLOAT); 174 double AV = var_data_get_G_FLOAT(A); 175 double BV = var_data_get_G_FLOAT(B); 176 177 double S = AV / BV; 178 179 var_data_float* data = var_data_alloc_G_FLOAT(S); 180 181 var_set(var, data, G_FLOAT); 182 183 return var; 184 } 185 var_cont* var_div_int(var_cont* A, var_cont* B) 186 { 187 var_cont* var = var_new(G_INT); 188 int AV = var_data_get_G_INT(A); 189 int BV = var_data_get_G_INT(B); 190 191 int S = AV / BV; 192 193 var_data_int* data = var_data_alloc_G_INT(S); 194 195 var_set(var, data, G_INT); 196 197 return var; 198 } 199 var_cont* var_div(var_cont* A, var_cont* B) 200 { 201 var_cont* rv; 202 203 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 204 if (A->type == G_INT && B->type == G_INT) 205 { 206 rv = var_div_int(A, B); 207 } else 208 if (A->type == G_FLOAT && B->type == G_FLOAT) 209 { 210 rv = var_div_float(A, B); 211 } 212 213 N_ASSERT(rv, "var_div\n"); 214 215 return rv; 216 } 217 218 var_cont* var_gthan_float(var_cont* A, var_cont* B) 219 { 220 var_cont* var = var_new(G_INT); 221 double AV = var_data_get_G_FLOAT(A); 222 double BV = var_data_get_G_FLOAT(B); 223 224 int S = (AV > BV); 225 226 var_data_int* data = var_data_alloc_G_INT(S); 227 228 var_set(var, data, G_INT); 229 230 return var; 231 } 232 var_cont* var_gthan_int(var_cont* A, var_cont* B) 233 { 234 var_cont* var = var_new(G_INT); 235 int AV = var_data_get_G_INT(A); 236 int BV = var_data_get_G_INT(B); 237 238 int S = (AV > BV); 239 240 var_data_int* data = var_data_alloc_G_INT(S); 241 242 var_set(var, data, G_INT); 243 244 return var; 245 246 } 247 var_cont* var_gthan(var_cont* A, var_cont* B) 248 { 249 var_cont* rv; 250 251 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 252 if (A->type == G_INT && B->type == G_INT) 253 { 254 rv = var_gthan_int(A, B); 255 } else 256 if (A->type == G_FLOAT && B->type == G_FLOAT) 257 { 258 rv = var_gthan_float(A, B); 259 } 260 261 N_ASSERT(rv, "var_gthan\n"); 262 263 return rv; 264 } 265 266 var_cont* var_lthan_float(var_cont* A, var_cont* B) 267 { 268 var_cont* var = var_new(G_INT); 269 double AV = var_data_get_G_FLOAT(A); 270 double BV = var_data_get_G_FLOAT(B); 271 272 int S = (AV < BV); 273 274 var_data_int* data = var_data_alloc_G_INT(S); 275 276 var_set(var, data, G_INT); 277 278 return var; 279 } 280 var_cont* var_lthan_int(var_cont* A, var_cont* B) 281 { 282 var_cont* var = var_new(G_INT); 283 int AV = var_data_get_G_INT(A); 284 int BV = var_data_get_G_INT(B); 285 286 int S = (AV < BV); 287 288 var_data_int* data = var_data_alloc_G_INT(S); 289 290 var_set(var, data, G_INT); 291 292 return var; 293 } 294 var_cont* var_lthan(var_cont* A, var_cont* B) 295 { 296 var_cont* rv; 297 298 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 299 if (A->type == G_INT && B->type == G_INT) 300 { 301 rv = var_lthan_int(A, B); 302 } else 303 if (A->type == G_FLOAT && B->type == G_FLOAT) 304 { 305 rv = var_lthan_float(A, B); 306 } 307 308 N_ASSERT(rv, "var_lthan\n"); 309 310 return rv; 311 } 312 313 var_cont* var_gthan_eq_float(var_cont* A, var_cont* B) 314 { 315 var_cont* var = var_new(G_INT); 316 double AV = var_data_get_G_FLOAT(A); 317 double BV = var_data_get_G_FLOAT(B); 318 319 int S = (AV >= BV); 320 321 var_data_int* data = var_data_alloc_G_INT(S); 322 323 var_set(var, data, G_INT); 324 325 return var; 326 } 327 var_cont* var_gthan_eq_int(var_cont* A, var_cont* B) 328 { 329 var_cont* var = var_new(G_INT); 330 int AV = var_data_get_G_INT(A); 331 int BV = var_data_get_G_INT(B); 332 333 int S = (AV >= BV); 334 335 var_data_int* data = var_data_alloc_G_INT(S); 336 337 var_set(var, data, G_INT); 338 339 return var; 340 341 } 342 var_cont* var_gthan_eq(var_cont* A, var_cont* B) 343 { 344 var_cont* rv; 345 346 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 347 if (A->type == G_INT && B->type == G_INT) 348 { 349 rv = var_gthan_eq_int(A, B); 350 } else 351 if (A->type == G_FLOAT && B->type == G_FLOAT) 352 { 353 rv = var_gthan_eq_float(A, B); 354 } 355 356 N_ASSERT(rv, "var_gthan\n"); 357 358 return rv; 359 } 360 361 var_cont* var_lthan_eq_float(var_cont* A, var_cont* B) 362 { 363 var_cont* var = var_new(G_INT); 364 double AV = var_data_get_G_FLOAT(A); 365 double BV = var_data_get_G_FLOAT(B); 366 367 int S = (AV <= BV); 368 369 var_data_int* data = var_data_alloc_G_INT(S); 370 371 var_set(var, data, G_INT); 372 373 return var; 374 } 375 var_cont* var_lthan_eq_int(var_cont* A, var_cont* B) 376 { 377 var_cont* var = var_new(G_INT); 378 int AV = var_data_get_G_INT(A); 379 int BV = var_data_get_G_INT(B); 380 381 int S = (AV <= BV); 382 383 var_data_int* data = var_data_alloc_G_INT(S); 384 385 var_set(var, data, G_INT); 386 387 return var; 388 } 389 var_cont* var_lthan_eq(var_cont* A, var_cont* B) 390 { 391 var_cont* rv; 392 393 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 394 if (A->type == G_INT && B->type == G_INT) 395 { 396 rv = var_lthan_eq_int(A, B); 397 } else 398 if (A->type == G_FLOAT && B->type == G_FLOAT) 399 { 400 rv = var_lthan_eq_float(A, B); 401 } 402 403 N_ASSERT(rv, "var_lthan\n"); 404 405 return rv; 406 } 407 408 var_cont* var_eq_float(var_cont* A, var_cont* B) 409 { 410 var_cont* var = var_new(G_INT); 411 double AV = var_data_get_G_FLOAT(A); 412 double BV = var_data_get_G_FLOAT(B); 413 414 int S = (AV == BV); 415 416 var_data_int* data = var_data_alloc_G_INT(S); 417 418 var_set(var, data, G_INT); 419 420 return var; 421 } 422 var_cont* var_eq_int(var_cont* A, var_cont* B) 423 { 424 var_cont* var = var_new(G_INT); 425 int AV = var_data_get_G_INT(A); 426 int BV = var_data_get_G_INT(B); 427 428 int S = (AV == BV); 429 430 var_data_int* data = var_data_alloc_G_INT(S); 431 432 var_set(var, data, G_INT); 433 434 return var; 435 } 436 var_cont* var_eq(var_cont* A, var_cont* B) 437 { 438 var_cont* rv; 439 440 ASSERT(( A->type == B->type ), "Inconsistent Types\n"); 441 if (A->type == G_INT && B->type == G_INT) 442 { 443 rv = var_eq_int(A, B); 444 } else 445 if (A->type == G_FLOAT && B->type == G_FLOAT) 446 { 447 rv = var_eq_float(A, B); 448 } 449 450 N_ASSERT(rv, "var_eq\n"); 451 452 return rv; 453 } 454 455 var_cont* var_not(var_cont* A) 456 { 457 var_cont* rv = var_new(G_INT); 458 459 int val = var_data_get_G_INT(A); 460 if (val < 1) val = 1; 461 else val = 0; 462 463 var_set(rv, var_data_alloc_G_INT(val), G_INT); 464 465 return rv; 466 }