language

some fools attempt at an interpreted language
Log | Files | Refs | README

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 }