Subversion Repositories Kolibri OS

Rev

Rev 7567 | 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. #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. #define TStr 1
  23. #define TInt 2
  24. #define TSym 3
  25. #define TBol 4
  26.  
  27. #define TLen 4*5
  28.  
  29. dword buffer = 0;
  30. word bufferSymbol = 0;
  31. dword memory = 0;
  32.  
  33. dword stack = 0;
  34. dword code = 0;
  35. byte tempBuffer[100] = {0};
  36.  
  37. void consoleInit()
  38. {
  39.         IF(!initConsole)
  40.         {
  41.                 load_dll(libConsole, #con_init, 0);
  42.                 con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
  43.                 initConsole = 0xFF;
  44.         }
  45. }
  46.  
  47. dword evalLisp()
  48. {
  49.         byte s = 0;
  50.         byte args = 0;
  51.         dword pos = 0;
  52.         dword name = 0;
  53.         dword tmp = 0;
  54.         dword tmp2 = 0;
  55.         dword dataArgs = 0;
  56.         dword posArgs = 0;
  57.         dword ret = 0;
  58.         dword p = 0;
  59.         dword i = 0;
  60.         dword ii = 0;
  61.         dataArgs = malloc(16*4);
  62.         posArgs = dataArgs;
  63.  
  64.         loop()
  65.         {
  66.                 s = DSBYTE[code];
  67.                 while (s == ' ') || (s == 9) || (s == 10) || (s == 13)
  68.                 {
  69.                         code++;
  70.                         s = DSBYTE[code];
  71.                 }
  72.                 if (!s) return 0;
  73.                 if (s==')')
  74.                 {
  75.                         code++;
  76.                         args--;
  77.                         ret = StdCall(args, name, dataArgs);
  78.                         free(name);
  79.                         //free(dataArgs);
  80.                         return ret;
  81.                 }
  82.                 if(s == '(')
  83.                 {
  84.                         code++;
  85.                         DSDWORD[posArgs] = evalLisp();
  86.                         args++;
  87.                         posArgs += 4;
  88.                         continue;
  89.                 }
  90.                 else if (!args)
  91.                 {
  92.                         if (s != ')') // name function
  93.                         {
  94.                                 name = malloc(100);
  95.                                 pos = name;
  96.                                 while (s) && (s != ' ') && (s != ')')
  97.                                 {
  98.                                         DSBYTE[pos] = s;
  99.                                         pos++;
  100.                                         code++;
  101.                                         s = DSBYTE[code];
  102.                                 }      
  103.                                 DSBYTE[pos] = 0;
  104.                                 args++;
  105.                                 continue;
  106.                         }
  107.                 }
  108.                 else
  109.                 {
  110.                         if (s >= '0') && (s <= '9')
  111.                         {
  112.                                 tmp = 0;
  113.                                 while (s >= '0') && (s <= '9')
  114.                                 {
  115.                                         tmp *= 10;
  116.                                         tmp += s-'0';
  117.                                         code++;
  118.                                         s = DSBYTE[code];
  119.                                 }
  120.                                 args++;
  121.                                 EDX = malloc(TLen);
  122.                                 DSDWORD[EDX] = tmp;
  123.                                 DSDWORD[EDX+4] = TInt;
  124.                                 DSDWORD[posArgs] = EDX;
  125.                                 posArgs += 4;
  126.                                 continue;
  127.                         }
  128.                         else if (s == '"')
  129.                         {
  130.                                 i = 1;
  131.                                 tmp = malloc(1<<i);
  132.                                 p = tmp;
  133.                                 code++;
  134.                                 s = DSBYTE[code];
  135.                                 ii = 0;
  136.                                 while (s != '"') && (s)
  137.                                 {
  138.                                         ii++;
  139.                                         if (1<<i < ii)
  140.                                         {
  141.                                                 i++;
  142.                                                 tmp2 = p-tmp;
  143.                                                 tmp = realloc(tmp, 1<<i);
  144.                                                 p = tmp+tmp2;
  145.                                         }
  146.                                         DSBYTE[p] = s;
  147.                                         p++;
  148.                                        
  149.                                         code++;
  150.                                         s = DSBYTE[code];
  151.                                 }
  152.                                 DSBYTE[p] = 0;
  153.                                 EDX = malloc(TLen);
  154.                                 DSDWORD[EDX] = tmp;
  155.                                 DSDWORD[EDX+4] = TStr;
  156.                                 DSDWORD[EDX+8] = p-tmp;
  157.                                 DSDWORD[posArgs] = EDX;
  158.                                 posArgs += 4;
  159.                                 code++;
  160.                                 args++;
  161.                                 continue;
  162.                         }
  163.                         else
  164.                         {
  165.                                 tmp = malloc(20);
  166.                                 p = tmp;
  167.                                 while (s) && (s != ')') && (s != '(') && (s != ' ') && (s != 10) && (s != 13)
  168.                                 {
  169.                                         DSBYTE[p] = s;
  170.                                         p++;
  171.                                         code++;
  172.                                         s = DSBYTE[code];
  173.                                 }
  174.                                 DSBYTE[p] = 0;
  175.                                 args++;
  176.                                 EDX = malloc(TLen);
  177.                                 DSDWORD[EDX] = tmp;
  178.                                 DSDWORD[EDX+4] = TSym;
  179.                                 DSDWORD[posArgs] = EDX;
  180.                                 posArgs += 4;
  181.                                 continue;
  182.                         }
  183.                        
  184.                         DSDWORD[posArgs] = tmp;
  185.                         posArgs += 4;
  186.                 }
  187.                 code++;
  188.                 args++;
  189.         }
  190.         args--;
  191.         ret = StdCall(args, name, dataArgs);
  192.         free(name);
  193.         //free(dataArgs);
  194.         return ret;
  195. }
  196.  
  197. void main()
  198. {
  199.         dword brainFuckCode = 0;
  200.         word maxLoop = 1000;
  201.         dword txt = "(set name (input \"Enter you name: \"))(print \"You name \" (get name))";
  202.        
  203.         buffer = malloc(bufferSize);
  204.         memory = malloc(memoryBrainfuck);
  205.         stack = malloc(stackBrainFuck);
  206.        
  207.         Init();
  208.        
  209.         IF(DSBYTE[I_Param])
  210.         {
  211.                 IF(io.read(I_Param))
  212.                 {
  213.                         code = EAX;
  214.                         evalLisp();
  215.                 }
  216.         }
  217.         else
  218.         {
  219.                 consoleInit();
  220.                 con_printf stdcall ("Lisp interpreter v1.5\r\n");
  221.                 while(maxLoop)
  222.                 {
  223.                         con_printf stdcall ("\r\n$ ");
  224.                         con_gets stdcall(buffer, bufferSize);
  225.                         code = EAX;
  226.                         //code = txt;
  227.                         con_printf stdcall ("Output: ");
  228.                         evalLisp();
  229.                         maxLoop--;
  230.                 }
  231.         }
  232.        
  233.         IF(initConsole) con_exit stdcall (0);
  234.         ExitProcess();
  235. }
  236.  
  237.