librarystatistics.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

			{
				if (in.openBinaryInput(getUrl()))
                    throw new IOException("openBytesInput");
				CheckedInputStream checkedInputStream = new CheckedInputStream(in.dataInputStream, new CRC32());
				if (checkedInputStream.skip(fileLength) != fileLength)
					throw new IOException("skip failed");
				crc = checkedInputStream.getChecksum().getValue();
			} finally
			{
				in.closeInput();
			}

			stat.getDirectory(file.getParent()).files.put(file.getName(), this);
		}

        private URL getUrl() {
            try {
                return file.toURI().toURL();
            } catch (MalformedURLException e) {
                return null;
            }
        }

		public int compareTo(Object o)
		{
			FileInstance f = (FileInstance)o;
			if (lastModified > f.lastModified) return 1;
			if (lastModified < f.lastModified) return -1;
			return fileName.compareTo(f.fileName);
		}
	}

	private static class StatisticsInput extends Input
	{
		private LibraryStatistics stat;

		StatisticsInput(IdManager idManager, URL url)
			throws IOException
		{
			if (openTextInput(url)) throw new IOException("openStatisticsInput");
			try
			{
				stat = new LibraryStatistics(idManager);
				LibraryName libraryName = null;
				long fileLength = 0;
				long crc = 0;
				FileContents fc = null;

				for (;;)
				{
					String line = lineReader.readLine();
					if (line == null) break;
					if (line.length() == 0) continue;
					if (line.charAt(0) != ' ')
					{
						libraryName = stat.getLibraryName(line);
						continue;
					}
					if (line.startsWith("        "))
					{
						String fileName;
						String timeString;
						int indexElib = line.lastIndexOf(".elib");
						int indexJelib = line.lastIndexOf(".jelib");
						int indexDelib = line.lastIndexOf(".delib");
						if (indexElib >= 0)
						{
							fileName = line.substring(8, indexElib + 5);
							timeString = line.substring(indexElib + 5);
						} else if (indexJelib >= 0)
						{
							fileName = line.substring(8, indexJelib + 6);
							timeString = line.substring(indexJelib + 6);
						} else if (indexDelib >= 0)
						{
                            while (indexDelib < line.length() && line.charAt(indexDelib) != ' ')
                                indexDelib++;
							fileName = line.substring(8, indexDelib);
							timeString = line.substring(indexDelib);
						} else
						{
							throw new IOException("Library extension: " + line);
						}
						String[] pieces = timeString.split(" +");
						long lastModified;
						try
						{
							lastModified = Long.parseLong(pieces[1]);
						} catch (NumberFormatException e)
						{
							throw new IOException("lastModified:" + pieces[1]);
						}
						FileInstance f = new FileInstance(stat, fileName, fileLength, lastModified, crc);
						if (fc == null)
							fc = new FileContents(libraryName, f);
						else
							fc.add(f);
					} else if (line.startsWith("    "))
					{
						String[] pieces = line.split(" +");
						try {
							fileLength = Long.parseLong(pieces[1]);
						} catch (NumberFormatException e)
						{
							throw new IOException("fileLength: " + pieces[1]);
						}
						try {
							crc = Long.parseLong(pieces[2], 16);
						} catch (NumberFormatException e)
						{
							throw new IOException("crc: " + pieces[2]);
						}
						fc = null;
					} else
					{
						throw new IOException("bad line:" + line);
					}
				}
			} finally
			{
				closeInput();
			}
		}
	}

	private class StatisticsOutput extends Output
	{
		StatisticsOutput(String filePath)
			throws IOException
		{
			if (openTextOutputStream(filePath)) throw new IOException("openStatisticsOutput");
			try
			{
				for (Iterator lit = getLibraryNames(); lit.hasNext(); )
				{
					LibraryName libraryName = (LibraryName)lit.next();
					printWriter.println(libraryName.getName());
					for (Iterator it = libraryName.getVersions(); it.hasNext(); )
					{
						FileContents fc = (FileContents)it.next();
						Date date = new Date(fc.lastModified);
						printWriter.println("    " + fc.fileLength + " " + Long.toHexString(fc.crc) +
											" " + TextUtils.formatDateGMT(date));
						for (Iterator fit = fc.instances.iterator(); fit.hasNext(); )
						{
							FileInstance f = (FileInstance)fit.next();
							date = new Date(f.lastModified);
							printWriter.println("        " + f.fileName + " " + f.lastModified +
												" " + TextUtils.formatDateGMT(date));
						}
					}
				}
			} finally {
				closeTextOutputStream();
			}
		}
	}

	private static class StatisticsInputSerialized extends Input
	{
		private LibraryStatistics stat;

		StatisticsInputSerialized(URL url)
			throws IOException
		{
			if (openBinaryInput(url)) throw new IOException("openStatisticsInputSerialized");
			try
			{
				ObjectInputStream objectInputStream = new ObjectInputStream(dataInputStream);
				try
				{
					stat = (LibraryStatistics)objectInputStream.readObject();
				} catch (ClassNotFoundException e)
				{
				}
				objectInputStream.close();
			} finally
			{
				closeInput();
			}
		}
	}

	private class StatisticsOutputSerialized extends Output
	{
		StatisticsOutputSerialized(String filePath)
			throws IOException
		{
			if (openBinaryOutputStream(filePath)) throw new IOException("openStatisticsOutputSerialized");
			try
			{
				ObjectOutputStream objectOutputStream = new ObjectOutputStream(dataOutputStream);
				objectOutputStream.writeObject(LibraryStatistics.this);
				objectOutputStream.close();
			} finally {
				closeBinaryOutputStream();
			}
		}
	}

//	private class StatisticsOutputJelib extends Output
//	{
//		StatisticsOutputJelib(String filePath)
//			throws IOException
//		{
//			if (openTextOutputStream(filePath)) throw new IOException("openStatisticsOutputSerialized");
//			try
//			{
//				totalLibraryContents.printJelib(printWriter);
//			} finally {
//				closeTextOutputStream();
//			}
//		}
//	}

	static class VarDesc implements Serializable, Comparable
	{
		String role;
		String varName;
		int varBits;
		int td0, td1;
		int count;

		public int compareTo(Object o)
		{
			VarDesc v = (VarDesc)o;
			int cmp = role.compareTo(v.role);
			if (cmp != 0) return cmp;
			cmp = varName.compareTo(v.varName);
			if (cmp != 0) return cmp;
			if (varBits > v.varBits) return 1;
			if (varBits < v.varBits) return -1;
			if (td0 > v.td0) return 1;
			if (td0 < v.td0) return -1;
			if (td1 > v.td1) return 1;
			if (td1 < v.td1) return -1;
			return 0;
		}
	}

	static class UserBits implements Serializable, Comparable
	{
		String role;
		int bits;
		int count;

		public int compareTo(Object o)
		{
			UserBits u = (UserBits)o;
			int cmp = role.compareTo(u.role);
			if (cmp != 0) return cmp;
			if (bits > u.bits) return 1;
			if (bits < u.bits) return -1;
			return 0;
		}
	}

	static class VarStat implements Serializable
	{
		private static final long serialVersionUID = -2536836777200853733L;
		TreeMap varNamePool = new TreeMap();
		TreeMap varBag = new TreeMap();
		TreeMap userBitsBag = new TreeMap();
		transient TreeMap otherStrings = new TreeMap();
		transient VarDesc dummyVarDesc = new VarDesc();
		transient UserBits dummyUserBits = new UserBits();

		String getVarName(String name)
		{
			String v = (String)varNamePool.get(name);
			if (v == null)
			{
				v = name;
				varNamePool.put(v, v);
			}
			return v;
		}

		void addVarDesc(String varName, int varBits, int td0, int td1, String role)
		{
			td1 &= ~017700000; // hide face
			dummyVarDesc.varName = varName;
			dummyVarDesc.varBits = varBits;
			dummyVarDesc.td0 = td0;
			dummyVarDesc.td1 = td1;
			dummyVarDesc.role = role;
			VarDesc v = (VarDesc)varBag.get(dummyVarDesc);
			if (v == null)
			{
				v = new VarDesc();
				v.varName = getVarName(varName);
				v.varBits = varBits;
				v.td0 = td0;
				v.td1 = td1;
				v.role = (String)otherStrings.get(role);
				if (v.role == null)
				{
					v.role = role;
					otherStrings.put(role, role);
				}
				varBag.put(v, v);
			}
			v.count++;
		}

		void addUserBits(int userBits, String role)
		{
			dummyUserBits.bits = userBits;
			dummyUserBits.role = role;
			UserBits u = (UserBits)userBitsBag.get(dummyUserBits);
			if (u == null)
			{
				u = new UserBits();
				u.bits = userBits;
				u.role = (String)otherStrings.get(role);
				if (u.role == null)
				{
					u.role = role;
					otherStrings.put(role, role);
				}
				userBitsBag.put(u, u);
			}
			u.count++;
		}

	}

	transient VarStat varStat = new VarStat();

	private static class StatisticsInputVariableNames extends Input
	{
		private VarStat vs;

		StatisticsInputVariableNames(URL url)
			throws IOException
		{
			if (openBinaryInput(url)) throw new IOException("openStatisticsInputVariableNames");
			try
			{
				ObjectInputStream objectInputStream = new ObjectInputStream(dataInputStream);
				try
				{
					vs = (VarStat)objectInputStream.readObject();
				} catch (ClassNotFoundException e)
				{
				}
				objectInputStream.close();
			} finally
			{
				closeInput();
			}
		}
	}

	private class StatisticsOutputVariableNames extends Output
	{
		StatisticsOutputVariableNames(String filePath)
			throws IOException
		{
			if (openBinaryOutputStream(filePath)) throw new IOException("openStatisticsOutputSerialized");
			try
			{
				ObjectOutputStream objectOutputStream = new ObjectOutputStream(dataOutputStream);
				objectOutputStream.writeObject(varStat);
				objectOutputStream.close();
				int total = 0;
				for (Iterator it = varStat.varBag.values().iterator(); it.hasNext(); )
					total += ((VarDesc)it.next()).count;
				System.out.println(varStat.varBag.size() + " (" + total + ") variable descriptors");
			} finally {
				closeBinaryOutputStream();
			}
// 			if (openTextOutputStream(filePath)) throw new IOException("openStatisticsOutputVariableNames");
// 			try
// 			{
// 				totalLibraryContents.printJelibVariableNames(printWriter);
// 			} finally {
// 				closeTextOutputStream();
// 			}
		}
	}
}