/*
* Copyright 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.test.metric.method;
import static java.util.Arrays.asList;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import com.google.test.metric.JavaType;
import com.google.test.metric.Variable;
import com.google.test.metric.collection.KeyedMultiStack;
import com.google.test.metric.collection.PopClosure;
import com.google.test.metric.collection.KeyedMultiStack.ValueCompactor;
import com.google.test.metric.method.op.stack.JSR;
import com.google.test.metric.method.op.stack.StackOperation;
import com.google.test.metric.method.op.turing.Operation;
public class Stack2Turing {
public static final Object EMPTY = new Object();
public static class VariableCompactor extends ValueCompactor<Variable> {
@Override
public List<List<Variable>> compact(List<List<Variable>> pushValues) {
if (pushValues.size() < 2) {
return pushValues;
}
ArrayList<List<Variable>> compacted = new ArrayList<List<Variable>>();
Set<Object> equivalent = new HashSet<Object>();
Iterator<List<Variable>> iter;
for (iter = pushValues.iterator(); iter.hasNext();) {
List<Variable> values = iter.next();
Object key = computeKey(values);
if (equivalent.add(key)) {
compacted.add(values);
}
}
return compacted;
}
private Object computeKey(List<Variable> variables) {
int size = variables.size();
if (size == 0) {
return EMPTY;
} else if (size == 1) {
return computeKey(variables.get(0));
} else {
ArrayList<Object> keys = new ArrayList<Object>();
for (Variable variable : variables) {
keys.add(computeKey(variable));
}
return keys;
}
}
private Object computeKey(Variable variable) {
Object key;
if (variable instanceof Constant) {
Constant constant = (Constant) variable;
key = constant.getType();
} else {
key = variable;
}
return key;
}
}
private final Block rootBlock;
private final List<Operation> operations = new ArrayList<Operation>();
private final ValueCompactor<Variable> pathCompactor = new VariableCompactor();
public KeyedMultiStack<Block, Variable> stack = new KeyedMultiStack<Block, Variable>(
pathCompactor);
public Stack2Turing(Block block) {
this.rootBlock = block;
}
public List<Operation> translate() {
stack.init(rootBlock);
translate(rootBlock, new ArrayList<Block>());
return operations;
}
private Block translate(Block block, List<Block> parentProcessed) {
List<Block> blocks = new ArrayList<Block>();
List<Block> processed = parentProcessed;
blocks.add(block);
while (!blocks.isEmpty()) {
block = blocks.remove(0);
processed.add(block);
for (StackOperation operation : block.getOperations()) {
translateStackOperation(block, operation);
if (operation instanceof JSR) {
JSR jsr = (JSR) operation;
Block jsrBlock = jsr.getBlock();
stack.split(block, asList(jsrBlock));
Block terminalBlock = translate(jsrBlock, processed);
stack.join(asList(terminalBlock), block);
processed.add(jsrBlock);
}
}
List<Block> nextBlocks = new ArrayList<Block>(block.getNextBlocks());
nextBlocks.removeAll(processed); // Don't visit already visited
// blocks
if (nextBlocks.size() > 0) {
stack.split(block, nextBlocks);
}
blocks.addAll(nextBlocks);
blocks.removeAll(processed);
}
// It appears that when exceptions are involved a method might have
// paths where stacks are not emptied. So we can't assert this.
// Verdict is still out.
// stack.assertEmpty();
return block;
}
private void translateStackOperation(Block block,
final StackOperation operation) {
stack.apply(block, new PopClosure<Block, Variable>() {
@Override
public List<Variable> pop(Block key, List<Variable> input) {
List<Variable> variables = operation.apply(input);
// For performance reasons the line is commented out.
// assertValid(variables);
Operation turingOp = operation.toOperation(input);
if (turingOp != null) {
operations.add(turingOp);
}
return variables;
}
@Override
public int getSize() {
return operation.getOperatorCount();
}
});
}
protected void assertValid(List<Variable> variables) {
Iterator<Variable> iter = variables.iterator();
while (iter.hasNext()) {
final Variable variable = iter.next();
if (JavaType.isDoubleSlot(variable.getType())) {
Variable varNext = iter.hasNext() ? iter.next() : null;
if (variable != varNext) {
throw new IllegalStateException("Variable list '" + variables
+ "' contanins variable '" + variable
+ "' which is a double but the next "
+ "variable in the list is not a duplicate.");
}
}
}
}
}