Subversion Repositories Kolibri OS

Rev

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