public void append(object data, Int32 nbytes) { Ptr <byte> p = new Ptr <byte>((byte[])data, 0); int left = nbytes; int offset = (Int32)((count[0] >> 3) & 63); UInt32 nbits = (UInt32)(nbytes << 3); if (nbytes <= 0) { return; } /* Update the message length. */ count[1] += (UInt32)(nbytes >> 29); count[0] += nbits; if (count[0] < nbits) { count[1]++; } /* Process an initial partial block. */ Ptr <byte> pBuf = new Ptr <byte>(buf, 0); if (offset != 0) { int copy = (offset + nbytes > 64) ? (64 - offset) : nbytes; pBuf.AddPtr(offset); mem.memcpy(ref pBuf, p, copy); pBuf.AddPtr(-offset); if (offset + copy < 64) { return; } p.AddPtr(copy); left -= copy; process(pBuf); } /* Process full blocks. */ for (; left >= 64; p.AddPtr(64), left -= 64) { process(p); } /* Process a final partial block. */ if (left != 0) { mem.memcpy(ref pBuf, p, left); } }
protected string petsciiToAscii(ref Ptr <byte> spPet) { List <byte> buffer = new List <byte>(); do { byte petsciiChar = spPet.buf[spPet.ptr]; spPet.AddPtr(1); if ((petsciiChar == 0x00) || (petsciiChar == 0x0d)) { break; } // If character is 0x9d (left arrow key) then move back. if ((petsciiChar == 0x9d) && buffer.Count != 0) { buffer.RemoveAt(buffer.Count - 1); } else { // ASCII CHR$ conversion byte asciiChar = CHR_tab[petsciiChar]; if ((asciiChar >= 0x20) && (buffer.Count <= 31)) { buffer.Add(asciiChar); } } }while (spPet.buf.Length > spPet.ptr); return(Encoding.ASCII.GetString(buffer.ToArray())); }
private Ptr <byte> reloc_globals(Ptr <byte> buf) { int n = getWord(buf, 0); buf.AddPtr(2); while (n != 0) { while (buf[buf.ptr] != 0) { buf.AddPtr(1); } byte seg = buf[buf.ptr]; Int32 oldVal = getWord(buf, 1); Int32 newVal = oldVal + reldiff(seg); setWord(buf, 1, newVal); buf.AddPtr(3); n--; } return(buf); }
// ---------------------------------------------------------------------------- // Evaluation of complete interpolating function. // Note that since each curve segment is controlled by four points, the // end points will not be interpolated. If extra control points are not // desirable, the end points can simply be repeated to ensure interpolation. // Note also that points of non-differentiability and discontinuity can be // introduced by repeating points. // ---------------------------------------------------------------------------- //template<class PointIter, class PointPlotter> //public void interpolate(PointIter p0, PointIter pn, PointPlotter plot, double res) //{ // double k1, k2; // // Set up points for first curve segment. // PointIter p1 = p0; ++p1; // PointIter p2 = p1; ++p2; // PointIter p3 = p2; ++p3; // // Draw each curve segment. // for (; p2 != pn; ++p0, ++p1, ++p2, ++p3) // { // // p1 and p2 equal; single point. // if (x(p1) == x(p2)) // { // continue; // } // // Both end points repeated; straight line. // if (x(p0) == x(p1) && x(p2) == x(p3)) // { // k1 = k2 = (y(p2) - y(p1)) / (x(p2) - x(p1)); // } // // p0 and p1 equal; use f''(x1) = 0. // else if (x(p0) == x(p1)) // { // k2 = (y(p3) - y(p1)) / (x(p3) - x(p1)); // k1 = (3 * (y(p2) - y(p1)) / (x(p2) - x(p1)) - k2) / 2; // } // // p2 and p3 equal; use f''(x2) = 0. // else if (x(p2) == x(p3)) // { // k1 = (y(p2) - y(p0)) / (x(p2) - x(p0)); // k2 = (3 * (y(p2) - y(p1)) / (x(p2) - x(p1)) - k1) / 2; // } // // Normal curve. // else // { // k1 = (y(p2) - y(p0)) / (x(p2) - x(p0)); // k2 = (y(p3) - y(p1)) / (x(p3) - x(p1)); // } // interpolate_segment(x(p1), y(p1), x(p2), y(p2), k1, k2, plot, res); // } //} public void interpolate(double[][] sp0, int sptrPn, int[] splot, double res) { double k1, k2; Ptr <double[]> p0 = new Ptr <double[]>(sp0, 0); Ptr <double[]> pn = new Ptr <double[]>(sp0, sptrPn); Ptr <double[]> p1 = new Ptr <double[]>(sp0, 1); Ptr <double[]> p2 = new Ptr <double[]>(sp0, 2); Ptr <double[]> p3 = new Ptr <double[]>(sp0, 3); // Set up points for first curve segment. //PointIter p1 = p0; ++p1; //PointIter p2 = p1; ++p2; //PointIter p3 = p2; ++p3; // Draw each curve segment. for (; p2.ptr != pn.ptr; p0.AddPtr(1), p1.AddPtr(1), p2.AddPtr(1), p3.AddPtr(1)) { // p1 and p2 equal; single point. if (x(p1) == x(p2)) { continue; } // Both end points repeated; straight line. if (x(p0) == x(p1) && x(p2) == x(p3)) { k1 = k2 = (y(p2) - y(p1)) / (x(p2) - x(p1)); } // p0 and p1 equal; use f''(x1) = 0. else if (x(p0) == x(p1)) { k2 = (y(p3) - y(p1)) / (x(p3) - x(p1)); k1 = (3 * (y(p2) - y(p1)) / (x(p2) - x(p1)) - k2) / 2; } // p2 and p3 equal; use f''(x2) = 0. else if (x(p2) == x(p3)) { k1 = (y(p2) - y(p0)) / (x(p2) - x(p0)); k2 = (3 * (y(p2) - y(p1)) / (x(p2) - x(p1)) - k1) / 2; } // Normal curve. else { k1 = (y(p2) - y(p0)) / (x(p2) - x(p0)); k2 = (y(p3) - y(p1)) / (x(p3) - x(p1)); } //interpolate_segment(x(p1), y(p1), x(p2), y(p2), k1, k2, splot, res); interpolate_forward_difference(x(p1), y(p1), x(p2), y(p2), k1, k2, splot, res); } }
private void process(Ptr <byte> data)//[64]) { UInt32 a = abcd[0], b = abcd[1], c = abcd[2], d = abcd[3]; #if MD5_WORDS_BIG_ENDIAN /* * On big-endian machines, we must arrange the bytes in the right * order. (This also works on machines of unknown byte order.) */ Ptr <byte> xp = new Ptr <byte>(data, 0); for (int i = 0; i < 16; ++i, xp.AddPtr(4)) { tmpBuf[i] = (UInt32)((xp[0] & 0xFF) + ((xp[1] & 0xFF) << 8) + ((xp[2] & 0xFF) << 16) + ((xp[3] & 0xFF) << 24)); } X = tmpBuf; #else /* !MD5_IS_BIG_ENDIAN */ /* * On little-endian machines, we can process properly aligned data * without copying it. */ //if (((data - (byte[])0) & 3) == 0) if ((data[0] & 3) == 0) { /* data are properly aligned */ X = new uint[data.buf.Length / 4]; for (int i = 0; i < 64 / 4; i++) { X[i] = (UInt32)((data[3 + i * 4] & 0xFF) + ((data[2 + i * 4] & 0xFF) << 8) + ((data[1 + i * 4] & 0xFF) << 16) + ((data[0 + i * 4] & 0xFF) << 24)); } } else { /* not aligned */ //mem.memcpy(ref tmpBuf, data, 64); //tmpBuf = new uint[data.buf.Length / 4]; for (int i = 0; i < 64 / 4; i++) { tmpBuf[i] = (UInt32)((data[3 + i * 4] & 0xFF) + ((data[2 + i * 4] & 0xFF) << 8) + ((data[1 + i * 4] & 0xFF) << 16) + ((data[0 + i * 4] & 0xFF) << 24)); } X = tmpBuf; } #endif /* Round 1. */ /* Let [abcd k s i] denote the operation * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ /* Do the following 16 operations. */ SET(F, ref a, ref b, ref c, ref d, 0, 7, T1); SET(F, ref d, ref a, ref b, ref c, 1, 12, T2); SET(F, ref c, ref d, ref a, ref b, 2, 17, T3); SET(F, ref b, ref c, ref d, ref a, 3, 22, T4); SET(F, ref a, ref b, ref c, ref d, 4, 7, T5); SET(F, ref d, ref a, ref b, ref c, 5, 12, T6); SET(F, ref c, ref d, ref a, ref b, 6, 17, T7); SET(F, ref b, ref c, ref d, ref a, 7, 22, T8); SET(F, ref a, ref b, ref c, ref d, 8, 7, T9); SET(F, ref d, ref a, ref b, ref c, 9, 12, T10); SET(F, ref c, ref d, ref a, ref b, 10, 17, T11); SET(F, ref b, ref c, ref d, ref a, 11, 22, T12); SET(F, ref a, ref b, ref c, ref d, 12, 7, T13); SET(F, ref d, ref a, ref b, ref c, 13, 12, T14); SET(F, ref c, ref d, ref a, ref b, 14, 17, T15); SET(F, ref b, ref c, ref d, ref a, 15, 22, T16); /* Round 2. */ /* Let [abcd k s i] denote the operation * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ /* Do the following 16 operations. */ SET(G, ref a, ref b, ref c, ref d, 1, 5, T17); SET(G, ref d, ref a, ref b, ref c, 6, 9, T18); SET(G, ref c, ref d, ref a, ref b, 11, 14, T19); SET(G, ref b, ref c, ref d, ref a, 0, 20, T20); SET(G, ref a, ref b, ref c, ref d, 5, 5, T21); SET(G, ref d, ref a, ref b, ref c, 10, 9, T22); SET(G, ref c, ref d, ref a, ref b, 15, 14, T23); SET(G, ref b, ref c, ref d, ref a, 4, 20, T24); SET(G, ref a, ref b, ref c, ref d, 9, 5, T25); SET(G, ref d, ref a, ref b, ref c, 14, 9, T26); SET(G, ref c, ref d, ref a, ref b, 3, 14, T27); SET(G, ref b, ref c, ref d, ref a, 8, 20, T28); SET(G, ref a, ref b, ref c, ref d, 13, 5, T29); SET(G, ref d, ref a, ref b, ref c, 2, 9, T30); SET(G, ref c, ref d, ref a, ref b, 7, 14, T31); SET(G, ref b, ref c, ref d, ref a, 12, 20, T32); /* Round 3. */ /* Let [abcd k s t] denote the operation * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ /* Do the following 16 operations. */ SET(H, ref a, ref b, ref c, ref d, 5, 4, T33); SET(H, ref d, ref a, ref b, ref c, 8, 11, T34); SET(H, ref c, ref d, ref a, ref b, 11, 16, T35); SET(H, ref b, ref c, ref d, ref a, 14, 23, T36); SET(H, ref a, ref b, ref c, ref d, 1, 4, T37); SET(H, ref d, ref a, ref b, ref c, 4, 11, T38); SET(H, ref c, ref d, ref a, ref b, 7, 16, T39); SET(H, ref b, ref c, ref d, ref a, 10, 23, T40); SET(H, ref a, ref b, ref c, ref d, 13, 4, T41); SET(H, ref d, ref a, ref b, ref c, 0, 11, T42); SET(H, ref c, ref d, ref a, ref b, 3, 16, T43); SET(H, ref b, ref c, ref d, ref a, 6, 23, T44); SET(H, ref a, ref b, ref c, ref d, 9, 4, T45); SET(H, ref d, ref a, ref b, ref c, 12, 11, T46); SET(H, ref c, ref d, ref a, ref b, 15, 16, T47); SET(H, ref b, ref c, ref d, ref a, 2, 23, T48); /* Round 4. */ /* Let [abcd k s t] denote the operation * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ /* Do the following 16 operations. */ SET(I, ref a, ref b, ref c, ref d, 0, 6, T49); SET(I, ref d, ref a, ref b, ref c, 7, 10, T50); SET(I, ref c, ref d, ref a, ref b, 14, 15, T51); SET(I, ref b, ref c, ref d, ref a, 5, 21, T52); SET(I, ref a, ref b, ref c, ref d, 12, 6, T53); SET(I, ref d, ref a, ref b, ref c, 3, 10, T54); SET(I, ref c, ref d, ref a, ref b, 10, 15, T55); SET(I, ref b, ref c, ref d, ref a, 1, 21, T56); SET(I, ref a, ref b, ref c, ref d, 8, 6, T57); SET(I, ref d, ref a, ref b, ref c, 15, 10, T58); SET(I, ref c, ref d, ref a, ref b, 6, 15, T59); SET(I, ref b, ref c, ref d, ref a, 13, 21, T60); SET(I, ref a, ref b, ref c, ref d, 4, 6, T61); SET(I, ref d, ref a, ref b, ref c, 11, 10, T62); SET(I, ref c, ref d, ref a, ref b, 2, 15, T63); SET(I, ref b, ref c, ref d, ref a, 9, 21, T64); /* Then perform the following additions. (That is increment each * of the four registers by the value it had before this block * was started.) */ abcd[0] += a; abcd[1] += b; abcd[2] += c; abcd[3] += d; }
private Ptr <byte> reloc_seg(Ptr <byte> buf, int len, Ptr <byte> rtab) { Int32 adr = -1; while (rtab[0] != 0)//(rtab.ptr < rtab.Count) { if ((rtab[0] & 255) == 255) { adr += 254; rtab.AddPtr(1); } else { adr += rtab[0] & 255; rtab.AddPtr(1); byte type = (byte)(rtab[0] & 0xe0); byte seg = (byte)(rtab[0] & 0x07); rtab.AddPtr(1); switch (type) { case 0x80: { Int32 oldVal = getWord(buf, adr); Int32 newVal = oldVal + reldiff(seg); setWord(buf, adr, newVal); break; } case 0x40: { Int32 oldVal = buf[adr] * 256 + rtab[0]; Int32 newVal = oldVal + reldiff(seg); buf[adr] = (byte)((newVal >> 8) & 255); rtab[0] = (byte)(newVal & 255); rtab.AddPtr(1); break; } case 0x20: { Int32 oldVal = buf[adr]; Int32 newVal = oldVal + reldiff(seg); buf[adr] = (byte)(newVal & 255); break; } } if (seg == 0) { rtab.AddPtr(2); } } //Console.WriteLine("buf[{0}]={1}",adr,buf[adr]); if (adr > len) { // Warning: relocation table entries past segment end! } } rtab.AddPtr(1); return(rtab); }