Subversion Repositories Kolibri OS

Rev

Rev 7560 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Author Pavel Iakovlev
  3. */
  4.  
  5. #define MEMSIZE 4096*10
  6.  
  7. #include "../lib/io.h"
  8. #include "../lib/obj/console.h"
  9.  
  10. #define bufferSize 10000;
  11. #define memoryBrainfuck 30000
  12. #define memoryByteBF 1
  13. #define stackBrainFuck 4*1024
  14.  
  15. dword buffer = 0;
  16. word bufferSymbol = 0;
  17. dword memory = 0;
  18. byte initConsole = 0;
  19. dword stack = 0;
  20.  
  21. void consoleInit()
  22. {
  23.         IF(!initConsole)
  24.         {
  25.                 load_dll(libConsole, #con_init, 0);
  26.                 con_init stdcall (-1, -1, -1, -1, "BrainF*ck interpreter");
  27.                 initConsole = 0xFF;
  28.         }
  29. }
  30.  
  31. void evalBrainFuckCode(dword code)
  32. {
  33.         dword offsetMemory = 0;
  34.         dword countStack = 0;
  35.         dword countOffset = memoryBrainfuck / 2 / memoryByteBF;
  36.         offsetMemory = memory;
  37.         // clear memory
  38.         EBX = memoryBrainfuck;
  39.         offsetMemory = memory;
  40.         WHILE(EBX)
  41.         {
  42.                 EBX--;
  43.                 DSBYTE[offsetMemory] = 0;
  44.                 offsetMemory++;
  45.         }
  46.         //--------
  47.        
  48.         offsetMemory = memory + countOffset;
  49.         countStack = stack;
  50.        
  51.         WHILE(1)
  52.         {
  53.                 switch(DSBYTE[code])
  54.                 {
  55.                         case '+':
  56.                                 DSBYTE[offsetMemory]++;
  57.                         break;
  58.                         case '-':
  59.                                 DSBYTE[offsetMemory]--;
  60.                         break;
  61.                         case '[':
  62.                                 DSDWORD[countStack] = code;
  63.                                 countStack += 4;
  64.                         break;
  65.                         case ']':
  66.                                 IF (DSBYTE[offsetMemory]) code = DSDWORD[countStack - 4];
  67.                                 ELSE countStack -= 4;
  68.                         break;
  69.                         case ',':
  70.                                 consoleInit();
  71.                                 con_getch stdcall();
  72.                                 DSBYTE[offsetMemory] = AL;
  73.                         break;
  74.                         case '.':
  75.                                 consoleInit();
  76.                                 DSBYTE[#bufferSymbol] = DSBYTE[offsetMemory];
  77.                                 con_printf stdcall (#bufferSymbol);
  78.                         break;
  79.                         case '>':
  80.                                 offsetMemory++;
  81.                         break;
  82.                         case '<':
  83.                                 offsetMemory--;
  84.                         break;
  85.                         case 0:
  86.                                 return;
  87.                         break;
  88.                 }
  89.                 code++;
  90.         }
  91. }
  92.  
  93.  
  94. void main()
  95. {
  96.         dword brainFuckCode = 0;
  97.         word maxLoop = 1000;
  98.        
  99.         buffer = malloc(bufferSize);
  100.         memory = malloc(memoryBrainfuck);
  101.         stack = malloc(stackBrainFuck);
  102.        
  103.         IF(DSBYTE[I_Param])
  104.         {
  105.                 IF(io.read(I_Param)) evalBrainFuckCode(EAX);
  106.         }
  107.         ELSE
  108.         {
  109.                 consoleInit();
  110.                 con_printf stdcall ("BrainF*ck interpreter v1.05");
  111.                 WHILE(maxLoop)
  112.                 {
  113.                         con_printf stdcall ("\r\n\r\nEnter code: ");
  114.                         con_gets stdcall(buffer, bufferSize);
  115.                         brainFuckCode = EAX;
  116.                         con_printf stdcall ("Output: ");
  117.                         evalBrainFuckCode(brainFuckCode);
  118.                         maxLoop--;
  119.                 }
  120.         }
  121.        
  122.         IF(initConsole) con_exit stdcall (0);
  123.         ExitProcess();
  124. }
  125.  
  126.