GP-5891: Include Debugger javadocs in the build.

Ghidra/Debug/Debugger-api/build.gradle

@@ -4,9 +4,9 @@
  * 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.
@@ -18,6 +18,7 @@ apply from: "${rootProject.projectDir}/gradle/javaProject.gradle"
 apply from: "${rootProject.projectDir}/gradle/jacocoProject.gradle"
 apply from: "${rootProject.projectDir}/gradle/javaTestProject.gradle"
 apply from: "${rootProject.projectDir}/gradle/distributableGhidraModule.gradle"
+apply from: "${rootProject.projectDir}/gradle/javadoc.gradle"
 
 apply plugin: 'eclipse'
 eclipse.project.name = 'Debug Debugger-api'

Ghidra/Debug/Debugger-api/src/main/java/ghidra/app/services/DebuggerPlatformService.java

@@ -38,8 +38,8 @@ public interface DebuggerPlatformService {
 	 * <p>
 	 * If the trace's current mapper is applicable to the object, it will be returned. Otherwise,
 	 * the service will query the opinions for a new mapper, as in
-	 * {@link #getNewMapper(TraceObject)} and set it as the current mapper before returning. If a
-	 * new mapper is set, the trace is also initialized for that mapper.
+	 * {@link #getNewMapper(Trace, TraceObject, long)} and set it as the current mapper before
+	 * returning. If a new mapper is set, the trace is also initialized for that mapper.
 	 * 
 	 * @param trace the trace
 	 * @param object the object for which a mapper is desired

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/emulation/DebuggerPcodeEmulatorFactory.java

@@ -4,9 +4,9 @@
  * 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.
@@ -22,10 +22,6 @@ import ghidra.util.classfinder.ExtensionPoint;
 
 /**
  * A factory for configuring and creating a Debugger-integrated emulator
- *
- * <p>
- * See {@link BytesDebuggerPcodeEmulatorFactory} for the default implementation. See the Taint
- * Analyzer for the archetype of alternative implementations.
  */
 public interface DebuggerPcodeEmulatorFactory extends ExtensionPoint {
 	// TODO: Config options, use ModelFactory as a model

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/emulation/DebuggerPcodeMachine.java

@@ -4,9 +4,9 @@
  * 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.
@@ -20,10 +20,6 @@ import ghidra.pcode.exec.trace.TracePcodeMachine;
 /**
  * A Debugger-integrated emulator (or p-code machine)
  *
- * <p>
- * A common implementation is an emulator with concrete plus some auxiliary state. To realize such a
- * machine, please see {@link AuxDebuggerPcodeEmulator} and {@link AuxDebuggerEmulatorPartsFactory}.
- *
  * @param <T> the type of values in the machine's memory and registers
  */
 public interface DebuggerPcodeMachine<T> extends TracePcodeMachine<T> {

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/emulation/PcodeDebuggerAccess.java

@@ -4,9 +4,9 @@
  * 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.
@@ -26,8 +26,7 @@ import ghidra.trace.model.thread.TraceThread;
  * In addition to the trace "coordinates" encapsulated by {@link PcodeTraceAccess}, this
  * encapsulates the tool controlling a session and the session's target. This permits p-code
  * executor/emulator states to access target data and to access session data, e.g., data from mapped
- * static images. It supports the same method chain pattern as {@link PcodeTraceAccess}, but
- * starting with {@link DefaultPcodeDebuggerAccess}.
+ * static images. It supports the same method chain pattern as {@link PcodeTraceAccess}.
  */
 public interface PcodeDebuggerAccess extends PcodeTraceAccess {
 	@Override

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/target/Target.java

@@ -519,8 +519,10 @@ public interface Target {
 	 * be recorded into the trace <em>before</em> this method returns. If the request is
 	 * unsuccessful, this method throw an exception.
 	 * 
-	 * @param address the starting address
-	 * @param data the bytes to write
+	 * @param platform the platform whose language defines the registers
+	 * @param thread the thread whose register to write
+	 * @param frame the frame level, usually 0.
+	 * @param value the register and value to write
 	 */
 	void writeRegister(TracePlatform platform, TraceThread thread, int frame, RegisterValue value);
 
@@ -548,7 +550,7 @@ public interface Target {
 	 * @param thread if a register, the thread whose registers to examine
 	 * @param frame the frame level, usually 0.
 	 * @param address the address of the variable
-	 * @param size the size of the variable. Ignored for memory
+	 * @param length the size of the variable. Ignored for memory
 	 * @return true if the variable can be mapped to the target
 	 */
 	boolean isVariableExists(TracePlatform platform, TraceThread thread, int frame, Address address,
@@ -558,8 +560,7 @@ public interface Target {
 	 * @see #writeVariable(TracePlatform, TraceThread, int, Address, byte[])
 	 */
 	CompletableFuture<Void> writeVariableAsync(TracePlatform platform, TraceThread thread,
-			int frame,
-			Address address, byte[] data);
+			int frame, Address address, byte[] data);
 
 	/**
 	 * Write a variable (memory or register) of the given thread or the process
@@ -571,7 +572,7 @@ public interface Target {
 	 * {@link #writeMemory(Address, byte[])}.
 	 * 
 	 * @param thread the thread. Ignored (may be null) if address is in memory
-	 * @param frameLevel the frame, usually 0. Ignored if address is in memory
+	 * @param frame the frame, usually 0. Ignored if address is in memory
 	 * @param address the starting address
 	 * @param data the value to write
 	 */
@@ -665,7 +666,8 @@ public interface Target {
 	 * This will first attempt to kill the target gracefully. In addition, and whether or not the
 	 * target is successfully terminated, the target will be dissociated from its trace, and the
 	 * target will be invalidated. To attempt only a graceful termination, check
-	 * {@link #collectActions(ActionName, ActionContext)} with {@link ActionName#KILL}.
+	 * {@link #collectActions(ActionName, ActionContext, ObjectArgumentPolicy)} with
+	 * {@link ActionName#KILL}.
 	 */
 	void forceTerminate();
 

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/tracermi/RemoteMethod.java

@@ -117,7 +117,7 @@ public interface RemoteMethod {
 	 * Check the type of an argument.
 	 * 
 	 * <p>
-	 * This is a hack, because {@link TraceObjectSchema} expects {@link TargetObject}, or a
+	 * This is a hack, because {@link TraceObjectSchema} expects {@link TraceObject}, or a
 	 * primitive. We instead need {@link TraceObject}. I'd add the method to the schema, except that
 	 * trace stuff is not in its dependencies.
 	 * 

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/tracermi/TraceRmiAcceptor.java

@@ -4,9 +4,9 @@
  * 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.
@@ -34,6 +34,7 @@ public interface TraceRmiAcceptor {
 	 * 
 	 * @return the connection, if successful
 	 * @throws IOException if there was an error
+	 * @throws CancelledException if {@link #cancel()} is called, usually from the user canceling
 	 */
 	TraceRmiConnection accept() throws IOException, CancelledException;
 
@@ -64,8 +65,8 @@ public interface TraceRmiAcceptor {
 	 * 
 	 * <p>
 	 * If a different thread has called {@link #accept()}, it will fail. In this case, both
-	 * {@linkplain TraceRmiServiceListener#acceptCancelled(TraceRmiAcceptor)} and
-	 * {@linkplain TraceRmiServiceListener#acceptFailed(Exception)} may be invoked.
+	 * {@link TraceRmiServiceListener#acceptCancelled(TraceRmiAcceptor)} and
+	 * {@link TraceRmiServiceListener#acceptFailed(TraceRmiAcceptor, Exception)} may be invoked.
 	 */
 	void cancel();
 }

Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/tracermi/TraceRmiServiceListener.java

@@ -86,8 +86,9 @@ public interface TraceRmiServiceListener {
 	 * 
 	 * <p>
 	 * The acceptor remains valid until one of three events occurs:
-	 * {@linkplain} #connected(TraceRmiConnection, ConnectMode, TraceRmiAcceptor)},
-	 * {@linkplain} #acceptCancelled(TraceRmiAcceptor)}, or {@linkplain} #acceptFailed(Exception)}.
+	 * {@link #connected(TraceRmiConnection, ConnectMode, TraceRmiAcceptor)},
+	 * {@link #acceptCancelled(TraceRmiAcceptor)}, or
+	 * {@link #acceptFailed(TraceRmiAcceptor, Exception)}.
 	 * 
 	 * @param acceptor the acceptor waiting
 	 */