Main Page | Class List | File List | Class Members | File Members

instructions.cpp

Go to the documentation of this file.
00001 00002 #include <iostream> 00003 00004 #include "instructions.h" 00005 #include "world.h" 00006 00007 00008 #define process2entity(PROC) *static_cast<entity*>(&(PROC.getProgram())) 00009 #define vm2world(VM) *static_cast<world*>(&VM) 00010 00011 00012 void instr_null(virtualMachine& vm, process& proc, thread& t) 00013 { 00014 world& w = vm2world(vm); 00015 entity& ent = process2entity(proc); 00016 program& prog = proc.getProgram(); 00017 00018 w.releaseEnergy(1, ent); 00019 00020 t+=sizeof(instruction); 00021 t = prog.read<address>(t); 00022 } 00023 00024 00025 void instr_increment(virtualMachine& vm, process& proc, thread& t) 00026 { 00027 world& w = vm2world(vm); 00028 entity& ent = process2entity(proc); 00029 address next, addr; 00030 char data; 00031 program& prog = proc.getProgram(); 00032 00033 w.releaseEnergy(1, ent); 00034 00035 t+=sizeof(instruction); 00036 next = prog.read<address>(t); 00037 00038 t+=sizeof(address); 00039 addr = prog.read<address>(t); 00040 data = prog.read<char>(addr); 00041 ++data; 00042 prog.write(addr, data); 00043 00044 t = next; 00045 } 00046 00047 00048 void instr_and(virtualMachine& vm, process& proc, thread& t) 00049 { 00050 world& w = vm2world(vm); 00051 entity& ent = process2entity(proc); 00052 address next, addr; 00053 char data; 00054 program& prog = proc.getProgram(); 00055 00056 w.releaseEnergy(1, ent); 00057 00058 t+=sizeof(instruction); 00059 next = prog.read<address>(t); 00060 00061 t+=sizeof(address); 00062 addr = prog.read<address>(t); 00063 data = prog.read<char>(addr); 00064 00065 t+=sizeof(address); 00066 addr = prog.read<address>(t); 00067 data &= prog.read<char>(addr); 00068 00069 t+=sizeof(address); 00070 addr = prog.read<address>(t); 00071 prog.write(addr, data); 00072 00073 t = next; 00074 } 00075 00076 00077 void instr_or(virtualMachine& vm, process& proc, thread& t) 00078 { 00079 world& w = vm2world(vm); 00080 entity& ent = process2entity(proc); 00081 address next, addr; 00082 char data; 00083 program& prog = proc.getProgram(); 00084 00085 w.releaseEnergy(1, ent); 00086 00087 t+=sizeof(instruction); 00088 next = prog.read<address>(t); 00089 00090 t+=sizeof(address); 00091 addr = prog.read<address>(t); 00092 data = prog.read<char>(addr); 00093 00094 t+=sizeof(address); 00095 addr = prog.read<address>(t); 00096 data |= prog.read<char>(addr); 00097 00098 t+=sizeof(address); 00099 addr = prog.read<address>(t); 00100 prog.write(addr, data); 00101 00102 t = next; 00103 } 00104 00105 00106 void instr_copy(virtualMachine& vm, process& proc, thread& t) 00107 { 00108 world& w = vm2world(vm); 00109 entity& ent = process2entity(proc); 00110 address next, addr; 00111 char data; 00112 program& prog = proc.getProgram(); 00113 00114 w.releaseEnergy(1, ent); 00115 00116 t+=sizeof(instruction); 00117 next = prog.read<address>(t); 00118 00119 t+=sizeof(address); 00120 addr = prog.read<address>(t); 00121 data = prog.read<char>(addr); 00122 00123 t+=sizeof(address); 00124 addr = prog.read<address>(t); 00125 prog.write(addr, data); 00126 00127 t = next; 00128 } 00129 00130 00131 void instr_decrement(virtualMachine& vm, process& proc, thread& t) 00132 { 00133 world& w = vm2world(vm); 00134 entity& ent = process2entity(proc); 00135 address next, addr; 00136 char data; 00137 program& prog = proc.getProgram(); 00138 00139 w.releaseEnergy(1, ent); 00140 00141 t+=sizeof(instruction); 00142 next = prog.read<address>(t); 00143 00144 t+=sizeof(address); 00145 addr = prog.read<address>(t); 00146 data = prog.read<char>(addr); 00147 --data; 00148 prog.write(addr, data); 00149 00150 t = next; 00151 } 00152 00153 00154 00155 void instr_add(virtualMachine& vm, process& proc, thread& t) 00156 { 00157 world& w = vm2world(vm); 00158 entity& ent = process2entity(proc); 00159 program& prog = proc.getProgram(); 00160 address next, addr; 00161 char val; 00162 00163 w.releaseEnergy(1, ent); 00164 00165 t+=sizeof(instruction); 00166 next = prog.read<address>(t); 00167 00168 t+=sizeof(address); 00169 addr = prog.read<address>(t); 00170 val = prog.read<char>(addr); 00171 00172 t+=sizeof(address); 00173 addr = prog.read<address>(t); 00174 val += prog.read<char>(addr); 00175 00176 t+=sizeof(address); 00177 addr = prog.read<address>(t); 00178 prog.write(addr, val); 00179 00180 t = next; 00181 } 00182 00183 00184 void instr_sub(virtualMachine& vm, process& proc, thread& t) 00185 { 00186 world& w = vm2world(vm); 00187 entity& ent = process2entity(proc); 00188 program& prog = proc.getProgram(); 00189 address next, addr; 00190 char val; 00191 00192 w.releaseEnergy(1, ent); 00193 00194 t+=sizeof(instruction); 00195 next = prog.read<address>(t); 00196 00197 t+=sizeof(address); 00198 addr = prog.read<address>(t); 00199 val = prog.read<char>(addr); 00200 00201 t+=sizeof(address); 00202 addr = prog.read<address>(t); 00203 val -= prog.read<char>(addr); 00204 00205 t+=sizeof(address); 00206 addr = prog.read<address>(t); 00207 prog.write(addr, val); 00208 00209 t = next; 00210 } 00211 00212 00213 00214 00215 00216 00217 void instr_switch(virtualMachine& vm, process& proc, thread& t) 00218 { 00219 world& w = vm2world(vm); 00220 entity& ent = process2entity(proc); 00221 address a, b, addr; 00222 char data; 00223 program& prog = proc.getProgram(); 00224 00225 w.releaseEnergy(1, ent); 00226 00227 t+=sizeof(instruction); 00228 a = prog.read<address>(t); 00229 00230 t+=sizeof(address); 00231 b = prog.read<address>(t); 00232 00233 t+=sizeof(address); 00234 addr = prog.read<address>(t); 00235 data = prog.read<char>(addr); 00236 00237 if(data) 00238 { 00239 t = a; 00240 } else 00241 { 00242 t = b; 00243 } 00244 } 00245 00246 00247 void instr_spawnThread(virtualMachine& vm, process& proc, thread& t) 00248 { 00249 world& w = vm2world(vm); 00250 entity& ent = process2entity(proc); 00251 address next, addr; 00252 program& prog = proc.getProgram(); 00253 00254 w.releaseEnergy(1, ent); 00255 00256 t+=sizeof(instruction); 00257 next = prog.read<address>(t); 00258 00259 if(proc.getNumThreads()<g_maxThreads) 00260 { 00261 t+=sizeof(address); 00262 addr = prog.read<address>(t); 00263 00264 proc.spawnThread(addr); 00265 #ifdef VERBOSE 00266 std::cout << "pid: " << proc.getId() << "\tspawn thread: " << proc.getNumThreads() << std::endl; 00267 #endif 00268 } 00269 00270 00271 00272 t = next; 00273 } 00274 00275 00276 00277 void instr_killThread(virtualMachine& vm, process& proc, thread& t) 00278 { 00279 world& w = vm2world(vm); 00280 entity& ent = process2entity(proc); 00281 address next, addr; 00282 uChar data; 00283 program& prog = proc.getProgram(); 00284 00285 w.releaseEnergy(1, ent); 00286 00287 t+=sizeof(instruction); 00288 next = prog.read<address>(t); 00289 00290 if(proc.getNumThreads()>1) 00291 { 00292 t+=sizeof(address); 00293 addr = prog.read<address>(t); 00294 data = prog.read<uChar>(addr); 00295 00296 proc.killThread(data%g_maxThreads+1); 00297 #ifdef VERBOSE 00298 std::cout << "pid: " << proc.getId() << "\tkill thread: " << data%g_maxThreads+1 << std::endl; 00299 #endif 00300 } 00301 00302 00303 t = next; 00304 } 00305 00306 00307 void instr_moveFoward(virtualMachine& vm, process& proc, thread& t) 00308 { 00309 entity& ent = process2entity(proc); 00310 world& w = vm2world(vm); 00311 program& prog = proc.getProgram(); 00312 00313 t+=sizeof(instruction); 00314 address next = prog.read<address>(t); 00315 00316 w.releaseEnergy(1, ent); 00317 w.moveEntity(ent); 00318 00319 t = next; 00320 } 00321 00322 00323 void instr_rotate(virtualMachine& vm, process& proc, thread& t) 00324 { 00325 entity& ent = process2entity(proc); 00326 world& w = vm2world(vm); 00327 program& prog = proc.getProgram(); 00328 00329 t+=sizeof(instruction); 00330 address next = prog.read<address>(t); 00331 00332 t+=sizeof(address); 00333 address addr = prog.read<address>(t); 00334 char left = prog.read<char>(addr)%2; 00335 00336 w.releaseEnergy(1, ent); 00337 if(left==1) 00338 { 00339 w.rotateEntityLeft(ent); 00340 } else 00341 { 00342 w.rotateEntityRight(ent); 00343 } 00344 00345 t = next; 00346 } 00347 00348 00349 00350 void instr_transferEnergy(virtualMachine& vm, process& proc, thread& t) 00351 { 00352 entity& ent = process2entity(proc); 00353 world& w = vm2world(vm); 00354 program& prog = proc.getProgram(); 00355 00356 t+=sizeof(instruction); 00357 address next = prog.read<address>(t); 00358 00359 t+=sizeof(address); 00360 address addr = prog.read<address>(t); 00361 energy e = prog.read<energy>(addr); 00362 00363 w.releaseEnergy(1, ent); 00364 w.transferEnergy(e, ent); 00365 00366 t = next; 00367 } 00368 00369 00370 void instr_absorbEnergy(virtualMachine& vm, process& proc, thread& t) 00371 { 00372 entity& ent = process2entity(proc); 00373 world& w = vm2world(vm); 00374 program& prog = proc.getProgram(); 00375 address next = prog.read<address>(t); 00376 00377 w.absorbEnergy(ent); 00378 00379 t = next; 00380 } 00381 00382 00383 void instr_giveMemory(virtualMachine& vm, process& proc, thread& t) 00384 { 00385 entity& ent = process2entity(proc); 00386 world& w = vm2world(vm); 00387 program& prog = proc.getProgram(); 00388 00389 t+=sizeof(instruction); 00390 address next = prog.read<address>(t); 00391 00392 t+=sizeof(address); 00393 address addr = prog.read<address>(t); 00394 addr = prog.read<address>(addr); 00395 00396 w.releaseEnergy(1, ent); 00397 w.giveMemory(ent, addr); 00398 00399 t = next; 00400 } 00401 00402 00403 void instr_takeMemory(virtualMachine& vm, process& proc, thread& t) 00404 { 00405 entity& ent = process2entity(proc); 00406 world& w = vm2world(vm); 00407 program& prog = proc.getProgram(); 00408 00409 t+=sizeof(instruction); 00410 address next = prog.read<address>(t); 00411 00412 t+=sizeof(address); 00413 address addr = prog.read<address>(t); 00414 addr = prog.read<address>(addr); 00415 00416 w.releaseEnergy(1, ent); 00417 w.takeMemory(ent, addr); 00418 00419 t = next; 00420 } 00421 00422 00423 void instr_convertEnergyToMemory(virtualMachine& vm, process& proc, thread& t) 00424 { 00425 entity& ent = process2entity(proc); 00426 world& w = vm2world(vm); 00427 program& prog = proc.getProgram(); 00428 00429 t+=sizeof(instruction); 00430 address next = prog.read<address>(t); 00431 00432 t+=sizeof(address); 00433 address addr = prog.read<address>(t); 00434 energy e = prog.read<energy>(addr); 00435 00436 w.releaseEnergy(1, ent); 00437 w.convertEnergyToMemory(ent, e); 00438 00439 t = next; 00440 } 00441 00442 00443 void instr_convertMemoryToEnergy(virtualMachine& vm, process& proc, thread& t) 00444 { 00445 entity& ent = process2entity(proc); 00446 world& w = vm2world(vm); 00447 program& prog = proc.getProgram(); 00448 00449 t+=sizeof(instruction); 00450 address next = prog.read<address>(t); 00451 00452 t+=sizeof(address); 00453 address addr = prog.read<address>(t); 00454 addr = prog.read<address>(addr); 00455 00456 w.releaseEnergy(1, ent); 00457 w.convertMemoryToEnergy(ent, addr); 00458 00459 t = next; 00460 } 00461 00462

Generated on Sun Mar 6 22:11:24 2005 for experiment03 by doxygen 1.3.7