/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package flex2.compiler.io;
import java.io.*;
import java.util.List;
/**
* A helper class used by classes doing file operations. Part of it's
* original purpose was to consolidate J# handling, but J# support was
* dropped many years ago.
*
* @author Clement Wong
*/
public final class FileUtil
{
public static final boolean caseInsensitive = (System.getProperty("os.name").toLowerCase().startsWith("windows") ||
System.getProperty("os.name").toLowerCase().startsWith("mac"));
/**
* Return an instance of File...
*
* @param path
* @return File
*/
public static File openFile(String path)
{
try
{
return new File(path);
}
catch (Exception e) // J#.NET throws an error if the file is not found...
{
return null;
}
}
public static File openFile(String path, boolean mkdir)
{
File f = new File(path).getAbsoluteFile();
if (mkdir)
{
new File(f.getParent()).mkdirs();
}
return f;
}
/**
* Return an instance of File...
*
* @param parentPath
* @param fileName
* @return File
*/
public static File openFile(File parentPath, String fileName)
{
try
{
return new File(parentPath, fileName);
}
catch (Exception e) // J#.NET throws an error if the file is not found...
{
return null;
}
}
/**
* Create a temp file. Write the input stream to the file...
*
* @param in
* @return
* @throws IOException
*/
public static File createTempFile(InputStream in) throws IOException
{
File temp = File.createTempFile("Flex2_", "");
writeBinaryFile(temp, in);
return temp;
}
/**
* Return an input stream with BOM consumed...
*
* @param file
* @return
* @throws FileNotFoundException
* @throws IOException
*/
public static InputStream openStream(File file) throws FileNotFoundException, IOException
{
return openStream(file.getAbsolutePath());
}
/**
* Return an input stream with BOM consumed...
*
* @param path
* @return
* @throws FileNotFoundException
* @throws IOException
*/
public static InputStream openStream(String path) throws FileNotFoundException, IOException
{
return openStream(new FileInputStream(path));
}
/**
* Return an input stream with BOM consumed...
*
* @param in
* @return
* @throws IOException
*/
public static InputStream openStream(InputStream in) throws IOException
{
byte[] bom = new byte[3];
in.read(bom, 0, 3);
if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf)
{
return in;
}
// else if (bom[0] == 0xff && bom[1] == 0xfe || bom[0] == 0xfe && bom[1] == 0xff)
else
{
return new BOMInputStream(bom, in);
}
}
/**
* It's a normal input stream but it serves BOM before bytes in the stream...
*/
//TODO make a reader version of this class so calls like
// > new BufferedReader(new InputStreamReader(FileUtil.openStream(f)))
// don't have so many levels of indirection to get to the stream
private static final class BOMInputStream extends InputStream
{
private BOMInputStream(byte[] bom, InputStream in)
{
this.bom = bom;
bomSize = bom.length;
this.in = in;
index = 0;
}
private byte[] bom;
private final int bomSize;
private final InputStream in;
private int index;
public int read() throws IOException
{
if (bom == null)
{
return in.read();
}
else
{
int c = bom[index];
if (index == bomSize - 1)
{
bom = null;
}
index += 1;
return c;
}
}
public int read(byte b[], int off, int len) throws IOException
{
if (bom == null)
{
return in.read(b, off, len);
}
int count = 0;
while ((index < 3) && (count < len))
{
b[off+count] = bom[index++];
++count;
}
if (index == 3)
{
bom = null;
}
if (len <= count)
return count;
int r = in.read(b, off+count, len-count);
return (r == -1)? -1 : r + count;
}
public long skip(long n) throws IOException
{
throw new UnsupportedOperationException("supports read() and close() only...");
}
public int available() throws IOException
{
int num = in.available();
if (bom == null)
{
return num;
}
else
{
return (bomSize - index) + num;
}
}
public void close() throws IOException
{
in.close();
}
public synchronized void mark(int readlimit)
{
throw new UnsupportedOperationException("supports read() and close() only...");
}
public synchronized void reset() throws IOException
{
throw new UnsupportedOperationException("supports read() and close() only...");
}
public boolean markSupported()
{
return false;
}
}
/**
* Write a stream of binary data to a file.
* @param file
* @param in
* @throws IOException
*/
public static void writeBinaryFile(File file, InputStream in) throws IOException
{
OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
in = new BufferedInputStream(in);
try
{
streamOutput(in, out);
}
finally
{
out.close();
}
}
public static void streamOutput(InputStream in, OutputStream out)
throws IOException
{
int len = 8192;
byte[] bytes = new byte[len];
while ((len = in.read(bytes, 0, len)) != -1)
{
out.write(bytes, 0, len);
}
// C: caller is responsible for closing the streams.
out.flush();
}
/**
* Write a String to a file
* @param fileName
* @param output
* @throws java.io.IOException
*/
public static void writeFile(String fileName, String output) throws FileNotFoundException, IOException
{
File file = openFile(fileName);
if (file == null)
{
throw new FileNotFoundException(fileName);
}
Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF8"));
try
{
out.write(output);
out.flush();
}
finally
{
out.close();
}
}
public static void writeBinaryFile(String fileName, byte[] output) throws FileNotFoundException, IOException
{
File file = openFile(fileName);
if (file == null)
{
throw new FileNotFoundException(fileName);
}
OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
try
{
out.write(output);
out.flush();
}
finally
{
out.close();
}
}
public static String getCanonicalPath(String path)
{
File f = openFile(path);
return (f == null) ? null : getCanonicalPath(f);
}
public static String getCanonicalPath(File f)
{
try
{
return f.getCanonicalPath();
}
catch (IOException ex)
{
return f.getAbsolutePath();
}
}
public static File getCanonicalFile(File f)
{
try
{
return f.getCanonicalFile();
}
catch (IOException ex)
{
return f.getAbsoluteFile();
}
}
public static String readFile(File f)
{
BufferedReader file = null;
StringBuilder buffer = new StringBuilder((int) f.length());
String lineSep = System.getProperty("line.separator");
try
{
/* TODO
* Do we need a BufferedReader layered on a BufferedInputStream?
* There are so many levels of indirection here that it would be a good idea
* to have an InputBufferReader (like InputBufferStream) and openReader()
*/
file = new BufferedReader(new InputStreamReader(FileUtil.openStream(f)));
String s = null;
while ((s = file.readLine()) != null)
{
buffer.append(s);
buffer.append(lineSep);
}
return buffer.toString();
}
catch (FileNotFoundException ex)
{
return null;
}
catch (IOException ex)
{
return null;
}
finally
{
if (file != null)
{
try
{
file.close();
}
catch (IOException ex)
{
}
}
}
}
public static String readLine(String f, int line)
{
BufferedReader file = null;
try
{
file = new BufferedReader(new InputStreamReader(FileUtil.openStream(f), "UTF8"));
for (int i = 0; i < line - 1 && file.readLine() != null; i++);
return file.readLine();
}
catch (FileNotFoundException ex)
{
return null;
}
catch (IOException ex)
{
return null;
}
finally
{
if (file != null)
{
try
{
file.close();
}
catch (IOException ex)
{
}
}
}
}
public static byte[] readBytes(String f, int line)
{
BufferedInputStream in = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
boolean lastIsCR = false;
int pos = 0, ch = 0, count = 0;
try
{
in = new BufferedInputStream(FileUtil.openStream(f));
while ((ch = in.read()) != -1)
{
if (lastIsCR)
{
count++;
if (line == count)
{
return baos.toByteArray();
}
else
{
baos.reset();
}
if (ch == '\n')
{
lastIsCR = false;
}
else if (ch == '\r')
{
lastIsCR = true;
}
else
{
baos.write(ch);
lastIsCR = false;
}
}
else
{
if (ch == '\n')
{
count++;
if (line == count)
{
return baos.toByteArray();
}
else
{
baos.reset();
}
lastIsCR = false;
}
else if (ch == '\r')
{
lastIsCR = true;
}
else
{
baos.write(ch);
lastIsCR = false;
}
}
pos++;
}
return null;
}
catch (FileNotFoundException ex)
{
return null;
}
catch (IOException ex)
{
return null;
}
finally
{
if (in != null) { try { in.close(); } catch (IOException ex) {} }
}
}
/**
* check whether the provided path is a subdirectory of the list of directories and vice versa.
* @param path
* @param directories
* @return -1 if not
*/
public static int isSubdirectoryOf(File pathFile, List directories)
{
String path = pathFile.toString();
for (int j = 0, size = directories.size(); j < size; j++)
{
File dirFile = FileUtil.getCanonicalFile((File) directories.get(j));
String dir = dirFile.toString();
if (! pathFile.getParent().equals(dirFile.getParent()) &&
(path.length() > dir.length() && path.startsWith(dir) ||
dir.length() > path.length() && dir.startsWith(path)))
{
return j;
}
}
return -1;
}
/**
* check whether the provided directory is a subdirectory of the list of directories.
* @param directory
* @param directories
* @return -1 if not
*/
public static int isSubdirectoryOf(String directory, VirtualFile[] directories)
{
File pathFile = FileUtil.openFile(directory);
String path = pathFile.toString();
for (int j = 0, size = directories == null ? 0 : directories.length; j < size; j++)
{
File dirFile = FileUtil.openFile(directories[j].getName());
String dir = dirFile.toString();
if (!pathFile.getParent().equals(dirFile.getParent()) && path.length() > dir.length() && path.startsWith(dir))
{
return j;
}
}
return -1;
}
public static String getExceptionMessage(Exception ex)
{
return getExceptionMessage(ex, true);
}
public static String getExceptionMessage(Exception ex, boolean stackDump)
{
String m = ex.getMessage();
if (m == null)
{
m = ex.getLocalizedMessage();
}
if (m == null)
{
m = "(" + ex.getClass().getName() + ")";
if (stackDump)
{
StringWriter s = new StringWriter();
PrintWriter p = new PrintWriter(s, true);
ex.printStackTrace(p);
m += s.getBuffer().toString();
}
}
return m;
}
}