icltermstringreceiver.java

SRI international 发布的OAA框架软件

package com.sri.oaa2.simplefac;

import com.sri.oaa2.icl.*;
import java.net.*;
import java.io.*;
import antlr_oaa.*;
import org.apache.log4j.Logger;
import org.apache.log4j.NDC;

public class IclTermStringReceiver implements IclTermReceiver
{
  // Logger
  static Logger logger = Logger.getLogger(IclTermStringReceiver.class.getName());

  // Socket connected to client agent
  private Socket clientSocket = null;

  // InputStreamReader associated with socket
  private BufferedInputStream clientStream = null;

  // Are we connected?
  private boolean connected = true;

  // The object that does the work
  StringReceiverParser parser;

  // The connection
  SimpleFacConnection conn;

  Throwable closeException;

  /**
   * Construct with the given socket
   */
  public IclTermStringReceiver(Socket s, SimpleFacConnection c)
  {
    setConnected(true);
    setSocket(s);
    setConn(c);
    try {
      clientStream = new BufferedInputStream(getSocket().getInputStream());
    }
    catch(IOException ioe) {
      throw new RuntimeException("IclTermStringReceiver could not create BufferedReader: " + ioe.toString());
    }
    parser = new StringReceiverParser(clientStream, getConn());
    Thread t = new Thread(parser);
    StringBuffer b = new StringBuffer();
    b.append("StringReceiverParser:");
    b.append(getConn().getId().toString());
    t.setName(b.toString());
    t.start();
  }

  public IclTermStringReceiver(InputStream r, SimpleFacConnection c)
  {
    setConnected(false);
    setConn(c);
    clientStream = new BufferedInputStream(r);
    parser = new StringReceiverParser(clientStream, getConn());
    Thread t = new Thread(parser);
    StringBuffer b = new StringBuffer();
    b.append("StringReceiverParser:");
    b.append(getConn().getId().toString());
    t.setName(b.toString());
    t.start();
  }

  protected void setSocket(Socket s)
  {
    clientSocket = s;
  }

  protected Socket getSocket()
  {
    return clientSocket;
  }

  protected void setConn(SimpleFacConnection c)
  {
    conn = c;
  }

  protected SimpleFacConnection getConn()
  {
    return conn;
  }

  /**
   * Disconnect request
   */
  public synchronized void disconnect()
  {
    connected = false;
  }

  /**
   * Check if disconnect requested
   */
  public synchronized boolean isConnected()
  {
    return connected;
  }

    public Throwable getCloseException() {
        return closeException;
    }

    public synchronized void setConnected(boolean b)
  {
    connected = b;
  }

  /**
   * Get next term; may return null if not connected
   */
  public IclTerm getNextTerm()
  {
    IclTerm t = parser.getTerm();
    if(!parser.isConnected()) {
      disconnect();
      return null;
    }
    return t;
  }

  /**
   * Check if there is a next term
   */
  public boolean haveNextTerm()
  {
    return parser.hasTerm();
  }
}

/**
 * Class to parse incoming string IclTerms
 */
class StringReceiverParser extends AbstractReceiverParser
{
  // Logger
  static Logger logger = Logger.getLogger(StringReceiverParser.class.getName());

  OaaPrologLexer lexer;
  OaaPrologParser parser;
  InputStream stream;
  InterruptibleBuffer internalBuffer;

  /**
   * Construct using given input stream.
   */
  public StringReceiverParser(InputStream r, SimpleFacConnection c)
  {
    stream = r;
    lexer = new OaaPrologLexer(new StringReader(""));
    internalBuffer = new InterruptibleBuffer(stream);
    lexer.getInputState().resetInput(internalBuffer);
    parser = new OaaPrologParser(lexer);
    parser.setASTNodeType("com.sri.oaa2.icl.IclAST");
    setConn(c);
  }

  /**
   * Keep trying to parse the reader, as long as we are connected
   */
  public void run()
  {
    boolean pushed = false;
    IclTerm oneTerm;
    GETTING_TERMS:
    while(true) {
      if(!pushed) {
        if(getConn().getName() != null) {
          NDC.push(getConn().getName().toString());
          pushed = true;
        }
      }
      if(!isConnected()) {
        try {
          logger.warn("StringReceiverParser.run() not connected; closing stream");
          stream.close();
        }
        catch(IOException ioe) {
          if(pushed) {
            NDC.pop();
          }
          throw new RuntimeException("StringReceiverParser could not close stream");
        }
        if(pushed) {
          NDC.pop();
        }
        NDC.remove();
        return;
      }
      try {
        if(logger.isDebugEnabled()) {
          logger.debug("StringReceiverParser starting parse");
        }
        parser.startMulti();
        oneTerm = ((IclAST)parser.getAST()).getIclTerm();
        if(logger.isDebugEnabled()) {
          logger.debug("StringReceiverParser got term [" + oneTerm + "]");
        }
        setTerm(oneTerm);
      }
      catch(TokenStreamEOF tseof) {
        if(logger.isDebugEnabled()) {
          logger.debug("StringReceiverParser got TokenStreamEOF");
        }
        continue GETTING_TERMS;
      }
      catch(TokenStreamException tse) {
          closeException = tse;
        disconnect();
        try {
          logger.warn("StringReceiverParser.run() got TokenStreamException closing reader");
          if(tse instanceof TokenStreamRecognitionException) {
            RecognitionException re = ((TokenStreamRecognitionException)tse).recog;
            if(re instanceof NoViableAltForCharException) {
              NoViableAltForCharException none = (NoViableAltForCharException)re;
              logger.warn("StringReceiverParser.run() failed on character: " + (int)(none.foundChar));
            }
            else if(re instanceof MismatchedCharException) {
              MismatchedCharException mce = (MismatchedCharException)re;
              mce.printStackTrace();
            }
            tse.printStackTrace();
          }
          stream.close();
        }
        catch(IOException ioe) {
          throw new RuntimeException("StringReceiverParser could not close reader");
        }
        if(logger.isInfoEnabled()) {
          if(!pushed) {
            if(getConn().getName() != null) {
              NDC.push(getConn().getName().toString());
              pushed = true;
            }
          }
          logger.info("StringReceiverParser token stream exception [" + tse.toString() + "]; closing");
        }
        setTerm(null);
        if(pushed) {
          NDC.pop();
        }
        NDC.remove();
        return;
      }
      catch(RecognitionException re) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        re.printStackTrace(pw);
        logger.warn("StringReceiverParser.run() got RecognitionException closing reader; stack trace: " + sw.toString());
        logger.warn("StringReceiverParser.run() RecognitionException with context: " + new String(internalBuffer.getContext()));

        /*
        // Let's try to do something to recover from this error--look for a '.' then continue
        // after it
        boolean foundDot = false;

        while(!foundDot) {
          char c = (char)stream.read();
          if(c == '.') {
            foundDot = true;
          }
        }

        */

          closeException = re;
        disconnect();
        setTerm(null);
        try {
          stream.close();
        }
        catch(IOException ioe) {
          throw new RuntimeException("StringReceiverParser could not close reader");
        }
        logger.error("StringReceiverParser could not recognize anything in the stream; closing");
        if(pushed) {
          NDC.pop();
        }
        NDC.remove();
        return;
      }
    }
  }
}