API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 23rd, 2014
250
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 29.00 KB | None | 0 0
raw download clone embed print report
  1. #include <string.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <errno.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9.  
  10. /*These variables are associated with the implementation of the VM*/
  11. int fp ;
  12. char *ptr ;
  13. int i ;
  14. int j, k ;
  15. char input_line [7] ;
  16.  
  17. /*These are variables representing the VM itself*/
  18.  
  19. char IR[6] ;
  20. int PC = 0 ;
  21.  
  22. int P0 ; //these are the pointer registers
  23. int P1 ;
  24. int P2 ;
  25. int P3 ;
  26.  
  27. int R0 ; //GP regs
  28. int R1 ;
  29. int R2 ;
  30. int R3 ;
  31.  
  32. int ACC ;
  33. char PSW[2] ;
  34. char memory [100][6] ; //this is the program memory for first program
  35. int opcode ; //nice to know what we are doing
  36. int program_line = 0 ;
  37.  
  38. void LoadPointerImmediate() {
  39. printf("Load pointer immediate, register P%s, value %s%s",
  40. IR[3], IR[4], IR[5]);
  41. if (IR[3] == "0") {
  42. P0 = (int) (IR[4]-48) * 10;
  43. P0 += (int) (IR[5] -48);
  44. }
  45. else if (IR[3] == "1") {
  46. P1 = (int) (IR[4]-48) * 10;
  47. P1 += (int) (IR[5] -48);
  48. }
  49. else if (IR[3] == "2") {
  50. P2 = (int) (IR[4]-48) * 10;
  51. P2 += (int) (IR[5] -48);
  52. }
  53. else if(IR[3] == "3") {
  54. P3 = (int) (IR[4]-48) * 10;
  55. P3 += (int) (IR[5] -48);
  56. }
  57. else
  58. printf("Read error on line %d", PC);
  59. }
  60. void AddToPointerImmediate() {
  61. printf("Add to pointer immediate, register P%s, value %s%s",
  62. IR[3], IR[4], IR[5]);
  63. if (IR[3] == "0") {
  64. P0 += (int) (IR[4]-48) * 10;
  65. P0 += (int) (IR[5] -48);
  66. }
  67. else if (IR[3] == "1") {
  68. P1 += (int) (IR[4]-48) * 10;
  69. P1 += (int) (IR[5] -48);
  70. }
  71. else if (IR[3] == "2") {
  72. P2 += (int) (IR[4]-48) * 10;
  73. P2 += (int) (IR[5] -48);
  74. }
  75. else if (IR[3] == "3") {
  76. P3 += (int) (IR[4]-48) * 10;
  77. P3 += (int) (IR[5] -48);
  78. }
  79. else
  80. printf("Read error on line %d", PC);
  81. }
  82. void SubtractFromPointerImmediate() {
  83. printf("Subtract from pointer immediate, register P%s, value %s%s",
  84. IR[3], IR[4], IR[5]);
  85. if (IR[3] == "0") {
  86. P0 -= (int) (IR[4]-48) * 10;
  87. P0 -= (int) (IR[5] -48);
  88. }
  89. else if (IR[3] == "1") {
  90. P1 -= (int) (IR[4]-48) * 10;
  91. P1 -= (int) (IR[5] -48);
  92. }
  93. else if (IR[3] == "2") {
  94. P2 -= (int) (IR[4]-48) * 10;
  95. P2 -= (int) (IR[5] -48);
  96. }
  97. else if (IR[3] == "3") {
  98. P3 -= (int) (IR[4]-48) * 10;
  99. P3 -= (int) (IR[5] -48);
  100. }
  101. else
  102. printf("Invalid Pointer, Read error on line %d", PC);
  103. }
  104. void LoadAccumulatorImmediate() {
  105. printf("Load Accumulator Immediate, value %c%c%c%c \n",
  106. IR[2], IR[3], IR[4],IR[5]);
  107. ACC = (int) (IR[2]-48) * 1000;
  108. ACC += (int) (IR[3]-48) * 100;
  109. ACC += (int) (IR[4]-48) * 10;
  110. ACC += (int) (IR[5]-48);
  111. }
  112. void LoadAccumulatorRegister() {
  113. printf("Load Accumulator Register, register P%c \n", IR[3]);
  114. if (IR[3] == "0") {
  115. ACC = (int) (memory[P0][2]-48) * 1000;
  116. ACC += (int) (memory[P0][3]-48) * 100;
  117. ACC += (int) (memory[P0][4]-48) * 10;
  118. ACC += (int) (memory[P0][5]-48);
  119. }
  120. else if (IR[3] == "1") {
  121. ACC = (int) (memory[P1][2]-48) * 1000;
  122. ACC += (int) (memory[P1][3]-48) * 100;
  123. ACC += (int) (memory[P1][4]-48) * 10;
  124. ACC += (int) (memory[P1][5]-48);
  125. }
  126. else if (IR[3] == "2") {
  127. ACC = (int) (memory[P2][2]-48) * 1000;
  128. ACC += (int) (memory[P2][3]-48) * 100;
  129. ACC += (int) (memory[P2][4]-48) * 10;
  130. ACC += (int) (memory[P2][5]-48);
  131. }
  132. else if (IR[3] == "3") {
  133. ACC = (int) (memory[P3][2]-48) * 1000;
  134. ACC += (int) (memory[P3][3]-48) * 100;
  135. ACC += (int) (memory[P3][4]-48) * 10;
  136. ACC += (int) (memory[P3][5]-48);
  137. }
  138. else
  139. printf("Invalid Pointer, Read error on line %d", PC);
  140. }
  141. void LoadAccumulatorDirect() {
  142. printf("Load Accumulator Direct, Memory Location %c%c \n", IR[2], IR[3]);
  143. ACC = (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  144. [2]-48) * 1000;
  145. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  146. [3]-48) * 100;
  147. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  148. [4]-48) * 10;
  149. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  150. [5]-48);
  151. }
  152. void StoreAccumulatorRegister() {
  153. printf("Store Accumulator Register, register P%c \n", IR[3]);
  154. if (IR[3] == "0") {
  155. memory[P0][5] = (char) ((ACC % 10) + 48);
  156. memory[P0][4] = (char) (((ACC % 100)/10) + 48);
  157. memory[P0][3] = (char) (((ACC % 1000)/100) + 48);
  158. memory[P0][2] = (char) ((ACC /1000) + 48);
  159. }
  160. else if (IR[3] == "1") {
  161. memory[P1][5] = (char) ((ACC % 10) + 48);
  162. memory[P1][4] = (char) (((ACC % 100)/10) + 48);
  163. memory[P1][3] = (char) (((ACC % 1000)/100) + 48);
  164. memory[P1][2] = (char) ((ACC /1000) + 48);
  165. }
  166. else if (IR[3] == "2") {
  167. memory[P2][5] = (char) ((ACC % 10) + 48);
  168. memory[P2][4] = (char) (((ACC % 100)/10) + 48);
  169. memory[P2][3] = (char) (((ACC % 1000)/100) + 48);
  170. memory[P2][2] = (char) ((ACC /1000) + 48);
  171. }
  172. else if (IR[3] == "3") {
  173. memory[P3][5] = (char) ((ACC % 10) + 48);
  174. memory[P3][4] = (char) (((ACC % 100)/10) + 48);
  175. memory[P3][3] = (char) (((ACC % 1000)/100) + 48);
  176. memory[P3][2] = (char) ((ACC /1000) + 48);
  177. }
  178. }
  179. void StoreAccumulatorDirect() {
  180. printf("Store Accumulator Register, memory[%c%c] \n", IR[2], IR[3]);
  181. memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  182. [5] = (char) ((ACC % 10) + 48);
  183. memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  184. [4] = (char) (((ACC % 100)/10) + 48);
  185. memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  186. [3] = (char) (((ACC % 1000)/100) + 48);
  187. memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  188. [2] = (char) ((ACC /1000) + 48);
  189. }
  190. void StoreRegisterToMemoryRegister() {
  191. printf("Store Register to Memory: Register Adressing, register"
  192. " R%c to memory[P%c] \n", IR[3], IR[5]);
  193. if (IR[3] == "0" && IR[5] == "0"){
  194. memory[P0][5] = (char) ((R0 % 10) + 48);
  195. memory[P0][4] = (char) (((R0 % 100)/10) + 48);
  196. memory[P0][3] = (char) (((R0 % 1000)/100) + 48);
  197. memory[P0][2] = (char) ((R0 /1000) + 48);
  198. }
  199. else if (IR[3] == "1" && IR[5] == "0"){
  200. memory[P0][5] = (char) ((R1 % 10) + 48);
  201. memory[P0][4] = (char) (((R1 % 100)/10) + 48);
  202. memory[P0][3] = (char) (((R1 % 1000)/100) + 48);
  203. memory[P0][2] = (char) ((R1 /1000) + 48);
  204. }
  205. else if (IR[3] == "2" && IR[5] == "0"){
  206. memory[P0][5] = (char) ((R2 % 10) + 48);
  207. memory[P0][4] = (char) (((R2 % 100)/10) + 48);
  208. memory[P0][3] = (char) (((R2 % 1000)/100) + 48);
  209. memory[P0][2] = (char) ((R2 /1000) + 48);
  210. }
  211. else if (IR[3] == "3" && IR[5] == "0"){
  212. memory[P0][5] = (char) ((R3 % 10) + 48);
  213. memory[P0][4] = (char) (((R3 % 100)/10) + 48);
  214. memory[P0][3] = (char) (((R3 % 1000)/100) + 48);
  215. memory[P0][2] = (char) ((R3 /1000) + 48);
  216. }
  217. else if (IR[3] == "0" && IR[5] == "1"){
  218. memory[P1][5] = (char) ((R0 % 10) + 48);
  219. memory[P1][4] = (char) (((R0 % 100)/10) + 48);
  220. memory[P1][3] = (char) (((R0 % 1000)/100) + 48);
  221. memory[P1][2] = (char) ((R0 /1000) + 48);
  222. }
  223. else if (IR[3] == "1" && IR[5] == "1"){
  224. memory[P1][5] = (char) ((R1 % 10) + 48);
  225. memory[P1][4] = (char) (((R1 % 100)/10) + 48);
  226. memory[P1][3] = (char) (((R1 % 1000)/100) + 48);
  227. memory[P1][2] = (char) ((R1 /1000) + 48);
  228. }
  229. else if (IR[3] == "2" && IR[5] == "1"){
  230. memory[P1][5] = (char) ((R2 % 10) + 48);
  231. memory[P1][4] = (char) (((R2 % 100)/10) + 48);
  232. memory[P1][3] = (char) (((R2 % 1000)/100) + 48);
  233. memory[P1][2] = (char) ((R2 /1000) + 48);
  234. }
  235. else if (IR[3] == "3" && IR[5] == "1"){
  236. memory[P1][5] = (char) ((R3 % 10) + 48);
  237. memory[P1][4] = (char) (((R3 % 100)/10) + 48);
  238. memory[P1][3] = (char) (((R3 % 1000)/100) + 48);
  239. memory[P1][2] = (char) ((R3 /1000) + 48);
  240. }
  241. else if (IR[3] == "0" && IR[5] == "2"){
  242. memory[P2][5] = (char) ((R0 % 10) + 48);
  243. memory[P2][4] = (char) (((R0 % 100)/10) + 48);
  244. memory[P2][3] = (char) (((R0 % 1000)/100) + 48);
  245. memory[P2][2] = (char) ((R0 /1000) + 48);
  246. }
  247. else if (IR[3] == "1" && IR[5] == "2"){
  248. memory[P2][5] = (char) ((R1 % 10) + 48);
  249. memory[P2][4] = (char) (((R1 % 100)/10) + 48);
  250. memory[P2][3] = (char) (((R1 % 1000)/100) + 48);
  251. memory[P2][2] = (char) ((R1 /1000) + 48);
  252. }
  253. else if (IR[3] == "2" && IR[5] == "2"){
  254. memory[P2][5] = (char) ((R2 % 10) + 48);
  255. memory[P2][4] = (char) (((R2 % 100)/10) + 48);
  256. memory[P2][3] = (char) (((R2 % 1000)/100) + 48);
  257. memory[P2][2] = (char) ((R2 /1000) + 48);
  258. }
  259. else if (IR[3] == "3" && IR[5] == "2"){
  260. memory[P2][5] = (char) ((R3 % 10) + 48);
  261. memory[P2][4] = (char) (((R3 % 100)/10) + 48);
  262. memory[P2][3] = (char) (((R3 % 1000)/100) + 48);
  263. memory[P2][2] = (char) ((R3 /1000) + 48);
  264. }
  265. else if (IR[3] == "0" && IR[5] == "3"){
  266. memory[P3][5] = (char) ((R0 % 10) + 48);
  267. memory[P3][4] = (char) (((R0 % 100)/10) + 48);
  268. memory[P3][3] = (char) (((R0 % 1000)/100) + 48);
  269. memory[P3][2] = (char) ((R0 /1000) + 48);
  270. }
  271. else if (IR[3] == "1" && IR[5] == "3"){
  272. memory[P3][5] = (char) ((R1 % 10) + 48);
  273. memory[P3][4] = (char) (((R1 % 100)/10) + 48);
  274. memory[P3][3] = (char) (((R1 % 1000)/100) + 48);
  275. memory[P3][2] = (char) ((R1 /1000) + 48);
  276. }
  277. else if (IR[3] == "2" && IR[5] == "3"){
  278. memory[P3][5] = (char) ((R2 % 10) + 48);
  279. memory[P3][4] = (char) (((R2 % 100)/10) + 48);
  280. memory[P3][3] = (char) (((R2 % 1000)/100) + 48);
  281. memory[P3][2] = (char) ((R2 /1000) + 48);
  282. }
  283. else if (IR[3] == "3" && IR[5] == "3"){
  284. memory[P3][5] = (char) ((R3 % 10) + 48);
  285. memory[P3][4] = (char) (((R3 % 100)/10) + 48);
  286. memory[P3][3] = (char) (((R3 % 1000)/100) + 48);
  287. memory[P3][2] = (char) ((R3 /1000) + 48);
  288. }
  289. }
  290. void StoreRegisterToMemoryDirect() {
  291. printf("Store Register To Memory: Direct Addressing, "
  292. "register R%c to memory[%c%c] \n", IR[3], IR[4], IR[5]);
  293. if (IR[3] == "0") {
  294. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  295. [5] = (char) ((R0 % 10) + 48);
  296. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  297. [4] = (char) (((R0 % 100)/10) + 48);
  298. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  299. [3] = (char) (((R0 % 1000)/100) + 48);
  300. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  301. [2] = (char) ((R0 /1000) + 48);
  302. }
  303. else if (IR[3] == "1") {
  304. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  305. [5] = (char) ((R1 % 10) + 48);
  306. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  307. [4] = (char) (((R1 % 100)/10) + 48);
  308. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  309. [3] = (char) (((R1 % 1000)/100) + 48);
  310. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  311. [2] = (char) ((R1 /1000) + 48);
  312. }
  313. else if (IR[3] == "2") {
  314. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  315. [5] = (char) ((R2 % 10) + 48);
  316. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  317. [4] = (char) (((R2 % 100)/10) + 48);
  318. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  319. [3] = (char) (((R2 % 1000)/100) + 48);
  320. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  321. [2] = (char) ((R2 /1000) + 48);
  322. }
  323. else if (IR[3] == "3") {
  324. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  325. [5] = (char) ((R3 % 10) + 48);
  326. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  327. [4] = (char) (((R3 % 100)/10) + 48);
  328. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  329. [3] = (char) (((R3 % 1000)/100) + 48);
  330. memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  331. [2] = (char) ((R3 /1000) + 48);
  332. }
  333. }
  334. void LoadRegisterFromMemoryRegister() {
  335. printf("Load Register from Memory: Register Addressing,"
  336. " memory[P%c] to register R%c \n", IR[5], IR[3]);
  337. if (IR [3] == "0" && IR[5] == "0") {
  338. R0 = (int) (memory[P0][2]-48) * 1000;
  339. R0 += (int) (memory[P0][3]-48) * 100;
  340. R0 += (int) (memory[P0][4]-48) * 10;
  341. R0 += (int) (memory[P0][5]-48);
  342. }
  343. else if (IR [3] == "1" && IR[5] == "0") {
  344. R1 = (int) (memory[P0][2]-48) * 1000;
  345. R1 += (int) (memory[P0][3]-48) * 100;
  346. R1 += (int) (memory[P0][4]-48) * 10;
  347. R1 += (int) (memory[P0][5]-48);
  348. }
  349. else if (IR [3] == "2" && IR[5] == "0") {
  350. R2 = (int) (memory[P0][2]-48) * 1000;
  351. R2 += (int) (memory[P0][3]-48) * 100;
  352. R2 += (int) (memory[P0][4]-48) * 10;
  353. R2 += (int) (memory[P0][5]-48);
  354. }
  355. else if (IR [3] == "3" && IR[5] == "0") {
  356. R3 = (int) (memory[P0][2]-48) * 1000;
  357. R3 += (int) (memory[P0][3]-48) * 100;
  358. R3 += (int) (memory[P0][4]-48) * 10;
  359. R3 += (int) (memory[P0][5]-48);
  360. }
  361. else if (IR [3] == "0" && IR[5] == "1") {
  362. R0 = (int) (memory[P1][2]-48) * 1000;
  363. R0 += (int) (memory[P1][3]-48) * 100;
  364. R0 += (int) (memory[P1][4]-48) * 10;
  365. R0 += (int) (memory[P1][5]-48);
  366. }
  367. else if (IR [3] == "1" && IR[5] == "1") {
  368. R1 = (int) (memory[P1][2]-48) * 1000;
  369. R1 += (int) (memory[P1][3]-48) * 100;
  370. R1 += (int) (memory[P1][4]-48) * 10;
  371. R1 += (int) (memory[P1][5]-48);
  372. }
  373. else if (IR [3] == "2" && IR[5] == "1") {
  374. R2 = (int) (memory[P1][2]-48) * 1000;
  375. R2 += (int) (memory[P1][3]-48) * 100;
  376. R2 += (int) (memory[P1][4]-48) * 10;
  377. R2 += (int) (memory[P1][5]-48);
  378. }
  379. else if (IR [3] == "3" && IR[5] == "1") {
  380. R3 = (int) (memory[P1][2]-48) * 1000;
  381. R3 += (int) (memory[P1][3]-48) * 100;
  382. R3 += (int) (memory[P1][4]-48) * 10;
  383. R3 += (int) (memory[P1][5]-48);
  384. }
  385. else if (IR [3] == "0" && IR[5] == "2") {
  386. R0 = (int) (memory[P2][2]-48) * 1000;
  387. R0 += (int) (memory[P2][3]-48) * 100;
  388. R0 += (int) (memory[P2][4]-48) * 10;
  389. R0 += (int) (memory[P2][5]-48);
  390. }
  391. else if (IR [3] == "1" && IR[5] == "2") {
  392. R1 = (int) (memory[P3][2]-48) * 1000;
  393. R1 += (int) (memory[P3][3]-48) * 100;
  394. R1 += (int) (memory[P3][4]-48) * 10;
  395. R1 += (int) (memory[P3][5]-48);
  396. }
  397. else if (IR [3] == "2" && IR[5] == "2") {
  398. R2 = (int) (memory[P2][2]-48) * 1000;
  399. R2 += (int) (memory[P2][3]-48) * 100;
  400. R2 += (int) (memory[P2][4]-48) * 10;
  401. R2 += (int) (memory[P2][5]-48);
  402. }
  403. else if (IR [3] == "3" && IR[5] == "2") {
  404. R3 = (int) (memory[P2][2]-48) * 1000;
  405. R3 += (int) (memory[P2][3]-48) * 100;
  406. R3 += (int) (memory[P2][4]-48) * 10;
  407. R3 += (int) (memory[P2][5]-48);
  408. }
  409. else if (IR [3] == "0" && IR[5] == "3") {
  410. R0 = (int) (memory[P3][2]-48) * 1000;
  411. R0 += (int) (memory[P3][3]-48) * 100;
  412. R0 += (int) (memory[P3][4]-48) * 10;
  413. R0 += (int) (memory[P3][5]-48);
  414. }
  415. else if (IR [3] == "1" && IR[5] == "3") {
  416. R1 = (int) (memory[P3][2]-48) * 1000;
  417. R1 += (int) (memory[P3][3]-48) * 100;
  418. R1 += (int) (memory[P3][4]-48) * 10;
  419. R1 += (int) (memory[P3][5]-48);
  420. }
  421. else if (IR [3] == "2" && IR[5] == "3") {
  422. R2 = (int) (memory[P3][2]-48) * 1000;
  423. R2 += (int) (memory[P3][3]-48) * 100;
  424. R2 += (int) (memory[P3][4]-48) * 10;
  425. R2 += (int) (memory[P3][5]-48);
  426. }
  427. else if (IR [3] == "3" && IR[5] == "3") {
  428. R3 = (int) (memory[P3][2]-48) * 1000;
  429. R3 += (int) (memory[P3][3]-48) * 100;
  430. R3 += (int) (memory[P3][4]-48) * 10;
  431. R3 += (int) (memory[P3][5]-48);
  432. }
  433. }
  434. void LoadRegisterFromMemoryDirect() {
  435. printf("Load Register from Memory: Direct Addressing,"
  436. " memory[%c%c] to register R%c \n",IR[4], IR[5], IR[3]);
  437. if (IR [3] == "0") {
  438. R0 = (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  439. [2]-48) * 1000;
  440. R0 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  441. [3]-48) * 100;
  442. R0 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  443. [4]-48) * 10;
  444. R0 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  445. [5]-48);
  446. }
  447. else if (IR [3] == "1") {
  448. R1 = (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  449. [2]-48) * 1000;
  450. R1 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  451. [3]-48) * 100;
  452. R1 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  453. [4]-48) * 10;
  454. R1 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  455. [5]-48);
  456. }
  457. else if (IR [3] == "2") {
  458. R2 = (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  459. [2]-48) * 1000;
  460. R2 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  461. [3]-48) * 100;
  462. R2 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  463. [4]-48) * 10;
  464. R2 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  465. [5]-48);
  466. }
  467. else if (IR [3] == "3") {
  468. R3 = (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  469. [2]-48) * 1000;
  470. R3 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  471. [3]-48) * 100;
  472. R3 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  473. [4]-48) * 10;
  474. R3 += (int) (memory[(((int) (IR[4]-48) * 10) + (int) (IR[5]-48))]
  475. [5]-48);
  476. }
  477. }
  478. void AddAccumulatorImmediate() {
  479. printf("Add Accumulator Immediate, value %c%c%c%c \n",
  480. IR[2], IR[3], IR[4], IR[5]);
  481. ACC += (int) (IR[2]-48) * 1000;
  482. ACC += (int) (IR[3]-48) * 100;
  483. ACC += (int) (IR[4]-48) * 10;
  484. ACC += (int) (IR[5]-48);
  485. }
  486. void SubtractAccumulatorImmediate() {
  487. printf("Subtract Accumulator Immediate, value %c%c%c%c \n",
  488. IR[2],IR[3],IR[4],IR[5]);
  489. ACC -= (int) (IR[2]-48) * 1000;
  490. ACC -= (int) (IR[3]-48) * 100;
  491. ACC -= (int) (IR[4]-48) * 10;
  492. ACC -= (int) (IR[5]-48);
  493. }
  494. void AddContentsOfRegisterToAccumulator() {
  495. printf("Add Contents of Register to Accumulator, register R%c", IR[3]);
  496. if (IR[3] == "0")
  497. ACC += R0;
  498. else if (IR[3] == "1")
  499. ACC += R1;
  500. else if (IR[3] == "2")
  501. ACC += R2;
  502. else if (IR[3] == "3")
  503. ACC += R3;
  504. }
  505. void SubtractContentsOfRegisterToAccumulator() {
  506. printf("Subtract Contents of Register to Accumulator, register R%c \n",
  507. IR[3]);
  508. if (IR[3] == "0")
  509. ACC -= R0;
  510. else if (IR[3] == "1")
  511. ACC -= R1;
  512. else if (IR[3] == "2")
  513. ACC -= R2;
  514. else if (IR[3] == "3")
  515. ACC -= R3;
  516. }
  517. void AddAccumulatorRegister() {
  518. printf("Add to Accumulator: Register Addressing, memory[P%c] \n", IR[3]);
  519. if (IR[3] == "0") {
  520. ACC += (int) (memory[P0][2]-48) *1000;
  521. ACC += (int) (memory[P0][3]-48) *100;
  522. ACC += (int) (memory[P0][4]-48) *10;
  523. ACC += (int) (memory[P0][5]-48);
  524. }
  525. else if (IR[3] == "1") {
  526. ACC += (int) (memory[P1][2]-48) *1000;
  527. ACC += (int) (memory[P1][3]-48) *100;
  528. ACC += (int) (memory[P1][4]-48) *10;
  529. ACC += (int) (memory[P1][5]-48);
  530. }
  531. else if (IR[3] == "2") {
  532. ACC += (int) (memory[P2][2]-48) *1000;
  533. ACC += (int) (memory[P2][3]-48) *100;
  534. ACC += (int) (memory[P2][4]-48) *10;
  535. ACC += (int) (memory[P2][5]-48);
  536. }
  537. else if (IR[3] == "3") {
  538. ACC += (int) (memory[P3][2]-48) *1000;
  539. ACC += (int) (memory[P3][3]-48) *100;
  540. ACC += (int) (memory[P3][4]-48) *10;
  541. ACC += (int) (memory[P3][5]-48);
  542. }
  543. }
  544. void AddAccumulatorDirect() {
  545. printf("Add to Accumulator: Direct Addressing, memory[%c%c] \n",
  546. IR[2], IR[3]);
  547. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  548. [2]-48) *1000;
  549. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  550. [3]-48) *100;
  551. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  552. [4]-48) *10;
  553. ACC += (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  554. [5]-48);
  555. }
  556. void SubtractFromAccumulatorRegister() {
  557. printf("Subtract from Accumulator: Register Addressing, memory[P%c] \n",
  558. IR[3]);
  559. if (IR[3] == "0") {
  560. ACC -= (int) (memory[P0][2]-48) *1000;
  561. ACC -= (int) (memory[P0][3]-48) *100;
  562. ACC -= (int) (memory[P0][4]-48) *10;
  563. ACC -= (int) (memory[P0][5]-48);
  564. }
  565. else if (IR[3] == "1") {
  566. ACC -= (int) (memory[P1][2]-48) *1000;
  567. ACC -= (int) (memory[P1][3]-48) *100;
  568. ACC -= (int) (memory[P1][4]-48) *10;
  569. ACC -= (int) (memory[P1][5]-48);
  570. }
  571. else if (IR[3] == "2") {
  572. ACC -= (int) (memory[P2][2]-48) *1000;
  573. ACC -= (int) (memory[P2][3]-48) *100;
  574. ACC -= (int) (memory[P2][4]-48) *10;
  575. ACC -= (int) (memory[P2][5]-48);
  576. }
  577. else if (IR[3] == "3") {
  578. ACC -= (int) (memory[P3][2]-48) *1000;
  579. ACC -= (int) (memory[P3][3]-48) *100;
  580. ACC -= (int) (memory[P3][4]-48) *10;
  581. ACC -= (int) (memory[P3][5]-48);
  582. }
  583. }
  584. void SubtractFromAccumulatorDirect() {
  585. printf("Subtract from Accumulator: Direct Addressing, memory[%c%c] \n",
  586. IR[2], IR[3]);
  587. ACC -= (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  588. [2]-48) *1000;
  589. ACC -= (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  590. [3]-48) *100;
  591. ACC -= (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  592. [4]-48) *10;
  593. ACC -= (int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  594. [5]-48);
  595. }
  596. void CompareEqualRegister() {
  597. printf("Compare Equal: Register Addressing, compare to memory[P%c] \n",
  598. IR[3]);
  599. if (IR[3] == "0") {
  600. if (ACC == (((int) (memory[P0][2]-48) *1000) +
  601. ((int) (memory[P0][3]-48) *100) +
  602. ((int) (memory[P0][4]-48) *10) +
  603. ((int) (memory[P0][5]-48))))
  604. PSW[1] != "0";
  605. else
  606. PSW[1] = "0";
  607. }
  608. else if (IR[3] == "1") {
  609. if (ACC == (((int) (memory[P1][2]-48) *1000) +
  610. ((int) (memory[P1][3]-48) *100) +
  611. ((int) (memory[P1][4]-48) *10) +
  612. ((int) (memory[P1][5]-48))))
  613. PSW[1] != "0";
  614. else
  615. PSW[1] = "0";
  616. }
  617. else if (IR[3] == "0") {
  618. if (ACC == (((int) (memory[P2][2]-48) *1000) +
  619. ((int) (memory[P2][3]-48) *100) +
  620. ((int) (memory[P2][4]-48) *10) +
  621. ((int) (memory[P2][5]-48))))
  622. PSW[1] != "0";
  623. else
  624. PSW[1] = "0";
  625. }
  626. else if (IR[3] == "0") {
  627. if (ACC == (((int) (memory[P3][2]-48) *1000) +
  628. ((int) (memory[P3][3]-48) *100) +
  629. ((int) (memory[P3][4]-48) *10) +
  630. ((int) (memory[P3][5]-48))))
  631. PSW[1] != "0";
  632. else
  633. PSW[1] = "0";
  634. }
  635. else
  636. PSW[1] = "0";
  637. }
  638. void CompareLessRegister() {
  639. printf("Compare Less Than: Register Addressing, compare to memory[P%c] \n",
  640. IR[3]);
  641. if (IR[3] == "0") {
  642. if (ACC < (((int) (memory[P0][2]-48) *1000) +
  643. ((int) (memory[P0][3]-48) *100) +
  644. ((int) (memory[P0][4]-48) *10) +
  645. ((int) (memory[P0][5]-48))))
  646. PSW[1] != "0";
  647. else
  648. PSW[1] = "0";
  649. }
  650. else if (IR[3] == "1") {
  651. if (ACC < (((int) (memory[P1][2]-48) *1000) +
  652. ((int) (memory[P1][3]-48) *100) +
  653. ((int) (memory[P1][4]-48) *10) +
  654. ((int) (memory[P1][5]-48))))
  655. PSW[1] != "0";
  656. else
  657. PSW[1] = "0";
  658. }
  659. else if (IR[3] == "0") {
  660. if (ACC < (((int) (memory[P2][2]-48) *1000) +
  661. ((int) (memory[P2][3]-48) *100) +
  662. ((int) (memory[P2][4]-48) *10) +
  663. ((int) (memory[P2][5]-48))))
  664. PSW[1] != "0";
  665. else
  666. PSW[1] = "0";
  667. }
  668. else if (IR[3] == "0") {
  669. if (ACC < (((int) (memory[P3][2]-48) *1000) +
  670. ((int) (memory[P3][3]-48) *100) +
  671. ((int) (memory[P3][4]-48) *10) +
  672. ((int) (memory[P3][5]-48))))
  673. PSW[1] != "0";
  674. else
  675. PSW[1] = "0";
  676. }
  677. else
  678. PSW[1] = "0";
  679. }
  680. void CompareGreaterRegister() {
  681. printf("Compare Greater Than: Register Addressing, compare to memory[P%c] \n",
  682. IR[3]);
  683. if (IR[3] == "0") {
  684. if (ACC > (((int) (memory[P0][2]-48) *1000) +
  685. ((int) (memory[P0][3]-48) *100) +
  686. ((int) (memory[P0][4]-48) *10) +
  687. ((int) (memory[P0][5]-48))))
  688. PSW[1] != "0";
  689. else
  690. PSW[1] = "0";
  691. }
  692. else if (IR[3] == "1") {
  693. if (ACC > (((int) (memory[P1][2]-48) *1000) +
  694. ((int) (memory[P1][3]-48) *100) +
  695. ((int) (memory[P1][4]-48) *10) +
  696. ((int) (memory[P1][5]-48))))
  697. PSW[1] != "0";
  698. else
  699. PSW[1] = "0";
  700. }
  701. else if (IR[3] == "0") {
  702. if (ACC > (((int) (memory[P2][2]-48) *1000) +
  703. ((int) (memory[P2][3]-48) *100) +
  704. ((int) (memory[P2][4]-48) *10) +
  705. ((int) (memory[P2][5]-48))))
  706. PSW[1] != "0";
  707. else
  708. PSW[1] = "0";
  709. }
  710. else if (IR[3] == "0") {
  711. if (ACC > (((int) (memory[P3][2]-48) *1000) +
  712. ((int) (memory[P3][3]-48) *100) +
  713. ((int) (memory[P3][4]-48) *10) +
  714. ((int) (memory[P3][5]-48))))
  715. PSW[1] != "0";
  716. else
  717. PSW[1] = "0";
  718. }
  719. else
  720. PSW[1] = "0";
  721. }
  722. void CompareGreaterImmediate() {
  723. printf("Compare ACC Greater: Immediate Addressing, to memory[%c%c] \n",
  724. IR[2], IR[3]);
  725. if (ACC > (((int) (memory[(((int) (IR[2]-48) * 10)+ (int) (IR[3]-48))]
  726. [2]-48) *1000) +
  727. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  728. [3]-48) *100) +
  729. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  730. [4]-48) *10) +
  731. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  732. [5]-48))))
  733. PSW[1] != "0";
  734. else
  735. PSW[1] = "0";
  736. }
  737. void CompareEqualImmediate() {
  738. printf("Compare ACC Equal: Immediate Addressing, to memory[%c%c] \n",
  739. IR[2], IR[3]);
  740. if (ACC == (((int) (memory[(((int) (IR[2]-48) * 10)+ (int) (IR[3]-48))]
  741. [2]-48) *1000) +
  742. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  743. [3]-48) *100) +
  744. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  745. [4]-48) *10) +
  746. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  747. [5]-48))))
  748. PSW[1] != "0";
  749. else
  750. PSW[1] = "0";
  751. }
  752. void CompareLessImmediate() {
  753. printf("Compare ACC Greater: Immediate Addressing, to memory[%c%c] \n",
  754. IR[2], IR[3]);
  755. if (ACC < (((int) (memory[(((int) (IR[2]-48) * 10)+ (int) (IR[3]-48))]
  756. [2]-48) *1000) +
  757. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  758. [3]-48) *100) +
  759. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  760. [4]-48) *10) +
  761. ((int) (memory[(((int) (IR[2]-48) * 10) + (int) (IR[3]-48))]
  762. [5]-48))))
  763. PSW[1] != "0";
  764. else
  765. PSW[1] = "0";
  766. }
  767. void BranchConditionalTrue() {
  768. printf("Branch Conditional True, PC to %c%c \n", IR[2], IR[3]);
  769. if (PSW[1] != "0")
  770. PC = ((int) (IR[2]-48) * 10) + (int) (IR[3]-48);
  771. }
  772. void BranchConditionalFalse() {
  773. printf("Branch Conditional False, PC to %c%c \n", IR[2], IR[3]);
  774. if (PSW[1] == "0")
  775. PC = ((int) (IR[2]-48) * 10) + (int) (IR[3]-48);
  776. }
  777. void BranchUnconnditional() {
  778. printf("Branch Unconditional, PC to %c%c \n", IR[2], IR[3]);
  779. PC = ((int) (IR[2]-48) * 10) + (int) (IR[3]-48);
  780. }
  781. void LoadRegisterFromAccumulator() {
  782. printf("Load Register From Accumulator, ACC to R%c", IR[3]);
  783.  
  784. }
  785. void StoreRegisterToAccumulator() {
  786. printf("Load Register From Accumulator, ACC to R%c", IR[3]);
  787. if (IR[3] == "0")
  788. R0 = ACC;
  789. else if (IR[3] == "1")
  790. R1 = ACC;
  791. else if (IR[3] == "2")
  792. R2 = ACC;
  793. else if (IR[3] == "3")
  794. R3 = ACC;
  795. }
  796. void Halt(){
  797. return 0;
  798. }
  799.  
  800. main(int argc, char *argv[]) {
  801. char *ptr ;
  802. fp = open("program", O_RDONLY) ; //always check the return value.
  803. printf("Open is %d\n", fp) ;
  804.  
  805. if (fp < 0) //error in read or EOF
  806. {printf("Bus Error 22\n") ;
  807. exit(0) ;
  808. }
  809.  
  810. //iterate through the source code to and load it into memory
  811.  
  812. int ret = read (fp, input_line, 7 ) ; //returns number of characters read
  813. while (1) {
  814. if (ret <= 0) //indicates end of file or
  815. break ; //breaks out of loop
  816. ptr = input_line ; //base address of array
  817.  
  818. //write into Program_memory
  819. for (i = 0; i < 6 ; i++)
  820. memory[program_line][i] = input_line[i] ;
  821.  
  822. //read in next line of code
  823. ret = read (fp, input_line, 7 ) ;
  824. program_line++ ; //now at a new line in the program
  825. }
  826.  
  827. /*We have read in the entire PBRAIN12 program.
  828. Now time to execute the code.
  829. First, we copy the current line of the program code
  830. into the Instruction Register (IR)
  831. */
  832. for (i = 0 ; i< program_line; i++) {
  833. for (j = 0 ; j < 6 ; j++)
  834. IR[j] = memory[i] [j] ;
  835.  
  836. printf("Working on Program line %d\n", i) ;
  837.  
  838. //easy way to calc integer equivalent of chars
  839.  
  840. opcode = (int) (IR[0] -48) * 10 ;
  841. opcode += (int) (IR[1] -48);
  842.  
  843. /* Now we know the opcode for the instruction. This
  844. provides all the information we need to parse the
  845. operands.
  846. */
  847.  
  848. printf("Opcode is %d\n", opcode) ;
  849.  
  850. switch(IR[0,1]) {
  851. case 0: {LoadPointerImmediate(); break;}
  852. case 1: {AddToPointerImmediate(); break;}
  853. case 2: {SubtractFromPointerImmediate(); break;}
  854. case 3: {LoadAccumulatorImmediate(); break;}
  855. case 4: {LoadAccumulatorRegister(); break;}
  856. case 5: {LoadAccumulatorDirect(); break;}
  857. case 6: {StoreAccumulatorRegister(); break;}
  858. case 7: {StoreAccumulatorDirect(); break;}
  859. case 8: {StoreRegisterToMemoryRegister(); break;}
  860. case 9: {StoreRegisterToMemoryDirect(); break;}
  861. case 10: {LoadRegisterFromMemoryRegister(); break;}
  862. case 11: {LoadRegisterFromMemoryDirect(); break;}
  863. case 12: {AddAccumulatorImmediate(); break;}
  864. case 13: {SubtractAccumulatorImmediate(); break;}
  865. case 14: {AddContentsOfRegisterToAccumulator(); break;}
  866. case 15: {SubtractContentsOfRegisterToAccumulator(); break;}
  867. case 16: {AddAccumulatorRegister(); break;}
  868. case 17: {AddAccumulatorDirect(); break;}
  869. case 18: {SubtractFromAccumulatorRegister(); break;}
  870. case 19: {SubtractFromAccumulatorDirect(); break;}
  871. case 20: {CompareEqualRegister(); break;}
  872. case 21: {CompareLessRegister(); break;}
  873. case 22: {CompareGreaterRegister(); break;}
  874. case 23: {CompareGreaterImmediate(); break;}
  875. case 24: {CompareEqualImmediate(); break;}
  876. case 25: {CompareLessImmediate(); break;}
  877. case 26: {BranchConditionalTrue(); break;}
  878. case 27: {BranchConditionalFalse(); break;}
  879. case 28: {BranchUnconnditional(); break;}
  880. case 29: {LoadRegisterFromAccumulator(); break;}
  881. case 30: {StoreRegisterToAccumulator(); break;}
  882. case 99: {Halt(); break;}
  883. }
  884. }
  885. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!