ins_def.c - language - some fools attempt at an interpreted language

ins_def.c (18248B)
      1 #include <stdlib.h>
      2 #include <stdio.h>
      3 
      4 #include "ins_def.h"
      5 
      6 #include "proc.h"
      7 #include "rt.h"
      8 #include "bc.h"
      9 #include "stk.h"
     10 #include "object.h"
     11 #include "var.h"
     12 #include "var_ops.h"
     13 #include "pc.h"
     14 #include "helper.h"
     15 
     16 /* Initializes INS_DEF with pointers to each instructions function
     17  * Populates INS_DEF
     18  */
     19 void init_ins_def( void )
     20 {
     21 	INS_DEC(0x00, _ins_def_NULL, "NULL");
     22 	INS_DEC(0x01, _ins_def_SYNC, "SYNC");
     23 
     24 	INS_DEC(0x02, _ins_def_PRINT, "PRINT");
     25 	INS_DEC(0x03, _ins_def_DEBUG, "DEBUG");
     26 	INS_DEC(0x0E, _ins_def_ARGB, "ARGB");
     27 	INS_DEC(0x0F, _ins_def_LIBC, "LIBC");
     28 
     29 	INS_DEC(0x10, _ins_def_POP, "POP");
     30 	INS_DEC(0x11, _ins_def_ROT, "ROT");
     31 	INS_DEC(0x12, _ins_def_DUP, "DUP");
     32 	INS_DEC(0x13, _ins_def_ROT_THREE, "ROT_THREE");
     33 
     34 	INS_DEC(0x20, _ins_def_DEC, "DEC");
     35 	INS_DEC(0x21, _ins_def_LOV, "LOV");
     36 	INS_DEC(0x22, _ins_def_STV, "STV");
     37 	INS_DEC(0x23, _ins_def_CTV, "CTV");
     38 	INS_DEC(0x24, _ins_def_CTS, "CTS");
     39 
     40 	INS_DEC(0x30, _ins_def_TYPEOF, "TYPEOF");
     41 	INS_DEC(0x31, _ins_def_CAST, "CAST");
     42 
     43 	INS_DEC(0x40, _ins_def_ADD, "ADD");
     44 	INS_DEC(0x41, _ins_def_SUB, "SUB");
     45 	INS_DEC(0x42, _ins_def_MULT, "MULT");
     46 	INS_DEC(0x43, _ins_def_DIV, "DIV");
     47 	INS_DEC(0x44, _ins_def_POW, "POW");
     48 	INS_DEC(0x45, _ins_def_BRT, "BRT");
     49 	INS_DEC(0x46, _ins_def_SIN, "SIN");
     50 	INS_DEC(0x47, _ins_def_COS, "COS");
     51 	INS_DEC(0x48, _ins_def_TAN, "TAN");
     52 	INS_DEC(0x49, _ins_def_ISIN, "ISIN");
     53 	INS_DEC(0x4A, _ins_def_ICOS, "ICOS");
     54 	INS_DEC(0x4B, _ins_def_ITAN, "ITAN");
     55 	INS_DEC(0x4C, _ins_def_MOD, "MOD");
     56 	INS_DEC(0x4D, _ins_def_BOR, "BOR");
     57 	INS_DEC(0x4E, _ins_def_BXOR, "BXOR");
     58 	INS_DEC(0x4F, _ins_def_BNAND, "BNAND");
     59 
     60 	INS_DEC(0x50, _ins_def_GTHAN, "GTHAN");
     61 	INS_DEC(0x51, _ins_def_LTHAN, "LTHAN");
     62 	INS_DEC(0x52, _ins_def_GTHAN_EQ, "GTHAN_EQ");
     63 	INS_DEC(0x53, _ins_def_LTHAN_EQ, "LTHAN_EQ");
     64 	INS_DEC(0x54, _ins_def_EQ, "EQ");
     65 	INS_DEC(0x55, _ins_def_NEQ, "NEQ");
     66 	INS_DEC(0x56, _ins_def_NOT, "NOT");
     67 	INS_DEC(0x57, _ins_def_OR, "OR");
     68 	INS_DEC(0x58, _ins_def_AND, "AND");
     69 
     70 	INS_DEC(0x60, _ins_def_STARTL, "STARTL");
     71 	INS_DEC(0x61, _ins_def_CLOOP, "CLOOP");
     72 	INS_DEC(0x6E, _ins_def_BREAK, "BREAK");
     73 	INS_DEC(0x6F, _ins_def_ENDL, "ENDL");
     74 
     75 	INS_DEC(0x70, _ins_def_GOTO, "GOTO");
     76 	INS_DEC(0x71, _ins_def_JUMPF, "JUMPF");
     77 	INS_DEC(0x72, _ins_def_IFDO, "IFDO");
     78 	INS_DEC(0x73, _ins_def_ELSE, "ELSE");
     79 	INS_DEC(0x7E, _ins_def_DONE, "DONE");
     80 	INS_DEC(0x7F, _ins_def_CALL, "CALL");
     81 
     82 	INS_DEC(0x80, _ins_def_GETN, "GETN");
     83 	INS_DEC(0x81, _ins_def_SETN, "SETN");
     84 	INS_DEC(0x82, _ins_def_CALLM, "CALLM");
     85 	INS_DEC(0x83, _ins_def_INDEXO, "INDEXO");
     86 	INS_DEC(0x84, _ins_def_MODO, "MODO");
     87 
     88 	INS_DEC(0xF0, _ins_def_RETURN, "RETURN");
     89 	INS_DEC(0xF1, _ins_def_NEW, "NEW");
     90 	INS_DEC(0xF2, _ins_def_ENDCLASS, "ENDCLASS");
     91 	INS_DEC(0xFE, _ins_def_DECLASS, "DECLASS");
     92 	INS_DEC(0xFF, _ins_def_DEFUN, "DEFUN");
     93 }
     94 
     95 int ins_def_is_valid(bc_cont* line)
     96 {
     97 	int rv = 0;
     98 
     99 	if (INS_DEF[line->op] != NULL)
    100 	{
    101 		rv = 1;
    102 	}
    103 	return rv;
    104 }
    105 
    106 inline void run_ins(rt_t* ctx, bc_cont* line)
    107 {
    108 	INS_DEF[line->op](ctx, line);
    109 }
    110 
    111 void _ins_def_NULL     (rt_t* ctx, bc_cont* line)
    112 {
    113 	pc_inc(ctx->pc, 1);
    114 }
    115 void _ins_def_SYNC     (rt_t* ctx, bc_cont* line)
    116 {
    117 	pc_inc(ctx->pc, 1);
    118 }
    119 void _ins_def_PRINT    (rt_t* ctx, bc_cont* line)
    120 {
    121 	var_cont* var = stk_pop(ctx->stack);
    122 
    123 	var_pprint(var);
    124 
    125 	pc_inc(ctx->pc, 1);
    126 }
    127 void _ins_def_DEBUG    (rt_t* ctx, bc_cont* line)
    128 {
    129 	ctx->db = 0 ? ctx->db : 1;
    130 	pc_inc(ctx->pc, 1);
    131 }
    132 void _ins_def_ARGB     (rt_t* ctx, bc_cont* line)
    133 {
    134 	var_cont* var = stk_pop(ctx->stack);
    135 
    136 	stk_push(ctx->argstk, var);
    137 
    138 	pc_inc(ctx->pc, 1);
    139 }
    140 void _ins_def_LIBC     (rt_t* ctx, bc_cont* line)
    141 {
    142 	pc_inc(ctx->pc, 1);
    143 }
    144 
    145 void _ins_def_POP      (rt_t* ctx, bc_cont* line)
    146 {
    147 	int n = var_data_get_G_INT(line->varg[0]);
    148 	int i = 0;
    149 
    150 	while (n > i)
    151 	{
    152 		i++;
    153 		stk_pop(ctx->stack);
    154 	}
    155 
    156 	pc_inc(ctx->pc, 1);
    157 }
    158 void _ins_def_ROT      (rt_t* ctx, bc_cont* line)
    159 {
    160 	stk_rot_top(ctx->stack);
    161 
    162 	pc_inc(ctx->pc, 1);
    163 }
    164 void _ins_def_DUP      (rt_t* ctx, bc_cont* line)
    165 {
    166 	var_cont* var = stk_at(ctx->stack, 0);
    167 	var_cont* dup = var_data_cpy(var);
    168 	stk_push(ctx->stack, dup);
    169 	pc_inc(ctx->pc, 1);
    170 }
    171 void _ins_def_ROT_THREE(rt_t* ctx, bc_cont* line)
    172 {
    173 	stk_rot_three(ctx->stack);
    174 	pc_inc(ctx->pc, 1);
    175 }
    176 
    177 void _ins_def_DEC      (rt_t* ctx, bc_cont* line)
    178 {
    179 	int scope = var_data_get_G_INT(line->varg[0]);
    180 	b_type type  = var_data_get_TYPE(line->varg[1]);
    181 	int name  = var_data_get_G_INT(line->varg[2]);
    182 
    183 	proc_decvar(ctx, type, scope, name);
    184 
    185 	pc_inc(ctx->pc, 1);
    186 }
    187 void _ins_def_LOV      (rt_t* ctx, bc_cont* line)
    188 {
    189 	int scope = var_data_get_G_INT(line->varg[0]);
    190 	int name  = var_data_get_G_INT(line->varg[1]);
    191 
    192 	var_cont* var;
    193 
    194 	var = proc_getvar(ctx, scope, name);
    195 
    196 	stk_push(ctx->stack, var);
    197 
    198 	pc_inc(ctx->pc, 1);
    199 }
    200 void _ins_def_STV      (rt_t* ctx, bc_cont* line)
    201 {
    202 	int scope = var_data_get_G_INT(line->varg[0]);
    203 	int name  = var_data_get_G_INT(line->varg[1]);
    204 
    205 	var_cont* var = stk_pop(ctx->stack);
    206 	var_cont* ovr = proc_getvar(ctx, scope, name);
    207 	var_cont* set = var_data_cpy(var);
    208 	set->ownership = ovr->ownership;
    209 
    210 	proc_setvar(ctx, scope, name, set);
    211 
    212 	pc_inc(ctx->pc, 1);
    213 }
    214 void _ins_def_CTV      (rt_t* ctx, bc_cont* line)
    215 {
    216 	int name = var_data_get_G_INT(line->varg[0]);
    217 	
    218 	int scope = var_data_get_G_INT(line->varg[1]);
    219 
    220 	var_cont* new = var_data_cpy(line->varg[2]);
    221 
    222 	proc_setvar(ctx, scope, name, new);
    223 
    224 	pc_inc(ctx->pc, 1);
    225 }
    226 void _ins_def_CTS      (rt_t* ctx, bc_cont* line)
    227 {
    228 	//var_cont* new = var_data_cpy(line->varg[0]);
    229 
    230 	stk_push(ctx->stack, line->varg[0]);
    231 
    232 	pc_inc(ctx->pc, 1);
    233 }
    234 
    235 void _ins_def_TYPEOF   (rt_t* ctx, bc_cont* line)
    236 {
    237 	var_cont* var = stk_at(ctx->stack, 0);
    238 	var_cont* new = var_new(TYPE);
    239 
    240 	var_data_type* data = var_data_alloc_TYPE(var->type);
    241 
    242 	var_set(new, data, TYPE);
    243 
    244 	stk_push(ctx->stack, new);
    245 
    246 	pc_inc(ctx->pc, 1);
    247 }
    248 void _ins_def_CAST     (rt_t* ctx, bc_cont* line)
    249 {
    250 	pc_inc(ctx->pc, 1);
    251 }
    252 
    253 void _ins_def_ADD      (rt_t* ctx, bc_cont* line)
    254 {
    255 	var_cont* A = stk_pop(ctx->stack);
    256 	var_cont* B = stk_pop(ctx->stack);
    257 
    258 	var_cont* var = var_add(A, B);
    259 
    260 	stk_push(ctx->stack, var);
    261 
    262 	pc_inc(ctx->pc, 1);
    263 }
    264 void _ins_def_SUB      (rt_t* ctx, bc_cont* line)
    265 {
    266 	var_cont* A = stk_pop(ctx->stack);
    267 	var_cont* B = stk_pop(ctx->stack);
    268 
    269 	var_cont* var = var_sub(A, B);
    270 
    271 	stk_push(ctx->stack, var);
    272 
    273 	pc_inc(ctx->pc, 1);
    274 }
    275 void _ins_def_MULT     (rt_t* ctx, bc_cont* line)
    276 {
    277 	var_cont* A = stk_pop(ctx->stack);
    278 	var_cont* B = stk_pop(ctx->stack);
    279 
    280 	var_cont* var = var_mult(A, B);
    281 
    282 	stk_push(ctx->stack, var);
    283 
    284 	pc_inc(ctx->pc, 1);
    285 }
    286 void _ins_def_DIV      (rt_t* ctx, bc_cont* line)
    287 {
    288 	var_cont* A = stk_pop(ctx->stack);
    289 	var_cont* B = stk_pop(ctx->stack);
    290 
    291 	var_cont* var = var_div(A, B);
    292 
    293 	stk_push(ctx->stack, var);
    294 
    295 	pc_inc(ctx->pc, 1);
    296 }
    297 void _ins_def_POW      (rt_t* ctx, bc_cont* line)
    298 {
    299 	pc_inc(ctx->pc, 1);
    300 }
    301 void _ins_def_BRT      (rt_t* ctx, bc_cont* line)
    302 {
    303 	pc_inc(ctx->pc, 1);
    304 }
    305 void _ins_def_SIN      (rt_t* ctx, bc_cont* line)
    306 {
    307 	pc_inc(ctx->pc, 1);
    308 }
    309 void _ins_def_COS      (rt_t* ctx, bc_cont* line)
    310 {
    311 	pc_inc(ctx->pc, 1);
    312 }
    313 void _ins_def_TAN      (rt_t* ctx, bc_cont* line)
    314 {
    315 	pc_inc(ctx->pc, 1);
    316 }
    317 void _ins_def_ISIN     (rt_t* ctx, bc_cont* line)
    318 {
    319 	pc_inc(ctx->pc, 1);
    320 }
    321 void _ins_def_ICOS     (rt_t* ctx, bc_cont* line)
    322 {
    323 	pc_inc(ctx->pc, 1);
    324 }
    325 void _ins_def_ITAN     (rt_t* ctx, bc_cont* line)
    326 {
    327 	pc_inc(ctx->pc, 1);
    328 }
    329 void _ins_def_MOD      (rt_t* ctx, bc_cont* line)
    330 {
    331 	pc_inc(ctx->pc, 1);
    332 }
    333 void _ins_def_BOR      (rt_t* ctx, bc_cont* line)
    334 {
    335 	pc_inc(ctx->pc, 1);
    336 }
    337 void _ins_def_BXOR     (rt_t* ctx, bc_cont* line)
    338 {
    339 	pc_inc(ctx->pc, 1);
    340 }
    341 void _ins_def_BNAND    (rt_t* ctx, bc_cont* line)
    342 {
    343 	pc_inc(ctx->pc, 1);
    344 }
    345 
    346 void _ins_def_GTHAN    (rt_t* ctx, bc_cont* line)
    347 {
    348 	var_cont* A = stk_pop(ctx->stack);
    349 	var_cont* B = stk_pop(ctx->stack);
    350 
    351 	var_cont* C = var_gthan(A, B);
    352 
    353 	stk_push(ctx->stack, C);
    354 
    355 	pc_inc(ctx->pc, 1);
    356 }
    357 void _ins_def_LTHAN    (rt_t* ctx, bc_cont* line)
    358 {
    359 	var_cont* A = stk_pop(ctx->stack);
    360 	var_cont* B = stk_pop(ctx->stack);
    361 
    362 	var_cont* C = var_lthan(A, B);
    363 
    364 	stk_push(ctx->stack, C);
    365 
    366 	pc_inc(ctx->pc, 1);
    367 }
    368 void _ins_def_GTHAN_EQ (rt_t* ctx, bc_cont* line)
    369 {
    370 	var_cont* A = stk_pop(ctx->stack);
    371 	var_cont* B = stk_pop(ctx->stack);
    372 
    373 	var_cont* C = var_gthan_eq(A, B);
    374 
    375 	stk_push(ctx->stack, C);
    376 
    377 	pc_inc(ctx->pc, 1);
    378 }
    379 void _ins_def_LTHAN_EQ (rt_t* ctx, bc_cont* line)
    380 {
    381 	var_cont* A = stk_pop(ctx->stack);
    382 	var_cont* B = stk_pop(ctx->stack);
    383 
    384 	var_cont* C = var_gthan_eq(A, B);
    385 
    386 	stk_push(ctx->stack, C);
    387 
    388 	pc_inc(ctx->pc, 1);
    389 }
    390 void _ins_def_EQ       (rt_t* ctx, bc_cont* line)
    391 {
    392 	var_cont* A = stk_pop(ctx->stack);
    393 	var_cont* B = stk_pop(ctx->stack);
    394 
    395 	var_cont* C = var_eq(A, B);
    396 
    397 	stk_push(ctx->stack, C);
    398 
    399 	pc_inc(ctx->pc, 1);
    400 }
    401 void _ins_def_NEQ       (rt_t* ctx, bc_cont* line)
    402 {
    403 	var_cont* A = stk_pop(ctx->stack);
    404 	var_cont* B = stk_pop(ctx->stack);
    405 
    406 	var_cont* C = var_eq(A, B);
    407 
    408 	C = var_not(C);
    409 
    410 	stk_push(ctx->stack, C);
    411 
    412 	pc_inc(ctx->pc, 1);
    413 }
    414 
    415 void _ins_def_NOT      (rt_t* ctx, bc_cont* line)
    416 {
    417 	var_cont* A = stk_pop(ctx->stack);
    418 
    419 	var_cont* C = var_not(A);
    420 
    421 	stk_push(ctx->stack, C);
    422 
    423 	pc_inc(ctx->pc, 1);
    424 }
    425 void _ins_def_OR       (rt_t* ctx, bc_cont* line)
    426 {
    427 	pc_inc(ctx->pc, 1);
    428 }
    429 void _ins_def_AND      (rt_t* ctx, bc_cont* line)
    430 {
    431 	pc_inc(ctx->pc, 1);
    432 }
    433 
    434 /* HELPER FUNCTIONS */
    435 void _ins_def_loop_break(rt_t* ctx)
    436 {
    437 	while (pc_safe(ctx->pc))
    438 	{
    439 		pc_update(ctx->pc);
    440 		pc_inc(ctx->pc, 1);
    441 
    442 		if (ctx->pc->line->op == 0x6F)
    443 		{
    444 			break;
    445 		}
    446 	}
    447 }
    448 /* END HELPER FUNCIONS */
    449 void _ins_def_STARTL   (rt_t* ctx, bc_cont* line)
    450 {
    451 	pc_branch(ctx->pc, ctx->pc->address);
    452 	pc_inc(ctx->pc, 1);
    453 }
    454 void _ins_def_CLOOP    (rt_t* ctx, bc_cont* line)
    455 {
    456 	var_cont* var = stk_pop(ctx->stack);
    457 
    458 	int value = var_data_get_G_INT(var);
    459 
    460 	if (value < 1)
    461 	{
    462 		pc_return(ctx->pc);
    463 		_ins_def_loop_break(ctx);
    464 	} else
    465 	{
    466 		pc_inc(ctx->pc, 1);
    467 	}
    468 }
    469 void _ins_def_BREAK    (rt_t* ctx, bc_cont* line)
    470 {
    471 	pc_return(ctx->pc);
    472 	
    473 	_ins_def_loop_break(ctx);
    474 }
    475 void _ins_def_ENDL     (rt_t* ctx, bc_cont* line)
    476 {
    477 	pc_return(ctx->pc);
    478 }
    479 
    480 /* HELPER FUNCTIONS */
    481 void _ins_def_branch_to_end_if(rt_t* ctx)
    482 {
    483 	int level = 0;
    484 	while (pc_safe(ctx->pc))
    485 	{
    486 		pc_inc(ctx->pc, 1);
    487 		pc_update(ctx->pc);
    488 
    489 		// Is this instruction another IF statement?
    490 		if (ctx->pc->line->op == 0x72)
    491 		{
    492 			// Increment the if statement depth counter
    493 			level++;
    494 		} else
    495 		// Is the instruction an ELSE statement?
    496 		if (ctx->pc->line->op == 0x73)
    497 		{
    498 			// We're done here if we're in our scope
    499 			if (level == 0) break;
    500 		} else
    501 		// Is the instruction a DONE statement?
    502 		if (ctx->pc->line->op == 0x7E)
    503 		{
    504 			// And we're not in another if statement, we're done here
    505 			if (level == 0) break;
    506 
    507 			level--;
    508 		}
    509 	}
    510 
    511 	pc_inc(ctx->pc, 1);
    512 }
    513 /* END HELPER FUNCTIONS */
    514 void _ins_def_GOTO     (rt_t* ctx, bc_cont* line)
    515 {
    516 	int value = var_data_get_G_INT(line->varg[0]);
    517 
    518 	pc_branch(ctx->pc, value);
    519 }
    520 void _ins_def_JUMPF    (rt_t* ctx, bc_cont* line)
    521 {
    522 	int value = var_data_get_G_INT(line->varg[0]);
    523 
    524 	pc_inc(ctx->pc, value);
    525 }
    526 void _ins_def_IFDO     (rt_t* ctx, bc_cont* line)
    527 {
    528 	// Get the value off the stack
    529 	var_cont* var = stk_pop(ctx->stack);
    530 	int value = var_data_get_G_INT(var);
    531 
    532 	// If the value is false, find an ELSE statement or DONE statement.
    533 	if (value < 1)
    534 	{
    535 		_ins_def_branch_to_end_if(ctx);
    536 	} else
    537 	{
    538 		pc_inc(ctx->pc, 1);
    539 	}
    540 }
    541 void _ins_def_ELSE     (rt_t* ctx, bc_cont* line)
    542 {
    543 	pc_inc(ctx->pc, 1);
    544 	_ins_def_branch_to_end_if(ctx);
    545 }
    546 void _ins_def_DONE     (rt_t* ctx, bc_cont* line)
    547 {
    548 	pc_inc(ctx->pc, 1);
    549 }
    550 void _ins_def_CALL     (rt_t* ctx, bc_cont* line)
    551 {
    552 	int scope = var_data_get_G_INT(line->varg[0]);
    553 	int name  = var_data_get_G_INT(line->varg[1]);
    554 
    555 	// Call the function
    556 	proc_function_call(ctx, scope, name);
    557 
    558 	pc_inc(ctx->pc, 1);
    559 }
    560 
    561 void _ins_def_GETN     (rt_t* ctx, bc_cont* line)
    562 {
    563 	int name = var_data_get_G_INT(line->varg[0]);
    564 
    565 	var_cont* obj = stk_pop(ctx->stack);
    566 
    567 	ns_t* object = object_get(obj);
    568 
    569 	var_cont* var = object_get_name(object, name);
    570 
    571 	stk_push(ctx->stack, var);
    572 
    573 	pc_inc(ctx->pc, 1);
    574 }
    575 void _ins_def_SETN     (rt_t* ctx, bc_cont* line)
    576 {
    577 	int name = var_data_get_G_INT(line->varg[0]);
    578 
    579 	var_cont* obj = stk_pop(ctx->stack);
    580 	var_cont* var = stk_pop(ctx->stack);
    581 
    582 	ns_t* object = object_get(obj);
    583 	var_cont* set = var_data_cpy(var);
    584 
    585 	object_set_name(object, name, set);
    586 
    587 	pc_inc(ctx->pc, 1);
    588 }
    589 void _ins_def_CALLM    (rt_t* ctx, bc_cont* line)
    590 {
    591 	int name = var_data_get_G_INT(line->varg[0]);
    592 	// Pop the stack to get the object
    593 	var_cont* obj = stk_pop(ctx->stack);
    594 	// Get the objects variable data
    595 	ns_t* object = object_get(obj);
    596 	// Get the method to call
    597 	var_cont* var = object_get_name(object, name);
    598 	var_data_func* func = var_data_get_FUNC(var);
    599 	// Push current namespace context
    600 	ns_ctx_push(ctx->varctx, ctx->vars);
    601 
    602 	// Set current namespace to objects namespace
    603 	ctx->vars = object;
    604 	// Call the function
    605 	proc_function_call_handle(ctx, func);
    606 	// Update the program counter
    607 	pc_update(ctx->pc);
    608 	// Run code here so we can pop the namespace context
    609 	proc_run_to_return(ctx);
    610 	// Pop the namespace context
    611 	ctx->vars = ns_ctx_pop(ctx->varctx);
    612 
    613 	pc_inc(ctx->pc, 1);
    614 }
    615 void _ins_def_INDEXO   (rt_t* ctx, bc_cont* line)
    616 {
    617 	pc_inc(ctx->pc, 1);
    618 }
    619 void _ins_def_MODO     (rt_t* ctx, bc_cont* line)
    620 {
    621 	pc_inc(ctx->pc, 1);
    622 }
    623 
    624 void _ins_def_RETURN   (rt_t* ctx, bc_cont* line)
    625 {
    626 	// Pop a level in the stack and arguement stack
    627 	stk_poplevel(&ctx->stack);
    628 	stk_poplevel(&ctx->argstk);
    629 
    630 	// Pop the namespace and get the return value
    631 	var_cont* return_value = ns_pop(ctx->vars);
    632 
    633 	if (return_value->type != VOID)
    634 	{
    635 		// Push the return value to the stack
    636 		stk_push(ctx->stack, return_value);
    637 	}
    638 	else
    639 	{
    640 		var_del(return_value);
    641 	}
    642 
    643 	// Return to the callee
    644 	pc_return(ctx->pc);
    645 }
    646 void _ins_def_NEW      (rt_t* ctx, bc_cont* line)
    647 {
    648 	int scope = var_data_get_G_INT(line->varg[0]);
    649 	int name  = var_data_get_G_INT(line->varg[1]);
    650 
    651 	// Get the object builder
    652 	var_cont* var = proc_getvar(ctx, scope, name);
    653 	var_data_objbldr* builder = var_data_get_OBJBLDR(var);
    654 
    655 	// Init a new namespace of proper size
    656 	ns_t* new_ns = ns_init(builder->size);
    657 
    658 	// Push current namespace to namespace context
    659 	ns_ctx_push(ctx->varctx, ctx->vars);
    660 
    661 	// Set the current namespace to new namespace
    662 	ctx->vars = new_ns;
    663 
    664 	int offset = 1;
    665 	int i;
    666 	for (i = 0; i < builder->paramlen; i++)
    667 	{
    668 		// Pop the arguement stack
    669 		var_cont* arg = stk_pop(ctx->argstk);
    670 
    671 		// Is the arguement of the right type?
    672 		ASSERT(arg->type == builder->param[i], "Invalid arguement stack\n");
    673 
    674 		// Declare the name in the new namespace and pass the arguements
    675 		ns_dec(ctx->vars, arg->type, 0, i+offset);
    676 		ns_set(ctx->vars, 0, i+offset, arg);
    677 	}
    678 	// Push new stack levels for the stack and the arguement stack
    679 	stk_newlevel(&ctx->stack);
    680 	stk_newlevel(&ctx->argstk);
    681 
    682 	pc_branch(ctx->pc, builder->loc);
    683 }
    684 void _ins_def_ENDCLASS (rt_t* ctx, bc_cont* line)
    685 {
    686 	var_cont* new = var_new(OBJECT);
    687 
    688 	var_set(new, ctx->vars, OBJECT);
    689 
    690 	ns_dec(ctx->vars, OBJECT, 1, 0);
    691 	ns_set(ctx->vars, 1, 0, new);
    692 
    693 	stk_poplevel(&ctx->stack);
    694 	stk_poplevel(&ctx->argstk);
    695 
    696 	ctx->vars = ns_ctx_pop(ctx->varctx);
    697 
    698 	stk_push(ctx->stack, new);
    699 
    700 	pc_return(ctx->pc);
    701 	pc_inc(ctx->pc, 1);
    702 }
    703 void _ins_def_DENS     (rt_t* ctx, bc_cont* line)
    704 {
    705 	int name = var_data_get_G_INT(line->varg[0]);
    706 
    707 	ns_t* namespace = ns_init(MAXIMUM_TRACKING_VARS);
    708 
    709 	var_cont* ns_var = var_new(OBJECT);
    710 	var_set(ns_var, namespace, OBJECT);
    711 
    712 	ns_dec(ctx->names, OBJECT, 1, name);
    713 	ns_set(ctx->names, 1, name, ns_var);
    714 
    715 	ctx->vars = namespace;
    716 }
    717 void _ins_def_DECLASS  (rt_t* ctx, bc_cont* line)
    718 {
    719 	int     name = var_data_get_G_INT(line->varg[0]);
    720 	b_type* args = var_data_get_PLIST(line->varg[1]);
    721 	size_t  alen = line->sarg[1];
    722 
    723 	// Create a new variable for the object builder
    724 	var_cont* obj = var_new(OBJBLDR);
    725 
    726 	// Allocate memory for this variable
    727 	var_data_objbldr* data = var_data_alloc_OBJBLDR();
    728 
    729 	// Set this objects ID
    730 	data->id  = name;
    731 	// Set the location
    732 	data->loc = line->real_addr + 1;
    733 
    734 	/* Determine namespace size for this object
    735 	 */
    736 	int nsize;
    737 	for (nsize = 0; pc_safe(ctx->pc);)
    738 	{
    739 		// Are we at the end of the object builder?
    740 		if (ctx->pc->line->op == 0xF2)
    741 		{
    742 			break;
    743 		} else
    744 		// Are we declaring a variable or function?
    745 		if (ctx->pc->line->op == 0x20 || ctx->pc->line->op == 0xFF)
    746 		{
    747 			nsize++;
    748 		}
    749 
    750 		pc_inc(ctx->pc, 1);
    751 		pc_update(ctx->pc);
    752 	}
    753 
    754 	data->end      = ctx->pc->line->real_addr;
    755 	data->size     = nsize + alen + 1;
    756 	data->paramlen = alen;
    757 	data->param    = args;
    758 
    759 	// Throw the data in a variable container
    760 	var_set(obj, data, OBJBLDR);
    761 
    762 	// Declare a name for this object
    763 	proc_decvar(ctx, OBJBLDR, 1, name);
    764 	// Set the object to the name we just declared
    765 	proc_setvar(ctx, 1, name, obj);
    766 
    767 	pc_inc(ctx->pc, 1);
    768 	pc_update(ctx->pc);
    769 }
    770 void _ins_def_DEFUN    (rt_t* ctx, bc_cont* line)
    771 {
    772 	int     name = var_data_get_G_INT(line->varg[0]);
    773 	b_type  type = var_data_get_TYPE(line->varg[1]);
    774 	b_type* args = var_data_get_PLIST(line->varg[2]);
    775 	size_t  alen = line->sarg[2];
    776 
    777 	// Create a new variable for the new function
    778 	var_cont* func = var_new(FUNC);
    779 
    780 	// Allocate the data.
    781 	var_data_func* data = var_data_alloc_FUNC(type);
    782 
    783 	// Set the location of the functions body
    784 	data->loc = line->real_addr + 1;
    785 
    786 	int nsize;
    787 	/* Determine the namespace size by finding variable declarations in the
    788 	   functions body, Along with determining the end of the function.
    789 	 */
    790 	for (nsize = 0; pc_safe(ctx->pc);)
    791 	{
    792 		// Is this the end?
    793 		if (ctx->pc->line->op == 0xF0)
    794 		{
    795 			break;
    796 		} else
    797 		// Are we declaring a variable?
    798 		if (ctx->pc->line->op == 0x20)
    799 		{
    800 			// If so, increment the namespace size.
    801 			nsize++;
    802 		}
    803 
    804 		// Increment the program counter
    805 		pc_inc(ctx->pc, 1);
    806 		pc_update(ctx->pc);
    807 	}
    808 
    809 	pc_update(ctx->pc);
    810 	// Set all the values.
    811 	data->end      = ctx->pc->line->real_addr; // This is the end!
    812 	data->size     = nsize + alen + 1;         // How many names will this
    813 	                                           // function have?
    814 	data->type     = type;                     // Return type
    815 	data->paramlen = alen;                     // Set the arguement length
    816 	data->param    = args;                     // Set the parameter list
    817 
    818 	// Throw the data in a variable container
    819 	var_set(func, data, FUNC);
    820 
    821 	// Declare a name
    822 	proc_decvar(ctx, FUNC, 1, name);
    823 	// Set the name's value to the function we just defined
    824 	proc_setvar(ctx, 1, name, func);
    825 
    826 	pc_inc(ctx->pc, 1);
    827 	pc_update(ctx->pc);
    828 }
	language some fools attempt at an interpreted language
	Log \| Files \| Refs \| README