entity.cpp

一个RPG术语查询器

					done=0;
					workingloc=swapper+sizeof(int);
					while(done==0)
					{
						switch(*(int *)(ram + workingloc))
						{
							case DWORD:
								pstack[pstackpointer].type=DWORD;
								pstack[pstackpointer].dword=*(int *)(ram+address);
								pstack[pstackpointer].address=address;
								++pstackpointer;
								--stackpointer;
								*(int *)(ram+address)=stack[stackpointer];
								address+=sizeof(int);
								break;
							case FLOATER:
								pstack[pstackpointer].type=FLOATER;
								pstack[pstackpointer].floater=*(double *)(ram+address);
								pstack[pstackpointer].address=address;
								++pstackpointer;
								--fstackpointer;
								*(double *)(ram+address)=fstack[fstackpointer];
								address+=sizeof(double);
								break;
							
							case ENDPARAMS:
								done=1;
								break;

							default:
//								std::cout << "INVALID DATA TYPE IN FRAME PROTOTYPE" << std::endl;
								operational=0;
								return cycles;
								break;

						}
						workingloc+=sizeof(int);
						

					}
					
					break;
				

				case FRETURN:
					
					done=0;
					while(done==0)
					{
						--pstackpointer;
#if defined DEBUG						
						if(pstackpointer<0)
						{
//							std::cout << "FUNCTION FRAME PRESERVER STACK UNDERFLOW!" << std::endl;
							operational=0;
							return cycles;
						}
#endif
						switch(pstack[pstackpointer].type)
						{
							case DWORD:
								
								address=pstack[pstackpointer].address;

								*(int *)(ram+address) = pstack[pstackpointer].dword;
								
								break;
							case FLOATER:
								writedouble.data=pstack[pstackpointer].floater;
								address=pstack[pstackpointer].address;
								for(writeiterate=0;writeiterate<sizeof(double);++writeiterate)
								{
									ram[address+writeiterate]=writedouble.bytes[writeiterate];
								}
								break;
							case BYTE:
								address=pstack[pstackpointer].address;
								ram[address]=pstack[pstackpointer].byte;
								break;

							case RETURNADDRESS:
								codepointer=pstack[pstackpointer].address;
								done=1;
								break;
							default:
//								std::cout << "INVALID PRESERVE TYPE: YOU PROBLY SHOULDN'T SEE THIS" << std::endl;
								operational=0;
								return cycles;
								break;

						}

					}
					
					break;
	

				case PRESERVE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					switch(stack[stackpointer+1])
					{
						case DWORD:
							pstack[pstackpointer].dword = *(int *)(ram+stack[stackpointer]);
							pstack[pstackpointer].type=DWORD;
							pstack[pstackpointer].address=stack[stackpointer];
							++pstackpointer;
							break;
						
						default:
//							std::cout << "Preserve debug address: " << stack[stackpointer] << std::endl;
//							std::cout << "Preserve type " << stack[stackpointer+1] << " not handled yet!" << std::endl;
							operational=0;
							return cycles;
					}

					break;
				
				case RESTORE:
					codepointer+=sizeof(int);
					--pstackpointer;					
					switch(pstack[pstackpointer].type)
					{
						case DWORD:
							*(int *)(ram+pstack[pstackpointer].address) = pstack[pstackpointer].dword;
							break;
						default:
//							std::cout << "Restore type " << pstack[pstackpointer].type << " not handled yet!" << std::endl;
							operational=0;
							return cycles;
					}

					break;

				case CLONE:
					codepointer+=sizeof(int);
					stack[stackpointer]=stack[stackpointer-1];
					++stackpointer;
					break;

				case CONVERT:
					codepointer+=sizeof(int);
					--stackpointer;
					fstack[fstackpointer]=(double)stack[stackpointer];
					++fstackpointer;
					break;
				
				case ADD:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] += stack[stackpointer+1];
					++stackpointer;
					break;
				
				case SUB:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] -= stack[stackpointer+1];
					++stackpointer;
					break;
				
				case MUL:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] *=stack[stackpointer+1];
					++stackpointer;
					break;

				case DIV:
					codepointer+=sizeof(int);
					stackpointer-=2;
					if(stack[stackpointer+1]==0)
					{
//						std::cout << "ERR: DIVISION BY 0" << std::endl;
						operational=0;
						return cycles;
					}
					stack[stackpointer] = stack[stackpointer] / stack[stackpointer+1];
					++stackpointer;
					break;
				case AND:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] & stack[stackpointer+1];
					++stackpointer;
					break;
					
				case OR:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] | stack[stackpointer+1];
					++stackpointer;
					break;
				
				case XOR:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] ^ stack[stackpointer+1];
					++stackpointer;
					break;

				case NOT:
					codepointer+=sizeof(int);
					--stackpointer;
					stack[stackpointer]=~stack[stackpointer];
					++stackpointer;
					break;


				case EXP:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = (int) pow(stack[stackpointer], stack[stackpointer+1]);
					++stackpointer;
					break;
				
				case MOD:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] % stack[stackpointer+1];
					++stackpointer;
					break;
				
				case SHR:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] >> stack[stackpointer+1];
					++stackpointer;
					break;

				case SHL:
					codepointer+=sizeof(int);
					stackpointer-=2;
					stack[stackpointer] = stack[stackpointer] << stack[stackpointer+1];
					++stackpointer;
					break;
				


				case CMP:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=0;
					bitflags.cmpbit.equal = (stack[stackpointer] == stack[stackpointer+1]);
					bitflags.cmpbit.greaterthan = (stack[stackpointer] > stack[stackpointer+1]) ;
					bitflags.cmpbit.notequal = (stack[stackpointer] != stack[stackpointer+1]);
					bitflags.cmpbit.lessthan = (stack[stackpointer] < stack[stackpointer+1]);
					bitflags.cmpbit.greaterthan = (stack[stackpointer] > stack[stackpointer+1]);
					bitflags.cmpbit.greaterthanequal = (stack[stackpointer] >= stack[stackpointer+1]);
					bitflags.cmpbit.lessthanequal = (stack[stackpointer] <= stack[stackpointer+1]);
					stack[stackpointer]=bitflags.cmpint;
					++stackpointer;
					break;
				
				case JMP:
					--stackpointer;
#if defined DEBUG
					if(stack[stackpointer]<0 || stack[stackpointer]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					codepointer=stack[stackpointer];
					break;


				
				case JME:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG					
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif
					if(bitflags.cmpbit.equal!=0) codepointer=stack[stackpointer+1];
					break;
				
				case JML:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG	
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					if(bitflags.cmpbit.lessthan!=0) codepointer=stack[stackpointer+1];
					break;


				
				case JMG:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG					
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					if(bitflags.cmpbit.greaterthan!=0) codepointer=stack[stackpointer+1];
					break;
				
				
				case JLE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG					
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					if(bitflags.cmpbit.lessthanequal!=0) codepointer=stack[stackpointer+1];
					break;

				case JGE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG					
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					if(bitflags.cmpbit.greaterthanequal!=0) codepointer=stack[stackpointer+1];
					break;
				
				case JNE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					bitflags.cmpint=stack[stackpointer];
#if defined DEBUG
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID JMP POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
#endif					
					if(bitflags.cmpbit.notequal!=0) codepointer=stack[stackpointer+1];
					break;

				
				case LOAD:
					codepointer+=sizeof(int);
					--stackpointer;
					address=stack[stackpointer];
#if defined DEBUG
					if(address<0 || address>(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID LOAD POINTER: " << address << std::endl;
						operational=0;
						return cycles;
					}
#endif
					stack[stackpointer]=*(int *)(ram+address);
					++stackpointer;
					break;
				
				case STORE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					address=stack[stackpointer+1];
#if defined DEBUG
					
					if(address<0 || address>(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID STORE POINTER: " << address << std::endl;
						operational=0;
						return cycles;
					}
#endif
					*(int *)(ram+address) = stack[stackpointer];

					break;


				case RSTORE:
					codepointer+=sizeof(int);
					stackpointer-=2;
					address=stack[stackpointer];
#if defined DEBUG
					
					if(address<0 || address>(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID STORE POINTER: " << address << std::endl;
						operational=0;
						return cycles;
					}
#endif
					*(int *)(ram+address) = stack[stackpointer+1];
					break;

				
				case STOREB:
					codepointer+=sizeof(int);
					stackpointer-=2;
					if(stack[stackpointer+1]<0 || stack[stackpointer+1]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID STOREB POINTER: " << stack[stackpointer+1] << std::endl;
						operational=0;
						return cycles;
					}
					ram[stack[stackpointer+1]] = (char)stack[stackpointer];
					break;
				

				case LOADB:
					codepointer+=sizeof(int);
					--stackpointer;
					if(stack[stackpointer]<0 || stack[stackpointer]>(int)(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID LOAD POINTER: " << stack[stackpointer] << std::endl;
						operational=0;
						return cycles;
					}
					stack[stackpointer]=(int)ram[stack[stackpointer]];
					++stackpointer;
					break;
				


				case INCL:
					codepointer+=sizeof(int);
					--stackpointer;
					address=stack[stackpointer];
#if defined DEBUG
					if(address<0 || address>(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID INCL POINTER: " << address << std::endl;
						operational=0;
						return cycles;
					}
#endif
					
					stack[stackpointer]=++*(int *)(ram+address);
					++stackpointer;
					break;

				case DECL:
				
					codepointer+=sizeof(int);
					--stackpointer;
					address=stack[stackpointer];
#if defined DEBUG
					if(address<0 || address>(sizeram-sizeof(int)))
					{
//						std::cout << "INVALID DECL POINTER: " << address << std::endl;
						operational=0;
						return cycles;
					}
#endif
					stack[stackpointer]=--*(int *)(ram+address);
					++stackpointer;
					break;
									
				case API:
					//API PROCESSING
					codepointer+=sizeof(int);
					--stackpointer;
					MASTER->api.exec((char *)(ram + stack[stackpointer]),this);
					break;

				

				case SYS:
					//SYSTEM PROCESSING
					codepointer+=sizeof(int);
					--stackpointer;
					switch(stack[stackpointer])
					{


						//INSERT SYSTEM ROUTINES HERE :D


						case sys_write:
							--stackpointer;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_write: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;
							}
							std::cout << (char *)(ram + stack[stackpointer]);
							break;
						case sys_read:
							stackpointer-=2;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_read: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;
							}
							std::cin.getline((char *)(ram + stack[stackpointer]),stack[stackpointer+1]);
							break;
						case sys_sort:
							stackpointer-=2;
							base=(int *)&ram[stack[stackpointer]];  //Address of int array
							address=stack[stackpointer+1];  //Sort elements

							while(done>0)
							{
								done=0;
								for(writeiterate=1;writeiterate<address;++writeiterate)
								{
									if(base[writeiterate]<base[writeiterate-1])
									{
										writes=base[writeiterate];
										base[writeiterate]=base[writeiterate-1];
										base[writeiterate-1]=writes;
										++done;
									}
								}
							}

							break;
																			
						case sys_atoi:
							--stackpointer;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_atoi: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;
							}
							stack[stackpointer]=atoi((char *)(ram + stack[stackpointer]));
							++stackpointer;
							break;

						case sys_itoa:
							stackpointer-=2;
							if(stack[stackpointer+1]<0 || stack[stackpointer+1]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_itoa: " << stack[stackpointer+1] << std::endl;
								operational=0;
								return cycles;
							}
							sprintf((char *)(ram + stack[stackpointer+1]),"%i",stack[stackpointer]);
							break;
						
						case sys_atof:
							--stackpointer;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_atof: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;
							}
							fstack[fstackpointer]=atof((char *)(ram + stack[stackpointer]));
							++fstackpointer;
							break;

						case sys_ftoa:
							--stackpointer;
							--fstackpointer;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID POINTER FOR sys_ftoa: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;