fork download
copy 
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4.  
  5.  
  6. #define true 1
  7. #define false 0
  8. typedef unsigned char Char;
  9.  
  10.  
  11. Char p[2000];  /* This is memory */
  12. int programLength;
  13. int littleEndian = true;
  14. int num_words;
  15.  
  16. int* eax;
  17. int* ecx;
  18. int* edx;
  19. int* ebx;
  20. int* esi;
  21. int* edi;
  22. int* esp;
  23. int* ebp;
  24.  
  25. int pc;
  26. int codes; /* status, condition codes[3]; control and status flags */
  27.  
  28. void loadVal(int val, int addr)
  29. {
  30.   p[addr] = (Char) (val & 0xf000);
  31.   p[addr+1] = (Char) (val & 0x0f00);
  32.   p[addr+2] = (Char) (val & 0x00f0);
  33.   p[addr+3] = (Char) (val & 0x000f);
  34. }
  35. void setup()
  36. {
  37.         /* get the file from arc */
  38.     eax = malloc(sizeof(int*));
  39.     ecx = malloc(sizeof(int*));
  40.     edx = malloc(sizeof(int*));
  41.     ebx = malloc(sizeof(int*));
  42.     esi = malloc(sizeof(int*));
  43.     edi = malloc(sizeof(int*));
  44.     esp = malloc(sizeof(int*));
  45.     ebp = malloc(sizeof(int*));
  46.     *eax = *ecx = *edx = *ebx = *esi = *edi = *esp = *ebp = pc = 0;
  47.     printf("setup done");
  48. }
  49. Char aToH(Char x)
  50. {
  51.   if(x > '/' && x < ':')
  52.    x=(Char) (x-48);
  53.   else
  54.   {
  55.     if(x>'`' && x<'g')
  56.       x=(Char) (x-87);
  57.   }
  58.   return x;
  59. }
  60.  
  61. int FASCII(Char z[])
  62. {
  63.   int b=0;
  64.   programLength=0;
  65.   if(*z=='\0')
  66.   {
  67.     printf("NO CHARS\n");
  68.     return 1;
  69.   }
  70.   else
  71.   {
  72.     for(int a=0; z[a]!='\0'; a++)
  73.     {
  74.       Char s=aToH(z[a]);
  75.       Char t=aToH(z[a+1]);
  76.       p[b]=(Char) (s << 4|t);
  77.       printf("%x ", p[b] & 0xff);
  78.       a++;
  79.       b++;
  80.     }
  81.     programLength = b;
  82.   }
  83.   printf("\n");
  84.   return 0;
  85. }
  86.  
  87. /* Zero flag operations */
  88. void setZF()
  89. {
  90.   codes = codes | 64;  /* sets the 01000000 flag */
  91.   printf("	ZF flag set");
  92. }
  93.  
  94.  
  95. void clearZF()
  96. {/* clears 10111111 flag */
  97.     // if set, clear
  98.     // if clear, clear
  99.   codes= codes & 64;
  100. }
  101.  
  102. int getZF()
  103. {
  104.   if((codes & 63) == 64)
  105.     return 1;
  106.   return 0;
  107. }
  108.  
  109.  
  110.  
  111. /* Sign Flag operations */
  112. void setSF()
  113. {
  114.   codes = codes | 32;  /* sets the 00100000 flag */
  115.   printf("	SF flag set");
  116. }
  117.  
  118. void clearSF()
  119. {
  120.   codes = codes & 32;
  121. }
  122.  
  123. void clearOF()
  124. {
  125.   codes = codes & 16;
  126. }
  127.  
  128. void clearFlags()
  129. {
  130.   clearSF();
  131.   clearZF();
  132.   clearOF();
  133. }
  134.  
  135. int getSF()
  136. {
  137.   if((codes & 32) == 32)
  138.     return 1;
  139.   return 0;
  140. }
  141.  
  142. /* Overflow flag operations */
  143. void setOF()
  144. {
  145.   codes = codes | 16;  /* sets the 00010000 flag */
  146.   printf("	OF flag set");
  147. }
  148.  
  149.  
  150.  
  151. int getOF()
  152. {
  153.   if((codes & 16) == 16 )
  154.     return 1;
  155.   return 0;
  156. }
  157.  
  158. void clearStatus()
  159. {
  160.   codes = codes & (255 - 15);  /* 11110000 - clears last four bits */
  161. }
  162.  
  163. /* Status code operations (last four bits) */
  164. void setAOK()
  165. {
  166.   clearStatus();
  167.   codes = codes | 1;  /* sets 00000001 */
  168.   printf("	set status = AOK");
  169. }
  170.  
  171. void setHLT()
  172. {
  173.   clearStatus();
  174.   codes = codes | 2;  /* sets 00000010 */
  175.   printf("	set status = HLT");
  176. }
  177.  
  178. void setADR()
  179. {
  180.   clearStatus();
  181.   codes = codes | 3;  /* sets 00000011 */
  182.   printf("	set status = ADR");
  183. }
  184.  
  185. void setINS()
  186. {
  187.   clearStatus();
  188.   codes = codes | 4;  /* sets 00000010 */
  189.   printf("	set status = INS");
  190. }
  191.  
  192. int getStatus()
  193. {
  194.   return codes & 0xf0;
  195. }
  196.  
  197. /*
  198.  * Prints out the values of the registers */
  199. void printRegisters()
  200. {
  201.   printf("\teax: %x, ", *eax);
  202.   printf("ecx: %x, ", *ecx);
  203.   printf("edx: %x, ", *edx);
  204.   printf("ebx: %x, ", *ebx);
  205.   printf("esi: %x, ", *esi);
  206.   printf("edi: %x, ", *edi);
  207.   printf("esp: %x, ", *esp);
  208.   printf("ebp: %x, ", *ebp);
  209.   printf("PC: %x, ", pc);
  210. }
  211.  
  212. /* Generates an error then exits the program */
  213. void error(Char words[], int pc)
  214. {
  215.   for(int a=0; words[a] != '\0'; a++)
  216.     printf("%c", words[a]);
  217.   exit(0);
  218. }
  219.  
  220. /* Assembly instructions */
  221. /**
  222.  * halt 00
  223.  */
  224. void halt()
  225. {
  226.   printf("halt");
  227.   setHLT();
  228.   pc+=1;
  229.   printRegisters();
  230.   exit(0);
  231. }
  232.  
  233.  
  234. /**
  235.  * nop 10
  236.  */
  237. void nop()
  238. {
  239.   printf("nop");
  240.   pc+=1;
  241. }
  242.  
  243.  
  244. /**
  245.  ** Gets an integer value from four chars ( based on big * endian or little
  246.  * endian encoding)
  247.  *
  248.  */
  249. int getVal(Char a, Char b, Char c, Char d)
  250. {
  251.   unsigned int val;
  252.   if(littleEndian)
  253.   {
  254.     val=a;
  255.     val=val | b << 8;
  256.     val=val | c << 16;
  257.     val=val | (unsigned int) d << 32u;
  258.   }
  259.   else
  260.   {
  261.     val=a;
  262.     val=val | b << 4;
  263.     val=val | c << 8;
  264.     val=val | d << 16;
  265.   }
  266.   return val;
  267. }
  268.  
  269. /*
  270. Computes the register from the first part of the Char
  271. passed in. Returns a pointer to the register given
  272. character code as input.
  273. 0 eax; 1 ecx; 2 edx; 3 ebx
  274. 4 esp; 5ebp; 7 edi
  275. F No register
  276.  */
  277. int* r1(Char a)
  278. {
  279.   switch(a & 0xf0)
  280.   {
  281.     case 0x00:
  282.       return eax;
  283.     case 0x10:
  284.       return ecx;
  285.     case 0x20:
  286.       return edx;
  287.     case 0x30:
  288.       return ebx;
  289.     case 0x40:
  290.       return esp;
  291.     case 0x50:
  292.       return ebp;
  293.     case 0x60:
  294.       return esi;
  295.     case 0x70:
  296.       return edi;
  297.     default:
  298.       printf("Error determining register value. pc=%x", pc);
  299.   }
  300.   return eax; /* shouldn't be hit */
  301. }   
  302.  
  303.  
  304. /*
  305. Computes the register from the second part of the Char
  306. passed in. Returns a pointer to the register given
  307. character code as input.
  308. 0 eax; 1 ecx; 2 edx; 3 ebx
  309. 4 esp; 5 ebp; 6 esi; 7 edi
  310. F No register
  311.  */ 
  312. int* r2(Char a)
  313. {
  314.   switch(a & 0x0f)
  315.   {
  316.     case 0x00:
  317.       return eax;
  318.     case 0x01:
  319.       return ecx;
  320.     case 0x02:
  321.       return edx;
  322.     case 0x03:
  323.       return ebx;
  324.     case 0x04:
  325.       return esp;
  326.     case 0x05:
  327.       return ebp;
  328.     case 0x06:
  329.       return esi;
  330.     case 0x07:
  331.       return edi;
  332.     default:
  333.       printf("Error determining register value. pc=%x", pc);
  334.   }
  335.   return eax; /* shouldn't be hit */
  336. }   
  337.  
  338.  
  339. /**
  340.  * rrmov1 rA, rB 20 rArB
  341.  */
  342. void rrmov1(Char reg)
  343. {
  344.   int* src = r1(reg);
  345.   int* dst = r2(reg);
  346.   *dst = *src;
  347.   printf("rrmov1 %p, %p: (%x)", &src, &dst, *dst);
  348.   pc+=2;
  349. }
  350.  
  351. /**
  352.  * cmov1e rA, rB 21 rArB
  353.  */
  354. void cmov1e(Char reg)
  355. {
  356.   int* src = r1(reg);
  357.   int* dst = r2(reg);
  358.   if(getZF() ==1 || getSF() != getOF())
  359.   {
  360.     *dst = *src;
  361.     printf("cmov1e %p, %p: (%x moved)", &src, &dst, *dst);
  362.   }
  363.   else
  364.         printf("cmov1e %p, %p: (%x not moved)", &src, &dst, *dst);
  365.   pc+=2;
  366. }
  367.  
  368. /**
  369.  * cmov1 rA, rB 22 rArB
  370.  */
  371. void cmov1(Char reg)
  372. {
  373.   int* src = r1(reg);
  374.   int* dst = r2(reg);
  375.   if(getSF() != getOF())
  376.   {
  377.     *dst = *src;
  378.     printf("cmov1 %p, %p: (%x moved)", &src, &dst, *dst);
  379.   }
  380.   else
  381.         printf("cmov1 %p, %p: (%x not moved)", &src, &dst, *dst);
  382.   pc+=2;
  383. }
  384.  
  385. /**
  386.  * cmove rA, rB 23 rArB
  387.  */
  388. void cmove(Char reg)
  389. {
  390.   int* src = r1(reg);
  391.   int* dst = r2(reg);
  392.   if(getZF() ==1)
  393.   {
  394.     *dst = *src;
  395.     printf("cmove %p, %p: (%x moved)", &src, &dst, *dst);
  396.   }
  397.   else
  398.         printf("cmove %p, %p: (%x not moved)", &src, &dst, *dst);
  399.   pc+=2;
  400. }
  401.  
  402. /**
  403.  * cmovne rA, rB 24 rArB
  404.  */
  405. void cmovne(Char reg)
  406. {
  407.   int* src = r1(reg);
  408.   int* dst = r2(reg);
  409.   if(getZF() == 0)
  410.   {
  411.     *dst = *src;
  412.     printf("cmovne %p, %p: (%x moved)", &src, &dst, *dst);
  413.   }
  414.   else
  415.         printf("cmovne %p, %p: (%x not moved)", &src, &dst, *dst);
  416.   pc+=2;
  417. }
  418.  
  419. /**
  420.  * cmovge rA, rB 21 5ArB
  421.  */
  422. void cmovge(Char reg)
  423. {
  424.   int* src = r1(reg);
  425.   int* dst = r2(reg);
  426.   if(getSF() == getZF())
  427.   {
  428.     dst = src;
  429.     printf("cmovge %p, %p: (%x moved)", &src, &dst, *dst);
  430.   }
  431.   else
  432.         printf("cmovge %p, %p: (%x not moved)", &src, &dst, *dst);
  433.   pc+=2;
  434. }
  435.  
  436. /**
  437.  * cmovg rA, rB 26 rArB
  438.  */
  439. void cmovg(Char reg)
  440. {
  441.   int* src = r1(reg);
  442.   int* dst = r2(reg);
  443.   if(getSF() ==0 || getZF() == 0)
  444.   {
  445.     dst = src;
  446.     printf("cmovg %p, %p: (%x moved)", &src, &dst, *dst);
  447.   }
  448.   else
  449.         printf("cmovg %p, %p: (%x not moved)", &src, &dst, *dst);
  450.   pc+=2;
  451. }
  452.  
  453. /**
  454.  * irmov1 V, rb 30 FrB Va Vb Vc Vd
  455.  */
  456. void irmov1(int val, Char reg)
  457. {
  458.   int* rB = r2(reg); 
  459.   *rB = val;
  460.   printf("irmov1 %p, %x", &rB, *rB & 0xffff);
  461.   pc+=6;
  462. }
  463.  
  464. /**
  465.  * rmmov1 rA, D(rB) 40 rArB Da Db Dc Dd
  466.  */
  467. void rmmov1(Char reg, int offset)
  468. {
  469.   int* rA = r1(reg);
  470.   int* rB = r2(reg);
  471.   loadVal(*rA, *rB + offset);
  472.   printf("rmmov1 %p, %x(%x)", &rA, offset & 0xffff, *rB & 0xffff);
  473.   pc+=6;
  474. }
  475.  
  476. /**
  477.  * mrmov1 D(rB), rA 50 rArB Da Db Dc Dd
  478.  */
  479. void mrmov1(Char reg, int offset)
  480. {
  481.   int* rA = r1(reg);
  482.   int* rB = r2(reg);
  483.   *rA = p[*rB + offset];
  484.   printf("mrmov1 %x(%p), %p: (%x)", offset & 0xffff, &rB, &rA, *rA);
  485.   pc+=6;
  486. }
  487.  
  488. /**
  489.  * add1 rA, rB 60 rArB
  490.  */
  491. void add1(Char reg)
  492. {
  493.   int* src = r1(reg);
  494.   int* dst = r2(reg);
  495.   int* tmp = *dst;
  496.   *dst = *dst + *src;
  497.   printf("add1 %s, %s: (%x)", dst, src, *dst);
  498.   setFlags(*tmp, *src, *dst);
  499.   pc+=2;
  500. }
  501.  
  502. /**
  503.  * sub1 rA, rB 61 rArB
  504.  */
  505. void sub1(Char reg)
  506. {
  507.   int* src = r1(reg);
  508.   int* dst = r2(reg);
  509.   int* tmp = *dst;
  510.   *dst = *dst - *src;
  511.   printf("sub1 %s, %s: (%x)", dst, src, *dst);
  512.   pc+=2;
  513. }
  514.  
  515. /**
  516.  * and1 rA, rB 62 rArB
  517.  */
  518. void and1(Char reg)
  519. {
  520.   int  *src = r1(reg);
  521.   int  *dst = r2(reg);
  522.   int  *tmp = dst;
  523.   *dst = *dst & *src;
  524.   printf("and1 %s, %s: (%x)", dst, src, *dst);
  525.   setFlags(*tmp, *src, *dst);
  526.   pc+=2;
  527. }
  528.  
  529. /**
  530.  * xor1 rA, rB 63 rArB
  531.  */
  532. void xor1(Char reg)
  533. {
  534.   int  *src = r1(reg);
  535.   int  *dst = r2(reg);
  536.   int  *tmp = dst;
  537.   *dst = *dst ^ *src;
  538.   printf("xor1 %s, %s: (%x)", dst, src, *dst);
  539.   setFlags(*tmp, *src, *dst);
  540.   pc+=2;
  541. }
  542.  
  543. /**
  544.  * jmp Dest 70 Da Db Dc Dd
  545.  */
  546. void jmp(int dest)
  547. {
  548.   printf("jmp %x", dest);
  549.   pc=dest;
  550.   printf(" (pc=%x)", dest);
  551.   pc+=5;
  552. }
  553.  
  554. /**
  555.  * j1e Dest 71 Da Db Dc Dd
  556.  */
  557. void j1e(int dest)
  558. {
  559.   printf("j1e %x", dest);
  560.   if(getZF()==1 || getSF()!=getOF())
  561.   {
  562.     pc=dest;
  563.     printf(" (pc=%x)", dest);
  564.   }
  565.   else
  566.   {
  567.     printf(" (no)");
  568.     pc+=5;
  569.   }
  570. }
  571.  
  572. /**
  573.  * j1 Dest 72 Da Db Dc Dd
  574.  */
  575. void j1(int dest)
  576. {
  577.   printf("j1 %x", dest);
  578.   if(getZF()!=getOF())
  579.   {
  580.     pc=dest;
  581.     printf(" (pc=%x)", dest);
  582.   }
  583.   else
  584.   {
  585.     printf(" (no)");
  586.     pc+=5;
  587.   }
  588. }
  589.  
  590. /**
  591.  * je Dest 73 Da Db Dc Dd
  592.  */
  593. void je(int dest)
  594. {
  595.   printf("je %x", dest);
  596.   if(getZF()==1)
  597.   {
  598.     pc=dest;
  599.     printf(" (tak)");
  600.   }
  601.   else
  602.   {
  603.     printf(" (no)");
  604.     pc+=5;
  605.   }
  606. }
  607.  
  608. /**
  609.  * jne Dest 74 Da Db Dc Dd
  610.  */
  611. void jne(int dest)
  612. {
  613.   printf("jne %x", dest);
  614.   if(getZF()==0)
  615.   {
  616.     pc=dest;
  617.     printf(" (pc=%x)", pc & 0xff);
  618.   }
  619.   else
  620.   {
  621.     printf(" (not taken)");
  622.     pc+=5;
  623.   }
  624. }
  625.  
  626. /**
  627.  * jge Dest 75 Da Db Dc Dd
  628.  */
  629. void jge(int dest)
  630. {
  631.   printf("jge %x", dest);
  632.   if(getZF()==getSF())
  633.   {
  634.     pc=dest;
  635.     printf(" (pc=%x)", dest);
  636.   }
  637.   else
  638.   {
  639.     printf(" (no)");
  640.     pc+=5;
  641.   }
  642. }
  643.  
  644. /**
  645.  * jg Dest 76 Da Db Dc Dd
  646.  */
  647. void jg(int dest)
  648. {
  649.   printf("jg %x", dest);
  650.   if(getZF()==0 && getSF()==0)
  651.   {
  652.     pc=dest;
  653.     printf(" (pc=%x)", dest);
  654.   }
  655.   else
  656.   {
  657.     printf(" (no)");
  658.     pc+=5;
  659.   }
  660. }
  661.  
  662. /**
  663. * call 80 Da Db Dc Dd
  664. */
  665. void call(int addr)
  666. {
  667.   printf("call %x", addr);
  668.   /* make entry on stack */
  669.   /* push old pc onto stack */
  670.   doPsh(pc);
  671.   pc=addr;
  672. }
  673.  
  674. /* ret	90 */
  675. void ret()
  676. {
  677.   printf("ret");
  678.   pc=p[*esp];
  679.   *esp=*esp+0x4;  /* restore pc from stack */
  680.   pc+=5; /* for how many chars it took to call */
  681. }
  682.  
  683. void doPsh(int val)
  684. { 
  685.   *esp=*esp-4; /* make entry on the stack */
  686.   loadVal(val, *esp);
  687. }
  688.  
  689. /* push1 rA	A0 rAF */
  690. void push1(Char reg)
  691. {
  692.   int  *rA = r1(reg);
  693.   printf("push1 %x", *rA);
  694.   pc+=2;
  695.   doPsh(*rA);
  696. }
  697.  
  698. /* pop1 rA	B0 rAF */
  699. void pop1(Char reg)
  700. {
  701.   int *rA=r1(reg);
  702.   *rA=p[*esp];  /* pull top stack value into rA */
  703.   *esp=*esp+0x4;  /* remove entry from the stack */
  704.   printf("pop1 %s %x", rA, *rA);
  705.   pc+=2;
  706. }
  707.  
  708. int printMemory(int start)
  709. {
  710.   int words_on_screen = 1000;
  711.   for(int i=start; i< start+words_on_screen; i++)
  712.   {
  713.     if(i==(0%4))
  714.       printf(" ");
  715.     printf("%x\t", p[i]);
  716.   }
  717.   return 0;
  718. }
  719.  
  720. /* Decodes the string of Char-sized characters and executes them */
  721. int decode(Char p[])
  722. {
  723.   /*   
  724.   take the first Char
  725.     - determine how many operands
  726.     - call function with right operands
  727.   */
  728.   for(pc=0; pc< programLength;)
  729.   {
  730.  
  731.     printf("\n0x%x:\t", pc & 0xff);
  732.     switch(p[pc] & 0xf0)
  733.     {
  734.       case 0x00:
  735.       {
  736.         if((p[pc] & 0x0f) == 0x0)
  737.         {
  738.           printf("%x\t\t", p[pc]);
  739.           halt();
  740.         }
  741.         else
  742.           printf("Error interpreting halt at pc=%x", pc);
  743.         break;
  744.       }
  745.       case 0x10:
  746.       {
  747.         if((p[pc] & 0x0f) == 0x0)
  748.         {
  749.           printf("%x\t\t", p[pc]);
  750.           nop();
  751.         }
  752.         else
  753.           printf("Error interpreting nop at pc=%x", pc);
  754.         break;
  755.       }
  756.       case 0x20:
  757.       {
  758.         printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
  759.         Char reg=p[pc+1];
  760.         /* 1=4, mov
  761.           rrmov1 rA, rb		20 rArB
  762.           cmov1e rA, rb		21 rArB
  763.           cmov1 rA, rb		22 rArB
  764.           cmove rA, rb		23 rArB
  765.           cmovne rA, rb		24 rArB
  766.           cmovge rA, rb		25 rArB
  767.           cmovg rA, rb		26 rArB
  768.          */
  769.          switch(p[pc] & 0x0f)
  770.          {
  771.            case 0x0:
  772.              rrmov1(reg);
  773.              break;
  774.            case 0x1:
  775.              cmov1e(reg);
  776.              break;
  777.            case 0x2:
  778.              cmov1(reg);
  779.              break;
  780.            case 0x3:
  781.              cmove(reg);
  782.              break;
  783.            case 0x4:
  784.              cmovne(reg);
  785.              break;
  786.            case 0x5:
  787.              cmovge(reg);
  788.              break;
  789.            case 0x6:
  790.              cmovg(reg);
  791.              break;
  792.            default:
  793.              setINS();
  794.              printf("Error interpretinf mov at pc=%x", pc);
  795.              break;
  796.          }
  797.          break;
  798.       }
  799.       case 0x30:
  800.       {
  801.         /* l=8, irmov1 */
  802.         /* irmov1 V,rb		30 FrB V[4] */
  803.         if((p[pc] & 0x0f) == 0x0)
  804.         {
  805.           printf("%x %x %x %x %x %x\t",
  806.                  p[pc] & 0xff,
  807.                  p[pc+1] && 0xff,
  808.                  p[pc+2] && 0xff,
  809.                  p[pc+3] && 0xff,
  810.                  p[pc+4] && 0xff,
  811.                  p[pc+5] && 0xff);
  812.           int val=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
  813.           Char reg=p[pc+1];
  814.           irmov1(val, reg);
  815.         }
  816.         else
  817.         {
  818.           setINS();
  819.           printf("Error interpreting irmov1 at pc=%x", pc);
  820.         }
  821.         break;
  822.       }
  823.       case 0x40:
  824.       {
  825.         /* 1=8, rmmov1 */
  826.         /* rmmov1 rA, D(rB)	40 rArB D[4] */
  827.         if((p[pc] & 0x0f) == 0x0)
  828.         {
  829.           printf("%x %x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
  830.                  p[pc+2] & 0xff, p[pc+3], p[pc+4], p[pc+5]);
  831.           int data=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
  832.           rmmov1(p[pc+1], data);
  833.         }
  834.         else
  835.         {
  836.           setINS();
  837.           printf("Error interpreting rrmov1 at pc=%x", pc);
  838.         }
  839.         break;
  840.       }
  841.       case 0x50:
  842.       {
  843.         /* 1=8, mrmov1 */
  844.         /* mrmov1 D(rB), rA	50 rArB D[4] */
  845.         if((p[pc] & 0x0f) == 0x0)
  846.         {
  847.           printf("%x %x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
  848.                  p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff, p[pc+5] & 0xff);
  849.           int data=getVal(p[pc+2], p[pc+3], p[pc+4], p[pc+5]);
  850.           mrmov1(p[pc+1], data);
  851.         }
  852.         else
  853.         {
  854.           setINS();
  855.           printf("Error interpreting mrmov1 at pc=%x", pc);
  856.         }
  857.         break;
  858.       }
  859.       case 0x60:
  860.       {
  861.         printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
  862.         Char reg=p[pc+1];
  863.         /* 1=4, op */
  864.       /*
  865.       add1 rA, rB	60 rArB
  866.       sub1 rA, rB	61 rArB
  867.       and1 rA, rB	62 rArB
  868.       xor1 rA, rB	63 rArB
  869.        */
  870.         switch(p[pc] & 0x0f)
  871.         {
  872.           case 0x0:
  873.             add1(reg);
  874.             break;
  875.           case 0x1:
  876.             sub1(reg);
  877.             break;
  878.           case 0x2:
  879.             and1(reg);
  880.             break;
  881.           case 0x3:
  882.             xor1(reg);
  883.             break;
  884.           default:
  885.             setINS();
  886.             printf("Problem parsing op at pc=%x", pc);
  887.             break;
  888.         }
  889.         break;
  890.       }
  891.       case 0x70:
  892.       {
  893.         /* 1=8, jmps */
  894.         printf("%x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
  895.                  p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff);
  896.         int dest=getVal(p[pc+1], p[pc+2], p[pc+3], p[pc+4]);
  897.       /* 
  898.       jmp Dest		70 Dest[4]
  899.       j1e Dest		71 Dest[4]
  900.       j1 Dest		72 Dest[4]
  901.       je Dest		73 Dest[4]
  902.       jne Dest		74 Dest[4]
  903.       jge Dest		75 Dest[4]
  904.       jg Dest		76 Dest[4]
  905.         */
  906.         switch(p[pc] & 0x0f)
  907.         {
  908.           case 0x0:
  909.             jmp(dest);
  910.             break;
  911.           case 0x1:
  912.             j1e(dest);
  913.             break;
  914.           case 0x2:
  915.             j1(dest);
  916.             break;
  917.           case 0x3:
  918.             je(dest);
  919.             break;
  920.           case 0x4:
  921.             jne(dest);
  922.             break;
  923.           case 0x5:
  924.             jge(dest);
  925.             break;
  926.           case 0x6:
  927.             jg(dest);
  928.             break;
  929.           default:
  930.             setINS();
  931.             printf("Error interpreting jump at pc=%x", pc);
  932.             break;
  933.         } 
  934.         break;
  935.       }
  936.       case 0x80:
  937.       {
  938.         /* 1=8, call */
  939.         /* call	80 Dest[4] */
  940.         if((p[pc] & 0x0f) == 0x0)
  941.         {
  942.           printf("%x %x %x %x %x\t", p[pc] & 0xff, p[pc+1] & 0xff,
  943.                  p[pc+2] & 0xff, p[pc+3] & 0xff, p[pc+4] & 0xff);
  944.           int dest=getVal(p[pc+1], p[pc+2], p[pc+3], p[pc+4]);
  945.           call(dest);
  946.         }
  947.         else
  948.         {
  949.           setINS();
  950.           printf("Error interpreting call at pc=%x", pc);
  951.         }
  952.         break;
  953.       }
  954.       case 0x90:
  955.       {
  956.         /* 1=2, ret */
  957.         /* ret	90 */
  958.         if((p[pc] & 0x0f) == 0x0)
  959.         {
  960.           printf("%x \t\t", p[pc] & 0xff);
  961.           ret();
  962.         }
  963.         else
  964.         {
  965.           setINS();
  966.           printf("Error interpreting ret at pc=%x", pc);
  967.         }
  968.         break;
  969.       }
  970.       case 0xa0:
  971.       {
  972.         /* 1=4, push */
  973.         /* push1 rA	A0 rAF */
  974.         if((p[pc] & 0x0f) == 0x0)
  975.         {
  976.           printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
  977.           push1((Char) (p[pc+1] & 0xf0));
  978.         }
  979.         else
  980.         {
  981.           setINS();
  982.           printf("Error interpreting push1 at pc=%x", pc);
  983.         }
  984.         break;
  985.       }
  986.       case 0xb0:
  987.       {
  988.         /* 1=4, pop1 */
  989.         /* pop1 rA	B0 rAF */
  990.         if((p[pc] & 0x0f) == 0x0)
  991.         {
  992.           printf("%x %x \t\t", p[pc] & 0xff, p[pc+1] & 0xff);
  993.           pop1((Char)(p[pc+1] & 0xf0));
  994.         }
  995.         else
  996.         {
  997.           setINS();
  998.           printf("Error interpreting pop1 at pc=%x", pc);
  999.         }
  1000.         break;
  1001.       }
  1002.       default:
  1003.       {
  1004.           setINS();
  1005.           printf("Error interpreting instruction at pc=%x", pc);
  1006.       }
  1007.     }
  1008.   } 
  1009.   printRegisters();
  1010.   return 0;   
  1011. }
  1012.  
  1013. void setFlags(int a, int b, int result)
  1014.     {
  1015.         clearFlags();
  1016.         if (result == 0)
  1017.             setZF();
  1018.         if (result < 0)
  1019.             setSF();
  1020.         if (((a & 128) == 128 &&  (b & 128) == 128 &  (result & 128) == 0) ||
  1021.             ((a & 128) == 0   &&  (b & 128) == 0   &  (result & 128) == 128))
  1022.             setOF();
  1023.     }
  1024.  
  1025. /* Program start */
  1026. int main(int argv, char* argc[])
  1027. {
  1028.  
  1029.   for(int p=1; p<argv; p++)
  1030.     printf("%s", argc[p]);
  1031.  
  1032.   setup();
  1033.  
  1034.   if(argv<1)
  1035.     printf("Enter the name:");
  1036.   else
  1037.   {
  1038.  
  1039.     FILE *fp;
  1040.     Char *buf;
  1041.     long fLen;
  1042.  
  1043.     fp = fopen(argc[1], "rb");
  1044.     fseek(fp, 0, SEEK_END);
  1045.     fLen = ftell(fp);
  1046.     rewind(fp);
  1047.     buf = (Char *)malloc((fLen+1)*sizeof(Char));
  1048.     fread(buf, fLen, 1, fp);
  1049.     fclose(fp);
  1050.  
  1051.     FASCII(buf);
  1052.  
  1053.     decode(buf);*/
  1054.   }
  1055.   return 0;
  1056. }
  1057.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
prog.c: In function ‘getVal’:
prog.c:257:32: warning: left shift count >= width of type [-Wshift-count-overflow]
     val=val | (unsigned int) d << 32u;
                                ^~
prog.c: In function ‘add1’:
prog.c:495:14: warning: initialization makes pointer from integer without a cast [-Wint-conversion]
   int* tmp = *dst;
              ^
prog.c:497:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("add1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:497:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("add1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c:498:3: warning: implicit declaration of function ‘setFlags’ [-Wimplicit-function-declaration]
   setFlags(*tmp, *src, *dst);
   ^~~~~~~~
prog.c: In function ‘sub1’:
prog.c:509:14: warning: initialization makes pointer from integer without a cast [-Wint-conversion]
   int* tmp = *dst;
              ^
prog.c:511:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("sub1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:511:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("sub1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c:509:8: warning: unused variable ‘tmp’ [-Wunused-variable]
   int* tmp = *dst;
        ^~~
prog.c: In function ‘and1’:
prog.c:524:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("and1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:524:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("and1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c: In function ‘xor1’:
prog.c:538:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("xor1 %s, %s: (%x)", dst, src, *dst);
                 ^
prog.c:538:21: warning: format ‘%s’ expects argument of type ‘char *’, but argument 3 has type ‘int *’ [-Wformat=]
   printf("xor1 %s, %s: (%x)", dst, src, *dst);
                     ^
prog.c: In function ‘call’:
prog.c:670:3: warning: implicit declaration of function ‘doPsh’ [-Wimplicit-function-declaration]
   doPsh(pc);
   ^~~~~
prog.c: At top level:
prog.c:683:6: warning: conflicting types for ‘doPsh’
 void doPsh(int val)
      ^~~~~
prog.c:670:3: note: previous implicit declaration of ‘doPsh’ was here
   doPsh(pc);
   ^~~~~
prog.c: In function ‘pop1’:
prog.c:704:17: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int *’ [-Wformat=]
   printf("pop1 %s %x", rA, *rA);
                 ^
prog.c: At top level:
prog.c:1013:6: warning: conflicting types for ‘setFlags’
 void setFlags(int a, int b, int result)
      ^~~~~~~~
prog.c:498:3: note: previous implicit declaration of ‘setFlags’ was here
   setFlags(*tmp, *src, *dst);
   ^~~~~~~~
prog.c: In function ‘setFlags’:
prog.c:1020:45: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
         if (((a & 128) == 128 &&  (b & 128) == 128 &  (result & 128) == 0) ||
                                   ~~~~~~~~~~^~~~~~
prog.c:1021:45: warning: suggest parentheses around comparison in operand of ‘&’ [-Wparentheses]
             ((a & 128) == 0   &&  (b & 128) == 0   &  (result & 128) == 128))
                                   ~~~~~~~~~~^~~~
prog.c: In function ‘main’:
prog.c:1053:18: error: expected expression before ‘/’ token
     decode(buf);*/
                  ^
stdout
copy 
Standard output is empty
https://ideone.com/SqZQUX
language:
C (gcc 8.3)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!