+ * Tries to match the rules to the given sequence to generate an
+ * {@link WindowsEvent}.
+ *
+ *
+ * The rules are matched the order, in which they are defined in the XML
+ * file. Therefore, the order of the rules in the file defines priorities,
+ * when multiple rules could be matched to the same sequence.
+ *
+ *
+ * @param sequence
+ * sequence of message for which an event will be generated
+ * @return event that matches the messages; null, if no rule can be matched
+ */
+ @SuppressWarnings("unchecked")
+ public Event generateEvent(List sequence) {
+ Document rulesDoc = getDocument(rulesFile);
+ Element rulesRoot = rulesDoc.getRootElement();
+
+ List ruleElements = rulesRoot.getChildren("rule",
+ rulesNamespace);
+
+ boolean isMatch = false;
+
+ for (int ruleIndex = 0; ruleIndex < ruleElements.size() && !isMatch; ruleIndex++) {
+ Element currentRule = ruleElements.get(ruleIndex);
+ currentRuleName = currentRule.getAttributeValue("name");
+ currentType = new MFCEventType(currentRuleName);
+ currentToken = new Event(currentType);
+
+ isMatch = true;
+ messageStorage = new HashMap();
+ sequenceIterator = sequence.listIterator();
+ List ruleChildrenMsg = currentRule.getChildren("msg",
+ rulesNamespace);
+
+ int i = 0;
+ while (isMatch && i < ruleChildrenMsg.size()) {
+ Element messageElement = ruleChildrenMsg.get(i);
+ if ("true".equals(messageElement.getAttributeValue("multiple"))) {
+ Element nextMessageElement = null;
+ if (i + 1 < ruleChildrenMsg.size()) {
+ nextMessageElement = ruleChildrenMsg.get(i + 1);
+ }
+ try {
+ isMatch = matchMultipleMessages(messageElement,
+ nextMessageElement);
+ } catch (InvalidParameterException e) {
+ Console.printerrln(e.getMessage());
+ }
+ } else {
+ try {
+ isMatch = matchSingleMessage(messageElement);
+ } catch (InvalidParameterException e) {
+ Console.printerrln(e.getMessage());
+ }
+ }
+ i++;
+ }
+ if (isMatch) {
+ List ruleChildren = currentRule.getChildren();
+ for (Element genMsgElement : ruleChildren) {
+ if (genMsgElement.getName().equals("genMsg")) {
+ try {
+ generateReplayMessage(genMsgElement);
+ } catch (InvalidParameterException e) {
+ Console.printerrln(e.getMessage());
+ // TODO currentToken.invalidateReplay();
+ }
+ } else if (genMsgElement.getName().equals("genMsgSeq")) {
+ try {
+ generateReplaySequence(genMsgElement);
+ // TODO currentToken.invalidateReplay();
+ } catch (InvalidParameterException e) {
+ Console.printerrln(e.getMessage());
+ // TODO currentToken.invalidateReplay();
+ }
+ }
+ }
+ Element idinfoElement = currentRule.getChild("idinfo",
+ rulesNamespace);
+ if (idinfoElement != null) {
+ // cannot be empty if document is valid
+ List valueElements = idinfoElement.getChildren();
+ currentType.setInfo(getTermValue(null,
+ valueElements.get(0)));
+ }
+ Console.traceln(currentToken.getType().toString() + " matched");
+ } else {
+ currentToken = null;
+ }
+ }
+ if (!isMatch) {
+ Console.traceln("no match found for sequence: "
+ + sequence.toString());
+ }
+ return currentToken;
+ }
+
+ // ////////////////////////////////////////////////////////////
+ // Helper functions for matching of events, i.e., msg-nodes //
+ // ////////////////////////////////////////////////////////////
+
+ /**
+ *
+ * Handles msg-nodes where multiple is not true, i.e., not a sequences.
+ *
+ *
+ * @param messageElement
+ * {@link Element} representing the msg-node
+ * @return true, if a match is found; false otherwise
+ */
+ private boolean matchSingleMessage(Element messageElement) {
+ boolean isMatch = false;
+ WindowsMessage currentMessage = null;
+
+ int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+
+ while (!isMatch && sequenceIterator.hasNext()) {
+ /*
+ * traverses the messages from the current position forward till a
+ * message with the correct type is found
+ */
+ currentMessage = sequenceIterator.next();
+ if (type == currentMessage.getType()) {
+ // message with the correct type found
+ // eval child nodes for further matching/storing
+ isMatch = evalEqualRestrictions(currentMessage, messageElement);
+
+ // in case the message is a match, eval storage children
+ if (isMatch) {
+ handleStorage(messageElement, currentMessage);
+ currentToken.setTarget(new MFCEventTarget(currentMessage
+ .getXmlWindowDescription()));
+ // TODO currentToken.setTargetShort(currentMessage.getParentNames());
+ }
+ }
+ }
+
+ return isMatch;
+ }
+
+ /**
+ *
+ * Handles msg-nodes where multiple is true, i.e., sequences. Requires
+ * knowledge about the next msg-node to determine the end of the sequence.
+ *
+ *
+ * @param messageElement
+ * {@link Element} representing the msg-node
+ * @param nextMessageElement
+ * {@link Element} representing the next msg-node; {@code null}
+ * if the current node is the last one
+ * @return true, if a sequence is matched; false otherwise
+ */
+ private boolean matchMultipleMessages(Element messageElement,
+ Element nextMessageElement) {
+ boolean isMatch = false;
+ boolean isCurrentMatch = false;
+ boolean nextMatchFound = false;
+ WindowsMessage currentMessage = null;
+ WindowsMessage nextMessage = null;
+
+ int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+
+ int nextType = -1;
+ if (nextMessageElement != null) {
+ nextType = Integer.parseInt(nextMessageElement
+ .getAttributeValue("type"));
+ }
+
+ while (!nextMatchFound && sequenceIterator.hasNext()) {
+ currentMessage = sequenceIterator.next();
+ if (type == currentMessage.getType()) {
+ isCurrentMatch = evalEqualRestrictions(currentMessage,
+ messageElement);
+ isMatch = isMatch || isCurrentMatch;
+
+ if (isCurrentMatch) {
+ handleStorage(messageElement, currentMessage);
+ currentToken.setTarget(new MFCEventTarget(currentMessage
+ .getXmlWindowDescription()));
+ // TODO currentToken.setTargetShort(currentMessage.getParentNames());
+ }
+ }
+ if (nextMessageElement != null && isMatch) {
+ // peek next message to check if the sequence ends and the next
+ // match is found
+ if (!sequenceIterator.hasNext()) {
+ return false; // sequence is over, but not all messages are
+ // found
+ }
+ nextMessage = sequenceIterator.next();
+ sequenceIterator.previous();
+
+ if (nextType == nextMessage.getType()) {
+ nextMatchFound = evalEqualRestrictions(nextMessage,
+ nextMessageElement);
+ }
+
+ }
+ }
+
+ return isMatch;
+ }
+
+ /**
+ *
+ * Handles equals-nodes.
+ *
+ *
+ * @param currentMessage
+ * {@link Element} representing the msg-node the equals-node
+ * belongs to
+ * @param messageElement
+ * {@link Element} representing the equals-node to be evaluated
+ * @return true, if constraint is fulfilled; false otherwise
+ */
+ @SuppressWarnings("unchecked")
+ private boolean evalEqualRestrictions(WindowsMessage currentMessage,
+ Element messageElement) {
+ boolean isMatch = true;
+ for (Element childElement : (List) messageElement.getChildren(
+ "equals", rulesNamespace)) {
+ List termElements = childElement.getChildren();
+ // the size 2 of termElements is guaranteed by the XML schema
+ String value1 = getTermValue(currentMessage, termElements.get(0));
+ String value2 = getTermValue(currentMessage, termElements.get(1));
+ if (value1 == null || value2 == null) {
+ isMatch = false;
+ } else {
+ isMatch = isMatch && value1.equals(value2);
+ }
+ }
+ for (Element childElement : (List) messageElement.getChildren(
+ "equalsSeq", rulesNamespace)) {
+ List termElements = childElement.getChildren();
+ List values1 = getTermValueSeq(termElements.get(0));
+ List values2 = getTermValueSeq(termElements.get(0));
+ if (values1 == null || values2 == null) {
+ isMatch = false;
+ } else {
+ isMatch = isMatch && values1.equals(values2);
+ }
+ }
+ return isMatch;
+ }
+
+ /**
+ *
+ * Handles store-nodes and storeSeq-nodes.
+ *
+ *
+ * @param messageElement
+ * {@link Element} representing the msg-node that is currently
+ * being evaluated
+ * @param currentMessage
+ * current message in the message sequence that is matched; this
+ * is the message that is stored
+ */
+ @SuppressWarnings("unchecked")
+ private void handleStorage(Element messageElement,
+ WindowsMessage currentMessage) {
+ for (Element childElement : (List) messageElement.getChildren(
+ "store", rulesNamespace)) {
+ String identifier = childElement.getAttributeValue("var");
+ messageStorage.put(identifier, currentMessage);
+ resolveHwnd(currentMessage, childElement);
+ }
+ for (Element childElement : (List) messageElement.getChildren(
+ "storeSeq", rulesNamespace)) {
+ String identifier = childElement.getAttributeValue("varSeq");
+ Object tmp = messageStorage.get(identifier);
+ List storedSequence;
+ if (tmp == null || tmp instanceof WindowsMessage) {
+ storedSequence = new LinkedList();
+ storedSequence.add(currentMessage);
+ messageStorage.put(identifier, storedSequence);
+ } else if (tmp instanceof List) {
+ storedSequence = (List) tmp;
+ storedSequence.add(currentMessage);
+ messageStorage.put(identifier, storedSequence);
+ }
+ resolveHwnd(currentMessage, childElement);
+ }
+ }
+
+ /**
+ *
+ * Resolves a parameter that contains a HWND of a message to the target
+ * string of the HWND and stores it.
+ *
+ *
+ * @param currentMessage
+ * message whose HWND is resolved
+ * @param childElement
+ * child element of the store node that represents the resolve
+ */
+ @SuppressWarnings("unchecked")
+ private void resolveHwnd(WindowsMessage currentMessage, Element childElement) {
+ List resolveElements = childElement.getChildren("resolveHwnd",
+ rulesNamespace);
+ for (Element resolveElement : resolveElements) {
+ String param = resolveElement.getAttributeValue("param");
+ String storeParam = resolveElement.getAttributeValue("storeParam");
+ int paramHwnd = Integer
+ .parseInt(currentMessage.getParameter(param));
+ WindowTreeNode node = WindowTree.getInstance().find(paramHwnd);
+ if (node != null) {
+ currentMessage.addParameter(storeParam,
+ node.xmlRepresentation());
+ }
+ }
+ }
+
+ // /////////////////////////////////////////////////////
+ // Helper functions for generating the replay, i.e.,
+ // parsing of genMsg und genMsgSeq-nodes
+ // /////////////////////////////////////////////////////
+
+ /**
+ *
+ * Handles genMsg-nodes and adds the replay to the {@link Event} that is
+ * generated.
+ *
+ *
+ * @param genMsgElement
+ * {@link Element} representing the genMsg-node
+ */
+ @SuppressWarnings("unchecked")
+ private void generateReplayMessage(Element genMsgElement) {
+ List genMsgChildren = genMsgElement.getChildren();
+ WindowsMessage generatedMessage = null;
+ if (genMsgChildren.size() == 1) { // replay stored message without
+ // change
+ String obj = genMsgChildren.get(0).getAttributeValue("obj");
+ generatedMessage = getStoredMessageVariable(null, obj);
+ } else { // generate message according to the rule
+ for (Element genMsgChild : genMsgChildren) {
+ Element termElement = (Element) genMsgChild.getChildren()
+ .get(0);
+ if (genMsgChild.getName().equals("type")) {
+ try {
+ int msgType = Integer.parseInt(getTermValue(null,
+ termElement));
+ generatedMessage = new WindowsMessage(msgType);
+ } catch (NumberFormatException e) {
+ throw new InvalidParameterException(
+ "Failure generating replay sequence for rule "
+ + currentRuleName
+ + ": Defined type is not an integer.");
+ }
+ } else if (genMsgChild.getName().equals("target")) {
+ String targetString = getTermValue(null, termElement);
+ generatedMessage.setXmlWindowDescription(targetString);
+ } else if (genMsgChild.getName().equals("LPARAM")) {
+ String paramValueStr = getTermValue(null, termElement);
+ long paramValue = 0;
+ Element loword = genMsgChild.getChild("LOWORD",
+ rulesNamespace);
+ if (loword != null) {
+ paramValue = loHiWord(genMsgChild);
+ generatedMessage.setLPARAM(paramValue);
+ } else {
+ try {
+ paramValue = Integer.parseInt(paramValueStr);
+ generatedMessage.setLPARAM(paramValue);
+ } catch (NumberFormatException e) {
+ generatedMessage
+ .setLPARAMasWindowDesc(paramValueStr);
+ }
+ }
+ } else if (genMsgChild.getName().equals("WPARAM")) {
+ String paramValueStr = getTermValue(null, termElement);
+ long paramValue = 0;
+ Element loword = genMsgChild.getChild("LOWORD",
+ rulesNamespace);
+ if (loword != null) {
+ paramValue = loHiWord(genMsgChild);
+ generatedMessage.setWPARAM(paramValue);
+ } else {
+ try {
+ paramValue = Integer.parseInt(paramValueStr);
+ generatedMessage.setWPARAM(paramValue);
+ } catch (NumberFormatException e) {
+ generatedMessage
+ .setWPARAMasWindowDesc(paramValueStr);
+ }
+ }
+ }
+ }
+ }
+ if (generatedMessage != null) {
+ int delay = Integer.parseInt(genMsgElement
+ .getAttributeValue("delay"));
+ generatedMessage.setDelay(delay);
+ } else {
+ // TODO currentToken.invalidateReplay();
+ }
+ currentToken.addReplayable(generatedMessage);
+ }
+
+ /**
+ * Handles genMsgSeq-nodes and adds the replay to the {@link Event} that is
+ * generated.
+ *
+ * @param genMsgElement
+ * {@link Element} representing the genMsgSeq-node.
+ */
+ @SuppressWarnings("unchecked")
+ private void generateReplaySequence(Element genMsgElement) {
+ List genMsgSeqChildren = genMsgElement.getChildren();
+ List generatedMessageSeq = new LinkedList();
+ if (genMsgSeqChildren.size() == 1) {
+ String obj = genMsgSeqChildren.get(0).getAttributeValue("seqObj");
+ generatedMessageSeq = getStoredSeqVariable(obj);
+ } else {
+ boolean msgsGenerated = false;
+ int constMsgType = 0;
+ for (Element genMsgSeqChild : genMsgSeqChildren) {
+ Element termElement = (Element) genMsgSeqChild.getChildren()
+ .get(0);
+ if (genMsgSeqChild.getName().equals("type")) {
+ // note: cannot easily be extracted because of mulitple
+ // return values
+ if (termElement.getName().equals("seqValue")) {
+ String obj = termElement.getAttributeValue("seqObj");
+ List seqVar = getStoredSeqVariable(obj);
+ for (WindowsMessage msg : seqVar) {
+ generatedMessageSeq.add(new WindowsMessage(msg
+ .getType()));
+ }
+ msgsGenerated = true;
+ } else { // constValue type
+ constMsgType = Integer.parseInt(getTermValue(null,
+ termElement));
+ }
+ } else if (genMsgSeqChild.getName().equals("target")) {
+ msgsGenerated = createSequenceTarget(generatedMessageSeq,
+ msgsGenerated, constMsgType, termElement);
+ } else if (genMsgSeqChild.getName().equals("LPARAM")) {
+ msgsGenerated = createSequenceLParam(generatedMessageSeq,
+ msgsGenerated, constMsgType, termElement);
+ } else if (genMsgSeqChild.getName().equals("WPARAM")) {
+ msgsGenerated = createSequenceWParam(generatedMessageSeq,
+ msgsGenerated, constMsgType, termElement);
+ }
+ }
+ }
+ currentToken.addReplayableSequence(generatedMessageSeq);
+ }
+
+ /**
+ *
+ * Creates the targets for replay sequences generated with genMsgSeq-nodes.
+ *
+ *
+ * @param generatedMessageSeq
+ * list of the messages that is being generated
+ * @param msgsGenerated
+ * boolean stating if the list of messages is already generated
+ * or if the generation has to be handles by this method
+ * @param constMsgType
+ * a constant message type that is used for message generation,
+ * in case the list of message is generated by this method
+ * @param termElement
+ * {@link Element} representing the term-node describing the
+ * target
+ * @return true, if the list of message is generated after calling this
+ * method; false otherwise
+ * @throws NoSuchElementException
+ * thrown if the seqVar referred to in the termElement contains
+ * a different number of messages than is contained in
+ * messageSeq
+ */
+ private boolean createSequenceTarget(
+ List generatedMessageSeq, boolean msgsGenerated,
+ int constMsgType, Element termElement)
+ throws NoSuchElementException {
+ Iterator seqIterator = generatedMessageSeq.iterator();
+ if (termElement.getName().equals("seqValue")) {
+ String obj = termElement.getAttributeValue("seqObj");
+ List seqVar = getStoredSeqVariable(obj);
+ if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+ throw new InvalidParameterException(
+ "Failure generating replay sequence for rule "
+ + currentRuleName
+ + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+ }
+ for (WindowsMessage msg : seqVar) {
+ WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+ generatedMessageSeq, msgsGenerated, constMsgType,
+ seqIterator);
+ String targetString = msg.getParameter(termElement
+ .getAttributeValue("param"));
+ currentSeqMsg.setXmlWindowDescription(targetString);
+ }
+ msgsGenerated = true;
+ } else { // const value
+ throw new AssertionError("target must be a sequence variable!");
+ /*
+ * If target would not be a variable, the message-elements could not
+ * yet be created and the whole sequence might be broken. If this is
+ * to be changed, createSequenceLParam and createSequenceWParam need
+ * to be addepted, too.
+ */
+ }
+ return msgsGenerated;
+ }
+
+ /**
+ *
+ * Creates the LPARAMs for replay sequences generated with genMsgSeq-nodes.
+ *
+ *
+ * @param generatedMessageSeq
+ * list of the messages that is being generated
+ * @param msgsGenerated
+ * boolean stating if the list of messages is already generated
+ * or if the generation has to be handles by this method
+ * @param constMsgType
+ * a constant message type that is used for message generation,
+ * in case the list of message is generated by this method
+ * @param termElement
+ * {@link Element} representing the term-node describing the
+ * LPARAM
+ * @return true, if the list of message is generated after calling this
+ * method; false otherwise
+ * @throws NoSuchElementException
+ * thrown if the seqVar referred to in the termElement contains
+ * a different number of messages than is contained in
+ * messageSeq
+ */
+ private boolean createSequenceLParam(
+ List generatedMessageSeq, boolean msgsGenerated,
+ int constMsgType, Element termElement)
+ throws NoSuchElementException {
+ Iterator seqIterator = generatedMessageSeq.iterator();
+ if (termElement.getName().equals("seqValue")) {
+ String obj = termElement.getAttributeValue("seqObj");
+ List seqVar = getStoredSeqVariable(obj);
+ if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+ throw new InvalidParameterException(
+ "Failure generating replay sequence for rule "
+ + currentRuleName
+ + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+ }
+ for (WindowsMessage msg : seqVar) {
+ WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+ generatedMessageSeq, msgsGenerated, constMsgType,
+ seqIterator);
+ String paramValueStr = msg.getParameter(termElement
+ .getAttributeValue("param"));
+ int paramValue = 0;
+ try {
+ paramValue = Integer.parseInt(paramValueStr);
+ currentSeqMsg.setLPARAM(paramValue);
+ } catch (NumberFormatException e) {
+ currentSeqMsg.setLPARAMasWindowDesc(paramValueStr);
+ }
+ }
+ if (seqIterator.hasNext()) {
+ // the first seq-var has a different number of elements than the
+ // current one
+ throw new NoSuchElementException();
+ }
+ msgsGenerated = true;
+ } else { // const value
+ int paramValue = Integer.parseInt(getTermValue(null, termElement));
+ while (seqIterator.hasNext()) {
+ seqIterator.next().setLPARAM(paramValue);
+ }
+ }
+ return msgsGenerated;
+ }
+
+ /**
+ *
+ * Creates the WPARAMs for replay sequences generated with genMsgSeq-nodes.
+ *
+ *
+ * @param generatedMessageSeq
+ * list of the messages that is being generated
+ * @param msgsGenerated
+ * boolean stating if the list of messages is already generated
+ * or if the generation has to be handles by this method
+ * @param constMsgType
+ * a constant message type that is used for message generation,
+ * in case the list of message is generated by this method
+ * @param termElement
+ * {@link Element} representing the term-node describing the
+ * WPARAM
+ * @return true, if the list of message is generated after calling this
+ * method; false otherwise
+ * @throws NoSuchElementException
+ * thrown if the seqVar referred to in the termElement contains
+ * a different number of messages than is contained in
+ * messageSeq
+ */
+ private boolean createSequenceWParam(
+ List generatedMessageSeq, boolean msgsGenerated,
+ int constMsgType, Element termElement)
+ throws NoSuchElementException {
+ Iterator seqIterator = generatedMessageSeq.iterator();
+ if (termElement.getName().equals("seqValue")) {
+ String obj = termElement.getAttributeValue("seqObj");
+ List seqVar = getStoredSeqVariable(obj);
+ if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+ throw new InvalidParameterException(
+ "Failure generating replay sequence for rule "
+ + currentRuleName
+ + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+ }
+ for (WindowsMessage msg : seqVar) {
+ WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+ generatedMessageSeq, msgsGenerated, constMsgType,
+ seqIterator);
+ String paramValueStr = msg.getParameter(termElement
+ .getAttributeValue("param"));
+ int paramValue = 0;
+ try {
+ paramValue = Integer.parseInt(paramValueStr);
+ currentSeqMsg.setWPARAM(paramValue);
+ } catch (NumberFormatException e) {
+ currentSeqMsg.setWPARAMasWindowDesc(paramValueStr);
+ }
+ }
+ if (seqIterator.hasNext()) {
+ // the first seq-var has a different number of elements than the
+ // current one
+ throw new NoSuchElementException();
+ }
+ msgsGenerated = true;
+ } else { // const value
+ int paramValue = Integer.parseInt(getTermValue(null, termElement));
+ while (seqIterator.hasNext()) {
+ seqIterator.next().setWPARAM(paramValue);
+ }
+ }
+ return msgsGenerated;
+ }
+
+ /**
+ *
+ * If a message sequence is already generated, i.e., msgsGenerated is true,
+ * the seqIterator is used to iterate through these messages and return the
+ * current one. If the message sequence is not yet generated, i.e.,
+ * msgsGenerated is false, the message sequence is generated on the fly
+ * during each call of this message and the newly generated messages are
+ * returned.
+ *
+ *
+ * @param generatedMessageSeq
+ * message sequence
+ * @param msgsGenerated
+ * indicates if generatedMessageSeq is already generated or has
+ * to be generated on the fly by this method
+ * @param constMsgType
+ * type of the message to be used for message generation
+ * @param seqIterator
+ * iterates through an already generated message sequence; must
+ * not be {@code null}, if msgsGenerated is true
+ * @return current message
+ */
+ private WindowsMessage getCurrentSeqMsg(
+ List generatedMessageSeq, boolean msgsGenerated,
+ int constMsgType, Iterator seqIterator) {
+ WindowsMessage currentSeqMsg = null;
+ if (msgsGenerated) {
+ currentSeqMsg = seqIterator.next();
+ } else {
+ currentSeqMsg = new WindowsMessage(constMsgType);
+ generatedMessageSeq.add(currentSeqMsg);
+ }
+ return currentSeqMsg;
+ }
+
+ // ////////////////////////////
+ // General helper functions //
+ // ////////////////////////////
+
+ /**
+ *
+ * Retrieves a message from the storage for, e.g., comparison or replay.
+ * "this" is used to refer to the current message.
+ *
+ *
+ * @param currentMessage
+ * current message during the parsing; passed to handle "this"
+ * @param obj
+ * object identifier in the storage
+ * @return message retrieved from the storage
+ * @throws InvalidParameterException
+ * thrown in case of invalid uses of "this" or if no message
+ * with the identifier obj is found in the storage
+ */
+ private WindowsMessage getStoredMessageVariable(
+ WindowsMessage currentMessage, String obj)
+ throws InvalidParameterException {
+ WindowsMessage varMessage = null;
+ if (obj.equals("this")) {
+ if (currentMessage == null) {
+ throw new InvalidParameterException(
+ "Failure obtaining term value for rule "
+ + currentRuleName
+ + ": \"this\" is not a valid name for generating runtime messages.");
+ }
+ varMessage = currentMessage;
+ } else {
+ Object tmp = messageStorage.get(obj);
+ if (tmp instanceof WindowsMessage) {
+ varMessage = (WindowsMessage) tmp;
+ } else {
+ throw new InvalidParameterException(
+ "Failure obtaining term value for rule "
+ + currentRuleName + ": No message \"" + obj
+ + "\" stored.");
+ }
+ }
+ return varMessage;
+ }
+
+ /**
+ *
+ * Retrieves a stored message sequence from the storage.
+ *
+ *
+ * @param obj
+ * object identifier in the storage
+ * @return message sequence retrieved from the storage
+ * @throws InvalidParameterException
+ * thrown if no message sequences with the identifier obj is
+ * found in the storage
+ */
+ @SuppressWarnings("unchecked")
+ private List getStoredSeqVariable(String obj)
+ throws InvalidParameterException {
+ List varMsgSeq = null;
+ Object tmp = messageStorage.get(obj);
+ if (tmp instanceof List) {
+ varMsgSeq = (List) tmp;
+ } else {
+ throw new InvalidParameterException(
+ "Failure obtaining term value for rule " + currentRuleName
+ + ": No sequence \"" + obj + "\" store.");
+ }
+ return varMsgSeq;
+ }
+
+ /**
+ *
+ * Handles term-nodes and returns the value of the described term.
+ *
+ *
+ * @param currentMessage
+ * current message during the parsing; required to resolve
+ * references to "this" in a term
+ * @param termElement
+ * {@link Element} representing the term node
+ * @return value of the term or {@code null} of the term node could not be
+ * evaluated
+ */
+ private String getTermValue(WindowsMessage currentMessage,
+ Element termElement) {
+ String value = null;
+ WindowsMessage varMessage = null;
+ if (termElement.getName().equals("constValue")) {
+ value = termElement.getAttributeValue("value");
+ } else if (termElement.getName().equals("paramValue")) {
+ String objectName = termElement.getAttributeValue("obj");
+ varMessage = getStoredMessageVariable(currentMessage, objectName);
+ if (varMessage != null) {
+ String param = termElement.getAttributeValue("param");
+ value = varMessage.getParameter(param);
+ }
+ } else if (termElement.getName().equals("winInfoValue")) {
+ String objectName = termElement.getAttributeValue("obj");
+ varMessage = getStoredMessageVariable(currentMessage, objectName);
+ if (varMessage != null) {
+ String paramString = termElement.getAttributeValue("winParam");
+ if (paramString.equals("class")) {
+ value = varMessage.getWindowClass();
+ } else if (paramString.equals("resourceId")) {
+ value = "" + varMessage.getWindowResourceId();
+ } else if (paramString.equals("hwnd")) {
+ value = "" + varMessage.getHwnd();
+ } else if (paramString.equals("parentTarget")) {
+ String target = varMessage.getXmlWindowDescription();
+ int index = target.lastIndexOf("<");
+ if (index == 0) {
+ Console.traceln("Trying to adress parent of top-level window! Replay probably invalid!");
+ }
+ value = target.substring(0, index);
+ } else if (paramString.equals("parentClass")) {
+ value = varMessage.getParentClass();
+ }
+ }
+ } else if (termElement.getName().equals("msgInfoValue")) {
+ String objectName = termElement.getAttributeValue("obj");
+ varMessage = getStoredMessageVariable(currentMessage, objectName);
+ if (varMessage != null) {
+ String paramString = termElement.getAttributeValue("msgParam");
+ if (paramString.equals("type")) {
+ value = "" + varMessage.getType();
+ } else if (paramString.equals("target")) {
+ value = varMessage.getXmlWindowDescription();
+ }
+ }
+ }
+ return value;
+ }
+
+ /**
+ *
+ * Handles term-nodes contained by equalSeq nodes.
+ *
+ *
+ * @param termElement
+ * {@link Element} representing the term-node
+ * @return list of values of the term
+ */
+ private List getTermValueSeq(Element termElement) {
+ List values = new LinkedList();
+ if (termElement.getName().equals("seqValue")) {
+ String obj = termElement.getAttributeValue("seqObj");
+ String param = termElement.getAttributeValue("param");
+ List seqVar = getStoredSeqVariable(obj);
+
+ for (WindowsMessage msg : seqVar) {
+ // msg.getParameter returns null, if parameter is not found,
+ // therefore the List can contain null-values
+ values.add(msg.getParameter(param));
+ }
+ }
+ return values;
+ }
+
+ /**
+ *
+ * Handles LOWORD and HIWORD child nodes of LPARAM and WPARAM nodes. The
+ * returned value is the LPARAM/WPARAM value based on the LOWORD and HIWORD.
+ *
+ * Pre-processes log files generated by the EventBench's MFCUsageMonitor. It
+ * decodes Base64 encoding into UTF-16. It removes all lines of the log file,
+ * that do not start with the prefix "UL:", end everything before the prefix and
+ * the prefix itself.
+ *
+ * Internal flag that monitors whether there is an open session-node in the
+ * XML file to ensure that there is a closing session-node for each opening
+ * session node and, thereby, ensure that the XML file is well formed.
+ *
+ * Constructor. Creates a new LogPreprocessor.
+ *
+ *
+ * @param base64
+ * if true, Base64 will be decoded.
+ */
+ public LogPreprocessor(boolean base64) {
+ this.base64 = base64;
+ }
+
+ /**
+ *
+ * Pre-processes a single log file.
+ *
+ *
+ * @param source
+ * name and path of the source file
+ * @param target
+ * name and path of the target file
+ * @throws IOException
+ * thrown if there is a problem with reading from or writing to
+ * the source, respectively target file
+ * @throws FileNotFoundException
+ * thrown if the source file is not found
+ */
+ public void convertToXml(String source, String target) throws IOException,
+ FileNotFoundException {
+ OutputStreamWriter targetFile = new OutputStreamWriter(
+ new FileOutputStream(target), "UTF-8");
+ targetFile.write(""
+ + StringTools.ENDLINE);
+ targetFile.write("" + StringTools.ENDLINE);
+ processFile(source, targetFile);
+ if (sessionOpen) {
+ targetFile.write(" " + StringTools.ENDLINE);
+ }
+ targetFile.write("");
+ targetFile.close();
+ }
+
+ /**
+ *
+ * Pre-processes all files in a given source folder.
+ *
+ *
+ * @param path
+ * path of the source folder
+ * @param target
+ * name and path of the target file
+ * @throws IOException
+ * thrown if there is a problem with reading from or writing to
+ * the source, respectively target file
+ * @throws FileNotFoundException
+ * thrown if the source file is not found
+ */
+ public void convertDirToXml(String path, String target) throws IOException,
+ FileNotFoundException {
+ OutputStreamWriter targetFile = new OutputStreamWriter(
+ new FileOutputStream(target), "UTF-8");
+ targetFile.write(""
+ + StringTools.ENDLINE);
+ targetFile.write("" + StringTools.ENDLINE);
+ File folder = new File(path);
+ if (!folder.isDirectory()) {
+ throw new IOException(path + " is not a directory");
+ }
+ String absolutPath = folder.getAbsolutePath();
+ for (String filename : folder.list()) {
+ String source = absolutPath + "/" + filename;
+ Console.traceln("Processing file: " + source);
+ processFile(source, targetFile);
+ }
+
+ if (sessionOpen) {
+ targetFile.write(" " + StringTools.ENDLINE);
+ }
+ targetFile.write("");
+ targetFile.close();
+ }
+
+ /**
+ *
+ * Internal function that pre-processes a log file.
+ *
+ * This class provides functionality to parse XML log files generated by the
+ * MFCUsageMonitor of EventBench. The result of parsing a file is a collection
+ * of event sequences. It uses the {@link SequenceSplitter} and the
+ * {@link EventGenerator} as well as custom defined {@link MessageHandler} for
+ * the parsing.
+ *
+ * Collection of event sequences that is contained in the log file, which is
+ * parsed.
+ *
+ */
+ private Collection> sequences;
+
+ /**
+ *
+ * Debugging variable that allows the analysis which message type occurs how
+ * often in the log file. Can be used to enhance the message filter.
+ *
+ */
+ private SortedMap typeCounter;
+
+ /**
+ *
+ * Debugging variable that enables the counting of the occurrences of each
+ * message. Used in combination with {@link #typeCounter}.
+ *
+ * Contains definitions of windows message codes, such that they can be used
+ * internally by their name and not their integer value, to improve the
+ * readability of the source code.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public interface MessageDefs {
+
+ public static final int WM_NULL = 0;
+ public static final int WM_CREATE = 1;
+ public static final int WM_DESTROY = 2;
+ public static final int WM_MOVE = 3;
+ public static final int WM_SIZE = 5;
+ public static final int WM_ACTIVATE = 6;
+ public static final int WM_SETFOCUS = 7;
+ public static final int WM_KILLFOCUS = 8;
+ public static final int WM_ENABLE = 10;
+ public static final int WM_SETREDRAW = 11;
+ public static final int WM_SETTEXT = 12;
+ public static final int WM_GETTEXT = 13;
+ public static final int WM_GETTEXTLENGTH = 14;
+ public static final int WM_PAINT = 15;
+ public static final int WM_CLOSE = 16;
+ public static final int WM_QUERYENDSESSION = 17;
+ public static final int WM_QUIT = 18;
+ public static final int WM_QUERYOPEN = 19;
+ public static final int WM_ERASEBKGND = 20;
+ public static final int WM_SYSCOLORCHANGE = 21;
+ public static final int WM_ENDSESSION = 22;
+ public static final int WM_SHOWWINDOW = 24;
+ public static final int WM_CTLCOLOR = 25;
+ public static final int WM_WININICHANGE = 26;
+ public static final int WM_DEVMODECHANGE = 27;
+ public static final int WM_ACTIVATEAPP = 28;
+ public static final int WM_FONTCHANGE = 29;
+ public static final int WM_TIMECHANGE = 30;
+ public static final int WM_CANCELMODE = 31;
+ public static final int WM_SETCURSOR = 32;
+ public static final int WM_MOUSEACTIVATE = 33;
+ public static final int WM_CHILDACTIVATE = 34;
+ public static final int WM_QUEUESYNC = 35;
+ public static final int WM_GETMINMAXINFO = 36;
+ public static final int WM_PAINTICON = 38;
+ public static final int WM_ICONERASEBKGND = 39;
+ public static final int WM_NEXTDLGCTL = 40;
+ public static final int WM_SPOOLERSTATUS = 42;
+ public static final int WM_DRAWITEM = 43;
+ public static final int WM_MEASUREITEM = 44;
+ public static final int WM_DELETEITEM = 45;
+ public static final int WM_VKEYTOITEM = 46;
+ public static final int WM_CHARTOITEM = 47;
+ public static final int WM_SETFONT = 48;
+ public static final int WM_GETFONT = 49;
+ public static final int WM_SETHOTKEY = 50;
+ public static final int WM_GETHOTKEY = 51;
+ public static final int WM_QUERYDRAGICON = 55;
+ public static final int WM_COMPAREITEM = 57;
+ public static final int WM_GETOBJECT = 61;
+ public static final int WM_COMPACTING = 65;
+ public static final int WM_COMMNOTIFY = 68;
+ public static final int WM_WINDOWPOSCHANGING = 70;
+ public static final int WM_WINDOWPOSCHANGED = 71;
+ public static final int WM_POWER = 72;
+ public static final int WM_COPYDATA = 74;
+ public static final int WM_CANCELJOURNAL = 75;
+ public static final int WM_NOTIFY = 78;
+ public static final int WM_INPUTLANGCHANGEREQUEST = 80;
+ public static final int WM_INPUTLANGCHANGE = 81;
+ public static final int WM_TCARD = 82;
+ public static final int WM_HELP = 83;
+ public static final int WM_USERCHANGED = 84;
+ public static final int WM_NOTIFYFORMAT = 85;
+ public static final int WM_CONTEXTMENU = 123;
+ public static final int WM_STYLECHANGING = 124;
+ public static final int WM_STYLECHANGED = 125;
+ public static final int WM_DISPLAYCHANGE = 126;
+ public static final int WM_GETICON = 127;
+ public static final int WM_SETICON = 128;
+ public static final int WM_NCCREATE = 129;
+ public static final int WM_NCDESTROY = 130;
+ public static final int WM_NCCALCSIZE = 131;
+ public static final int WM_NCHITTEST = 132;
+ public static final int WM_NCPAINT = 133;
+ public static final int WM_NCACTIVATE = 134;
+ public static final int WM_GETDLGCODE = 135;
+ public static final int WM_SYNCPAINT = 136;
+ public static final int WM_NCMOUSEMOVE = 160;
+ public static final int WM_NCLBUTTONDOWN = 161;
+ public static final int WM_NCLBUTTONUP = 162;
+ public static final int WM_NCLBUTTONDBLCLK = 163;
+ public static final int WM_NCRBUTTONDOWN = 164;
+ public static final int WM_NCRBUTTONUP = 165;
+ public static final int WM_NCRBUTTONDBLCLK = 166;
+ public static final int WM_NCMBUTTONDOWN = 167;
+ public static final int WM_NCMBUTTONUP = 168;
+ public static final int WM_NCMBUTTONDBLCLK = 169;
+ public static final int WM_NCXBUTTONDOWN = 171;
+ public static final int WM_NCXBUTTONUP = 172;
+ public static final int WM_NCXBUTTONDBLCLK = 173;
+ public static final int WM_INPUT = 255;
+ public static final int WM_KEYDOWN = 256;
+ public static final int WM_KEYFIRST = 256;
+ public static final int WM_KEYUP = 257;
+ public static final int WM_CHAR = 258;
+ public static final int WM_DEADCHAR = 259;
+ public static final int WM_SYSKEYDOWN = 260;
+ public static final int WM_SYSKEYUP = 261;
+ public static final int WM_SYSCHAR = 262;
+ public static final int WM_SYSDEADCHAR = 263;
+ public static final int WM_KEYLAST = 264;
+ public static final int WM_WNT_CONVERTREQUESTEX = 265;
+ public static final int WM_CONVERTREQUEST = 266;
+ public static final int WM_CONVERTRESULT = 267;
+ public static final int WM_INTERIM = 268;
+ public static final int WM_IME_STARTCOMPOSITION = 269;
+ public static final int WM_IME_ENDCOMPOSITION = 270;
+ public static final int WM_IME_COMPOSITION = 271;
+ public static final int WM_IME_KEYLAST = 271;
+ public static final int WM_INITDIALOG = 272;
+ public static final int WM_COMMAND = 273;
+ public static final int WM_SYSCOMMAND = 274;
+ public static final int WM_TIMER = 275;
+ public static final int WM_HSCROLL = 276;
+ public static final int WM_VSCROLL = 277;
+ public static final int WM_INITMENU = 278;
+ public static final int WM_INITMENUPOPUP = 279;
+ public static final int WM_MENUSELECT = 287;
+ public static final int WM_MENUCHAR = 288;
+ public static final int WM_ENTERIDLE = 289;
+ public static final int WM_MENURBUTTONUP = 290;
+ public static final int WM_MENUDRAG = 291;
+ public static final int WM_MENUGETOBJECT = 292;
+ public static final int WM_UNINTMENUPOPUP = 293;
+ public static final int WM_MENUCOMMAND = 294;
+ public static final int WM_CHANGEUISTATE = 295;
+ public static final int WM_UPDATEUISTATE = 296;
+ public static final int WM_QUERYUISTATE = 297;
+ public static final int WM_CTLCOLORMSGBOX = 306;
+ public static final int WM_CTLCOLOREDIT = 307;
+ public static final int WM_CTLCOLORLISTBOX = 308;
+ public static final int WM_CTLCOLORBTN = 309;
+ public static final int WM_CTLCLOLORDLG = 310;
+ public static final int WM_CTLCOLORSCROLLBAR = 311;
+ public static final int WM_CTLCOLORSTATIC = 312;
+ public static final int WM_MOUSEFIRST = 512;
+ public static final int WM_MOUSEMOVE = 512;
+ public static final int WM_LBUTTONDOWN = 513;
+ public static final int WM_LBUTTONUP = 514;
+ public static final int WM_LBUTTONDBLCLK = 515;
+ public static final int WM_RBUTTONDOWN = 516;
+ public static final int WM_RBUTTONUP = 517;
+ public static final int WM_RBUTTONDBLCLK = 518;
+ public static final int WM_MBUTTONDOWN = 519;
+ public static final int WM_MBUTTONUP = 520;
+ public static final int WM_MBUTTONDBLCLK = 521;
+ public static final int WM_MOUSELAST = 521;
+ public static final int WM_MOUSEWHEEL = 522;
+ public static final int WM_XBUTTONDOWN = 523;
+ public static final int WM_XBUTTONUP = 524;
+ public static final int WM_XBUTTONDBLCLK = 525;
+}
Index: /trunk/quest-plugin-mfc/src/main/java/de/ugoe/cs/quest/plugin/mfc/MessageHandler.java
===================================================================
--- /trunk/quest-plugin-mfc/src/main/java/de/ugoe/cs/quest/plugin/mfc/MessageHandler.java (revision 581)
+++ /trunk/quest-plugin-mfc/src/main/java/de/ugoe/cs/quest/plugin/mfc/MessageHandler.java (revision 581)
@@ -0,0 +1,55 @@
+package de.ugoe.cs.quest.plugin.mfc;
+
+/**
+ *
+ * Base class to define custom message handlers, for messages that shall be
+ * handled differently during the parsing of usage logs. It provides dummy
+ * implementations for all required methods, such that implementations can only
+ * overwrite the parts they actually require and ignore the rest.
+ *
+ * Called by the {@link MFCLogParser} to handle param-nodes.
+ *
+ *
+ * @param name
+ * name (type) of the parameter
+ * @param value
+ * value of the parameter
+ */
+ public void onParameter(String name, String value) {
+ }
+
+ /**
+ *
+ * Called in the endElement() method of {@link MFCLogParser} when a msg-node
+ * ends.
+ *
+ * Number of messages in the current sequences, that signal that a key or
+ * mouse button has been pressed down to which not yet a message has been
+ * found, that signals that the button has been released.
+ *
+ */
+ private int openDowns;
+
+ /**
+ *
+ * Internal flag that signals if {@link #currentSequence} needs to be
+ * initialized.
+ *
+ */
+ private boolean initMessages;
+
+ /**
+ *
+ * The {@link EventGenerator} used to convert the subsequences into
+ * {@link Event}s
+ *