--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/testdev/ite/src/com.nokia.testfw.codegen.ui/src/com/nokia/testfw/codegen/ui/parser/Parser.java Tue Mar 30 14:39:29 2010 +0800
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+package com.nokia.testfw.codegen.ui.parser;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.cdt.core.model.CModelException;
+import org.eclipse.cdt.core.model.CoreModel;
+import org.eclipse.cdt.core.model.ICElement;
+import org.eclipse.cdt.core.model.ICProject;
+import org.eclipse.cdt.core.model.IMethodDeclaration;
+import org.eclipse.cdt.core.model.IStructure;
+import org.eclipse.cdt.core.model.ITranslationUnit;
+import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
+
+import com.nokia.testfw.codegen.ui.CodegenUIPlugin;
+import com.nokia.testfw.codegen.ui.parser.model.UIClassNode;
+import com.nokia.testfw.codegen.ui.parser.model.UIMethodNode;
+import com.nokia.testfw.codegen.ui.parser.model.UIProjectNode;
+
+public class Parser {
+
+ public static int PUBLIC = 1;
+ public static int PROTECTED = 2;
+ public static int PRIVATE = 4;
+ public static int FRIEND = 8;
+
+ public static UIProjectNode parseProject(IProject aProject,
+ String lTemplateName, int accessVisibility) {
+ UIProjectNode lProjectNode = null;
+
+ try {
+ Set<String> testFolders = ProjectInfoHelper.getTestFolders(
+ aProject, lTemplateName);
+
+ ICProject lCProject = CoreModel.getDefault().create(aProject);
+ lProjectNode = new UIProjectNode(lCProject);
+
+ List<ITranslationUnit> headers = new ArrayList<ITranslationUnit>();
+ lCProject.accept(new TranslationUnitCollector(null, headers,
+ new NullProgressMonitor()));
+ for (ITranslationUnit header : headers) {
+ if (!matchTestFolder(header.getResource()
+ .getProjectRelativePath().toString(), testFolders)) {
+ parseTranslationUnit(header, lProjectNode, accessVisibility);
+ }
+ }
+
+ collectBuildInfo(aProject, lProjectNode);
+ } catch (CoreException lCoreException) {
+ IStatus lStatus = new Status(IStatus.ERROR, Parser.class.getName(),
+ IStatus.ERROR, "Core exception while parsing project",
+ lCoreException);
+ CodegenUIPlugin.getDefault().getLog().log(lStatus);
+ }
+ return lProjectNode;
+ }
+
+ private static boolean matchTestFolder(final String path,
+ final Set<String> testFolders) {
+ for (String testfolder : testFolders) {
+ if (path.startsWith(testfolder)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static void collectBuildInfo(IProject aProject,
+ UIProjectNode aProjectNode) {
+ Map<String, Set<String>> lBuildInfoMap = ProjectInfoHelper
+ .getBuildInfoMap(aProject);
+ aProjectNode.setUserIncludes(lBuildInfoMap
+ .get(ProjectInfoHelper.USERINCLUDE));
+ aProjectNode.setSystemIncludes(lBuildInfoMap
+ .get(ProjectInfoHelper.SYSTEMINCLUDE));
+ aProjectNode.setLibrarys(lBuildInfoMap.get(ProjectInfoHelper.LIBRARY));
+ }
+
+ private static void parseTranslationUnit(final ITranslationUnit tu,
+ UIProjectNode aProjectNode, int accessVisibility)
+ throws CModelException {
+ if (tu != null) {
+ ICElement[] elements = tu.getChildren();
+ for (ICElement element : elements) {
+ if (element instanceof IStructure) {
+ UIClassNode lClassNode = parseClass((IStructure) element,
+ aProjectNode, accessVisibility);
+ if (lClassNode.getChildren().size() > 0) {
+ aProjectNode.addChild(lClassNode);
+ }
+ }
+ }
+ }
+ }
+
+ public static UIProjectNode parseTranslationUnit(ITranslationUnit[] tus,
+ int accessVisibility) throws CModelException {
+ UIProjectNode lProjectNode = new UIProjectNode(tus[0].getCProject());
+ for (ITranslationUnit tu : tus) {
+ parseTranslationUnit(tu, lProjectNode, accessVisibility);
+ }
+ collectBuildInfo(tus[0].getCProject().getProject(), lProjectNode);
+ return lProjectNode;
+ }
+
+ public static UIProjectNode parseTranslationUnit(ITranslationUnit tu,
+ int accessVisibility) throws CModelException {
+ UIProjectNode lProjectNode = new UIProjectNode(tu.getCProject());
+ parseTranslationUnit(tu, lProjectNode, accessVisibility);
+ return lProjectNode;
+ }
+
+ private static UIClassNode parseClass(IStructure classDec,
+ UIProjectNode parent, int accessVisibility) throws CModelException {
+ UIClassNode lClassNode = new UIClassNode(classDec, parent);
+ lClassNode.setDeclLocation(classDec.getTranslationUnit().getLocation()
+ .toOSString());
+ IMethodDeclaration[] lMethodsList = classDec.getMethods();
+ for (IMethodDeclaration lMethod : lMethodsList) {
+ if (lMethod.getVisibility() == ASTAccessVisibility.PUBLIC) {
+ if ((accessVisibility & PUBLIC) == 0) {
+ continue;
+ }
+ } else if (lMethod.getVisibility() == ASTAccessVisibility.PROTECTED) {
+ if ((accessVisibility & PROTECTED) == 0) {
+ continue;
+ }
+ } else if (lMethod.getVisibility() == ASTAccessVisibility.PRIVATE) {
+ if ((accessVisibility & PRIVATE) == 0) {
+ continue;
+ }
+ }
+ if (lMethod.isFriend()) {
+ if ((accessVisibility & FRIEND) == 0) {
+ continue;
+ }
+ }
+ UIMethodNode lMethodItem = parseMethod(lMethod, lClassNode);
+ lClassNode.addChild(lMethodItem);
+ }
+ if (lClassNode.getChildren().size() > 0) {
+ parent.addChild(lClassNode);
+ }
+ return lClassNode;
+ }
+
+ public static UIProjectNode parseClass(IStructure[] classDecs,
+ int accessVisibility) throws CModelException {
+ UIProjectNode lProjectNode = new UIProjectNode(classDecs[0]
+ .getCProject());
+ for (IStructure classDec : classDecs) {
+ parseClass(classDec, lProjectNode, accessVisibility);
+ }
+ collectBuildInfo(classDecs[0].getCProject().getProject(), lProjectNode);
+ return lProjectNode;
+ }
+
+ private static UIMethodNode parseMethod(IMethodDeclaration methodDec,
+ UIClassNode parent) throws CModelException {
+ UIMethodNode lMethodNode = new UIMethodNode(methodDec, parent);
+
+ if (methodDec.getVisibility() == ASTAccessVisibility.PUBLIC) {
+ lMethodNode.setVisibility(0);
+ } else if (methodDec.getVisibility() == ASTAccessVisibility.PROTECTED) {
+ lMethodNode.setVisibility(1);
+ } else {// private
+ lMethodNode.setVisibility(2);
+ }
+ lMethodNode.setConstructor(methodDec.isConstructor());
+ lMethodNode.setDestructor(methodDec.isDestructor());
+ lMethodNode.setInline(methodDec.isInline());
+ lMethodNode.setOperator(methodDec.isOperator());
+ lMethodNode.setPureVirtual(methodDec.isPureVirtual());
+ lMethodNode.setStatic(methodDec.isStatic());
+ lMethodNode.setVirtual(methodDec.isVirtual());
+ lMethodNode.setConst(methodDec.isConst());
+
+ String[] lParameterTypes = methodDec.getParameterTypes();
+
+ for (int i = 0; i < lParameterTypes.length; i++) {
+ String type = lParameterTypes[i];
+ if ("TRequestStatus&".equals(type)) {
+ lMethodNode.setAsync(true);
+ }
+ type = type.split("=")[0];
+ lMethodNode.addParameters(type, "aParam" + (i + 1));
+ }
+ return lMethodNode;
+ }
+
+ public static UIProjectNode parseMethod(IMethodDeclaration[] methodDecs)
+ throws CModelException {
+ UIProjectNode lProjectNode = new UIProjectNode(methodDecs[0]
+ .getCProject());
+ Map<IStructure, UIClassNode> classDecMap = new HashMap<IStructure, UIClassNode>();
+ for (IMethodDeclaration methodDec : methodDecs) {
+ IStructure classDec = (IStructure) methodDec.getParent();
+ UIClassNode lClassNode = (UIClassNode) classDecMap.get(classDec);
+ if (lClassNode == null) {
+ lClassNode = new UIClassNode(classDec, lProjectNode);
+ lClassNode.setDeclLocation(classDec.getTranslationUnit()
+ .getLocation().toOSString());
+ lProjectNode.addChild(lClassNode);
+ classDecMap.put(classDec, lClassNode);
+ }
+ UIMethodNode lMethodItem = parseMethod(methodDec, lClassNode);
+ lClassNode.addChild(lMethodItem);
+ }
+ collectBuildInfo(methodDecs[0].getCProject().getProject(), lProjectNode);
+ return lProjectNode;
+ }
+}