[ create a new paste ] login | about

Link: http://codepad.org/Dk0lIqSw    [ raw code | output | fork | 2 comments ]

salihdb - D, pasted on Mar 26:
/******************************************************************************
bitDerle v0.1.26 ham (beta)
(c) 2012 - Salih Dinçer <salihdb@hotmail.com>

o Ali Çehreli <acehreli@yahoo.com>
o Zafer Çelenk <zafercelenk@gmail.com>

(o) Katkı sağladılar...
******************************************************************************/
import std.stdio;

struct Bit (data_t = ubyte) {  
    data_t[] xData;
    
    data_t bl = data_t.sizeof * 8;   // bit length (ubyte => 8)
    auto lb = (bl.max / 2) + 1;      // last bit (ubyte => 128)

    auto mask(data_t rol, data_t lOffset, data_t mLength) {
        auto maske = data_t.max;
        
        maske >>= bl - mLength;
        maske <<= lOffset;
        
        // partial masking (offset/rolling 2/3 => 0b11100111)
        // if (rol) maske = ~maske; // invert mask
        for (; rol>0; rol--) {
            maske <<= 1;
            maske |= 1;
        }
        
        return maske;
    }
    
    auto reverse(data_t n) {
        data_t x = 0;
        
        for(auto i = 0; i < bl; ++i) {
           x <<= 1;
           x += n % 2;
           n >>= 1;
        }
        
        return x;
    }
    
    auto invert(data_t xPattern, data_t pLength = 0) {
        // !!! BAKILACAK !!!
        
        return ~xPattern;
    }
    
    void init(data_t[] data) {
        xData ~= data;
    }
    
    bool read(int n) {
        return (xData[n / bl] & (lb >> n % bl)) != 0;/*
        
        if((xData[n / bl] & (1 << n % bl)) != 0) return true;
        return false;//*/
    }
    
    int find(data_t xBit) {
        data_t xHead, xMask, x, xSay = xBit;
        
        for (x = 0; x <= bl; ++x, xSay >>= 1) if(xSay == 0) {
            xMask = mask(0, 0, x);
            for (auto bs = 0; bs < (xData.length * bl); ++bs, xHead <<= 1) {
                if ((xData[bs / bl] & (lb >> bs % bl)) != 0) xHead |= 1;
                xHead &= xMask;
                if (xHead == xBit) return bs - x + 1;
            }
	    }
        
	    return 0;  // not found!
	}

	int write(int xOffset, data_t xPattern, data_t pLength) {
	    auto pOffset = cast(data_t)(bl - (xOffset % bl));   // pattern offset
	    auto sOffset = cast(data_t)(pLength - pOffset);     // secondary offset
	    auto lOffset = cast(data_t)(bl - sOffset);          // left offset
	    auto rOffset = cast(data_t)(pOffset - pLength);     // right offset
	    uint xByte = xOffset / cast(int)bl;
	
	    if(xOffset) {
	        if(pOffset >= pLength) {
	            if(pOffset == pLength) {
	                xData[xByte] &= mask(0, pLength, bl);
	                xData[xByte] |= xPattern;
	                return 1;   // shift masking
	            } else {
	                xData[xByte] &= mask(rOffset, pLength, bl);
                    xData[xByte] |= xPattern << rOffset;
                    return 2;   // rotate masking
	            }
	        } else {
	            xData[xByte] &= mask(0, pOffset, bl);
	            xData[xByte] |= xPattern >> sOffset;
	            
	            xByte++;   // next byte...
	            
	            xData[xByte] &= mask(lOffset, sOffset, bl);
	            xData[xByte] |= (xPattern & mask(0, 0, sOffset)) << lOffset;
	            return 3;  // partial masking
	        }
	        return -1; // error!
	    }
	    
	    return 0;  // no change...
    }

    void print(uint sb, data_t sr = 0) {
        
        if (sr == 0) sr = bl;   // !!! BAKILACAK !!!
        
        for (uint i = 0; i < xData.length * bl; i++) {
            if ((i != 0) && (i % sr == 0)) writef("_");
            writef(read(i) ? "1" : "0");
        }
        writef("\n");
        
        for (uint i = 0; i < sb + (sb / sr); i++) writef("-");
        if (sb) writef("^\n");
    }
}

int main() {
    Bit!(ubyte) bit;
    //Bit!(ulong) bit; // !!! BAKILACAK !!!
    
    typeof(bit.bl) [] searchData = [ 7, 1, 137, 137, 137, 137, 3, 143 ];
    typeof(bit.bl) keyword1 = 0b1110;
    typeof(bit.bl) keyword2 = 0b0001;   //bit.invert(keyword1);
    
    bit.init(searchData);
    auto offset = bit.find(keyword1);
    
    bit.print(offset);//, bit.bl);
    auto test = bit.write(offset, keyword2, 4);
    bit.print(offset);//, bit.bl);
    
    //writef("%b - ", test);/*
    
    if (test < 0) writef("!!! ERROR !!! ");
    else if (test == 0) writef("No Change: ");
    else if (test == 1) writef("Shift Masking: ");
    else if (test == 2) writef("Rotate Masking: ");
    else if (test == 3) writef("Partial Masking: ");
    
    //*/ 
    writef("[ %b ] Search term ", keyword1);
    if(offset) writef("found.\nFirst occurrence was at position %d.", offset);
    else writef("not found! Sorry...");
      
    return 1;
}


Output:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Line 18: found 'rol' when expecting ')'
Line 18: semicolon expected, not 'lOffset'
Line 18: no identifier for declarator lOffset
Line 18: semicolon expected, not 'mLength'
Line 18: no identifier for declarator mLength
Line 18: semicolon expected, not ')'
Line 18: Declaration expected, not ')'
Line 21: no identifier for declarator maske
Line 21: semicolon expected, not '>>='
Line 21: Declaration expected, not '>>='
Line 22: no identifier for declarator maske
Line 22: semicolon expected, not '<<='
Line 22: Declaration expected, not '<<='
Line 26: Declaration expected, not 'for'
Line 26: no identifier for declarator rol
Line 26: semicolon expected, not '>'
Line 26: Declaration expected, not '>'
Line 26: no identifier for declarator rol
Line 26: semicolon expected, not '--'
Line 26: Declaration expected, not '--'
Line 28: no identifier for declarator maske


Create a new paste based on this one


Comments:
posted by salihdb on Mar 26
Aslında henüz ham (beta) bile sayılmaz. Çünkü bitmemiş işlevler (functions) ve bir kaç kritik hata var. Yani alfa (Türkçesi ne bilmiyorum!) gibi görünüyor. Ancak doğru çalışıyor...:)

CodePad'de çalışmamasının sebebi ise işlevden aldığım değişkeni for(;...) içinde kullanmam olabilir.
reply
posted by salihdb on Apr 3
reply