Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | 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. byte initConsole = 0;
  11.  
  12. #include "stdcall.h"
  13.  
  14. #define bufferSize 10000;
  15. #define memoryBrainfuck 30000*4
  16. #define memoryByteBF 1
  17. #define stackBrainFuck 4*1024
  18.  
  19. dword buffer = 0;
  20. word bufferSymbol = 0;
  21. dword memory = 0;
  22.  
  23. dword stack = 0;
  24. dword code = 0;
  25. byte tempBuffer[100] = {0};
  26.  
  27. void consoleInit()
  28. {
  29.         IF(!initConsole)
  30.         {
  31.                 load_dll(libConsole, #con_init, 0);
  32.                 con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
  33.                 initConsole = 0xFF;
  34.         }
  35. }
  36.  
  37. dword evalLisp()
  38. {
  39.         byte s = 0;
  40.         byte args = 0;
  41.         dword pos = 0;
  42.         dword name = 0;
  43.         dword tmp = 0;
  44.         dword dataArgs = 0;
  45.         dword posArgs = 0;
  46.         dword ret = 0;
  47.         dataArgs = malloc(16*4);
  48.         posArgs = dataArgs;
  49.         name = malloc(100);
  50.         pos = name;
  51.         loop()
  52.         {
  53.                 s = DSBYTE[code];
  54.                 while(s == ' ')
  55.                 {
  56.                         code++;
  57.                         s = DSBYTE[code];
  58.                 }
  59.                 if (!s) || (s==')')
  60.                 {
  61.                         code++;
  62.                         break;
  63.                 }
  64.                 if (!args)
  65.                 {
  66.                         if(s>='A') && (s<='z') // name function
  67.                         {
  68.                                 while (s>='A') && (s<='z')
  69.                                 {
  70.                                         DSBYTE[pos] = s;
  71.                                         code++;
  72.                                         s = DSBYTE[code];
  73.                                         pos++;
  74.                                 }
  75.                                 code--;
  76.                         }
  77.                 }
  78.                 else
  79.                 {
  80.                         if(s == '(')
  81.                         {
  82.                                 code++;
  83.                                 DSDWORD[posArgs] = evalLisp();
  84.                                 posArgs += 4;
  85.                         }
  86.                         else if (s >= '0') && (s <= '9')
  87.                         {
  88.                                 tmp = 0;
  89.                                 while (s >= '0') && (s <= '9')
  90.                                 {
  91.                                         tmp *= 10;
  92.                                         tmp += s-'0';
  93.                                         code++;
  94.                                         s = DSBYTE[code];
  95.                                 }
  96.                                 code--;
  97.                                 DSDWORD[posArgs] = tmp;
  98.                                 posArgs += 4;
  99.                         }
  100.                 }
  101.                 code++;
  102.                 args++;
  103.         }
  104.         args -= 2;
  105.         ret = StdCall(args, name, dataArgs);
  106.         free(name);
  107.         free(dataArgs);
  108.         return ret;
  109. }
  110.  
  111.  
  112. void main()
  113. {
  114.         dword brainFuckCode = 0;
  115.         word maxLoop = 1000;
  116.        
  117.         buffer = malloc(bufferSize);
  118.         memory = malloc(memoryBrainfuck);
  119.         stack = malloc(stackBrainFuck);
  120.        
  121.         IF(DSBYTE[I_Param])
  122.         {
  123.                 IF(io.read(I_Param))
  124.                 {
  125.                         code = EAX;
  126.                         loop()
  127.                         {
  128.                                 if(DSBYTE[code]!='(') break;
  129.                                 else code++;
  130.                                 evalLisp();
  131.                                 if(DSBYTE[code]!=')') break;
  132.                                 code++;
  133.                         }
  134.                 }
  135.         }
  136.         ELSE
  137.         {
  138.                 consoleInit();
  139.                 con_printf stdcall ("Lisp interpreter v1.0");
  140.                 WHILE(maxLoop)
  141.                 {
  142.                         con_printf stdcall ("\r\n\r\nEnter code: ");
  143.                         con_gets stdcall(buffer, bufferSize);
  144.                         code = EAX;
  145.                         con_printf stdcall ("Output: ");
  146.                         nextLispLine:
  147.                         if(DSBYTE[code]!='(') continue;
  148.                         else code++;
  149.                         evalLisp();
  150.                         if(DSBYTE[code]!=')') continue;
  151.                         code++;
  152.                         goto nextLispLine;
  153.                         maxLoop--;
  154.                 }
  155.         }
  156.        
  157.         IF(initConsole) con_exit stdcall (0);
  158.         ExitProcess();
  159. }
  160.  
  161.