Main.java :  » 6.0-JDK-Modules-sun » tools » sun » tools » native2ascii » Java Open Source

Java Open Source » 6.0 JDK Modules sun » tools 
tools » sun » tools » native2ascii » Main.java
/*
 * Copyright 1996-2005 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

/*
 * @(#)Main.java  1.37  07/05/05
 */

/*
   Currently javac and load() method in java.util.Properties
  supports only Latin1 encoding input.
  But in Asian platforms programmer or message translator
  uses the editor which support othere than latin1 encoding
  to specify their native language string.
  So if programmer or message translator wants to use other than
  Latin1 character in his/her program source or properties file
  they must convert the file to ASCII plus \udddd notation.
  (javac/load() modification is not appropriate due to
   time constraints for JDK1.1)
  This utility is for the purpose of that conversion.

    NAME
  native2ascii - convert native encoding file to ascii file
           include \udddd Unicode notation

    SYNOPSIS
  native2ascii [options] [inputfile [outputfile]]

    DESCRIPTION
  If outputfile is not described standard output is used as
  output file, and if inputfile is not also described
  stardard input is used as input file.

  Options

  -reverse
     convert ascii with \udddd notation to native encoding

  -encoding encoding_name
     Specify the encoding name which is used by conversion.
     8859_[1 - 9], JIS, EUCJIS, SJIS is currently supported.
     Default encoding is taken from System property "file.encoding".

*/

package sun.tools.native2ascii;

import java.io.*;
import java.util.*;
import java.text.MessageFormat;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.UnsupportedCharsetException;
import sun.tools.native2ascii.A2NFilter;
import sun.tools.native2ascii.N2AFilter;

/**
 * Main program of the native2ascii
 */

public class Main {

    String inputFileName = null;
    String outputFileName = null;
    File tempFile = null;
    boolean reverse = false;
    static String encodingString = null;
    static String defaultEncoding = null;
    static CharsetEncoder encoder = null;

    /**
     * Run the converter
     */
    public synchronized boolean convert(String argv[]){
  Vector v = new Vector(2);
  File outputFile = null;
  boolean createOutputFile = false;

  // Parse arguments
  for (int i = 0; i < argv.length; i++) {
      if (argv[i].equals("-encoding")) {
    if ((i + 1) < argv.length){
        encodingString = argv[++i];
    } else {
        error(getMsg("err.bad.arg"));
        usage();
        return false;
    }
      } else if (argv[i].equals("-reverse")){
    reverse = true;
      } else {
    if (v.size() > 1) {
        usage();
        return false;
    }
    v.addElement(argv[i]);
      }
  }
  if (encodingString == null)
     defaultEncoding = Charset.defaultCharset().name();

        char[] lineBreak = System.getProperty("line.separator").toCharArray();
  try {
      initializeConverter();

      if (v.size() == 1)
    inputFileName = (String)v.elementAt(0);

      if (v.size() == 2) {
    inputFileName = (String)v.elementAt(0);
    outputFileName = (String)v.elementAt(1);
    createOutputFile = true;
      }

      if (createOutputFile) {
    outputFile = new File(outputFileName);
        if (outputFile.exists() && !outputFile.canWrite()) {
      throw new Exception(formatMsg("err.cannot.write", outputFileName));
        }
      }

      if (reverse){
    BufferedReader reader = getA2NInput(inputFileName);
    Writer osw = getA2NOutput(outputFileName);
    String line;

    while ((line = reader.readLine()) != null) {
        osw.write(line.toCharArray());
        osw.write(lineBreak);
        if (outputFileName == null) { // flush stdout
      osw.flush();
        }
    }
    reader.close();  // Close the stream.
    osw.close();
      } else {
       //N2A
    String inLine;
    BufferedReader in = getN2AInput(inputFileName);
          BufferedWriter out = getN2AOutput(outputFileName);

    while ((inLine = in.readLine()) != null) {
        out.write(inLine.toCharArray());
        out.write(lineBreak);
        if (outputFileName == null) { // flush stdout
      out.flush();
        }
    }
          out.close();
      }
      // Since we are done rename temporary file to desired output file
      if (createOutputFile) {
    if (outputFile.exists()) {
        // Some win32 platforms can't handle atomic
        // rename if source and target file paths are
        // identical. To make things simple we just unconditionally 
        // delete the target file before calling renameTo()
        outputFile.delete();
    }
          tempFile.renameTo(outputFile);
      }

  } catch(Exception e){
      error(e.toString());
      return false;
  }

  return true;
    }

    private void error(String msg){
  System.out.println(msg);
    }

    private void usage(){
  System.out.println(getMsg("usage"));
    }


    private BufferedReader getN2AInput(String inFile) throws Exception {

  InputStream forwardIn;
  if (inFile == null)
      forwardIn = System.in;
  else {
      File f = new File(inFile);
      if (!f.canRead()){
    throw new Exception(formatMsg("err.cannot.read", f.getName()));
      }

      try {
     forwardIn = new FileInputStream(inFile);
      } catch (IOException e) { 
         throw new Exception(formatMsg("err.cannot.read", f.getName()));
      }
  }

  BufferedReader r = (encodingString != null) ? 
      new BufferedReader(new InputStreamReader(forwardIn,
                 encodingString)) :
      new BufferedReader(new InputStreamReader(forwardIn));
  return r;
    }


    private BufferedWriter getN2AOutput(String outFile) throws Exception {
  Writer output;
  BufferedWriter n2aOut;

  if (outFile == null)
      output = new OutputStreamWriter(System.out,"US-ASCII");

  else {
      File f = new File(outFile);

      File tempDir = f.getParentFile();

      if (tempDir == null)
    tempDir = new File(System.getProperty("user.dir"));

      tempFile = File.createTempFile("_N2A",
             ".TMP",
              tempDir);
      tempFile.deleteOnExit();

      try {
    output = new FileWriter(tempFile);
      } catch (IOException e){
    throw new Exception(formatMsg("err.cannot.write", tempFile.getName()));
      }
  }

  n2aOut = new BufferedWriter(new N2AFilter(output));
  return n2aOut;
    }
  
    private BufferedReader getA2NInput(String inFile) throws Exception {
  Reader in;
  BufferedReader reader;

  if (inFile == null)
      in = new InputStreamReader(System.in, "US-ASCII");
  else {
      File f = new File(inFile);
      if (!f.canRead()){
    throw new Exception(formatMsg("err.cannot.read", f.getName()));
      }

      try {
     in = new FileReader(inFile);
      } catch (Exception e) { 
         throw new Exception(formatMsg("err.cannot.read", f.getName()));
      }
  }

  reader = new BufferedReader(new A2NFilter(in));
  return reader;
    }

    private Writer getA2NOutput(String outFile) throws Exception {
  
  OutputStreamWriter w = null;
  OutputStream output = null;

  if (outFile == null)
      output = System.out;
  else {
      File f = new File(outFile);

      File tempDir = f.getParentFile();
      if (tempDir == null)
    tempDir = new File(System.getProperty("user.dir"));
      tempFile =  File.createTempFile("_N2A",
              ".TMP",
              tempDir);
      tempFile.deleteOnExit();

      try {
    output = new FileOutputStream(tempFile);
      } catch (IOException e){
    throw new Exception(formatMsg("err.cannot.write", tempFile.getName()));
      }
  }

  w = (encodingString != null) ?
      new OutputStreamWriter(output, encodingString) :
      new OutputStreamWriter(output);
      
  return (w);
    }

    private static Charset lookupCharset(String csName) {
  if (Charset.isSupported(csName)) {
     try {
    return Charset.forName(csName);
           } catch (UnsupportedCharsetException x) {
    throw new Error(x);
     }
  }
  return null;
    }

    public static boolean canConvert(char ch) {
  return (encoder != null && encoder.canEncode(ch));
    }

    private static void initializeConverter() throws UnsupportedEncodingException {
  Charset cs = null;

        try {
      cs = (encodingString == null) ?
          lookupCharset(defaultEncoding):
          lookupCharset(encodingString);

      encoder =  (cs != null) ?
    cs.newEncoder() :
    null;
  } catch (IllegalCharsetNameException e) {
            throw new Error(e);
        } 
    }

    private static ResourceBundle rsrc;

    static {
        try {
            rsrc = ResourceBundle.getBundle(
                     "sun.tools.native2ascii.resources.MsgNative2ascii");
        } catch (MissingResourceException e) {
            throw new Error("Missing message file.");
        }
    }

    private String getMsg(String key) {
        try {
            return (rsrc.getString(key));
        } catch (MissingResourceException e) {
            throw new Error("Error in  message file format.");
        }
    }

    private String formatMsg(String key, String arg) {
        String msg = getMsg(key);
        String[] args = new String[1];
        args[0] = arg;
        return MessageFormat.format(msg, args);
    }


    /**
     * Main program
     */
    public static void main(String argv[]){
  Main converter = new Main();
  System.exit(converter.convert(argv) ? 0 : 1);
    }
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.