entity.cpp

一个RPG术语查询器

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

						case sys_putchar:
							--stackpointer;
							std::cout << (char)stack[stackpointer];
							break;
											
						case sys_endl:
							std::cout << std::endl;
							break;
						case sys_szdouble:
							stack[stackpointer]=sizeof(double);
							++stackpointer;
							break;
						case sys_szint:
							stack[stackpointer]=sizeof(int);
							++stackpointer;
							break;

						case sys_thread:
							--stackpointer;
							if(stack[stackpointer]<0 || stack[stackpointer]>=sizeram)
							{
//								std::cout << "INVALID CODE POINTER FOR sys_thread: " << stack[stackpointer] << std::endl;
								operational=0;
								return cycles;
							}
							
							AddThread(stack[stackpointer]);
							stack[stackpointer]=threads;
							++stackpointer;
							break;


						case sys_yield:
							--stackpointer;
							yield=stack[stackpointer];
							return cycles;
							break;
						
	
					}

					break;


				case EXIT:
#ifdef DEBUG
//					std::cout << "Stackpointer: " << stackpointer << std::endl;
#endif
					operational=0;
					return cycles;
					break;
					
					
					
					
					
		//ENTER THE FLOATING POINT MATH :boing:

				case PUSHF:
					
					if(fstackpointer>=STACKSIZE)
					{
//						std::cout << "ERR: FSTACK OVERFLOW" << std::endl;
						operational=0;
						return cycles;
					}
				
					codepointer+=sizeof(int);
					
					for(writeiterate=0;writeiterate<sizeof(double);++writeiterate)
					{
						writedouble.bytes[writeiterate]=ram[codepointer+writeiterate];
					}
					
					fstack[fstackpointer]=writedouble.data;
					codepointer+=sizeof(double);
					++fstackpointer;
					break;
								
				case POPF:
					codepointer+=sizeof(int);
					if(fstackpointer<0)
					{
//						std::cout << "ERR: FSTACK UNDERFLOW" << std::endl;
						operational=0;
						return cycles;
					}

					
					--fstackpointer;
					break;
				
				case CLONEF:
					codepointer+=sizeof(int);
					fstack[fstackpointer]=fstack[fstackpointer-1];
					++fstackpointer;
					break;
				
				case CONVERTF:
					codepointer+=sizeof(int);
					--fstackpointer;
					stack[stackpointer]=(int)fstack[fstackpointer];
					++stackpointer;
					break;
						


				case ADDF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					fstack[fstackpointer] = fstack[fstackpointer] + fstack[fstackpointer+1];
					++fstackpointer;
					break;
								
				case SUBF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					fstack[fstackpointer] = fstack[fstackpointer] - fstack[fstackpointer+1];
					++fstackpointer;
					break;
				
							
				case DIVF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					if(fstack[fstackpointer+1]==0)
					{
//						std::cout << "ERR: DIVISION BY 0" << std::endl;
						operational=0;
						return cycles;
					}
					fstack[fstackpointer] = fstack[fstackpointer] / fstack[fstackpointer+1];
					++fstackpointer;
					break;


				case MULF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					fstack[fstackpointer] = fstack[fstackpointer] * fstack[fstackpointer+1];
					++fstackpointer;
					break;


				case EXPF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					fstack[fstackpointer] = pow(fstack[fstackpointer],fstack[fstackpointer+1]);
					++fstackpointer;
					break;
					
				case MODF:
					codepointer+=sizeof(int);
					fstackpointer-=2;
					fstack[fstackpointer] = fmod(fstack[fstackpointer],fstack[fstackpointer+1]);
					++fstackpointer;
					break;

				case SQRTF:
					codepointer+=sizeof(int);
					--fstackpointer;
					fstack[fstackpointer]=sqrt(fstack[fstackpointer]);
					++fstackpointer;
					break;

				case COSF:
					codepointer+=sizeof(int);
					--fstackpointer;
					fstack[fstackpointer]=cos(fstack[fstackpointer]);
					++fstackpointer;
					break;

				case SINF:
					codepointer+=sizeof(int);
					--fstackpointer;
					fstack[fstackpointer]=sin(fstack[fstackpointer]);
					++fstackpointer;
					break;

				case TANF:
					codepointer+=sizeof(int);
					--fstackpointer;
					fstack[fstackpointer]=tan(fstack[fstackpointer]);
					++fstackpointer;
					break;

				
				case CMPF:
					bitflags.cmpint=0;
					codepointer+=sizeof(int);
					fstackpointer-=2;
					bitflags.cmpbit.equal = (fstack[fstackpointer] == fstack[fstackpointer+1]);
					bitflags.cmpbit.greaterthan = (fstack[fstackpointer] > fstack[fstackpointer+1]);
					bitflags.cmpbit.notequal = (fstack[fstackpointer] != fstack[fstackpointer+1]);
					bitflags.cmpbit.lessthan = (fstack[fstackpointer] < fstack[fstackpointer+1]);
					bitflags.cmpbit.greaterthan = (fstack[fstackpointer] > fstack[fstackpointer+1]);
					bitflags.cmpbit.greaterthanequal = (fstack[fstackpointer] >= fstack[fstackpointer+1]);
					bitflags.cmpbit.lessthanequal = (fstack[fstackpointer] <= fstack[fstackpointer+1]);
					stack[stackpointer]=bitflags.cmpint;
					++stackpointer;
					break;
				
				
							
				case LOADF:
					codepointer+=sizeof(int);
					--stackpointer;
					if(stack[stackpointer]<0 || stack[stackpointer]>(int)(sizeram-sizeof(double)))
					{
//						std::cout << "INVALID LOAD POINTER: " << stack[stackpointer] << std::endl;
						operational=0;
						return cycles;
					}
					for(writeiterate=0;writeiterate<sizeof(double);++writeiterate)
					{
						writedouble.bytes[writeiterate]=ram[stack[stackpointer]+writeiterate];
					}
					fstack[fstackpointer]=writedouble.data;
					
					
					++fstackpointer;
					break;

				case STOREF:
					codepointer+=sizeof(int);
					--stackpointer;
					if(stack[stackpointer]<0 || stack[stackpointer]>(int)(sizeram-sizeof(double)))
					{
//						std::cout << "INVALID STOREF POINTER: " << stack[stackpointer] << std::endl;
						operational=0;
						return cycles;
					}
					--fstackpointer;
					writedouble.data=fstack[fstackpointer];
					for(writeiterate=0;writeiterate<sizeof(double);++writeiterate)
					{
						ram[stack[stackpointer]+writeiterate]=writedouble.bytes[writeiterate];
					}
					break;

				
				
								
				default:
//					std::cout << "ERR: INVALID OPCODE (" << (int)ram[codepointer] << ") AT :" << codepointer << std::endl;
					operational=0;
					return cycles;
					break;

			}
			
		}

		return cycles;



	}



THREAD * THREAD::AddThread(int startpoint)
	{
		
		THREAD *crawler=this;
		while(1)
		{
			if(crawler->operational==0)
			{
				crawler->operational=OPERATE;
				crawler->yield=0;
				crawler->fstackpointer=0;
				crawler->stackpointer=0;
				crawler->pstackpointer=0;
				crawler->codepointer=startpoint;
				return crawler;

			}
			
			if(crawler->next==NULL)
			{
				THREAD * newthread =new THREAD(ram,sizeram,startpoint,owner);
				if(newthread==NULL)
				{
//					std::cout << "UNABLE TO START NEW THREAD, DISABLING" << std::endl;
					return NULL;
				}
				crawler->next = newthread;
				newthread->parent=crawler;
				return newthread;
			}
			crawler=crawler->next;
		}

	}


int THREAD::GetThreads()
{
	return threads;
}

THREAD::~THREAD()
{
	--threads;
}
	

VMOBJ::~VMOBJ()
{
	KillEntries(processes);
	if(ram!=NULL) delete[] ram;
}

VMOBJ::VMOBJ()
{
		owner=NULL;
		processes=NULL;
		operational=0;
		sizeram=-1;
		ram = NULL;
		
}

void VMOBJ::setram(void *mymaster)
{
	owner=mymaster;
}


		
void VMOBJ::loadbinary(char *file)
{
        operational = 0;
		if(file==NULL) return;
//		std::cout << "BOOT " << file;
		FILE *loader=fopen(file,"rb");
		if(loader==NULL)
		{
//			std::cout << " MISSING, DISABLING" << std::endl;
			return;
		}
		
       	#define BENDIAN 0
    	#define LENDIAN 1
    	
    	int mendian = BENDIAN;
        union endian {int huhu; char a[sizeof(int)];}; endian bleh;	bleh.huhu=1;
        if(bleh.a[0]==1) mendian = LENDIAN;

        char fendian;
        char szdouble;
        char szint;
        char version[8];
        int numops;
        int startaddress;

        int test;
        test = fread(&fendian,1,1,loader);
        test = fread(&szdouble,1,1,loader);
        test = fread(&szint,1,1,loader);
        test = fread(version,1,8,loader);
        
        if(szdouble!=sizeof(double) || szint!=sizeof(int))
        {
//            std::cout << "Data size mismatch, disabling!" << std::endl;
            operational = 0;
        	fclose(loader);
			return;
        }
                

        if(fendian==BENDIAN && mendian==LENDIAN)
        {
//            std::cout << "Endian mismatch.  Attempting to fix.  :gulp:" << std::endl;
//            std::cout << "Endian in file is big.  This machine is little." << std::endl;
   	        int *endianconvert;
            unsigned char *fakeram;
            
            fakeram = (unsigned char*)&numops;
            endianconvert = (int *)&numops;
            test = fread(&numops,1,sizeof(int),loader);
            *endianconvert = fakeram[3] | (fakeram[2] << 8) | (fakeram[1] << 16) | (fakeram[0] << 24);

            fakeram = (unsigned char*)&startaddress;
            endianconvert = (int *)&startaddress;
            test = fread(&startaddress,1,sizeof(int),loader);
            *endianconvert = fakeram[3] | (fakeram[2] << 8) | (fakeram[1] << 16) | (fakeram[0] << 24);
//            std::cout << "Size: " << numops << "  Start: " << startaddress << std::endl;
	        int left = numops;
	        int adder = 0;
            ram = new char[numops];
            sizeram=numops;
            fakeram = (unsigned char*)ram;
	        while(left>=sizeof(int))
	        {
	           test = fread(&fakeram[adder],1,numops,loader);
	           endianconvert = (int *)&fakeram[adder];
	           *endianconvert = fakeram[adder+3] | (fakeram[adder+2] << 8) | (fakeram[adder+1] << 16) | (fakeram[adder] << 24);
               adder+=sizeof(int);
	           left-=sizeof(int);
            }
            if(left>0)
            {
//                std::cout << "Uhoh, extra garbage." << std::endl;
            }
            
       
        }
        else if(fendian==LENDIAN && mendian==BENDIAN)
        {
//            std::cout << "Endian mismatch.  Attempting to fix.  :gulp:" << std::endl;
//            std::cout << "Endian in file is little.  This machine is big." << std::endl;
   	        int *endianconvert;
            unsigned char *fakeram;
            
            fakeram = (unsigned char*)&numops;
            endianconvert = (int *)&numops;
            test = fread(&numops,1,sizeof(int),loader);
            *endianconvert = fakeram[0] | (fakeram[1] << 8) | (fakeram[2] << 16) | (fakeram[3] << 24);

            fakeram = (unsigned char*)&startaddress;
            endianconvert = (int *)&startaddress;
            test = fread(&startaddress,1,sizeof(int),loader);
            *endianconvert = fakeram[0] | (fakeram[1] << 8) | (fakeram[2] << 16) | (fakeram[3] << 24);
//            std::cout << "Size: " << numops << "  Start: " << startaddress << std::endl;
	        int left = numops;
	        int adder = 0;
            ram = new char[numops];
            sizeram=numops;
            fakeram = (unsigned char*)ram;
	        while(left>=sizeof(int))
	        {
	           test = fread(&fakeram[adder],1,numops,loader);
	           endianconvert = (int *)&fakeram[adder];
	           *endianconvert = fakeram[adder] | (fakeram[adder+1] << 8) | (fakeram[adder+2] << 16) | (fakeram[adder+3] << 24);
               adder+=sizeof(int);
	           left-=sizeof(int);
            }
            if(left>0)
            {
//                std::cout << "Uhoh, extra garbage." << std::endl;
            }

        
        }
        else if(fendian == mendian)
        {
                      

            test = fread(&numops,1,sizeof(int),loader);
            test = fread(&startaddress,1,sizeof(int),loader);

            ram = new char[numops];
            sizeram=numops;
            test = fread(ram,1,numops,loader);
    		if(test!=numops)
	        {
    			fclose(loader);
    			return;
	       	}
            
        
        
        }
        else
        {
//            std::cout << "Broken endian!  Disabling!" << std::endl;
            operational = 0;
       		fclose(loader);
   			return;
           
        }
             





        int codepointer=startaddress;
		if(codepointer<0 || codepointer>=sizeram)
		{
//			std::cout << "INVALID START ADDRESS, DISABLING" << std::endl;
			fclose(loader);
			return;
		}
         

//		std::cout << " OK" << std::endl;
		fclose(loader);
//		std::cout << "READY" << std::endl;
		processes=new THREAD(ram,sizeram,codepointer, owner);
		if(processes) operational=OPERATE;			
//		else std::cout << "UNABLE TO ALLOCATE THREAD, DISABLING" << std::endl;

	}
	
void VMOBJ::RemoveProcess(THREAD *pskill)
	{
		if(pskill==NULL) return;
		if(pskill->parent!=NULL)
		{
			pskill->parent->next=pskill->next;
		
		}
		if(pskill->next!=NULL)
		{
			pskill->next->parent=pskill->parent;
		}
		delete pskill;
		

	}


void VMOBJ::KillEntries(THREAD *root)
{
	if(root == NULL) return;
	KillEntries(root->next);
	delete root;
}

int VMOBJ::Execute(int cycles)
	{
		operational=processes->operational;
		if(operational!=OPERATE)
		{
			return cycles;
		}
		
		
		if(processes!=NULL)
		{
			THREAD *crawler = processes;
			while(crawler!=NULL)
			{
				if(crawler->operational==OPERATE)
				{
					crawler->ExecObj(cycles);
				}
				crawler=crawler->next;
			}
		}

		return cycles;
	}