Subversion Repositories Kolibri OS

Rev

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