발로쓰는 블로그

//////////////////////////////////////////////////
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;
 }
}

cls
javac srcList.java
java srcList
PAUSE


import java.io.*;
import java.util.*;
import java.lang.*;
import java.text.*;

/*
 * java srcList D:\KTF_WIPIC\Pipe\src skt
 * java srcList D:\KTF_WIPIC\Pipe\src lgt
 * skt일때는 파일 명만 lgt일때는 경로 까지 포함한다
 * 파일을 리스트를 뽑아내 텍스트 파일을 만든다
 */
public class srcList
{
    boolean DEBUG = false;
    int cursor = 0, cursor2 = 0;
    String szFileNameSKT[] = new String[128];
    String szFileNameLGT[] = new String[128];
    String szSKTName = "srcList2_skt.txt";
    String szLGTName = "srcList2_lgt.txt";
    String szFileNameSKTFolder[] = new String[128];
    String szSKTFolderName = "srcList2_sktfolder.txt";

    public static void main(String args[])
    {
        srcList mix = new srcList();
        String dir = System.getProperty("user.dir");
        mix.filterFile(dir);
        mix.writeFile(dir);
    }

    public void writeFile(String _curPath){
        String _szSKT = "", _szLGT = "", _szSKTFolder = "";
        for(int i =0; i < cursor; i++){
        //    if(DEBUG)System.out.println("["+i+"]"+szFileNameSKT[i]);
            _szSKT += szFileNameSKT[i]+"\\\n";
            _szLGT += szFileNameLGT[i]+"\\\n";
        }


        for(int i =0; i < cursor2; i++){
        //    if(DEBUG)System.out.println("["+i+"]"+szFileNameSKTFolder[i]);
            _szSKTFolder += szFileNameSKTFolder[i]+"\\\n";
        }

        _szSKT = _szSKT.substring(0, _szSKT.length() - 2);
        _szLGT = _szLGT.substring(0, _szLGT.length() - 2);

        _szSKT += "#";
        _szLGT += "#";

    //    if(DEBUG)System.out.println("SKT:"+_szSKT);
    //    if(DEBUG)System.out.println("LGT:"+_szLGT);

        byte bufNames[] = _szSKT.getBytes();
        save(_curPath, szSKTName, bufNames);

        bufNames = _szLGT.getBytes();
        save(_curPath, szLGTName, bufNames);

        bufNames = _szSKTFolder.getBytes();
        save(_curPath, szSKTFolderName, bufNames);
    }


    public void filterFile(String _curPath)
    {
        if(DEBUG)System.out.println("_curPath:" + _curPath);
        File _fileList = new File(_curPath);
        String _fileNameList[] = _fileList.list();
        String _fullPathFile;
        File _curFile;
        int _len, _idx;
        for(int i = 0 ; i < _fileNameList.length; i ++){
            _fullPathFile = _curPath+"\\"+_fileNameList[i];
            _curFile = new File(_fullPathFile);
            if(DEBUG)System.out.println("["+i+"]:"+_curFile);

            if(_curFile.isFile()){
                _len = _fileNameList[i].length();
                _idx = _fileNameList[i].indexOf(".c");
                if(_idx > 0 && _idx == _len - 2 ){
                    //if(DEBUG)System.out.println(" > 파일:" + _fileNameList[i]);
                    pushName(_curPath, _fileNameList[i]);
                }else{
                    //if(DEBUG)System.out.println(" > 일반파일이라서 패스:" + _fileNameList[i]);
                }
            }else{
            //    if(DEBUG)System.out.println(" > 디렉토리:" + _curFile);
            //    if(DEBUG)System.out.println(" > 디렉토리:" + _curFile.getName());
                pushFolderName(_fullPathFile);
                filterFile(_fullPathFile);
            }
        }
    }

    public void pushName(String _szParentPath, String _szFileName){
        szFileNameSKT[cursor] = _szFileName;
       
       
        int i ;
        int length = _szParentPath.length();
       
        byte dirbuf[]  = new byte[length];
        dirbuf = _szParentPath.getBytes();
        for(i = 0;i< length; i ++)
        {
            if(dirbuf[i]=='\\')
                dirbuf[i] = '/';
        }
        String szParentPath = new String(dirbuf);           
       
        szFileNameLGT[cursor] = szParentPath +"/"+ _szFileName;
                   
        cursor++;
    }


    public void pushFolderName(String _fullPathFile){
        szFileNameSKTFolder[cursor2] = _fullPathFile;
        cursor2++;
    }

    public void save(String directory, String fileName, byte data[]){
        FileOutputStream out = null;
        File file = new File(directory,fileName);
        try{
            out = new FileOutputStream(file);
            out.write(data);
        }catch(Exception e){
            if(DEBUG)System.out.println(fileName+"이 쓰다 오류:"+e);
        }

    }

}

백번 설명보다 첨부된 자료 파일 까서 실행 해보시면 끝

중요내용은 아랫부분입니다.



이게 젤로 중요합니다 해당폴더에가서 copy라는 bat파일을 실행 시킵니다.
Program.launch("copy");




java컴파일 하는 배치파일

cd D:\JavaProject\mmfoggresource\src

set classpath=org.eclipse.swt.win32.win32.x86_3.5.2.v3557f.jar;D:\JavaProject\mmfoggresource\src

javac MMFOggResourceChange.java
java  MMFOggResourceChange D:\KTF_WIPIC\Pipe\res 1200 1235 1 D:\KTF_WIPIC\Pipe\resource\sound_oggtest