// /////////////////////////////////////////////////////////////////
// // private methods ////
// Recursively compute the set of free variables for all actors
// deeply contained in the given model.
private Set _freeVariables(Entity model) throws IllegalActionException {
// First get the free variables of contained actors.
Set set = new HashSet();
if (model instanceof CompositeEntity) {
for (Iterator entities = ((CompositeEntity) model).entityList().iterator();
entities.hasNext(); ) {
Entity entity = (Entity) entities.next();
set.addAll(_freeVariables(entity));
}
}
// Next, compute the set of variable names defined in this container.
Set variableNames = new HashSet();
for (Iterator variables = model.attributeList(Variable.class).iterator();
variables.hasNext(); ) {
Variable variable = (Variable) variables.next();
variableNames.add(variable.getName());
}
variableNames = Collections.unmodifiableSet(variableNames);
// Free variables of contained actors that are defined in this
// container are not free variables of this container.
set.removeAll(variableNames);
// Iterate over all the variables of this container, and add in
// any free variables they reference.
PtParser parser = new PtParser();
ParseTreeFreeVariableCollector collector = new ParseTreeFreeVariableCollector();
for (Iterator variables = model.attributeList(Variable.class).iterator();
variables.hasNext(); ) {
Variable variable = (Variable) variables.next();
String expression = variable.getExpression();
ASTPtRootNode root;
if (variable.isStringMode()) {
root = parser.generateStringParseTree(expression);
} else {
root = parser.generateParseTree(expression);
}
Set freeIdentifiers = new HashSet(collector.collectFreeVariables(root));
// Identifiers that reference other variables in the same container
// are bound, not free.
Set tempSet = new HashSet(variableNames);
tempSet.remove(variable.getName());
freeIdentifiers.removeAll(tempSet);
set.addAll(freeIdentifiers);
}
_entityToFreeVariableNameSet.put(model, set);
return set;
}
/**
* Set the expression associated with the iteration count. The expression will probably be
* something like "a2::in::tokenConsumptionRate/gcd(a2::in::tokenConsumptionRate,
* a::out::tokenProductionRate)."
*
* @param expression The expression to be associated with the iteration count.
*/
public void setIterationCount(String expression) {
_expression = expression;
// FIXME: Need better exception handling.
try {
PtParser parser = new PtParser();
_parseTree = parser.generateParseTree(expression);
} catch (Exception exception) {
throw new RuntimeException(
"Error setting iteration count to " + expression + ".\n" + exception.getMessage());
}
}
/**
* Create a new FunctionToken from the given string.
*
* @param init The initialization string, for example <code>function(x,y) 4+x+y</code>.
* @exception IllegalActionException If an error occurs, or the string cannot be parsed into a
* function.
*/
public FunctionToken(String init) throws IllegalActionException {
PtParser parser = new PtParser();
ASTPtRootNode tree = parser.generateParseTree(init);
ParseTreeTypeInference inference = new ParseTreeTypeInference();
inference.inferTypes(tree);
Token token = (new ParseTreeEvaluator()).evaluateParseTree(tree);
if (token instanceof FunctionToken) {
_function = ((FunctionToken) token)._function;
_type = ((FunctionToken) token)._type;
} else {
throw new IllegalActionException(
"A function token cannot be" + " created from the expression '" + init + "'");
}
}
/**
* Evaluate the specified command.
*
* @param command The command.
* @return The return value of the command, or null if there is none.
* @exception Exception If something goes wrong processing the command.
*/
public String evaluateCommand(String command) throws Exception {
if (command.trim().equals("")) {
return "";
}
PtParser parser = new PtParser();
ASTPtRootNode node = parser.generateSimpleAssignmentParseTree(command);
String targetName = null;
// Figure out if we got an assignment... if so, then get the
// identifier name and only evaluated the expression part.
if (node instanceof ASTPtAssignmentNode) {
ASTPtAssignmentNode assignmentNode = (ASTPtAssignmentNode) node;
targetName = assignmentNode.getIdentifier();
node = assignmentNode.getExpressionTree();
}
final NamedObj model = ((ExpressionShellEffigy) getContainer()).getModel();
ParserScope scope =
new ModelScope() {
public ptolemy.data.Token get(String name) throws IllegalActionException {
Variable result = getScopedVariable(null, model, name);
if (result != null) {
return result.getToken();
} else {
return null;
}
}
public ptolemy.data.type.Type getType(String name) throws IllegalActionException {
Variable result = getScopedVariable(null, model, name);
if (result != null) {
return result.getType();
} else {
return null;
}
}
public InequalityTerm getTypeTerm(String name) throws IllegalActionException {
Variable result = getScopedVariable(null, model, name);
if (result != null) {
return result.getTypeTerm();
} else {
return null;
}
}
public Set identifierSet() {
return getAllScopedVariableNames(null, model);
}
};
Token result = _evaluator.evaluateParseTree(node, scope);
// If a target was specified, instantiate a new token.
if (targetName != null) {
Attribute attribute = model.getAttribute(targetName);
if (attribute != null && !(attribute instanceof Parameter)) {
attribute.setContainer(null);
attribute = null;
}
if (attribute == null) {
attribute = new Parameter(model, targetName);
}
((Parameter) attribute).setToken(result);
}
if (result == null) {
return "";
} else {
return result.toString();
}
}