Subversion Repositories Kolibri OS

Rev

Rev 7844 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.         STDCALL function
  3.         Author: PaulCodeman
  4. */
  5.  
  6. void initFunctionLisp()
  7. {
  8.         set_procedure("TEST",  #lisp_test);
  9.         set_procedure("SLEEP", #lisp_sleep);
  10.         set_procedure("PRINT", #lisp_print);
  11.         set_procedure("INPUT", #lisp_input);   
  12.         set_procedure("STDCALL", #lisp_stdcall);
  13.         set_procedure("SETQ",   #lisp_setq);
  14.         set_procedure("DEFVAR", #lisp_setq);
  15.         set_procedure("+",     #lisp_add);
  16.         set_procedure("-",     #lisp_sub);
  17.         set_procedure("=",     #lisp_cmp);
  18. }
  19.  
  20. dword lisp_test(dword args)
  21. {
  22.         malloc(sizeStruct);
  23.         DSDWORD[EAX] = TString;
  24.         DSDWORD[EAX+4] = "ZZZ";
  25.         return EAX;
  26. }
  27.  
  28. dword lisp_setq(dword args)
  29. {
  30.         dword i = 0;
  31.         dword name = 0;
  32.         dword data = 0;
  33.         while(1)
  34.         {
  35.                 i++;
  36.                 data = indexArray(args, i);
  37.                 data = DSDWORD[data];
  38.                 IF (!data) break;
  39.                
  40.                 if (i&1)
  41.                 {
  42.                         name = DSDWORD[data+4];
  43.                 }
  44.                 else
  45.                 {
  46.                         set_variable(name, data);
  47.                 }
  48.         }
  49.         return 0;
  50. }
  51.  
  52. dword lisp_print(dword args)
  53. {
  54.         dword i = 0;
  55.         consoleInit();
  56.         while(1)
  57.         {
  58.                 i++;
  59.                 indexArray(args, i);
  60.                 IF (!DSDWORD[EAX]) break;
  61.                 con_printf stdcall (string(DSDWORD[EAX]));
  62.         }
  63.         con_printf stdcall ("\r\n");
  64.         return 0;
  65. }
  66.  
  67. dword lisp_stdcall(dword args)
  68. {
  69.         dword i = 0;
  70.         dword buffer = 0;
  71.         while(1)
  72.         {
  73.                 i++;
  74.                 indexArray(args, i);
  75.                 buffer = DSDWORD[EAX];
  76.                 IF (!buffer) break;
  77.                 $push DSDWORD[buffer+4];
  78.         }
  79.         IF (i == 2) $pop eax
  80.         IF (i == 3) $pop ebx
  81.         IF (i == 4) $pop ecx
  82.         $int 0x40
  83.         return EAX;
  84. }
  85.  
  86. dword lisp_input(dword args)
  87. {
  88.         dword buffer = 0;
  89.         consoleInit();
  90.         buffer = malloc(100);
  91.         con_gets stdcall(buffer, 100);
  92.         malloc(sizeStruct);
  93.         DSDWORD[EAX] = TString;
  94.         DSDWORD[EAX+4] = buffer;
  95.         return EAX;
  96. }
  97.  
  98. dword lisp_inc(dword args)
  99. {
  100.         dword i = 0;
  101.         dword sum = 0;
  102.         dword buffer = 0;
  103.         while(1)
  104.         {
  105.                 i++;
  106.                 buffer = indexArray(args, i);
  107.                 IF (!DSDWORD[buffer]) break;
  108.                 buffer = DSDWORD[buffer];
  109.         }
  110.         return 0;
  111. }
  112.  
  113. dword lisp_add(dword args)
  114. {
  115.         dword i = 0;
  116.         dword sum = 0;
  117.         dword buffer = 0;
  118.         while(1)
  119.         {
  120.                 i++;
  121.                 buffer = indexArray(args, i);
  122.                 IF (!DSDWORD[buffer]) break;
  123.                 buffer = DSDWORD[buffer];
  124.                
  125.                 sum += number(buffer);
  126.         }
  127.         malloc(sizeStruct);
  128.         DSDWORD[EAX] = TNumber;
  129.         DSDWORD[EAX+4] = sum;
  130.         return EAX;
  131. }
  132.  
  133. dword lisp_sub(dword args)
  134. {
  135.         dword i = 0;
  136.         dword sum = 0;
  137.         while(1)
  138.         {
  139.                 i++;
  140.                 indexArray(args, i);
  141.                 IF (!DSDWORD[EAX]) break;
  142.                 sum -= number(DSDWORD[EAX]);
  143.         }
  144.         malloc(sizeStruct);
  145.         DSDWORD[EAX] = TNumber;
  146.         DSDWORD[EAX+4] = sum;
  147.         return EAX;
  148. }
  149.  
  150. dword lisp_cmp(dword args)
  151. {
  152.         dword i = 0;
  153.         dword first = 0;
  154.         dword buffer = 0;
  155.        
  156.         while(1)
  157.         {
  158.                 i++;
  159.                 buffer = indexArray(args, i);
  160.                 buffer = DSDWORD[buffer];
  161.                 IF (!buffer) break;
  162.                 if (i == 1)
  163.                 {
  164.                         first = buffer;
  165.                 }
  166.                 else
  167.                 {
  168.                         if (DSDWORD[first+4] != DSDWORD[buffer+4])
  169.                         {
  170.                                 malloc(sizeStruct);
  171.                                 DSDWORD[EAX] = TSymbol;
  172.                                 DSDWORD[EAX+4] = NIL;
  173.                                 return EAX;
  174.                         }
  175.                 }
  176.         }
  177.         if (i == 1) error_message("*** - EVAL: too few arguments given to =: (=)");
  178.         malloc(sizeStruct);
  179.         DSDWORD[EAX] = TSymbol;
  180.         DSDWORD[EAX+4] = "T";
  181.         return EAX;
  182. }
  183.  
  184. dword lisp_sleep(dword args)
  185. {
  186.         dword time = 0;
  187.         indexArray(args, 1);
  188.         time = number(DSDWORD[EAX]);
  189.         EAX = 5;
  190.         EBX = time;
  191.         $int 0x40
  192.         return 0;
  193. }
  194.