Example #1
1
  public static void showSession(HttpServletRequest req, PrintStream out) {

    // res.setContentType("text/html");

    // Get the current session object, create one if necessary
    HttpSession session = req.getSession();

    out.println("Session id: " + session.getId());
    out.println(" session.isNew(): " + session.isNew());
    out.println(" session.getMaxInactiveInterval(): " + session.getMaxInactiveInterval() + " secs");
    out.println(
        " session.getCreationTime(): "
            + session.getCreationTime()
            + " ("
            + new Date(session.getCreationTime())
            + ")");
    out.println(
        " session.getLastAccessedTime(): "
            + session.getLastAccessedTime()
            + " ("
            + new Date(session.getLastAccessedTime())
            + ")");
    out.println(" req.isRequestedSessionIdFromCookie: " + req.isRequestedSessionIdFromCookie());
    out.println(" req.isRequestedSessionIdFromURL: " + req.isRequestedSessionIdFromURL());
    out.println(" req.isRequestedSessionIdValid: " + req.isRequestedSessionIdValid());

    out.println("Saved session Attributes:");
    Enumeration atts = session.getAttributeNames();
    while (atts.hasMoreElements()) {
      String name = (String) atts.nextElement();
      out.println(" " + name + ": " + session.getAttribute(name) + "<BR>");
    }
  }
Example #2
1
  private static void showThreads(PrintStream pw, ThreadGroup g, Thread current) {
    int nthreads = g.activeCount();
    pw.println("\nThread Group = " + g.getName() + " activeCount= " + nthreads);
    Thread[] tarray = new Thread[nthreads];
    int n = g.enumerate(tarray, false);

    for (int i = 0; i < n; i++) {
      Thread thread = tarray[i];
      ClassLoader loader = thread.getContextClassLoader();
      String loaderName = (loader == null) ? "Default" : loader.getClass().getName();
      Thread.State state = thread.getState();
      long id = thread.getId();
      pw.print("   " + id + " " + thread.getName() + " " + state + " " + loaderName);
      if (thread == current) pw.println(" **** CURRENT ***");
      else pw.println();
    }

    int ngroups = g.activeGroupCount();
    ThreadGroup[] garray = new ThreadGroup[ngroups];
    int ng = g.enumerate(garray, false);
    for (int i = 0; i < ng; i++) {
      ThreadGroup nested = garray[i];
      showThreads(pw, nested, current);
    }
  }
 private void saveSqlScript(String fileName, String[] sql) throws FileNotFoundException {
   FileOutputStream fileOutputStream = new FileOutputStream(fileName);
   PrintStream printStream = new PrintStream(fileOutputStream);
   for (int i = 0; i < sql.length; i++) {
     printStream.println(sql[i] + getSqlDelimiter());
   }
 }
Example #4
0
 static void printFooter(PrintStream file) {
   file.println();
   file.println("#ifdef HAVE_JIKES_NAMESPACE");
   file.println("} // Close namespace Jikes block");
   file.println("#endif");
   file.println();
 }
Example #5
0
 public static void viewTagInfo(String inurl, String tag) throws Exception {
   // pr = new PrintStream(new FileOutputStream("/semplest/lluis/keywordExp/urldata.txt"));
   pr = System.out;
   long start = System.currentTimeMillis();
   pr.println(inurl + "****************************************************************");
   printList(cleanUrlText(TextUtils.HTMLText(inurl, tag)));
   String urls = TextUtils.HTMLLinkString(inurl, inurl);
   String[] url = urls.split("\\s+");
   Set<String> urlMap = new HashSet<String>(url.length);
   urlMap.add(inurl);
   for (String ur : url) {
     if (!urlMap.contains(ur)) {
       pr.println(ur + "***************************************************************");
       try {
         printList(cleanUrlText(TextUtils.HTMLText(ur, tag)));
       } catch (Exception e) {
         System.out.println("Error with url :" + ur);
         e.printStackTrace();
         logger.error("Problem", e);
       }
       urlMap.add(ur);
     }
   }
   pr.println("Time elapsed" + (start - System.currentTimeMillis()));
 }
 public static void println(double[] p, PrintStream ps) {
   for (int i = 0; i < p.length; i++) {
     ps.print(i > 0 ? " " : "");
     ps.print(String.format("%.2f", p[i]));
   }
   ps.println();
 }
Example #7
0
 protected int unknownArgument(String[] args, String arg, int argNum) {
   if (arg == "-t") {
     arg = args[++argNum];
     if (arg.equalsIgnoreCase("parse")) setTraceParse(true);
     else if (arg.equalsIgnoreCase("gen")) setTraceGen(true);
     else if (arg.equalsIgnoreCase("dot")) setTraceDot(true);
     else {
       if (!arg.equalsIgnoreCase("all"))
         --argNum; // unknown value, trace all, and rethink that option
       setTraceParse(true);
       setTraceGen(true);
       setTraceMisc(true);
       setTraceDot(true);
     }
   } else if (arg == "-version") {
     messageOut.println("schema2beans - " + Version.getVersion());
     System.exit(0);
   } else if (arg == "-xmlschema") setSchemaTypeNum(XML_SCHEMA);
   else if (arg == "-dtd") setSchemaTypeNum(DTD);
   else if (arg == "-premium") buyPremium();
   else if (arg == "-strict") useStrict();
   else if (arg == "-basebean") {
     setOutputType(OUTPUT_TRADITIONAL_BASEBEAN);
   } else if (arg == "-javabeans") setOutputType(OUTPUT_JAVABEANS);
   else if (arg == "-commoninterface") setGenerateCommonInterface(COMMON_BEAN);
   else if (arg == "-nocommoninterface") setGenerateCommonInterface(null);
   else {
     messageOut.println("Unknown argument: " + arg);
     messageOut.println("Use -help.");
     System.exit(1);
   }
   return argNum;
 }
Example #8
0
 public static void main(String[] args) {
   String tokensFile = args[0];
   String progFile = args[1];
   String tempFile = "CAMLE_TEMP.txt";
   List<String> tokenName = new ArrayList<String>();
   List<Integer> tokenType = new ArrayList<Integer>();
   List<String> nameOf = new ArrayList<String>();
   String line;
   boolean skipping = false;
   try {
     int nTokens = readTokensFile(tokensFile, tokenName, tokenType, nameOf);
     BufferedReader in = new BufferedReader(new FileReader(progFile));
     PrintStream o = new PrintStream(new FileOutputStream(tempFile));
     while ((line = in.readLine()) != null) {
       if (line.equals("// CAMLE TOKENS END")) {
         skipping = false;
       }
       if (!skipping) {
         o.println(line);
       }
       if (line.equals("// CAMLE TOKENS BEGIN")) {
         skipping = true;
         writeTokensCode(o, nTokens, tokenName, tokenType, nameOf);
       }
     }
     in.close();
     o.close();
     new File(tempFile).renameTo(new File(progFile));
   } catch (Exception e) {
     System.out.println(e.toString());
     System.exit(1);
   }
 }
Example #9
0
 public void init() {
   try {
     url = new URL(urlStr);
     // 创建一个代理服务器对象
     proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyAddress, proxyPort));
     // 使用指定的代理服务器打开连接
     conn = url.openConnection(proxy);
     // 设置超时时长。
     conn.setConnectTimeout(5000);
     scan = new Scanner(conn.getInputStream());
     // 初始化输出流
     ps = new PrintStream("Index.htm");
     while (scan.hasNextLine()) {
       String line = scan.nextLine();
       // 在控制台输出网页资源内容
       System.out.println(line);
       // 将网页资源内容输出到指定输出流
       ps.println(line);
     }
   } catch (MalformedURLException ex) {
     System.out.println(urlStr + "不是有效的网站地址!");
   } catch (IOException ex) {
     ex.printStackTrace();
   }
   // 关闭资源
   finally {
     if (ps != null) {
       ps.close();
     }
   }
 }
Example #10
0
  public void run() {
    if (clientSocket == null) {
      return;
    }

    PrintStream out = null;

    Utilities.printMsg("creating output stream");

    try {
      out = new PrintStream(clientSocket.getOutputStream());
    } catch (IOException e) {
      System.err.println("Error binding output to socket, " + e);
      System.exit(1);
    }

    Utilities.printMsg("writing current date");

    Date d = new Date();
    out.println(d);

    try {
      out.close();
      clientSocket.close();
    } catch (IOException e) {
    }
  }
  /**
   * Determines if the given configuration is currently running. If any of the configurations are
   * currently stuck in the queue, it is logged.
   *
   * @param execution Contains information about the general build, including the listener used to
   *     log queue blockage.
   * @param configuration The configuration being checked to see if it's running.
   * @param mutableWhyMap Mutable map used to track the reasons a configuration is stuck in the
   *     queue. This prevents duplicate reasons from flooding the logs.
   * @return True if the build represented by the given configuration is currently running or stuck
   *     in the queue. False if the build has finished running.
   */
  private boolean isBuilding(
      MatrixBuild.MatrixBuildExecution execution,
      MatrixConfiguration configuration,
      Map<String, String> mutableWhyMap) {
    MatrixRun build = configuration.getBuildByNumber(execution.getBuild().getNumber());
    if (build != null) {
      return build.isBuilding();
    }

    Queue.Item queueItem = configuration.getQueueItem();
    if (queueItem != null) {
      String why = queueItem.getWhy();
      String key = queueItem.task.getFullDisplayName() + " " + queueItem.id;
      String oldWhy = mutableWhyMap.get(key);
      if (why == null) {
        mutableWhyMap.remove(key);
      }
      if (why != null && !why.equals(oldWhy)) {
        mutableWhyMap.put(key, why);
        BuildListener listener = execution.getListener();
        PrintStream logger = listener.getLogger();
        logger.print(
            "Configuration "
                + ModelHyperlinkNote.encodeTo(configuration)
                + " is still in the queue: ");
        queueItem.getCauseOfBlockage().print(listener); // this is still shown on the same line
      }
    }

    return true;
  }
  private void sendProcessingError(Throwable t, ServletResponse response) {

    String stackTrace = getStackTrace(t);

    if (stackTrace != null && !stackTrace.equals("")) {

      try {

        response.setContentType("text/html");
        PrintStream ps = new PrintStream(response.getOutputStream());
        PrintWriter pw = new PrintWriter(ps);
        pw.print("<html>\n<head>\n</head>\n<body>\n"); // NOI18N

        // PENDING! Localize this for next official release
        pw.print("<h1>The resource did not process correctly</h1>\n<pre>\n");
        pw.print(stackTrace);
        pw.print("</pre></body>\n</html>"); // NOI18N
        pw.close();
        ps.close();
        response.getOutputStream().close();
        ;
      } catch (Exception ex) {
      }
    } else {
      try {
        PrintStream ps = new PrintStream(response.getOutputStream());
        t.printStackTrace(ps);
        ps.close();
        response.getOutputStream().close();
        ;
      } catch (Exception ex) {
      }
    }
  }
Example #13
0
 public static void xinac() {
   out.println("xinac instruction");
   // XINAC1 increment the value in AC by 1, setting/resetting flags
   // as appropriate
   if ((AC < 0) && (AC + 1 >= 0)) {
     flag[1] = true;
   } else {
     flag[1] = false;
   }
   if (AC > 0 && (short) (AC + 1) < 0) {
     flag[2] = true;
   } else {
     flag[2] = false;
   }
   AC++;
   // set other flags
   if (AC == 0) {
     flag[0] = true;
   } else {
     flag[0] = false;
   }
   if (AC < 0) {
     flag[3] = true;
   } else {
     flag[3] = false;
   }
   out.print("xinac1 AC = " + AC);
   printzcvn();
 }
Example #14
0
  public static void xlsl() {
    out.println("xlsl instruction");
    // XLSL1 shifts AC left one bit, sets/resets the flags
    // if AC is negative, carry bit will be true
    if ((short) AC < 0) {
      flag[1] = true;
    } else {
      flag[1] = false;
    }
    // setting overflow flag
    // if it changes sign, overflow
    if ((short) (0xFFFF & AC) > 0 && (short) ((0xFFFF & AC) << 1) < 0) {
      flag[2] = true;
    } else if ((short) (0xFFFF & AC) < 0 && (short) ((0xFFFF & AC) << 1) > 0) {
      flag[2] = true;
    } else {
      flag[2] = false;
    }
    AC += -(0xFFFF & AC) + (0xFFFF & AC << 1);

    out.println(0xFFFF & AC);
    // set the flags
    setFlagsXRotS();
    out.print("xlsl1 AC = " + AC);
    printzcvn();
  }
Example #15
0
  /**
   * There are two things we need to check
   *
   * <ul>
   *   <li>files created or modified since last build time, we only need to check the source folder
   *   <li>file deleted since last build time, we have to compare source and destination folder
   * </ul>
   */
  @Override
  public boolean pollChanges(
      AbstractProject project, Launcher launcher, FilePath workspace, TaskListener listener)
      throws IOException, InterruptedException {

    long start = System.currentTimeMillis();

    PrintStream log = launcher.getListener().getLogger();
    log.println("FSSCM.pollChange: " + path);

    AllowDeleteList allowDeleteList = new AllowDeleteList(project.getRootDir());
    // we will only delete a file if it is listed in the allowDeleteList
    // ie. we will only delete a file if it is copied by us
    if (allowDeleteList.fileExists()) {
      allowDeleteList.load();
    } else {
      // watch list save file doesn't exist
      // we will assuem all existing files are under watch
      // ie. everything can be deleted
      Set<String> existingFiles = workspace.act(new RemoteListDir());
      allowDeleteList.setList(existingFiles);
    }

    RemoteFolderDiff.PollChange callable = new RemoteFolderDiff.PollChange();
    setupRemoteFolderDiff(callable, project, allowDeleteList.getList());

    boolean changed = workspace.act(callable);
    String str = callable.getLog();
    if (str.length() > 0) log.println(str);
    log.println("FSSCM.pollChange return " + changed);

    log.println(
        "FSSCM.poolChange completed in " + formatDurration(System.currentTimeMillis() - start));
    return changed;
  }
Example #16
0
	public void WriteHeader(){
		out.println("\t\t"+Parser.StartingTag("ValidichroHeader"));
		out.println("\t\t\t"+Parser.Tag("Date",experiment_date));
		out.println("\t\t\t"+Parser.Tag("Generic",generic));
		//...
		out.println("\t\t"+Parser.EndingTag("ValidichroHeader"));
	}
Example #17
0
  /**
   * ********************************************************************** Prints the iniFile.
   *
   * @param ps The <code>PrintStream</code> to which to print.
   */
  public void printProps(PrintStream ps) {

    Enumeration se = getSectionList();

    if (se == null) {
      ps.println(errMsg);
    } else {

      while (se.hasMoreElements()) {

        String sname = (String) se.nextElement();

        setSection(sname);

        ps.println("[" + sname + "]");

        Enumeration pe = getPropList(sname);

        while (pe.hasMoreElements()) {

          String pair[] = (String[]) pe.nextElement();

          String prop = pair[0];

          String valu = getProperty(prop);

          ps.println("    \"" + prop + "\" = \"" + valu + "\"");
        }
      }
    }
  }
 /** Try the given mail server, writing output to the given PrintStream */
 public static void process(String suspect_relay, PrintStream pw) {
   pw.println("processs: trying: " + suspect_relay);
   try {
     // Redirect all output from mail API to the given stream.
     System.setOut(pw);
     System.setErr(pw);
     Sender2 sm = new Sender2(suspect_relay);
     sm.addRecipient("*****@*****.**");
     sm.setFrom(MY_TARGET);
     sm.setSubject("Testing for open mail relay, see " + RSS_SITE);
     sm.setBody(
         "This mail is an attempt to confirm that site "
             + suspect_relay
             + "\n"
             + "is in fact an open mail relay site.\n"
             + "For more information on the problem of open mail relays,\n"
             + "please visit site "
             + RSS_SITE
             + "\n"
             + "Please join the fight against spam by closing all open mail relays!\n"
             + "If this open relay has been closed, please accept our thanks.\n");
     sm.sendFile();
   } catch (MessagingException e) {
     pw.println(e);
   } catch (Exception e) {
     pw.println(e);
   }
 }
Example #19
0
  // rl
  // rl rotates AC left one bit, sets/resets all flags
  public static void rl() {
    out.println("rl instruction");
    // RL1 rotates AC left one bit, sets/resets the flags
    // if AC is negative, carry bit will be true
    if ((byte) AC < 0) {
      flag[1] = true;
    } else {
      flag[1] = false;
    }
    // setting overflow flag
    // if it changes sign, overflow
    if ((byte) (0xFF & AC) > 0 && (byte) ((0xFF & AC) << 1) < 0) {
      flag[2] = true;
    } else if ((byte) (0xFF & AC) < 0 && (byte) ((0xFF & AC) << 1) > 0) {
      flag[2] = true;
    } else {
      flag[2] = false;
    }
    AC += -(0xFF & AC) + (0xFF & AC << 1);
    // if there is a carried bit, set the LSB to 1
    if (flag[1]) {
      AC++;
    }
    // set the remaining flags
    setFlagsRotS();

    out.print("rl1 AC = " + (byte) (0xFF & AC));
    printzcvn();
  }
Example #20
0
  /**
   * Prints the given map with nice line breaks.
   *
   * @param out the stream to print to
   * @param key the key that maps to the map in some other map
   * @param map the map to print
   */
  public static synchronized void debugPrint(PrintStream out, Object key, Map map) {
    debugPrintIndent(out);
    out.println(key + " = ");

    debugPrintIndent(out);
    out.println("{");
    ++debugIndent;

    for (Iterator iter = map.entrySet().iterator(); iter.hasNext(); ) {
      Map.Entry entry = (Map.Entry) iter.next();
      String childKey = (String) entry.getKey();
      Object childValue = entry.getValue();
      if (childValue instanceof Map) {
        verbosePrint(out, childKey, (Map) childValue);
      } else {
        debugPrintIndent(out);

        String typeName = (childValue != null) ? childValue.getClass().getName() : null;

        out.println(childKey + " = " + childValue + " class: " + typeName);
      }
    }
    --debugIndent;
    debugPrintIndent(out);
    out.println("}");
  }
Example #21
0
 // inac
 // inac increments the accumulator
 public static void inac() {
   out.println("inac instruction");
   // INAC1 increment the value in AC by 1, setting/resetting flags
   // as appropriate
   if (((byte) (AC) < 0) && ((byte) (AC + 1) >= 0)) {
     flag[1] = true;
   } else {
     flag[1] = false;
   }
   if ((byte) (AC) == 127) {
     flag[2] = true;
   } else {
     flag[2] = false;
   }
   if ((byte) (AC) == -1) {
     AC -= 0xFF & AC;
   } else {
     AC++;
   }
   // set other flags
   if ((byte) AC == 0) {
     flag[0] = true;
   } else {
     flag[0] = false;
   }
   if ((byte) AC < 0) {
     flag[3] = true;
   } else {
     flag[3] = false;
   }
   out.print("inac1 AC = " + (byte) (0xFF & AC));
   printzcvn();
 }
Example #22
0
  // jumper
  // jumper carries out the jump instruction for the conditional jumps
  public static void jumper(String op) {
    // JUMP1 read the high order half of the address into DR
    DR = readMemory(AR);
    PC++;
    AR++;
    out.println(
        op
            + "1 AR = "
            + ((int) 0xFFFF & AR)
            + " PC = "
            + ((int) 0xFFFF & PC)
            + " DR = "
            + ((int) 0xFF & DR));

    // JUMP2 save the contents of DR
    TR = DR;
    DR = readMemory(AR);
    PC++;
    out.println(
        op
            + "2 AR = "
            + ((int) 0xFFFF & AR)
            + " PC = "
            + ((int) 0xFFFF & PC)
            + " DR = "
            + ((int) 0xFF & DR)
            + " TR = "
            + ((int) 0xFF & TR));

    // JUMP3 form the address from TR and DR and place it in PC

    PC = (short) (((0xFF & TR) * 256) + (0xFF & DR));
    out.println(op + "3 PC = " + ((int) 0xFFFF & AR));
  }
Example #23
0
  public static void xlsr() {
    out.println("xlsr instruction");
    // LSR1 shifts AC right one bit, sets/resets all flags
    if ((short) AC < 0) {
      if (((short) AC * -1) % 2 == 1) {
        flag[1] = true;
      } else {
        flag[1] = false;
      }
    } else if ((short) AC % 2 == 1) {
      flag[1] = true;
    } else {
      flag[1] = false;
    }
    int conv;
    conv = AC & 0xFFFF;
    conv >>>= 1;
    // setting overflow flag
    // if it changes sign, overflow
    if ((short) (0xFFFF & AC) > 0 && (short) conv < 0) {
      flag[2] = true;
    } else if ((short) (0xFFFF & AC) < 0 && (short) conv > 0) {
      flag[2] = true;
    } else {
      flag[2] = false;
    }
    AC += -(0xFFFF & AC) + conv;

    // set the flags
    setFlagsXRotS();
    out.print("xlsr1 AC = " + AC);
    printzcvn();
  }
Example #24
0
  @Override
  public boolean checkout(
      AbstractBuild build,
      Launcher launcher,
      FilePath workspace,
      BuildListener listener,
      File changelogFile)
      throws IOException, InterruptedException {

    long start = System.currentTimeMillis();
    PrintStream log = launcher.getListener().getLogger();
    log.println("FSSCM.checkout " + path + " to " + workspace);
    Boolean b = Boolean.TRUE;

    AllowDeleteList allowDeleteList = new AllowDeleteList(build.getProject().getRootDir());

    if (clearWorkspace) {
      log.println("FSSCM.clearWorkspace...");
      workspace.deleteRecursive();
    }

    // we will only delete a file if it is listed in the allowDeleteList
    // ie. we will only delete a file if it is copied by us
    if (allowDeleteList.fileExists()) {
      allowDeleteList.load();
    } else {
      // watch list save file doesn't exist
      // we will assuem all existing files are under watch
      // ie. everything can be deleted
      Set<String> existingFiles = workspace.act(new RemoteListDir());
      allowDeleteList.setList(existingFiles);
    }

    RemoteFolderDiff.CheckOut callable = new RemoteFolderDiff.CheckOut();
    setupRemoteFolderDiff(callable, build.getProject(), allowDeleteList.getList());
    List<FolderDiff.Entry> list = workspace.act(callable);

    // maintain the watch list
    for (FolderDiff.Entry entry : list) {
      if (FolderDiff.Entry.Type.DELETED.equals(entry.getType())) {
        allowDeleteList.remove(entry.getFilename());
      } else {
        // added or modified
        allowDeleteList.add(entry.getFilename());
      }
    }
    allowDeleteList.save();

    // raw log
    String str = callable.getLog();
    if (str.length() > 0) log.println(str);

    ChangelogSet.XMLSerializer handler = new ChangelogSet.XMLSerializer();
    ChangelogSet changeLogSet = new ChangelogSet(build, list);
    handler.save(changeLogSet, changelogFile);

    log.println("FSSCM.check completed in " + formatDurration(System.currentTimeMillis() - start));
    return b;
  }
Example #25
0
 public static void writeLinesToFile(File file, List<?> lines) throws Exception {
   PrintStream output = new PrintStream(new FileOutputStream(file));
   for (Iterator<?> iterator = lines.iterator(); iterator.hasNext(); ) {
     String line = (String) iterator.next();
     output.println(line);
   }
   output.close();
 }
Example #26
0
 /**
  * Generates XML description of the OD.<br>
  * If the print stream is specified, then XML buffer is written to the stream.
  *
  * @param out print stream.
  * @throws IOException
  */
 public void xmlDump(PrintStream out) throws IOException {
   if (out == null) out = System.out;
   out.print("<od begin=\"" + origin.getId() + "\" end=\"" + destination.getId() + "\">\n");
   out.print("<PathList>\n");
   for (int i = 0; i < pathList.size(); i++) pathList.get(i).xmlDump(out);
   out.print("</PathList>\n</od>\n");
   return;
 }
 private static void outputProbes(Iterator<ProbeLine> lines, File f) throws IOException {
   PrintStream ps = new PrintStream(new FileOutputStream(f));
   while (lines.hasNext()) {
     ProbeLine line = lines.next();
     ps.println(line.toString());
   }
   ps.close();
 }
Example #28
0
	public void WriteExported(){
		out.println(Parser.getFileHeader());
		out.println("\t"+Parser.StartingTag("ValidichroData"));
		WriteHeader();
		WriteBody();
		WriteUnparsed();
		out.println("\t"+Parser.EndingTag("ValidichroData"));
	}
Example #29
0
  public void Print(PrintStream outfile) {

    outfile.printf(weocode + " " + countryname + " " + currency + " " + scale + " ");

    for (Double b : gdplist) outfile.printf(b + " ");

    outfile.println("Average GDP = " + average + " Standard Deviation = " + stdev);
  }
Example #30
0
  // add
  // add adds the value in R with AC, and places the value in AC
  public static void add() {
    out.println("add instruction");
    // ADD1 adds R into AC, and sets the flags as appropriate
    add1();

    out.print("add1 AC = " + (byte) (0xFF & AC) + " R = " + (byte) (0xFF & R));
    printzcvn();
  }