Nixyri/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2024-11-24 05:02:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

GP-0: Fixing some javadoc

Browse Source
This commit is contained in:
Ryan Kurtz 2024-09-03 12:57:52 -04:00
parent 8577082976
commit 4eefa887fb
88 changed files with 671 additions and 653 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Ghidra/Features/Base/src/main/java/ghidra/app/cmd/label/CreateNamespacesCmd.java
View File

@ -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.
@ -30,8 +30,8 @@ import ghidra.util.exception.InvalidInputException;
* <a id="examples"></a>
* Example strings:
* <ul>
* <li>global{@link Namespace#DELIMITER ::}child1{@link Namespace#DELIMITER ::}child2
* <li>child1
* <li>global{@link Namespace#DELIMITER ::}child1{@link Namespace#DELIMITER ::}child2</li>
* <li>child1</li>
* </ul>
* <p>
* <a id="assumptions"></a>

14
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/ProgramPlugin.java
View File

@ -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,11 +34,11 @@ import ghidra.program.util.ProgramSelection;
* Subclasses should override the following methods if they are interested in the corresponding
* events:
* <ul>
* <LI> {@link #programOpened(Program)}
* <LI> {@link #programClosed(Program)}
* <LI> {@link #locationChanged(ProgramLocation)}
* <LI> {@link #selectionChanged(ProgramSelection)}
* <LI> {@link #highlightChanged(ProgramSelection)}
* <LI> {@link #programOpened(Program)}</LI>
* <LI> {@link #programClosed(Program)}</LI>
* <LI> {@link #locationChanged(ProgramLocation)}</LI>
* <LI> {@link #selectionChanged(ProgramSelection)}</LI>
* <LI> {@link #highlightChanged(ProgramSelection)}</LI>
* </ul>
*/
public abstract class ProgramPlugin extends Plugin {

8
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/GolangStringAnalyzer.java
View File

@ -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.
@ -50,8 +50,8 @@ import ghidra.util.task.UnknownProgressWrappingTaskMonitor;
* <p>
* The string struct is found in a couple of different ways:
* <ul>
* <li>References from an instruction (see markupStaticStructRefsInFunction)
* <li>Iterating through data segments and making educated guesses (see markupDataSegmentStructs)
* <li>References from an instruction (see markupStaticStructRefsInFunction)</li>
* <li>Iterating through data segments and making educated guesses (see markupDataSegmentStructs)</li>
* </ul>
* Some char[] data is only referenced from Golang string structs that exist temporarily
* in registers after being set by an instruction that statically references the char[] data,

20
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/console/CodeCompletion.java
View File

@ -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.
@ -23,20 +23,20 @@ import javax.swing.JComponent;
* It is intended to be used by the code completion process, especially the
* CodeCompletionWindow. It encapsulates:
* <ul>
* <li> a description of the completion (what are you completing?)
* <li> the actual String that will be inserted
* <li> an optional Component that will be in the completion List
* <li> the number of characters to remove before the insertion of the completion
* <li> a description of the completion (what are you completing?)</li>
* <li> the actual String that will be inserted</li>
* <li> an optional Component that will be in the completion List</li>
* <li> the number of characters to remove before the insertion of the completion</li>
* </ul>
* <p>
* For example, if one wants to autocomplete a string "Runscr" into "runScript",
* the fields may look as follows:
* <ul>
* <li> description: "runScript (Method)"
* <li> insertion: "runScript"
* <li> component: null or JLabel("runScript (Method)")
* <li> description: "runScript (Method)"</li>
* <li> insertion: "runScript"</li>
* <li> component: null or JLabel("runScript (Method)")</li>
* <li> charsToRemove: 6 (i.e. the length of "Runscr",
* as it may be required later to correctly replace the string)
* as it may be required later to correctly replace the string)</li>
* </ul>
*/
public class CodeCompletion implements Comparable<CodeCompletion> {

8
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/cparser/ParseDialog.java
View File

@ -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.
@ -58,9 +58,9 @@ import resources.Icons;
* Dialog that shows files used for parsing C header files. The profile has a list of source header
* files to parse, followed by parse options (compiler directives). Ghidra supplies a Windows
* profile by default in core/parserprofiles. The user can do "save as" on this default profile to
* create new profiles that will be written to the user's <home>/userprofiles directory. The
* create new profiles that will be written to the user's {@code <home>/userprofiles} directory. The
* CParserPlugin creates this directory if it doesn't exist.
*
* <p>
* The data types resulting from the parse operation can either be added to the data type manager in
* the current program, or written to an archive data file.
*

10
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/function/tags/FunctionTagTable.java
View File

@ -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.
@ -79,8 +79,10 @@ public class FunctionTagTable extends GhidraTable {
/**
* We need to override the renderer for the following cases:
* <li>italicize tags that cannot be edited</li>
* <li>disable rows in the source table that have already been added to the selected function </li>
* <ul>
* <li>italicize tags that cannot be edited</li>
* <li>disable rows in the source table that have already been added to the selected function </li>
* </ul>
*/
@Override
public TableCellRenderer getCellRenderer(int row, int col) {

10
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/instructionsearch/ui/InsertBytesWidget.java
View File

@ -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.
@ -398,8 +398,10 @@ public class InsertBytesWidget extends ReusableDialogComponentProvider implement
/**
* Verifies that the input entered by the user is valid. Meaning:
* <li>The string represents a hex or binary number.</li>
* <li>The string contains only full bytes.</li>
* <ul>
* <li>The string represents a hex or binary number.</li>
* <li>The string contains only full bytes.</li>
* </ul>
*
* @return true if input is valid
*/

18
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/navigation/NextPrevCodeUnitPlugin.java
View File

@ -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.
@ -40,13 +40,13 @@ import resources.Icons;
* The NextPrevCodeUnitPlugin generates a GoTo event based on where the cursor
* is located in the program. The GoTo events provided by this plugin are:
* <UL>
* <LI>Next-Previous Instruction
* <LI>Next-Previous Defined Data
* <LI>Next-Previous Undefined Data
* <LI>Next-Previous Function
* <LI>Next-Previous Non-Function
* <LI>Next-Previous Label
* <LI>Next-Previous Bookmark
* <LI>Next-Previous Instruction</LI>
* <LI>Next-Previous Defined Data</LI>
* <LI>Next-Previous Undefined Data</LI>
* <LI>Next-Previous Function</LI>
* <LI>Next-Previous Non-Function</LI>
* <LI>Next-Previous Label</LI>
* <LI>Next-Previous Bookmark</LI>
* </UL>
*/
//@formatter:off

6
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/osgi/BundleHost.java
View File

@ -49,11 +49,11 @@ import utilities.util.FileUtilities;
* Note: {@link GhidraBundle}, its implementations, and this class constitute a bridge between
* OSGi's {@link Bundle} and Ghidra.
* <ul>
* <li> unqualified, "bundle" will mean {@link GhidraBundle}
* <li> unqualified, "bundle" will mean {@link GhidraBundle}</li>
* <li> use of OSGi types, including {@link Bundle} and {@link Framework}, should be package scoped
* (not public)
* (not public) </li>
* <li> bundle lifecycle is simplified to "active"(same as OSGi "active" state) and "inactive"
* (OSGi "uninstalled" state)
* (OSGi "uninstalled" state)</li>
* </ul>
*/
public class BundleHost {

8
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/scalartable/RangeFilterTextField.java
View File

@ -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.
@ -25,8 +25,8 @@ import ghidra.program.model.listing.Program;
* <p>
* Specifically this provides the following:
* <ul>
* <li>Ability to specify if this is a min/max range field
* <li>Allows hex input of the form "0x...." for hex values
* <li>Ability to specify if this is a min/max range field</li>
* <li>Allows hex input of the form "0x...." for hex values</li>
* </ul>
*/
public class RangeFilterTextField extends IntegerTextField {

8
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/scalartable/ScalarSearchProvider.java
View File

@ -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.
@ -42,8 +42,8 @@ import help.HelpService;
/**
* Displays the results of a query from the {@link ScalarSearchPlugin}. Consists of 2 components:
* <ul>
* <li>The scalar table that is displayed to the user
* <li>The range filter that allows the user to filter the scalar table via a min and max value.
* <li>The scalar table that is displayed to the user</li>
* <li>The range filter that allows the user to filter the scalar table via a min and max value.</li>
* </ul>
*/
public class ScalarSearchProvider extends ComponentProviderAdapter {

12
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/string/DefinedStringIterator.java
View File

@ -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.
@ -15,7 +15,7 @@
*/
package ghidra.app.plugin.core.string;
import static ghidra.program.util.string.FoundString.DefinedState.DEFINED;
import static ghidra.program.util.string.FoundString.DefinedState.*;
import java.util.Iterator;
@ -31,9 +31,9 @@ import ghidra.program.util.string.FoundString;
* Basic Algorithm: Uses a defined data iterator to find all defined data in a program. For
* each defined data, strings are searched as follows:
* <ol>
* <li> is it a string? if so, add to the queue of results
* <li> is it an array? if so, are they non-primitive elements? if so, recursively search them for strings.
* <li> is it a composite (structure or union)? if so, recursively search each element of the structure.
* <li> is it a string? if so, add to the queue of results</li>
* <li> is it an array? if so, are they non-primitive elements? if so, recursively search them for strings.</li>
* <li> is it a composite (structure or union)? if so, recursively search each element of the structure.</li>
* </ol>
* <p>
* This class maintains a queue of all strings found at any given top-level data element. When

10
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/terminal/vt/VtHandler.java
View File

@ -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.
@ -62,17 +62,17 @@ import ghidra.util.Msg;
* <td>{@code "\033["}</td>
* </tr>
* <tr>
* <td>{@code OSC}
* <td>{@code OSC}</td>
* <td>{@code ESC ]}</td>
* <td>{@code "\033]"}</td>
* </tr>
* <tr>
* <td>{@code ST}
* <td>{@code ST}</td>
* <td>{@code ESC \}</td>
* <td>{@code "\033\\"}</td>
* </tr>
* <tr>
* <td>{@code BEL}
* <td>{@code BEL}</td>
* <td>byte 0x07</td>
* <td>{@code "\007"}</td>
* </tr>

11
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/exceptionhandlers/gcc/structures/gccexcepttable/LSDATable.java
View File

@ -1,13 +1,12 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* 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.
@ -38,10 +37,10 @@ import ghidra.util.task.TaskMonitor;
* The LSDA is comprised of:
* <ul>
* <li>A header that describes the bounds of exception handling support and encoding
* modes for values found later in the LSDA table
* modes for values found later in the LSDA table</li>
* <li>A call site table that describes each location a 'throws' occurs and where
* a corresponding catch block resides, and the actions to take.
* <li>An action table, that describes what the runtime needs to do during unwind
* a corresponding catch block resides, and the actions to take.</li>
* <li>An action table, that describes what the runtime needs to do during unwind</li>
* </ul>
* <p>
* The structures modeled here are described in detail in the C++ ABI.

10
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/dwarf/DWARFDataTypeConflictHandler.java
View File

@ -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.
@ -39,16 +39,16 @@ import ghidra.util.SystemUtilities;
* <p>
* <ul>
* <li>discarded and replaced by the existing data type
* ({@link ConflictResult#USE_EXISTING})
* ({@link ConflictResult#USE_EXISTING})</li>
* <li>used to overwrite the existing data type
* ({@link ConflictResult#REPLACE_EXISTING})
* ({@link ConflictResult#REPLACE_EXISTING})</li>
* </ul>
* or the candidate data type was <b>NOT</b> matched with an existing data type,
* and the new data type is:
* <p>
* <ul>
* <li>kept, but renamed with a .conflictNNNN suffix to make it unique
* ({@link ConflictResult#RENAME_AND_ADD})
* ({@link ConflictResult#RENAME_AND_ADD})</li>
* </ul>
* <b>NOTE:</b> structures with alignment (instead of being statically laid out)
* are not treated specially and will not match other aligned or non-aligned

15
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/info/StandardElfInfoProducer.java
View File

@ -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.
@ -31,7 +31,6 @@ import ghidra.program.model.listing.Program;
import ghidra.program.model.mem.Memory;
import ghidra.program.model.mem.MemoryBlock;
import ghidra.program.model.util.CodeUnitInsertionException;
import ghidra.util.Msg;
import ghidra.util.classfinder.ExtensionPointProperties;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -39,11 +38,11 @@ import ghidra.util.task.TaskMonitor;
/**
* Handles marking up and program info for basic ELF note (and note-like) sections.
* <ul>
* <li>NoteAbiTag
* <li>NoteGnuBuildId
* <li>NoteGnuProperty
* <li>GnuDebugLink (not a note)
* <li>ElfComment (not a note)
* <li>NoteAbiTag</li>
* <li>NoteGnuBuildId</li>
* <li>NoteGnuProperty</li>
* <li>GnuDebugLink (not a note)</li>
* <li>ElfComment (not a note)</li>
* </ul>
* <p>
* Runs after other ElfInfoProducers that have a normal priority.

10
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/golang/GoFunctionMultiReturn.java
View File

@ -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.
@ -30,10 +30,10 @@ import ghidra.program.model.lang.Register;
* <p>
* Assigning custom storage for the return value is complicated by:
* <ul>
* <li>golang storage allocations depend on the formal ordering of the return values
* <li>stack storage must be last in a list of varnodes
* <li>golang storage allocations depend on the formal ordering of the return values</li>
* <li>stack storage must be last in a list of varnodes</li>
* <li>the decompiler maps a structure's contents to the list of varnodes in an endian-dependent
* manner.
* manner.</li>
* </ul>
* To meet these complications, the structure's layout is modified to put all items that were
* marked as being stack parameters to either the front or back of the structure.

23
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/golang/GolangElfInfoProducer.java
View File

@ -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.
@ -28,16 +28,17 @@ import ghidra.util.task.TaskMonitor;
/**
* Handles marking up and program info for Golang binaries.
* <p>
* <ul>
* <li>NoteGoBuildId
* <li>GoBuildInfo
* <ul>
* <li>Go version
* <li>App path, main package
* <li>Module dependency list
* <li>Build settings / flags
* </ul>
* <li>NoteGoBuildId</li>
* <li>GoBuildInfo</li>
* <li>
* <ul>
* <li>Go version</li>
* <li>App path, main package</li>
* <li>Module dependency list</li>
* <li>Build settings / flags</li>
* </ul>
* </li>
* </ul>
*/
public class GolangElfInfoProducer implements ElfInfoProducer {

8
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/golang/rtti/GoFuncData.java
View File

@ -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.
@ -225,8 +225,8 @@ public class GoFuncData implements StructureMarkup<GoFuncData> {
* <p>
* The information that can be recovered about arguments is limited to:
* <ul>
* <li>the size of the argument
* <li>general grouping (eg. grouping of arg values as a structure or array)
* <li>the size of the argument</li>
* <li>general grouping (eg. grouping of arg values as a structure or array)</li>
* </ul>
* Return value information is unknown and always represented as an "undefined" data type.
*

30
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/golang/rtti/GoRttiMapper.java
View File

@ -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.
@ -58,22 +58,26 @@ import ghidra.util.task.UnknownProgressWrappingTaskMonitor;
* <li>Find the GoBuildInfo struct. This struct is the easiest to locate, even when the binary
* is stripped. This gives us the go pointerSize (probably same as ghidra pointer size) and the
* goVersion. This struct does not rely on StructureMapping, allowing its use before a
* DataTypeMapper is created.
* <li>Create DataTypeMapper
* <li>Find the runtime.firstmoduledata structure.
* <ul>
* <li>If there are symbols, just use the symbol or named memory block.
* <li>If stripped:
* DataTypeMapper is created.</li>
* <li>Create DataTypeMapper</li>
* <li>Find the runtime.firstmoduledata structure.</li>
* <li>
* <ul>
* <li>If there are symbols, just use the symbol or named memory block.</li>
* <li>If stripped:</li>
* <li>
* <ul>
* <li>Find the pclntab. This has a magic signature, a pointerSize, and references
* to a couple of tables that are also referenced in the moduledata structure.
* to a couple of tables that are also referenced in the moduledata structure.</li>
* <li>Search memory for a pointer to the pclntab struct. This should be the first
* field of the moduledata structure. The values that are duplicated between the
* two structures can be compared to ensure validity.
* two structures can be compared to ensure validity.</li>
* <li>Different binary formats (Elf vs PE) will determine which memory blocks to
* search.
* </ul>
* </ul>
* search.</li>
* </ul>
* </li>
* </ul>
* </li>
* </ul>
*/
public class GoRttiMapper extends DataTypeMapper implements DataTypeMapperContext {

6
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/macho/MachHeader.java
View File

@ -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.
@ -196,7 +196,7 @@ public class MachHeader implements StructConverter {
/**
* Parses only this {@link MachHeader}'s {@link SegmentCommand segments}
*
* @return A {@List} of this {@link MachHeader}'s {@link SegmentCommand segments}
* @return A {@link List} of this {@link MachHeader}'s {@link SegmentCommand segments}
* @throws IOException If there was an IO-related error
*/
public List<SegmentCommand> parseSegments() throws IOException {

30
Ghidra/Features/Base/src/main/java/ghidra/app/util/cparser/C/CParserUtils.java
View File

@ -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.
@ -260,7 +260,7 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param args arguments for parsing, "-D<defn>=", "-I<includepath>"
* @param args arguments for parsing, {@code -D<defn>=, -I<includepath>}
*
* @param dataFileName name of data type archive file (include the .gdt extension)
*
@ -297,8 +297,9 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param includePaths paths to include files, instead of using "-I<includepath>" in args
* @param args arguments for parsing, "-D<defn>=", ( "-I<includepath>" use includePaths parm instead)
* @param includePaths paths to include files, instead of using {@code -I<includepath>} in args
* @param args arguments for parsing, {@code -D<defn>=}, ( {@code -I<includepath>} use
* includePaths parm instead)
*
* @param dataFileName name of data type archive file (include the .gdt extension)
*
@ -338,8 +339,8 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param includePaths path to include files, could also be in args with "-I<includepath>"
* @param args arguments for parsing, "-D<defn>=", "-I<includepath>"
* @param includePaths path to include files, could also be in args with {@code -I<includepath>}
* @param args arguments for parsing, {@code -D<defn>=, -I<includepath>}
*
* @param dataFileName name of data type archive file (include the .gdt extension)
*
@ -391,11 +392,12 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param args arguments for parsing, "-D<defn>=", ( "-I<includepath>" use includePaths parm instead)
* @param args arguments for parsing, {@code -D<defn>=}, ({@code -I<includepath>} use
* includePaths parm instead)
*
* @param existingDTMgr datatypes will be populated into this provided DTMgr, can pass Program or File DTMgr
*
* @param languageId language identication to use for data type organization definitions (int, long, ptr size)
* @param languageId language identification to use for data type organization definitions (int, long, ptr size)
* @param compileSpecId compiler specification to use for parsing
*
* @param monitor used to cancel or provide results
@ -431,12 +433,12 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param includePaths paths to include files, instead of using "-I<includepath>" in args
* @param args arguments for parsing, "-D<defn>=", ( "-I<includepath>" use includePaths parm instead)
* @param includePaths paths to include files, instead of using {@code -I<includepath>} in args
* @param args arguments for parsing, {@code -D<defn>=}, ( {@code -I<includepath>} use includePaths parm instead)
*
* @param existingDTMgr datatypes will be populated into this provided DTMgr, can pass Program or File DTMgr
*
* @param languageId language identication to use for data type organization definitions (int, long, ptr size)
* @param languageId language identification to use for data type organization definitions (int, long, ptr size)
* @param compileSpecId compiler specification to use for parsing
*
* @param monitor used to cancel or provide results
@ -508,8 +510,8 @@ public class CParserUtils {
*
* @param filenames names of files in order to parse, could include strings with
* "#" at start, which are ignored as comments
* @param includePaths paths to include files, instead of using "-I<includepath>" in args
* @param args arguments for parsing, "-D<defn>=", ( "-I<includepath>" use includePaths parm instead)
* @param includePaths paths to include files, instead of using {@code -I<includepath>} in args
* @param args arguments for parsing, {@code -D<defn>=}, ( {@code -I<includepath>} use includePaths parm instead)
*
* @param dtMgr datatypes will be populated into this provided DTMgr, can pass Program or File DTMgr
*

10
Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/BoundedBufferedReader.java
View File

@ -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.
@ -200,13 +200,13 @@ public class BoundedBufferedReader extends Reader {
* true:
* <ul>
*
* <li>The specified number of characters have been read,
* <li>The specified number of characters have been read,</li>
*
* <li>The <code>read</code> method of the underlying stream returns
* <code>-1</code>, indicating end-of-file, or
* <code>-1</code>, indicating end-of-file, or</li>
*
* <li>The <code>ready</code> method of the underlying stream returns
* <code>false</code>, indicating that further input requests would block.
* <code>false</code>, indicating that further input requests would block.</li>
*
* </ul>
* If the first <code>read</code> on the underlying stream returns

16
Ghidra/Features/Base/src/main/java/ghidra/formats/gfilesystem/FSRL.java
View File

@ -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.
@ -39,13 +39,13 @@ import ghidra.util.SystemUtilities;
* <p>
* Examples (pipes shown in red since they are hard to see):
* <ul>
* <li><b>file://dir/subdir</b> -- simplest example, locates a file on local computer filesystem.
* <li><b>file://dir/subdir/example.zip<span style="color:red">|</span>zip://readme.txt</b> -- points to a file named "readme.txt" in a zip file.
* <li><b>file://dir/subdir/example.zip<span style="color:red">|</span>zip://dir/nested.tar<span style="color:red">|</span>tar://file.txt</b> -- points to
* a file inside a TAR archive, which is inside a ZIP archive, which is on the local filesystem.
* <li><b>file://dir/subdir/example.zip?MD5=1234567<span style="color:red">|</span>zip://readme.txt?MD5=987654</b> --
* <li><b>file://dir/subdir</b> -- simplest example, locates a file on local computer filesystem.</li>
* <li><b>file://dir/subdir/example.zip</b><span style="color:red;font-weight:bold;">|</span><b>zip://readme.txt</b> -- points to a file named "readme.txt" in a zip file.</li>
* <li><b>file://dir/subdir/example.zip</b><span style="color:red;font-weight:bold;">|</span><b>zip://dir/nested.tar</b><span style="color:red;font-weight:bold;">|</span><b>tar://file.txt</b> -- points to
* a file inside a TAR archive, which is inside a ZIP archive, which is on the local filesystem.</li>
* <li><b>file://dir/subdir/example.zip?MD5=1234567</b><span style="color:red;font-weight:bold;">|</span><b>zip://readme.txt?MD5=987654</b> --
* points to a file named "readme.txt" (with a MD5 hash) in a zip file (that has another
* MD5 hash).
* MD5 hash).</li>
* </ul>
* <p>
* See {@link FSRLRoot} for examples of how FSRL and FSRLRoot's are related.

10
Ghidra/Features/Base/src/main/java/ghidra/formats/gfilesystem/FSRLRoot.java
View File

@ -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,11 +26,11 @@ package ghidra.formats.gfilesystem;
* <p>
* <ul>
* <li>FSRLRoot [ file:// ]<br>
* "file://"
* "file://"</li>
* <li>{@literal FSRLRoot [ file:// ] <---- FSRL [ /filename.txt ]}<br>
* "file:///filename.txt"
* "file:///filename.txt"</li>
* <li>{@literal FSRLRoot [ file:// ] <---- FSRL [ /filename.txt ] <--- FSRLRoot [ subfs:// ]}<br>
* "file:///filename.txt|subfs://"
* "file:///filename.txt|subfs://"</li>
* </ul>
*/
public class FSRLRoot extends FSRL {

8
Ghidra/Features/Base/src/main/java/ghidra/program/flatapi/FlatProgramAPI.java
View File

@ -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.
@ -57,8 +57,8 @@ import ghidra.util.task.TaskMonitor;
* <p>
* NOTE:
* <ol>
* <li>NO METHODS *SHOULD* EVER BE REMOVED FROM THIS CLASS.
* <li>NO METHOD SIGNATURES *SHOULD* EVER BE CHANGED IN THIS CLASS.
* <li>NO METHODS *SHOULD* EVER BE REMOVED FROM THIS CLASS.</li>
* <li>NO METHOD SIGNATURES *SHOULD* EVER BE CHANGED IN THIS CLASS.</li>
* </ol>
* <p>
* This class is used by GhidraScript.

12
Ghidra/Features/Base/src/main/java/ghidra/util/bytesearch/AlignRule.java
View File

@ -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,12 +22,12 @@ import ghidra.xml.XmlPullParser;
/**
* ByteSearch post search rule when a pattern is found. Used when a pattern must have a certain
* alignment at an offset from the location the pattern matches.
*
* <p>
* The pattern can be constructed or restored from XML of the form,
* where alignOffset=mark, alignmask=bits
*
* <align mark="0" bits="1"/>
*
* <pre>{@code
* <align mark="0" bits="1"/>
* }</pre>
*/
public class AlignRule implements PostRule {

6
Ghidra/Features/Base/src/main/java/ghidra/util/bytesearch/Pattern.java
View File

@ -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.
@ -185,7 +185,7 @@ public class Pattern extends DittedBitSequence {
}
/**
* Read just the post patterns from the <patternpair> tags
* Read just the post patterns from the {@code <patternpair>} tags
* @param file is the file to read from
* @param patternList collects the resulting Pattern objects
* @param pfactory is the factory for constructing postrules and matchactions

41
Ghidra/Features/Base/src/main/java/ghidra/util/bytesearch/PatternPairSet.java
View File

@ -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.
@ -27,28 +27,31 @@ import ghidra.xml.XmlPullParser;
* To match, a sequence from the "pre" sequence set must first match, then one of the "post" patterns
* is matched relative to the matching "pre" pattern. This class is really a storage object for the
* patterns and provides a mechanism to read the pre/post patterns from an XML file.
*
* <p>
* The larger pattern has the idea of bits of check, which means the number of bits that are fixed to
* a value when matching (not don't care). There is a pre pattern bits of check and post pattern bits
* of check. The bits of check are used to statistically gauge the accuracy of the pattern.
*
* <p>
* An example of the XML format follows:
* <patternpairs totalbits="32" postbits="16">
* <prepatterns>
* <data>0xe12fff1. </data>
* <data>0xe12fff1e 0x46c0 </data>
* <data>0xe12fff1e 0xe1a00000 </data>
* </prepatterns>
* <pre> {@code
* <patternpairs totalbits="32" postbits="16">
* <prepatterns>
* <data>0xe12fff1. </data>
* <data>0xe12fff1e 0x46c0 </data>
* <data>0xe12fff1e 0xe1a00000 </data>
* </prepatterns>
*
* <postpatterns>
* <data> 0xe24dd... 11101001 00101101 .1...... ....0000 </data>
* <data> 11101001 00101101 .1...... ....0000 0xe24dd... </data>
* <data> 11101001 00101101 .1...... ....0000 0x........ 0xe24dd... </data>
* <align mark="0" bits="3"/>
* <setcontext name="TMode" value="0"/>
* <funcstart/>
* </postpatterns>
* </patternpairs>
* <postpatterns>
* <data> 0xe24dd... 11101001 00101101 .1...... ....0000 </data>
* <data> 11101001 00101101 .1...... ....0000 0xe24dd... </data>
* <data> 11101001 00101101 .1...... ....0000 0x........ 0xe24dd... </data>
* <align mark="0" bits="3"/>
* <setcontext name="TMode" value="0"/>
* <funcstart/>
* </postpatterns>
* </patternpairs>
* }
* </pre>
*
* Note: The post Patterns can also have a set of rules that must be satisfied along with one of the
* Pattern DittedBitSequence matches.

14
Ghidra/Features/Decompiler/src/main/java/ghidra/app/decompiler/DecompInterface.java
View File

@ -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.
@ -462,18 +462,18 @@ public class DecompInterface {
* The current predefined analysis class are:
* <ul>
* <li>"decompile" - this is the default, and performs all
* analysis steps suitable for producing C code.
* analysis steps suitable for producing C code.</li>
* <li>"normalize" - omits type recovery from the analysis
* and some of the final clean-up steps involved in
* making valid C code. It is suitable for creating
* normalized pcode syntax trees of the dataflow.
* normalized pcode syntax trees of the dataflow.</li>
* <li>"firstpass" - does no analysis, but produces an
* unmodified syntax tree of the dataflow from the
* <li>"register" - does ???.
* unmodified syntax tree of the dataflow from the</li>
* <li>"register" - does ???.</li>
* <li>"paramid" - does required amount of decompilation
* followed by analysis steps that send parameter
* measure information for parameter id analysis.
* raw pcode.
* raw pcode.</li>
* </ul>
*
* <p>

6
Ghidra/Features/Decompiler/src/main/java/ghidra/app/util/DecompilerConcurrentQ.java
View File

@ -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.
@ -37,7 +37,7 @@ import utility.function.Dummy;
* {@link #waitForResults()}.</li>
* <li>For non-blocking usage, simply call
* {@link #process(Iterator, Consumer)}, passing the consumer of the results.</li>
* </ol>
* </ul>
* <p>
*
* @param <I> The input data needed by the supplied {@link QCallback}

8
Ghidra/Framework/DB/src/main/java/db/VarRecNode.java
View File

@ -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.
@ -27,11 +27,11 @@ import ghidra.util.exception.AssertException;
* <p>
* This type of node has the following layout within a single DataBuffer
* (field size in bytes):
* <pre>
* <pre>{@code
* | NodeType(1) | KeyCount(4) | PrevLeafId(4) | NextLeafId(4) | Key0(8) | RecOffset0(4) | IndFlag0(1) |...
*
* | KeyN(8) | RecOffsetN(4) | IndFlagN(1) |...<FreeSpace>... | RecN |... | Rec0 |
* </pre>
* }</pre>
* IndFlag - if not zero the record has been stored within a chained DBBuffer
* whose 4-byte integer buffer ID has been stored within this leaf at the record offset.
*/

14
Ghidra/Framework/Docking/src/main/java/docking/ComponentProvider.java
View File

@ -49,17 +49,17 @@ import utilities.util.reflection.ReflectionUtilities;
* <p>
* This also provides several useful convenience methods:
* <ul>
* <li>{@link #addLocalAction(DockingActionIf)}
* <li>{@link #addToTool()}
* <li>{@link #setVisible(boolean)}
* <li>{@link #setTitle(String)}
* <li>{@link #setIcon(Icon)}
* <li>{@link #addLocalAction(DockingActionIf)}</li>
* <li>{@link #addToTool()}</li>
* <li>{@link #setVisible(boolean)}</li>
* <li>{@link #setTitle(String)}</li>
* <li>{@link #setIcon(Icon)}</li>
* </ul>
* <p>
* There are a handful of stub methods that can be overridden as desired:
* <ul>
* <li>{@link #componentActivated()} and {@link #componentDeactived()}
* <li>{@link #componentHidden()} and {@link #componentShown()}
* <li>{@link #componentActivated()} and {@link #componentDeactived()}</li>
* <li>{@link #componentHidden()} and {@link #componentShown()}</li>
* </ul>
*
* <p>

6
Ghidra/Framework/Docking/src/main/java/docking/KeyBindingOverrideKeyEventDispatcher.java
View File

@ -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.
@ -86,7 +86,7 @@ public class KeyBindingOverrideKeyEventDispatcher implements KeyEventDispatcher
* </ol>
* Ghidra has altered this flow to be:
* <ol>
* <li><b>Reserved keybinding actions</b>
* <li><b>Reserved keybinding actions</b></li>
* <li>KeyListeners on the focused Component</li>
* <li>InputMap and ActionMap actions for the Component</li>
* <li><b>Ghidra tool-level actions</b></li>

8
Ghidra/Framework/Docking/src/main/java/docking/PlaceholderSet.java
View File

@ -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.
@ -21,8 +21,8 @@ import java.util.Map.Entry;
/**
* A class that tracks:
* <ul>
* <li>placeholders that are being used for a given provider
* <li>placeholders that are no longer being used, which are available for reuse
* <li>placeholders that are being used for a given provider</li>
* <li>placeholders that are no longer being used, which are available for reuse </li>
* </ul>
*/
class PlaceholderSet {

10
Ghidra/Framework/Docking/src/main/java/docking/dnd/Draggable.java
View File

@ -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.
@ -51,9 +51,9 @@ public interface Draggable {
/**
* Get the drag actions supported by this drag source:
* <UL>
* <li>DnDConstants.ACTION_MOVE
* <li>DnDConstants.ACTION_COPY
* <li>DnDConstants.ACTION_COPY_OR_MOVE
* <li>DnDConstants.ACTION_MOVE</li>
* <li>DnDConstants.ACTION_COPY</li>
* <li>DnDConstants.ACTION_COPY_OR_MOVE</li>
* </UL>
*
* @return the drag actions

50
Ghidra/Framework/Docking/src/main/java/docking/widgets/OptionDialog.java
View File

@ -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,9 +34,7 @@ import ghidra.util.exception.AssertException;
* A utility class to easily show dialogs that require input from the user.
*
*
* <h2>Option Dialogs</h2><br>
* <blockquote>
* <p>
* <h2>Option Dialogs</h2>
* The primary type of
* dialog provided herein is the basic option dialog that allows the user to specify the buttons
* that appear on the dialog. By default, the given option text will appear as a button(s),
@ -44,55 +42,37 @@ import ghidra.util.exception.AssertException;
* {@link #showOptionNoCancelDialog(Component, String, String, String, String, int)} methods if
* you do not want a <code>Cancel</code> button. To use this type of dialog you can use the
* various <b><code>showOptionDialog*</code></b> methods.
* </p>
* <p>
* Each of the option dialog methods will return a result, which is a number indicating the
* choice made by the user. See each method for more details.
* </p>
* </blockquote>
*
*
* <h3>Data Input and Choice Dialogs</h3><br>
* <blockquote>
* <p>
* The methods listed here allow the user to either enter data from the keyboard or to choose
* from a pre-populated list of data.
* </p>
* <blockquote>
* {@link #showInputChoiceDialog(Component, String, String, String[], String, int)}<br>
* {@link #showInputMultilineDialog(Component, String, String, String)}<br>
* {@link #showInputSingleLineDialog(Component, String, String, String)}
* </blockquote>
* </blockquote>
* <h3>Data Input and Choice Dialogs</h3>
* The methods listed here allow the user to either enter data from the keyboard or to choose
* from a pre-populated list of data.
* <ul>
* <li>{@link #showInputChoiceDialog(Component, String, String, String[], String, int)}</li>
* <li>{@link #showInputMultilineDialog(Component, String, String, String)}</li>
* <li>{@link #showInputSingleLineDialog(Component, String, String, String)}</li>
* </ul>
*
*
* <h3>Yes/No Dialogs</h3><br>
* <blockquote>
* <p>
* <h3>Yes/No Dialogs</h3>
* Finally, there are a series of methods that present <code>Yes</code> and <code>No</code> buttons in
* a dialog. There are versions that do and do not have a <code>Cancel</code> button.
* </p>
* </blockquote>
*
*
* <h3>Basic Message / Warning / Error Dialogs</h3><br>
* <blockquote>
* <p>
* <h3>Basic Message / Warning / Error Dialogs</h3>
* If you would like to display a simple message to the user, but do not require input from the
* user, then you should use the various methods of {@link Msg}, such as
* {@link Msg#showInfo(Object, Component, String, Object)}.
* </p>
* <p>
* Note, the user will be unable to select any text shown in the message area of the dialog.
* </p>
* </blockquote>
*
* <h3>"Apply to All" / "Don't Show Again"</h3><br>
* <blockquote>
* <p>For more advanced input dialog usage, to include allowing the user to tell the dialog
* <h3>"Apply to All" / "Don't Show Again"</h3>
* For more advanced input dialog usage, to include allowing the user to tell the dialog
* to remember a particular decision, or to apply a given choice to all future request, see
* {@link OptionDialogBuilder}.
* </blockquote>
*
* @see Msg
* @see OptionDialogBuilder

8
Ghidra/Framework/Docking/src/main/java/docking/widgets/autocomplete/TextFieldAutocompleter.java
View File

@ -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.
@ -77,7 +77,7 @@ import ghidra.util.task.SwingUpdateManager;
* The simplest use case is to create a text field, create an autocompleter with a custom model, and
* then attach and show.
*
* <pre>
* <pre>{@code
* JTextField field = new JTextField();
*
* AutocompletionModel<String> model = new AutocompletionModel<String>() {
@ -90,7 +90,7 @@ import ghidra.util.task.SwingUpdateManager;
* completer.attachTo(field);
* // ... Add the field to, e.g., a dialog, and show.
*
* </pre>
* }</pre>
*
* @param <T> the type of suggestions presented by this autocompleter.
*/

12
Ghidra/Framework/Docking/src/main/java/docking/widgets/filechooser/GhidraFileChooser.java
View File

@ -626,13 +626,13 @@ public class GhidraFileChooser extends ReusableDialogComponentProvider implement
* Sets the <code>GhidraFileChooser</code> to allow the user to just
* select files, just select
* directories, or select both files and directories. The default is
* <code>JFilesChooser.FILES_ONLY</code>.
* {@link JFileChooser#FILES_ONLY}.
*
* @param mode the type of files to be displayed:
* <ul>
* <li>GhidraFileChooser.FILES_ONLY
* <li>GhidraFileChooser.DIRECTORIES_ONLY
* <li>GhidraFileChooser.FILES_AND_DIRECTORIES
* <li>{@link GhidraFileChooser#FILES_ONLY}</li>
* <li>{@link GhidraFileChooser#DIRECTORIES_ONLY}</li>
* <li>{@link GhidraFileChooser#FILES_AND_DIRECTORIES}</li>
* </ul>
*
* @exception IllegalArgumentException if <code>mode</code> is an
@ -1007,8 +1007,8 @@ public class GhidraFileChooser extends ReusableDialogComponentProvider implement
* <ul>
* <li>If the parent directory of the file exists, then the parent directory will be made
* the current directory and the name of the file will be put into the filename
* textfield; otherwise,
* <li>If the parent file does <b>not</b> exist, then the selection is cleared.
* textfield; otherwise,</li>
* <li>If the parent file does <b>not</b> exist, then the selection is cleared.</li>
* </ul>
* <p>
* If the given file is null, then the selected file state is cleared.

8
Ghidra/Framework/Docking/src/main/java/docking/widgets/searchlist/DefaultSearchListModel.java
View File

@ -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,8 @@ import utility.function.Dummy;
/**
* Default implementation of the {@link SearchListModel}. Since this model's primary purpose is
* to also implement the {@link ListModel}, this class extends the AbstractListModel.
* This model's primary type is T, but it implements the list model on SearchListEntry<T> to provide
* more information for the custom rendering that groups items into categories.
* This model's primary type is T, but it implements the list model on {@code SearchListEntry<T>}
* to provide more information for the custom rendering that groups items into categories.
*
* @param <T> The type of items to display and select.
*/

14
Ghidra/Framework/Docking/src/main/java/docking/widgets/table/GTableFilterPanel.java
View File

@ -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.
@ -65,8 +65,8 @@ import utility.function.Callback;
*
* <b><u>Important Usage Notes</u></b>
* <ul>
* <li><b><a id="translation"></a>You must translate row values retrieved from the table using
* this panel.</b>
* <li><a id="translation"></a><b>You must translate row values retrieved from the table using
* this panel.</b></li>
* <p>
* Since this class wraps the given table with a new model, you must use this class to
* translate row number values. For example, when getting the selected row, the normal Java
@ -84,14 +84,14 @@ import utility.function.Callback;
* </span>
* </pre>
*
* <li><b>This class may set a new model on the given table, which can affect how tables are sized.</b>
* <li><b>This class may set a new model on the given table, which can affect how tables are sized.</b></li>
* <p>
* If {@link JTable#getAutoCreateColumnsFromModel()} returns true, then the columns will
* be recreated and resized when this class is constructed.
* <li>The {@link TableFilter} used by this class will be passed the empty string ("") when
* {@link TableFilter#acceptsRow(Object)} is called.
* {@link TableFilter#acceptsRow(Object)} is called.</li>
* <li><b>You cannot rely on {@link JTable#getRowCount()} to access all of the table data,
* since the data may be filtered.</b>
* since the data may be filtered.</b></li>
* <p>
* To get a row count that is always all of the model's data, call
* {@link #getUnfilteredRowCount()}.

16
Ghidra/Framework/Docking/src/main/java/docking/widgets/table/constrainteditor/LocalDateSpinnerModel.java
View File

@ -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.
@ -38,9 +38,9 @@ public class LocalDateSpinnerModel extends AbstractSpinnerModel {
* @param maxDate maximum value for spinner model. (Can be null)
* @param calendarField specifies the year, month, or day to increment/decrement. One of:
* <ul>
* <li><code>Calendar.YEAR</code>
* <li><code>Calendar.MONTH</code>
* <li><code>Calendar.DAY_OF_MONTH</code>
* <li>{@link Calendar#YEAR}</li>
* <li>{@link Calendar#MONTH}</li>
* <li>{@link Calendar#DAY_OF_MONTH}</li>
* </ul>
* <p>
*/
@ -128,9 +128,9 @@ public class LocalDateSpinnerModel extends AbstractSpinnerModel {
*
* @param calendarField one of
* <ul>
* <li><code>Calendar.YEAR</code>
* <li><code>Calendar.MONTH</code>
* <li><code>Calendar.DAY_OF_MONTH</code>
* <li>{@link Calendar#YEAR}</li>
* <li>{@link Calendar#MONTH}</li>
* <li>{@link Calendar#DAY_OF_MONTH}</li>
* </ul>
* <p>
*

18
Ghidra/Framework/Docking/src/main/java/docking/widgets/table/threaded/TableUpdateJob.java
View File

@ -191,18 +191,18 @@ public class TableUpdateJob<T> {
* effect depends on the running job's state:
* <ul>
* <li>If the sort state hasn't happened yet, all it does is set the comparator for when
* the sort occurs.
* the sort occurs.</li>
* <li>If the sort state has already been started or completed, then this method attempts
* to stop the current process phase and cause the state machine to return to the sort
* phase.
* phase.</li>
* <li>If the current job has already entered the DONE state, then the sort cannot take
* effect in this job and a false value is returned to indicate the
* sort was not handled by this job.
* sort was not handled by this job.</li>
* </ul>
* @param newSortingContext the TableColumnComparator to use to sort the data.
* @param forceSort True signals to re-sort, even if this is already sorted
* @return true if the sort can be processed by this job, false if this job is essentially
* already completed and therefor cannot perform the sort job.
* already completed and therefore cannot perform the sort job.
*/
public synchronized boolean requestSort(TableSortingContext<T> newSortingContext,
boolean forceSort) {
@ -225,16 +225,16 @@ public class TableUpdateJob<T> {
* depends on the running job's state:
* <ul>
* <li>If the filter state hasn't happened yet, then nothing needs to be done as this job
* will filter later anyway.
* will filter later anyway.</li>
* <li>If the filter state has already been started or completed, then this method
* attempts to stop the current process phase and cause the state machine to return to
* the filter phase.
* the filter phase.</li>
* <li>If the current job has already entered the DONE state, then the filter cannot take
* effect in this job and a false value is returned to indicate the filter was not
* handled by this job.
* handled by this job.</li>
* </ul>
* @return true if the filter can be processed by this job, false if this job is essentially
* already completed and therefor cannot perform the filter job.
* already completed and therefore cannot perform the filter job.
*/
public synchronized boolean requestFilter() {
if (currentState == DONE) {
@ -718,7 +718,7 @@ public class TableUpdateJob<T> {
}
/**
* Wraps a comparator<T> to add progress monitoring and cancel checking
* Wraps a {@link Comparator} to add progress monitoring and cancel checking
*
* @param <T> The type of data being sorted
*/

6
Ghidra/Framework/Docking/src/main/java/ghidra/util/task/BasicTaskMonitor.java
View File

@ -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.
@ -30,7 +30,7 @@ import ghidra.util.exception.CancelledException;
* the Java concurrent structures (e.g., {@link AtomicBoolean}). In order to keep the values of
* this class's fields update-to-date, we have chosen to synchronize the package-level client of
* this class. <b>If this class is ever made public, then most of the methods herein need to
* be synchronized to prevent race conditions and to provide visibility.
* be synchronized to prevent race conditions and to provide visibility.</b>
*/
class BasicTaskMonitor implements TaskMonitor {

36
Ghidra/Framework/Docking/src/main/java/ghidra/util/task/TaskLauncher.java
View File

@ -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,7 +26,7 @@ import java.awt.Component;
* {@link #TaskLauncher(Task, Component, int, int)}. Alternatively, for simpler uses,
* see one of the many static convenience methods.
*
* <p><b><a id="modal_usage">Modal Usage</a></b><br>
* <p><a id="modal_usage"><b>Modal Usage</b></a></p>
* Most clients of this class should not be concerned with where
* the dialog used by this class will appear. By default, it will be shown over
* the active window, which is the desired
@ -63,13 +63,12 @@ public class TaskLauncher {
/**
* A convenience method to directly run a {@link MonitoredRunnable} in a separate
* thread as a {@link Task}, displaying a non-modal progress dialog.
* <p>
* <code>
* TaskLauncher.launchNonModal( "My task", <br>
* &nbsp;&nbsp;null, // parent<br>
* &nbsp;&nbsp;monitor -&gt; { while ( !monitor.isCanceled() ) { longRunningWork(); } }<br>
* <pre>{@code
* TaskLauncher.launchNonModal("My task",
* null, // parent
* monitor -> { while (!monitor.isCanceled()) { longRunningWork(); } }
* );
* </code>
* }</pre>
*
* <p>Note: the task created by this call will be both cancellable and have progress. If
* you task cannot be cancelled or does not have progress, then do not use this
@ -93,13 +92,12 @@ public class TaskLauncher {
/**
* A convenience method to directly run a {@link MonitoredRunnable} in a separate
* thread as a {@link Task}, displaying a <b>modal</b> progress dialog.
* <p>
* <code>
* TaskLauncher.launchModal( "My task", <br>
* &nbsp;&nbsp;null, // parent<br>
* &nbsp;&nbsp;monitor -&gt; { while ( !monitor.isCanceled() ) { longRunningWork(); } }<br>
* <pre>{@code
* TaskLauncher.launchModal("My task",
* null, // parent
* monitor -> { while (!monitor.isCanceled()) { longRunningWork(); } }
* );
* </code>
* }</pre>
*
* <p>Note: the task created by this call will be both cancellable and have progress. If
* you task cannot be cancelled or does not have progress, then do not use this
@ -128,11 +126,11 @@ public class TaskLauncher {
* to have it immediately go away. If you desire this default behavior, then do not use
* this convenience method.
*
* <p><code>
* TaskLauncher.launchModal( "My task", <br>
* &nbsp;&nbsp;monitor -&gt; { { foo(); }<br>
* <pre>{@code
* TaskLauncher.launchModal("My task",
* monitor -> { foo(); }
* );
* </code>
* }</pre>
*
* <p>Note: the task created by this call will not be cancellable nor have progress. If
* you need either of these behaviors, the do not use this

6
Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeUseropLibrary.java
View File

@ -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.
@ -40,7 +40,7 @@ public interface PcodeUseropLibrary<T> {
/**
* The class of the empty userop library.
*
* @see {@link PcodeUseropLibrary#nil()}
* @see PcodeUseropLibrary#nil()
*/
final class EmptyPcodeUseropLibrary implements PcodeUseropLibrary<Object> {
@Override

23
Ghidra/Framework/Generic/src/main/java/ghidra/util/CountLatch.java
View File

@ -1,13 +1,12 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* 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.
@ -105,15 +104,15 @@ public class CountLatch {
* dormant until one of two things happen:
* <ul>
* <li>The count reaches zero due to invocations of the
* {@link #decrement} method; or
* {@link #decrement} method; or</li>
* <li>Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread.
* the current thread.</li>
* </ul>
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,
* <li>has its interrupted status set on entry to this method; or</li>
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,</li>
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.
@ -138,10 +137,10 @@ public class CountLatch {
* dormant until one of three things happen:
* <ul>
* <li>The count reaches zero due to invocations of the
* {@link #decrement} method; or
* {@link #decrement} method; or</li>
* <li>Some other thread {@linkplain Thread#interrupt interrupts}
* the current thread; or
* <li>The specified waiting time elapses.
* the current thread; or</li>
* <li>The specified waiting time elapses.</li>
* </ul>
*
* <p>If the count reaches zero then the method returns with the
@ -149,8 +148,8 @@ public class CountLatch {
*
* <p>If the current thread:
* <ul>
* <li>has its interrupted status set on entry to this method; or
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,
* <li>has its interrupted status set on entry to this method; or</li>
* <li>is {@linkplain Thread#interrupt interrupted} while waiting,</li>
* </ul>
* then {@link InterruptedException} is thrown and the current thread's
* interrupted status is cleared.

12
Ghidra/Framework/Graph/src/main/java/ghidra/graph/GraphAlgorithms.java
View File

@ -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.
@ -38,25 +38,30 @@ import util.CollectionUtils;
* a node 'a' dominates node 'b' if all paths from start to 'b' contain 'a';
* a node always dominates itself (except in 'strict dominance', which is all
* dominators except for itself)
* </LI>
*
* <LI>
* <B>post-dominance:</B>
* A node 'b' is said to post-dominate node 'a' if all paths from 'a'
* to END contain 'b'
* </LI>
*
* <LI>
* <B>immediate dominator:</B>
* the closest dominator of a node
* </LI>
*
* <LI>
* <B>dominance tree:</B>
* A dominator tree is a tree where each node's children are those nodes
* it *immediately* dominates (a idom b)
* </LI>
*
* <LI>
* <B>dominance frontier:</B>
* the immediate successors of the nodes dominated by 'a'; it is the set of
* nodes where d's dominance stops.
* </LI>
*
* <LI>
* <B>strongly connected components:</B>
@ -64,8 +69,11 @@ import util.CollectionUtils;
* from every other vertex. The strongly connected components
* of an arbitrary directed graph form a partition into
* subgraphs that are themselves strongly connected.
* </LI>
*
* <LI>
* <B>graph density:</B>
* </LI>
* <PRE>
* E
* Density = --------

10
Ghidra/Framework/Graph/src/main/java/ghidra/graph/viewer/GraphViewerUtils.java
View File

@ -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.
@ -48,11 +48,11 @@ import ghidra.graph.viewer.vertex.VisualGraphVertexShapeTransformer;
*
* <ul>
* <li>Layout Space - the layout contains Point2D objects that represent positions of the
* vertices.
* vertices. </li>
* <li>Graph Space - the space where the Layout points are transformed as the view is moved
* around the screen (e.g., as the user pans)
* around the screen (e.g., as the user pans)</li>
* <li>View Space - the coordinate system of Java 2D rendering; scaling (zooming) transformations
* are applied at this layer
* are applied at this layer</li>
* </ul>
*
* <P> Note: vertex relative means that the value is from inside the vertex, or the vertex's

6
Ghidra/Framework/Graph/src/main/java/ghidra/graph/viewer/edge/VisualGraphPathHighlighter.java
View File

@ -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.
@ -49,7 +49,7 @@ import utility.function.Callback;
* <LI>Results must be cached for speed, but may cleared as the graph is mutated</LI>
* <LI>Algorithms must not block the UI thread</LI>
* <LI>Related actions (i.e., hover vs. selection) should cancel any pending action, but not
* unrelated actions (e.g., a new hover request should cancel a pending hover update)
* unrelated actions (e.g., a new hover request should cancel a pending hover update)</LI>
* </UL>
*
* Based on these requirements, we need to use multi-threading. Further complicating the need

20
Ghidra/Framework/Gui/src/main/java/generic/theme/SystemThemeIds.java
View File

@ -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.
@ -35,18 +35,18 @@ import generic.theme.laf.UiDefaultsMapper;
* <LI>VIEW - these ids are used for the colors and fonts used for widgets that display data
* such as Trees, Tables, TextFieds, and Lists</LI>
* <LI>MENU - these ids are used by menu components such as Menus and MenuItems.</LI>
* <LI>TOOLTIP - these ids are used just by the tooltip component
* <LI>TOOLTIP - these ids are used just by the tooltip component</LI>
* </UL>
* <P>
* For each of those categories the ids specify a specific property for those components.
* <UL>
* <LI> BG - the background color
* <LI> FG - the foreground color
* <LI> BG_SELECTED - the background color when the component is selected
* <LI> FG_SELECTED - the foreground color when the component is selected
* <LI> FG_DISABLED - the foreground color when the component is disabled
* <LI> BG_BORDER - the border color
* <LI> FONT - the font
* <LI> BG - the background color</LI>
* <LI> FG - the foreground color</LI>
* <LI> BG_SELECTED - the background color when the component is selected</LI>
* <LI> FG_SELECTED - the foreground color when the component is selected</LI>
* <LI> FG_DISABLED - the foreground color when the component is disabled</LI>
* <LI> BG_BORDER - the border color</LI>
* <LI> FONT - the font</LI>
* </UL>
*/
public class SystemThemeIds {

4
Ghidra/Framework/Gui/src/main/java/generic/theme/ThemeManager.java
View File

@ -41,13 +41,13 @@ import utility.function.Callback;
* The basic idea is that all the colors, fonts, and icons used in an application should be
* accessed indirectly via an "id" string. Then the actual color, font, or icon can be changed
* without changing the source code. The default mapping of the id strings to a value is defined
* in <name>.theme.properties files which are dynamically discovered by searching the module's
* in {@code <name>.theme.properties} files which are dynamically discovered by searching the module's
* data directory. Also, these files can optionally define a dark default value for an id which
* would replace the standard default value in the event that the current theme specifies that it
* is a dark theme. Themes are used to specify the application's {@link LookAndFeel}, whether or
* not it is dark, and any customized values for colors, fonts, or icons. There are several
* "built-in" themes, one for each supported {@link LookAndFeel}, but additional themes can
* be defined and stored in the users application home directory as a <name>.theme file.
* be defined and stored in the users application home directory as a {@code <name>.theme} file.
* <P>
* Clients that just need to access the colors, fonts, and icons from the theme can use the
* convenience methods in the {@link Gui} class. Clients that need to directly manipulate the

16
Ghidra/Framework/Gui/src/main/java/generic/theme/laf/UiDefaultsMapper.java
View File

@ -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.
@ -47,16 +47,16 @@ import ghidra.util.Msg;
* Some basic concepts:
* <UL>
* <LI>UI Defaults - key-value pairs defined by the Java LaF; there are 2 key types, widget
* keys and Java group/reusable keys (e.g., Button.background; control)
* keys and Java group/reusable keys (e.g., Button.background; control)</LI>
* <LI>UI Indirection - UI Defaults values are changed to point to custom terms we created to
* allow for indirection (e.g., Button.background -> laf.color.Button.background)
* allow for indirection (e.g., Button.background -> laf.color.Button.background)</LI>
* <LI>Normalized Keys - keys we created to facilitate the UI Indirection, based upon the Java
* keys (e.g., laf.color.Button.background)
* keys (e.g., laf.color.Button.background)</LI>
* <LI>System Color/Font Keys - user facing terms for common color or font concepts into an
* easy-to-change setting (e.g., system.color.fg.text)
* easy-to-change setting (e.g., system.color.fg.text)</LI>
* <LI>Palette Keys - dynamically generated color palette keys based on the LaF for any colors
* and fonts that were not mapped into an system color or font (e.g.,
* laf.palette.color.01)
* laf.palette.color.01)</LI>
* </UL>
*
* <P>
@ -65,7 +65,7 @@ import ghidra.util.Msg;
* <LI>Extracts all color, font, and icon values from the UI Defaults.</LI>
* <LI>Use the current LaF values to populate the pre-defined system colors and fonts.</LI>
* <LI>Any UI Defaults values not assigned in the previous step will be assigned to a dynamic shared
* palette color or font.
* palette color or font.</LI>
* <LI>Update Java UI Defaults to use our indirection and system values.</LI>
* </OL>
*

8
Ghidra/Framework/Help/src/main/java/help/GHelpBuilder.java
View File

@ -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.
@ -37,9 +37,9 @@ import help.validator.location.HelpModuleCollection;
* Note: Help links must not be absolute. They can be relative, including <code>. and ..</code>
* syntax. Further, they can use the special help system syntax, which is:
* <ul>
* <li><code><b>help/topics/</b>topicName/Filename.html</code> for referencing help topic files
* <li><code><b>help/topics/</b>topicName/Filename.html</code> for referencing help topic files</li>
* <li><code><b>help/</b>shared/image.png</code> for referencing image files at paths rooted under
* the module's root help dir
* the module's root help dir</li>
* </ul>
*/
public class GHelpBuilder {

10
Ghidra/Framework/Project/src/main/java/ghidra/framework/main/logviewer/ui/FileViewer.java
View File

@ -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.
@ -40,17 +40,17 @@ import utilities.util.FileUtilities;
* <ol>
* <li>The viewer consists of a simple JTable and a custom JSlider. The table displays lines of
* text described by {@link Chunk} objects. The number of chunks visible at any given time
* is restricted by the {@link ChunkModel#MAX_VISIBLE_CHUNKS} property.
* is restricted by the {@link ChunkModel#MAX_VISIBLE_CHUNKS} property.</li>
*
* <li>Because only part of the file is loaded into the viewable table at any given time, the
* built-in scrollbar associated with the scroll pane cannot be used. We want the scroll bar
* maximum size to reflect the total size of the file, not just what's in view at the time. So
* we use our own slider implementation ({@link FVSlider}) and manage the size/position
* ourselves. If you're asking why a JSlider is used instead of a JScrollPane, it's because the
* former is more easily configuration for what we need.
* former is more easily configuration for what we need.</li>
*
* <li>Communication between modules (the table, the slider, the viewport utility, etc...) is done
* almost exclusively via events, using the custom {@link FVEvent} framework.
* almost exclusively via events, using the custom {@link FVEvent} framework.</li>
* </ol>
*/
public class FileViewer extends JPanel implements Observer {

132
Ghidra/Framework/Project/src/main/java/ghidra/framework/plugintool/Plugin.java
View File

@ -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.
@ -40,15 +40,17 @@ import ghidra.util.classfinder.ExtensionPoint;
* <p>
* <h2>Well formed Plugins:</h2>
* <UL>
* <LI>Derive from <code>Plugin</code> (directly or indirectly).
* <LI>Class name ends with "Plugin" and does not match any other Plugin, regardless of
* its location in the package tree.
* <LI>Have a {@link PluginInfo @PluginInfo()} annotation.
* <LI>Have a constructor with exactly 1 parameter: PluginTool.
* <UL>
* <LI><code>public MyPlugin(PluginTool tool) { ... }</code>
* </UL>
* <LI>Usually overrides <code>protected void init()</code>.
* <LI>Derive from <code>Plugin</code> (directly or indirectly).</LI>
* <LI>Class name ends with "Plugin" and does not match any other Plugin, regardless of its
* location in the package tree.</LI>
* <LI>Have a {@link PluginInfo @PluginInfo()} annotation.</LI>
* <LI>Have a constructor with exactly 1 parameter: PluginTool.</LI>
* <LI>
* <UL>
* <LI><code>public MyPlugin(PluginTool tool) { ... }</code></LI>
* </UL>
* </LI>
* <LI>Usually overrides <code>protected void init()</code>.</LI>
* </UL>
* <h2>Class naming</h2>
* All Plugin Classes <b>MUST END IN</b> "Plugin". If not, the ClassSearcher will not find them.
@ -58,50 +60,60 @@ import ghidra.util.classfinder.ExtensionPoint;
*
* <h2>Plugin Life cycle</h2>
* <OL>
* <LI>Your Plugin's constructor is called
* <OL>
* <LI>Plugin base class constructor is called.
* <OL>
* <LI>Services listed in the @PluginInfo annotation are automatically added
* to dependency list
* </OL>
* <LI>Your Plugin publishes any services listed in PluginInfo using
* {@link Plugin#registerServiceProvided(Class, Object) registerServiceProvided()}.
* (required)
* <LI>Create Actions (optional)
* <LI>Register {@link ghidra.framework.options.Options Options} with the
* {@link PluginTool#getOptions(String)}. (optional)<br>
* </OL>
* <LI>Other Plugins are constructed, dependencies evaluated, etc.<br>
* <LI>Your Plugin's constructor is called</LI>
* <LI>
* <OL>
* <LI>Plugin base class constructor is called.</LI>
* <LI>
* <OL>
* <LI>Services listed in the @PluginInfo annotation are automatically added to dependency
* list</LI>
* </OL>
* </LI>
* <LI>Your Plugin publishes any services listed in PluginInfo using
* {@link Plugin#registerServiceProvided(Class, Object) registerServiceProvided()}.
* (required)</LI>
* <LI>Create Actions (optional)</LI>
* <LI>Register {@link ghidra.framework.options.Options Options} with the
* {@link PluginTool#getOptions(String)}. (optional)</LI><br>
* </OL>
* </LI>
* <LI>Other Plugins are constructed, dependencies evaluated, etc.<br>
* If your dependencies are not available (i.e., not installed, threw an exception during their
* initialization, etc), your Plugin's {@link #dispose()} will be called and then your Plugin
* instance will be discarded.<br>
* <LI>Your Plugin's {@link #init()} method is called (when its dependencies are met).
* <OL>
* <LI>Call {@link PluginTool#getService(Class)} to get service
* implementations. (the service class being requested should already be
* listed in the @PluginInfo)
* <LI>Create Actions (optional)
* <LI>Other initialization stuff.
* </OL>
* <LI>Your Plugin's {@link #readConfigState(SaveState)} is called.
* <LI>...user uses Ghidra...
* <UL>
* <LI>Your Plugin's {@link #processEvent(PluginEvent)} is called for events.
* <LI>Your Plugin's Action's methods (i.e.,
* {@link DockingAction#actionPerformed(docking.ActionContext) actionPerformed}) are
* called.
* <LI>Your Plugin's published service methods are called by other Plugins.
* <LI>Your Plugin's listener methods are called.
* </UL>
* <LI>Plugin is unloaded due to shutdown of the Tool or being disabled by user
* <OL>
* <LI>Your Plugin's {@link #writeConfigState(SaveState)} is called - override this
* method to write configuration info into the Tool definition.
* <LI>Your Plugin's {@link #dispose()} is called - override this method to free
* any resources and perform any needed cleanup.
* <LI>Your Plugin's services and events are de-registered automatically.
* </OL>
* instance will be discarded.</LI><br>
* <LI>Your Plugin's {@link #init()} method is called (when its dependencies are met).</LI>
* <LI>
* <OL>
* <LI>Call {@link PluginTool#getService(Class)} to get service
* implementations. (the service class being requested should already be
* listed in the @PluginInfo)</LI>
* <LI>Create Actions (optional)</LI>
* <LI>Other initialization stuff.</LI>
* </OL>
* </LI>
* <LI>Your Plugin's {@link #readConfigState(SaveState)} is called.</LI>
* <LI>...user uses Ghidra...</LI>
* <LI>
* <UL>
* <LI>Your Plugin's {@link #processEvent(PluginEvent)} is called for events.</LI>
* <LI>Your Plugin's Action's methods (i.e.,
* {@link DockingAction#actionPerformed(docking.ActionContext) actionPerformed}) are
* called.</LI>
* <LI>Your Plugin's published service methods are called by other Plugins.</LI>
* <LI>Your Plugin's listener methods are called.</LI>
* </UL>
* </LI>
* <LI>Plugin is unloaded due to shutdown of the Tool or being disabled by user</LI>
* <LI>
* <OL>
* <LI>Your Plugin's {@link #writeConfigState(SaveState)} is called - override this
* method to write configuration info into the Tool definition.</LI>
* <LI>Your Plugin's {@link #dispose()} is called - override this method to free
* any resources and perform any needed cleanup.</LI>
* <LI>Your Plugin's services and events are de-registered automatically.</LI>
* </OL>
* </LI>
* </OL>
*
* <h2>Plugin Service dependency</h2>
@ -164,26 +176,26 @@ import ghidra.util.classfinder.ExtensionPoint;
* <h2>Plugin Events</h2>
* <UL>
* <LI>Every type of plugin event should be represented by some class extending
* {@link PluginEvent}.
* {@link PluginEvent}.</LI>
* <LI>One PluginEvent subclass may be used for more than one event type as long as there's some
* natural grouping.
* natural grouping.</LI>
* </UL>
*
* <h2>Component Providers</h2>
* <UL>
* <LI>A plugin may supply a {@link ComponentProvider} that provides a visual component when
* the plugin is added to the tool.
* the plugin is added to the tool.</LI>
* </UL>
*
* <h2>Important interfaces Plugins often need to implement</h2>
* <UL>
* <LI>{@link OptionsChangeListener} - to receive notification when a configuration option
* is changed by the user.
* is changed by the user.</LI>
* <LI>{@link ApplicationLevelPlugin} - marks this Plugin as being suitable for inclusion in the
* application-level tool.
* application-level tool.</LI>
* <LI>{@link ApplicationLevelOnlyPlugin} - marks this Plugin as application-level only, not
* usable in an application's sub-tools.
* <LI>{@link ProgramaticUseOnly} - marks this Plugin as special and not for user configuration.
* usable in an application's sub-tools.</LI>
* <LI>{@link ProgramaticUseOnly} - marks this Plugin as special and not for user configuration.</LI>
* </UL>
*
*/

14
Ghidra/Framework/Project/src/main/java/ghidra/framework/plugintool/PluginTool.java
View File

@ -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.
@ -1197,13 +1197,13 @@ public abstract class PluginTool extends AbstractDockingTool {
* Closes this tool, possibly with input from the user. The following conditions are checked
* and can prompt the user for more info and allow them to cancel the close.
* <OL>
* <LI>Running tasks. Closing with running tasks could lead to data loss.
* <LI>Running tasks. Closing with running tasks could lead to data loss.</LI>
* <LI>Plugins get asked if they can be closed. They may prompt the user to resolve
* some plugin specific state.
* <LI>The user is prompted to save any data changes.
* some plugin specific state.</LI>
* <LI>The user is prompted to save any data changes.</LI>
* <LI>Tools are saved, possibly asking the user to resolve any conflicts caused by
* changing multiple instances of the same tool in different ways.
* <LI>If all the above conditions passed, the tool is closed and disposed.
* changing multiple instances of the same tool in different ways.</LI>
* <LI>If all the above conditions passed, the tool is closed and disposed.</LI>
* </OL>
*/
@Override

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/assembler/sleigh/SleighAssemblerBuilder.java
View File

@ -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.
@ -187,8 +187,8 @@ import ghidra.program.model.listing.Program;
*
* <ol>
* <li>Resolve operands from right to left, descending into sub-table operands.</li>
* <li>Solve context mutations, in reverse order.
* <li>Apply the required patterns
* <li>Solve context mutations, in reverse order.</li>
* <li>Apply the required patterns</li>
* </ol>
*
* <p>

10
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/processors/sleigh/ParserWalker.java
View File

@ -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,9 +26,9 @@ import ghidra.util.exception.AssertException;
* Class for walking the Sleigh Parser tree. The nodes of the tree are the Sleigh Constructors arranged for a particular
* instruction. This tree is walked for various purposes:
* <ul>
* <li>SleighInstructionPrototype.resolve - initial parsing of instruction and building the tree
* <li>SleighInstructionPrototype.resolveHandles - filling in Varnode values for all the Constructor exports
* <li>PcodeEmit - for weaving together p-code for an instruction
* <li>SleighInstructionPrototype.resolve - initial parsing of instruction and building the tree</li>
* <li>SleighInstructionPrototype.resolveHandles - filling in Varnode values for all the Constructor exports</li>
* <li>PcodeEmit - for weaving together p-code for an instruction</li>
* </ul>
*
*/

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/processors/sleigh/SleighParserContext.java
View File

@ -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.
@ -72,7 +72,7 @@ public class SleighParserContext implements ParserContext {
/**
* Constructor for building precompiled templates.
* NOTE: This form does not support use of <code>inst_next2</next>.
* NOTE: This form does not support use of {@code inst_next2}.
* @param aAddr = address to which 'inst_start' resolves
* @param nAddr = address to which 'inst_next' resolves
* @param rAddr = special address associated with original call

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/processors/sleigh/VarnodeData.java
View File

@ -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.
@ -36,7 +36,7 @@ public class VarnodeData {
public int size;
/**
* Encode the data to stream as an \<addr> element
* Encode the data to stream as an {@code <addr>} element
* @param encoder is the stream encoder
* @throws IOException for errors writing to the underlying stream
*/

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/processors/sleigh/template/ConstructTpl.java
View File

@ -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.
@ -96,7 +96,7 @@ public class ConstructTpl {
}
/**
* Decode this template from a \<construct_tpl> tag in the stream.
* Decode this template from a {@code <construct_tpl>} tag in the stream.
* @param decoder is the stream
* @return the constructor section id described by the tag
* @throws DecoderException for errors in the encoding

20
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/NamespaceUtils.java
View File

@ -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.
@ -29,25 +29,25 @@ import ghidra.util.exception.*;
* <a id="examples"></a>
* Example string format:
* <ul>
* <li>global{@link Namespace#DELIMITER ::}child1{@link Namespace#DELIMITER ::}child2
* <li>child1
* <li>global{@link Namespace#DELIMITER ::}child1{@link Namespace#DELIMITER ::}child2</li>
* <li>child1</li>
* </ul>
* <a id="assumptions"></a>
* <b>Assumptions for creating namespaces from a path string: </b>
* <ul>
* <li>All elements of a namespace path should be namespace symbols and not other
* symbol types.
* <li>Absolute paths can optionally start with the global namespace.
* symbol types.</li>
* <li>Absolute paths can optionally start with the global namespace.</li>
* <li>You can provide a relative path that will start at the given
* parent namespace (or global if there is no parent provided).
* parent namespace (or global if there is no parent provided).</li>
* <li>You can provide a path that has as its first entry the name of the
* given parent. In this case, the first entry will not be created,
* but rather the provided parent will be used.
* but rather the provided parent will be used.</li>
* <li>If you provide a path and a parent, but the first element of the
* path is the global namespace, then the global namespace will be
* used as the parent namespace and not the one that was provided.
* used as the parent namespace and not the one that was provided.</li>
* <li>You cannot embed the global namespace in a path, but it can be at
* the root.
* the root.</li>
* </ul>
*
*

20
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/PseudoDisassembler.java
View File

@ -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.
@ -361,10 +361,10 @@ public class PseudoDisassembler {
/**
* Check that this entry point leads to valid code:
* <ul>
* <li> May have multiple entries into the body of the code.
* <li>The intent is that it be valid code, not nice code.
* <li>Hit no bad instructions.
* <li>It should return.
* <li> May have multiple entries into the body of the code.</li>
* <li>The intent is that it be valid code, not nice code.</li>
* <li>Hit no bad instructions.</li>
* <li>It should return.</li>
* </ul>
* @param entryPoint
* @return true if the entry point leads to valid code
@ -377,10 +377,10 @@ public class PseudoDisassembler {
/**
* Check that this entry point leads to valid code:
* <ul>
* <li> May have multiple entries into the body of the code.
* <li>The intent is that it be valid code, not nice code.
* <li>Hit no bad instructions.
* <li>It should return.
* <li> May have multiple entries into the body of the code.</li>
* <li>The intent is that it be valid code, not nice code.</li>
* <li>Hit no bad instructions.</li>
* <li>It should return.</li>
* </ul>
*
* @param entryPoint location to test for valid code

10
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/SymbolPath.java
View File

@ -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.
@ -28,9 +28,9 @@ import ghidra.program.model.symbol.*;
* name of a symbol in the "bar" namespace, which is in the "foo" namespace.
* <P>
* <UL>
* <LI>{@link #getName()} will return "baz".
* <LI>{@link #getParentPath()} will return "foo:bar".
* <LI>{@link #getPath()} will return "foo::bar::baz".
* <LI>{@link #getName()} will return "baz".</LI>
* <LI>{@link #getParentPath()} will return "foo:bar".</LI>
* <LI>{@link #getPath()} will return "foo::bar::baz".</LI>
* </UL>
*
*/

29
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/pcodeCPort/slgh_compile/ParseException.java
View File

@ -1,13 +1,12 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* 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.
@ -28,18 +27,18 @@ package ghidra.pcodeCPort.slgh_compile;
*/
public class ParseException extends Exception {
/**
* This constructor is used by the method "generateParseException"
* in the generated parser. Calling this constructor generates
* a new object of this type with the fields "currentToken",
* "expectedTokenSequences", and "tokenImage" set. The boolean
* flag "specialConstructor" is also set to true to indicate that
* this constructor was used to create this object.
* This constructor calls its super class with the empty string
* to force the "toString" method of parent class "Throwable" to
* print the error message in the form:
* ParseException: <result of getMessage>
*/
/**
* This constructor is used by the method "generateParseException"
* in the generated parser. Calling this constructor generates
* a new object of this type with the fields "currentToken",
* "expectedTokenSequences", and "tokenImage" set. The boolean
* flag "specialConstructor" is also set to true to indicate that
* this constructor was used to create this object.
* This constructor calls its super class with the empty string
* to force the "toString" method of parent class "Throwable" to
* print the error message in the form:
* {@code ParseException: <result of getMessage>}
*/
public ParseException(Token currentTokenVal,
int[][] expectedTokenSequencesVal,
String[] tokenImageVal

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramAddressFactory.java
View File

@ -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.
@ -40,7 +40,7 @@ public class ProgramAddressFactory extends DefaultAddressFactory {
* <li>A stack space (see {@link AddressSpace#TYPE_STACK})</li>
* <li>{@link AddressSpace#HASH_SPACE}</li>
* <li>A join space (see {@link AddressSpace#TYPE_JOIN})</li>
* </ol>
* </ul>
* In addition, support is provided for {@link ProgramOverlayAddressSpace}.
* @param language language specification
* @param compilerSpec compiler specification

49
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/SpecExtension.java
View File

@ -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.
@ -35,34 +35,37 @@ import ghidra.xml.*;
/**
* Utility class for installing/removing "specification extensions" to a Program.
* A specification extension is a program specific version of either a:
* - Prototype Model
* - Call Fixup or
* - Callother Fixup
* <ul>
* <li>Prototype Model</li>
* <li>Call Fixup or</li>
* <li>Callother Fixup</li>
* </ul>
* Normally these objects are provided by the language specific configuration files (.cspec or .pspec),
* but this class allows additional objects to be added that are specific to the program.
*
* <p>
* Internally, each spec extension is stored as an XML document as a formal Program Option. Each type of
* extension is described by a specific XML tag and is parsed as it would be in a .cspec or .pspec file.
* The XML tags are:
* - \<callfixup> - describing a Call Fixup
* - \<callotherfixup> - describing a Callother Fixup
* - \<prototype> - describing a typical Prototype Model
* - \<resolveprototype> - describing a Prototype Model merged from other models
*
* <ul>
* <li>{@code <callfixup>} - describing a Call Fixup</li>
* <li>{@code <callotherfixup>} - describing a Callother Fixup</li>
* <li>{@code <prototype>} - describing a typical Prototype Model</li>
* <li>{@code <resolveprototype>} - describing a Prototype Model merged from other models</li>
* </ul>
* Each type of object has a unique name or target, which must be specified as part of the XML tag,
* which is referred to in this class as the extension's "formal name". In the \<callotherfixup> tag,
* the formal name is given by the "targetop" attribute; for all the other tags, the formal name is
* given by the "name" attribute".
*
* which is referred to in this class as the extension's "formal name". In the
* {@code <callotherfixup>} tag, the formal name is given by the "targetop" attribute; for all the
* other tags, the formal name is given by the "name" attribute".
* <p>
* The parent option for all extensions is given by the static field SPEC_EXTENSION. Under the parent
* option, each extension is stored as a string with an option name, constructed by
* concatenating the extension's formal name with a prefix corresponding to the extension's XML tag name.
*
* <p>
* testExtensionDocument() is used independently to extensively test whether a document
* describes a valid extension.
*
* Extensions are installed on a program via addReplaceCompilerSpecExtension().
* Extensions are removed from a program via removeCompilerSpecExtension().
* <p>
* Extensions are installed on a program via {@code addReplaceCompilerSpecExtension()}.
* Extensions are removed from a program via {@code removeCompilerSpecExtension()}.
*/
public class SpecExtension {
@ -394,10 +397,12 @@ public class SpecExtension {
/**
* Parse an XML string and build the corresponding compiler spec extension object.
* Currently this can either be a
* - PrototypeModel or
* - InjectPayload
* <ul>
* <li>PrototypeModel</li>
* <li>InjectPayload</li>
* </ul>
*
* For InjectPayloadCallfixup or InjectPayloadCallother, the p-code \<body> tag
* For InjectPayloadCallfixup or InjectPayloadCallother, the p-code {@code <body>} tag
* is also parsed, and the caller can control whether any parse errors
* cause an exception or whether a dummy payload is provided instead.
* @param optionName is the option name the extension is attached to

15
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/util/AddressRangeMapDB.java
View File

@ -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.
@ -39,9 +39,9 @@ import ghidra.util.task.TaskMonitor;
* <P>
* This is implemented by storing records for each contiguous range with the same value.
* <ul>
* <li>The key is the encoded start address of the range.
* <li>The TO_COL column of the record stores the encoded end address of the range.
* <li>The VALUE_COL column of the record stores the value for the range.
* <li>The key is the encoded start address of the range.</li>
* <li>The TO_COL column of the record stores the encoded end address of the range.</li>
* <li>The VALUE_COL column of the record stores the value for the range.</li>
* </ul>
* <P>
* This implementation is complicated by several issues.
@ -51,7 +51,7 @@ import ghidra.util.task.TaskMonitor;
* Encoded addresses do not necessarily encode to keys that have the same ordering.
* Therefore, all comparisons must be done in address space and not in the encoded space.
* Also, record iterators must use the {@link AddressKeyRecordIterator} which will return
* records in address order versus encoded key order.
* records in address order versus encoded key order.</li>
* <li>The default space's image base can be changed after records have been created. This can
* cause the address ranges represented by a record to wrap around. For example, suppose
* the image base is 0 and you paint a range from address 0 to 0x20, which say maps to
@ -66,7 +66,8 @@ import ghidra.util.task.TaskMonitor;
* logic, any wrapping record will first be split into two records before painting. However
* we can only do this during a write operation (when we can make changes). Since the getter
* methods and iterators cannot modify the database, they have to deal with wrapping
* records on the fly.
* records on the fly.</li>
* </ol>
*/
public class AddressRangeMapDB implements DBListener {
public static final String RANGE_MAP_TABLE_PREFIX = "Range Map - ";

18
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/block/BasicBlockModel.java
View File

@ -1,13 +1,12 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* 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,14 +25,14 @@ import ghidra.program.model.symbol.*;
* Each Codeblock is made up of contiguous instructions in address order.
*
* Blocks satisfy the following:<ol>
* <li>Any instruction with a label starts a block.
* <li>Any instruction with a label starts a block.</li>
* <li>Each instruction that could cause program control flow to change local to
* the containing function (i.e., excludes calls) is the last instruction of a Codeblock.
* the containing function (i.e., excludes calls) is the last instruction of a Codeblock.</li>
* <li>All other instructions are "NOP" fallthroughs, meaning
* after execution the program counter will be at
* the instruction immediately following.
* the instruction immediately following.</li>
* <li>Any instruction that is unreachable and has no label is also considered the start
* of a block.
* of a block.</li>
* </ol>
* So a CodeBlock in this model consists of contiguous code that has zero or
* more fallthrough or call instructions followed by a single flow instruction.
@ -41,11 +40,12 @@ import ghidra.program.model.symbol.*;
* have a label at any other instruction contained in the block.
*
* This model handles delay slot instructions with the following
* assumptions:<ol>
* assumptions:
* <ol>
* <li>The delay slot depth of the delayed instruction will always
* correspond to the number of delay slot instructions immediately
* following the instruction. The model may not behave properly if
* the disassembled code violates this assumption.
* the disassembled code violates this assumption.</li>
* </ol>
* @see ghidra.program.model.block.CodeBlockModel
*/

25
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/block/SimpleBlockModel.java
View File

@ -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.
@ -30,34 +30,35 @@ import ghidra.util.task.TaskMonitor;
* Each Codeblock is made up of contiguous instructions in address order.
*
* Blocks satisfy the following:<ol>
* <li>Any instruction with a label starts a block.
* <li>Any instruction with a label starts a block.</li>
* <li>Each instruction that could cause program control flow to change is the
* last instruction of a Codeblock.
* last instruction of a Codeblock.</li>
* <li>All other instructions are "NOP" fallthroughs, meaning
* after execution the program counter will be at
* the instruction immediately following.
* the instruction immediately following.</li>
* <li>Any instruction that is unreachable and has no label is also considered the start
* of a block.
* of a block.</li>
* </ol>
* So a CodeBlock in this model consists of contiguous code that has zero or
* more nonflow fallthrough instructions followed by a single flow instruction.
* Each block may or may not have a label at the first instruction, but may not
* have a label at any other instruction contained in the block.
*
* <p>
* This model does not implement the pure simple block model
* because unreachable code is still considered a block.
*
* <p>
* This model handles delay slot instructions with the following
* assumptions:<ol>
* assumptions:
* <ol>
* <li>A delayed instruction is always corresponds to a change in
* flow and terminates a block. The delay slot instructions
* following this instruction are always included with the
* block. Therefor, delay slot instructions will always fall
* at the bottom of a simple block.
* block. Therefore, delay slot instructions will always fall
* at the bottom of a simple block.</li>
* <li>The delay slot depth of the delayed instruction will always
* correspond to the number of delay slot instructions immediately
* following the instruction. The model may not behave properly if
* the disassembled code violates this assumption.
* the disassembled code violates this assumption.</li>
* </ol>
* @see ghidra.program.model.block.CodeBlockModel
*/

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/BitFieldPackingImpl.java
View File

@ -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.
@ -165,7 +165,7 @@ public class BitFieldPackingImpl implements BitFieldPacking {
}
/**
* Restore settings from a \<bitfield_packing> tag in an XML stream.
* Restore settings from a {@code <bitfield_packing>} tag in an XML stream.
* The XML is designed to override existing settings from the default constructor
* @param parser is the XML stream
*/

10
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.java
View File

@ -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.
@ -275,9 +275,9 @@ public interface Composite extends DataType {
* affect of disabled packing differs between {@link Structure} and {@link Union}. When
* packing disabled:
* <ul>
* <li>Structures utilize explicit component offsets and produce undefined filler
* components where defined components do not consume space.</li>
* <li>Unions always place components at offset 0 and do not pad for alignment.
* <li>Structures utilize explicit component offsets and produce undefined filler
* components where defined components do not consume space.</li>
* <li>Unions always place components at offset 0 and do not pad for alignment.</li>
* </ul>
* In addition, when packing is disabled the default alignment is always 1 unless a
* different minimum alignment has been set. When packing is enabled the overall

2
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataUtilities.java
View File

@ -424,7 +424,7 @@ public final class DataUtilities {
* </li>
* <li>If the originalDataType is any type of pointer the supplied newDatatype
* will replace the pointer's base type (e.g., int * would become db * when
* newDataType is {@link ByteDataType}).
* newDataType is {@link ByteDataType}).</li>
* </ul>
* <P>If false, only required transformations will be applied, Example:
* if newDataType is a FunctionDefinitionDataType it will be transformed

28
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StringDataType.java
View File

@ -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.
@ -23,23 +23,23 @@ import ghidra.util.classfinder.ClassTranslator;
* <p>
* All string data types:
* <ul>
* <li>{@link StringDataType} - this type, fixed length, user settable charset.
* <li>{@link StringUTF8DataType} - fixed length UTF-8 string.
* <li>{@link TerminatedStringDataType} - terminated and unbounded string, user settable charset.
* <li>{@link TerminatedUnicodeDataType} - terminated and unbounded UTF-16 string.
* <li>{@link TerminatedUnicode32DataType} - terminated and unbounded UTF-32 string.
* <li>{@link PascalString255DataType} - length-prefixed string (limited to 255 chars), user settable charset.
* <li>{@link PascalStringDataType} - length-prefixed string (limited to 64k), user settable charset.
* <li>{@link PascalUnicodeDataType} - length-prefixed UTF-16 (limited to 64k).
* <li>{@link UnicodeDataType} - fixed length UTF-16 string.
* <li>{@link Unicode32DataType} - fixed length UTF-32 string.
* <li>{@link StringDataType} - this type, fixed length, user settable charset.</li>
* <li>{@link StringUTF8DataType} - fixed length UTF-8 string.</li>
* <li>{@link TerminatedStringDataType} - terminated and unbounded string, user settable charset.</li>
* <li>{@link TerminatedUnicodeDataType} - terminated and unbounded UTF-16 string.</li>
* <li>{@link TerminatedUnicode32DataType} - terminated and unbounded UTF-32 string.</li>
* <li>{@link PascalString255DataType} - length-prefixed string (limited to 255 chars), user settable charset.</li>
* <li>{@link PascalStringDataType} - length-prefixed string (limited to 64k), user settable charset.</li>
* <li>{@link PascalUnicodeDataType} - length-prefixed UTF-16 (limited to 64k).</li>
* <li>{@link UnicodeDataType} - fixed length UTF-16 string.</li>
* <li>{@link Unicode32DataType} - fixed length UTF-32 string.</li>
* </ul>
* <p>
* The following settings are supported by all string types on the data instance:
* <ul>
* <li> {@link TranslationSettingsDefinition} - controls display of string values that have been
* translated to english.
* <li> {@link RenderUnicodeSettingsDefinition} - controls display of non-ascii Unicode characters.
* translated to English.</li>
* <li> {@link RenderUnicodeSettingsDefinition} - controls display of non-ascii Unicode characters.</li>
* </ul>
*/
public class StringDataType extends AbstractStringDataType {

16
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StringLayoutEnum.java
View File

@ -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,12 +18,12 @@ package ghidra.program.model.data;
/**
* Controls strings termination
* <ul>
* <li>{@link StringLayoutEnum#FIXED_LEN}
* <li>{@link StringLayoutEnum#CHAR_SEQ}
* <li>{@link StringLayoutEnum#NULL_TERMINATED_UNBOUNDED}
* <li>{@link StringLayoutEnum#NULL_TERMINATED_BOUNDED}
* <li>{@link StringLayoutEnum#PASCAL_255}
* <li>{@link StringLayoutEnum#PASCAL_64k}
* <li>{@link StringLayoutEnum#FIXED_LEN}</li>
* <li>{@link StringLayoutEnum#CHAR_SEQ}</li>
* <li>{@link StringLayoutEnum#NULL_TERMINATED_UNBOUNDED}</li>
* <li>{@link StringLayoutEnum#NULL_TERMINATED_BOUNDED}</li>
* <li>{@link StringLayoutEnum#PASCAL_255}</li>
* <li>{@link StringLayoutEnum#PASCAL_64k}</li>
* </ul>
*/
public enum StringLayoutEnum {

2
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureDataType.java
View File

@ -29,7 +29,7 @@ import ghidra.util.exception.AssertException;
* NOTES:
* <ul>
* <li>Implementation is not thread safe when being modified.</li>
* <li>For a structure to treated as having a zero-length (see {@link #isZeroLength()}) it
* <li>For a structure to treated as having a zero-length (see {@link #isZeroLength()}) it </li>
*
* </ul>
*

36
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureFactory.java
View File

@ -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.
@ -47,12 +47,12 @@ public class StructureFactory {
* @return A new structure not yet added to memory.
* @throws IllegalArgumentException for the following conditions:
* <ul>
* <li>if <code>dataLength</code> is not greater than zero
* <li>if <code>dataLength</code> is not greater than zero</li>
* <li>if the number of components to add exceeds the available
* address space
* address space</li>
* <li>if there are any instructions in the provided
* address space
* <li>if there are no data components to add to the structure
* address space</li>
* <li>if there are no data components to add to the structure</li>
* </ul>
*/
public static Structure createStructureDataType(Program program, Address address,
@ -73,13 +73,13 @@ public class StructureFactory {
* @return A new structure not yet added to memory.
* @throws IllegalArgumentException for the following conditions:
* <ul>
* <li>if <code>structureName</code> is <code>null</code>
* <li>if <code>dataLength</code> is not greater than zero
* <li>if <code>structureName</code> is <code>null</code></li>
* <li>if <code>dataLength</code> is not greater than zero</li>
* <li>if the number of components to add exceeds the available
* address space
* address space</li>
* <li>if there are any instructions in the provided
* address space
* <li>if there are no data components to add to the structure
* address space</li>
* <li>if there are no data components to add to the structure</li>
* </ul>
*/
public static Structure createStructureDataType(Program program, Address address,
@ -147,9 +147,9 @@ public class StructureFactory {
* @throws IllegalArgumentException for the following conditions:
* <ul>
* <li>if the component at <code>fromPath</code> or the component
* at <code>toPath</code> are null
* <li>if there is not data to add to the structure
* <li>if the parent data type is not a structure
* at <code>toPath</code> are null</li>
* <li>if there is not data to add to the structure</li>
* <li>if the parent data type is not a structure</li>
* </ul>
*/
public static Structure createStructureDataTypeInStrucuture(Program program, Address address,
@ -176,11 +176,11 @@ public class StructureFactory {
* @return A new structure not yet added to memory.
* @throws IllegalArgumentException for the following conditions:
* <ul>
* <li>if <code>structureName</code> is <code>null</code>
* <li>if <code>structureName</code> is <code>null</code></li>
* <li>if the component at <code>fromPath</code> or the component
* at <code>toPath</code> are null
* <li>if there is not data to add to the structure
* <li>if the parent data type is not a structure
* at <code>toPath</code> are null</li>
* <li>if there is not data to add to the structure</li>
* <li>if the parent data type is not a structure</li>
* </ul>
*/
public static Structure createStructureDataTypeInStrucuture(Program program, Address address,

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/BasicCompilerSpec.java
View File

@ -5,9 +5,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.
@ -582,7 +582,7 @@ public class BasicCompilerSpec implements CompilerSpec {
}
/**
* Initialize this object from an XML stream. A single \<compiler_spec> tag is expected.
* Initialize this object from an XML stream. A single {@code <compiler_spec>} tag is expected.
* @param parser is the XML stream
* @throws XmlParseException for badly formed XML
* @throws DuplicateNameException if we parse more than one PrototypeModel with the same name

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/CompilerSpec.java
View File

@ -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.
@ -261,7 +261,7 @@ public interface CompilerSpec {
/**
* Encode this entire specification to a stream. A document is written with
* root element \<compiler_spec>.
* root element {@code <compiler_spec>}.
* @param encoder is the stream encoder
* @throws IOException for errors writing to the underlying stream
*/

10
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/ContextSetting.java
View File

@ -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.
@ -47,11 +47,11 @@ public final class ContextSetting {
}
/**
* Construct from an XML \<set> tag. The tag is a child of either \<context_set> or \<tracked_set>
* which provides details of the memory range affected.
* Construct from an XML {@code <set>} tag. The tag is a child of either {@code <context_set>}
* or {@code <tracked_set>} which provides details of the memory range affected.
* @param el is the XML tag
* @param cspec is used to lookup register names present in the tag
* @param isContextReg is true for a \<context_set> parent, false for a \<tracked_set> parent
* @param isContextReg is true for a {@code <context_set>} parent, false for a {@code <tracked_set>} parent
* @param first is the first Address in the affected memory range
* @param last is the last Address in the affected memory range
*/

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/InjectPayload.java
View File

@ -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.
@ -157,7 +157,7 @@ public interface InjectPayload {
public boolean isIncidentalCopy();
/**
* Encode configuration parameters as a \<pcode> element to stream
* Encode configuration parameters as a {@code <pcode>} element to stream
* @param encoder is the stream encoder
* @throws IOException for errors writing to the underlying stream
*/
@ -165,7 +165,7 @@ public interface InjectPayload {
/**
* Restore the payload from an XML stream. The root expected document is
* the \<pcode> tag, which may be wrapped with another tag by the derived class.
* the {@code <pcode>} tag, which may be wrapped with another tag by the derived class.
* @param parser is the XML stream
* @param language is used to resolve registers and address spaces
* @throws XmlParseException for badly formed XML

41
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/AddressXML.java
View File

@ -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,15 +34,16 @@ import ghidra.xml.XmlParseException;
/**
* Utility class for the myriad ways of marshaling/unmarshaling an address and an optional size,
* to/from XML for the various configuration files.
*
* <p>
* An object of the class itself is the most general form, where the specified address
* - MAY have an associated size given in bytes
* - MAY be in the JOIN address space, with physical pieces making up the logical value explicitly provided.
*
* The static buildXML methods write out an \<addr> tag given component elements without allocating an object.
* <ul>
* <li>MAY have an associated size given in bytes</li>
* <li>MAY be in the JOIN address space, with physical pieces making up the logical value explicitly provided</li>
* </ul>
* The static buildXML methods write out an {@code <addr>} tag given component elements without allocating an object.
* The static readXML methods read XML tags (presented in different forms) and returns an Address object.
* The static appendAttributes methods write out attributes of an address to an arbitrary XML tag.
* The static restoreXML methods read an \<addr> tag and produce a general AddressXML object.
* The static restoreXML methods read an {@code <addr>} tag and produce a general AddressXML object.
*/
public class AddressXML {
@ -136,7 +137,7 @@ public class AddressXML {
}
/**
* Encode this sized address as an \<addr> element to the stream
* Encode this sized address as an {@code <addr>} element to the stream
* @param encoder is the stream encoder
* @throws IOException for errors in the underlying stream
*/
@ -433,12 +434,14 @@ public class AddressXML {
/**
* Create an address from a stream encoding. This recognizes elements
* - \<addr>
* - \<spaceid>
* - \<iop> or
* - any element with "space" and "offset" attributes
*
* An empty \<addr> element, with no attributes, results in Address.NO_ADDRESS being returned.
* <ul>
* <li>{@code <addr>}</li>
* <li>{@code <spaceid>}</li>
* <li>{@code <iop>} or</li>
* <li>any element with "space" and "offset" attributes</li>
* </ul>
* An empty {@code <addr>} element, with no attributes, results in {@link Address#NO_ADDRESS}
* being returned.
* @param decoder is the stream decoder
* @return Address created from decode info
* @throws DecoderException for any problems decoding the stream
@ -545,7 +548,7 @@ public class AddressXML {
}
/**
* Encode the given Address as an \<addr> element to the stream
* Encode the given Address as an {@code <addr>} element to the stream
*
* @param encoder is the stream encoder
* @param addr -- Address to encode
@ -563,7 +566,7 @@ public class AddressXML {
}
/**
* Encode the given Address and a size as an \<addr> element to the stream
* Encode the given Address and a size as an {@code <addr>} element to the stream
*
* @param encoder is the stream encoder
* @param addr is the given Address
@ -577,9 +580,9 @@ public class AddressXML {
}
/**
* Encode a sequence of Varnodes as a single \<addr> element to the stream.
* Encode a sequence of Varnodes as a single {@code <addr>} element to the stream.
* If there is more than one Varnode, or if the logical size is non-zero,
* the \<addr> element will specify the address space as "join" and will have
* the {@code <addr>} element will specify the address space as "join" and will have
* additional "piece" attributes.
*
* @param encoder is the stream encoder

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/PcodeDataTypeManager.java
View File

@ -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.
@ -826,8 +826,8 @@ public class PcodeDataTypeManager {
/**
* Encode a TypeDef data-type to the stream. Generally this sends
* a \<def> element with a \<typeref> reference to the underlying data-type being typedefed,
* but we check for Settings on the TypeDef object that can indicate
* a {@code <def>} element with a {@code <typeref>} reference to the underlying data-type being
* typedefed, but we check for Settings on the TypeDef object that can indicate
* specialty data-types with their own encodings.
* @param encoder is the stream encoder
* @param type is the TypeDef to build the XML for

6
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/PcodeOp.java
View File

@ -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.
@ -431,7 +431,7 @@ public class PcodeOp {
/**
* Encode just the opcode and input/output Varnode data for this PcodeOp to a stream
* as an \<op> element
* as an {@code <op>} element
* @param encoder is the stream encoder
* @param addrFactory is a factory for looking up encoded address spaces
* @throws IOException for errors in the underlying stream

6
Ghidra/Framework/Utility/src/main/java/ghidra/framework/ApplicationIdentifier.java
View File

@ -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.
@ -29,7 +29,7 @@ import utility.application.ApplicationUtilities;
* <p>
* Examples:
* <ul>
* <li>ghidra-7.4_DEV
* <li>ghidra-7.4_DEV</li>
* </ul>
*/
public class ApplicationIdentifier {

12
Ghidra/Framework/Utility/src/main/java/ghidra/framework/ApplicationVersion.java
View File

@ -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,16 +18,16 @@ package ghidra.framework;
/**
* Class to represent an application's version information.
* <p>
* The version format is \d\.\d(\.\d)?(\-.+)?
* The version format is {@code \d\.\d(\.\d)?(\-.+)?}
* <p>
* Note: this class has a natural ordering that is inconsistent with equals (the <code>tag</code>
* part of the version is disregarded in the {@link #compareTo(ApplicationVersion)} method).
* <p>
* Examples:
* <ul>
* <li>7.4
* <li>7.4.1
* <li>7.4.1-BETA
* <li>7.4</li>
* <li>7.4.1</li>
* <li>7.4.1-BETA</li>
* </ul>
*/
public class ApplicationVersion implements Comparable<ApplicationVersion> {

12
Ghidra/Framework/Utility/src/main/java/ghidra/util/UserSearchUtils.java
View File

@ -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.
@ -82,10 +82,10 @@ public class UserSearchUtils {
* <b>Note: </b>This method <b>will</b> escape regular expression
* characters, such as:
* <ul>
* <li>?
* <li>.
* <li>$
* <li>...and many others
* <li>?</li>
* <li>.</li>
* <li>$</li>
* <li>...and many others</li>
* </ul>
* Thus, this method is not meant to <b>accept</b> regular expressions, but
* rather <b>generates</b> regular expressions.