core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/core/ScriptContentDescriber.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016 xored software, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     xored software, Inc. - initial API and implementation
  *******************************************************************************/
 package org.eclipse.dltk.core;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.RandomAccessFile;
 import java.io.Reader;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import org.eclipse.core.runtime.QualifiedName;
 import org.eclipse.core.runtime.content.IContentDescription;
 import org.eclipse.core.runtime.content.ITextContentDescriber;
 import org.eclipse.dltk.utils.CharArraySequence;

 public abstract class ScriptContentDescriber implements ITextContentDescriber {
 	@Override
 	public QualifiedName[] getSupportedOptions() {
 		return new QualifiedName[] { DLTKContentTypeManager.DLTK_VALID };
 	}

 	private final static int BUFFER_LENGTH = 2 * 1024;
 	private final static int HEADER_LENGTH = 4 * 1024;
 	private final static int FOOTER_LENGTH = 4 * 1024;

 	private static boolean checkHeader(File file, Pattern[] headerPatterns,
 			Pattern[] footerPatterns) throws FileNotFoundException, IOException {
 		FileInputStream reader = null;
 		try {
 			reader = new FileInputStream(file);
 			byte buf[] = new byte[BUFFER_LENGTH + 1];
 			int res = reader.read(buf);
 			if (res == -1 || res == 0) {
 				return false;
 			}

 			String header = new String(buf);

 			if (checkBufferForPatterns(header, headerPatterns)) {
 				return true;
 			}
 			if (file.length() < BUFFER_LENGTH && footerPatterns != null) {
 				if (checkBufferForPatterns(header, footerPatterns)) {
 					return true;
 				}
 			}

 			return false;
 		} finally {
 			if (reader != null) {
 				try {
 					reader.close();
 				} catch (IOException e) {
 				}
 			}
 		}
 	}

 	private static boolean checkFooter(File file, Pattern[] footerPatterns)
 			throws FileNotFoundException, IOException {
 		RandomAccessFile raFile = new RandomAccessFile(file, "r"); //$NON-NLS-1$
 		try {
 			long len = BUFFER_LENGTH;
 			long fileSize = raFile.length();
 			long offset = fileSize - len;
 			if (offset < 0) {
 				offset = 0;
 			}
 			raFile.seek(offset);
 			byte buf[] = new byte[BUFFER_LENGTH + 1];
 			int code = raFile.read(buf);
 			if (code != -1) {
 				String content = new String(buf, 0, code);
 				if (checkBufferForPatterns(content, footerPatterns)) {
 					return true;
 				}
 			}
 			return false;
 		} finally {
 			raFile.close();
 		}

 	}

 	private static boolean checkBufferForPatterns(CharSequence header,
 			Pattern[] patterns) {
 		if (patterns == null) {
 			return false;
 		}
 		for (int i = 0; i < patterns.length; i++) {
 			Matcher m = patterns[i].matcher(header);
 			if (m.find()) {
 				return true;
 			}
 		}
 		return false;
 	}

 	public static boolean checkPatterns(File file, Pattern[] headerPatterns,
 			Pattern[] footerPatterns) {
 		try {
 			if (checkHeader(file, headerPatterns, footerPatterns)) {
 				return true;
 			}
 			if (footerPatterns != null && file.length() > BUFFER_LENGTH
 					&& checkFooter(file, footerPatterns)) {
 				return true;
 			}
 		} catch (FileNotFoundException e) {
 			return false;
 		} catch (IOException e) {
 			return false;
 		}
 		return false;
 	}

 	/**
 	 * Reads the specified number of bytes from the specified reader. Calls
 	 * {@link Reader#read(char[], int, int)} multiple times until EOF of the
 	 * specified number of bytes is read. Also catches {@link IOException} and
 	 * return -1 on it.
 	 *
 	 * @param reader
 	 * @param bufffer
 	 * @param offset
 	 * @param len
 	 * @return
 	 */
 	private static int read(Reader reader, char[] bufffer, int offset, int len) {
 		try {
 			int count = 0;
 			while (len > 0) {
 				final int result = reader.read(bufffer, offset, len);
 				if (result > 0) {
 					offset += result;
 					len -= result;
 					count += result;
 				} else if (result < 0) {
 					if (count == 0) {
 						return result;
 					} else {
 						break;
 					}
 				}
 			}
 			return count;
 		} catch (IOException e) {
 			if (DLTKCore.DEBUG) {
 				e.printStackTrace(); // ignore
 			}
 			return -1;
 		}
 	}

 	public static boolean checkPatterns(Reader reader,
 			Pattern[] headerPatterns, Pattern[] footerPatterns) {
 		/*
 		 * There is no need to use BufferedReader here since a) we read blocks,
 		 * b) implementation provided by eclipse.core already do buffering.
 		 */
 		final int bufferSize = Math.max(HEADER_LENGTH, FOOTER_LENGTH);
 		char[] buffer = new char[bufferSize];
 		int len = read(reader, buffer, 0, HEADER_LENGTH);
 		if (len > 0) {
 			if (headerPatterns != null && headerPatterns.length > 0) {
 				if (checkBufferForPatterns(new CharArraySequence(buffer, len),
 						headerPatterns)) {
 					return true;
 				}
 			}
 		}
 		if (footerPatterns != null && footerPatterns.length > 0) {
 			char[] prevBuffer = new char[bufferSize];
 			int prevLen = 0;
 			for (;;) {
 				final char[] tempBuffer = buffer;
 				buffer = prevBuffer;
 				prevBuffer = tempBuffer;
 				//
 				final int savedLen = prevLen;
 				prevLen = len;
 				len = savedLen;
 				//
 				len = read(reader, buffer, 0, bufferSize);
 				if (len <= 0) {
 					final CharSequence footer;
 					if (savedLen >= FOOTER_LENGTH) {
 						footer = new CharArraySequence(buffer, savedLen
 								- FOOTER_LENGTH, FOOTER_LENGTH);
 					} else {
 						int footerLength = prevLen;
 						if (savedLen > 0) {
 							footerLength += savedLen;
 						}
 						if (footerLength > FOOTER_LENGTH) {
 							footerLength = FOOTER_LENGTH;
 						}
 						int prevOffset = Math.max(prevLen - footerLength, 0);
 						int prevSize = Math.min(prevLen, footerLength);
 						if (savedLen > 0) {
 							System.arraycopy(buffer, 0, buffer, footerLength
 									- savedLen, savedLen);
 							prevOffset += savedLen;
 							prevSize -= savedLen;
 						}
 						if (prevSize > 0) {
 							System.arraycopy(prevBuffer, prevOffset, buffer, 0,
 									prevSize);
 						}
 						footer = new CharArraySequence(buffer, footerLength);
 					}
 					if (checkBufferForPatterns(footer, footerPatterns)) {
 						return true;
 					}
 				}
 				break;
 			}
 		}
 		return false;
 	}

 	@Override
 	public int describe(InputStream contents, IContentDescription description)
 			throws IOException {
 		return describe(new InputStreamReader(contents), description);
 	}

 	@Override
 	public int describe(Reader contents, IContentDescription description)
 			throws IOException {
 		Pattern[] header = getHeaderPatterns();
 		Pattern[] footer = getFooterPatterns();

 		if (checkPatterns(contents, header, footer)) {
 			if (description != null) {
 				description.setProperty(DLTKContentTypeManager.DLTK_VALID,
 						Boolean.TRUE);
 			}
 			return VALID;
 		}
 		return INDETERMINATE;
 	}

 	/**
 	 * Returns an array of patterns that will be used to scan file headers to
 	 * determine the script content type.
 	 */
 	protected abstract Pattern[] getHeaderPatterns();

 	/**
 	 * Returns an array of patterns that will be used to scan file footers to
 	 * determine the script content type.
 	 *
 	 * <p>
 	 * Default implementation returns <code>null</code>. Subclasses are free to
 	 * override if they wish to provide footer patterns.
 	 * </p>
 	 */
 	protected Pattern[] getFooterPatterns() {
 		return null;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2016 xored software, Inc. and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* xored software, Inc. - initial API and implementation
	*******************************************************************************/
	package org.eclipse.dltk.core;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.RandomAccessFile;
	import java.io.Reader;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;

	import org.eclipse.core.runtime.QualifiedName;
	import org.eclipse.core.runtime.content.IContentDescription;
	import org.eclipse.core.runtime.content.ITextContentDescriber;
	import org.eclipse.dltk.utils.CharArraySequence;

	public abstract class ScriptContentDescriber implements ITextContentDescriber {
	@Override
	public QualifiedName[] getSupportedOptions() {
	return new QualifiedName[] { DLTKContentTypeManager.DLTK_VALID };
	}

	private final static int BUFFER_LENGTH = 2 * 1024;
	private final static int HEADER_LENGTH = 4 * 1024;
	private final static int FOOTER_LENGTH = 4 * 1024;

	private static boolean checkHeader(File file, Pattern[] headerPatterns,
	Pattern[] footerPatterns) throws FileNotFoundException, IOException {
	FileInputStream reader = null;
	try {
	reader = new FileInputStream(file);
	byte buf[] = new byte[BUFFER_LENGTH + 1];
	int res = reader.read(buf);
	if (res == -1 \|\| res == 0) {
	return false;
	}

	String header = new String(buf);

	if (checkBufferForPatterns(header, headerPatterns)) {
	return true;
	}
	if (file.length() < BUFFER_LENGTH && footerPatterns != null) {
	if (checkBufferForPatterns(header, footerPatterns)) {
	return true;
	}
	}

	return false;
	} finally {
	if (reader != null) {
	try {
	reader.close();
	} catch (IOException e) {
	}
	}
	}
	}

	private static boolean checkFooter(File file, Pattern[] footerPatterns)
	throws FileNotFoundException, IOException {
	RandomAccessFile raFile = new RandomAccessFile(file, "r"); //$NON-NLS-1$
	try {
	long len = BUFFER_LENGTH;
	long fileSize = raFile.length();
	long offset = fileSize - len;
	if (offset < 0) {
	offset = 0;
	}
	raFile.seek(offset);
	byte buf[] = new byte[BUFFER_LENGTH + 1];
	int code = raFile.read(buf);
	if (code != -1) {
	String content = new String(buf, 0, code);
	if (checkBufferForPatterns(content, footerPatterns)) {
	return true;
	}
	}
	return false;
	} finally {
	raFile.close();
	}

	}

	private static boolean checkBufferForPatterns(CharSequence header,
	Pattern[] patterns) {
	if (patterns == null) {
	return false;
	}
	for (int i = 0; i < patterns.length; i++) {
	Matcher m = patterns[i].matcher(header);
	if (m.find()) {
	return true;
	}
	}
	return false;
	}

	public static boolean checkPatterns(File file, Pattern[] headerPatterns,
	Pattern[] footerPatterns) {
	try {
	if (checkHeader(file, headerPatterns, footerPatterns)) {
	return true;
	}
	if (footerPatterns != null && file.length() > BUFFER_LENGTH
	&& checkFooter(file, footerPatterns)) {
	return true;
	}
	} catch (FileNotFoundException e) {
	return false;
	} catch (IOException e) {
	return false;
	}
	return false;
	}

	/**
	* Reads the specified number of bytes from the specified reader. Calls
	* {@link Reader#read(char[], int, int)} multiple times until EOF of the
	* specified number of bytes is read. Also catches {@link IOException} and
	* return -1 on it.
	*
	* @param reader
	* @param bufffer
	* @param offset
	* @param len
	* @return
	*/
	private static int read(Reader reader, char[] bufffer, int offset, int len) {
	try {
	int count = 0;
	while (len > 0) {
	final int result = reader.read(bufffer, offset, len);
	if (result > 0) {
	offset += result;
	len -= result;
	count += result;
	} else if (result < 0) {
	if (count == 0) {
	return result;
	} else {
	break;
	}
	}
	}
	return count;
	} catch (IOException e) {
	if (DLTKCore.DEBUG) {
	e.printStackTrace(); // ignore
	}
	return -1;
	}
	}

	public static boolean checkPatterns(Reader reader,
	Pattern[] headerPatterns, Pattern[] footerPatterns) {
	/*
	* There is no need to use BufferedReader here since a) we read blocks,
	* b) implementation provided by eclipse.core already do buffering.
	*/
	final int bufferSize = Math.max(HEADER_LENGTH, FOOTER_LENGTH);
	char[] buffer = new char[bufferSize];
	int len = read(reader, buffer, 0, HEADER_LENGTH);
	if (len > 0) {
	if (headerPatterns != null && headerPatterns.length > 0) {
	if (checkBufferForPatterns(new CharArraySequence(buffer, len),
	headerPatterns)) {
	return true;
	}
	}
	}
	if (footerPatterns != null && footerPatterns.length > 0) {
	char[] prevBuffer = new char[bufferSize];
	int prevLen = 0;
	for (;;) {
	final char[] tempBuffer = buffer;
	buffer = prevBuffer;
	prevBuffer = tempBuffer;
	//
	final int savedLen = prevLen;
	prevLen = len;
	len = savedLen;
	//
	len = read(reader, buffer, 0, bufferSize);
	if (len <= 0) {
	final CharSequence footer;
	if (savedLen >= FOOTER_LENGTH) {
	footer = new CharArraySequence(buffer, savedLen
	- FOOTER_LENGTH, FOOTER_LENGTH);
	} else {
	int footerLength = prevLen;
	if (savedLen > 0) {
	footerLength += savedLen;
	}
	if (footerLength > FOOTER_LENGTH) {
	footerLength = FOOTER_LENGTH;
	}
	int prevOffset = Math.max(prevLen - footerLength, 0);
	int prevSize = Math.min(prevLen, footerLength);
	if (savedLen > 0) {
	System.arraycopy(buffer, 0, buffer, footerLength
	- savedLen, savedLen);
	prevOffset += savedLen;
	prevSize -= savedLen;
	}
	if (prevSize > 0) {
	System.arraycopy(prevBuffer, prevOffset, buffer, 0,
	prevSize);
	}
	footer = new CharArraySequence(buffer, footerLength);
	}
	if (checkBufferForPatterns(footer, footerPatterns)) {
	return true;
	}
	}
	break;
	}
	}
	return false;
	}

	@Override
	public int describe(InputStream contents, IContentDescription description)
	throws IOException {
	return describe(new InputStreamReader(contents), description);
	}

	@Override
	public int describe(Reader contents, IContentDescription description)
	throws IOException {
	Pattern[] header = getHeaderPatterns();
	Pattern[] footer = getFooterPatterns();

	if (checkPatterns(contents, header, footer)) {
	if (description != null) {
	description.setProperty(DLTKContentTypeManager.DLTK_VALID,
	Boolean.TRUE);
	}
	return VALID;
	}
	return INDETERMINATE;
	}

	/**
	* Returns an array of patterns that will be used to scan file headers to
	* determine the script content type.
	*/
	protected abstract Pattern[] getHeaderPatterns();

	/**
	* Returns an array of patterns that will be used to scan file footers to
	* determine the script content type.
	*
	* <p>
	* Default implementation returns <code>null</code>. Subclasses are free to
	* override if they wish to provide footer patterns.
	* </p>
	*/
	protected Pattern[] getFooterPatterns() {
	return null;
	}

	}