Subversion Repositories Kolibri OS

Rev

Rev 7567 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. /* Lisp functions */
  3. :dword std_exit()
  4. {
  5.         con_exit stdcall (1);
  6.         ExitProcess();
  7. }
  8.  
  9. :dword std_set(dword count, args)
  10. {
  11.         dword name = 0;
  12.         dword value = 0;
  13.         WHILE(count > 0)
  14.         {
  15.                 name = DSDWORD[args];
  16.                 IF (DSDWORD[name+4] == TSym) name = DSDWORD[name];
  17.                 ELSE
  18.                 {
  19.                         con_printf stdcall ("Error variable!");
  20.                         ExitProcess();
  21.                 }
  22.                 args += 4;
  23.                 value = DSDWORD[args];
  24.                 args += 4;
  25.                 variables.set(name, value);
  26.                 count -= 2;
  27.         }
  28. }
  29.  
  30. :dword std_get(dword count, args)
  31. {
  32.         dword name = 0;
  33.         IF(!count) RETURN 0;
  34.         name = DSDWORD[args];
  35.         IF (DSDWORD[name+4] != TSym)
  36.         {
  37.                 con_printf stdcall ("Error variable!");
  38.                 ExitProcess();
  39.         }
  40.         RETURN variables.get(DSDWORD[name]);
  41. }
  42.  
  43. :dword std_str(dword count, args)
  44. {
  45.         dword tmp = 0;
  46.         IF(!count) RETURN "";
  47.         tmp = malloc(15);
  48.         itoa_(tmp,DSDWORD[args]);
  49.         RETURN tmp;
  50. }
  51.  
  52. /* Math functions */
  53. :dword std_add(dword count, args)
  54. {
  55.         dword ret = 0;
  56.         WHILE(count)
  57.         {
  58.                 ret += DSDWORD[args];
  59.                 args+=4;
  60.                 count--;
  61.         }
  62.         RETURN ret;
  63. }
  64.  
  65. :dword std_sub(dword count, args)
  66. {
  67.         dword ret = 0;
  68.         IF(count)
  69.         {
  70.                 ret = DSDWORD[args];
  71.                 count--;
  72.                 args+=4;
  73.         }
  74.         WHILE(count)
  75.         {
  76.                 ret -= DSDWORD[args];
  77.                 args += 4;
  78.                 count--;
  79.         }
  80.         RETURN ret;
  81. }
  82.  
  83. /* Console functions */
  84. :dword std_print(dword count, args)
  85. {
  86.         dword ret = 0;
  87.         dword arg = 0;
  88.         dword val = 0;
  89.         consoleInit();
  90.         IF (!count) con_printf stdcall ("nil");
  91.         WHILE(count)
  92.         {
  93.                 arg = DSDWORD[args];
  94.                 REPEAT1:
  95.                 IF (DSDWORD[arg+4] == TInt) val = itoa(DSDWORD[arg]);
  96.                 ELSE IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg];
  97.                 ELSE IF (DSDWORD[arg+4] == TSym)
  98.                 {
  99.                         arg = std_get(1, args);
  100.                         goto REPEAT1;
  101.                 }
  102.                 IF(!arg) con_printf stdcall ("nil");
  103.                 ELSE con_printf stdcall (val);
  104.                 args+=4;
  105.                 count--;
  106.         }
  107.         RETURN ret;
  108. }
  109.  
  110. :dword std_len(dword count, args)
  111. {
  112.         dword ret = 0;
  113.         dword arg = 0;
  114.         dword val = 0;
  115.         ret = malloc(TLen);
  116.         DSDWORD[ret] = 0;
  117.         DSDWORD[ret+4] = TInt;
  118.         WHILE(count)
  119.         {
  120.                 arg = DSDWORD[args];
  121.                 REPEAT1:
  122.                 IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg];
  123.                 ELSE IF (DSDWORD[arg+4] == TSym)
  124.                 {
  125.                         arg = std_get(1, args);
  126.                         goto REPEAT1;
  127.                 }
  128.                 ELSE return ret;
  129.                 DSDWORD[ret] += DSDWORD[arg+8];
  130.                 args+=4;
  131.                 count--;
  132.         }
  133.         RETURN ret;
  134. }
  135.  
  136. :dword std_cmp(dword count, args)
  137. {
  138.         dword ret = 0;
  139.         dword arg = 0;
  140.         dword val = 0;
  141.         dword tmp = 0;
  142.         dword x = 0;
  143.         dword y = 0;
  144.         byte start = 0;
  145.         ret = malloc(TLen);
  146.         DSDWORD[ret] = 0;
  147.         DSDWORD[ret+4] = TInt;
  148.         IF (!count) return ret;
  149.         while(count)
  150.         {
  151.                 arg = DSDWORD[args];
  152.                 REPEAT2:
  153.                 IF (DSDWORD[arg+4] == TSym)
  154.                 {
  155.                         arg = std_get(1, args);
  156.                         goto REPEAT2;
  157.                 }
  158.                 IF (!start)
  159.                 {
  160.                         start = 1;
  161.                         tmp = arg;
  162.                         args+=4;
  163.                         count--;
  164.                         continue;
  165.                 }
  166.                 IF (DSDWORD[tmp+4] != DSDWORD[arg+4]) return ret;
  167.                 IF (DSDWORD[tmp+4] == TInt)
  168.                 {
  169.                         IF (DSDWORD[tmp] != DSDWORD[arg]) return ret;
  170.                 }
  171.                 ELSE IF (DSDWORD[tmp+4] == TStr)
  172.                 {
  173.                         /*IF (!DSDWORD[tmp+8]) DSDWORD[tmp+8] = crc32(DSDWORD[tmp]);
  174.                         IF (!DSDWORD[arg+8]) DSDWORD[arg+8] = crc32(DSDWORD[arg]);
  175.                         IF (DSDWORD[tmp+8] != DSDWORD[arg+8]) return ret;*/
  176.                         IF (strcmp(DSDWORD[tmp], DSDWORD[arg])) return ret;
  177.                 }
  178.                 args+=4;
  179.                 count--;
  180.         }
  181.         DSDWORD[ret] = 1;
  182.         return ret;
  183. }
  184.  
  185. :dword std_input(dword count, args)
  186. {
  187.         dword buf = 0;
  188.         consoleInit();
  189.         buf = malloc(100);
  190.         IF (count) std_print(count, args);
  191.         con_gets stdcall(buf, 100);
  192.         EDX = malloc(TLen);
  193.         DSDWORD[EDX] = buf;
  194.         DSDWORD[EDX+4] = TStr;
  195.         RETURN EDX;
  196. }
  197.  
  198. void Init()
  199. {
  200.         functions.init(100);
  201.        
  202.         /* Console functions */
  203.         functions.set("print", #std_print);
  204.         functions.set("input", #std_input);
  205.        
  206.         /* String functions */
  207.         functions.set("str", #std_str);
  208.         functions.set("len", #std_len);
  209.        
  210.         /* System functions */
  211.         functions.set("exit", #std_exit);
  212.        
  213.         /* Math functions */
  214.         functions.set("+", #std_add);
  215.         functions.set("-", #std_sub);
  216.         functions.set("==", #std_cmp);
  217.        
  218.         /* Lisp functions */
  219.         functions.set("set", #std_set);
  220.         functions.set("get", #std_get);
  221.        
  222.         variables.init(100);
  223. }
  224.  
  225. dword StdCall(dword count, name, args)
  226. {
  227.         functions.get(name);
  228.         IF(EAX) RETURN EAX(count, args);
  229.         RETURN 0;
  230. }
  231.  
  232.