Alıntı (Salih Dinçer):
> Belki çözüm bir çok yerde size_t kullanmam olabilir.
Öyle. Kural şu: eğer indeks ve adet gibi bir kavramsa size_t olsun. Açıklamalar kodun içinde 'Ali' ile işaretli:
/******************************************************************************
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)
/* [Ali] Konum (offset) oldukları için size_t uygundur. */
auto mask(size_t rol, size_t lOffset, size_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;//*/
}
/* [Ali] offset gibi bir konuz bilgisi için size_t uygundur. */
size_t 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!
}
/* [Ali] Konum için size_t uygundur. */
int write(size_t xOffset, data_t xPattern, data_t pLength) {
/* [Ali] Buradaki cast'lere gerek kalmamış oluyor. */
auto pOffset = bl - (xOffset % bl); // pattern offset
auto sOffset = pLength - pOffset; // secondary offset
auto lOffset = bl - sOffset; // left offset
auto rOffset = pOffset - pLength; // right offset
/* [Ali] xBit bir indeks olduğundan size_t uygundur. cast'e de gerek
* kalmadı.*/
size_t xByte = xOffset / 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 {
/* [Ali] 0 yerine size_t.init. (Aslında bu çok saçma oldu.) */
xData[xByte] &= mask(cast(size_t)0, pOffset, bl);
xData[xByte] |= xPattern >> sOffset;
xByte++; // next byte...
xData[xByte] &= mask(lOffset, sOffset, bl);
/* [Ali] 0 yerine size_t.init. (Bu da çok saçma oldu.) */
xData[xByte] |= (xPattern & mask(size_t.init, size_t.init, sOffset)) << lOffset;
return 3; // partial masking
}
/* [Ali] dmd'nin -w seçeneği bu satıra hiç gelinmeyeceğini
* söylüyor.*/
// return -1; // error!
}
return 0; // no change...
}
/* [Ali] sb'nin ne anlama geldiği açık değil ama eğer konumsaq size_t
* uygundur. */
void print(size_t 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");
}
}
/* [Ali] Bütün türlerle deneyebilmek için bir şablon. */
void dene(T)()
{
writefln("\n===== %s denemesi ======", T.stringof);
Bit!(T) bit;
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...");
/* [Ali] */
writeln();
}
int main() {
import std.typetuple;
alias TypeTuple!(ubyte, ushort, uint, ulong) Types;
foreach (Tür; Types) {
dene!Tür();
}
/* [Ali] Başarılı sonlanma anlamında 0. */
return 0;
}
Ali
--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]
Permalink
Reply