Subversion Repositories Kolibri OS

Rev

Rev 7563 | 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.         dword p = 0;
  51.         dataArgs = malloc(16*4);
  52.         posArgs = dataArgs;
  53.         name = malloc(100);
  54.         pos = name;
  55.         loop()
  56.         {
  57.                 s = DSBYTE[code];
  58.                
  59.                 while(s == ' ')
  60.                 {
  61.                         code++;
  62.                         s = DSBYTE[code];
  63.                 }
  64.                
  65.                 if (!s) || (s==')')
  66.                 {
  67.                         code++;
  68.                         break;
  69.                 }
  70.                
  71.                 if (!args)
  72.                 {
  73.                         if (s != ')') // name function
  74.                         {
  75.                                 while (s != ' ') && (s != ')')
  76.                                 {
  77.                                         DSBYTE[pos] = s;
  78.                                         pos++;
  79.                                         code++;
  80.                                         s = DSBYTE[code];
  81.                                 }
  82.                                 code--;
  83.                         }
  84.                 }
  85.                 else
  86.                 {
  87.                         if(s == '(')
  88.                         {
  89.                                 code++;
  90.                                 tmp = evalLisp();
  91.                         }
  92.                         else if (s >= '0') && (s <= '9')
  93.                         {
  94.                                 tmp = 0;
  95.                                 while (s >= '0') && (s <= '9')
  96.                                 {
  97.                                         tmp *= 10;
  98.                                         tmp += s-'0';
  99.                                         code++;
  100.                                         s = DSBYTE[code];
  101.                                 }
  102.                                 code--;
  103.                         }
  104.                         else if (s == '"')
  105.                         {
  106.                                 tmp = malloc(100);
  107.                                 p = tmp;
  108.                                 code++;
  109.                                 s = DSBYTE[code];
  110.                                 while (s != '"') && (s)
  111.                                 {
  112.                                         DSBYTE[p] = s;
  113.                                         p++;
  114.                                        
  115.                                         code++;
  116.                                         s = DSBYTE[code];
  117.                                 }
  118.                                 DSBYTE[p] = 0;
  119.                         }
  120.                         else if(s >= 'A') && (s <= 'z')
  121.                         {
  122.                                 tmp = malloc(100);
  123.                                 p = tmp;
  124.                                 while (s >= 'A') && (s <= 'z')
  125.                                 {
  126.                                         DSBYTE[p] = s;
  127.                                         p++;
  128.                                        
  129.                                         code++;
  130.                                         s = DSBYTE[code];
  131.                                 }
  132.                                 DSBYTE[p] = 0;
  133.                         }
  134.                        
  135.                         DSDWORD[posArgs] = tmp;
  136.                         posArgs += 4;
  137.                 }
  138.                 code++;
  139.                 args++;
  140.         }
  141.         args--;
  142.         ret = StdCall(args, name, dataArgs);
  143.         free(name);
  144.         free(dataArgs);
  145.         return ret;
  146. }
  147.  
  148. void main()
  149. {
  150.         dword brainFuckCode = 0;
  151.         word maxLoop = 1000;
  152.         dword txt = "  (print 1)(print 2)";
  153.        
  154.         buffer = malloc(bufferSize);
  155.         memory = malloc(memoryBrainfuck);
  156.         stack = malloc(stackBrainFuck);
  157.        
  158.         Init();
  159.        
  160.         IF(DSBYTE[I_Param])
  161.         {
  162.                 IF(io.read(I_Param))
  163.                 {
  164.                         code = EAX;
  165.                         loop()
  166.                         {
  167.                                 WHILE(DSBYTE[code] == ' ') code++;
  168.                                 IF(DSBYTE[code]!='(') BREAK;
  169.                                 ELSE code++;
  170.                                 evalLisp();
  171.                                 code--;
  172.                                 IF(DSBYTE[code]!=')') BREAK;
  173.                                 ELSE code++;
  174.                         }
  175.                 }
  176.         }
  177.         else
  178.         {
  179.                 consoleInit();
  180.                 con_printf stdcall ("Lisp interpreter v1.2");
  181.                 while(maxLoop)
  182.                 {
  183.                         con_printf stdcall ("\r\n\r\nEnter code: ");
  184.                         con_gets stdcall(buffer, bufferSize);
  185.                         code = EAX;
  186.                         //code = txt;
  187.                         con_printf stdcall ("Output: ");
  188.                         nextLispLine:
  189.                         while(DSBYTE[code] == ' ') code++;
  190.                         if(DSBYTE[code] == '(') code++;
  191.                         else goto endNext;
  192.                         evalLisp();
  193.                         code--;
  194.                         if(DSBYTE[code]==')') code++;
  195.                         else goto endNext;
  196.                         IF(!DSBYTE[code]) goto endNext;
  197.                         goto nextLispLine;
  198.                         endNext:
  199.                         maxLoop--;
  200.                 }
  201.         }
  202.        
  203.         IF(initConsole) con_exit stdcall (0);
  204.         ExitProcess();
  205. }
  206.  
  207.