Subversion Repositories Kolibri OS

Rev

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

  1.  
  2.  
  3. :void copyVariable(dword x)
  4. {
  5.         load_const(DSDWORD[x],DSBYTE[x+4],DSDWORD[x+5]);
  6. }
  7.  
  8.  
  9. :dword LenStdout = 0;
  10. :void _stdout(dword txt)
  11. {
  12.         dword addr = txt;
  13.         WHILE(DSBYTE[addr]) addr++;
  14.         IF(!LenStdout)
  15.         {
  16.                 LenStdout = addr-txt;
  17.                 CreateFile(LenStdout,txt,"/sys/stdout");
  18.         }
  19.         ELSE
  20.         {
  21.                 AddFile(LenStdout,addr-txt,txt,"/sys/stdout");
  22.                 LenStdout+=addr-txt;
  23.         }
  24. }
  25. :dword std__stdStr(dword count)
  26. {
  27.         return _str(popFast());
  28. }
  29. :dword stdcall std__stdout(dword count)
  30. {
  31.         std__str(count);
  32.         popStack();
  33.         _stdout(DSDWORD[EAX]);
  34. }
  35. :dword stdcall std__len(dword c)
  36. {
  37.         popFast();
  38.         load_const(DSDWORD[EAX+5],PY_INT,0);
  39.         RETURN 0;
  40. }
  41.  
  42. :dword stdcall std__INT40(dword c)
  43. {
  44.         X = popFast();
  45.         Y = DSDWORD[X+5];
  46.         X = DSDWORD[X];
  47.         X = DSDWORD[X];
  48.         X = DSDWORD[X];
  49.         test(X,1);
  50.        
  51.         RETURN 0;
  52. }
  53.  
  54. :void hexAddress(dword x,y)
  55. {
  56.         dword i = 0;
  57.         i = 8;
  58.         WHILE(i)
  59.         {
  60.                 DSBYTE[x] = DSBYTE[y&0xF+#arraySymbolHEX];
  61.                 y>>=4;
  62.                 x--;
  63.                 i--;
  64.         }
  65. }
  66. #define rSize DSBYTE[#RDATA+5]
  67. #define rData DSBYTE[#RDATA]
  68. #define rType DSBYTE[#RDATA+4]
  69.  
  70. :dword stdcall std__str(dword c)
  71. {
  72.         dword n = 0;
  73.         dword m = 0;
  74.         dword l = 0;
  75.         dword v = 0;
  76.         dword f = "<function a at 0x00000000>";
  77.         dword t = 0;
  78.         dword o = 0;
  79.        
  80.         v = popFast();
  81.         IF(DSBYTE[v+4] == PY_STR)
  82.         {
  83.                 copyVariable(v);
  84.                 return 0;
  85.         }
  86.  
  87.         switch(DSBYTE[v+4])
  88.         {
  89.                 case PY_BOOL:
  90.                         if(DSDWORD[v])
  91.                         {
  92.                                 load_const("True",PY_STR,4);
  93.                                 return 0;
  94.                         }
  95.                         load_const("False",PY_STR,5);
  96.                         return 0;
  97.                 break;
  98.                 case PY_INT:
  99.                         m = malloc(MEMBUF);
  100.                         l = itoa(DSDWORD[v],m);
  101.                         load_const(m,PY_STR,l);
  102.                         return 0;
  103.                 break;
  104.                 case PY_NONE:
  105.                         load_const("None",PY_STR,4);
  106.                         return 0;
  107.                 break;
  108.                 case PY_FNC:
  109.                         hexAddress(f+24,v);
  110.                         load_const(f,PY_STR,26);
  111.                         return 0;
  112.                 break;
  113.         }
  114. }