excelfileformatdocfunctionextractor.java

来自「EXCEL read and write」· Java 代码 · 共 618 行 · 第 1/2 页

					_fdc.endTableGroup(_lastHeadingText);
					_isInsideTable = false;
				} else if(matchesRelPath(TABLE_ROW_RELPATH_NAMES)) {
					String[] cellData = new String[_rowData.size()];
					_rowData.toArray(cellData);
					_rowData.clear();
					Boolean[] noteFlags = new Boolean[_rowNoteFlags.size()];
					_rowNoteFlags.toArray(noteFlags);
					_rowNoteFlags.clear();
					processTableRow(cellData, noteFlags);
				} else if(matchesRelPath(TABLE_CELL_RELPATH_NAMES)) {
					_rowData.add(_textNodeBuffer.toString().trim());
					_rowNoteFlags.add(Boolean.valueOf(_cellHasNote));
					_textNodeBuffer.setLength(0);
				}
			}
			_elemNameStack.pop();
		}

		private void processTableRow(String[] cellData, Boolean[] noteFlags) {
			// each table row of the document contains data for two functions
			if(cellData.length != 15) {
				throw new RuntimeException("Bad table row size");
			}
			processFunction(cellData, noteFlags, 0);
			processFunction(cellData, noteFlags, 8);
		}
		public void processFunction(String[] cellData, Boolean[] noteFlags, int i) {
			String funcIxStr = cellData[i + 0];
			if (funcIxStr.length() < 1) {
				// empty (happens on the right hand side when there is an odd number of functions)
				return;
			}
			int funcIx = parseInt(funcIxStr);

			boolean hasFootnote = noteFlags[i + 1].booleanValue();
			String funcName = cellData[i + 1];
			int minParams = parseInt(cellData[i + 2]);
			int maxParams = parseInt(cellData[i + 3]);

			String returnClass = cellData[i + 4];
			String paramClasses = cellData[i + 5];
			String volatileFlagStr = cellData[i + 6];
			
			_fdc.addFuntion(funcIx, hasFootnote, funcName, minParams, maxParams, returnClass, paramClasses, volatileFlagStr);
		}
		private static int parseInt(String valStr) {
			try {
				return Integer.parseInt(valStr);
			} catch (NumberFormatException e) {
				throw new RuntimeException("Value '" + valStr + "' could not be parsed as an integer");
			}
		}
		public void startElement(String namespaceURI, String localName, String name, Attributes atts) {
			_elemNameStack.add(name);
			if(matchesTargetPath()) {
				String tableName = atts.getValue("table:name");
				if(tableName.startsWith("tab_fml_func") && !tableName.equals("tab_fml_func0")) {
					_isInsideTable = true;
				}
				return;
			}
			if(matchesPath(0, HEADING_PATH_NAMES)) {
				_textNodeBuffer.setLength(0);
			} else if(matchesRelPath(TABLE_ROW_RELPATH_NAMES)) {
				_rowData.clear();
				_rowNoteFlags.clear();
			} else if(matchesRelPath(TABLE_CELL_RELPATH_NAMES)) {
				_textNodeBuffer.setLength(0);
				_cellHasNote = false;
			} else if(matchesRelPath(NOTE_REF_RELPATH_NAMES_OLD)) {
				_cellHasNote = true;
			} else if(matchesRelPath(NOTE_REF_RELPATH_NAMES)) {
				_cellHasNote = true;
			}
		}

		public void endDocument() {
			// do nothing
		}
		public void endPrefixMapping(String prefix) {
			// do nothing
		}
		public void ignorableWhitespace(char[] ch, int start, int length) {
			// do nothing
		}
		public void processingInstruction(String target, String data) {
			// do nothing
		}
		public void setDocumentLocator(Locator locator) {
			// do nothing
		}
		public void skippedEntity(String name) {
			// do nothing
		}
		public void startDocument() {
			// do nothing
		}
		public void startPrefixMapping(String prefix, String uri) {
			// do nothing
		}
	}

	private static void extractFunctionData(FunctionDataCollector fdc, InputStream is) {
		XMLReader xr;
		
		try {
			// First up, try the default one
			xr = XMLReaderFactory.createXMLReader();
		} catch (SAXException e) {
			// Try one for java 1.4
			System.setProperty("org.xml.sax.driver", "org.apache.crimson.parser.XMLReaderImpl");
			try {
				xr = XMLReaderFactory.createXMLReader();
			} catch (SAXException e2) {
				throw new RuntimeException(e2);
			}
		}
		xr.setContentHandler(new EFFDocHandler(fdc));

		InputSource inSrc = new InputSource(is);

		try {
			xr.parse(inSrc);
			is.close();
		} catch (IOException e) {
			throw new RuntimeException(e);
		} catch (SAXException e) {
			throw new RuntimeException(e);
		}
	}
	/**
	 * To be sure that no tricky unicode chars make it through to the output file.
	 */
	private static final class SimpleAsciiOutputStream extends OutputStream {

		private final OutputStream _os;

		public SimpleAsciiOutputStream(OutputStream os) {
			_os = os;
		}
		public void write(int b) throws IOException {
			checkByte(b);
			_os.write(b);
		}
		private static void checkByte(int b) {
			if (!isSimpleAscii((char)b)) {
				throw new RuntimeException("Encountered char (" + b + ") which was not simple ascii as expected");
			}
		}
		public void write(byte[] b, int off, int len) throws IOException {
			for (int i = 0; i < len; i++) {
				checkByte(b[i + off]);
				
			}
			_os.write(b, off, len);
		}
	}

	private static void processFile(File effDocFile, File outFile) {
		if(!effDocFile.exists()) {
			throw new RuntimeException("file '" + effDocFile.getAbsolutePath() + "' does not exist");
		}
		OutputStream os;
		try {
			os = new FileOutputStream(outFile);
		} catch (FileNotFoundException e) {
			throw new RuntimeException(e);
		}
		os = new SimpleAsciiOutputStream(os);
		PrintStream ps;
		try {
			ps = new PrintStream(os, true, "UTF-8");
		} catch(UnsupportedEncodingException e) {
			throw new RuntimeException(e);
		}
		
		outputLicenseHeader(ps);
		Class genClass = ExcelFileFormatDocFunctionExtractor.class;
		ps.println("# Created by (" + genClass.getName() + ")");
		// identify the source file
		ps.print("# from source file '" + SOURCE_DOC_FILE_NAME + "'");
		ps.println(" (size=" + effDocFile.length() + ", md5=" + getFileMD5(effDocFile) + ")");
		ps.println("#");
		ps.println("#Columns: (index, name, minParams, maxParams, returnClass, paramClasses, isVolatile, hasFootnote )");
		ps.println("");
		try {
			ZipFile zf = new ZipFile(effDocFile);
			InputStream is = zf.getInputStream(zf.getEntry("content.xml"));
			extractFunctionData(new FunctionDataCollector(ps), is);
			zf.close();
		} catch (ZipException e) {
			throw new RuntimeException(e);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		ps.close();
		
		String canonicalOutputFileName;
		try {
			canonicalOutputFileName = outFile.getCanonicalPath();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		System.out.println("Successfully output to '" + canonicalOutputFileName + "'");
	}

	private static void outputLicenseHeader(PrintStream ps) {
		String[] lines= {
			"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.",
		};
		for (int i = 0; i < lines.length; i++) {
			ps.print("# ");
			ps.println(lines[i]);
		}
		ps.println();
	}

	/**
	 * Helps identify the source file
	 */
	private static String getFileMD5(File f) {
		MessageDigest m;
		try {
			m = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException(e);
		}

		byte[]buf = new byte[2048];
		try {
			InputStream is = new FileInputStream(f);
			while(true) {
				int bytesRead = is.read(buf);
				if(bytesRead<1) { 
					break;
				}
				m.update(buf, 0, bytesRead);
			}
			is.close();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		
		return "0x" + new BigInteger(1, m.digest()).toString(16);
	}

	private static File downloadSourceFile() {
		URL url;
		try {
			url = new URL("http://sc.openoffice.org/" + SOURCE_DOC_FILE_NAME);
		} catch (MalformedURLException e) {
			throw new RuntimeException(e);
		}

		File result;
		byte[]buf = new byte[2048];
		try {
			URLConnection conn = url.openConnection();
			InputStream is = conn.getInputStream();
			System.out.println("downloading " + url.toExternalForm());
			result = File.createTempFile("excelfileformat", ".odt");
			OutputStream os = new FileOutputStream(result);
			while(true) {
				int bytesRead = is.read(buf);
				if(bytesRead<1) { 
					break;
				}
				os.write(buf, 0, bytesRead);
			}
			is.close();
			os.close();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		System.out.println("file downloaded ok");
		return result;
	}

	public static void main(String[] args) {

		File outFile = new File("functionMetadata-asGenerated.txt");

		if (false) { // set true to use local file
			File dir = new File("c:/temp");
			File effDocFile = new File(dir, SOURCE_DOC_FILE_NAME);
			processFile(effDocFile, outFile);
			return;
		}
		
		File tempEFFDocFile = downloadSourceFile();
		processFile(tempEFFDocFile, outFile);
		tempEFFDocFile.delete();
	}
}