Subversion Repositories Kolibri OS

Rev

Rev 7744 | Blame | Last modification | View Log | Download | RSS feed

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