sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Restructuring for better separation of Tool packages.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1674 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lhauch
2006-10-05 23:12:07 +00:00
parent 214b0d1914
commit feccee87a7
796 changed files with 32 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Tools/Java/Source/MigrationTools/MANIFEST.MF Normal file
View File

@ -0,0 +1,2 @@
Manifest-Version: 1.0
Main-Class: org.tianocore.migration.MigrationTool

48
Tools/Java/Source/MigrationTools/MigrationTools.msa Normal file
View File

@ -0,0 +1,48 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" >
<MsaHeader>
<ModuleName>MigrationTools</ModuleName>
<ModuleType>TOOL</ModuleType>
<GuidValue>09C77FAE-6374-408e-AB88-32822B92096E</GuidValue>
<Version>1.0</Version>
<Abstract>This is the EFI/Tiano Migration Tool Resources Module</Abstract>
<Description>
This Module provdes the entity, action and exception package for Migration
tools, This package will be shared for building tools or wizard tools.
</Description>
<Copyright>Copyright 2005-2006, Intel Corporation</Copyright>
<License>
All rights reserved.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the
BSD License which accompanies this distribution. The full text of the
license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>NULL</OutputFileBasename>
</ModuleDefinitions>
<SourceFiles>
<Filename>build.xml</Filename>
<Filename>org/tianocore/migration/Database.java</Filename>
<Filename>org/tianocore/migration/FirstPanel.java</Filename>
<Filename>org/tianocore/migration/Func.java</Filename>
<Filename>org/tianocore/migration/Guid.java</Filename>
<Filename>org/tianocore/migration/Macro.java</Filename>
<Filename>org/tianocore/migration/ModuleInfo.java</Filename>
<Filename>org/tianocore/migration/ModuleReader.java</Filename>
<Filename>org/tianocore/migration/MsaWriter.java</Filename>
<Filename>org/tianocore/migration/SourceFileReplacer.java</Filename>
<Filename>org/tianocore/migration/UI.java</Filename>
<Filename>org/tianocore/migration/MsaTreeEditor.java</Filename>
<Filename>org/tianocore/migration/Critic.java</Filename>
<Filename>org/tianocore/migration/Common.java</Filename>
</SourceFiles>
</ModuleSurfaceArea>

52
Tools/Java/Source/MigrationTools/build.xml Normal file
View File

@ -0,0 +1,52 @@
<?xml version="1.0"?>
<!--
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-->
<project name="MigrationTools" default="MigrationTools" basedir=".">
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
<property environment="env"/>
<property name="WORKSPACE" value="${env.WORKSPACE}"/>
<path id="classpath">
<fileset dir="${WORKSPACE}/Tools/Jars" includes="*.jar"/>
<fileset dir="${env.XMLBEANS_HOME}/lib" includes="*.jar"/>
</path>
<property name="buildDir" value="build"/>
<property name="installLocation" value="${WORKSPACE}/Tools/bin"/>
<target name="MigrationTools" depends="install"/>
<target name="source">
<mkdir dir="${buildDir}"/>
<javac srcdir="." destdir="${buildDir}">
<classpath refid="classpath"/>
<compilerarg value="-Xlint"/>
</javac>
</target>
<target name="clean">
<delete dir="${buildDir}"/>
</target>
<target name="cleanall">
<delete dir="${buildDir}"/>
<delete file="${installLocation}/MigrationTools.jar"/>
<if>
<available file="${installLocation}/MigrationTools.jar"/>
<then>
<echo message="You must manually remove the file: ${installLocation}/MigrationTools.jar"/>
<echo message="Java has already loaded the file, and cannot remove it within ANT!"/>
</then>
</if>
</target>
<target name="install" depends="source">
<jar destfile="${installLocation}/MigrationTools.jar"
basedir="${buildDir}"
includes="**"
manifest="MANIFEST.MF"
/>
</target>
</project>

230
Tools/Java/Source/MigrationTools/org/tianocore/migration/Common.java Normal file
View File

@ -0,0 +1,230 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.regex.*;
import java.util.*;
import java.lang.reflect.*;
public final class Common {
public static final int BOTH = 0;
public static final int FILE = 1;
public static final int DIR = 2;
public static final String STRSEPARATER = "(.*)\\\\([^\\\\]*)";
public static final Pattern PTNSEPARATER = Pattern.compile("(.*)\\\\([^\\\\]*)");
//-------------------------------------regex------------------------------------------//
public static final String replaceAll(String line, Pattern ptn, String des) {
Matcher mtr = ptn.matcher(line);
if (mtr.find()) {
return mtr.replaceAll(des);
}
return line;
}
public static final boolean find (String line, String regex) {
Pattern ptn = Pattern.compile(regex);
return ptn.matcher (line).find ();
}
//-------------------------------------regex------------------------------------------//
//-----------------------------------file&string---------------------------------------//
public static final String file2string(String filename) throws Exception {
BufferedReader rd = new BufferedReader(new FileReader(filename));
StringBuffer wholefile = new StringBuffer();
String line;
while ((line = rd.readLine()) != null) {
wholefile.append(line + "\n");
}
rd.close();
return wholefile.toString();
}
public static final void string2file(String content, String filename) throws Exception {
ensureDir(filename);
PrintWriter outfile = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
outfile.append(content);
outfile.flush();
outfile.close();
}
public static final void fileCopy(String src, String des) throws Exception {
string2file(file2string(src), des);
}
//-----------------------------------file&string---------------------------------------//
//--------------------------------------dir--------------------------------------------//
/*
public static final HashSet<String> walkDir(String path, int mode) throws Exception {
HashSet<String> pathlist = new HashSet<String>();
Common.toDoAll(path, Common.class.getMethod("walkDir", String.class), null, null, mode);
return pathlist;
}
*/
public static final void ensureDir(String objFileWhole) {
File tempdir;
Matcher mtrseparate = PTNSEPARATER.matcher(objFileWhole);
if (mtrseparate.find()) {
tempdir = new File(mtrseparate.group(1));
if (!tempdir.exists()) tempdir.mkdirs();
}
}
public static final void deleteDir(String objFileWhole) {
String[] list = new File(objFileWhole).list();
File temp;
for (int i = 0 ; i < list.length ; i++) {
temp = new File(objFileWhole + File.separator + list[i]);
if (temp.isDirectory()) {
deleteDir(objFileWhole + File.separator + list[i]);
} else {
temp.delete();
}
}
new File(objFileWhole).delete();
}
public static final String dirCopy_(String src) throws Exception {
Matcher mtrseparate = Common.PTNSEPARATER.matcher(src);
if (mtrseparate.find()) {
dirCopy(src, mtrseparate.group(1) + File.separator + "_" + mtrseparate.group(2));
}
return mtrseparate.group(1) + File.separator + "_" + mtrseparate.group(2);
}
public static final void dirCopy(String src, String des) throws Exception {
String[] list = new File(src).list();
File test;
ensureDir(des);
for (int i = 0 ; i < list.length ; i++) {
test = new File(src + File.separator + list[i]);
if (test.isDirectory()) {
dirCopy(src + File.separator + list[i], des + File.separator + list[i]);
} else {
//ensureDir(des + File.separator + list[i]);
string2file(file2string(src + File.separator + list[i]), des + File.separator + list[i]);
}
}
}
public static final void oneLevelDirCopy(String src, String des, String type) throws Exception {
String[] list = new File(src).list();
ensureDir(des);
for (int i = 0; i < list.length; i++) {
if (list[i].contains(type)) {
string2file(file2string(src + File.separator + list[i]), des + File.separator + list[i]);
}
}
}
//--------------------------------------dir--------------------------------------------//
//-------------------------------like python walk-----------------------------------------//
public static final void toDoAll(String path, Method md, Object obj, Object[] args, int type) throws Exception {
String[] list = new File(path).list();
ArrayList<Object> _args = new ArrayList<Object>();
_args.add(path);
if (args != null) {
for (int i = 0; i < args.length; i++) {
_args.add(args[i]);
}
}
if (type == DIR || type == BOTH) {
md.invoke(obj, _args.toArray());
}
for (int i = 0 ; i < list.length ; i++) {
if (new File(path + File.separator + list[i]).isDirectory()) {
toDoAll(path + File.separator + list[i], md, obj, args, type);
} else {
if (type == FILE || type == BOTH) {
_args.set(0, path + File.separator + list[i]);
md.invoke(obj, _args.toArray());
}
}
}
}
public static final void toDoAll(Set<String> set, ForDoAll fda) throws Exception {
Iterator<String> di = set.iterator();
while (di.hasNext()) {
fda.run(di.next());
}
}
public static final void toDoAll(String path, ForDoAll fda, int type) throws Exception { // filter of file type can be done in toDo
String[] list = new File(path).list();
File test;
if (type == DIR || type == BOTH) {
fda.run(path);
}
for (int i = 0 ; i < list.length ; i++) {
test = new File(path + File.separator + list[i]);
if (test.isDirectory()) {
if (fda.filter(test)) {
toDoAll(path + File.separator + list[i], fda, type);
}
} else {
if (type == FILE || type == BOTH) {
fda.run(path + File.separator + list[i]);
}
}
}
}
public static interface ForDoAll {
public void run(String filepath) throws Exception;
public boolean filter(File dir);
}
public static abstract class Laplace {
public void transform(String src, String des) throws Exception {
Common.string2file(operation(Common.file2string(src)), des);
}
public abstract String operation(String wholeline);
public abstract boolean recognize(String filename);
public abstract String namechange(String oldname);
}
public static interface Element {
// public int replace = 0;
// public int type = 1;
public String getReplace(String key);
// public void getType(String key);
//
// public void setReplace(int num);
//
// public void setType(int num);
}
}

207
Tools/Java/Source/MigrationTools/org/tianocore/migration/Critic.java Normal file
View File

@ -0,0 +1,207 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.util.regex.*;
import java.io.*;
public final class Critic {
public static final Pattern PTN_NEW_HEAD_COMMENT = Pattern.compile("^\\/\\*\\*.*?\\*\\*\\/",Pattern.DOTALL);
private static final Pattern ptnheadcomment = Pattern.compile("^\\/\\*\\+\\+(.*?)\\-\\-\\*\\/",Pattern.DOTALL);
private static final Pattern ptnfunccomment = Pattern.compile("([\\};\\/\">]\\s*)([\\w\\s\\*]*?[_\\w][_\\w\\d]*\\s*\\([^\\)\\(]*\\)\\s*)\\/\\*\\+\\+(.*?)\\-\\-\\*\\/(\\s*.*?)(?=[\\{;])",Pattern.DOTALL); // find function with {;">/ , may be unsafe
//private static Pattern ptncommentstructure = Pattern.compile("\\/\\*\\+\\+\\s*Routine Description:\\s*(.*?)\\s*Arguments:\\s*(.*?)\\s*Returns:\\s*(.*?)\\s*\\-\\-\\*\\/",Pattern.DOTALL);
private static final Pattern ptncommentequation = Pattern.compile("([^\\s]*)\\s+-\\s+(.*)\\s*");
private static Matcher mtrcommentequation;
private static final Pattern ptnnewcomment = Pattern.compile("(\\s*@(param|retval)\\s+[^\\s]+)\\s+(.*)");
private static Matcher mtrnewcomment;
private static final int totallinelength = 82;
public static final void run(String filepath) throws Exception {
if (MigrationTool.doCritic) { // this is left here to set an example for future structure
critic(filepath);
}
}
private static final void critic(String filepath) throws Exception {
if (filepath.contains(".c") || filepath.contains(".h")) {
BufferedReader rd = null;
String line = null;
StringBuffer templine = new StringBuffer();
boolean incomment = false;
System.out.println("Criticing " + filepath);
String wholeline = Common.file2string(filepath);
wholeline = wholeline.replaceAll("\t", " ");
wholeline = Common.replaceAll(wholeline, ptnheadcomment, "/** @file$1**/");
wholeline = Common.replaceAll(wholeline, ptnfunccomment, "$1\n/**$3\n**/$4$2");
//wholeline = Common.replaceAll(wholeline, ptncommentstructure, "/**\n#%\n$1\n%#\n#%%\n$2\n%%#\n#%%%\n$3\n%%%#\n**/");
// first scan
boolean description = false;
boolean arguments = false;
boolean returns = false;
boolean inequation = false;
rd = new BufferedReader(new StringReader(wholeline));
while ((line = rd.readLine()) != null) {
if (line.matches("\\/\\*\\*")) {
incomment = true;
description = false;
arguments = false;
returns = false;
templine.append(line + "\n");
} else if (line.matches("\\*\\*\\/")) {
incomment = false;
templine.append("\n" + line + "\n");
} else if (incomment) {
if (line.contains("Routine Description:")) {
description = true;
arguments = false;
returns = false;
} else if (line.contains("Arguments:")) {
description = false;
arguments = true;
returns = false;
templine.append("\n");
} else if (line.contains("Returns:")) {
description = false;
arguments = false;
returns = true;
templine.append("\n");
} else if (description) {
if (line.trim().length() != 0) {
templine.append(" " + line.trim() + "\n");
}
} else if (arguments) {
mtrcommentequation = ptncommentequation.matcher(line);
if (mtrcommentequation.find()) {
inequation = true;
templine.append(" @param " + mtrcommentequation.group(1) + " " + mtrcommentequation.group(2) + "\n");
} else if (inequation && line.trim().length() == 0) {
inequation = false;
} else if (inequation && line.trim().length() != 0) {
templine.append("#%#%" + line + "\n");
} else {
if (line.trim().length() != 0) {
templine.append(" " + line.trim() + "\n");
}
}
} else if (returns) {
mtrcommentequation = ptncommentequation.matcher(line);
if (mtrcommentequation.find()) {
inequation = true;
templine.append(" @retval " + mtrcommentequation.group(1) + " " + mtrcommentequation.group(2) + "\n");
} else if (inequation && line.trim().length() == 0) {
inequation = false;
} else if (inequation && line.trim().length() != 0) {
templine.append("#%#%" + line + "\n");
} else {
if (line.trim().length() != 0) {
templine.append(" @return " + line.trim() + "\n");
}
}
}
} else {
templine.append(line + "\n");
}
}
wholeline = templine.toString();
wholeline = wholeline.replaceAll("\n#%#%\\s*", " ");
//
// secend scan
int startmax = 0;
rd = new BufferedReader(new StringReader(wholeline));
while ((line = rd.readLine()) != null) {
if (line.matches("\\/\\*\\*")) {
incomment = true;
templine.append(line + "\n");
} else if (line.matches("\\*\\*\\/")) {
incomment = false;
templine.append(line + "\n");
} else if (incomment) {
mtrnewcomment = ptnnewcomment.matcher(line);
if (mtrnewcomment.find()) {
startmax = mtrnewcomment.group(1).length() > startmax ? mtrnewcomment.group(1).length() : startmax;
}
}
}
startmax++;
//
// third scan
int n = 0;
String temp = null;
String[] tempcont = null;
int count = 0;
templine = new StringBuffer();
rd = new BufferedReader(new StringReader(wholeline));
while ((line = rd.readLine()) != null) {
if (line.matches("\\/\\*\\*")) {
incomment = true;
templine.append(line + "\n");
} else if (line.matches("\\*\\*\\/")) {
incomment = false;
templine.append(line + "\n");
} else if (incomment) {
mtrnewcomment = ptnnewcomment.matcher(line);
if (mtrnewcomment.find()) {
n = startmax - mtrnewcomment.group(1).length();
templine.append(mtrnewcomment.group(1));
while (n-- >= 0) {
templine.append(" ");
}
temp = mtrnewcomment.group(3);
tempcont = temp.split(" "); // use \\s+ ?
count = 0;
for (int i = 0; i < tempcont.length; i++) {
count += tempcont[i].length();
if (count <= (totallinelength - startmax)) {
templine.append(tempcont[i] + " ");
count += 1;
} else {
templine.append("\n");
n = startmax;
while (n-- >= 0) {
templine.append(" ");
}
templine.append(tempcont[i] + " ");
count = tempcont[i].length() + 1;
}
}
templine.append("\n");
} else {
templine.append(line + "\n");
}
} else {
templine.append(line + "\n");
}
}
wholeline = templine.toString();
//
// Remove trailing blanks.
//
wholeline = wholeline.replaceAll (" +\n", "\n");
Common.string2file(wholeline, filepath);
}
}
public static final void fireAt(String path) throws Exception {
//Common.toDoAll(Common.dirCopy_(path), Critic.class.getMethod("critic", String.class), null, null, Common.FILE);
Common.toDoAll(path, Critic.class.getMethod("run", String.class), null, null, Common.FILE);
//Common.toDoAll(Common.dirCopy_(path), critic, Common.FILE);
System.out.println("Critic Done");
}
}

186
Tools/Java/Source/MigrationTools/org/tianocore/migration/Database.java Normal file
View File

@ -0,0 +1,186 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.*;
import java.util.regex.*;
public final class Database {
private static final Database INSTANCE = Database.init();
Database(String path) {
DatabasePath = path;
try {
importDBLib("Library.csv");
importDBGuid("Guid.csv", "Guid");
importDBGuid("Ppi.csv", "Ppi");
importDBGuid("Protocol.csv", "Protocol");
importDBMacro("Macro.csv");
importListR8Only();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
public String DatabasePath;
public Set<String> error = new HashSet<String>();
public Set<String> r8only = new HashSet<String>();
private Map<String,Guid> hashguid = new HashMap<String,Guid>();
private Map<String,Func> hashfunc = new HashMap<String,Func>();
private Map<String,Macro> hashmacro = new HashMap<String,Macro>();
//-------------------------------------import------------------------------------------//
private void importDBLib(String filename) throws Exception {
BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
String line;
String[] linecontext;
Func lf;
if (rd.ready()) {
System.out.println("Found " + filename + ", Importing Library Database.");
while ((line = rd.readLine()) != null) {
if (line.length() != 0) {
linecontext = line.split(",");
lf = new Func(linecontext);
hashfunc.put(lf.r8funcname,lf);
}
}
}
}
private void importDBGuid(String filename, String type) throws Exception {
BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
String line;
String[] linecontext;
Guid gu;
if (rd.ready()) {
System.out.println("Found " + filename + ", Importing " + type + " Database.");
while ((line = rd.readLine()) != null) {
if (line.length() != 0) {
linecontext = line.split(",");
gu = new Guid(linecontext, type);
hashguid.put(gu.r8name,gu);
}
}
}
}
private void importDBMacro(String filename) throws Exception {
BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
String line;
String[] linecontext;
Macro mc;
if (rd.ready()) {
System.out.println("Found " + filename + ", Importing Macro Database.");
while ((line = rd.readLine()) != null) {
if (line.length() != 0) {
linecontext = line.split(",");
mc = new Macro(linecontext);
hashmacro.put(mc.r8name,mc);
}
}
}
}
private void importListR8Only() throws Exception {
Pattern ptnr8only = Pattern.compile("////#?(\\w*)?.*?R8_(.*?)\\s*\\(.*?////~", Pattern.DOTALL);
String wholeline = Common.file2string(DatabasePath + File.separator + "R8Lib.c");
System.out.println("Found " + "R8Lib.c" + ", Importing R8Lib Database.");
Matcher mtrr8only = ptnr8only.matcher(wholeline);
while (mtrr8only.find()) {
r8only.add(mtrr8only.group(2));
}
}
//-------------------------------------import------------------------------------------//
//-------------------------------------get------------------------------------------//
public String getR9Lib(String r8funcname) {
String temp = null;
if (hashfunc.containsKey(r8funcname)) {
temp = hashfunc.get(r8funcname).r9libname;
}
return temp;
}
public String getR9Func(String r8funcname) {
String temp = null;
if (hashfunc.containsKey(r8funcname)) {
temp = hashfunc.get(r8funcname).r9funcname;
}
return temp;
}
public String getR9Macro(String r8macro) {
return hashmacro.get(r8macro).r9name; // the verification job of if the macro exists in the database is done when registering it
}
public String getR9Guidname(String r8Guid) {
String temp = null;
try {
temp = hashguid.get(r8Guid).r9name;
} catch (NullPointerException e) {
error.add("getR9Guidname :" + r8Guid);
}
return temp;
}
public String getGuidType(String r8Guid) {
String temp = null;
try {
temp = hashguid.get(r8Guid).type;
} catch (NullPointerException e) {
error.add("getR9Guidname :" + r8Guid);
}
return temp;
}
//-------------------------------------get------------------------------------------//
//-------------------------------------has------------------------------------------//
public boolean hasFunc(String r8lib) {
return hashfunc.containsKey(r8lib);
}
public boolean hasGuid(String r8guid) {
return hashguid.containsKey(r8guid);
}
public boolean hasMacro(String r8macro) {
return hashmacro.containsKey(r8macro);
}
//-------------------------------------has------------------------------------------//
//-------------------------------------init------------------------------------------//
private static final Database init() {
if (System.getenv("WORKSPACE") == null) {
return new Database("C:" + File.separator + "tianocore" + File.separator + "edk2" + File.separator + "Tools" + File.separator + "Conf" + File.separator + "Migration");
} else {
return new Database(System.getenv("WORKSPACE") + File.separator + "Tools" + File.separator + "Conf" + File.separator + "Migration");
}
}
public static final Database getInstance() {
return INSTANCE;
}
}

281
Tools/Java/Source/MigrationTools/org/tianocore/migration/FirstPanel.java Normal file
View File

@ -0,0 +1,281 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
public final class FirstPanel extends JPanel implements ActionListener, ItemListener, UI {
/**
* Define class Serial Version UID
*/
private static final long serialVersionUID = 207759413522910399L;
private static final FirstPanel INSTANCE = FirstPanel.init();
private String startpath = null;
private JButton moduleButton, goButton, msaEditorButton, criticButton, specifyCommentButton;
private JTextField moduletext;
private JTextArea log;
private JFileChooser fc = new JFileChooser();
private JCheckBox filebox, screenbox, mibox, criticbox, defaultpathbox;
private boolean tofile = true, toscreen = true;
private PrintWriter logfile;
FirstPanel() {
GridBagLayout gridbag = new GridBagLayout();
setLayout(gridbag);
GridBagConstraints cst = new GridBagConstraints();
goButton = new JButton("Go");
goButton.addActionListener(this);
goButton.setActionCommand("go");
moduleButton = new JButton("Choose ModulePath");
moduleButton.addActionListener(this);
msaEditorButton = new JButton("MsaEditor");
msaEditorButton.addActionListener(this);
criticButton = new JButton("Critic");
criticButton.addActionListener(this);
specifyCommentButton = new JButton("Comment Style");
specifyCommentButton.addActionListener(this);
moduletext = new JTextField(30);
filebox = new JCheckBox("Output to logfile", true);
filebox.addItemListener(this);
screenbox = new JCheckBox("Specify logfile", false);
screenbox.addItemListener(this);
mibox = new JCheckBox("Print ModuleInfo", false);
mibox.addItemListener(this);
MigrationTool.printModuleInfo = false;
criticbox = new JCheckBox("Run Critic", true);
criticbox.addItemListener(this);
MigrationTool.doCritic = true;
defaultpathbox = new JCheckBox("Use Default Output Path", true);
defaultpathbox.addItemListener(this);
MigrationTool.defaultoutput = true;
JPanel modulePanel = new JPanel();
modulePanel.add(moduleButton);
modulePanel.add(moduletext);
modulePanel.add(goButton);
//modulePanel.add(msaEditorButton);
cst.gridx = 0;
cst.gridy = 0;
//cst.gridwidth = GridBagConstraints.REMAINDER;
gridbag.setConstraints(modulePanel, cst);
add(modulePanel);
cst.gridx = 1;
cst.gridy = 0;
gridbag.setConstraints(specifyCommentButton, cst);
add(specifyCommentButton);
//gridbag.setConstraints(criticButton, cst);
//add(criticButton);
JPanel checkboxPanel = new JPanel();
checkboxPanel.setLayout(new BoxLayout(checkboxPanel, BoxLayout.Y_AXIS));
checkboxPanel.add(filebox);
checkboxPanel.add(screenbox);
checkboxPanel.add(mibox);
checkboxPanel.add(criticbox);
checkboxPanel.add(defaultpathbox);
cst.gridx = 1;
cst.gridy = 1;
//cst.gridheight = 2;
gridbag.setConstraints(checkboxPanel, cst);
add(checkboxPanel);
log = new JTextArea(10,20);
log.setMargin(new Insets(5,5,5,5));
log.setEditable(false);
JScrollPane logScrollPane = new JScrollPane(log);
cst.gridx = 0;
cst.gridy = 1;
cst.fill = GridBagConstraints.BOTH;
gridbag.setConstraints(logScrollPane, cst);
add(logScrollPane);
}
//---------------------------------------------------------------------------------------//
public boolean yesOrNo(String question) {
return JOptionPane.showConfirmDialog(this, question, "Yes or No", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION;
}
public void print(String message) {
if (toscreen == true) {
log.append(message);
System.out.print(message);
}
if (tofile == true) {
logfile.append(message);
}
}
public void println(String message) {
print(message + "\n");
}
public void println(Set<String> hash) {
if (toscreen == true) {
log.append(hash + "\n");
System.out.println(hash);
}
if (tofile == true) {
logfile.append(hash + "\n");
}
}
public String choose(String message, Object[] choicelist) {
return (String)JOptionPane.showInputDialog(this, message,"Choose",JOptionPane.PLAIN_MESSAGE,null,choicelist,choicelist[0]);
}
public String getInput(String message) {
return (String)JOptionPane.showInputDialog(message);
}
//---------------------------------------------------------------------------------------//
public String getFilepath(String title, int mode) {
fc.setDialogTitle(title);
fc.setFileSelectionMode(mode);
if (fc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
log.append(fc.getSelectedFile().getAbsolutePath() + "\n");
return fc.getSelectedFile().getAbsolutePath();
}
return null;
}
//---------------------------------------------------------------------------------------//
public void actionPerformed(ActionEvent e) {
if ( e.getSource() == moduleButton ) {
startpath = getFilepath("Please choose a starting path", JFileChooser.DIRECTORIES_ONLY);
moduletext.setText(startpath);
}
if ( e.getSource() == goButton ) {
try {
logfile = new PrintWriter(new BufferedWriter(new FileWriter(startpath.replaceAll(Common.STRSEPARATER, "$1") + File.separator + "migration.log")));
MigrationTool.startMigrateAll(startpath);
logfile.flush();
logfile.close();
} catch (Exception en) {
println(en.getMessage());
}
}
if ( e.getSource() == msaEditorButton) {
try {
MsaTreeEditor.init();
} catch (Exception en) {
println(en.getMessage());
}
}
if ( e.getSource() == criticButton) {
try {
Critic.fireAt(startpath);
} catch (Exception en) {
println(en.getMessage());
}
}
if ( e.getSource() == specifyCommentButton) {
try { // input examine is not imposed but should be added
MigrationTool.MIGRATIONCOMMENT = getInput("Please type in wanted comment style used by the tool\nbe sure to start with '//', or you won't enjoy the result");
//MsaWriter.parse("C:\\tianocore\\edk2\\MdePkg\\Library\\BaseLib\\BaseLib.msa");
} catch (Exception en) {
println(en.getMessage());
}
}
}
public void itemStateChanged(ItemEvent e) {
if (e.getSource() == filebox) {
if (e.getStateChange() == ItemEvent.DESELECTED) {
System.out.println("filebox DESELECTED");
} else if (e.getStateChange() == ItemEvent.SELECTED) {
System.out.println("filebox SELECTED");
}
} else if (e.getSource() == screenbox) {
if (e.getStateChange() == ItemEvent.DESELECTED) {
System.out.println("screenbox DESELECTED");
} else if (e.getStateChange() == ItemEvent.SELECTED) {
System.out.println("screenbox SELECTED");
}
} else if (e.getSource() == mibox) {
if (e.getStateChange() == ItemEvent.DESELECTED) {
MigrationTool.printModuleInfo = false;
} else if (e.getStateChange() == ItemEvent.SELECTED) {
MigrationTool.printModuleInfo = true;
}
} else if (e.getSource() == criticbox) {
if (e.getStateChange() == ItemEvent.DESELECTED) {
MigrationTool.doCritic = false;
} else if (e.getStateChange() == ItemEvent.SELECTED) {
MigrationTool.doCritic = true;
}
} else if (e.getSource() == defaultpathbox) {
if (e.getStateChange() == ItemEvent.DESELECTED) {
MigrationTool.defaultoutput = false;
} else if (e.getStateChange() == ItemEvent.SELECTED) {
MigrationTool.defaultoutput = true;
}
}
}
//---------------------------------------------------------------------------------------//
private static final FirstPanel init() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
//UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
//UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
} catch (Exception e) {
System.out.println(e.getMessage());
}
JFrame frame = new JFrame("MigrationTools");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
FirstPanel fp = new FirstPanel();
//fp.setLayout(new GridBagLayout());
//fp.setLayout(new BoxLayout(fp, BoxLayout.Y_AXIS));
fp.setOpaque(true);
frame.setContentPane(fp);
frame.pack();
frame.setVisible(true);
return fp;
}
public static final FirstPanel getInstance() {
return INSTANCE;
}
}

66
Tools/Java/Source/MigrationTools/org/tianocore/migration/Func.java Normal file
View File

@ -0,0 +1,66 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.util.regex.*;
public class Func {
Func(String r8func,String r8lib,String r9func,String r9lib) {
r8funcname = r8func;
r8libname = r8lib;
r9funcname = r9func;
r9libname = r9lib;
}
Func(String[] linecontext) {
r8funcname = linecontext[1];
r8libname = linecontext[0];
r9funcname = linecontext[2];
if (r9funcname.contains("n/a")) {
r9funcname = "#error Unknown or missing library function in EDKII: " + r8funcname;
}
r9libname = linecontext[3];
}
public String r8funcname;
public String r8libname;
public String r9funcname;
public String r9libname;
public static Pattern ptnbrace = Pattern.compile("\\{[^\\{\\}]*\\}",Pattern.MULTILINE);
public static Pattern ptnfuncc = Pattern.compile("(?<!->)([a-zA-Z_]\\w*)\\s*\\(",Pattern.MULTILINE);
public static Pattern ptnfuncd = Pattern.compile("([a-zA-Z_]\\w*)\\s*\\([^\\)\\(]*\\)\\s*@",Pattern.MULTILINE);
public static Pattern ptnlowcase = Pattern.compile("[a-z]"); // must be removed
private static String reservedwords = "if for pack while switch return sizeof";
public static String register(Matcher mtr, ModuleInfo mi, Database db) {
String temp = null;
temp = mtr.group(1); // both changed and not changed funcc are registered , for finding all the non-local function calls
Matcher mtrlowcase = ptnlowcase.matcher(temp); // must be removed , so the two funcs can be merged
if (!reservedwords.contains(temp) && mtrlowcase.find()) {
mi.hashfuncc.add(temp);
}
return temp;
}
/*
public static String registerFuncD(Matcher mtr, ModuleInfo mi, Database db) {
String temp = null;
temp = mtr.group(1); // both changed and not changed funcd are registered , for finding all the non-local function calls
if (!reservedwords.contains(temp)) {
mi.hashfuncd.add(temp);
}
return temp;
}
*/
}

61
Tools/Java/Source/MigrationTools/org/tianocore/migration/Guid.java Normal file
View File

@ -0,0 +1,61 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.util.regex.*;
public class Guid {
Guid (String r8, String t, String n, String r9, String gv, String p) {
r8name = r8;
type = t;
name = n;
r9name = r9;
guidvalue = gv;
pack = p;
}
Guid (String[] linecontext, String t) {
r8name = linecontext[1];
type = t;
name = linecontext[0];
r9name = linecontext[2];
guidvalue = linecontext[3];
pack = linecontext[4];
}
public String r8name;
public String type;
public String name;
public String r9name;
public String guidvalue;
public String pack;
public static Pattern ptnguid = Pattern.compile("g\\w*Guid");
public static String register(Matcher mtr, ModuleInfo mi, Database db) {
String type = null;
String temp = null;
temp = mtr.group();
if (MigrationTool.db.hasGuid(temp)) { // only changed guids registered, because both changed and not changed guids are included in database
type = MigrationTool.db.getGuidType(temp);
if (type.matches("Protocol")) {
mi.protocols.add(temp);
} else if (type.matches("Ppi")) {
mi.ppis.add(temp);
} else if (type.matches("Guid")) {
mi.guids.add(temp);
}
return temp;
}
return null;
}
}

47
Tools/Java/Source/MigrationTools/org/tianocore/migration/Macro.java Normal file
View File

@ -0,0 +1,47 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.util.regex.*;
public class Macro {
Macro(String r8, String r9) {
r8name = r8;
r9name = r9;
}
Macro(String[] linecontext) {
r8name = linecontext[0];
r9name = linecontext[1];
}
public String r8name;
public String r9name;
public static Pattern ptntmacro = Pattern.compile("\\b[A-Z_]+\\s*?\\(?\\b",Pattern.MULTILINE);
private static String unmacro = "VOID UINTN BOOLEAN ASSERT OPTIONAL STATIC NULL TRUE IN OUT FALSE";
public static String register(Matcher mtr, ModuleInfo mi, Database db) {
String temp = null;
temp = mtr.group();
mi.hashmacro.add(temp);
if (MigrationTool.db.hasMacro(temp)) { // only changed macros registered, because the database of macro has only changed ones
if (!unmacro.contains(temp)) {
mi.hashnonlocalmacro.add(temp);
}
return temp;
}
return null;
}
}

121
Tools/Java/Source/MigrationTools/org/tianocore/migration/MigrationTool.java Normal file
View File

@ -0,0 +1,121 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.File;
import java.util.*;
import javax.swing.JFileChooser;
import org.tianocore.UsageTypes;
public class MigrationTool {
public static UI ui = null;
public static Database db = null;
public static String MIGRATIONCOMMENT = "//@MT:";
public static boolean printModuleInfo = false;
public static boolean doCritic = false;
public static boolean defaultoutput = false;
public static final HashMap<ModuleInfo, String> ModuleInfoMap = new HashMap<ModuleInfo, String>();
private static String startpath = null;
private static final void mainFlow(ModuleInfo mi) throws Exception {
ModuleReader.aimAt(mi);
SourceFileReplacer.fireAt(mi); // some adding library actions are taken here,so it must be put before "MsaWriter"
// show result
if (MigrationTool.printModuleInfo) {
MigrationTool.ui.println("\nModule Information : ");
MigrationTool.ui.println("Entrypoint : " + mi.entrypoint);
show(mi.protocols, "Protocol : ");
show(mi.ppis, "Ppi : ");
show(mi.guids, "Guid : ");
show(mi.hashfuncc, "call : ");
show(mi.hashfuncd, "def : ");
show(mi.hashEFIcall, "EFIcall : ");
show(mi.hashnonlocalmacro, "macro : ");
show(mi.hashnonlocalfunc, "nonlocal : ");
show(mi.hashr8only, "hashr8only : ");
}
new MsaWriter(mi).flush();
mi.addProtocol("protocol", UsageTypes.ALWAYS_CONSUMED);
mi.addGuid("guid", UsageTypes.ALWAYS_CONSUMED);
mi.addLibraryClass("class", UsageTypes.ALWAYS_CONSUMED);
mi.addPpi("ppi", UsageTypes.ALWAYS_CONSUMED);
mi.getMsaOwner().flush(MigrationTool.ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename + File.separator + mi.modulename + ".___");
if (MigrationTool.doCritic) {
Critic.fireAt(ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename);
}
MigrationTool.ui.println("Errors Left : " + MigrationTool.db.error);
MigrationTool.ui.println("Complete!");
//MigrationTool.ui.println("Your R9 module was placed here: " + mi.modulepath + File.separator + "result");
//MigrationTool.ui.println("Your logfile was placed here: " + mi.modulepath);
}
private static final void show(Set<String> hash, String show) {
MigrationTool.ui.println(show + hash.size());
MigrationTool.ui.println(hash);
}
public static final String getTempDir(String modulepath) {
return "C:" + File.separator + "MigrationTool_Temp" + modulepath.replace(startpath, "");
}
private static final String assignOutPutPath(String inputpath) {
if (MigrationTool.defaultoutput) {
return inputpath.replaceAll(Common.STRSEPARATER, "$1");
} else {
return MigrationTool.ui.getFilepath("Please choose where to place the output module", JFileChooser.DIRECTORIES_ONLY);
}
}
public static final void seekModule(String filepath) throws Exception {
if (ModuleInfo.isModule(filepath)) {
ModuleInfoMap.put(new ModuleInfo(filepath), assignOutPutPath(filepath));
}
}
public static final void startMigrateAll(String path) throws Exception {
startpath = path;
MigrationTool.ui.println("Project Migration");
MigrationTool.ui.println("Copyright (c) 2006, Intel Corporation");
if (new File("C:" + File.separator + "MigrationTool_Temp").exists()) {
Common.deleteDir("C:" + File.separator + "MigrationTool_Temp");
}
Common.toDoAll(path, MigrationTool.class.getMethod("seekModule", String.class), null, null, Common.DIR);
Iterator<ModuleInfo> miit = ModuleInfoMap.keySet().iterator();
while (miit.hasNext()) {
mainFlow(miit.next());
}
ModuleInfoMap.clear();
Common.deleteDir("C:" + File.separator + "MigrationTool_Temp");
}
public static void main(String[] args) throws Exception {
ui = FirstPanel.getInstance();
db = Database.getInstance();
}
}

119
Tools/Java/Source/MigrationTools/org/tianocore/migration/ModuleInfo.java Normal file
View File

@ -0,0 +1,119 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.*;
import org.tianocore.UsageTypes;
/*
Class ModuleInfo is built for scanning the source files, it contains all the needed
information and all the temporary data.
*/
public final class ModuleInfo {
ModuleInfo(String modulepath) throws Exception {
this.modulepath = modulepath;
this.temppath = MigrationTool.getTempDir(this.modulepath);
}
public final String modulepath;
public final String temppath;
private MsaOwner msaowner = MsaOwner.initNewMsaOwner();
public String modulename = null;
public String guidvalue = null;
public String moduletype = null;
public String entrypoint = null;
public final Set<String> localmodulesources = new HashSet<String>(); //contains both .c and .h
public final Set<String> preprocessedccodes = new HashSet<String>();
public final Set<String> msaorinf = new HashSet<String>(); //only a little, hash may be too big for this
public final Set<String> infincludes = new HashSet<String>();
public final Set<String> infsources = new HashSet<String>();
public final Set<String> hashfuncc = new HashSet<String>();
public final Set<String> hashfuncd = new HashSet<String>();
public final Set<String> hashnonlocalfunc = new HashSet<String>();
public final Set<String> hashnonlocalmacro = new HashSet<String>();
public final Set<String> hashEFIcall = new HashSet<String>();
public final Set<String> hashr8only = new HashSet<String>();
public final Set<String> hashmacro = new HashSet<String>();
public final Set<String> hashrequiredr9libs = new HashSet<String>(); // hashrequiredr9libs is now all added in SourceFileReplacer
public final Set<String> guids = new HashSet<String>();
public final Set<String> protocols = new HashSet<String>();
public final Set<String> ppis = new HashSet<String>();
//-----------------------------------------------------------------------------------//
public final boolean addProtocol (String proname, UsageTypes.Enum usage) {
//protocols.add(proname);
return msaowner.addProtocol(proname, usage);
}
public final boolean addPpi (String ppiname, UsageTypes.Enum usage) {
//ppis.add(ppiname);
return msaowner.addPpi(ppiname, usage);
}
public final boolean addGuid (String guidname, UsageTypes.Enum usage) {
//guids.add(guidname);
return msaowner.addGuid(guidname, usage);
}
public final boolean addLibraryClass(String name, UsageTypes.Enum usage) {
//hashrequiredr9libs.add(name);
return msaowner.addLibraryClass(name, usage);
}
//-----------------------------------------------------------------------------------//
public final String getModuleType() {
if (moduletype.contains("PEI")) {
return "PEIM";
} else {
return "DXE_DRIVER";
}
}
public final void enroll(String filepath) throws Exception {
String temp = null;
if (filepath.contains(".c") || filepath.contains(".C") || filepath.contains(".h") ||
filepath.contains(".H") || filepath.contains(".dxs") || filepath.contains(".uni")) {
localmodulesources.add(filepath.replace(modulepath + File.separator, ""));
} else if (filepath.contains(".inf") || filepath.contains(".msa")) {
temp = filepath.replace(modulepath + File.separator, "");
if (!temp.contains(File.separator)) { // .inf in subdirectory is not regarded
msaorinf.add(temp);
}
}
}
public static final boolean isModule(String path) {
String[] list = new File(path).list();
for (int i = 0 ; i < list.length ; i++) {
if (!new File(list[i]).isDirectory()) {
if (list[i].contains(".inf") || list[i].contains(".msa")) {
return true;
}
}
}
return false;
}
public final MsaOwner getMsaOwner() {
return msaowner;
}
}

318
Tools/Java/Source/MigrationTools/org/tianocore/migration/ModuleReader.java Normal file
View File

@ -0,0 +1,318 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import org.tianocore.*;
public final class ModuleReader implements Common.ForDoAll {
private static final ModuleReader modulereader = new ModuleReader();
private ModuleInfo mi;
private final CommentLaplace commentlaplace = new CommentLaplace();
private static final Pattern ptninfequation = Pattern.compile("([^\\s]*)\\s*=\\s*([^\\s]*)");
private static final Pattern ptnsection = Pattern.compile("\\[([^\\[\\]]*)\\]([^\\[\\]]*)\\n", Pattern.MULTILINE);
private static final Pattern ptnfilename = Pattern.compile("[^\\s]+");
public final void ModuleScan() throws Exception {
Common.toDoAll(mi.modulepath, ModuleInfo.class.getMethod("enroll", String.class), mi, null, Common.FILE);
// inf&msa
String filename = null;
if (mi.msaorinf.isEmpty()) {
MigrationTool.ui.println("No INF nor MSA file found!");
System.exit(0);
} else {
if (mi.msaorinf.size() == 1) {
filename = (String)mi.msaorinf.toArray()[0];
} else {
filename = MigrationTool.ui.choose("Found .inf or .msa file for module\n" + mi.modulepath + "\nChoose one Please", mi.msaorinf.toArray());
}
}
if (filename.contains(".inf")) {
readInf(filename);
} else if (filename.contains(".msa")) {
readMsa(filename);
}
// inf&msa
preProcessModule();
}
private final void readMsa(String name) throws Exception {
ModuleSurfaceAreaDocument msadoc = ModuleSurfaceAreaDocument.Factory.parse(new File(mi.modulepath + File.separator + name));
ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = msadoc.getModuleSurfaceArea();
MsaHeaderDocument.MsaHeader msaheader = msa.getMsaHeader();
mi.modulename = msaheader.getModuleName();
mi.guidvalue = msaheader.getGuidValue();
mi.moduletype = msaheader.getModuleType().toString(); // ???
SourceFilesDocument.SourceFiles sourcefiles = msa.getSourceFiles();
String temp;
Iterator<FilenameDocument.Filename> li = sourcefiles.getFilenameList().iterator();
while (li.hasNext()) {
if (!mi.localmodulesources.contains(temp = li.next().toString())) {
System.out.println("Source File Missing! : " + temp);
}
}
}
private final void readInf(String name) throws Exception {
System.out.println("\nParsing INF file: " + name);
String wholeline;
Matcher mtrinfequation;
Matcher mtrsection;
Matcher mtrfilename;
wholeline = Common.file2string(mi.modulepath + File.separator + name);
mtrsection = ptnsection.matcher(wholeline);
while (mtrsection.find()) {
if (mtrsection.group(1).matches("defines")) {
mtrinfequation = ptninfequation.matcher(mtrsection.group(2));
while (mtrinfequation.find()) {
if (mtrinfequation.group(1).matches("BASE_NAME")) {
mi.modulename = mtrinfequation.group(2);
}
if (mtrinfequation.group(1).matches("FILE_GUID")) {
mi.guidvalue = mtrinfequation.group(2);
}
if (mtrinfequation.group(1).matches("COMPONENT_TYPE")) {
mi.moduletype = mtrinfequation.group(2);
}
}
}
if (mtrsection.group(1).contains("nmake.")) {
mtrinfequation = ptninfequation.matcher(mtrsection.group(2));
while (mtrinfequation.find()) {
if (mtrinfequation.group(1).matches("IMAGE_ENTRY_POINT")) {
mi.entrypoint = mtrinfequation.group(2);
}
if (mtrinfequation.group(1).matches("DPX_SOURCE")) {
if (!mi.localmodulesources.contains(mtrinfequation.group(2))) {
MigrationTool.ui.println("DPX File Missing! : " + mtrinfequation.group(2));
}
}
}
}
if (mtrsection.group(1).contains("sources.")) {
mtrfilename = ptnfilename.matcher(mtrsection.group(2));
while (mtrfilename.find()) {
mi.infsources.add(mtrfilename.group());
if (!mi.localmodulesources.contains(mtrfilename.group())) {
MigrationTool.ui.println("Warn: Source File Missing! : " + mtrfilename.group());
}
}
}
if (mtrsection.group(1).matches("includes.")) {
mtrfilename = ptnfilename.matcher(mtrsection.group(2));
while (mtrfilename.find()) {
mi.infincludes.add(mtrfilename.group());
}
}
}
}
private final void preProcessModule() throws Exception {
// according to .inf file, add extraordinary includes and sourcefiles
Common.dirCopy(mi.modulepath, mi.temppath); // collect all Laplace.namechange to here???
if (!mi.infincludes.isEmpty()) {
Iterator<String> it = mi.infincludes.iterator();
String tempincludename = null;
while (it.hasNext()) {
tempincludename = it.next();
if (tempincludename.contains("..")) {
Matcher mtr = Common.PTNSEPARATER.matcher(tempincludename);
if (mtr.find() && !mtr.group(2).matches(".")) {
Common.oneLevelDirCopy(mi.modulepath.replaceAll(Common.STRSEPARATER, "$1") + File.separator + mtr.group(2), mi.temppath, ".h");
} else {
Common.oneLevelDirCopy(mi.modulepath.replaceAll(Common.STRSEPARATER, "$1"), mi.temppath, ".h");
}
}
}
}
if (!mi.infsources.isEmpty()) {
Iterator<String> it = mi.infsources.iterator();
String tempsourcename = null;
while (it.hasNext()) {
tempsourcename = it.next();
if (tempsourcename.contains("..")) {
Common.ensureDir(mi.temppath + File.separator + "MT_Parent_Sources");
Matcher mtr = Common.PTNSEPARATER.matcher(tempsourcename);
if (mtr.find()) {
Common.fileCopy(mi.modulepath.replaceAll(Common.STRSEPARATER, "$1") + File.separator + mtr.group(2), mi.temppath + File.separator + "MT_Parent_Sources" + File.separator + mtr.group(2));
}
}
}
}
//CommentOutNonLocalHFile();
Common.toDoAll(mi.temppath, this, Common.FILE);
parsePreProcessedSourceCode();
}
private final void parsePreProcessedSourceCode() throws Exception {
//Cl cl = new Cl(modulepath);
//cl.execute("Fat.c");
//cl.generateAll(preprocessedccodes);
//
//System.out.println("Note!!!! The CL is not implemented now , pls do it manually!!! RUN :");
//System.out.println("cl " + modulepath + "\\temp\\*.c" + " -P");
//String[] list = new File(modulepath + File.separator + "temp").list(); // without CL , add
BufferedReader rd = null;
String ifile = null;
String line = null;
String temp = null;
Iterator<String> ii = mi.localmodulesources.iterator();
while (ii.hasNext()) {
temp = ii.next();
if (temp.contains(".c")) {
mi.preprocessedccodes.add(temp);
}
}
ii = mi.preprocessedccodes.iterator();
Pattern patefifuncc = Pattern.compile("g?(BS|RT)\\s*->\\s*([a-zA-Z_]\\w*)",Pattern.MULTILINE);
Matcher matguid;
Matcher matfuncc;
Matcher matfuncd;
Matcher matenclosereplace;
Matcher matefifuncc;
Matcher matmacro;
while (ii.hasNext()) {
StringBuffer wholefile = new StringBuffer();
ifile = ii.next();
rd = new BufferedReader(new FileReader(mi.temppath + File.separator + ifile));
while ((line = rd.readLine()) != null) {
wholefile.append(line + '\n');
}
line = wholefile.toString();
// find guid
matguid = Guid.ptnguid.matcher(line); // several ways to implement this , which one is faster ? :
while (matguid.find()) { // 1.currently , find once , then call to identify which is it
if ((temp = Guid.register(matguid, mi, MigrationTool.db)) != null) { // 2.use 3 different matchers , search 3 times to find each
//matguid.appendReplacement(result, MigrationTool.db.getR9Guidname(temp)); // search the database for all 3 kinds of guids , high cost
}
}
//matguid.appendTail(result);
//line = result.toString();
// find EFI call in form of '->' , many 'gUnicodeCollationInterface->' like things are not changed
// This item is not simply replaced , special operation is required.
matefifuncc = patefifuncc.matcher(line);
while (matefifuncc.find()) {
mi.hashEFIcall.add(matefifuncc.group(2));
}
// find function call
matfuncc = Func.ptnfuncc.matcher(line);
while (matfuncc.find()) {
if ((temp = Func.register(matfuncc, mi, MigrationTool.db)) != null) {
//MigrationTool.ui.println(ifile + " dofunc " + temp);
//matfuncc.appendReplacement(result, MigrationTool.db.getR9Func(temp));
}
}
//matfuncc.appendTail(result);
//line = result.toString();
// find macro
matmacro = Macro.ptntmacro.matcher(line);
while (matmacro.find()) {
if ((temp = Macro.register(matmacro, mi, MigrationTool.db)) != null) {
}
}
// find function definition
// replace all {} to @
while ((matenclosereplace = Func.ptnbrace.matcher(line)).find()) {
line = matenclosereplace.replaceAll("@");
}
matfuncd = Func.ptnfuncd.matcher(line);
while (matfuncd.find()) {
if ((temp = Func.register(matfuncd, mi, MigrationTool.db)) != null) {
}
}
}
// op on hash
Iterator<String> funcci = mi.hashfuncc.iterator();
while (funcci.hasNext()) {
if (!mi.hashfuncd.contains(temp = funcci.next()) && !mi.hashEFIcall.contains(temp)) {
mi.hashnonlocalfunc.add(temp); // this set contains both changed and not changed items
}
}
}
public class CommentLaplace extends Common.Laplace {
public String operation(String wholeline) {
StringBuffer wholebuffer = new StringBuffer();
String templine = null;
Pattern ptnincludefile = Pattern.compile("[\"<](.*[.]h)[\">]");
Pattern ptninclude = Pattern.compile("#include\\s*(.*)");
Matcher mtrinclude = ptninclude.matcher(wholeline);
Matcher mtrincludefile = null;
while (mtrinclude.find()) {
mtrincludefile = ptnincludefile.matcher(mtrinclude.group(1));
if (mtrincludefile.find() && mi.localmodulesources.contains(mtrincludefile.group(1))) {
templine = mtrinclude.group();
} else {
templine = MigrationTool.MIGRATIONCOMMENT + mtrinclude.group();
}
mtrinclude.appendReplacement(wholebuffer, templine);
}
mtrinclude.appendTail(wholebuffer);
return wholebuffer.toString();
}
public boolean recognize(String filename) {
return filename.contains(".c") || filename.contains(".h");
}
public String namechange(String oldname) {
return oldname;
}
}
//-----------------------------------ForDoAll-----------------------------------//
public void run(String filepath) throws Exception {
String name = mi.temppath + File.separator + filepath.replace(mi.temppath + File.separator, "");
commentlaplace.transform(name, name);
}
public boolean filter(File dir) {
return true;
}
//-----------------------------------ForDoAll-----------------------------------//
public final void setModuleInfo(ModuleInfo m) {
mi = m;
}
public static final void aimAt(ModuleInfo mi) throws Exception {
modulereader.setModuleInfo(mi);
modulereader.ModuleScan();
}
}

390
Tools/Java/Source/MigrationTools/org/tianocore/migration/MsaOwner.java Normal file
View File

@ -0,0 +1,390 @@
package org.tianocore.migration;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.*;
import org.apache.xmlbeans.XmlOptions;
import org.tianocore.*;
import org.tianocore.SupportedArchitectures.Enum;
public class MsaOwner {
public static final String COPYRIGHT = "Copyright (c) 2006, Intel Corporation";
public static final String VERSION = "1.0";
public static final String ABSTRACT = "Component name for module ";
public static final String DESCRIPTION = "FIX ME!";
public static final String LICENSE = "All rights reserved.\n" +
" This software and associated documentation (if any) is furnished\n" +
" under a license and may only be used or copied in accordance\n" +
" with the terms of the license. Except as permitted by such\n" +
" license, no part of this software or documentation may be\n" +
" reproduced, stored in a retrieval system, or transmitted in any\n" +
" form or by any means without the express written consent of\n" +
" Intel Corporation.";
public static final String SPECIFICATION = "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052";
public static final Enum IA32 = SupportedArchitectures.IA_32;
public static final Enum X64 = SupportedArchitectures.X_64;
public static final Enum IPF = SupportedArchitectures.IPF;
public static final Enum EBC = SupportedArchitectures.EBC;
private ModuleSurfaceAreaDocument msadoc = ModuleSurfaceAreaDocument.Factory.newInstance();
private ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = null;
private MsaHeaderDocument.MsaHeader msaheader = null;
private LicenseDocument.License license = null;
private ModuleDefinitionsDocument.ModuleDefinitions moduledefinitions = null;
private SourceFilesDocument.SourceFiles sourcefiles = null; //found local .h files are not written
private GuidsDocument.Guids guids = null;
private ProtocolsDocument.Protocols protocols = null;
private PPIsDocument.PPIs ppis = null;
private PackageDependenciesDocument.PackageDependencies packagedependencies = null;
private LibraryClassDefinitionsDocument.LibraryClassDefinitions libclassdefs = null;
private ExternsDocument.Externs externs = null;
private List<Enum> listarch = new ArrayList<Enum>();
//private Map<String, Enum> mapfilenames = new HashMap<String, Enum>(); //this need to be installed manually when msa is to be written
//private Map<String, UsageTypes.Enum> mapprotocols = new HashMap<String, UsageTypes.Enum>();
//-----------------------------msaheader-------------------------------------//
public final boolean addLibraryClass (String name, UsageTypes.Enum usage) {
Iterator<LibraryClassDocument.LibraryClass> classit = libclassdefs.getLibraryClassList().iterator();
while (classit.hasNext()) {
if (classit.next().getKeyword() == name) {
MigrationTool.ui.println ("Warning: Duplicate LibraryClass");
return false;
}
}
LibraryClassDocument.LibraryClass classname;
classname = libclassdefs.addNewLibraryClass();
classname.setKeyword(name);
classname.setUsage(usage);
return true;
}
public final boolean addGuid (String guidname, UsageTypes.Enum usage) {
if (guids == null) {
guids = msa.addNewGuids();
}
Iterator<GuidsDocument.Guids.GuidCNames> guidit = guids.getGuidCNamesList().iterator();
while (guidit.hasNext()) {
if (guidit.next().getGuidCName() == guidname) {
MigrationTool.ui.println ("Warning: Duplicate Guid");
return false;
}
}
GuidsDocument.Guids.GuidCNames guid;
guid = guids.addNewGuidCNames();
guid.setGuidCName(guidname);
guid.setUsage(usage);
return true;
}
public final boolean addPpi (String ppiname, UsageTypes.Enum usage) {
if (ppis == null) {
ppis = msa.addNewPPIs();
}
Iterator<PPIsDocument.PPIs.Ppi> ppiit = ppis.getPpiList().iterator();
while (ppiit.hasNext()) {
if (ppiit.next().getPpiCName() == ppiname) {
MigrationTool.ui.println ("Warning: Duplicate Ppi");
return false;
}
}
PPIsDocument.PPIs.Ppi ppi;
ppi = ppis.addNewPpi();
ppi.setPpiCName(ppiname);
ppi.setUsage(usage);
return true;
}
/*
private final boolean installProtocols () {
if (mapprotocols.isEmpty()) {
return false;
}
Set<String> setprotocols = mapprotocols.keySet();
ProtocolsDocument.Protocols.Protocol protocol;
Iterator<String> it = setprotocols.iterator();
while (it.hasNext()) {
protocol = protocols.addNewProtocol();
protocol.setProtocolCName(it.next());
protocol.setUsage(mapprotocols.get(protocol.getProtocolCName()));
}
return true;
}
public final boolean addProtocols (String protocol, UsageTypes.Enum usage) {
if (mapprotocols.containsKey(protocol)) {
return false;
} else {
mapprotocols.put(protocol, usage);
return true;
}
}
*/
public final boolean addProtocol (String proname, UsageTypes.Enum usage) {
if (protocols == null) {
protocols = msa.addNewProtocols();
}
Iterator<ProtocolsDocument.Protocols.Protocol> proit = protocols.getProtocolList().iterator();
while (proit.hasNext()) {
if (proit.next().getProtocolCName() == proname) {
MigrationTool.ui.println ("Warning: Duplicate Protocol");
return false;
}
}
ProtocolsDocument.Protocols.Protocol protocol;
protocol = protocols.addNewProtocol();
protocol.setProtocolCName(proname);
protocol.setUsage(usage);
return true;
}
/*
private final boolean installHashFilename () {
if (mapfilenames.isEmpty()) {
return false;
}
Set<String> setfilename = mapfilenames.keySet();
FilenameDocument.Filename filename;
List<Enum> arch = new ArrayList<Enum>();
Iterator<String> it = setfilename.iterator();
while (it.hasNext()) {
filename = sourcefiles.addNewFilename();
filename.setStringValue(it.next());
arch.add(mapfilenames.get(filename.getStringValue()));
filename.setSupArchList(arch);
}
return true;
}
public final boolean addSourceFile (String filename, Enum arch) { // dummy & null how to imply?
if (mapfilenames.containsKey(filename)) {
return false;
} else {
mapfilenames.put(filename, arch);
return true;
}
}
*/
public final boolean addSourceFile (String name, Enum en) {
Iterator<FilenameDocument.Filename> fileit = sourcefiles.getFilenameList().iterator();
while (fileit.hasNext()) {
if (fileit.next().getStringValue() == name) {
MigrationTool.ui.println ("Warning: Duplicate SourceFileName");
return false;
}
}
FilenameDocument.Filename filename;
List<Enum> arch = new ArrayList<Enum>();
filename = sourcefiles.addNewFilename();
filename.setStringValue(name);
arch.add(en);
filename.setSupArchList(arch);
return true;
}
// entry point todo
public final boolean setupExternSpecification () {
addExternSpecification("EFI_SPECIFICATION_VERSION 0x00020000");
addExternSpecification("EDK_RELEASE_VERSION 0x00020000");
return true;
}
public final boolean addExternSpecification (String specification) {
if (externs.getSpecificationList().contains(specification)) {
return false;
} else {
externs.addSpecification(specification);
return true;
}
}
public final boolean setupPackageDependencies() {
addPackage("5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec");
addPackage("68169ab0-d41b-4009-9060-292c253ac43d");
return true;
}
public final boolean addPackage (String guid) {
if (packagedependencies.getPackageList().contains(guid)) {
return false;
} else {
packagedependencies.addNewPackage().setPackageGuid(guid);
return true;
}
}
public final boolean setupModuleDefinitions () { //????????? give this job to moduleinfo
moduledefinitions.setBinaryModule(false);
moduledefinitions.setOutputFileBasename(msaheader.getModuleName());
return true;
}
public final boolean addSupportedArchitectures (Enum arch) {
if (listarch.contains(arch)) {
return false;
} else {
listarch.add(arch);
return true;
}
}
public final boolean addSpecification (String specification) {
if (msaheader.getSpecification() == null) {
if (specification == null) {
msaheader.setSpecification(SPECIFICATION);
} else {
msaheader.setSpecification(specification);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate Specification");
return false;
}
}
public final boolean addLicense (String licensecontent) {
if (msaheader.getLicense() == null) {
license = msaheader.addNewLicense();
if (licensecontent == null) {
license.setStringValue(LICENSE);
} else {
license.setStringValue(licensecontent);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate License");
return false;
}
}
public final boolean addDescription (String description) {
if (msaheader.getDescription() == null) {
if (description == null) {
msaheader.setDescription(DESCRIPTION);
} else {
msaheader.setDescription(description);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate Description");
return false;
}
}
public final boolean addAbstract (String abs) {
if (msaheader.getAbstract() == null) {
if (abs == null) {
msaheader.setAbstract(ABSTRACT + msaheader.getModuleName());
} else {
msaheader.setVersion(abs);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate Abstract");
return false;
}
}
public final boolean addVersion (String version) {
if (msaheader.getVersion() == null) {
if (version == null) {
msaheader.setVersion(VERSION);
} else {
msaheader.setVersion(version);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate Version");
return false;
}
}
public final boolean addCopyRight (String copyright) {
if (msaheader.getCopyright() == null) {
if (copyright == null) {
msaheader.setCopyright(COPYRIGHT);
} else {
msaheader.setCopyright(copyright);
}
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate CopyRight");
return false;
}
}
public final boolean addModuleType (String moduletype) {
if (msaheader.getModuleType() == null) {
msaheader.setModuleType(ModuleTypeDef.Enum.forString(moduletype));
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate ModuleType");
return false;
}
}
public final boolean addGuidValue (String guidvalue) {
if (msaheader.getGuidValue() == null) {
msaheader.setGuidValue(guidvalue);
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate GuidValue");
return false;
}
}
public final boolean addModuleName (String modulename) {
if (msaheader.getModuleName() == null) {
msaheader.setModuleName(modulename);
return true;
} else {
MigrationTool.ui.println ("Warning: Duplicate ModuleName");
return false;
}
}
//-----------------------------msaheader-------------------------------------//
public final void flush(String outputpath) throws Exception {
XmlOptions options = new XmlOptions();
options.setCharacterEncoding("UTF-8");
options.setSavePrettyPrint();
options.setSavePrettyPrintIndent(2);
options.setUseDefaultNamespace();
BufferedWriter bw = new BufferedWriter(new FileWriter(outputpath));
msadoc.save(bw, options);
bw.flush();
bw.close();
}
private final MsaOwner init () {
msa = msadoc.addNewModuleSurfaceArea();
msaheader = msa.addNewMsaHeader();
moduledefinitions = msa.addNewModuleDefinitions();
moduledefinitions.setSupportedArchitectures(listarch);
sourcefiles = msa.addNewSourceFiles();
packagedependencies = msa.addNewPackageDependencies();
libclassdefs = msa.addNewLibraryClassDefinitions();
externs = msa.addNewExterns();
return this;
}
public static final MsaOwner initNewMsaOwner() {
return new MsaOwner().init();
}
}

161
Tools/Java/Source/MigrationTools/org/tianocore/migration/MsaTreeEditor.java Normal file
View File

@ -0,0 +1,161 @@
package org.tianocore.migration;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;
import javax.xml.parsers.*;
import org.w3c.dom.*;
public class MsaTreeEditor extends JPanel {
/**
* Define class Serial Version UID
*/
private static final long serialVersionUID = 3169905938472150649L;
private
/*
MsaTreeEditor(ModuleInfo m, UI u, ModuleSurfaceAreaDocument md) {
mi = m;
ui = u;
msadoc = md;
//rootNode = msadoc.getDomNode();
rootNode = new DefaultMutableTreeNode("Root Node");
treeModel = new DefaultTreeModel(rootNode);
tree = new JTree(treeModel);
tree.setEditable(true);
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setShowsRootHandles(false);
tree.addMouseListener(mouseadapter);
JScrollPane scrollPane = new JScrollPane(tree);
add(scrollPane);
popupmenu = new JPopupMenu();
menuitemadd = new JMenuItem("addNode");
menuitemdel = new JMenuItem("deleteNode");
popupmenu.add(menuitemadd);
popupmenu.add(menuitemdel);
menuitemadd.addActionListener(actionListener);
menuitemdel.addActionListener(actionListener);
addNode(rootNode, "1st");
addNode(rootNode, "2nd");
}
*/
MsaTreeEditor() throws Exception {
rootNode = new DefaultMutableTreeNode("Root Node");
treeModel = new DefaultTreeModel(rootNode);
tree = new JTree(treeModel);
tree.setEditable(true);
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.setShowsRootHandles(false);
tree.addMouseListener(mouseadapter);
JScrollPane scrollPane = new JScrollPane(tree);
//scrollPane.setSize(800, 600);
add(scrollPane);
popupmenu = new JPopupMenu();
menuitemadd = new JMenuItem("Add Node");
menuitemdel = new JMenuItem("Delete Node");
menuitemedit = new JMenuItem("Edit Node");
popupmenu.add(menuitemadd);
popupmenu.add(menuitemdel);
popupmenu.add(menuitemedit);
menuitemadd.addActionListener(actionListener);
menuitemdel.addActionListener(actionListener);
menuitemedit.addActionListener(actionListener);
genDomTree(MigrationTool.ui.getFilepath("Select a msa file", JFileChooser.FILES_AND_DIRECTORIES));
}
//private ModuleSurfaceAreaDocument msadoc;
private JTree tree;
private DefaultMutableTreeNode rootNode;
private DefaultTreeModel treeModel;
private JMenuItem menuitemadd, menuitemdel, menuitemedit;
private JPopupMenu popupmenu;
private MouseAdapter mouseadapter = new MouseAdapter() {
public void mouseReleased(MouseEvent me) {
if (me.getClickCount() == 1 && SwingUtilities.isRightMouseButton(me)) {
tree.setSelectionPath(tree.getPathForLocation(me.getX(), me.getY()));
popupmenu.show(tree, me.getX(), me.getY());
}
}
};
private ActionListener actionListener = new ActionListener() {
public void actionPerformed(ActionEvent ae) {
if (ae.getSource() == menuitemadd) {
addNode();
} else if (ae.getSource() == menuitemdel) {
delNode();
} else if (ae.getSource() == menuitemedit) {
editNode();
}
}
};
private void editNode() {
DefaultMutableTreeNode node = (DefaultMutableTreeNode)(tree.getSelectionPath().getLastPathComponent());
Element element = (Element)node.getUserObject();
System.out.println(element.getTextContent());
}
private void delNode() {
treeModel.removeNodeFromParent((DefaultMutableTreeNode)(tree.getSelectionPath().getLastPathComponent()));
}
private void addNode() {
addNode((DefaultMutableTreeNode)(tree.getSelectionPath().getLastPathComponent()), MigrationTool.ui.getInput("Input Node Name"));
}
private DefaultMutableTreeNode addNode(DefaultMutableTreeNode parentNode, Object child) {
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);
treeModel.insertNodeInto(childNode, parentNode, parentNode.getChildCount());
tree.scrollPathToVisible(new TreePath(childNode.getPath()));
return childNode;
}
private final void handleNode(Node node, DefaultMutableTreeNode parentNode) {
DefaultMutableTreeNode curNode = null;
if (node.getNodeType() == Node.ELEMENT_NODE) {
System.out.println("elem");
curNode = addNode(parentNode, node);
} else if (node.getNodeType() == Node.DOCUMENT_NODE){
System.out.println("doc");
curNode = addNode(parentNode, "MsaDocum"); // can Docum be with Root Node?
}
NodeList nodelist = node.getChildNodes();
for (int i = 0; i < nodelist.getLength(); i++) {
handleNode(nodelist.item(i), curNode);
}
}
private final void genDomTree(String filename) throws Exception {
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document document = builder.parse(filename);
handleNode(document, rootNode);
}
public static final void init() throws Exception {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
JFrame frame = new JFrame("MsaTreeEditor");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MsaTreeEditor mte = new MsaTreeEditor();
mte.setLayout(new GridBagLayout());
mte.setOpaque(true);
frame.setContentPane(mte);
frame.pack();
frame.setVisible(true);
}
}

213
Tools/Java/Source/MigrationTools/org/tianocore/migration/MsaWriter.java Normal file
View File

@ -0,0 +1,213 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.*;
import org.tianocore.*;
import org.tianocore.SupportedArchitectures.Enum;
import org.apache.xmlbeans.*;
public class MsaWriter {
MsaWriter(ModuleInfo moduleinfo) {
mi = moduleinfo;
}
private ModuleInfo mi;
private ModuleSurfaceAreaDocument msadoc = ModuleSurfaceAreaDocument.Factory.newInstance();
private ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = msadoc.addNewModuleSurfaceArea();
private MsaHeaderDocument.MsaHeader msaheader = msa.addNewMsaHeader();
private ModuleDefinitionsDocument.ModuleDefinitions md = msa.addNewModuleDefinitions();
private SourceFilesDocument.SourceFiles sourcefiles = msa.addNewSourceFiles(); //found local .h files are not written
private GuidsDocument.Guids guids;
private ProtocolsDocument.Protocols protocols;
private PPIsDocument.PPIs ppis;
private PackageDependenciesDocument.PackageDependencies pd = msa.addNewPackageDependencies();
private LibraryClassDefinitionsDocument.LibraryClassDefinitions libclassdefs = msa.addNewLibraryClassDefinitions();
private ExternsDocument.Externs externs = msa.addNewExterns();
private String Query (String requirement) throws Exception {
String answer;
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
System.out.println(requirement);
while ((answer = rd.readLine()).length() == 0) ;
return answer;
}
private void addSourceFiles (String name) { // furthur modification needed
List<Enum> arch = new ArrayList<Enum>();
FilenameDocument.Filename filename;
filename = sourcefiles.addNewFilename();
filename.setStringValue(name);
if (name.contains("x64" + File.separator)) { // filename ???
arch.add(SupportedArchitectures.X_64);
System.out.println("x64" + File.separator);
filename.setSupArchList(arch);
} else if (name.contains("Ia32" + File.separator)) { // filename ???
arch.add(SupportedArchitectures.IA_32);
System.out.println("Ia32" + File.separator);
filename.setSupArchList(arch);
} else if (name.contains("Ipf" + File.separator)) { // filename ???
arch.add(SupportedArchitectures.IPF);
System.out.println("Ipf" + File.separator);
filename.setSupArchList(arch);
} else if (name.contains("Ebc" + File.separator)) { // filename ???
arch.add(SupportedArchitectures.EBC);
System.out.println("Ebc" + File.separator);
filename.setSupArchList(arch);
}
}
private ModuleSurfaceAreaDocument fulfillMsadoc() throws Exception {
Iterator<String> it;
String temp;
if (mi.modulename != null) {
msaheader.setModuleName(mi.modulename);
} else {
msaheader.setModuleName(mi.modulename = Query("Module Name Not Found! Please Input ModuleName"));
}
if (mi.guidvalue == null) {
mi.guidvalue = UUID.randomUUID().toString();
MigrationTool.ui.println ("Guid value can not be retrieved from inf file. Generate " + mi.guidvalue + " at random!");
}
msaheader.setGuidValue(mi.guidvalue);
if (mi.moduletype != null) {
msaheader.setModuleType(ModuleTypeDef.Enum.forString(mi.getModuleType()));
} else {
msaheader.setModuleType(ModuleTypeDef.Enum.forString(mi.moduletype = Query("Guid Value Not Found! Please Input Guid Value")));
}
msaheader.setCopyright("Copyright (c) 2006, Intel Corporation");
msaheader.setVersion("1.0");
msaheader.setAbstract("Component name for module " + mi.modulename);
msaheader.setDescription("FIX ME!");
msaheader.addNewLicense().setStringValue("All rights reserved.\n" +
" This software and associated documentation (if any) is furnished\n" +
" under a license and may only be used or copied in accordance\n" +
" with the terms of the license. Except as permitted by such\n" +
" license, no part of this software or documentation may be\n" +
" reproduced, stored in a retrieval system, or transmitted in any\n" +
" form or by any means without the express written consent of\n" +
" Intel Corporation.");
msaheader.setSpecification("FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052");
List<Enum> arch = new ArrayList<Enum>();
arch.add(SupportedArchitectures.IA_32);
arch.add(SupportedArchitectures.X_64);
arch.add(SupportedArchitectures.IPF);
arch.add(SupportedArchitectures.EBC);
md.setSupportedArchitectures(arch);
md.setBinaryModule(false);
md.setOutputFileBasename(mi.modulename);
pd.addNewPackage().setPackageGuid("5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec");
pd.addNewPackage().setPackageGuid("68169ab0-d41b-4009-9060-292c253ac43d");
externs.addNewSpecification().setStringValue("EFI_SPECIFICATION_VERSION 0x00020000");
externs.addNewSpecification().setStringValue("EDK_RELEASE_VERSION 0x00020000");
if (mi.entrypoint != null) {
externs.addNewExtern().setModuleEntryPoint(mi.entrypoint);
org.tianocore.ModuleTypeDef.Enum moduleType = msaheader.getModuleType();
if (moduleType == ModuleTypeDef.PEIM) {
mi.hashrequiredr9libs.add("PeimEntryPoint");
} else {
mi.hashrequiredr9libs.add("UefiDriverEntryPoint");
}
}
it = mi.localmodulesources.iterator();
while (it.hasNext()) {
addSourceFiles(it.next());
}
if (!mi.protocols.isEmpty()) {
protocols = msa.addNewProtocols();
it = mi.protocols.iterator();
while (it.hasNext()) {
if ((temp = it.next()) != null) {
ProtocolsDocument.Protocols.Protocol pr = protocols.addNewProtocol();
pr.setProtocolCName(temp);
pr.setUsage(UsageTypes.ALWAYS_CONSUMED);
}
}
}
if (!mi.ppis.isEmpty()) {
ppis = msa.addNewPPIs();
it = mi.ppis.iterator();
while (it.hasNext()) {
if ((temp = it.next()) != null) {
PPIsDocument.PPIs.Ppi pp = ppis.addNewPpi();
pp.setPpiCName(temp);
pp.setUsage(UsageTypes.ALWAYS_CONSUMED);
}
}
}
if (!mi.guids.isEmpty()) {
guids = msa.addNewGuids();
it = mi.guids.iterator();
while (it.hasNext()) {
if ((temp = it.next()) != null) {
GuidsDocument.Guids.GuidCNames gcn = guids.addNewGuidCNames();
gcn.setGuidCName(temp);
gcn.setUsage(UsageTypes.ALWAYS_CONSUMED);
}
}
}
it = mi.hashrequiredr9libs.iterator();
while (it.hasNext()) {
if ((temp = it.next()) != null && !temp.matches("%") && !temp.matches("n/a")) {
LibraryClassDocument.LibraryClass lc = libclassdefs.addNewLibraryClass();
lc.setKeyword(temp);
lc.setUsage(UsageTypes.ALWAYS_CONSUMED);
}
}
return msadoc;
}
public void flush() throws Exception {
XmlOptions options = new XmlOptions();
options.setCharacterEncoding("UTF-8");
options.setSavePrettyPrint();
options.setSavePrettyPrintIndent(2);
options.setUseDefaultNamespace();
BufferedWriter bw = new BufferedWriter(new FileWriter(MigrationTool.ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename + File.separator + mi.modulename + ".msa"));
fulfillMsadoc().save(bw, options);
//MsaTreeEditor.init(mi, ui, msadoc);
bw.flush();
bw.close();
}
private static void flush(String path, ModuleSurfaceAreaDocument msadoc) throws Exception {
XmlOptions options = new XmlOptions();
options.setCharacterEncoding("UTF-8");
options.setSavePrettyPrint();
options.setSavePrettyPrintIndent(2);
options.setUseDefaultNamespace();
BufferedWriter bw = new BufferedWriter(new FileWriter(path));
msadoc.save(bw, options);
bw.flush();
bw.close();
}
public static final void parse(String msafile) throws Exception {
ModuleSurfaceAreaDocument msadoc = ModuleSurfaceAreaDocument.Factory.parse(msafile);
flush("c:\\temp.msa", msadoc);
}
}

50
Tools/Java/Source/MigrationTools/org/tianocore/migration/PathIterator.java Normal file
View File

@ -0,0 +1,50 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.File;
import java.util.*;
public final class PathIterator implements Common.ForDoAll {
// this PathIterator is based on HashSet, an thread implementation is required.
PathIterator(String path, int md) throws Exception {
startpath = path;
mode = md;
Common.toDoAll(startpath, this, mode);
it = pathlist.iterator();
}
private String startpath = null;
private int mode;
private HashSet<String> pathlist = new HashSet<String>();
private Iterator<String> it = null;
public final void run(String path) throws Exception {
pathlist.add(path);
}
public boolean filter(File dir) {
return true;
}
public final String next() {
return it.next();
}
public final boolean hasNext() {
return it.hasNext();
}
public final String toString() {
return pathlist.toString();
}
}

433
Tools/Java/Source/MigrationTools/org/tianocore/migration/SourceFileReplacer.java Normal file
View File

@ -0,0 +1,433 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class SourceFileReplacer implements Common.ForDoAll {
private static final SourceFileReplacer SFReplacer = new SourceFileReplacer();
private ModuleInfo mi;
private static final Set<Common.Laplace> Laplaces = new HashSet<Common.Laplace>();
// these sets are used only for printing log of the changes in current file
private static final Set<r8tor9> filefunc = new HashSet<r8tor9>();
private static final Set<r8tor9> filemacro = new HashSet<r8tor9>();
private static final Set<r8tor9> fileguid = new HashSet<r8tor9>();
private static final Set<r8tor9> fileppi = new HashSet<r8tor9>();
private static final Set<r8tor9> fileprotocol = new HashSet<r8tor9>();
private static final Set<String> filer8only = new HashSet<String>();
private static final String[] specialhoblibfunc = {
"BuildModuleHob",
"BuildResourceDescriptorHob",
"BuildFvHob",
"BuildCpuHob",
"BuildGuidDataHob",
"BuildStackHob",
"BuildBspStoreHob",
"BuildMemoryAllocationHob"
};
private static final String[] peiserviceslibfunc = {
"InstallPpi",
"ReInstallPpi",
"LocatePpi",
"NotifyPpi",
"GetBootMode",
"SetBootMode",
"GetHobList",
"CreateHob",
"FfsFindNextVolume",
"FfsFindNextFile",
"FfsFindSectionData",
"InstallPeiMemory",
"AllocatePages",
"AllocatePool",
"PeiResetSystem"
};
//---------------------------------------inner classes---------------------------------------//
private static class r8tor9 {
r8tor9(String r8, String r9) {
r8thing = r8;
r9thing = r9;
}
public String r8thing;
public String r9thing;
}
private class IdleLaplace extends Common.Laplace {
public String operation(String wholeline) {
return replaceLibrary (wholeline, mi.hashmacro);
}
public boolean recognize(String filename) {
return filename.contains(".h") || filename.contains(".H") || filename.contains(".uni");
}
public String namechange(String oldname) {
if (oldname.contains(".H")) {
return oldname.replaceFirst(".H", ".h");
} else {
return oldname;
}
}
}
private class DxsLaplace extends Common.Laplace {
public String operation(String wholeline) {
if (mi.getModuleType().equals("PEIM")) {
return addincludefile(wholeline, "\\<PeimDepex.h\\>");
} else {
return addincludefile(wholeline, "\\<DxeDepex.h\\>");
}
}
public boolean recognize(String filename) {
return filename.contains(".dxs");
}
public String namechange(String oldname) {
return oldname;
}
}
private class CLaplace extends Common.Laplace {
public String operation(String wholeline) {
// remove EFI_DRIVER_ENTRY_POINT
wholeline = wholeline.replaceAll("(EFI_[A-Z]+_ENTRY_POINT\\s*\\(\\s*" + mi.entrypoint + "\\s*\\)\\s*;)", MigrationTool.MIGRATIONCOMMENT + " $1");
// redefine module entry point for some self-relocated modules
wholeline = wholeline.replaceAll (mi.entrypoint + "([^{]*?})", "_ModuleEntryPoint" + "$1");
// remove R8 library contractor
wholeline = wholeline.replaceAll ("(\\b(?:Efi|Dxe)InitializeDriverLib\\b)", MigrationTool.MIGRATIONCOMMENT + " $1");
// Add Library Class for potential reference of gBS, gRT & gDS.
if (Common.find (wholeline, "\\bg?BS\\b")) {
mi.hashrequiredr9libs.add("UefiBootServicesTableLib");
}
if (Common.find (wholeline, "\\bg?RT\\b")) {
mi.hashrequiredr9libs.add ("UefiRuntimeServicesTableLib");
}
if (Common.find (wholeline, "\\bgDS\\b")) {
mi.hashrequiredr9libs.add ("DxeServicesTableLib");
}
wholeline = replaceLibrary (wholeline, mi.hashnonlocalfunc);
wholeline = replaceLibrary (wholeline, mi.hashmacro);
// Converting macro
wholeline = replaceMacro (wholeline, mi.hashnonlocalmacro);
// Converting guid
replaceGuid(wholeline, mi.guids, "guid", fileguid);
replaceGuid(wholeline, mi.ppis, "ppi", fileppi);
replaceGuid(wholeline, mi.protocols, "protocol", fileprotocol);
// Converting Pei
if (mi.getModuleType().matches("PEIM")) {
//
// Try to remove PeiServicesTablePointer;
//
wholeline = dropPeiServicesPointer (wholeline);
//
// Drop the possible return Status of Hob building function.
//
wholeline = drophobLibReturnStatus (wholeline);
}
//
// Expand obsolete R8 macro.
//
wholeline = replaceObsoleteMacro (wholeline);
show(filefunc, "function");
show(filemacro, "macro");
show(fileguid, "guid");
show(fileppi, "ppi");
show(fileprotocol, "protocol");
if (!filer8only.isEmpty()) {
MigrationTool.ui.println("Converting r8only : " + filer8only);
}
filefunc.clear();
filemacro.clear();
fileguid.clear();
fileppi.clear();
fileprotocol.clear();
filer8only.clear();
return wholeline;
}
public boolean recognize(String filename) {
return filename.contains(".c") || filename.contains(".C");
}
public String namechange(String oldname) {
if (oldname.contains(".C")) {
return oldname.replaceFirst(".C", ".c");
} else {
return oldname;
}
}
}
//---------------------------------------inner classes---------------------------------------//
//-------------------------------------process functions-------------------------------------//
private static final String addincludefile(String wholeline, String hfile) {
return wholeline.replaceFirst("(\\*/\\s)", "$1\n#include " + hfile + "\n");
}
private static final void show(Set<r8tor9> hash, String sh) {
Iterator<r8tor9> it = hash.iterator();
r8tor9 temp;
if (!hash.isEmpty()) {
MigrationTool.ui.print("Converting " + sh + " : ");
while (it.hasNext()) {
temp = it.next();
MigrationTool.ui.print("[" + temp.r8thing + "->" + temp.r9thing + "] ");
}
MigrationTool.ui.println("");
}
}
private static final void replaceGuid(String line, Set<String> hash, String kind, Set<r8tor9> filehash) {
Iterator<String> it;
String r8thing;
String r9thing;
it = hash.iterator();
while (it.hasNext()) {
r8thing = it.next();
if ((r9thing = MigrationTool.db.getR9Guidname(r8thing)) != null) {
if (!r8thing.equals(r9thing)) {
if (line.contains(r8thing)) {
line = line.replaceAll(r8thing, r9thing);
filehash.add(new r8tor9(r8thing, r9thing));
}
}
}
}
}
private final String dropPeiServicesPointer (String wholeline) {
String peiServicesTablePointer;
String peiServicesTableCaller;
String regPeiServices;
Pattern ptnPei;
Matcher mtrPei;
peiServicesTablePointer = "\\w(?:\\w|[0-9]|->)*";
peiServicesTableCaller = "\\(\\*\\*?\\s*(" + peiServicesTablePointer + ")\\s*\\)[.-]>?\\s*";
for (int i = 0; i < peiserviceslibfunc.length; i++) {
regPeiServices = peiServicesTableCaller + peiserviceslibfunc[i] + "\\s*\\(\\s*\\1\\s*,(\\t| )*";
ptnPei = Pattern.compile (regPeiServices);
mtrPei = ptnPei.matcher (wholeline);
if (mtrPei.find()) {
wholeline = mtrPei.replaceAll("PeiServices" + peiserviceslibfunc[i] + " (");
mi.hashrequiredr9libs.add("PeiServicesLib");
}
}
regPeiServices = peiServicesTableCaller + "(CopyMem|SetMem)" + "\\s*\\((\\t| )*";
ptnPei = Pattern.compile (regPeiServices);
mtrPei = ptnPei.matcher (wholeline);
if (mtrPei.find()) {
wholeline = mtrPei.replaceAll("$2 (");
mi.hashrequiredr9libs.add("BaseMemoryLib");
}
ptnPei = Pattern.compile("#%+(\\s*\\(+\\s*)" + peiServicesTablePointer + "\\s*,\\s*", Pattern.MULTILINE);
mtrPei = ptnPei.matcher(wholeline);
while (mtrPei.find()) {
wholeline = mtrPei.replaceAll("$1");
}
return wholeline;
}
private final String drophobLibReturnStatus (String wholeline) { // or use regex to find pattern "Status = ..."
Pattern ptnhobstatus;
Matcher mtrhobstatus;
String templine = wholeline;
for (int i = 0; i < specialhoblibfunc.length; i++) {
ptnhobstatus = Pattern.compile("(Status\\s*=\\s*)?" + specialhoblibfunc[i] + "(.*?\\)\\s*;)", Pattern.DOTALL);
mtrhobstatus = ptnhobstatus.matcher(templine);
if (mtrhobstatus.find()) {
templine = mtrhobstatus.replaceAll(specialhoblibfunc[i] + mtrhobstatus.group(2) + "\n " +
MigrationTool.MIGRATIONCOMMENT + "R9 Hob-building library functions will assert if build failure.\n Status = EFI_SUCCESS;");
}
}
return templine;
}
private final String replaceMacro (String wholeline, Set<String> symbolSet) {
String r8thing;
String r9thing;
Iterator<String> it;
it = symbolSet.iterator();
while (it.hasNext()) { //macros are all assumed MdePkg currently
r8thing = it.next();
//mi.hashrequiredr9libs.add(MigrationTool.db.getR9Lib(r8thing));
if ((r9thing = MigrationTool.db.getR9Macro(r8thing)) != null) {
if (wholeline.contains(r8thing)) {
wholeline = wholeline.replaceAll(r8thing, r9thing);
filemacro.add(new r8tor9(r8thing, r9thing));
}
}
}
return wholeline;
}
private final String replaceLibrary (String wholeline, Set<String> symbolSet) {
boolean addr8 = false;
// start replacing names
String r8thing;
String r9thing;
Iterator<String> it;
// Converting non-locla function
it = symbolSet.iterator();
while (it.hasNext()) {
r8thing = it.next();
mi.hashrequiredr9libs.add(MigrationTool.db.getR9Lib(r8thing)); // add a library here
r8tor9 temp;
if ((r9thing = MigrationTool.db.getR9Func(r8thing)) != null) {
if (!r8thing.equals(r9thing)) {
if (wholeline.contains(r8thing)) {
wholeline = wholeline.replaceAll(r8thing, r9thing);
filefunc.add(new r8tor9(r8thing, r9thing));
Iterator<r8tor9> rt = filefunc.iterator();
while (rt.hasNext()) {
temp = rt.next();
if (MigrationTool.db.r8only.contains(temp.r8thing)) {
filer8only.add(r8thing);
mi.hashr8only.add(r8thing);
addr8 = true;
}
}
}
}
}
} //is any of the guids changed?
if (addr8 == true) {
wholeline = addincludefile(wholeline, "\"R8Lib.h\"");
}
return wholeline;
}
private final String replaceObsoleteMacro (String wholeline) {
Matcher mtrmac;
mtrmac = Pattern.compile("EFI_IDIV_ROUND\\((.*), (.*)\\)").matcher(wholeline);
if (mtrmac.find()) {
wholeline = mtrmac.replaceAll("\\($1 \\/ $2 \\+ \\(\\(\\(2 \\* \\($1 \\% $2\\)\\) \\< $2\\) \\? 0 \\: 1\\)\\)");
}
mtrmac = Pattern.compile("EFI_MIN\\((.*), (.*)\\)").matcher(wholeline);
if (mtrmac.find()) {
wholeline = mtrmac.replaceAll("\\(\\($1 \\< $2\\) \\? $1 \\: $2\\)");
}
mtrmac = Pattern.compile("EFI_MAX\\((.*), (.*)\\)").matcher(wholeline);
if (mtrmac.find()) {
wholeline = mtrmac.replaceAll("\\(\\($1 \\> $2\\) \\? $1 \\: $2\\)");
}
mtrmac = Pattern.compile("EFI_UINTN_ALIGNED\\((.*)\\)").matcher(wholeline);
if (mtrmac.find()) {
wholeline = mtrmac.replaceAll("\\(\\(\\(UINTN\\) $1\\) \\& \\(sizeof \\(UINTN\\) \\- 1\\)\\)");
}
if (wholeline.contains("EFI_UINTN_ALIGN_MASK")) {
wholeline = wholeline.replaceAll("EFI_UINTN_ALIGN_MASK", "(sizeof (UINTN) - 1)");
}
return wholeline;
}
private final void addr8only() throws Exception {
String paragraph = null;
String line = Common.file2string(MigrationTool.db.DatabasePath + File.separator + "R8Lib.c");
PrintWriter outfile1 = new PrintWriter(new BufferedWriter(new FileWriter(MigrationTool.ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename + File.separator + "R8Lib.c")));
PrintWriter outfile2 = new PrintWriter(new BufferedWriter(new FileWriter(MigrationTool.ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename + File.separator + "R8Lib.h")));
Pattern ptnr8only = Pattern.compile("////#?(\\w*)?(.*?R8_(\\w*).*?)////~", Pattern.DOTALL);
Matcher mtrr8only = ptnr8only.matcher(line);
Matcher mtrr8onlyhead;
//add head comment
Matcher mtrr8onlyheadcomment = Critic.PTN_NEW_HEAD_COMMENT.matcher(line);
if (mtrr8onlyheadcomment.find()) {
outfile1.append(mtrr8onlyheadcomment.group() + "\n\n");
outfile2.append(mtrr8onlyheadcomment.group() + "\n\n");
}
//add functions body
while (mtrr8only.find()) {
if (mi.hashr8only.contains(mtrr8only.group(3))) {
paragraph = mtrr8only.group(2);
outfile1.append(paragraph + "\n\n");
if (mtrr8only.group(1).length() != 0) {
mi.hashrequiredr9libs.add(mtrr8only.group(1));
}
//generate R8lib.h
while ((mtrr8onlyhead = Func.ptnbrace.matcher(paragraph)).find()) {
paragraph = mtrr8onlyhead.replaceAll(";");
}
outfile2.append(paragraph + "\n\n");
}
}
outfile1.flush();
outfile1.close();
outfile2.flush();
outfile2.close();
mi.localmodulesources.add("R8Lib.h");
mi.localmodulesources.add("R8Lib.c");
}
//-------------------------------------process functions-------------------------------------//
//-----------------------------------ForDoAll-----------------------------------//
public void run(String filepath) throws Exception {
String inname = filepath.replace(mi.temppath + File.separator, "");
String tempinpath = mi.temppath + File.separator;
String tempoutpath = MigrationTool.ModuleInfoMap.get(mi) + File.separator + "Migration_" + mi.modulename + File.separator;
Iterator<Common.Laplace> itLaplace = Laplaces.iterator();
while (itLaplace.hasNext()) {
Common.Laplace lap = itLaplace.next();
if (lap.recognize(inname)) {
MigrationTool.ui.println("\nHandling file: " + inname);
lap.transform(tempinpath + inname, tempoutpath + lap.namechange(inname));
}
}
}
public boolean filter(File dir) {
return true;
}
//-----------------------------------ForDoAll-----------------------------------//
private final void setModuleInfo(ModuleInfo moduleinfo) {
mi = moduleinfo;
}
private final void start() throws Exception {
Laplaces.add(new DxsLaplace());
Laplaces.add(new CLaplace());
Laplaces.add(new IdleLaplace());
Common.toDoAll(mi.temppath, this, Common.FILE);
if (!mi.hashr8only.isEmpty()) {
addr8only();
}
Laplaces.clear();
}
public static final void fireAt(ModuleInfo moduleinfo) throws Exception {
SFReplacer.setModuleInfo(moduleinfo);
SFReplacer.start();
}
}

32
Tools/Java/Source/MigrationTools/org/tianocore/migration/UI.java Normal file
View File

@ -0,0 +1,32 @@
/** @file
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
package org.tianocore.migration;
import java.util.*;
public interface UI {
public boolean yesOrNo(String question);
public void print(String message);
public void println(String message);
public void println(Set<String> hash);
public String choose(String message, Object[] choicelist);
public String getInput(String message);
public String getFilepath(String title, int mode); // necessary ?
}