Subversion Repositories Kolibri OS

Rev

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

  1. :dword arrayInit(dword len)
  2. {
  3.         dword alloc = 0;
  4.         dword position = 0;
  5.         alloc = malloc(len*4+MEMBUF);
  6.         position = alloc;
  7.         DSDWORD[position] = 0;
  8.         position+=4;
  9.         DSDWORD[position] = len;
  10.         return alloc;
  11. }
  12. :dword ReallocArray(dword array,nMem)
  13. {
  14.         dword NEW = 0;
  15.         dword OLD = 0;
  16.         dword FLEN = 0;
  17.         dword LEN = 0;
  18.        
  19.         //test2("relloc",0);
  20.        
  21.         OLD = array;
  22.         FLEN = nMem*4+8;
  23.         LEN = DSDWORD[array];
  24.        
  25.         NEW = arrayInit(nMem);
  26.        
  27.         array+=8;
  28.         while(LEN)
  29.         {
  30.                 A = DSDWORD[array];
  31.                 IF(A)
  32.                 {
  33.                         arraySet(#NEW,DSDWORD[A],DSDWORD[A+4]);
  34.                         free(A);
  35.                 }
  36.                 LEN--;
  37.                 array+=4;
  38.         }
  39.         free(OLD);
  40.  
  41.         return NEW;
  42. }
  43.  
  44. :byte arraySet(dword array,key,value)
  45. {
  46.         dword NEW = 0;
  47.         dword LEN = 0;
  48.         dword FLEN = 0;
  49.         dword POSITION = 0;
  50.         dword VKEY = 0;
  51.         dword FULL = 0;
  52.         dword OST = 0;
  53.         dword BEGIN = 0;
  54.         dword gArray = 0;
  55.        
  56.         gArray = DSDWORD[array];
  57.        
  58.         IF(gArray)
  59.         {
  60.                 LEN = DSDWORD[gArray];
  61.                 OST = DSDWORD[gArray+4];
  62.         }
  63.         ELSE
  64.         {
  65.                 LEN = 0;
  66.                 OST = 8;
  67.         }
  68.  
  69.         IF(LEN)
  70.         {
  71.                 IF(!(LEN%OST))
  72.                 {
  73.                         gArray = ReallocArray(gArray,OST<<1);
  74.                         DSDWORD[array] = gArray;
  75.                 }
  76.         }
  77.         ELSE
  78.         {
  79.                 gArray = arrayInit(OST);
  80.                 DSDWORD[array] = gArray;
  81.         }
  82.        
  83.         BEGIN = gArray;
  84.        
  85.         gArray+=4;
  86.         FLEN = DSDWORD[gArray];
  87.        
  88.         gArray+=4;
  89.         POSITION = key%FLEN*4+gArray;
  90.        
  91.         FULL = FLEN*4+gArray;
  92.  
  93.         LOOP_COL2:
  94.         VKEY = DSDWORD[POSITION];
  95.        
  96.         IF(!VKEY)
  97.         {
  98.                
  99.                 NEW = malloc(8);
  100.                 DSDWORD[NEW] = key;
  101.                 DSDWORD[NEW+4] = value;
  102.                 DSDWORD[POSITION] = NEW;
  103.                 DSDWORD[BEGIN] = DSDWORD[BEGIN]+1;
  104.                 return 1;
  105.         }
  106.        
  107.         IF(DSDWORD[VKEY] == key)
  108.         {
  109.                 DSDWORD[VKEY+4] = value;
  110.                 return 2;
  111.         }
  112.         // collision
  113.         POSITION+=4;
  114.         IF(POSITION>FULL) POSITION = gArray+8;
  115.         goto LOOP_COL2;
  116.         return 3;
  117. }
  118.  
  119. :dword arrayGet(dword array,key)
  120. {
  121.        
  122.         dword NEW = 0;
  123.         dword LEN = 0;
  124.         dword MEMLEN = 0;
  125.         dword POSITION = 0;
  126.         dword VKEY = 0;
  127.         dword FULL = 0;
  128.        
  129.        
  130.         LEN = DSDWORD[array];
  131.         array+=4;
  132.         MEMLEN = DSDWORD[array];
  133.         array+=4;
  134.         POSITION = key%MEMLEN*4+array;
  135.         FULL = LEN*4+array;
  136.        
  137.         Z = 2;
  138.        
  139.         LOOP_COL1:
  140.         VKEY = DSDWORD[POSITION];
  141.  
  142.         IF(!VKEY) return 0;
  143.         IF(DSDWORD[VKEY] == key) return DSDWORD[VKEY+4];
  144.         // collision
  145.         POSITION+=4;
  146.         IF(POSITION>FULL)
  147.         {
  148.                 POSITION = array+8;
  149.                 Z--;
  150.                 IF(!Z) return 0;
  151.         }
  152.         goto LOOP_COL1;
  153. }
  154.  
  155. :dword arrayDelete(dword array,key)
  156. {
  157.        
  158.         dword NEW = 0;
  159.         dword LEN = 0;
  160.         dword MEMLEN = 0;
  161.         dword POSITION = 0;
  162.         dword VKEY = 0;
  163.         dword FULL = 0;
  164.         dword TMP = 0;
  165.        
  166.        
  167.         LEN = DSDWORD[array];
  168.         array+=4;
  169.         MEMLEN = DSDWORD[array];
  170.         array+=4;
  171.         POSITION = key%MEMLEN*4+array;
  172.         FULL = LEN*4+array;
  173.        
  174.         Z = 2;
  175.        
  176.         LOOP_COL1:
  177.         VKEY = DSDWORD[POSITION];
  178.  
  179.         IF(!VKEY) return 0;
  180.         IF(DSDWORD[VKEY] == key)
  181.         {
  182.                 TMP = DSDWORD[VKEY+4];
  183.                 free(VKEY);
  184.                 DSDWORD[POSITION] = 0;
  185.                 DSDWORD[array] = DSDWORD[array]-1;
  186.                 return TMP;
  187.         }
  188.         // collision
  189.         POSITION+=4;
  190.         IF(POSITION>FULL)
  191.         {
  192.                 POSITION = array+8;
  193.                 Z--;
  194.                 IF(!Z) return 0;
  195.         }
  196.         goto LOOP_COL1;
  197. }
  198.  
  199. // dict
  200.  
  201. :dword hash(dword str)
  202. {
  203.         byte S = 0;
  204.         dword s1 = 0;
  205.         dword s2 = 0;
  206.         S = DSBYTE[str];
  207.         WHILE(S)
  208.         {
  209.                 s1 += S;
  210.                 s2 += s1;
  211.                 S = DSBYTE[str];
  212.                 str++;
  213.         }
  214.         s1<<=16;
  215.         RETURN s1|s2;
  216. }
  217.  
  218. :byte dictSet(dword array,key,data)
  219. {
  220.         RETURN arraySet(array,hash(key),data);
  221. }
  222.  
  223. :byte dictDel(dword array,key)
  224. {
  225.         RETURN arrayDelete(array,hash(key));
  226. }
  227.  
  228. :dword dictGet(dword array,key)
  229. {
  230.         RETURN arrayGet(array,hash(key));
  231. }
  232.  
  233.  
  234. // list
  235. :void listAppend(dword position,data) // TODO Fixed!!
  236. {
  237.         dword len = 0;
  238.         dword flen = 0;
  239.         dword news = 0;
  240.         dword array = 0;
  241.         dword i = 0;
  242.         array = DSDWORD[position];
  243.         len = DSDWORD[array];
  244.         flen = DSDWORD[array+4];
  245.         IF(len>=flen)
  246.         {
  247.                 news = malloc(flen<<3+8);
  248.                 DSDWORD[position] = news;
  249.                 i = flen<<1+2;
  250.                 while(i)
  251.                 {
  252.                         DSDWORD[news] = DSDWORD[array];
  253.                         news+=4;
  254.                         array+=4;
  255.                         i--;
  256.                 }
  257.                 array = news;
  258.         }
  259.        
  260.         DSDWORD[len*4+array+8] = data;
  261.         DSDWORD[array] = DSDWORD[array]+1;
  262. }
  263. :dword listGet(dword array,key)
  264. {
  265.         return DSDWORD[key*4+array+8];
  266. }