示例#1
0
 /**
  * Return a new token whose value is the logical AND of the value of this token and the the value
  * of the argument token. If this token is nil, or the argument is nil, then {@link #NIL} is
  * returned.
  *
  * @param rightArgument The BooleanToken to OR with this one.
  * @return A new BooleanToken containing the result.
  */
 public BooleanToken and(BooleanToken rightArgument) {
   if (isNil() || rightArgument.isNil()) {
     return BooleanToken.NIL;
   }
   if (_value && rightArgument.booleanValue()) {
     return TRUE;
   } else {
     return FALSE;
   }
 }
示例#2
0
  /**
   * Retrieve the value of the parameter "evaluatedValue" of the model.
   *
   * @return The value of the "evaluatedValue" parameter.
   * @exception IllegalActionException If the model does not have a settable attribute named
   *     "evaluatedValue".
   */
  private boolean _getResult() throws IllegalActionException {
    Attribute attribute = _model.getAttribute("evaluatedValue");

    if (attribute instanceof Variable) {
      Token t = ((Variable) attribute).getToken();
      return ((BooleanToken) t).booleanValue();
    } else if (attribute instanceof Settable) {
      BooleanToken t = new BooleanToken(((Settable) attribute).getExpression());
      return t.booleanValue();
    } else {
      throw new IllegalActionException(
          this, "The specified model does not have an evaluatedValue parameter.");
    }
  }
示例#3
0
  public void initialize() throws IllegalActionException {
    super.initialize();

    IntToken it = (IntToken) LS0Bytes.getToken();
    _LS0Bytes = it.intValue();

    BooleanToken _bt = (BooleanToken) LS0Map.getToken();
    _LS0Map = _bt.booleanValue();

    it = (IntToken) S.getToken();
    _S = it.intValue();

    _fastReg = 0;
    _interReg = 0;
    _frameCounter = 0;

    _checkParameters();
  }
示例#4
0
 /**
  * Test for ordering of the values of this Token and the argument Token. It is assumed that the
  * type of the argument is PetiteToken. The argument token is then adjusted to the range of a
  * PetiteToken.
  *
  * @param rightArgument The token to compare this token with.
  * @exception IllegalActionException If this method is not supported by the derived class.
  * @return A new Token containing the result.
  */
 protected BooleanToken _isLessThan(ScalarToken rightArgument) throws IllegalActionException {
   PetiteToken convertedArgument = (PetiteToken) rightArgument;
   return BooleanToken.getInstance(_value < convertedArgument.doubleValue());
 }
示例#5
0
  public void fire() throws IllegalActionException {
    super.fire();

    // first, checks for acks from remote buffers, updating the
    // values within txack[].

    for (int i = 0; i < 5; i++) {
      if (ack[i].getWidth() > 0) {
        while (ack[i].hasToken(0)) {
          // consumes the token

          BooleanToken ackt = (BooleanToken) ack[i].get(0);
          if (_debugging) _debug("Consuming ack from " + ack[i]);

          if (ackt.booleanValue()) txack[i] = true;
          else txack[i] = false;
          if (_debugging) _debug("ack: " + txack[i]);
        }
      }
    }

    // second, handle the current request from the arbiter

    if (hasRequest()) {
      // get the index of the port with the request

      int j = nextRequest();
      if (_debugging) _debug("Arbiter gives turn to input " + j);

      if (j != -1) {
        // packet header flit
        RecordToken record = (RecordToken) inputreq[j].get(0);
        // calculate route information
        int dir = route(record);
        // verify if the output port is free, otherwise
        // do nothing and wait for another request
        boolean isfree = freeoutput[dir];
        boolean hasspace = txack[dir];
        if (isfree & hasspace) {
          // allocate outputport
          direction[j] = new IntToken(dir);
          freeoutput[dir] = false;

          if (_debugging) _debug("Input " + j + " connected to output " + dir);

          // deletes original header flit from buffer
          read[j].send(0, new Token());
          // signalize state machine to prepare for size
          state[j] = SIZE;

          // sends copy of the header flit to output
          output[dir].send(0, record);
          txack[dir] = false;

          // updates the last granted input port
          sel = j;
        }
      }
    }

    // clear all unatended requests (they will be asked again next cycle)
    clearRequests();

    // third, handle tokens on the inputs

    for (int i = 0; i < 5; i++) {
      if (inputreq[i].getWidth() > 0 & inputreq[i].hasToken(0)) {
        if (state[i] == SIZE | state[i] == PAYLOAD) {
          if (_debugging) _debug(inputreq[i] + " has size/payload token");
          // payload flit

          // get the direction assigned to this input port
          int dir = direction[i].intValue();

          // check if the remote buffer in that direction is free
          if (txack[dir]) {

            // check if it is a size flit or a regular flit

            if (state[i] == SIZE) {
              // set the size of the packet
              RecordToken record = (RecordToken) inputreq[i].get(0);
              packetsize[i] = ((IntToken) record.get("size")).intValue();
              if (_debugging) _debug("Packet size " + packetsize[i]);

              // prepare for payload
              state[i] = PAYLOAD;

              // deletes original header flit from buffer
              read[i].send(0, new Token());

              // send the token to the remote output buffer
              output[dir].send(0, record);

              if (_debugging) _debug(inputreq[i] + " sent size token to " + output[dir]);

              txack[dir] = false;

            } else if (state[i] == PAYLOAD) {

              // send the token to the remote output buffer
              output[dir].send(0, inputreq[i].get(0));
              txack[dir] = false;

              // deletes original header flit from buffer
              read[i].send(0, new Token());
              if (_debugging) _debug(inputreq[i] + " sent token to " + output[dir]);

              packetsize[i]--;
              if (_debugging) _debug("packet size " + packetsize[i]);

              // if package is finished,
              // release output port and prepare for new header
              if (packetsize[i] == 0) {
                freeoutput[dir] = true;
                state[i] = REQUESTING;
                if (_debugging) _debug("packet is over");
              }
            }
          } // end if direction is free
          else {
            inputreq[i].get(0);
          }
        } // end if state
      } // end if width > 1
    } // end for

    if (clocked) {

      // fourth: requests write on all inputs with packet payload or size
      // and whose respective output ports received acks

      for (int i = 0; i < 5; i++) {
        if (state[i] == PAYLOAD | state[i] == SIZE) {
          if (txack[direction[i].intValue()]) peek[i].send(0, new Token());
        }
      }

      // fifth: requests write on remote buffers
      for (int i = 0; i < 5; i++) {
        // if(!txack[i]){
        outputtx[i].send(0, new Token());
        // }
        txack[i] = false; // consumes unused acks
      }

      // requests copy of request from all requesting input buffers

      for (int i = 0; i < 5; i++) {
        if (state[i] == REQUESTING) {
          peek[i].send(0, new Token());
          if (_debugging) {
            _debug("Peek for request on direction " + i);
          }
        }
      }

      clocked = false;
    }
  }
  /**
   * Evaluate a logical AND or OR on the children of the specified node.
   *
   * @param node The specified node.
   * @exception IllegalActionException If an evaluation error occurs.
   */
  public void visitLogicalNode(ASTPtLogicalNode node) throws IllegalActionException {
    if (node.isConstant() && node.isEvaluated()) {
      _evaluatedChildToken = node.getToken();
      return;
    }

    // Note that we do not always evaluate all of the children...
    // We perform short-circuit evaluation instead and evaluate the
    // children in order until the final value is determined, after
    // which point no more children are evaluated.
    int numChildren = node.jjtGetNumChildren();
    _assert(numChildren > 0, node, "The number of child nodes must be greater than zero");

    _evaluateChild(node, 0);

    ptolemy.data.Token result = _evaluatedChildToken;

    if (!(result instanceof BooleanToken)) {
      throw new IllegalActionException(
          "Cannot perform logical "
              + "operation on "
              + result
              + " which is a "
              + result.getClass().getName());
    }

    // Make sure that exactly one of AND or OR is set.
    _assert(node.isLogicalAnd() ^ node.isLogicalOr(), node, "Invalid operation");

    // Perform both the short-circuit AND and short-circuit OR in
    // one piece of code.
    // FIXME: I dislike that this is not done in the token classes...
    boolean flag = node.isLogicalAnd();

    for (int i = 0; i < numChildren; i++) {
      ASTPtRootNode child = (ASTPtRootNode) node.jjtGetChild(i);

      // Evaluate the child
      child.visit(this);

      // Get its value.
      ptolemy.data.Token nextToken = _evaluatedChildToken;

      if (!(nextToken instanceof BooleanToken)) {
        throw new IllegalActionException(
            "Cannot perform logical "
                + "operation on "
                + nextToken
                + " which is a "
                + result.getClass().getName());
      }

      if (flag != ((BooleanToken) nextToken).booleanValue()) {
        _evaluatedChildToken = (BooleanToken.getInstance(!flag));

        // Note short-circuit eval.
        return;
      }
    }

    _evaluatedChildToken = (BooleanToken.getInstance(flag));

    if (node.isConstant()) {
      node.setToken(_evaluatedChildToken);
    }
  }
示例#7
0
 /**
  * Test for equality of the values of this Token and the argument Token. Two function tokens are
  * equal if they correspond to the same expression, under renaming of any bound variables.
  *
  * @param rightArgument The token to compare to this token.
  * @return A token containing true if the value element of the first argument is equal to the
  *     value of this token.
  */
 public BooleanToken isEqualTo(Token rightArgument) {
   FunctionToken convertedArgument = (FunctionToken) rightArgument;
   return BooleanToken.getInstance(convertedArgument._function.isCongruent(_function));
 }
示例#8
0
文件: Report.java 项目: ptII/ptII
  /**
   * Process this event. If the mode is {@link Mode#ERROR}, a message is shown in an error dialog.
   * If the mode is {@link Mode#EXCEPTION}, a message is shown in the form of an exception. If the
   * mode is {@link Mode#MESSAGE}, a message is shown in a message dialog. If the mode is {@link
   * Mode#TABLEAU}, a tableau is opened to show the message. The default tableau is the one defined
   * in the {@link #tableau} parameter. However, if {@link #referredTableau} is not an empty string,
   * its value is interpreted as the name of the tableau parameter in the model, whose tableau
   * should be used instead of the default one. If the mode is {@link Mode#WARNING}, a message is
   * shown in a warning dialog. If the mode is {@link Mode#YES_OR_NO}, a query dialog is shown with
   * the message, which allows the user to answer with yes or no. The answer is stored in {@link
   * #response}.
   *
   * @param arguments The arguments used to process this event, which must be either an ArrayToken
   *     or a RecordToken.
   * @return A refiring data structure that contains a non-negative double number if refire() should
   *     be called after that amount of model time, or null if refire() need not be called.
   * @exception IllegalActionException If the tableau cannot be used, or if thrown by the
   *     superclass.
   */
  public RefiringData fire(Token arguments) throws IllegalActionException {
    RefiringData data = super.fire(arguments);

    Mode choice = (Mode) mode.getChosenValue();
    String text = message.stringValue();
    MessageHandler oldHandler;
    switch (choice) {
      case ERROR:
        oldHandler = MessageHandler.getMessageHandler();
        try {
          MessageHandler.setMessageHandler(_MESSAGE_HANDLER);
          MessageHandler.error(text);
        } finally {
          MessageHandler.setMessageHandler(oldHandler);
        }
        break;
      case MESSAGE:
        oldHandler = MessageHandler.getMessageHandler();
        try {
          MessageHandler.setMessageHandler(_MESSAGE_HANDLER);
          MessageHandler.message(text);
        } finally {
          MessageHandler.setMessageHandler(oldHandler);
        }
        break;
      case EXCEPTION:
        throw new RuntimeException(text);
      case TABLEAU:
        Effigy effigy = EventUtils.findToplevelEffigy(this);
        if (effigy == null) {
          // The effigy may be null if the model is closed.
          return data;
        }

        Tableau tableau = EventUtils.getTableau(this, referredTableau, this.tableau);
        if (tableau != null && !(tableau.getFrame() instanceof TextEditor)) {
          EventUtils.setTableau(this, referredTableau, this.tableau, null);
          EventUtils.closeTableau(tableau);
          tableau = null;
        }

        boolean openNewWindow = true;
        String previousText = null;
        if (tableau != null) {
          JFrame frame = tableau.getFrame();
          if (frame instanceof TextEditor) {
            TextEditor editor = (TextEditor) frame;
            if (editor.getEffigy() == null) {
              previousText = editor.text.getText();
            } else {
              openNewWindow = false;
            }
          }
        }

        TextEditor frame;
        if (openNewWindow) {
          TextEffigy textEffigy;
          try {
            textEffigy = TextEffigy.newTextEffigy(effigy, "");
          } catch (Exception e) {
            throw new IllegalActionException(this, e, "Unable to " + "create effigy.");
          }
          try {
            tableau = new Tableau(textEffigy, "tableau");
          } catch (NameDuplicationException e) {
            throw new IllegalActionException(this, e, "Unable to " + "create tableau.");
          }
          frame = new TextEditor(tableau.getTitle(), textEffigy.getDocument());
          frame.text.setColumns(((IntToken) columnsDisplayed.getToken()).intValue());
          frame.text.setRows(((IntToken) rowsDisplayed.getToken()).intValue());
          tableau.setFrame(frame);
          frame.setTableau(tableau);
          EventUtils.setTableau(this, referredTableau, this.tableau, tableau);
          frame.pack();
          frame.setVisible(true);
          if (previousText != null) {
            frame.text.setText(previousText);
          }
        } else {
          frame = (TextEditor) tableau.getFrame();
        }
        frame.text.append(text + "\n");
        try {
          int lineOffset = frame.text.getLineStartOffset(frame.text.getLineCount() - 1);
          frame.text.setCaretPosition(lineOffset);
        } catch (BadLocationException ex) {
          // Ignore ... worst case is that the scrollbar
          // doesn't move.
        }
        break;
      case WARNING:
        try {
          oldHandler = MessageHandler.getMessageHandler();
          try {
            MessageHandler.setMessageHandler(_MESSAGE_HANDLER);
            MessageHandler.warning(text);
          } finally {
            MessageHandler.setMessageHandler(oldHandler);
          }
          response.setToken(BooleanToken.TRUE);
        } catch (CancelException e) {
          response.setToken(BooleanToken.FALSE);
        }
        break;
      case YES_OR_NO:
        oldHandler = MessageHandler.getMessageHandler();
        boolean success = false;
        boolean answer;
        try {
          MessageHandler.setMessageHandler(_MESSAGE_HANDLER);
          answer = MessageHandler.yesNoQuestion(text);
          success = true;
        } finally {
          MessageHandler.setMessageHandler(oldHandler);
        }
        if (success) {
          response.setToken(BooleanToken.getInstance(answer));
        }
        break;
      default:
        throw new IllegalActionException(
            "Unrecognized mode choice \"" + mode.getExpression() + "\".");
    }

    return data;
  }
示例#9
0
  /**
   * @param attribute The changed Attribute.
   * @throws ptolemy.kernel.util.IllegalActionException When bad things happen.
   */
  public void attributeChanged(ptolemy.kernel.util.Attribute attribute)
      throws ptolemy.kernel.util.IllegalActionException {

    log.debug("attributeChanged() start.");

    if (attribute == opendapURLParameter || attribute == opendapCEParameter) {

      String url = opendapURLParameter.getExpression();
      String ce = opendapCEParameter.getExpression();

      if (attribute == opendapURLParameter)
        log.debug("--- attributeChanged() url: " + url + " Current URL: " + opendapURL);
      if (attribute == opendapCEParameter)
        log.debug("--- attributeChanged()  ce: \"" + ce + "\" Current CE: \"" + opendapCE + "\"");

      boolean reload = false;
      if (!opendapURL.equals(url)) {
        opendapURL = url;

        // only reload if not empty.
        if (!url.equals("")) {
          reload = true;
        }
      }

      if (!opendapCE.equals(ce)) {
        opendapCE = ce;
        // *** I think this should test if url.equals(""). jhrg
        reload = true;
      }

      if (reload) {

        try {

          log.debug("OPeNDAP URL: " + opendapURL);
          dapConnection = new DConnect2(opendapURL);

          DDS dds = dapConnection.getDDS(opendapCE);

          log.debug("Got DDS.");
          // dds.print(System.out);

          log.debug("Squeezing arrays.");
          squeezeArrays(dds);

          // log.debug("Before ports configured.");
          // dds.print(System.out);

          log.debug("Configuring ports.");
          configureOutputPorts(dds);

          // log.debug("After ports configured.");
          // dds.print(System.out);

        } catch (Exception e) {
          e.printStackTrace();
          throw new IllegalActionException(
              "Problem accessing " + "OPeNDAP Data Source: " + e.getMessage());
        }
      }

    }
    // *** Remove the ODC option. jhrg
    else if (attribute == runODC) {
      BooleanToken token = (BooleanToken) runODC.getToken();
      if (token.booleanValue()) {
        // start ODC in separate thread
        ODCThread tr = new ODCThread();
        tr.start();
        runODC.setExpression("false");
      }
    }
  }