발로쓰는 블로그

//////////////////////////////////////////////////
DesLibrary des = new DesLibrary("12345678".getBytes());
   
   String message = "가나다라마바사아자차카타파하하하으에으ㅔ으에흥";
   
   byte buf []= new byte[((message.getBytes().length/8) + 1) *8];
   byte getbuf1[],getbuf2[];
   

   System.arraycopy(message.getBytes(), 0, buf, 0, message.getBytes().length);
   
   System.out.println(new String(buf));
   
   //암호화한다
   getbuf1 = des.encrypt(buf);
   System.out.println(new String(getbuf1));
   
   //복호화한다
   getbuf2 = des.decrypt(getbuf1);
   System.out.println(new String(getbuf2));


//////////////////////////////////////////////////


import java.io.*;

/**
 * This code is derived from the above source
 * JCIFS API
 * Norbert Hranitzky
 *
 * <p>and modified again by Michael B. Allen
 */

public class DesLibrary   {

    private int[] encryptKeys = new int[32];
    private int[] decryptKeys = new int[32];

    private int[] tempInts = new int[2];

    public DesLibrary( ) {

    }

    // Constructor, byte-array key.
    public DesLibrary( byte[] key )    {
        if( key.length == 7 ) {
            byte[] key8 = new byte[8];
            makeSMBKey( key, key8 );
            setKey( key8 );
        } else {
            setKey( key );
        }
    }

    public static void makeSMBKey(byte[] key7, byte[] key8) {

        int i;

        key8[0] = (byte) ( ( key7[0] >> 1) & 0xff);
        key8[1] = (byte)(( ((key7[0] & 0x01) << 6) | (((key7[1] & 0xff)>>2) & 0xff)) & 0xff );
        key8[2] = (byte)(( ((key7[1] & 0x03) << 5) | (((key7[2] & 0xff)>>3) & 0xff)) & 0xff );
        key8[3] = (byte)(( ((key7[2] & 0x07) << 4) | (((key7[3] & 0xff)>>4) & 0xff)) & 0xff );
        key8[4] = (byte)(( ((key7[3] & 0x0F) << 3) | (((key7[4] & 0xff)>>5) & 0xff)) & 0xff );
        key8[5] = (byte)(( ((key7[4] & 0x1F) << 2) | (((key7[5] & 0xff)>>6) & 0xff)) & 0xff );
        key8[6] = (byte)(( ((key7[5] & 0x3F) << 1) | (((key7[6] & 0xff)>>7) & 0xff)) & 0xff );
        key8[7] = (byte)(key7[6] & 0x7F);
        for (i=0;i<8;i++) {
            key8[i] = (byte)( key8[i] << 1);
        }
    }

    /// Set the key.
    public void setKey( byte[] key ) {

        // CHECK PAROTY TBD
        deskey( key, true, encryptKeys );
        deskey( key, false, decryptKeys );
    }

    // Turn an 8-byte key into internal keys.
    private void deskey( byte[] keyBlock, boolean encrypting, int[] KnL ) {

        int i, j, l, m, n;
        int[] pc1m = new int[56];
        int[] pcr  = new int[56];
        int[] kn   = new int[32];

        for ( j = 0; j < 56; ++j )  {
            l       = pc1[j];
            m       = l & 07;
            pc1m[j] = ( (keyBlock[l >>> 3] & bytebit[m]) != 0 )? 1: 0;
        }

        for ( i = 0; i < 16; ++i ) {

            if ( encrypting )
                m = i << 1;
            else
                m = (15-i) << 1;
            n = m+1;
            kn[m] = kn[n] = 0;
            for ( j = 0; j < 28; ++j ) {
                l = j+totrot[i];
                if ( l < 28 )
                    pcr[j] = pc1m[l];
                else
                    pcr[j] = pc1m[l-28];
            }
            for ( j=28; j < 56; ++j ) {
                l = j+totrot[i];
                if ( l < 56 )
                    pcr[j] = pc1m[l];
                else
                    pcr[j] = pc1m[l-28];
            }
            for ( j = 0; j < 24; ++j ) {
                if ( pcr[pc2[j]] != 0 )
                    kn[m] |= bigbyte[j];
                if ( pcr[pc2[j+24]] != 0 )
                    kn[n] |= bigbyte[j];
            }
        }
        cookey( kn, KnL );
    }

    private void cookey( int[] raw, int KnL[] )     {
        int raw0, raw1;
        int rawi, KnLi;
        int i;

        for ( i = 0, rawi = 0, KnLi = 0; i < 16; ++i )   {
            raw0 = raw[rawi++];
            raw1 = raw[rawi++];
            KnL[KnLi]  = (raw0 & 0x00fc0000) <<   6;
            KnL[KnLi] |= (raw0 & 0x00000fc0) <<  10;
            KnL[KnLi] |= (raw1 & 0x00fc0000) >>> 10;
            KnL[KnLi] |= (raw1 & 0x00000fc0) >>>  6;
            ++KnLi;
            KnL[KnLi]  = (raw0 & 0x0003f000) <<  12;
            KnL[KnLi] |= (raw0 & 0x0000003f) <<  16;
            KnL[KnLi] |= (raw1 & 0x0003f000) >>>  4;
            KnL[KnLi] |= (raw1 & 0x0000003f);
            ++KnLi;
        }
    }

    /// Encrypt a block of eight bytes.
    private void encrypt( byte[] clearText, int clearOff, byte[] cipherText, int cipherOff ) {

        squashBytesToInts( clearText, clearOff, tempInts, 0, 2 );
        des( tempInts, tempInts, encryptKeys );
        spreadIntsToBytes( tempInts, 0, cipherText, cipherOff, 2 );
    }

    /// Decrypt a block of eight bytes.
    private void decrypt( byte[] cipherText, int cipherOff, byte[] clearText, int clearOff ) {

        squashBytesToInts( cipherText, cipherOff, tempInts, 0, 2 );
        des( tempInts, tempInts, decryptKeys );
        spreadIntsToBytes( tempInts, 0, clearText, clearOff, 2 );
    }

    // The DES function.
    private void des( int[] inInts, int[] outInts, int[] keys ) {

        int fval, work, right, leftt;
        int round;
        int keysi = 0;

        leftt = inInts[0];
        right = inInts[1];

        work   = ((leftt >>>  4) ^ right) & 0x0f0f0f0f;
        right ^= work;
        leftt ^= (work << 4);

        work   = ((leftt >>> 16) ^ right) & 0x0000ffff;
        right ^= work;
        leftt ^= (work << 16);

        work   = ((right >>>  2) ^ leftt) & 0x33333333;
        leftt ^= work;
        right ^= (work << 2);

        work   = ((right >>>  8) ^ leftt) & 0x00ff00ff;
        leftt ^= work;
        right ^= (work << 8);
        right  = (right << 1) | ((right >>> 31) & 1);

        work   = (leftt ^ right) & 0xaaaaaaaa;
        leftt ^= work;
        right ^= work;
        leftt  = (leftt << 1) | ((leftt >>> 31) & 1);

        for ( round = 0; round < 8; ++round )  {
            work   = (right << 28) | (right >>> 4);
            work  ^= keys[keysi++];
            fval   = SP7[ work         & 0x0000003f ];
            fval  |= SP5[(work >>>  8) & 0x0000003f ];
            fval  |= SP3[(work >>> 16) & 0x0000003f ];
            fval  |= SP1[(work >>> 24) & 0x0000003f ];
            work   = right ^ keys[keysi++];
            fval  |= SP8[ work         & 0x0000003f ];
            fval  |= SP6[(work >>>  8) & 0x0000003f ];
            fval  |= SP4[(work >>> 16) & 0x0000003f ];
            fval  |= SP2[(work >>> 24) & 0x0000003f ];
            leftt ^= fval;
            work   = (leftt << 28) | (leftt >>> 4);
            work  ^= keys[keysi++];
            fval   = SP7[ work         & 0x0000003f ];
            fval  |= SP5[(work >>>  8) & 0x0000003f ];
            fval  |= SP3[(work >>> 16) & 0x0000003f ];
            fval  |= SP1[(work >>> 24) & 0x0000003f ];
            work   = leftt ^ keys[keysi++];
            fval  |= SP8[ work         & 0x0000003f ];
            fval  |= SP6[(work >>>  8) & 0x0000003f ];
            fval  |= SP4[(work >>> 16) & 0x0000003f ];
            fval  |= SP2[(work >>> 24) & 0x0000003f ];
            right ^= fval;
        }

        right  = (right << 31) | (right >>> 1);
        work   = (leftt ^ right) & 0xaaaaaaaa;
        leftt ^= work;
        right ^= work;
        leftt  = (leftt << 31) | (leftt >>> 1);
        work   = ((leftt >>>  8) ^ right) & 0x00ff00ff;
        right ^= work;
        leftt ^= (work << 8);
        work   = ((leftt >>>  2) ^ right) & 0x33333333;
        right ^= work;
        leftt ^= (work << 2);
        work   = ((right >>> 16) ^ leftt) & 0x0000ffff;
        leftt ^= work;
        right ^= (work << 16);
        work   = ((right >>>  4) ^ leftt) & 0x0f0f0f0f;
        leftt ^= work;
        right ^= (work << 4);
        outInts[0] = right;
        outInts[1] = leftt;
    }

    /// Encrypt a block of bytes.
    public void encrypt( byte[] clearText, byte[] cipherText )  {
        encrypt( clearText, 0, cipherText, 0 );
    }

    /// Decrypt a block of bytes.
    public void decrypt( byte[] cipherText, byte[] clearText ) {

        decrypt( cipherText, 0, clearText, 0 );
    }

    /**
     * encrypts an array where the length must be a multiple of 8
     */
    public byte[] encrypt(byte[] clearText) {

        int length = clearText.length;

        if (length % 8 != 0) {
            System.out.println("Array must be a multiple of 8");
            return null;
        }

        byte[] cipherText = new byte[length];
        int count = length / 8;

        for (int i=0; i<count; i++)
            encrypt(clearText, i*8, cipherText, i*8);

        return cipherText;
    }

    /**
     * decrypts an array where the length must be a multiple of 8
     */
    public byte[] decrypt(byte[] cipherText) {

        int length = cipherText.length;

        if (length % 8 != 0) {
            System.out.println("Array must be a multiple of 8");
            return null;
        }

        byte[] clearText = new byte[length];
        int count = length / 8;

        for (int i=0; i<count; i++)

//원래 이게 있는 소스인데 아랫부분을 수정해줘야지 지대로된 복호화가 가능했다

         decrypt(cipherText, i*8, clearText, i*8);
         
            //encrypt(cipherText, i*8, clearText, i*8);

        return clearText;
    }

    // Tables, permutations, S-boxes, etc.

    private static byte[] bytebit = {
        (byte)0x80, (byte)0x40, (byte)0x20, (byte)0x10,
        (byte)0x08, (byte)0x04, (byte)0x02, (byte)0x01
    };
    private static int[] bigbyte = {
        0x800000, 0x400000, 0x200000, 0x100000,
        0x080000, 0x040000, 0x020000, 0x010000,
        0x008000, 0x004000, 0x002000, 0x001000,
        0x000800, 0x000400, 0x000200, 0x000100,
        0x000080, 0x000040, 0x000020, 0x000010,
        0x000008, 0x000004, 0x000002, 0x000001
    };
    private static byte[] pc1 = {
        (byte)56, (byte)48, (byte)40, (byte)32, (byte)24, (byte)16, (byte) 8,
        (byte) 0, (byte)57, (byte)49, (byte)41, (byte)33, (byte)25, (byte)17,
        (byte) 9, (byte) 1, (byte)58, (byte)50, (byte)42, (byte)34, (byte)26,
        (byte)18, (byte)10, (byte) 2, (byte)59, (byte)51, (byte)43, (byte)35,
        (byte)62, (byte)54, (byte)46, (byte)38, (byte)30, (byte)22, (byte)14,
        (byte) 6, (byte)61, (byte)53, (byte)45, (byte)37, (byte)29, (byte)21,
        (byte)13, (byte) 5, (byte)60, (byte)52, (byte)44, (byte)36, (byte)28,
        (byte)20, (byte)12, (byte) 4, (byte)27, (byte)19, (byte)11, (byte)3
    };
    private static int[] totrot = {
        1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28
    };

    private static byte[] pc2 = {
        (byte)13, (byte)16, (byte)10, (byte)23, (byte) 0, (byte) 4,
        (byte) 2, (byte)27, (byte)14, (byte) 5, (byte)20, (byte) 9,
        (byte)22, (byte)18, (byte)11, (byte)3 , (byte)25, (byte) 7,
        (byte)15, (byte) 6, (byte)26, (byte)19, (byte)12, (byte) 1,
        (byte)40, (byte)51, (byte)30, (byte)36, (byte)46, (byte)54,
        (byte)29, (byte)39, (byte)50, (byte)44, (byte)32, (byte)47,
        (byte)43, (byte)48, (byte)38, (byte)55, (byte)33, (byte)52,
        (byte)45, (byte)41, (byte)49, (byte)35, (byte)28, (byte)31,
    };

    private static int[] SP1 = {
        0x01010400, 0x00000000, 0x00010000, 0x01010404,
        0x01010004, 0x00010404, 0x00000004, 0x00010000,
        0x00000400, 0x01010400, 0x01010404, 0x00000400,
        0x01000404, 0x01010004, 0x01000000, 0x00000004,
        0x00000404, 0x01000400, 0x01000400, 0x00010400,
        0x00010400, 0x01010000, 0x01010000, 0x01000404,
        0x00010004, 0x01000004, 0x01000004, 0x00010004,
        0x00000000, 0x00000404, 0x00010404, 0x01000000,
        0x00010000, 0x01010404, 0x00000004, 0x01010000,
        0x01010400, 0x01000000, 0x01000000, 0x00000400,
        0x01010004, 0x00010000, 0x00010400, 0x01000004,
        0x00000400, 0x00000004, 0x01000404, 0x00010404,
        0x01010404, 0x00010004, 0x01010000, 0x01000404,
        0x01000004, 0x00000404, 0x00010404, 0x01010400,
        0x00000404, 0x01000400, 0x01000400, 0x00000000,
        0x00010004, 0x00010400, 0x00000000, 0x01010004
    };
    private static int[] SP2 = {
        0x80108020, 0x80008000, 0x00008000, 0x00108020,
        0x00100000, 0x00000020, 0x80100020, 0x80008020,
        0x80000020, 0x80108020, 0x80108000, 0x80000000,
        0x80008000, 0x00100000, 0x00000020, 0x80100020,
        0x00108000, 0x00100020, 0x80008020, 0x00000000,
        0x80000000, 0x00008000, 0x00108020, 0x80100000,
        0x00100020, 0x80000020, 0x00000000, 0x00108000,
        0x00008020, 0x80108000, 0x80100000, 0x00008020,
        0x00000000, 0x00108020, 0x80100020, 0x00100000,
        0x80008020, 0x80100000, 0x80108000, 0x00008000,
        0x80100000, 0x80008000, 0x00000020, 0x80108020,
        0x00108020, 0x00000020, 0x00008000, 0x80000000,
        0x00008020, 0x80108000, 0x00100000, 0x80000020,
        0x00100020, 0x80008020, 0x80000020, 0x00100020,
        0x00108000, 0x00000000, 0x80008000, 0x00008020,
        0x80000000, 0x80100020, 0x80108020, 0x00108000
    };
    private static int[] SP3 = {
        0x00000208, 0x08020200, 0x00000000, 0x08020008,
        0x08000200, 0x00000000, 0x00020208, 0x08000200,
        0x00020008, 0x08000008, 0x08000008, 0x00020000,
        0x08020208, 0x00020008, 0x08020000, 0x00000208,
        0x08000000, 0x00000008, 0x08020200, 0x00000200,
        0x00020200, 0x08020000, 0x08020008, 0x00020208,
        0x08000208, 0x00020200, 0x00020000, 0x08000208,
        0x00000008, 0x08020208, 0x00000200, 0x08000000,
        0x08020200, 0x08000000, 0x00020008, 0x00000208,
        0x00020000, 0x08020200, 0x08000200, 0x00000000,
        0x00000200, 0x00020008, 0x08020208, 0x08000200,
        0x08000008, 0x00000200, 0x00000000, 0x08020008,
        0x08000208, 0x00020000, 0x08000000, 0x08020208,
        0x00000008, 0x00020208, 0x00020200, 0x08000008,
        0x08020000, 0x08000208, 0x00000208, 0x08020000,
        0x00020208, 0x00000008, 0x08020008, 0x00020200
    };
    private static int[] SP4 = {
        0x00802001, 0x00002081, 0x00002081, 0x00000080,
        0x00802080, 0x00800081, 0x00800001, 0x00002001,
        0x00000000, 0x00802000, 0x00802000, 0x00802081,
        0x00000081, 0x00000000, 0x00800080, 0x00800001,
        0x00000001, 0x00002000, 0x00800000, 0x00802001,
        0x00000080, 0x00800000, 0x00002001, 0x00002080,
        0x00800081, 0x00000001, 0x00002080, 0x00800080,
        0x00002000, 0x00802080, 0x00802081, 0x00000081,
        0x00800080, 0x00800001, 0x00802000, 0x00802081,
        0x00000081, 0x00000000, 0x00000000, 0x00802000,
        0x00002080, 0x00800080, 0x00800081, 0x00000001,
        0x00802001, 0x00002081, 0x00002081, 0x00000080,
        0x00802081, 0x00000081, 0x00000001, 0x00002000,
        0x00800001, 0x00002001, 0x00802080, 0x00800081,
        0x00002001, 0x00002080, 0x00800000, 0x00802001,
        0x00000080, 0x00800000, 0x00002000, 0x00802080
    };
    private static int[] SP5 = {
        0x00000100, 0x02080100, 0x02080000, 0x42000100,
        0x00080000, 0x00000100, 0x40000000, 0x02080000,
        0x40080100, 0x00080000, 0x02000100, 0x40080100,
        0x42000100, 0x42080000, 0x00080100, 0x40000000,
        0x02000000, 0x40080000, 0x40080000, 0x00000000,
        0x40000100, 0x42080100, 0x42080100, 0x02000100,
        0x42080000, 0x40000100, 0x00000000, 0x42000000,
        0x02080100, 0x02000000, 0x42000000, 0x00080100,
        0x00080000, 0x42000100, 0x00000100, 0x02000000,
        0x40000000, 0x02080000, 0x42000100, 0x40080100,
        0x02000100, 0x40000000, 0x42080000, 0x02080100,
        0x40080100, 0x00000100, 0x02000000, 0x42080000,
        0x42080100, 0x00080100, 0x42000000, 0x42080100,
        0x02080000, 0x00000000, 0x40080000, 0x42000000,
        0x00080100, 0x02000100, 0x40000100, 0x00080000,
        0x00000000, 0x40080000, 0x02080100, 0x40000100
    };
    private static int[] SP6 = {
        0x20000010, 0x20400000, 0x00004000, 0x20404010,
        0x20400000, 0x00000010, 0x20404010, 0x00400000,
        0x20004000, 0x00404010, 0x00400000, 0x20000010,
        0x00400010, 0x20004000, 0x20000000, 0x00004010,
        0x00000000, 0x00400010, 0x20004010, 0x00004000,
        0x00404000, 0x20004010, 0x00000010, 0x20400010,
        0x20400010, 0x00000000, 0x00404010, 0x20404000,
        0x00004010, 0x00404000, 0x20404000, 0x20000000,
        0x20004000, 0x00000010, 0x20400010, 0x00404000,
        0x20404010, 0x00400000, 0x00004010, 0x20000010,
        0x00400000, 0x20004000, 0x20000000, 0x00004010,
        0x20000010, 0x20404010, 0x00404000, 0x20400000,
        0x00404010, 0x20404000, 0x00000000, 0x20400010,
        0x00000010, 0x00004000, 0x20400000, 0x00404010,
        0x00004000, 0x00400010, 0x20004010, 0x00000000,
        0x20404000, 0x20000000, 0x00400010, 0x20004010
    };
    private static int[] SP7 = {
        0x00200000, 0x04200002, 0x04000802, 0x00000000,
        0x00000800, 0x04000802, 0x00200802, 0x04200800,
        0x04200802, 0x00200000, 0x00000000, 0x04000002,
        0x00000002, 0x04000000, 0x04200002, 0x00000802,
        0x04000800, 0x00200802, 0x00200002, 0x04000800,
        0x04000002, 0x04200000, 0x04200800, 0x00200002,
        0x04200000, 0x00000800, 0x00000802, 0x04200802,
        0x00200800, 0x00000002, 0x04000000, 0x00200800,
        0x04000000, 0x00200800, 0x00200000, 0x04000802,
        0x04000802, 0x04200002, 0x04200002, 0x00000002,
        0x00200002, 0x04000000, 0x04000800, 0x00200000,
        0x04200800, 0x00000802, 0x00200802, 0x04200800,
        0x00000802, 0x04000002, 0x04200802, 0x04200000,
        0x00200800, 0x00000000, 0x00000002, 0x04200802,
        0x00000000, 0x00200802, 0x04200000, 0x00000800,
        0x04000002, 0x04000800, 0x00000800, 0x00200002
    };
    private static int[] SP8 = {
        0x10001040, 0x00001000, 0x00040000, 0x10041040,
        0x10000000, 0x10001040, 0x00000040, 0x10000000,
        0x00040040, 0x10040000, 0x10041040, 0x00041000,
        0x10041000, 0x00041040, 0x00001000, 0x00000040,
        0x10040000, 0x10000040, 0x10001000, 0x00001040,
        0x00041000, 0x00040040, 0x10040040, 0x10041000,
        0x00001040, 0x00000000, 0x00000000, 0x10040040,
        0x10000040, 0x10001000, 0x00041040, 0x00040000,
        0x00041040, 0x00040000, 0x10041000, 0x00001000,
        0x00000040, 0x10040040, 0x00001000, 0x00041040,
        0x10001000, 0x00000040, 0x10000040, 0x10040000,
        0x10040040, 0x10000000, 0x00040000, 0x10001040,
        0x00000000, 0x10041040, 0x00040040, 0x10000040,
        0x10040000, 0x10001000, 0x10001040, 0x00000000,
        0x10041040, 0x00041000, 0x00041000, 0x00001040,
        0x00001040, 0x00040040, 0x10000000, 0x10041000
    };

 /// Squash bytes down to ints.
    public static void squashBytesToInts( byte[] inBytes, int inOff, int[] outInts,
                                           int outOff, int intLen ) {

        for ( int i = 0; i < intLen; ++i )
            outInts[outOff + i] =
                ( ( inBytes[inOff + i * 4    ] & 0xff ) << 24 ) |
                ( ( inBytes[inOff + i * 4 + 1] & 0xff ) << 16 ) |
                ( ( inBytes[inOff + i * 4 + 2] & 0xff ) <<  8 ) |
                 ( inBytes[inOff + i * 4 + 3] & 0xff );
    }

    /// Spread ints into bytes.
    public static void spreadIntsToBytes( int[] inInts, int inOff, byte[] outBytes,
                                         int outOff, int intLen ) {

        for ( int i = 0; i < intLen; ++i ) {

            outBytes[outOff + i * 4    ] = (byte) ( inInts[inOff + i] >>> 24 );
            outBytes[outOff + i * 4 + 1] = (byte) ( inInts[inOff + i] >>> 16 );
            outBytes[outOff + i * 4 + 2] = (byte) ( inInts[inOff + i] >>>  8 );
            outBytes[outOff + i * 4 + 3] = (byte)   inInts[inOff + i];
        }
    }
}

참고 : http://www.codeproject.com/KB/graphics/BarcodeLibrary.aspx
참고: http://www.codeproject.com/KB/cpp/includeh10.aspx
위의 주소에 보면 비쥬얼 스튜디오로 돌려 볼수있게 잘되어있다
모든 바코드 소스를 확인해볼수있다

아래의 코드는 참고 사이트에서 코드를 참고한것이다
내가 사용할 128a만 뽑아서
원래는 wipic용으로 만들었다가 다시 플랫폼이 변경되서
wipijava용으로 변경한것이다



import org.kwis.msp.lcdui.Graphics;

public class BarcodeClass {

 int ga2_Code128[][] = {
   { 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
     80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
     95, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
     31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
     46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
     61, 62, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 95, 96, 97,
     98, 99, 100, 101, 102, 103, 104, 105, 106, },
   { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
     31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
     46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
     61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
     76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
     91, 92, 93, 94, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 95, 96, 97,
     98, 99, 100, 101, 102, 103, 104, 105, 106, } };

 int ch[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
   18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
   35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
   52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
   69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
   86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
   102, 103, 104, 105, 106 };

 String psz[] = { "bbsbbssbbss", "bbssbbsbbss", "bbssbbssbbs",
   "bssbssbbsss", "bssbsssbbss", "bsssbssbbss", "bssbbssbsss",
   "bssbbsssbss", "bsssbbssbss", "bbssbssbsss", "bbssbsssbss",
   "bbsssbssbss", "bsbbssbbbss", "bssbbsbbbss", "bssbbssbbbs",
   "bsbbbssbbss", "bssbbbsbbss", "bssbbbssbbs", "bbssbbbssbs",
   "bbssbsbbbss", "bbssbssbbbs", "bbsbbbssbss", "bbssbbbsbss",
   "bbbsbbsbbbs", "bbbsbssbbss", "bbbssbsbbss", "bbbssbssbbs",
   "bbbsbbssbss", "bbbssbbsbss", "bbbssbbssbs", "bbsbbsbbsss",
   "bbsbbsssbbs", "bbsssbbsbbs", "bsbsssbbsss", "bsssbsbbsss",
   "bsssbsssbbs", "bsbbsssbsss", "bsssbbsbsss", "bsssbbsssbs",
   "bbsbsssbsss", "bbsssbsbsss", "bbsssbsssbs", "bsbbsbbbsss",
   "bsbbsssbbbs", "bsssbbsbbbs", "bsbbbsbbsss", "bsbbbsssbbs",
   "bsssbbbsbbs", "bbbsbbbsbbs", "bbsbsssbbbs", "bbsssbsbbbs",
   "bbsbbbsbsss", "bbsbbbsssbs", "bbsbbbsbbbs", "bbbsbsbbsss",
   "bbbsbsssbbs", "bbbsssbsbbs", "bbbsbbsbsss", "bbbsbbsssbs",
   "bbbsssbbsbs", "bbbsbbbbsbs", "bbssbssssbs", "bbbbsssbsbs",
   "bsbssbbssss", "bsbssssbbss", "bssbsbbssss", "bssbssssbbs",
   "bssssbsbbss", "bssssbssbbs", "bsbbssbssss", "bsbbssssbss",
   "bssbbsbssss", "bssbbssssbs", "bssssbbsbss", "bssssbbssbs",
   "bbssssbssbs", "bbssbsbssss", "bbbbsbbbsbs", "bbssssbsbss",
   "bsssbbbbsbs", "bsbssbbbbss", "bssbsbbbbss", "bssbssbbbbs",
   "bsbbbbssbss", "bssbbbbsbss", "bssbbbbssbs", "bbbbsbssbss",
   "bbbbssbsbss", "bbbbssbssbs", "bbsbbsbbbbs", "bbsbbbbsbbs",
   "bbbbsbbsbbs", "bsbsbbbbsss", "bsbsssbbbbs", "bsssbsbbbbs",
   "bsbbbbsbsss", "bsbbbbsssbs", "bbbbsbsbsss", "bbbbsbsssbs",
   "bsbbbsbbbbs", "bsbbbbsbbbs", "bbbsbsbbbbs", "bbbbsbsbbbs",
   "bbsbssssbss", "bbsbssbssss", "bbsbssbbbss", "bbsssbbbsbsbb" };

 final int SETA = 0;
 final int SETB = 1;
 final int SETC = 2;

 byte ia_Buf[] = new byte[4096];
 int i_LenBuf;

 int i_Ratio;

 void BarcodeBase() {
  Clear();
  i_Ratio = 3;
 }

 void Clear() {

  int i;
  for (i = 0; i < 4096; i++)
   ia_Buf[i] = 0;
  i_LenBuf = 0;
 }

 int GetEncodeLength() {

  int i, iLen = 0;
  for (i = 0; i < i_LenBuf; i++) {
   if ((ia_Buf[i] & 2) != 0)
    iLen += (i_Ratio - 1);
  }
  return iLen + i_LenBuf;
 }

 int GetBufferLength() {
  return i_LenBuf;
 }

 int GetRatio() {
  return i_Ratio;
 }

 int SetRatio(int iRatio) {
  i_Ratio = iRatio;
  if (i_Ratio <= 0)
   i_Ratio = 1;
  return 0;
 }

 void DrawBarCodeLine(Graphics hDC, int sx, int sy, int ex, int ey,
   int Color, int penW) {
  // 이건 내가 그리는 구현하자
  // SetColorHEX(Color);
  // FillRect(g_ScreenFB,sx,sy,penW,ey);
  hDC.setColor(Color);
  hDC.drawLine(sx, sy, ex, ey);

  System.out.println("sx "+sx+" sy "+sy+" penW "+penW+" ey "+ey+" COLOR "+Color);
  // DEBUGMSG("sx %d sy %d ex %d ey %d COLOR %d\n",sx, sy, ex, ey,Color);

 }

 void DrawBarcode(Graphics hDC, int iX, int iY0, int iY10, int iY11,
   int iPenW) {
  int clrBar = 0x0;
  int clrSpace = 0xffffff;
  
  // byte *pb=ia_Buf;
  int i0, iNum0 = i_LenBuf;

  byte bBar;
  int i1, iNum1;
  int iY;
  System.out.println("i_LenBuf "+i_LenBuf);
  for (i0 = 0; i0 < iNum0; i0++) {
   bBar = (byte) (ia_Buf[i0] & 0x01);
   iNum1 = (ia_Buf[i0] & 0x02) != 0 ? i_Ratio : 1;
   iY = (ia_Buf[i0] & 0x04) != 0 ? iY11 : iY10;
   for (i1 = 0; i1 < iNum1; i1++) {
    
    if (bBar != 0) {
     DrawBarCodeLine(hDC, iX, iY0, iX, iY, clrBar, iPenW);
    } else {
     DrawBarCodeLine(hDC, iX, iY0, iX, iY, clrSpace, iPenW);
    }
    iX += iPenW;
   }

  }
 }

 boolean Encode128A(String pszCode) {
  Clear();
  char pszCodereturn[] = pszCode.toCharArray();
  // 혹시 널 붙지 않을까 걱정이네
  return P_Encode128(pszCodereturn, SETA);
 }

 void Draw128(Graphics hDC, int iX, int iY0, int iY1, int iPenW) {
  DrawBarcode(hDC, iX, iY0, iY1, iY1, iPenW);
 }

 boolean P_Encode128(char pszCode[], int iSetIn) {
  // Clear();
  // byte pFst[] = ia_Buf;
  // byte pb[] = ia_Buf;

  int iCheckDigit = GetCheckDigit(iSetIn, pszCode);

  int iNum = pszCode.length;

  int iChar, iCharNext;
  int iPosition = 0;
  int iSet = iSetIn;
  count = 0;

  if (iSetIn == SETA)
   ia_Buf = P_GetBarSpace128(ia_Buf, 103);
  else if (iSetIn == SETB)
   ia_Buf = P_GetBarSpace128(ia_Buf, 104);
  else
   ia_Buf = P_GetBarSpace128(ia_Buf, 105);

  if (ia_Buf == null)
   return false;

  while (iPosition < iNum) {
   {
    int iTemp2 = pszCode[iPosition];
    if (iTemp2 < -1)
     iTemp2 = iTemp2 & 255;

    iChar = ga2_Code128[iSet][iTemp2];

    ia_Buf = P_GetBarSpace128(ia_Buf, iChar);
    if (ia_Buf == null)
     return false;
    iPosition++;
    if (iSet == SETA) {
     if (iChar == 100)
      iSet = SETB;
     else if (iChar == 99)
      iSet = SETC;
    } else if (iSet == SETB) {
     if (iChar == 101)
      iSet = SETA;
     else if (iChar == 99)
      iSet = SETC;
    } else if (iChar == 98) {
     if (iSet == SETA)
      iCharNext = ga2_Code128[SETB][pszCode[iPosition]];
     else
      iCharNext = ga2_Code128[SETA][pszCode[iPosition]];

     ia_Buf = P_GetBarSpace128(ia_Buf, iChar);
     if (ia_Buf == null)
      return false;
     iPosition++;
    }
   }
  }

  ia_Buf = P_GetBarSpace128(ia_Buf, iCheckDigit);
  if (ia_Buf == null)
   return false;
  ia_Buf = P_GetBarSpace128(ia_Buf, 106);
  i_LenBuf = count;

  return true;
 }

 int count;

 byte[] P_GetBarSpace128(byte pb[], int iV) {
  int i;

  if (iV < 0)
   return null;
  if (iV > 106)
   return null;

  char buf[] = psz[iV].toCharArray();

  
  for (i = 0; i < 11; i++) {

   if (buf[i] == 'b')
    pb[count] += 1;
   count++;
  }
  if (iV == 106) {
   pb[count] += 1;
   count++;
   pb[count] += 1;
   count++;
  }
  return pb;
 }

 int GetCheckDigit(int iSet, char pszCode[]) {
  int iSum = 0, iCurSet = 0, iChar128, iCharNext, iWeight, iPosition;
  int iNum;

  iCurSet = iSet;
  if (iSet == SETA) {
   iSum = 103;
  } else if (iSet == SETB) {
   iSum = 104;
  } else if (iSet == SETC) {
   iSum = 105;
  }

  iPosition = 0;
  iWeight = 1;

  iNum = pszCode.length;
  while (iPosition < iNum) {

   {
    int iTemp2 = pszCode[iPosition];
    if (iTemp2 < -1)
     iTemp2 = iTemp2 & 255;

    iChar128 = ga2_Code128[iCurSet][iTemp2];

    iSum += (iWeight * iChar128);

    iPosition++;
    iWeight++;

    if (iCurSet == SETA) {
     if (iChar128 == 100)
      iCurSet = SETB;
     else if (iChar128 == 99)
      iCurSet = SETC;
    } else if (iCurSet == SETB) {
     if (iChar128 == 101)
      iCurSet = SETA;
     else if (iChar128 == 99)
      iCurSet = SETC;
    } else if (iChar128 == 98) {
     if (iCurSet == SETA)
      iCharNext = ga2_Code128[SETB][pszCode[iPosition]];
     else
      iCharNext = ga2_Code128[SETA][pszCode[iPosition]];

     iSum += (iWeight * iCharNext);
     iPosition++;
     iWeight++;
    }
   }
  }
  return iSum % 103;
 }
}

아니 이렇게 좋은 swap을 봤나 !!
자료형에 관계없이 모든 것에 다 쓰이는 swap!!


#include <stdio.h>

void swap(void *a, void *b,int width)
{
 int t;

 int i;
 char *p = (char*)a;
 char *q = (char*)b;
 for(i=0; i<width; i++,p++,q++ )
 {
  t = *p;
  *p = *q;
  *q = t;
 }
}

int main()
{
 //int a=0x11111111, b=0x22222222;
 double a=3., b=4.;

 swap(&a,&b, sizeof(a));

 printf("a=%lf, b=%lf\n", a, b );
 //printf("a=%x, b=%x\n", a, b );
 return 0;
}

년월일 분리해서 변수에다가 집어 넣기

for /F "tokens=1" %%a in ('date /t') do set orgdate=%%a

set yy=%orgdate:~0,4%
set mm=%orgdate:~5,2%
set dd=%orgdate:~8,2%

요건 시 분 분리

for /F "tokens=2" %%a in ('time /t') do set orgtime=%%a

set hh=%orgtime:~0,2%
set min=%orgtime:~3,2%

복잡다 한글 조합 ...

내가 지금 해볼건 초성 자음 리스트가 쭉나와서 누르면 자동으로 중성 모음 리스트가 쭉 나온다 또 누르면 종성 자음 리스트가 쭉~!! 나온다 다누르면 한글 1자가 생성되는 것을 만들어 볼려고한다

 
DrawString을 쓸때 보내는 데이타는 완성형 한글 조합 을 가지고 처리를 한다

그런데 지금 한글을 입력하는 키패드를 만들 것은

초성 자음 선택 -> 중성 모음 선택-> 종성 자음 선택 해서 그 조합한 글을 보이는 것인데

완성형데이타로 그려진 자판에서 하나를 선택하면 같은 위치에있는 조합형 데이타를 넣고 ->이걸 반복 해서 한글자를 만들면 그 조합형 데이타 초성 중성 종성을 unsigned short데이타로 만든다

이때 만드는 방법은

1비트, 초성 5비트, 중성 5비트, 종성 5비트  이다 (총 16비트 short값이된다)

만약 종성이 없는 것이라면 1비트 , 초성 5비트, 중성 5비트, +1 하면 "가"라는 종성이 없는 글이 나온다

앞에 나온 1비트는 한글인지 영어인지 나타내는 비트인데 한글일 경우에는 무조건 1을 채워 넣는다

완성형 조합형 변환 하는건 검색하면 천지 삐까리이다

쓰기 좋고 보기 좋은 한글이 컴퓨터 자판 뒤에서는 이렇게나 분답스럽게 작업을 하고있다는 것을 세삼 느낀다

영어라면 그저 꿀인데 ... 뭐 지들 있어봐야 a,b,c,d,거 뭐냐 .. 21자냐 ??

26자구만.. (객관적이고 믿음이 가는 정보를 제공하기위해 자판은 직접 세었습니다)

삼각함수표

자세히 보면

서로 값이 대칭이거나 -값으로 변했다 원이니깐

색깔로되어있는 부분은 모바일로 전환하기위해 소수점을 없애고 자연수로 만들어봤다