yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-05 02:39:44 +02:00
Code Issues Releases Wiki Activity

GP-1361 - Updated auto comments to show user-defined repeatable comments

Browse source 
from the reference destination

Closes #2475
This commit is contained in:
dragonmacher 2021-10-18 17:07:45 -04:00
parent f9463e600d
commit a54d0e28d6
5 changed files with 170 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/navigation/locationreferences/ReferenceUtils.java
View file

@ -855,7 +855,7 @@ public final class ReferenceUtils {
// }
//
// Using the reference, we can heck for the 'Extended Markup' style reference, such as:
// Using the reference, we can check for the 'Extended Markup' style reference, such as:
// instruction ...=>Foo.bar.baz
// -------------
// Note: these references are to labels (not sure why the reference isn't to a data

51
Ghidra/Features/Base/src/main/java/ghidra/app/util/DisplayableEol.java
View file

@ -17,6 +17,8 @@ package ghidra.app.util;
import java.util.*;
import org.apache.commons.lang3.StringUtils;
import docking.widgets.fieldpanel.support.RowColLocation;
import ghidra.program.model.address.*;
import ghidra.program.model.data.*;
@ -116,7 +118,7 @@ public class DisplayableEol {
/**
* Return whether the associated code unit has an end of line comment
* @return whether the associated code unit has an end of line comment
* @return whether the associated code unit has an end of line comment
*/
public boolean hasEOL() {
return (displayCommentArrays[MY_EOLS] != null) &&
@ -144,10 +146,10 @@ public class DisplayableEol {
}
/**
* Return whether this code unit has an automatic comment. For example, a memory reference
* from this code unit has a function defined at the reference's to address, or if the to
* Return whether this code unit has an automatic comment. For example, a memory reference
* from this code unit has a function defined at the reference's to address, or if the to
* address is a pointer.
* @return whether this code unit has an automatic comment
* @return whether this code unit has an automatic comment
*/
public boolean hasAutomatic() {
return (displayCommentArrays[MY_AUTOMATIC] != null) &&
@ -240,7 +242,10 @@ public class DisplayableEol {
}
}
set.add("= " + getDataValueRepresentation(dataAccessAddress, data));
String dataRepresentation = getDataValueRepresentation(dataAccessAddress, data);
if (!StringUtils.isBlank(dataRepresentation)) {
set.add("= " + dataRepresentation);
}
}
private String getDataValueRepresentation(Address dataAccessAddress, Data data) {
@ -249,8 +254,7 @@ public class DisplayableEol {
}
if (isOffcut(dataAccessAddress, data)) {
String offcut = getOffcutDataString(dataAccessAddress, data);
return offcut;
return getOffcutDataString(dataAccessAddress, data);
}
return data.getDefaultValueRepresentation();
@ -516,13 +520,17 @@ public class DisplayableEol {
}
Address address = memRefs[i].getToAddress();
String repeatableComment = listing.getComment(CodeUnit.REPEATABLE_COMMENT, address);
if (repeatableComment != null) {
set.add(new RefRepeatComment(address, new String[] { repeatableComment }));
}
CodeUnit cu = listing.getCodeUnitAt(address);
if (cu == null) {
continue;
}
String[] comment = new String[0];
Function func = listing.getFunctionAt(address);
if (func != null) {
comment = func.getRepeatableCommentAsArray();
@ -643,6 +651,33 @@ public class DisplayableEol {
return (String[]) displayCommentArrays[MY_AUTOMATIC];
}
@Override
public String toString() {
StringBuilder buffy = new StringBuilder();
String[] eols = (String[]) displayCommentArrays[MY_EOLS];
if (eols.length != 0) {
buffy.append("EOLs: ").append(Arrays.toString(eols));
}
String[] myRepeatables = (String[]) displayCommentArrays[MY_REPEATABLES];
if (myRepeatables.length != 0) {
buffy.append("My Repeatables: ").append(Arrays.toString(myRepeatables));
}
Object[] refRepeatables = displayCommentArrays[REF_REPEATABLES];
if (refRepeatables.length != 0) {
buffy.append("Ref Repeatables: ").append(Arrays.toString(refRepeatables));
}
String[] myAutomatic = (String[]) displayCommentArrays[MY_AUTOMATIC];
if (myAutomatic.length != 0) {
buffy.append("My Automatic: ").append(Arrays.toString(myAutomatic));
}
return buffy.toString();
}
public int getCommentLineCount(int subType) {
switch (subType) {
case MY_EOLS:

9
Ghidra/Features/Base/src/main/java/ghidra/app/util/viewer/field/EolCommentFieldFactory.java
View file

@ -81,7 +81,7 @@ public class EolCommentFieldFactory extends FieldFactory {
private int refRepeatableCommentStyle;
// The codeUnitFormatOptions is used to monitor "follow pointer..." option to avoid
// duplication of data within auto-comment. We don't bother adding a listener
// duplication of data within auto-comment. We don't bother adding a listener
// to kick the model since this is done by the operand field.
private BrowserCodeUnitFormatOptions codeUnitFormatOptions;
@ -310,7 +310,8 @@ public class EolCommentFieldFactory extends FieldFactory {
new DisplayableEol(cu, alwaysShowRepeatable, alwaysShowRefRepeatables,
alwaysShowAutomatic, codeUnitFormatOptions.followReferencedPointers(),
maxDisplayLines, useAbbreviatedAutomatic, showAutomaticFunctions);
ArrayList<FieldElement> elementList = new ArrayList<>();
List<FieldElement> elementList = new ArrayList<>();
// This Code Unit's End of Line Comment
AttributedString myEolPrefixString =
@ -335,7 +336,6 @@ public class EolCommentFieldFactory extends FieldFactory {
if (alwaysShowRefRepeatables || elementList.isEmpty()) {
AttributedString refRepeatPrefixString = new AttributedString(SEMICOLON_PREFIX,
refRepeatableCommentColor, getMetrics(refRepeatableCommentStyle), false, null);
//int refRepeatLinesSoFar = 0;
int refRepeatCount = displayableEol.getReferencedRepeatableCommentsCount();
for (int subTypeIndex = 0; subTypeIndex < refRepeatCount; subTypeIndex++) {
RefRepeatComment refRepeatComment =
@ -345,7 +345,6 @@ public class EolCommentFieldFactory extends FieldFactory {
refRepeatComments, program, refRepeatPrefixString, showSemicolon, isWordWrap,
prependRefAddress, refRepeatComment.getAddress(), getNextRow(elementList));
elementList.addAll(refRepeatFieldElements);
//refRepeatLinesSoFar += refRepeatComments.length;
}
}
@ -368,7 +367,7 @@ public class EolCommentFieldFactory extends FieldFactory {
maxDisplayLines, hlProvider);
}
private int getNextRow(ArrayList<FieldElement> elementList) {
private int getNextRow(List<FieldElement> elementList) {
int elementIndex = elementList.size() - 1;
if (elementIndex >= 0) {
FieldElement element = elementList.get(elementIndex);

87
Ghidra/Features/Base/src/test.slow/java/ghidra/app/util/viewer/field/EolCommentFieldFactoryTest.java
View file

@ -15,6 +15,7 @@
*/
package ghidra.app.util.viewer.field;
import static org.hamcrest.core.StringStartsWith.*;
import static org.junit.Assert.*;
import javax.swing.SwingUtilities;
@ -22,21 +23,17 @@ import javax.swing.SwingUtilities;
import org.junit.*;
import docking.widgets.fieldpanel.field.FieldElement;
import ghidra.app.plugin.core.blockmodel.BlockModelServicePlugin;
import ghidra.app.plugin.core.codebrowser.CodeBrowserPlugin;
import ghidra.app.plugin.core.navigation.NextPrevAddressPlugin;
import ghidra.framework.options.Options;
import ghidra.framework.plugintool.PluginTool;
import ghidra.program.database.ProgramBuilder;
import ghidra.program.database.ProgramDB;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressFactory;
import ghidra.program.model.listing.*;
import ghidra.test.AbstractGhidraHeadedIntegrationTest;
import ghidra.test.TestEnv;
import ghidra.test.*;
public class EolCommentFieldFactoryTest extends AbstractGhidraHeadedIntegrationTest {
private TestEnv env;
private PluginTool tool;
private CodeBrowserPlugin cb;
private Options fieldOptions;
private Program program;
@ -47,12 +44,8 @@ public class EolCommentFieldFactoryTest extends AbstractGhidraHeadedIntegrationT
program = buildProgram();
env = new TestEnv();
tool = env.showTool(program);
tool.addPlugin(CodeBrowserPlugin.class.getName());
tool.addPlugin(NextPrevAddressPlugin.class.getName());
env.launchDefaultTool(program);
cb = env.getPlugin(CodeBrowserPlugin.class);
tool.addPlugin(BlockModelServicePlugin.class.getName());
fieldOptions = cb.getFormatManager().getFieldOptions();
}
@ -78,15 +71,50 @@ public class EolCommentFieldFactoryTest extends AbstractGhidraHeadedIntegrationT
assertEquals(4, tf.getNumRows());
}
@Test
public void testRepeatableComment_FunctionCall() throws Exception {
// check existing auto comment
ListingTextField tf = getFieldText(addr("0x010022e6"));
assertEquals(1, tf.getNumRows());
assertThat(tf.getText(), startsWith("undefined ghidra(undefined4 param_1,"));
// set repeatable comment at destination
Address destination = addr("0x01002cf5");
String repeatableComment = "My repeatable comment";
setRepeatableComment(destination, repeatableComment);
// check that the auto comment now matches the updated comment
tf = getFieldText(addr("0x010022e6"));
assertEquals(1, tf.getNumRows());
assertEquals(tf.getText(), repeatableComment);
}
@Test
public void testRepeatableComment_DataAccess() throws Exception {
// check existing auto comment
ListingTextField tf = getFieldText(addr("0x01002265"));
assertEquals(1, tf.getNumRows());
assertThat(tf.getText(), startsWith("= 01h"));
// set repeatable comment at destination
Address destination = addr("0x01002265");
String repeatableComment = "My repeatable comment";
setRepeatableComment(destination, repeatableComment);
// check that the auto comment now matches the updated comment
tf = getFieldText(addr("0x01002265"));
assertEquals(1, tf.getNumRows());
assertEquals(tf.getText(), repeatableComment);
}
//==================================================================================================
// Private Methods
//==================================================================================================
private ProgramDB buildProgram() throws Exception {
ProgramBuilder builder = new ProgramBuilder("sample", ProgramBuilder._TOY, this);
builder.createMemory(".text", "0x1001000", 0x6600);
builder.createEmptyFunction(null, "0x1002000", 20, null);
ClassicSampleX86ProgramBuilder builder = new ClassicSampleX86ProgramBuilder();
return builder.getProgram();
}
@ -111,29 +139,46 @@ public class EolCommentFieldFactoryTest extends AbstractGhidraHeadedIntegrationT
private void changeFieldWidthToHalfCommentLength(Function function) throws Exception {
ListingTextField tf = getFieldText(function);
FieldElement fieldElement = tf.getFieldElement(0, 0);
int stringWidth = fieldElement.getStringWidth();
setFieldWidth(tf.getFieldFactory(), stringWidth / 2);
}
private ListingTextField getFieldText(Function function) {
assertTrue(cb.goToField(function.getEntryPoint(), EolCommentFieldFactory.FIELD_NAME, 1, 1));
return getFieldText(function.getEntryPoint());
}
private ListingTextField getFieldText(Address address) {
assertTrue(cb.goToField(address, EolCommentFieldFactory.FIELD_NAME, 1, 1));
ListingTextField tf = (ListingTextField) cb.getCurrentField();
return tf;
}
private void setFieldWidth(final FieldFactory fieldFactory, final int width) throws Exception {
SwingUtilities.invokeAndWait(() -> fieldFactory.setWidth(width));
waitForPostedSwingRunnables();
waitForSwing();
cb.updateNow();
}
private void setBooleanOption(final String name, final boolean value) throws Exception {
SwingUtilities.invokeAndWait(() -> fieldOptions.setBoolean(name, value));
waitForPostedSwingRunnables();
waitForSwing();
cb.updateNow();
}
private Address addr(String address) {
AddressFactory addressFactory = program.getAddressFactory();
return addressFactory.getAddress(address);
}
private void setRepeatableComment(Address a, String comment) {
setComment(a, CodeUnit.REPEATABLE_COMMENT, comment);
}
private void setComment(Address a, int commentType, String comment) {
CodeUnit cu = program.getListing().getCodeUnitAt(a);
tx(program, () -> {
cu.setComment(commentType, comment);
});
}
}

111
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.java
View file

@ -38,11 +38,11 @@ public interface Composite extends DataType {
public abstract int getNumComponents();
/**
* Returns the number of explicitly defined components in this composite.
* For Unions and packed Structures this is equivalent to {@link #getNumComponents()}
* since they do not contain undefined components.
* This count will always exclude all undefined filler components which may be present
* within a Structure whoose packing is disabled (see {@link #isPackingEnabled()}).
* Returns the number of explicitly defined components in this composite.
* For Unions and packed Structures this is equivalent to {@link #getNumComponents()}
* since they do not contain undefined components.
* This count will always exclude all undefined filler components which may be present
* within a Structure whose packing is disabled (see {@link #isPackingEnabled()}).
* @return the number of explicitly defined components in this composite
*/
public abstract int getNumDefinedComponents();
@ -66,8 +66,8 @@ public interface Composite extends DataType {
/**
* Returns an array of Data Type Components that make up this composite excluding
* undefined filler components which may be present within Structures where packing is disabled.
* The number of components corresponds to {@link #getNumDefinedComponents()}. For Unions and
* packed Structures this is equivalent to {@link #getComponents()}
* The number of components corresponds to {@link #getNumDefinedComponents()}. For Unions and
* packed Structures this is equivalent to {@link #getComponents()}
* since they do not contain undefined filler components.
* @return array all explicitly defined components
*/
@ -78,7 +78,7 @@ public interface Composite extends DataType {
* to use for adding components to an aligned structure for fixed-length dataTypes.
* @param dataType the datatype to add.
* @return the DataTypeComponent created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be added to this composite data type.
* For example, suppose dt1 contains dt2. Therefore it is not valid
* to add dt1 to dt2 since this would cause a cyclic dependency.
@ -87,13 +87,13 @@ public interface Composite extends DataType {
/**
* Adds a new datatype to the end of this composite. This is the preferred method
* to use for adding components to an aligned structure for dynamic dataTypes such as
* to use for adding components to an aligned structure for dynamic dataTypes such as
* strings whose length must be specified.
* @param dataType the datatype to add.
* @param length the length to associate with the datatype.
* For fixed length types a length &lt;= 0 will use the length of the resolved dataType.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be added to this composite data type or an invalid length
* is specified.
* For example, suppose dt1 contains dt2. Therefore it is not valid
@ -108,7 +108,7 @@ public interface Composite extends DataType {
* @param name the field name to associate with this component.
* @param comment the comment to associate with this component.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be added to this composite data type.
* For example, suppose dt1 contains dt2. Therefore it is not valid
* to add dt1 to dt2 since this would cause a cyclic dependency.
@ -117,8 +117,8 @@ public interface Composite extends DataType {
throws IllegalArgumentException;
/**
* Adds a new bitfield to the end of this composite. This method is intended
* to be used with packed structures/unions only where the bitfield will be
* Adds a new bitfield to the end of this composite. This method is intended
* to be used with packed structures/unions only where the bitfield will be
* appropriately packed. The minimum storage storage byte size will be applied.
* It will not provide useful results for composites with packing disabled.
* @param baseDataType the bitfield base datatype (certain restrictions apply).
@ -135,7 +135,7 @@ public interface Composite extends DataType {
/**
* Adds a new datatype to the end of this composite. This is the preferred method
* to use for adding components to an aligned structure for dynamic dataTypes such as
* to use for adding components to an aligned structure for dynamic dataTypes such as
* strings whose length must be specified.
* @param dataType the datatype to add.
* @param length the length to associate with the datatype.
@ -143,7 +143,7 @@ public interface Composite extends DataType {
* @param name the field name to associate with this component.
* @param comment the comment to associate with this component.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be added to this composite data type or an invalid length is specified.
* For example, suppose dt1 contains dt2. Therefore it is not valid
* to add dt1 to dt2 since this would cause a cyclic dependency.
@ -155,10 +155,10 @@ public interface Composite extends DataType {
* Inserts a new datatype at the specified ordinal position in this composite.
* <BR>Note: For an aligned structure the ordinal position will get adjusted
* automatically to provide the proper alignment.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param dataType the datatype to insert.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be inserted into this composite data type.
* For example, suppose dt1 contains dt2. Therefore it is not valid
* to insert dt1 to dt2 since this would cause a cyclic dependency.
@ -171,13 +171,13 @@ public interface Composite extends DataType {
* Inserts a new datatype at the specified ordinal position in this composite.
* <BR>Note: For an aligned structure the ordinal position will get adjusted
* automatically to provide the proper alignment.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param dataType the datatype to insert.
* @param length the length to associate with the datatype.
* For fixed length types a length &lt;= 0 will use the length of the resolved dataType.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* allowed to be inserted into this composite data type or an invalid
* @throws IllegalArgumentException if the specified data type is not
* allowed to be inserted into this composite data type or an invalid
* length is specified.
* For example, suppose dt1 contains dt2. Therefore it is not valid
* to insert dt1 to dt2 since this would cause a cyclic dependency.
@ -190,14 +190,14 @@ public interface Composite extends DataType {
* Inserts a new datatype at the specified ordinal position in this composite.
* <BR>Note: For an aligned structure the ordinal position will get adjusted
* automatically to provide the proper alignment.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param ordinal the ordinal where the new datatype is to be inserted.
* @param dataType the datatype to insert.
* @param length the length to associate with the datatype.
* For fixed length types a length &lt;= 0 will use the length of the resolved dataType.
* @param name the field name to associate with this component.
* @param comment the comment to associate with this component.
* @return the componentDataType created.
* @throws IllegalArgumentException if the specified data type is not
* @throws IllegalArgumentException if the specified data type is not
* allowed to be inserted into this composite data type or an invalid length
* is specified.
* For example, suppose dt1 contains dt2. Therefore it is not valid
@ -209,7 +209,7 @@ public interface Composite extends DataType {
/**
* Deletes the component at the given ordinal position.
* <BR>Note: Removal of bitfields from a structure with packing disabled will
* <BR>Note: Removal of bitfields from a structure with packing disabled will
* not shift other components causing vacated bytes to revert to undefined filler.
* @param ordinal the ordinal of the component to be deleted.
* @throws IndexOutOfBoundsException if component ordinal is out of bounds
@ -218,7 +218,7 @@ public interface Composite extends DataType {
/**
* Deletes the specified set of components at the given ordinal positions.
* <BR>Note: Removal of bitfields from a structure with packing disabled will
* <BR>Note: Removal of bitfields from a structure with packing disabled will
* not shift other components causing vacated bytes to revert to undefined filler.
* @param ordinals the ordinals of the component to be deleted.
* @throws IndexOutOfBoundsException if any specified component ordinal is out of bounds
@ -232,7 +232,7 @@ public interface Composite extends DataType {
* <br>containing the data type directly
* <br>containing another data type that has the data type as a part of it.
* @param dataType the data type to look for.
* @return true if the indicated data type is part of a sub-component of
* @return true if the indicated data type is part of a sub-component of
* this data type.
*/
public abstract boolean isPartOf(DataType dataType);
@ -271,7 +271,7 @@ public interface Composite extends DataType {
}
/**
* Sets whether this data type's internal components are currently packed. The
* Sets whether this data type's internal components are currently packed. The
* affect of disabled packing differs between {@link Structure} and {@link Union}. When
* packing disabled:
* <ul>
@ -280,11 +280,11 @@ public interface Composite extends DataType {
* <li>Unions always place components at offset 0 and do not pad for alignment.
* </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
* composite length infleunced by the composite's minimum alignment setting.
* If a change in enablement occurs, the default alignment and packing behavior
* different minimum alignment has been set. When packing is enabled the overall
* composite length influenced by the composite's minimum alignment setting.
* If a change in enablement occurs, the default alignment and packing behavior
* will be used.
* @param enabled true enables packing of components respecting component
* @param enabled true enables packing of components respecting component
* alignment and pack setting, whereas false disables packing.
*/
public void setPackingEnabled(boolean enabled);
@ -306,19 +306,19 @@ public interface Composite extends DataType {
}
/**
* Gets the current packing value (typically a power of 2).
* If this isn't a packed composite with an explicit packing value (see {@link #hasExplicitPackingValue()})
* then the return value is undefined.
* Gets the current packing value (typically a power of 2).
* If this isn't a packed composite with an explicit packing value (see {@link #hasExplicitPackingValue()})
* then the return value is undefined.
* @return the current packing value or an undefined non-positive value
*/
public int getExplicitPackingValue();
/**
* Sets the pack value for this composite (positive value, usually a power of 2).
* If packing was previously disabled, packing will be enabled. This value will
* establish the maximum effective alignment for this composite and each of the
* components during the alignment computation (e.g., a value of 1 will eliminate
* any padding). The overall composite length may be infleunced by the composite's
* Sets the pack value for this composite (positive value, usually a power of 2).
* If packing was previously disabled, packing will be enabled. This value will
* establish the maximum effective alignment for this composite and each of the
* components during the alignment computation (e.g., a value of 1 will eliminate
* any padding). The overall composite length may be influenced by the composite's
* minimum alignment setting.
* @param packingValue the new positive packing value.
* @throws IllegalArgumentException if a non-positive value is specified.
@ -335,10 +335,10 @@ public interface Composite extends DataType {
}
/**
* Enables default packing behavior.
* If packing was previously disabled, packing will be enabled.
* Enables default packing behavior.
* If packing was previously disabled, packing will be enabled.
* Composite will automatically pack based upon the alignment requirements
* of its components with overall composite length possibly infleunced by the composite's
* of its components with overall composite length possibly influenced by the composite's
* minimum alignment setting.
*/
public void setToDefaultPacking();
@ -358,16 +358,16 @@ public interface Composite extends DataType {
abstract AlignmentType getAlignmentType();
/**
* Whether or not this data type is using the default alignment. When Structure packing
* Whether or not this data type is using the default alignment. When Structure packing
* is disabled the default alignment is always 1 (see {@link Structure#setPackingEnabled(boolean)}.
* @return true if this data type is using its default alignment.
* @return true if this data type is using its default alignment.
*/
public default boolean isDefaultAligned() {
return getAlignmentType() == AlignmentType.DEFAULT;
}
/**
* Whether or not this data type is using the machine alignment value, specified by
* Whether or not this data type is using the machine alignment value, specified by
* {@link DataOrganization#getMachineAlignment()}, for its alignment.
* @return true if this data type is using the machine alignment as its alignment.
*/
@ -376,8 +376,9 @@ public interface Composite extends DataType {
}
/**
* Determine if an explicit minimum alignment has been set (see {@link #getExplicitMinimumAlignment()}).
* An undefined value is returned if default alignment or machine alignment is enabled.
* Determine if an explicit minimum alignment has been set (see
* {@link #getExplicitMinimumAlignment()}). An undefined value is returned if default alignment
* or machine alignment is enabled.
* @return true if an explicit minimum alignment has been set, else false
*/
public default boolean hasExplicitMinimumAlignment() {
@ -385,20 +386,20 @@ public interface Composite extends DataType {
}
/**
* Get the explicitminimum alignment setting for this Composite which contributes
* Get the explicit minimum alignment setting for this Composite which contributes
* to the actual computed alignment value (see {@link #getAlignment()}.
* @return the minimum alignment setting for this Composite or an undefined
* @return the minimum alignment setting for this Composite or an undefined
* non-positive value if an explicit minimum alignment has not been set.
*/
public int getExplicitMinimumAlignment();
/**
* Sets this data type's explicit minimum alignment (positive value).
* Sets this data type's explicit minimum alignment (positive value).
* Together with the pack setting and component alignments will
* affect the actual computed alignment of this composite.
* When packing is enabled, the alignment setting may also affect padding
* When packing is enabled, the alignment setting may also affect padding
* at the end of the composite and its length. When packing is disabled,
* this setting will not affect the length of thhis composite.
* this setting will not affect the length of this composite.
* @param minAlignment the minimum alignment for this Composite.
* @throws IllegalArgumentException if a non-positive value is specified
*/
@ -416,14 +417,14 @@ public interface Composite extends DataType {
/**
* Sets this data type's alignment to its default alignment. For packed
* composites, this data type's alignment will be based upon the components it contains and
* its current pack settings. This is the default state and only needs to be used
* when changing from a non-default alignment type.
* its current pack settings. This is the default state and only needs to be used
* when changing from a non-default alignment type.
*/
public void setToDefaultAligned();
/**
* Sets this data type's minimum alignment to the machine alignment which is
* specified by {@link DataOrganization#getMachineAlignment()}. The machine alignment is
* Sets this data type's minimum alignment to the machine alignment which is
* specified by {@link DataOrganization#getMachineAlignment()}. The machine alignment is
* defined as the maximum useful alignment for the target machine.
*/
public void setToMachineAligned();