META-INF/MANIFEST.MF
Config.properties
License.txt
PseudoOps.txt
README.md
Settings.properties
Syscall.properties
help/SyscallMessageDialogQuestion.gif
help/MacrosHelp.html
help/SyscallMessageDialogInformation.gif
help/SyscallHelpPrelude.html
help/IDE.html
help/ExceptionsHelp.html
help/SyscallMessageDialogError.gif
help/Debugging.html
help/SyscallHelpConclusion.html
help/Command.html
help/BugReportingHelp.html
help/Intro.html
help/History.html
help/Limits.html
help/Tools.html
help/SyscallMessageDialogWarning.gif
help/Acknowledgements.html
images/Copy22.png
images/StepBack16.png
images/Cut22.gif
images/Find22.png
images/Undo22.png
images/Redo22.png
images/Paste16.png
images/Play16.png
images/Cut24.gif
images/Stop22.png
images/MyBlank16.gif
images/StepForward16.png
images/register.png
images/control.png
images/Pause16.png
images/Reset16.png
images/Open22.png
images/Save22.png
images/ALUcontrol.png
images/SaveAs22.png
images/Assemble16.png
images/Help16.png
images/Dump16.png
images/New22.png
images/Pause22.png
images/Previous22.png
images/datapath.png
images/Save16.png
images/Reset22.png
images/Open16.png
images/Help22.png
images/Assemble22.png
images/Edit_tab.jpg
images/SaveAs16.png
images/New16.png
images/Dump22.png
images/Undo16.png
images/Find16.png
images/MyBlank24.gif
images/Cut16.gif
images/StepBack22.png
images/Copy16.png
images/Redo16.png
images/RISC-V.png
images/StepForward22.png
images/Stop16.png
images/Play22.png
images/Paste22.png
images/Next22.png
images/Execute_tab.jpg
jsoftfloat/RoundingMode.class
jsoftfloat/types/Float32.class
jsoftfloat/types/Floating.class
jsoftfloat/types/Float32$1.class
jsoftfloat/Environment.class
jsoftfloat/Flags.class
jsoftfloat/internal/ExactFloat.class
jsoftfloat/operations/Arithmetic.class
jsoftfloat/operations/Conversions.class
jsoftfloat/operations/Comparisons.class
jsoftfloat/.git
rars/AssemblyException.class
rars/tools/AbstractToolAndApplication$10.class
rars/tools/MemoryReferenceVisualization$8.class
rars/tools/KeyboardAndDisplaySimulator$4.class
rars/tools/CacheSimulator$5.class
rars/tools/TimerTool.class
rars/tools/TimerTool$Tick.class
rars/tools/MemoryReferenceVisualization$ColorChooserControls$1.class
rars/tools/BitmapDisplay$4.class
rars/tools/TimerTool$1.class
rars/tools/AbstractToolAndApplication$7.class
rars/tools/FloatRepresentation$InstructionsPane.class
rars/tools/AbstractToolAndApplication$MessageField.class
rars/tools/TimerTool$3.class
rars/tools/AbstractToolAndApplication$5.class
rars/tools/BitmapDisplay$6.class
rars/tools/FloatRepresentation$1.class
rars/tools/KeyboardAndDisplaySimulator.class
rars/tools/CacheSimulator$3.class
rars/tools/KeyboardAndDisplaySimulator$2.class
rars/tools/AbstractToolAndApplication$EnterKeyListener.class
rars/tools/AbstractToolAndApplication$GUIUpdater.class
rars/tools/CacheSimulator.class
rars/tools/AbstractToolAndApplication$1.class
rars/tools/BitmapDisplay$2.class
rars/tools/CacheSimulator$CacheAccessResult.class
rars/tools/KeyboardAndDisplaySimulator$DisplayResizeAdapter.class
rars/tools/AbstractToolAndApplication$3.class
rars/tools/CacheSimulator$AbstractCache.class
rars/tools/CacheSimulator$Animation.class
rars/tools/CacheSimulator$1.class
rars/tools/CacheSimulator$AnyCache.class
rars/tools/FloatRepresentation$HexToBinaryGraphicPanel.class
rars/tools/KeyboardAndDisplaySimulator$FontChanger.class
rars/tools/AbstractToolAndApplication$4.class
rars/tools/BitmapDisplay.class
rars/tools/TimerTool$2.class
rars/tools/InstructionMemoryDump$1.class
rars/tools/CacheSimulator$CacheBlock.class
rars/tools/CacheSimulator$4.class
rars/tools/FloatRepresentation$BinaryFractionDisplayTextField.class
rars/tools/Tool.class
rars/tools/KeyboardAndDisplaySimulator$TransmitterDelayTechnique.class
rars/tools/BitmapDisplay$5.class
rars/tools/AbstractToolAndApplication$6.class
rars/tools/BitmapDisplay$1.class
rars/tools/AbstractToolAndApplication$2.class
rars/tools/InstructionStatistics.class
rars/tools/FloatRepresentation$DecimalDisplayKeystokeListenter.class
rars/tools/DigitalLabSim$SevenSegmentPanel.class
rars/tools/KeyboardAndDisplaySimulator$1.class
rars/tools/FloatRepresentation$BinaryDisplayKeystrokeListener.class
rars/tools/KeyboardAndDisplaySimulator$NormallyDistributedDelay.class
rars/tools/KeyboardAndDisplaySimulator$DelayLengthPanel$DelayLengthListener.class
rars/tools/CacheSimulator$2.class
rars/tools/KeyboardAndDisplaySimulator$3.class
rars/tools/KeyboardAndDisplaySimulator$FontSettingDialog.class
rars/tools/KeyboardAndDisplaySimulator$UniformlyDistributedDelay.class
rars/tools/BitmapDisplay$3.class
rars/tools/MemoryReferenceVisualization$GraphicsPanel.class
rars/tools/AbstractToolAndApplication$CreateAssembleRunProgram$1.class
rars/tools/MemoryReferenceVisualization$3.class
rars/tools/BitmapDisplay$Grid.class
rars/tools/KeyboardAndDisplaySimulator$FontSettingDialog$3.class
rars/tools/BHTSimGUI$1.class
rars/tools/KeyboardAndDisplaySimulator$FontSettingDialog$1.class
rars/tools/MemoryReferenceVisualization$1.class
rars/tools/BHTSimGUI.class
rars/tools/AbstractToolAndApplication$ConnectButton.class
rars/tools/InstructionCounter.class
rars/tools/KeyboardAndDisplaySimulator$KeyboardKeyListener.class
rars/tools/DigitalLabSim.class
rars/tools/MemoryReferenceVisualization$ColorChooserControls$ColorChooserListener.class
rars/tools/BHTSimulator.class
rars/tools/MemoryReferenceVisualization$5.class
rars/tools/BHTEntry.class
rars/tools/MemoryReferenceVisualization$7.class
rars/tools/BitmapDisplay$GraphicsPanel.class
rars/tools/DigitalLabSim$SevenSegmentDisplay.class
rars/tools/AbstractToolAndApplication$8.class
rars/tools/KeyboardAndDisplaySimulator$1$1.class
rars/tools/DigitalLabSim$1.class
rars/tools/MemoryReferenceVisualization$Grid.class
rars/tools/DigitalLabSim$HexaKeyboard.class
rars/tools/DigitalLabSim$HexaKeyboard$EcouteurClick.class
rars/tools/DigitalLabSim$OneSecondCounter.class
rars/tools/AbstractToolAndApplication$MessageField$MessageWriter.class
rars/tools/AbstractToolAndApplication$CreateAssembleRunProgram.class
rars/tools/TimerTool$TimePanel.class
rars/tools/FloatRepresentation$BinaryToDecimalFormulaGraphic.class
rars/tools/AbstractToolAndApplication.class
rars/tools/BHTableModel.class
rars/tools/MemoryReferenceVisualization$2.class
rars/tools/KeyboardAndDisplaySimulator$FontSettingDialog$2.class
rars/tools/KeyboardAndDisplaySimulator$DelayLengthPanel.class
rars/tools/FloatRepresentation$FlavorsOfFloat.class
rars/tools/MemoryReferenceVisualization$ColorChooserControls.class
rars/tools/MemoryReferenceVisualization$6.class
rars/tools/AbstractToolAndApplication$9.class
rars/tools/MemoryReferenceVisualization$CounterColorScale.class
rars/tools/TimerTool$TimeCmpDaemon.class
rars/tools/KeyboardAndDisplaySimulator$FixedLengthDelay.class
rars/tools/MemoryReferenceVisualization.class
rars/tools/MemoryReferenceVisualization$CounterColor.class
rars/tools/MemoryReferenceVisualization$4.class
rars/tools/FloatRepresentation$HexDisplayKeystrokeListener.class
rars/tools/InstructionMemoryDump.class
rars/tools/FloatRepresentation.class
rars/Settings$Bool.class
rars/assembler/TokenList.class
rars/assembler/Directives.class
rars/assembler/TokenTypes.class
rars/assembler/Assembler$AddressSpace.class
rars/assembler/Tokenizer.class
rars/assembler/MacroPool.class
rars/assembler/Macro.class
rars/assembler/Assembler$DataSegmentForwardReferences.class
rars/assembler/SourceLine.class
rars/assembler/SymbolTable.class
rars/assembler/DataTypes.class
rars/assembler/Token.class
rars/assembler/Assembler.class
rars/assembler/OperandFormat.class
rars/assembler/Symbol.class
rars/assembler/Assembler$DataSegmentForwardReferences$DataSegmentForwardReference.class
rars/util/PropertiesFile.class
rars/util/EditorFont.class
rars/util/MemoryDump.class
rars/util/Binary.class
rars/util/FilenameFinder$RarsFileFilter.class
rars/util/SystemIO.class
rars/util/SystemIO$FileIOData.class
rars/util/FilenameFinder.class
rars/util/SystemIO$Data.class
rars/venus/HelpHelpAction$1.class
rars/venus/EditFindReplaceAction$FindReplaceDialog$2.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog.class
rars/venus/settings/SettingsHighlightingAction$BackgroundChanger.class
rars/venus/settings/SettingsHighlightingAction$2.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$8.class
rars/venus/settings/SettingsHighlightingAction$ForegroundChanger.class
rars/venus/settings/SettingsHighlightingAction$6.class
rars/venus/settings/SettingsHighlightingAction$DefaultChanger.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$ForegroundChanger.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$BoldItalicChanger.class
rars/venus/settings/SettingsHighlightingAction$4.class
rars/venus/settings/SettingsEditorAction.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$9.class
rars/venus/settings/SettingsHighlightingAction$3.class
rars/venus/settings/ColorSelectButton.class
rars/venus/settings/SettingsHighlightingAction$1.class
rars/venus/settings/SettingsHighlightingAction$5.class
rars/venus/settings/SettingsHighlightingAction.class
rars/venus/settings/SettingsExceptionHandlerAction$ExceptionHandlerSettingAction.class
rars/venus/settings/SettingsHighlightingAction$7.class
rars/venus/settings/SettingsAction.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$1.class
rars/venus/settings/SettingsHighlightingAction$FontSettingDialog$2.class
rars/venus/settings/SettingsExceptionHandlerAction.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog$4.class
rars/venus/settings/SettingsExceptionHandlerAction$2.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$3.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$7.class
rars/venus/settings/SettingsHighlightingAction$FontSettingDialog.class
rars/venus/settings/SettingsMemoryConfigurationAction.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$DefaultChanger.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog$2.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$5.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog$5.class
rars/venus/settings/SettingsExceptionHandlerAction$3.class
rars/venus/settings/SettingsHighlightingAction$FontSettingDialog$1.class
rars/venus/settings/SettingsHighlightingAction$8.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$2.class
rars/venus/settings/SettingsHighlightingAction$FontSettingDialog$3.class
rars/venus/settings/SettingsExceptionHandlerAction$1.class
rars/venus/settings/SettingsHighlightingAction$FontChanger.class
rars/venus/settings/SettingsExceptionHandlerAction$ExceptionHandlerSelectionAction.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog$3.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$4.class
rars/venus/settings/SettingsMemoryConfigurationAction$ConfigurationButton.class
rars/venus/settings/SettingsEditorAction$EditorFontDialog$6.class
rars/venus/settings/SettingsMemoryConfigurationAction$MemoryConfigurationDialog$1.class
rars/venus/VenusUI$16.class
rars/venus/VenusUI$6.class
rars/venus/VenusUI$14.class
rars/venus/VenusUI$4.class
rars/venus/MessagesPane$Asker$1$1.class
rars/venus/EditPane$2.class
rars/venus/MessagesPane$Asker.class
rars/venus/MonoRightCellRenderer.class
rars/venus/GuiAction.class
rars/venus/FileDumpMemoryAction$DumpFormatComboBoxRenderer.class
rars/venus/FileStatus.class
rars/venus/NumberDisplayBaseChooser.class
rars/venus/EditFindReplaceAction.class
rars/venus/DataSegmentWindow$NextButton.class
rars/venus/VenusUI$10.class
rars/venus/EditFindReplaceAction$FindReplaceDialog$4.class
rars/venus/VenusUI$2.class
rars/venus/util/AbstractFontSettingDialog$ComboBoxRenderer.class
rars/venus/util/PopupListener.class
rars/venus/util/RepeatButton.class
rars/venus/util/AbstractFontSettingDialog.class
rars/venus/util/AbstractFontSettingDialog$2.class
rars/venus/util/AbstractFontSettingDialog$4.class
rars/venus/util/AbstractFontSettingDialog$3.class
rars/venus/util/AbstractFontSettingDialog$BlockComboListener.class
rars/venus/util/AbstractFontSettingDialog$1.class
rars/venus/VenusUI$12.class
rars/venus/DataSegmentWindow$8.class
rars/venus/EditFindReplaceAction$FindReplaceDialog$1.class
rars/venus/LabelsWindow$LabelsForSymbolTable.class
rars/venus/TextSegmentWindow$MyTableColumnMovingListener.class
rars/venus/ToolLoader.class
rars/venus/VenusUI$5.class
rars/venus/LabelsWindow$LabelDisplayMouseListener.class
rars/venus/VenusUI$15.class
rars/venus/DataSegmentWindow$MyTippedJTable$1.class
rars/venus/HelpHelpAction$2.class
rars/venus/LabelsWindow$LabelItemListener.class
rars/venus/editors/TextEditingArea.class
rars/venus/editors/jeditsyntax/InputHandler$insert_tab.class
rars/venus/editors/jeditsyntax/DefaultInputHandler$BindingMap.class
rars/venus/editors/jeditsyntax/KeywordMap.class
rars/venus/editors/jeditsyntax/InputHandler$backspace_word.class
rars/venus/editors/jeditsyntax/InputHandler$MacroRecorder.class
rars/venus/editors/jeditsyntax/InputHandler.class
rars/venus/editors/jeditsyntax/InputHandler$repeat.class
rars/venus/editors/jeditsyntax/InputHandler$delete_word.class
rars/venus/editors/jeditsyntax/InputHandler$insert_break.class
rars/venus/editors/jeditsyntax/InputHandler$prev_word.class
rars/venus/editors/jeditsyntax/InputHandler$backspace.class
rars/venus/editors/jeditsyntax/DefaultInputHandler$Binding.class
rars/venus/editors/jeditsyntax/InputHandler$insert_char.class
rars/venus/editors/jeditsyntax/PopupHelpItem.class
rars/venus/editors/jeditsyntax/JEditTextArea$AdjustHandler.class
rars/venus/editors/jeditsyntax/JEditTextArea$ScrollLayout.class
rars/venus/editors/jeditsyntax/SyntaxUtilities.class
rars/venus/editors/jeditsyntax/InputHandler$clip_copy.class
rars/venus/editors/jeditsyntax/InputHandler$NonRepeatable.class
rars/venus/editors/jeditsyntax/InputHandler$end.class
rars/venus/editors/jeditsyntax/InputHandler$prev_page.class
rars/venus/editors/jeditsyntax/JEditTextArea.class
rars/venus/editors/jeditsyntax/SyntaxDocument.class
rars/venus/editors/jeditsyntax/InputHandler$home.class
rars/venus/editors/jeditsyntax/KeywordMap$Keyword.class
rars/venus/editors/jeditsyntax/JEditTextArea$FocusHandler.class
rars/venus/editors/jeditsyntax/InputHandler$next_char.class
rars/venus/editors/jeditsyntax/InputHandler$clip_cut.class
rars/venus/editors/jeditsyntax/InputHandler$Wrapper.class
rars/venus/editors/jeditsyntax/tokenmarker/RISCVTokenMarker.class
rars/venus/editors/jeditsyntax/tokenmarker/TokenMarker.class
rars/venus/editors/jeditsyntax/tokenmarker/Token.class
rars/venus/editors/jeditsyntax/tokenmarker/TokenMarker$LineInfo.class
rars/venus/editors/jeditsyntax/InputHandler$prev_line.class
rars/venus/editors/jeditsyntax/SyntaxStyle.class
rars/venus/editors/jeditsyntax/InputHandler$overwrite.class
rars/venus/editors/jeditsyntax/InputHandler$select_all.class
rars/venus/editors/jeditsyntax/JEditTextArea$2.class
rars/venus/editors/jeditsyntax/InputHandler$document_end.class
rars/venus/editors/jeditsyntax/TextAreaDefaults.class
rars/venus/editors/jeditsyntax/JEditTextArea$PopupHelpActionListener.class
rars/venus/editors/jeditsyntax/TextAreaPainter.class
rars/venus/editors/jeditsyntax/InputHandler$next_word.class
rars/venus/editors/jeditsyntax/JEditBasedTextArea$1.class
rars/venus/editors/jeditsyntax/JEditBasedTextArea.class
rars/venus/editors/jeditsyntax/JEditTextArea$MouseHandler.class
rars/venus/editors/jeditsyntax/InputHandler$next_page.class
rars/venus/editors/jeditsyntax/JEditTextArea$CaretBlinker.class
rars/venus/editors/jeditsyntax/JEditTextArea$ComponentHandler.class
rars/venus/editors/jeditsyntax/JEditTextArea$MutableCaretEvent.class
rars/venus/editors/jeditsyntax/DefaultInputHandler$BindingAction.class
rars/venus/editors/jeditsyntax/InputHandler$document_home.class
rars/venus/editors/jeditsyntax/JEditTextArea$CaretUndo.class
rars/venus/editors/jeditsyntax/JEditTextArea$1.class
rars/venus/editors/jeditsyntax/TextAreaPainter$Highlight.class
rars/venus/editors/jeditsyntax/InputHandler$prev_char.class
rars/venus/editors/jeditsyntax/JEditTextArea$AdjustHandler$1.class
rars/venus/editors/jeditsyntax/TextUtilities.class
rars/venus/editors/jeditsyntax/InputHandler$clip_paste.class
rars/venus/editors/jeditsyntax/DefaultInputHandler.class
rars/venus/editors/jeditsyntax/JEditTextArea$DragHandler.class
rars/venus/editors/jeditsyntax/InputHandler$NonRecordable.class
rars/venus/editors/jeditsyntax/InputHandler$next_line.class
rars/venus/editors/jeditsyntax/InputHandler$toggle_rect.class
rars/venus/editors/jeditsyntax/JEditTextArea$MouseWheelHandler.class
rars/venus/editors/jeditsyntax/InstructionMouseEvent.class
rars/venus/editors/jeditsyntax/JEditTextArea$DocumentHandler.class
rars/venus/editors/jeditsyntax/InputHandler$delete.class
rars/venus/editors/generic/GenericTextArea$1.class
rars/venus/editors/generic/GenericTextArea.class
rars/venus/editors/generic/GenericTextArea$2.class
rars/venus/EditPane$1.class
rars/venus/MessagesPane$Asker$1$2.class
rars/venus/LabelsWindow$MyTippedJTable.class
rars/venus/VenusUI$7.class
rars/venus/VenusUI$17.class
rars/venus/EditFindReplaceAction$FindReplaceDialog$3.class
rars/venus/DataSegmentWindow$PrevButton.class
rars/venus/VenusUI.class
rars/venus/VenusUI$13.class
rars/venus/DataSegmentWindow$9.class
rars/venus/FileDumpMemoryAction.class
rars/venus/VenusUI$3.class
rars/venus/LabelsWindow$MyTippedJTable$SymbolTableHeader$SymbolTableHeaderMouseListener.class
rars/venus/TextSegmentWindow$CheckBoxTableCellRenderer.class
rars/venus/EditTabbedPane.class
rars/venus/HelpHelpAction$MyCellRenderer.class
rars/venus/EditFindReplaceAction$FindReplaceDialog$5.class
rars/venus/HelpHelpAction.class
rars/venus/registers/FloatingPointWindow.class
rars/venus/registers/RegisterBlockWindow$MyTippedJTable.class
rars/venus/registers/RegisterBlockWindow$1.class
rars/venus/registers/RegisterBlockWindow$MyTippedJTable$1.class
rars/venus/registers/RegistersPane.class
rars/venus/registers/RegisterBlockWindow$RegisterCellRenderer.class
rars/venus/registers/RegisterBlockWindow.class
rars/venus/registers/RegistersWindow.class
rars/venus/registers/ControlAndStatusWindow.class
rars/venus/registers/RegisterBlockWindow$RegTableModel.class
rars/venus/VenusUI$11.class
rars/venus/ExecutePane.class
rars/venus/VenusUI$1.class
rars/venus/DataSegmentWindow$7.class
rars/venus/TextSegmentWindow$MachineCodeCellRenderer.class
rars/venus/VenusUI$20.class
rars/venus/MessagesPane$Asker$3.class
rars/venus/DataSegmentWindow$DataTableModel.class
rars/venus/LabelsWindow.class
rars/venus/LabelsWindow$MyTippedJTable$SymbolTableHeader.class
rars/venus/TextSegmentWindow$CodeCellRenderer.class
rars/venus/MainPane$1.class
rars/venus/TextSegmentWindow$MyTippedJTable.class
rars/venus/EditFindReplaceAction$FindReplaceDialog.class
rars/venus/NumberDisplayBaseChooser$1.class
rars/venus/MessagesPane$4.class
rars/venus/DataSegmentWindow$AddressCellRenderer.class
rars/venus/DataSegmentWindow$MyTippedJTable.class
rars/venus/MessagesPane$Asker$1.class
rars/venus/VenusUI$22.class
rars/venus/DataSegmentWindow$5.class
rars/venus/HelpHelpAction$HelpHyperlinkListener$2.class
rars/venus/DataSegmentWindow$1.class
rars/venus/FileDumpMemoryAction$1.class
rars/venus/MessagesPane.class
rars/venus/EditTabbedPane$FileOpener.class
rars/venus/TextSegmentWindow.class
rars/venus/LabelsWindow$LabelAddressAscendingComparator.class
rars/venus/FileDumpMemoryAction$3.class
rars/venus/MessagesPane$2.class
rars/venus/VenusUI$9.class
rars/venus/LabelsWindow$LabelNameAscendingComparator.class
rars/venus/VenusUI$19.class
rars/venus/DataSegmentWindow$3.class
rars/venus/EditTabbedPane$1.class
rars/venus/TextSegmentWindow$MyTippedJTable$TextTableHeader.class
rars/venus/HelpAboutAction.class
rars/venus/TextSegmentWindow$TextTableModel.class
rars/venus/LabelsWindow$LabelTableModel.class
rars/venus/FileDumpMemoryAction$4.class
rars/venus/MainPane.class
rars/venus/DataSegmentWindow$4.class
rars/venus/VenusUI$23.class
rars/venus/HelpHelpAction$HelpHyperlinkListener.class
rars/venus/VenusUI$21.class
rars/venus/DataSegmentWindow.class
rars/venus/MessagesPane$Asker$2.class
rars/venus/run/RunGoAction$1.class
rars/venus/run/RunStepAction.class
rars/venus/run/RunGoAction$2.class
rars/venus/run/RunAssembleAction.class
rars/venus/run/RunStepAction$1.class
rars/venus/run/RunClearBreakpointsAction.class
rars/venus/run/RunBackstepAction.class
rars/venus/run/RunSpeedPanel$RunSpeedListener.class
rars/venus/run/RunSpeedPanel.class
rars/venus/run/RunGoAction.class
rars/venus/run/RunResetAction.class
rars/venus/Editor.class
rars/venus/DataSegmentWindow$6.class
rars/venus/LabelsWindow$DescendingComparator.class
rars/venus/ToolAction.class
rars/venus/TextSegmentWindow$MyTippedJTable$TextTableHeader$TextTableHeaderMouseListener.class
rars/venus/TextSegmentWindow$ModifiedCode.class
rars/venus/MessagesPane$3.class
rars/venus/EditTabbedPane$FileOpener$ChoosableFileFilterChangeListener.class
rars/venus/DataSegmentWindow$CustomComboBoxModel.class
rars/venus/FileDumpMemoryAction$2.class
rars/venus/HelpHelpAction$HelpHyperlinkListener$1.class
rars/venus/VenusUI$18.class
rars/venus/DataSegmentWindow$2.class
rars/venus/VenusUI$8.class
rars/venus/EditPane.class
rars/venus/MessagesPane$Asker$4.class
rars/venus/MessagesPane$1.class
rars/Launch$1.class
rars/ProgramStatement$BasicStatementList$ListElement.class
rars/ErrorList.class
rars/WaitException.class
rars/Globals.class
rars/SimulationException.class
rars/simulator/BackStepper$Action.class
rars/simulator/BackStepper.class
rars/simulator/Simulator.class
rars/simulator/Simulator$SimThread.class
rars/simulator/Simulator$StopListener.class
rars/simulator/Simulator$Reason.class
rars/simulator/BackStepper$BackstepStack.class
rars/simulator/BackStepper$1.class
rars/simulator/BackStepper$BackStep.class
rars/simulator/ProgramArgumentList.class
rars/simulator/Simulator$UpdateGUI.class
rars/simulator/SimulatorNotice.class
rars/BreakpointException.class
rars/ErrorMessage.class
rars/Settings.class
rars/RISCVprogram.class
rars/api/Options.class
rars/api/Program.class
rars/ProgramStatement.class
rars/Launch.class
rars/riscv/instructions/LH.class
rars/riscv/instructions/SLT.class
rars/riscv/instructions/FusedFloat.class
rars/riscv/instructions/FNMSUBS.class
rars/riscv/instructions/Arithmetic.class
rars/riscv/instructions/SB.class
rars/riscv/instructions/SRL.class
rars/riscv/instructions/Branch.class
rars/riscv/instructions/FLES.class
rars/riscv/instructions/CSRRC.class
rars/riscv/instructions/FENCEI.class
rars/riscv/instructions/BNE.class
rars/riscv/instructions/AND.class
rars/riscv/instructions/LBU.class
rars/riscv/instructions/MULH.class
rars/riscv/instructions/JALR.class
rars/riscv/instructions/BLTU.class
rars/riscv/instructions/FDIVS.class
rars/riscv/instructions/FCVTWS.class
rars/riscv/instructions/JAL.class
rars/riscv/instructions/SUB.class
rars/riscv/instructions/FEQS.class
rars/riscv/instructions/LW.class
rars/riscv/instructions/FCLASSS.class
rars/riscv/instructions/SLL.class
rars/riscv/instructions/SRAI.class
rars/riscv/instructions/FLW.class
rars/riscv/instructions/FMADDS.class
rars/riscv/instructions/REMU.class
rars/riscv/instructions/SLTIU.class
rars/riscv/instructions/FSGNJNS.class
rars/riscv/instructions/BEQ.class
rars/riscv/instructions/FCVTSW.class
rars/riscv/instructions/FSGNJXS.class
rars/riscv/instructions/FSGNJS.class
rars/riscv/instructions/ORI.class
rars/riscv/instructions/FCVTWUS.class
rars/riscv/instructions/FADDS.class
rars/riscv/instructions/URET.class
rars/riscv/instructions/ADD.class
rars/riscv/instructions/LHU.class
rars/riscv/instructions/AUIPC.class
rars/riscv/instructions/MULHU.class
rars/riscv/instructions/FMAXS.class
rars/riscv/instructions/DIV.class
rars/riscv/instructions/DIVU.class
rars/riscv/instructions/FSW.class
rars/riscv/instructions/MULHSU.class
rars/riscv/instructions/CSRRW.class
rars/riscv/instructions/FENCE.class
rars/riscv/instructions/FMINS.class
rars/riscv/instructions/FMSUBS.class
rars/riscv/instructions/SLTI.class
rars/riscv/instructions/BGEU.class
rars/riscv/instructions/MUL.class
rars/riscv/instructions/CSRRS.class
rars/riscv/instructions/FMVSX.class
rars/riscv/instructions/ADDI.class
rars/riscv/instructions/Store.class
rars/riscv/instructions/SLLI.class
rars/riscv/instructions/Floating.class
rars/riscv/instructions/CSRRSI.class
rars/riscv/instructions/FSUBS.class
rars/riscv/instructions/FCVTSWU.class
rars/riscv/instructions/WFI.class
rars/riscv/instructions/ECALL.class
rars/riscv/instructions/XORI.class
rars/riscv/instructions/SRA.class
rars/riscv/instructions/FMULS.class
rars/riscv/instructions/FSQRTS.class
rars/riscv/instructions/CSRRWI.class
rars/riscv/instructions/ImmediateInstruction.class
rars/riscv/instructions/BLT.class
rars/riscv/instructions/CSRRCI.class
rars/riscv/instructions/SH.class
rars/riscv/instructions/SLTU.class
rars/riscv/instructions/FNMADDS.class
rars/riscv/instructions/REM.class
rars/riscv/instructions/BGE.class
rars/riscv/instructions/SRLI.class
rars/riscv/instructions/FLTS.class
rars/riscv/instructions/LB.class
rars/riscv/instructions/FMVXS.class
rars/riscv/instructions/ANDI.class
rars/riscv/instructions/EBREAK.class
rars/riscv/instructions/SW.class
rars/riscv/instructions/XOR.class
rars/riscv/instructions/Load.class
rars/riscv/instructions/LUI.class
rars/riscv/instructions/OR.class
rars/riscv/hardware/FloatingPointRegisterFile.class
rars/riscv/hardware/AccessNotice.class
rars/riscv/hardware/MemoryAccessNotice.class
rars/riscv/hardware/RegisterFile.class
rars/riscv/hardware/Register.class
rars/riscv/hardware/MemoryConfigurations.class
rars/riscv/hardware/ReadOnlyRegister.class
rars/riscv/hardware/MaskedRegister.class
rars/riscv/hardware/InterruptController.class
rars/riscv/hardware/MemoryConfiguration.class
rars/riscv/hardware/Memory.class
rars/riscv/hardware/RegisterBlock.class
rars/riscv/hardware/Memory$MemoryObservable.class
rars/riscv/hardware/LinkedRegister.class
rars/riscv/hardware/AddressErrorException.class
rars/riscv/hardware/ControlAndStatusRegisterFile.class
rars/riscv/hardware/RegisterAccessNotice.class
rars/riscv/dump/BinaryDumpFormat.class
rars/riscv/dump/AbstractDumpFormat.class
rars/riscv/dump/SegmentWindowDumpFormat.class
rars/riscv/dump/AsciiTextDumpFormat.class
rars/riscv/dump/HexTextDumpFormat.class
rars/riscv/dump/DumpFormat.class
rars/riscv/dump/BinaryTextDumpFormat.class
rars/riscv/dump/DumpFormatLoader.class
rars/riscv/dump/IntelHexDumpFormat.class
rars/riscv/SyscallLoader.class
rars/riscv/ExtendedInstruction.class
rars/riscv/BasicInstructionFormat.class
rars/riscv/AbstractSyscall.class
rars/riscv/BasicInstruction.class
rars/riscv/Instruction.class
rars/riscv/InstructionSet$MatchMap.class
rars/riscv/InstructionSet.class
rars/riscv/SyscallNumberOverride.class
rars/riscv/syscalls/SyscallClose.class
rars/riscv/syscalls/SyscallRandInt.class
rars/riscv/syscalls/SyscallMidiOutSync.class
rars/riscv/syscalls/SyscallReadInt.class
rars/riscv/syscalls/SyscallSbrk.class
rars/riscv/syscalls/SyscallPrintString.class
rars/riscv/syscalls/NullString.class
rars/riscv/syscalls/SyscallMessageDialogString.class
rars/riscv/syscalls/SyscallWrite.class
rars/riscv/syscalls/SyscallConfirmDialog.class
rars/riscv/syscalls/SyscallMidiOut.class
rars/riscv/syscalls/SyscallTime.class
rars/riscv/syscalls/SyscallReadString.class
rars/riscv/syscalls/SyscallLSeek.class
rars/riscv/syscalls/SyscallRandFloat.class
rars/riscv/syscalls/SyscallReadChar.class
rars/riscv/syscalls/EndOfTrackListener.class
rars/riscv/syscalls/Tone.class
rars/riscv/syscalls/SyscallPrintChar.class
rars/riscv/syscalls/SyscallMessageDialog.class
rars/riscv/syscalls/SyscallInputDialogString.class
rars/riscv/syscalls/SyscallRandIntRange.class
rars/riscv/syscalls/SyscallSleep.class
rars/riscv/syscalls/SyscallPrintIntUnsigned.class
rars/riscv/syscalls/SyscallPrintInt.class
rars/riscv/syscalls/SyscallRandSeed.class
rars/riscv/syscalls/SyscallPrintFloat.class
rars/riscv/syscalls/ToneGenerator.class
rars/riscv/syscalls/RandomStreams.class
rars/riscv/syscalls/SyscallExit.class
rars/riscv/syscalls/SyscallExit2.class
rars/riscv/syscalls/SyscallPrintIntHex.class
rars/riscv/syscalls/SyscallMessageDialogInt.class
rars/riscv/syscalls/SyscallOpen.class
rars/riscv/syscalls/SyscallMessageDialogFloat.class
rars/riscv/syscalls/SyscallPrintIntBinary.class
rars/riscv/syscalls/SyscallGetCWD.class
rars/riscv/syscalls/SyscallReadFloat.class
rars/riscv/syscalls/SyscallInputDialogInt.class
rars/riscv/syscalls/SyscallInputDialogFloat.class
rars/riscv/syscalls/SyscallRead.class
rars/ProgramStatement$BasicStatementList.class
rars/ExitingException.class
rars/extras/Documentation.class
Manifest-Version: 1.0
Class-Path: .
Created-By: 1.6.0_33 (Sun Microsystems Inc.)
Main-Class: rars.Launch
# maximum length of scrolled text in Mars Message and Run I/O tabs, in bytes.
MessageLimit = 1000000
# Maximum number of errors that can be recorded in one assemble operation.
ErrorLimit = 200
# Maximum number of “backstep” operations that can be taken. An instruction
# may produce more than one (e.g. trap instruction may set several registers)
BackstepLimit = 2000
# Acceptable file extensions for MIPS assembly files.Separate with spaces.
Extensions = asms
# The set of ASCII strings to use for ASCII display or print
# of data segment contents. This covers 8-bit ASCII codes 0-255.
# The space character (decimal 32, hex 20) is encoded here as
# “space” without the quotes. It will be converted upon reading.
# All non-printable codes are encoded here as “null” without
# the quotes. They will be converted upon reading, to the value
# of variable AsciiNonPrint.If you wish to have non-printing
# codes be displayed as their octal value (see unix od) then
# replace all these null with the codes.
# 0123456789
AsciiTable =
\0 null null null null null null null\b\t
\n\v\f\r null null null null null null
null null null null null null null null null null
null null space !”#$%&‘
()*+,–./01
23456789:;
<=>?@ABCDE
FGHIJKLMNO
PQRSTUVWXY
Z[ \]^_`abc
defghijklm
nopqrstuvw
xyz{|}~ null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null null null null null
null null null null null null
# Use AsciiNonPrint as placeholder for non-printing ASCII codes.
# To use space character, specify AsciiNonPrint = space.
# The value of this variable will be substituted for the
# string “null” for any element in the Ascii list (above)
# having “null” as its value.
AsciiNonPrint = .
Copyright (c) 2003-2013,Pete Sanderson and Kenneth Vollmar
Developed by Pete Sanderson ([email protected])
and Kenneth Vollmar ([email protected])
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
“Software”), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject
to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
(MIT license, http://www.opensource.org/licenses/mit-license.html)
# Copyright (c) 2003-2010,Pete Sanderson and Kenneth Vollmar
#
# Developed by Pete Sanderson ([email protected])
# and Kenneth Vollmar ([email protected])
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# “Software”), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject
# to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# (MIT license, http://www.opensource.org/licenses/mit-license.html)
# File containing definitions of MIPS pseudo-ops
# File format:
# Each line contains specification for one pseudo-op, including optional description.
# First item is source statement syntax, specified in same “example” parser format used for regular instructions.
# Source statement specification ends with a tab.It is followed by a tab-separated list of basic instruction
# templates to complete and substitute for the pseudo-op.
# Format for specifying syntax of templates is different from specifying syntax of source statement:
#(n=0,1,2,3,…) is token position in source statement (operator is token 0, parentheses are tokens but commas aren’t)
#RGn means substitute register found in n’th token of source statement
#LLn means substitute low order 16-bits from label address in source token n.
#LHn means substitute high order 16-bits from label address in source token n. Must add 1 if address bit 11 is 1.
#PCLn is similar to LLn except the value substituted will be relative to PC of the psuedo-op.
#PCHn is similar to LHn except the value substituted will be relative to PC of the psuedo-op.
#VLn means substitute low order 16-bits from 32-bit value in source token n.
#VHn means substitute high order 16-bits from 32-bit value in source token n, then add 1 if value’s bit 11 is 1.
#LAB means substitute textual label from last token of source statement.Used for various branches.
# Everything else is copied as is into the generated statement (you must use register numbers not mnemonics)
# The list of basic instruction templates is optionally followed a description of the instruction for help purposes.
# To add optional description, append a tab then the ‘#’ character followed immediately (no spaces) by the description.
#
#See documentation for ExtendedInstruction.makeTemplateSubstitutions() for more details.
#
#Matching for a given instruction mnemonic is first-fit not best-fit.If an instruction has both 16 and 32-bit
#immediate operand options, they should be listed in that order (16-bit version first).Otherwise the 16-bit
#version will never be matched since the 32-bit version fits small immediate values first.
#
#The pseudo-op specification must start in the first column.If first column is blank, the line will be skipped!
#
#When specifying the example instruction (first item on line), the conventions I follow are:
#– for a register operand, specify a numbered register (e.g. $t1 or $f1) to represent any register in the set.
#The numerical value is not significant.This is NOT the case when writing the templates that follow!
#In the templates, numbered registers are parsed as is (use only $0 and $1, which are $zero and $at).
#– for an immediate operand, specify a positive value indicative of the expected range.I use 10 to represent
#a 5 bit value, 100 to represent a 16-bit value, and 100000 to represent a 32-bit value.
#– for a label operand, I use the string “label” (without the quotes).
#The idea is to give the parser an example that will be parsed into the desired token sequence.Syntax checking
#is done by comparing the source token sequence to list of token sequences generated from the examples.
#IMPORTANT NOTE:The use of $t1,$t2, etc in the instruction sample means that any CPU register reference
# can be used in that position.It is simply a placeholder.By contrast, when
# $1 is used in the template specification, $1 ($at) is literally placed into the generated
# instruction!If you want the generated code to echo the source register, use RG1,RG2, etc.
#######################arithmetic and branch pseudo-ops #####################
nop ;addi x0, x0, 0 ;#NO OPeration
not t1,t2 ;xori RG1, RG2, -1 ;#Bitwise NOT (bit inversion)
mvt1,t2 ;add RG1, x0, RG2;#MoVe : Set t1 to contents of t2
neg t1,t2 ;sub RG1, x0, RG2;#NEGate : Set t1 to negation of t2
# non-(load and store) pseudo-instructions for floating point (coprocessor 1) registers
fmv.sf1, f2 ;fsgnj.sRG1, RG2, RG2;# Move the value of f2 to f1
fabs.s f1, f2 ;fsgnjx.s RG1, RG2, RG2;# Set f1 to the absolute value of f2
fneg.s f1, f2 ;fsgnjn.s RG1, RG2, RG2;# Set f1 to the negation of f2
sgtt1,t2,t3 ;sltRG1, RG3, RG2 ;#Set Greater Than : if t2 greater than t3 then set t1 to 1 else 0
sgtu t1,t2,t3 ;sltu RG1, RG3, RG2 ;#Set Greater Than Unsigned : if t2 greater than t3 (unsigned compare) then set t1 to 1 else 0
seqz t1,t2;sltiu RG1, RG2, 1;#Set EQual to Zero : if t2 == 0 then set t1 to 1 else 0
snez t1,t2;sltu RG1, x0, RG2;#Set Not Equal to Zero : if t2 != 0 then set t1 to 1 else 0
sgtz t1,t2;slt RG1, x0, RG2 ;#Set Greater Than Zero : if t2 >0 then set t1 to 1 else 0
sltz t1,t2;slt RG1, RG2, x0 ;#Set Less Than Zero :if t2 <0 then set t1 to 1 else 0b label ;jal x0, LAB;#Branch : Branch to statement at label unconditionallybeqz t1,label ;beq RG1, x0, LAB ;#Branch if EQual Zero : Branch to statement at label if t1 == 0bnez t1,label ;bne RG1, x0, LAB ;#Branch if Not Equal Zero : Branch to statement at label if t1 != 0bgez t1,label ;bge RG1, x0, LAB ;#Branch if Greater than or Equal to Zero : Branch to statement at label if t1 >= 0
bltz t1,label ;blt RG1, x0, LAB ;#Branch if Less Than Zero : Branch to statement at label if t1 < 0bgtz t1,label ;blt x0, RG1, LAB ;#Branch if Greater Than: Branch to statement at label if t1 > 0
blez t1,label ;bge x0, RG1, LAB ;#Branch if Less than or Equal to Zero : Branch to statement at label if t1 <= 0bgtt1,t2,label ;bltRG2, RG1, LAB ;#Branch if Greater Than : Branch to statement at label if t1 > t2
bgtu t1,t2,label ;bltu RG2, RG1, LAB ;#Branch if Greater Than Unsigned: Branch to statement at label if t1 > t2 (unsigned compare)
blet1,t2,label ;bgeRG2, RG1, LAB ;#Branch if Less or Equal : Branch to statement at label if t1 <= t2bleu t1,t2,label ;bgeu RG2, RG1, LAB ;#Branch if Less or Equal Unsigned : Branch to statement at label if t1 <= t2 (unsigned compare)j label;jalx0, LAB ;#Jump : Jump to statement at labeljal label;jalx1, LAB ;#Jump And Link: Jump to statement at label and set the return address to rajr t0;jalr x0, RG1, 0;#Jump Register: Jump to address in t0jalr t0;jalr x1, RG1, 0;#Jump And Link Register: Jump to address in t0 and set the return address to rajr t0, -100;jalr x0, RG1, VL2;#Jump Register: Jump to address in t0jalr t0, -100;jalr x1, RG1, VL2;#Jump And Link Register: Jump to address in t0 and set the return address to raret;jalr x0, x1, 0 ;#Return: return from a subroutinecall label ;auipc x6,PCH1;jalr x1, x6, PCL1;#CALL: call a far-away subroutinetail label ;auipc x6,PCH1;jalr x0, x6, PCL1;#TAIL call: tail call (call without saving return address)a far-away subroutine#########################load/store pseudo-ops start here############################Most of these simply provide a variety of convenient memory addressing modes for #specifying load/store address.#li t1,-100 ;addi RG1, x0, VL2;#Load Immediate : Set t1 to 12-bit immediate (sign-extended)li t1,10000000 ;lui RG1, VH2 ;addi RG1, RG1, VL2 ;#Load Immediate : Set t1 to 32-bit immediatela t1,label;auipc RG1, PCH2 ; addi RG1, RG1, PCL2;#Load Address : Set t1 to label’s addresslw t1,(t2) ;lw RG1,0(RG3) ;#Load Word : Set t1 to contents of effective memory word addresslw t1,-100 ;lw RG1, VL2(x0) ;#Load Word : Set t1 to contents of effective memory word addresslw t1,10000000 ;lui RG1, VH2;lw RG1, VL2(RG1);#Load Word : Set t1 to contents of effective memory word addresslw t1,label ;auipc RG1, PCH2 ;lw RG1, PCL2(RG1) ;#Load Word : Set t1 to contents of memory word at label’s addresssw t1,(t2);sw RG1,0(RG3) ;#Store Word : Store t1 contents into effective memory word addresssw t1,-100;sw RG1, VL2(x0) ;#Store Word : Store $t1 contents into effective memory word addresssw t1,10000000,t2 ;lui RG3, VH2;sw RG1, VL2(RG3);#Store Word : Store $t1 contents into effective memory word address using t2 as a temporarysw t1,label,t2;auipc RG3, PCH2 ;sw RG1, PCL2(RG3) ;#Store Word : Store $t1 contents into memory word at label’s address using t2 as a temporarylh t1,(t2) ;lh RG1,0(RG3) ;#Load Halfword : Set t1 to sign-extended 16-bit value from effective memory halfword addresslh t1,-100 ;lh RG1, VL2(x0) ;#Load Halfword : Set t1 to sign-extended 16-bit value from effective memory halfword addresslh t1,10000000 ;lui RG1, VH2;lh RG1, VL2(RG1);#Load Halfword : Set t1 to sign-extended 16-bit value from effective memory halfword addresslh t1,label ;auipc RG1, PCH2 ;lh RG1, PCL2(RG1) ;#Load Halfword : Set t1 to sign-extended 16-bit value from effective memory halfword addresssh t1,(t2);sh RG1,0(RG3) ;#Store Halfword : Store the low-order 16 bits of $1 into the effective memory halfword addresssh t1,-100;sh RG1, VL2(x0) ;#Store Halfword : Store the low-order 16 bits of $t1 into the effective memory halfword addresssh t1,10000000,t2 ;lui RG3, VH2;sh RG1, VL2(RG3);#Store Halfword : Store the low-order 16 bits of t1 into the effective memory halfword address using t2 as a temporarysh t1,label,t2;auipc RG3, PCH2 ;sh RG1, PCL2(RG3) ;#Store Halfword : Store the low-order 16 bits of t1 into the effective memory halfword address using t2 as a temporarylb t1,(t2) ;lb RG1,0(RG3) ;#Load Byte : Set t1 to sign-extended 8-bit value from effective memory byte addresslb t1,-100 ;lb RG1, VL2(x0) ;#Load Byte : Set $1 to sign-extended 8-bit value from effective memory byte addresslb t1,10000000 ;lui RG1, VH2;lb RG1, VL2(RG1);#Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte addresslb t1,label ;auipc RG1, PCH2 ;lb RG1, PCL2(RG1) ;#Load Byte : Set $t1 to sign-extended 8-bit value from effective memory byte addresssb t1,(t2);sb RG1,0(RG3) ;#Store Byte : Store the low-order 8 bits of t1 into the effective memory byte addresssb t1,-100;sb RG1, VL2(x0) ;#Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte addresssb t1,10000000,t2 ;lui RG3, VH2;sb RG1, VL2(RG3);#Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte addresssb t1,label,t2;auipc RG3, PCH2 ;sb RG1, PCL2(RG3) ;#Store Byte : Store the low-order 8 bits of $t1 into the effective memory byte addresslhu t1,(t2) ;lhu RG1,0(RG3) ;#Load Halfword Unsigned : Set t1 to zero-extended 16-bit value from effective memory halfword addresslhu t1,-100 ;lhu RG1, VL2(x0) ;#Load Halfword Unsigned : Set t1 to zero-extended 16-bit value from effective memory halfword addresslhu t1,10000000 ;lui RG1, VH2 ;lhu RG1, VL2(RG1);#Load Halfword Unsigned : Set t1 to zero-extended 16-bit value from effective memory halfword addresslhu t1,label;auipc RG1, PCH2;lhu RG1, PCL2(RG1) ;#Load Halfword Unsigned : Set t1 to zero-extended 16-bit value from effective memory halfword addresslbu t1,(t2) ;lbu RG1,0(RG3) ;#Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte addresslbu t1,-100 ;lbu RG1, VL2(x0) ;#Load Byte Unsigned : Set $t1 to zero-extended 8-bit value from effective memory byte addresslbu t1,10000000 ;lui RG1, VH2;lbu RG1, VL2(RG1);#Load Byte Unsigned : Set t1 to zero-extended 8-bit value from effective memory byte addresslbu t1,label;auipc RG1, PCH2 ;lbu RG1, PCL2(RG1) ;#Load Byte Unsigned : Set t1 to zero-extended 8-bit value from effective memory byte address# load and store pseudo-instructions for floating point (coprocessor 1) registersflw f1,(t2) ;flw RG1,0(RG3);#Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word addressflw f1,-100 ;flw RG1, VL2(x0);#Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word addressflw f1,10000000,t3;lui RG3, VH2;flw RG1, VL2(RG3) ;#Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word address using t3 as a temporaryflw f1,label, t3;auipc RG3, PCH2 ;flw RG1, PCL2(RG3);#Load Word Coprocessor 1 : Set f1 to 32-bit value from effective memory word address using t3 as a temporaryfsw f1,(t2) ;fsw RG1,0(RG3)#Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word addressfsw f1,-100 ;fsw RG1, VL2(x0);#Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word addressfsw f1,10000000,t3;lui RG3, VH2;fsw RG1, VL2(RG3) ;#Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word address using t3 as a temporaryfsw f1,label, t3;auipc RG3, PCH2 ;fsw RG1, PCL2(RG3);#Store Word Coprocessor 1 : Store 32-bit value from f1 to effective memory word address using t3 as a temporary#######################CSR pseudo-ops #####################csrr t1, fcsr ;csrrs RG1, RG2, x0 ;#Read control and status registercsrw t1, fcsr ;csrrw x0, RG2, RG1 ;#Write control and status registercsrs t1, fcsr ;csrrs x0, RG2, RG1 ;#Set bits in control and status registercsrc t1, fcsr ;csrrc x0, RG2, RG1 ;#Clear bits in control and status registercsrwi fcsr, 100 ;csrrwi x0, RG1, RG2 ;#Write control and status registercsrsi fcsr, 100 ;csrrsi x0, RG1, RG2 ;#Set bits in control and status registercsrci fcsr, 100 ;csrrci x0, RG1, RG2 ;#Clear bits in control and status registerfrcsr t1 ; csrrs RG1, 0x003, x0;#Read FP control/status registerfscsr t1, t2 ; csrrw RG1, 0x003, RG2 ;#Swap FP control/status registerfscsr t1 ; csrrsx0, 0x003, RG1 ;#Write FP control/status registerfrsr t1 ; csrrs RG1, 0x003, x0;#Alias for frcsr t1fssr t1, t2 ; csrrw RG1, 0x003, RG2 ;#Alias for fscsr t1, t2fssr t1 ; csrrsx0, 0x003, RG1 ;#Alias for fscsr t1 frrm t1; csrrs RG1, 0x002, x0;#Read FP rounding modefsrm t1, t2; csrrw RG1, 0x002, RG2 ;#Swap FP rounding modefsrm t1; csrrsx0, 0x002, RG1 ;#Write FP rounding modefsrmi t1, 100 ; csrrwi RG1, 0x002, RG2 ;#Swap FP rounding mode, immediatefsrmi 100 ; csrrsix0, 0x002, RG1 ;#Write FP rounding mode, immediatefrflags t1; csrrs RG1, 0x001, x0;#Read FP exception flagsfsflags t1, t2; csrrw RG1, 0x001, RG2 ;#Swap FP exception flagsfsflags t1; csrrsx0, 0x001, RG1 ;#Write FP exception flagsfsflagsi t1, 100 ; csrrwi RG1, 0x001, RG2 ;#Swap FP exception flags, immediatefsflagsi 100 ; csrrsix0, 0x001, RG1 ;#Write FP exception flags, immediaterdcycle t1; csrrs rd, 0xC00, x0 ;# Read from cyclerdinstret t1; csrrs rd, 0xC02, x0 ;# Read from instretrdcycleh t1 ; csrrs rd, 0xC00, x0 ;# Read from cyclehrdinstreth t1 ; csrrs rd, 0xC02, x0 ;# Read from instreth# Floating point rounding mode removalfsqrt.s f1, f2 ; fsqrt.s RG1, RG2, dyn ;#Floating SQuare RooT: Assigns f1 to the square root of f2fsub.sf1, f2, f3 ; fsub.sRG1, RG2, RG3, dyn ;#Floating SUBtract: assigns f1 to f2 – f3fadd.sf1, f2, f3 ; fadd.sRG1, RG2, RG3, dyn ;#Floating ADD: assigns f1 to f2 + f3fmul.sf1, f2, f3 ; fmul.sRG1, RG2, RG3, dyn ;#Floating MULtiply: assigns f1 to f2 * f3fdiv.sf1, f2, f3 ; fdiv.sRG1, RG2, RG3, dyn ;#Floating DIVide: assigns f1 to f2 / f3fmadd.s f1, f2, f3, f4 ; fmadd.s RG1, RG2, RG3, RG4, dyn ;#Fused Multiply Add: Assigns f2*f3+f4 to f1fnmadd.sf1, f2, f3, f4 ; fnmadd.sRG1, RG2, RG3, RG4, dyn ;#Fused Negate Multiply Add: Assigns -(f2*f3+f4) to f1fmsub.s f1, f2, f3, f4 ; fmsub.s RG1, RG2, RG3, RG4, dyn ;#Fused Multiply Subatract: Assigns f2*f3-f4 to f1fnmsub.sf1, f2, f3, f4 ; fnmsub.sRG1, RG2, RG3, RG4, dyn ;#Fused Negated Multiply Subatract: Assigns -(f2*f3-f4) to f1fcvt.s.wu f1, t1 ; fcvt.s.wu RG1, RG2, dyn ;#Convert float from unsigned integer: Assigns the value of t1 to f1fcvt.s.wf1, t1 ; fcvt.s.wRG1, RG2, dyn ;#Convert float from signed integer: Assigns the value of t1 to f1fcvt.w.st1, f1 ; fcvt.w.sRG1, RG2, dyn ;#Convert signed integer from float: Assigns the value of f1 (rounded) to t1fcvt.wu.s t1, f1 ; fcvt.wu.s RG1, RG2, dyn ;#Convert unsigned integer from float: Assigns the value of f1 (rounded) to t1### GCC compatabilitylui t1,%hi(label) ;lui RG1,LH4;#Load Upper Address : Set t1 to upper 20-bit label’s addressaddi t1,t2,%lo(label) ;addi RG1,RG2,LL5 ;#Load Lower Address : Set t1 to t2 + lower 12-bit label’s addresslw t1,%lo(label)(t2);lw RG1,LL4(RG7);#Load from Addressflw f1,%lo(label)(t2) ;flw RG1,LL4(RG7) ;#Load from Addressfgt.s t1, f2, f3;fle.s t1, f3, f2 ;#Floating Greater Than: if f1 > f2, set t1 to 1, else set t1 to 0
fge.s t1, f2, f3;flt.s t1, f3, f2 ;#Floating Greater Than or Equal: if f1 >= f2, set t1 to 1, else set t1 to 0
RARS — RISC-V Assembler and Runtime Simulator
———————————————-
RARS, the RISC-V Assembler, Simulator, and Runtime, will assemble and simulate
the execution of RISC-V assembly language programs. Its primary goal is to be
an effective development environment for people getting started with RISC-V.
## Features
– RV32IMF ISA with some support for user level interrupts.
– Several system calls that match behaviour from MARS or SPIKE.
– Support for debugging using breakpoints and/or `ebreak`
– Side by side comparison from psuedo-instruction to machine code with
intermediate steps
– Multifile assembly using either files open or a directory
## Documentation
Documentation for supported [instructions](https://github.com/TheThirdOne/rars/wiki/Supported-Instructions), [system calls](https://github.com/TheThirdOne/rars/wiki/Environment-Calls), [assembler directives](https://github.com/TheThirdOne/rars/wiki/Assembler-Directives) and more can be found on the [wiki](https://github.com/TheThirdOne/rars/wiki). Documentation included in the download can be accessed via the help menu.
## Download
RARS is distributed as an executable jar. You will need at least Java 8 to run it.
The latest stable release can be found [here](https://github.com/TheThirdOne/rars/releases/latest), a release with the latest developments can be found on the [continuous release](https://github.com/TheThirdOne/rars/releases/tag/continuous), and the [releases page](https://github.com/TheThirdOne/rars/releases) contains all previous stable releases with patch notes.
## Screenshot
## Changes from MARS 4.5
RARS was built on MARS 4.5 and owes a lot to the development of MARS; its
important to note what are new developments and what come straight from MARS.
Besides moving from supporting MIPS to RISC-V and the associated small changes,
there are several general changes worth noting.
– Instructions can now be hot-loaded like Tools. If you want to support an additional extension to the RISC-V instruction set. the .class files just need to be added to the right folder
– ScreenMagnifier, MARS Bot, Intro to Tools, Scavenger Hunt, and MARS Xray were removed from the included tools. ScreenMagnifier, MARS Bot, Intro to Tools, and Scavenger Hunt were removed because they provide little benefit. And MARS Xray was removed because it is not set up to work with RISC-V, however if someone ports it, it could be merged in.
– Removed delayed branching
– Removed the print feature
– Added a testing framework to verify compatability with the RISC-V specification
– Significant internal restructuring and refactoring.
# NOTE: These are defaults only.The values of these keys are maintained by Java Preferences
# objects, which store key-value pairs in a system-dependent way (Windows uses Registry).
AssembleAll = false
AssembleOnOpen = false
BareMachine = false
DataSegmentHighlighting = true
DelayedBranching = false
DisplayAddressesInHex = true
DisplayValuesInHex = true
EditorCurrentLineHighlighting = true
EditorLineNumbersDisplayed = true
ExtendedAssembler = true
LabelWindowVisibility = false
LoadExceptionHandler = false
ProgramArguments = false
RegistersHighlighting = true
StartAtMain = false
WarningsAreErrors = false
PopupInstructionGuidance = true
EditorPopupPrefixLength = 2
EvenRowBackground = 0x00e0e0e0
EvenRowForeground = 0
OddRowBackground = 0x00ffffff
OddRowForeground = 0
TextSegmentHighlightBackground = 0x00ffff99
TextSegmentHighlightForeground = 0
TextSegmentDelaySlotHighlightBackground = 0x33ff00
TextSegmentDelaySlotHighlightForeground = 0
DataSegmentHighlightBackground = 0x0099ccff
DataSegmentHighlightForeground = 0
RegisterHighlightBackground = 0x0099cc55
RegisterHighlightForeground = 0
# Spike compatable calls
GetCWD = 17
Close =57
LSeek =62
Read = 63
Write =64
Exit2 =93
Open = 1024
# Almost compatable
Sbrk =9
Time = 30
# MARS / SPIM compatability
PrintInt =1
PrintFloat =2
PrintString = 4
ReadInt = 5
ReadFloat = 6
ReadString =8
Exit = 10
PrintChar =11
ReadChar = 12
MidiOut =31
Sleep =32
MidiOutSync = 33
PrintIntHex = 34
PrintIntBinary = 35
PrintIntUnsigned = 36
RandSeed = 40
RandInt =41
RandIntRange = 42
RandFloat =43
ConfirmDialog = 50
InputDialogInt = 51
InputDialogFloat = 52
InputDialogString = 54
MessageDialog = 55
MessageDialogInt = 56
MessageDialogString = 59
# Not compatable
# Collided with Close (57)
MessageDialogFloat = 58
Macros in RARS
Introduction to macros
Patterson and Hennessy define a macro as a pattern-matching and replacement facility
that provides a simple mechanism to name a frequently used sequence of instructions [1].
This permits the programmer to specify the instruction sequence by invoking the macro.This requires
only one line of code for each use instead of repeatedly typing
in the instruction sequence each time.It follows the axiom “define once, use many times,” which
not only reduces the chance for error but also facilitates program maintenance.
Macros are like procedures (subroutines) in this sense but operate differently than procedures.
Procedures in assembly language follow particular protocols for procedure definition, call and return.
Macros operate by substituting the macro body for each use at the time of assembly.This substitution
is called macro expansion..They do not require the protocols and execution overhead of procedures.
As a simple example, you may want to terminate your program from a number of locations.If you are running
from the RARS IDE, you will use system call 10, exit.The instruction sequence is pretty easy
li a7, 10
ecall
but still tedious.You can define a macro, let’s call it done, to represent this sequence
.macro done
li a7, 10
ecall
.end_macro
then invoke it whenever you wish with the statement
done
At assembly time, the assembler will replace each occurrence of the statement done with the two-statement
sequence
li a7, 10
ecall
This is the macro expansion.The runtime simulator is unaware of macros or macro expansion.
If running RARS from the command line, perhaps you want to return a termination value.This can be done
with syscall 93, exit2, which takes the termination value as an argument.An equivalent macro,
let’s call it terminatewould be
.macro terminate (%termination_value)
li a0, %termination_value
li a7, 93
ecall
.end_macro
This macro defines a formal parameter to represent the termination value.You would invoke it
with the statement
terminate (1)
to terminate with value 1.Upon assembly,
the statement terminate (1) would be replaced by the three-statement sequence
li a0, 1
li a7, 17
ecall
The argument value, 1, is substituted wherever the formal parameter %termination_value appears
in the macro body.
This is a textual substitution.Note that in this example the argument value must be an integer, not a
register name or a label, because the parameter is used as the second operand in the Load Immediate operation.
In RARS, a macro is similar to an extended (pseudo) instruction. They are distinguished in that the expansion of
extended instructions is supported by an internally-defined specification language and mechanism which can manipulate argument values.
The macro facility can only substitute argument values as given, and it uses a separate mechanism from extended instructions.
Additional examples and details follow.
How to define macros
The first line begins with a .macro directive followed by an optional list of formal parameters.
Placing commas between parameters and parentheses around the list is optional.
Each formal parameter is an identifier that begins with a % character.For compatibility with
the SPIM preprocessor APP, it may alternatively begin with $.
The lines that follow define the body of the macro.Use the formal parameters as appropriate.The body
may contain data segments as well as text segments.
The macro definition finishes with a .end_macro directive.
See the Notes below for additional information.
How to use macros
To invoke a macro, form a statement consisting of the macro name and then one token for each argument
to be substituted for its corresponding formal parameter by the assembler.
The argument list may optionally be surrounded by parentheses.
Arguments may be separated either by spaces or commas.
Macro expansion is a pre-processing task for assemblers.
Notes
A macro definition must appear before its use.No forward references.
All macro definitions are local in each file and they cannot be global.
Nested macro definitions are not supported. No .macro directive should appear inside body of a macro definition.
A macro definition can contain a call to a previously-defined macro.Only backward references are allowed.
Labels placed in the body of a macro definition will not have same name after macro expansion.
During expansion, their name will be followed by “_M#” where # will be a unique number for each macro expansion.
Two macros with the same name but different number of parameters are considered different and both can be used.
A macro defined with the same name and same number of parameters as another macro defined before it will be ignored.
Each argument in a macro call can only be a single language element (token).For instance “4($t0)” cannot be an argument.
Macros are a part of the assembler, not the ISA. So the syntax might be different with other assemblers.
For compatibility with the SPIM simulator, SPIM-style macros are also supported in RARS. SPIM-style macros are same as RARS but formal parameters begin with “$” instead of “%”.
Examples
Printing an integer (argument may be either an immediate value or register name):
.macro print_int (%x)
li a7, 1
add $a0, $zero, %x
syscall
.end_macro
print_int ($s0)
print_int (10)
Printing a string (macro will first assign a label to its parameter in data segment then print it):
.macro print_str (%str)
.data
myLabel: .asciiz %str
.text
li a7, 4
la $a0, myLabel
syscall
.end_macro
print_str (“test1″)#”test1” will be labeled with name “myLabel_M0”
print_str (“test2″)#”test2” will be labeled with name “myLabel_M1”
Implementing a simple for-loop:
# generic looping mechanism
.macro for (%regIterator, %from, %to, %bodyMacroName)
add %regIterator, $zero, %from
Loop:
%bodyMacroName ()
add %regIterator, %regIterator, 1
ble %regIterator, %to, Loop
.end_macro
#print an integer
.macro body()
print_int $t0
print_str “
”
.end_macro
#printing 1 to 10:
for ($t0, 1, 10, body)
The for macro has 4 parameters. %regIterator should be the name of a register which iterates from %from to %to and in each iteration %bodyMacroName will be expanded and run.
Arguments for
%from and %to can be either a register name or an immediate value, and %bodyMacroName should be name of a macro that has no parameters.
Macro source line numbers
For purpose of error messaging and Text Segment display, RARS attempts to display line numbers for both the definition and use of the pertinent
macro statement.If an error message shows the line number in the form “X->Y” (e.g. “20->4”), then X is the line number in the expansion
(use) where the error was detected and Y is the line number in the macro definition.In the Text Segment display
of source code, the macro definition
line number will be displayed within brackets, e.g. “<4>“, at the point of expansion.Line numbers should correspond to the
numbers you would see in the text editor.
The .eqv directive
The .eqv directive (short for “equivalence”) is similar to #define in C or C++.It
is used to substitute an arbitrary string for an identifier.It is useful but much less powerful than macros.
It was developed independently of the macro facility.
Using .eqv, you can specify simple substitutions that provide “define once, use many times” capability at assembly
pre-processing time.For example, once you define
.eqvLIMIT20
.eqvCTRt2
.eqvCLEAR_CTRaddCTR, zero, 0
then you can refer to them in subsequent code:
li a7,1
CLEAR_CTR
loop:move a0, CTR
syscall
add CTR, CTR, 1
blt CTR, LIMIT, loop
CLEAR_CTR
During assembly pre-processing, the .eqv substitutions will be applied.The resulting code is
li a7,1
addt2, zero, 0
loop:move a0, t2
syscall
addt2, t2, 1
bltt2, 20, loop
addt2, zero, 0
which when run will display the values 0 through 19 on one line with no intervening spaces.
Note that the substitution string is not limited to a single token.Like .macro, .eqv is local to the file
in which it is defined, and must be defined prior to use.Macro bodies can contain references to .eqv directives.
The .include directive
The .include directive has one operand, a quoted filename.When the
directive is carried out, the contents of the specified file are substituted for the directive.This occurs
during assembly preprocessing.It is like #include in C or C++.
.include is designed to makemacro and equivalence (.eqv directive) use
more convenient.Both macro definitions and equivalence definitions are local, which means they can be used only
in the same file where defined.Without .include, you would have to repeat their definitions in every
file where you want to use them.Besides being tedious, this is poor programming practice; remember
“define once, use many times.”Now you can define macros and equivalences in a separate file, then include it
in any file where you want to use them.
The .include preprocessor will detect and flag any circular includes (file that includes itself, directly or
indirectly).
The use of .include presents some challenges for error messaging and for source code numbering in the Text
Segment display.If a file being included has any assembly errors, the filename and line number in the error
message should refer to the file being included, not the file it was substituted into.Similarly, the line number
given in the Text Segment source code display refers to the line in the file being included.Thus the displayed line numbers do not
monotonically increase – this is also the case when using the “assemble all” setting.Line numbers should correspond to the numbers
you would see in the text editor.
As a simple example, you could define the done macro (and others) in a separate file
then include it wherever you need it.Suppose “macros.asm” contains the following:
.macro done
li a7,10
syscall
.end_macro
You could then include it in a different source file something like this:
.include “macros.asm”
.data
value:.word 13
.text
li a7, 1
lw a0, value
syscall
done
During assembly preprocessing, this would be expanded to
.macro done
li a7,10
syscall
.end_macro
.data
value:.word 13
.text
li a7, 1
lw a0, value
syscall
done
The assembler will then perform the appropriate macro expansion.
Acknowledgements
All of the RARS macro functionality comes straight from MARS.The MARS macro facility was developed in 2012 by
Mohammad Hossein Sekhavat, [email protected], while an engineering student at Sharif University in Tehran.MARS
creators Pete and Ken are incredibly grateful for his contribution!Pete developed .eqv and .include
at about the same time.
References
[1] Computer Organization and Design: The Hardware/Software Interface, Fourth Edition, Patterson and Hennessy,
Morgan Kauffman Publishers, 2009.
Syscall functions available in RARS
SYSCALL functions available in RARS
Introduction
A number of system services, mainly for input and output, are available for use by
your program.They are described in the table below.
Register contents are not affected by a system call, except for result registers
as specified in the table below.
How to use SYSCALL system services
Step 1. Load the service number in register a7.
Step 2. Load argument values, if any, in a0, a1, a2, a3, fa0, … as specified.
Step 3. Issue the ECALL instruction.
Step 4. Retrieve return values, if any, from result registers as specified.
Example: display the value stored in $t0 on the console
lia7, 1# service 1 is print integer
add a0, t0, zero # load desired value into argument register a0, using pseudo-op
ecall
Table of Available Services
RARS 1.3 help contents
RARS – RISC-V Assembler and Runtime Simulator
Release 1.0
August 2017
Using RARS through its Integrated Development Environment (IDE)
The IDE is invoked when RARS is run with no command arguments, e.g. java -jar rars.jar.
It may also be launched from a graphical interface by double-clicking the rars.jar icon
that represents this executable JAR file.
The IDE provides basic editing, assembling and execution capabilities.Hopefully it
is intuitive to use.Here are comments on some features.
Menus and Toolbar: Most menu items have equivalent toolbar icons.
If the function of a toolbar icon is not obvious, just hover the mouse over it and
a tool tip will soon appear.Nearly all menu items also have keyboard shortcuts.
Any menu item not appropriate in a given situation is disabled.
Editor: RARS includes two integrated text editors.The default editor features syntax-aware color
highlighting of most language elements and popup instruction guides.The original, generic, text
editor without these features is still available and can be selected in the Editor Settings dialog.
It supports a single font which can be modified in the Editor Settings dialog.
The bottom border of either editor includes the cursor line
and column position and there is a checkbox to display line numbers.
They are displayed outside the editing area.If you use an external editor, RARS provides
a convenience setting that will automatically assemble a file as soon as it is opened.See
the Settings menu.
Message Areas: There are two tabbed message areas at the
bottom of the screen.The Run I/O tab is used at runtime for
displaying console output and entering console input as program execution progresses.
You have the option of entering console input into a pop-up dialog then echoes to the message area.
The RARS Messages tab is used for other messages such as assembly or
runtime errors and informational messages.You can click on assembly error messages to
select the corresponding line of code in the editor.
Registers: Registers are displayed at all times, even
when you are editing and not running a program.While writing your program,
this serves as a useful reference for register names and their conventional
uses (hover mouse over the register name to see tool tips).There are three
register tabs: the Register File (integer registers $0 through $31 plus LO,
HI and the Program Counter), selected Coprocesor 0 registers (exceptions and
interrupts), and Coprocessor 1 floating point registers.
Assembly: Select Assemble from the Run menu or the
corresponding toolbar icon to assemble the file currently in the Edit tab.
files in current directory.With the Assemble All setting turned on the assembler will assemble
the current file as the “main” program and also assemble all other assembly
files (*.asm; *.s) in the same directory. And with the Assemble Open option, currently
open the assembler will also assemble currently open files. The results are linked and if all these
operations were successful the program can be executed.Labels that are
declared global with the “.globl” directive may be referenced in any of the
other files in the project.There is also a setting that permits
automatic loading and assembly of a selected exception handler file.
Execution: Once a program successfully assembles, the
registers are initialized and three windows
in the Execute tab are filled: Text Segment, Data Segment,
and Program Labels.The major execution-time features are described below.
Labels Window: Display of the Labels window (symbol table) is
controlled through the Settings menu.When displayed, you can click on any label
or its associated address to center and highlight the contents of that address
in the Text Segment window or Data Segment window as appropriate.
The assembler and simulator are invoked from the IDE
when you select the Assemble, Go,
or Step operations from the Run menu or their corresponding
toolbar icons or keyboard shortcuts.RARS messages are displayed on the
RARS Messages tab of the message area at the bottom of the screen.
Runtime console input and output is handled in the Run I/O tab.
Writing and Using RISC-V exception handlers in RARS
Writing and Using RISC-V user mode exception handlers in RARS
Introduction
Interrupts are a way to break away from the current execution path and deal with a potentially time sensitive
issue and then return to the previous execution path. Interrupts fall into three categories: software, timer, and external.
Software interrupts are triggered by setting a bit in the interrupt pending CSR. Timer interrupts are triggered by a timer.
External interrupts come from outside the CPU. Both timer and external interrupts can be caused from tools from the tools menu.
Synchronous traps are caused by code not being able to continue on its current path without having additional actiion taken.
This can be because the code is incorrect (e.g. load access misaligned) or because action needs to be taken by the OS
(ecall, ebreak, page fault, etc).
Exception handlers allow programs to handle both of these cases. Every trap must be handled immediately either by the
program, or by RARS. System calls and breakpoints are normally handled by RARS, but other faults are generally handled
by printing an error message to the console. The program’s exception handler doesn’t have to print to console though.
Below is a simple handler which just skips over instructions generating traps:
.text
main:
la t0,handler
csrrw zero, 5, t0 # set utvec (5) to the handlers address
csrrsi zero, 0, 1 # set interrupt enable bit in ustatus (0)
lw zero, 0# trigger trap for Load access fault
j main
handler: # Just ignore it by moving epc (65) to the next instruction
csrrw t0, 65, zero
addi t0, t0, 4
csrrw zero, 65, t0
uret
In order to have a working exception handler, the program must:
Set utvec to the address of the handler code (the lowest two bits are special)
Set the bits corresponding to the handled interrupts in uie
Set the interrupt enable (lowest) bit in ustatus to enable the handler
And inside the handler, :
The exception handler can return control to the program using
the uret instruction.This will place the uepc CSR value into the
Program Counter, so be sure to increment it by 4 before returning if you want
to skip over the instruction that caused the exception. It also resets some other
state to before the exception, so jumping to the value in uepc instead is not recommended
ucause contains the reason that the exception handler was called.
Exception types declared in rars.SimulatorException, but
not necessarily implemented, are INSTRUCTION_ADDR_MISALIGNED (0),
INSTRUCTION_ACCESS_FAULT (1), ILLEGAL_INSTRUCTION(2),
LOAD_ADDRESS_MISALIGNED(4), LOAD_ACCESS_FAULT(5),
STORE_ADDRESS_MISALIGNED(6), STORE_ACCESS_FAULT(7), and ENVIRONMENT_CALL(8)
When writing a non-trivial exception handler, your handler must first save
general purpose register contents, then restore them before returning.
The implementation of user-mode exception handlers in RARS is not complete and does not fully conform to the RISC-V
privilidged specification, but it is based upon that and contributions to make it be more conformant would be appreciated.
For more details, refer to the RISC-V priviledged specification https://riscv.org/specifications/privileged-isa/;
contributions to pull in more details into this page would be appreciated.
RARS 1.3 help contents
RARS – RISC-V Assembler and Runtime Simulator
Release 1.0
August 2017
Interactive Debugging Features
RARS provides many features for interactive debugging through its Execute pane.
Features include:
In Step mode, the next instruction to be simulated is highlighted and
memory content displays are updated at each step.
Select the Go option if you want to simulate continually.
It can also be used to continue simulation
from a paused (step, breakpoint, pause) state.
Breakpoints are easily set and reset using the check boxes next to each instruction displayed
in the Text Segment window. You can temporarily suspend breakpoints
using Toggle Breakpoints in the Run menu or by clicking the “Bkpt” column header in the Text Segment
window.Repeat, to re-activate.
When running in the Go mode, you can select the simulation
speed using the Run Speed slider.Available speeds range
from .05 instructions per second (20 seconds between steps) up to 30
instructions per second, then above this offers an “unlimited” speed.
When using “unlimited” speed, code highlighting and memory display updating
are turned off while simulating (but it executes really fast!).
When a breakpoint is reached, highlighting and updating occur.
Run speed can be adjusted while the program is running.
When running in the Go mode, you can pause or stop
simulation at any time using the Pause or Stop features.
The former will pause execution and update the display, as if you
were stepping or at a breakpoint.The latter will terminate execution
and display final memory and register values.If running at “unlimited”
speed, the system may not respond immediately but it will respond.
You have the ability to interactively step “backward” through program execution
one instruction at a time to “undo” execution steps.It will buffer up to 2000 of the most
recent execution steps (this limit is stored in a properties file and can be changed).
It will undo changes made to memory, registers or CSRs (however, interrupt state is not maintained currently),
but not console or file I/O.This should be a great debugging aid.
It is available anytime execution is paused and at termination (even if terminated due to
exception).
When program execution is paused or terminated, select Reset
to reset all memory cells and registers to their initial post-assembly values.
In fact, Reset is implemented by re-assembling the program.
Memory addresses and values, and register values, can be viewed in either decimal
or hexadecimal format.All data are stored in little-endian byte order (each
word consists of byte 3 followed by byte 2 then 1 then 0).Note that each word
can hold 4 characters of a string and those 4 characters will appear in the
reverse order from that of the string literal.
Data segment contents are displayed 512 bytes
at a time (with scrolling) starting with the data segment base address (0x10010000).
Navigation buttons are provided to change the display to the next
section of memory, the previous, or back to the initial (home) range.A combo box is
also provided to view memory contents in the vicinity of the stack pointer
(contents of sp register), global pointer (contents of gp register),
the heap base address (0x10040000), .extern globals (0x10000000), or memory-mapped IO (MMIO, 0xFFFF0000).
The raw text segment contents can also be displayed.
Contents of any data segment memory word and almost any register can be modified by
editing its displayed table cell.Double-click on a cell to edit it and press the Enter key
when finished typing the new value.If you
enter an invalid 32-bit integer, the word INVALID appears in the cell
and memory/register contents are not affected.Values can be entered
in either decimal or hexadecimal (leading “0x”).Negative hexadecimal
values can be entered in either two’s complement or signed format.Note
that three of the integer registers (zero, program counter, return address)
cannot be edited.
If the setting for Self-Modifying Code is enabled
(disabled by default, look in the Settings menu), text segment binary
code can be modified using the same technique described above. It can also
be modified by double-clicking on a cell in the Text Segment display’s Code
column.
Contents of cells representing floating point registers can be edited
as described above and will accept valid hexadecimal or decimal floating point
values.Since each double-precision register overlays two single-precision
registers, any changes to a double-precision register will affect one or both
of the displayed contents of its corresponding single-precision registers.
Changes to a single-precision register will affect the display of its
corresponding double-precision register.Values entered in hexadecimal
need to conform to IEEE-754 format.Values entered in decimal are entered
using decimal points and E-notation (e.g. 12.5e3 is 12.5 times 10 cubed).
Cell contents can be edited during program execution and once accepted
will apply starting with the next instruction to be executed.
Clicking on a Labels window entry will cause the location associated with
that label to be centered and highlighted in the Text Segment or Data Segment
window as appropriate.Note the Labels window is not displayed by default but
can be by selecting it from the Settings menu.
Example of File I/O
The sample program below will open a new file for writing, write text to it from a memory buffer, then close it.The file will be created in the
directory in which RARS was run.
# Sample program that writes to a new file.
# by Kenneth Vollmar and Pete Sanderson
.data
fout: .asciz “testout.txt”# filename for output
buffer: .asciz “The quick brown fox jumps over the lazy dog.”
.text
###############################################################
# Open (for writing) a file that does not exist
li a7, 1024 # system call for open file
la a0, fout # output file name
li a1, 1# Open for writing (flags are 0: read, 1: write)
ecall # open a file (file descriptor returned in a0)
mv s6, a0 # save the file descriptor
###############################################################
# Write to file just opened
li a7, 64 # system call for write to file
mv a0, s6 # file descriptor
la a1, buffer # address of buffer from which to write
li a2, 44 # hardcoded buffer length
ecall # write to file
###############################################################
# Close the file
li a7, 57 # system call for close file
mv a0, s6 # file descriptor to close
ecall # close file
###############################################################
Using MIDI output
These system services are unique to RARS, and provide a means of producing sound.MIDI output is
simulated by your system sound card, and the simulation is provided by the javax.sound.midi
package.
This service requires four parameters as follows:
pitch (a0)
Accepts a positive byte value (0-127) that denotes a pitch as it would
be represented in MIDI
Each number is one semitone / half-step in the chromatic scale.
0 represents a very low C and 127 represents a very high G (a standard
88 key piano begins at 9-A and ends at 108-C).
If the parameter value is outside this range, it applies a default value 60 which is the same as middle C on a piano.
From middle C, all other pitches in the octave are as follows:
61 = C# or Db
62 = D
63 = D# or Eb
64 = E or Fb
65 = E# or F
66 = F# or Gb
67 = G
68 = G# or Ab
69 = A
70 = A# or Bb
71 = B or Cb
72 = B# or C
To produce these pitches in other octaves, add or subtract multiples
of 12.
duration in milliseconds (a1)
Accepts a positive integer value that is the length of the tone in milliseconds.
If the parameter value is negative, it applies a default value of one second (1000 milliseconds).
instrument (a2)
Accepts a positive byte value (0-127) that denotes the General MIDI
“patch” used to play the tone.
If the parameter is outside this range, it applies a default value 0 which is an Acoustic Grand Piano.
General MIDI standardizes the number associated with each possible instrument
(often referred to as program change numbers), however it does
not determine how the tone will sound. This is determined by the synthesizer
that is producing the sound. Thus a Tuba (patch 58) on one computer
may sound different than that same patch on another computer.
The 128 available patches are divided into instrument families of 8:
0-7Piano64-71Reed
8-15Chromatic Percussion72-79Pipe
16-23Organ80-87Synth Lead
24-31Guitar88-95Synth Pad
32-39Bass96-103Synth Effects
40-47Strings104-111Ethnic
48-55Ensemble112-119Percussion
56-63Brass120-127Sound Effects
Note that outside of Java, General MIDI usually refers to patches 1-128.
When referring to a list of General MIDI patches, 1 must be subtracted
to play the correct patch. For a full list of General MIDI instruments,
see
www.midi.org/about-midi/gm/gm1sound.shtml.
The General MIDI channel 10 percussion key map is not relevant to the
toneGenerator method because it always defaults to MIDI channel 1.
volume (a3)
Accepts a positive byte value (0-127) where 127 is the loudest and 0
is silent. This value denotes MIDI velocity which refers to the initial
attack of the tone.
If the parameter value is outside this range, it applies a default value 100.
MIDI velocity measures how hard a note on (or note off)
message is played, perhaps on a MIDI controller like a keyboard. Most
MIDI synthesizers will translate this into volume on a logarithmic scale
in which the difference in amplitude decreases as the velocity value increases.
Note that velocity value on more sophisticated synthesizers can also
affect the timbre of the tone (as most instruments sound different when
they are played louder or softer).
MIDI Output was developed and documented by Otterbein student Tony Brock in July 2007.
RARS 1.3 help contents
RARS – RISC-V Assembler and Runtime Simulator
Release 1.0
August 2017
Using RARS from a command line.
RARS can be run from a command interpreter to assemble and execute a program in
a batch fashion.
The format for running RARS from a command line is:
java -jar rars.jar [options] program.asm [more files…] [ pa arg1 [more args…]]
Items in [ ] are optional.Valid options (not case sensitive, separated by spaces) are:
NOTICE: The table below is potentially innaccurate, if a command does not work as documented,
file an issue at https://github.com/thethirdone/rars/issues, and check java -jar rars.jar h
for potentially correct documentation
OptionDescriptionSince
aassemble only, do not simulate1.0
aenterminate RARS with integer exit code n if assembly error occurs4.1
asciidisplay memory or register contents interpreted as ASCII codes. (alternatives are dec and hex)4.1
bbrief – do not display register/memory address along with contents2.2
ddisplay RARS debugging statements (of interest mainly to RARS developer)
decdisplay memory or register contents in decimal. (alternatives are ascii and hex)2.2
dumpdump memory contents to file.
Option has 3 arguments, e.g. dump
and .data.Also supports an address range (see m-n below).Current supported dump formats are Binary, HexText, BinaryText, AsciiText.See examples below.3.4
hexdisplay memory or register contents in hexadecimal – this is the default. (alternatives are ascii and dec)2.2
hdisplay this help.Use this option by itself and with no filename.1.0
icdisplay instruction count; the number of basic instructions ‘executed’4.3
mcset memory configuration.
Option has 1 argument, e.g. mc
possible values are Default for the default 32-bit address space, CompactDataAtZero for
a 32KB address space with data segment at address 0, or CompactTextAtZero
for a 32KB address space with text segment at address 0.3.7
medisplay RARS messages to standard err instead of standard out.Allows you to separate RARS messages from program output using redirection.4.3
nccopyright notice will not be displayed.Useful if redirecting or piping program output.3.5
nppseudo-instructions or extended instruction formats are not permitted.3.0
pproject option – will assemble the specified file and all other assembly files (*.asm; *.s) in its directory.3.1
senterminate RARS with exit code n if simulate (run) error occurs4.1
smstart execution at statement having global label ‘main’ if defined3.8
smcSelf Modifying Code – Program can write and execute in either text or data segment4.4
weassembler warnings will be considered errors.3.5
nwhere n is an integer maximum count of execution steps to simulate.
If 0, negative or not specified, there is no maximum.1.0
$regwhere reg is number or name (e.g. 5, t3, f10) of register whose
content to display at end of run.Even-numbered float register displays both float and double.Option may be repeated.
NOTE: Depending on your command shell, you may need to escape the $, e.g. $t32.2
reg_namewhere reg_name is the name (e.g. t3, f10) of register whose
content to display at end of run.Even-numbered float register displays both float and double.Option may be repeated. $ not required.2.2
m-nmemory address range from m to n whose contents to
display at end of run. m and n may be decimal or hexadecimal (starts with 0x),
m <= n, both must be on word boundary.Option may be repeated.2.2paprogram arguments – all remaining space-separated items are argument values provided to theprogram via $a0 (argc – argument count) and $a1 (argv – address of array containing pointers to null-terminated argumentstrings). The count is also at the top of the runtime stack ($sp), followed by the array.This option and its arguments must be the last items in the command!3.5Example: java -jar rars.jar h Displays command options and explanations.Example: java -jar rars.jar $s0 $s1 0x10010000-0x10010010 fibonacci.asm Assemble and run fibonacci.asm.At the end of the run, display the contents of registers $s0 and$s1, and the contents of memory locations 0x10010000 through 0x10010010.The contents are displayed inhexadecimal format.Example: java -jar rars.jar a fibonacci.asmAssemble fibonacci.asm.Does not attempt to run the program, and the assembled code is not saved.Example: java -jar rars.jar 100000 infinite.asmAssemble and run infinite.asm for a maximum of 100,000 execution steps.Example: java -jar rars.jar p major.asmAssemble major.asm and all other files in the same directory, link the assembled code, and run starting with the first instruction in major.asm.Example: java -jar rars.jarmajor.asmminor.asmsub.asmAssemble and link major.asm, minor.asm and sub.asm.If successful, executionwill begin with the first instruction in major.asm.Example: java -jar rars.jar a dump .text HexText hexcode.txt fibonacci.asmAssemble fibonacci.asm without simulating (note use of ‘a’ option).At end of assembly, dump the text segment (machine code) tofile hexcode.txt in hexadecimal text format with one instruction per line.Example: java -jar rars.jardump 0x10010000-0x10010020 HexText hexcode.txt fibonacci.asmAssemble and simulate fibonacci.asm.At end of simulation, dump the contents of addresses 0x1001000 to0x10010020 to file hexdata.txt in hexadecimal text format with one word per line.Example: java -jar rars.jar t0 process.asmpa counter 10Assemble and run process.asm with two program argument values, “counter” and “10”.It may retrieve theargument count (2) from $a0, and the address of an array containing pointers to the strings “count” and “10”,from $a1.At theend of the run, display the contents of register $t0.The ability to run RARS from the command line is useful if you want to developscripts (macros) to exercise a given program under multiple scenariosor if you want to run a number of different programssuch as for grading purposes.Bug Reporting help contentsBug Reporting and General CommentsThe RARS is hosted athttps://github.com/TheThirdOne/rarsand will contain updated releases, bug lists, etc.For bug reporting, questions or comments, please create an issue at https://github.com/TheThirdOne/rars/issuesRARS 1.3 help contentsRARS – RISC-V Assembler and Runtime SimulatorRelease 1.0August 2017IntroductionRARS, the RISC-V Assembler, Simulator, and Runtime,will assemble and simulate the execution of RISC-V assembly language programs.It can be used either from a command line or through its integrated development environment (IDE). RARS is written in Java andrequires at least Release 1.8 of the Java SE Java Runtime Environment (JRE) to work.It is distributed as an executable JAR file.As of Release 1.0, RARS supports most of RV32IMFN (base 32 bit instruction set + multiplication, floating point, and user-level interrupts).The guiding reference for implementing the instruction set has been version 2.2 of the official specification.The RARS IDE provides program editing and assembling but its realstrength is its support for interactive debugging.The programmer can easily set andremove execution breakpoints or step through execution forward or backward (undo) whileviewing and directly editing register and memory contents.Questions and CommentsFor bug reporting, please create an issue at https://github.com/TheThirdOne/rars/issues for generalquestions or comments email the lowRISC mailing list [email protected] Release History and NotesRARS – RISC-V Assembler and Runtime SimulatorRelease 1.3June 2019Release HistoryRARS 1.3 was released in June 2019.It added a Java API to allow for quick automated simulation and contains several bugfixes.A full changelist is availible at https://github.com/TheThirdOne/rars/releases/tag/v1.3RARS 1.2 was released in March 2019. It improved tooling for new developers and fixed some documentation issuesRARS 1.1 was released in August 2018. This release fixed a bug with AUIPC and psuedointructions that used it, lburequiring half-word alignment and the funct fields of bge,bgeu, and bltu RARS 1.0 was released in August 2017. This release moved from supporting MIPS to supporting RISC-V.Besides that major change and associated small changes, there are several general changes worth noting.Instructions can now be hot-loaded like Tools. If you want to support an additional extension to the RISC-Vinstruction set. the .class files just need to be added to the right folderScreenMagnifier, Scavenger Hunt, and MARS Xray were removed from the included tools. ScreenMagnifier andScavenger Hunt were removed because they provide little benefit. And Xray was removed because it is not set up towork with RISC-V, however if someone ports it, it could be merged in.Removed delayed branchingRemoved the print featureAdded a testing framework to verify compatibility with the RISC-V specificationMars 4.5 was released in August 2014.Enhancements and bug fixes include:The Keyboard and Display MMIO Simulator tool has been enhanced at the suggestion of Eric Wang atWashington State University.Until now, all characters written to the display via the Data Transmitterlocation (low order byte of memory word 0xFFFF000C) were simply streamed to the tools’ display window.Mr. Wang requested the ability to treat the display window as a virtual text-based terminal bybeing able to programmatically clear the window or set the (x,y) position of a text cursor.Controlledplacement of the text cursor (which is not displayed) allows you to, among other things, develop 2D text-mode games.To clear the window, place ASCII/Unicode 12 decimal in the Data Transmitter byte.This is the non-printing Form Feed character.To set the text cursor to a specified (x,y) position, where x is the column and y is the row,place ASCII/Unicode 7 in the Data Transmitter byte, and place the (x,y) position in the unusedupper 24 bits of the Data Transmitter word.Place the X-position in bits 20-31 and the Y-position in bits 8-19.Position (0,0) is the upper-left corner of the display.You can resize the display window to desired dimensions prior to running your MIPS program.Dimensions are dynamically displayed in the upper border.Note that the tool now contains a splitter between the display window and the keyboard window.Once the program is running, changes to the display sizedoes not affect cursor positioning. The Help window for this tool is no longer modal, so you can view it while working in other windows. The Help window contains a lot of information so you will find it useful to be able to refer to it while working on your program.Installed the MIPS X-ray Tool developed by Marcio Roberto and colleagues at the Federal Center of Technological Education of Minas Gerais in Brazil. This tool animates a display of the MIPS datapath.The animation occurs while stepping through program execution.Search the Internet for “MIPS X-ray”to find relevant publications and other information.Context-sensitive help in the editor should now be easier to read.It was implemented as a menu ofdisabled items, which caused their text to be dimmed.The items are now enabled for greater visibilitybut clicking them will only make the list disappear.Bug Fix: Fixed an editor problem that affects certain European keyboards.The syntax-highlighting editorignored the Alt key, which some European keyboards require to produce the # or $ characters in particular.I had no means of testing this, but Torsten Maehne in France send me a solution and UmbertoVillano in Italy affirmed that it worked for him as well.Bug Fix:Source code references to Coprocessor 1 floating point registers (e.g. $f12) within macro definitions were erroneously flagged as syntax errors.MARS permits SPIM-stylemacro parameters (which start with $ instead of %) and did not correctly distinguish themfrom floating point register names.This has been fixed.Thanks to Rudolf Biczok in Germany for alertingme to the bug.Bug Fix:Corrected a bug that caused the Data Segment window to sometimes display incorrect valuesat the upper boundary of simulated memory segments.Thanks to Yi-Yu (James) Liu from Taiwan for alertingme to the bug, which was introduced in Mars 4.4.Mars 4.4 was released in August 2013.Enhancements and bug fixes include:A feature to support self-modifying code has been developed by Carl Burch (Hendrix College) and Pete Sanderson.It is disabled by defaultand can be enabled through a Settings menu option.A program can write to thetext segment and can also branch/jump to any user address in the data segmentswithin the limits of the simulated address space.Text segment contents can also be edited interactively using the Data Segment window, and textsegment contents within the address range of existing code can be editedinteractively using the Text Segment window.In command mode, the smc optionpermits a program to write and execute in both text and data segments.Bug fix: An assembly error occurred when a line within a macro contained both a macro parameter and an identifier defined to have an .eqv substitution.Bug fix: If a macro name was used as a macro parameter, an assembly error occurred in some situationswhen a macro being used as an argument was defined following the macro thatdefined the parameter.The “for” macro described in the Macro help tab isan example.Mars 4.3 was released in January 2013.Enhancements and bug fixes include:A macro facility has been developed by Mr. Mohammad Sekhavat.It is documentedin the MIPS help tab Macros.A text substitution facility similar to #define has been developed usingthe new .eqv directive.It is also documented in the MIPS helptab Macros.A text insertion facility similar to #include has been developedusing the new .include directive.It is also documented in theMIPS help tab Macros.It permits a macro to be defined in one file andincluded wherever needed.Two new command mode options are now available: ic (Instruction Count) todisplay a count of statements executed upon program termination, and me(Messages to Error) to send MARS messages to System.err instead of System.out.Allows you to separate MARS messages from MIPS output using redirection, if desired.Redirect a stream in DOS with “1>” or “2>” for out and err,
respectively. To redirect both, use “> filename 2>&1”
Changed the default font family settings from Courier New to Monospaced.
This was in response to reports of Macs displaying left parentheses and vertical
bars incorrectly.
Changed the way operands for .byte and .half directives are range-checked.
It will now work like SPIM, which accepts any operand value but truncates high-end bits as
needed to fit the 1 (byte) or 2 (half) byte field.We’ll still issue a warning
but not an error.
For file reads, syscall 14, file descriptor 0 is always open for standard input.For file
writes, syscall 15, file descriptors 1 and 2 are always open for standard output and
standard error, respectively.This permits you to write I/O code that will
work either with files or standard I/O.When using the IDE, standard input and output
are performed in the Run I/O tab.File descriptors for regular files are
allocated starting with file descriptor 3.
Mars 4.2 was released in August 2011.Enhancements and bug fixes include:
Performing a Save operation on a new file will now use the file’s tab
label as the the default filename in the Save As dialog (e.g. mips1.asm).
Previously, it did not provide a default name.
When the “assemble all files in directory” setting is enabled (useful
for multi-file projects), you can now switch focus from one editor tab to another
without invalidating the current assemble operation.You can similarly open
additional project files.Previously, the open or tab selection would
invalidate the assemble operation and any paused execution state or
breakpoints would be lost.
The Read String syscall (syscall 8) has been fortified to prevent Java exceptions from occurring
when invalid values are placed in $a1.
Will now perform runtime test for unaligned doubleword address in
‘ldc1’ and ‘sdc1’ instructions and trap if not aligned.
Basic statements in the Text Segment display now renders immediates using
eight hex digits when displaying in hex.Previously it rendered only
four digits to conserve space.This led to confusing
results.For instance, -1 and 0xFFFF would both be displayed as 0xFFFF
but -1 expands to 0xFFFFFFFF and 0xFFFF expands to 0x0000FFFF.
Mars 4.1 was released in January 2011.Enhancements and bug fixes include:
The ability to view Data Segment contents interpreted as ASCII
characters has been added.You’ll find it on the bottom border of
the Data Segment Window as the checkbox “ASCII”.This overrides the
hexadecimal/decimal setting but only for the Data Segment display.
It does not persist across sessions.Cells cannot be edited in
ASCII format.
The Dump Memory feature in the File menu now provides an ASCII dump
format.Memory contents are interpreted as ASCII codes.
A command-mode option “ascii” has been added to display memory or
register contents interpreted as ASCII codes.It joins the existing
“dec” and “hex” options for displaying in decimal or hexadecimal,
respectively.Only one of the three may be specified.
The actual characters to display for all the ASCII display options
(data segment window, dump memory, command-mode option) are
specified in the config.properties file.This includes a “placeholder”
character to be displayed for all codes specified as non-printing.
ASCII codes 1-7, 14-31, and 127-255 are specified as
non-printing, but this can be changed in the properties file.
A new Help tab called Exceptions has been added.It explains the basics
of MIPS exceptions and interrupts as implemented in MARS.It also includes
tips for writing and using exception handlers.
A new Tool called Bitmap Display has been added.You can use it
to simulate a simple bitmap display.Each word of the specified address
space represents a 24 bit RGB color (red in bits 16-23, green in bits
8-15, blue in bits 0-7) and a word’s value will be displayed on the Tool’s
display area when the word is written to by the MIPS program.The base
address corresponds to the upper left corner of the display, and words are
displayed in row-major order.Version 1.0 is pretty basic, constructed
from the Memory Reference Visualization Tool code.
Additional operand formats
were added for the multiplication pseudo-instructions ‘mul’ and ‘mulu’.
The editor’s context-sensitive pop-up help will now appear below
the current line whenever possible.Originally it appeared either above,
centered to the side,
or below, depending on the current line’s vertical position in the editing
window.Displaying the pop-up above the current line tended to visually block
important information, since frequently a line of code uses the same operand
(especially registers) as the one immediately above it.
The editor will now auto-indent each new line when the Enter
key is pressed.Indentation of the new line will match that of the
line that precedes it.This feature can be disabled in the Editor settings dialog.
Two new command-mode options have been added.The “aeN” option, where
N is an integer, will terminate MARS with exit value N when an assemble error
occurs.The “seN” option will similarly terminate MARS with exit value
N when a simulation (MIPS runtime) error occurs.These options can be useful
when writing scripts for grading. Thanks to my Software
Engineering students Robert Anderson, Jonathan Barnes, Sean Pomeroy, and Melissa Tress
for designing and implementing these options.
An editor bug that affected Macintosh users has been fixed.
Command shortcuts, e.g. Command-s for save, did not
function and also inserted the character into the text.
A bug in Syscall 54 (InputDialogString) has been fixed.This syscall is
the GUI equivalent of Syscall 8 (ReadString), which follows the semantics
of UNIX ‘fgets’.Syscall 54 has been modified to also follow the ‘fgets’
semantics.
A bug in the Cache Simulator Tool has been fixed.The animator that
paints visualized blocks green or red (to show cache hit or miss) sometimes
paints the wrong block when set-associated caching is used.The underlying
caching algorithm is correct so the numeric results such as hit ratios
have always been correct.The animator has been corrected.
Thanks to Andreas Schafer and his student Carsten Demel for bringing this
to my attention.
Mars 4.0.1 was released in October 2010.It is a bug fix release to address three bugs.
The Edit and Execute tabs of the IDE, which were relocated in 4.0 from the top to the left edge and oriented vertically, have been
moved back to the top edge because Macintosh running Java 1.6 does not correctly render vertically-oriented tabs.
An exception may be thrown in multi-file assembles when the last file of the assembly is not the longest. This occurs
only when using the IDE, and has been corrected.
If an assemble operation fails due to a non-existing exception handler file (specified through the IDE Settings menu), unchecking
the exception handler setting does not prevent the same error from occuring on the next assemble. This has been corrected.
Mars 4.0 was released in August 2010.Enhancements and bug fixes include:
New Text Editor: Mars features an entirely new integrated text editor.It creates a new tab for each file
as it is opened.The editor now features language-aware
color highlighting of many MIPS assembly language elements with customizable
colors and styles.It also features automatic context-sensitive popup instruction
guides.There are two levels: one with help and autocompletion of instruction names
and a second with help information for operands.These and other new editor
features can be customized or disabled through
the expanded Editor Settings dialog.You can even revert to the previous
notepad-style editor if you wish (multi-file capability is retained).
The language-aware editor is based on
the open source jEdit Syntax Package (syntax.jedit.org).It is separate from
the assembler, so any syntax highlighting quirks will not affect assembly.
Improved Instruction Help: All the instruction examples in the help tabs (and new popup instruction guides)
now use realistic register names, e.g. $t1, $t2, instead of $1, $2.The instruction format
key displayed above the MIPS help tabs has been expanded to include explanations of the
various addressing modes for load and store instructions and pseudo-instructions.
Descriptions have been added to every example instruction and pseudo-instruction.
Improved Assembly Error Capability: If the assemble operation results in errors, the first error message
in the Mars Messages text area will be highighted and the corresponding erroneous instruction will be selected in the
text editor.In addition, you can click on any error message in the Mars Messages text area to select the corresponding
erroneous instruction in the text editor.The first feature does not select in every situation (such as when
assemble-on-open is set) but in the situations where it doesn’t work no harm is done plus
the second feature, clicking on error messages, can still be used.
Console input syscalls (5, 6, 7, 8, 12) executed in the IDE now receive input keystrokes directly in the Run I/O text
area instead of through a popup input dialog.Thanks to Ricardo Pascual for providing this feature!
If you prefer the popup dialogs, there is a setting to restore them.
The floor, ceil, trunc and round operations now all produce the MIPS default result 2^31-1 if the value is
infinity, NaN or out of 32-bit range.For consistency, the sqrt operations now produce the result NaN if the operand is negative
(instead of raising an exception).These cases are all consistent with FCSR (FPU Control and Status Register)
Invalid Operation flag being off.The ideal solution would be to simulate the FCSR register itself so all
MIPS specs for floating point instructions can be implemented, but that hasn’t happened yet.
The Basic column in the Text Segment Window now displays data and addresses in either decimal or
hexadecimal, depending on the current settings.Note that the “address” in branch instructions
is actually an offset relative to the PC, so is treated as data not address.Since data operands in
basic instructions are no more than 16 bits long, their hexadecimal display includes only 4 digits.
The Source column in the Text Segment Window now preserves tab spacing for a cleaner appearance (tab characters were previously not rendered).
Instruction mnemonics can now be used as labels, e.g. “b:”.
New syscall 36 will display an integer as an unsigned decimal.
A new tool, Digital Lab Sim, contributed by Didier Teifreto ([email protected]).This tool
features two seven-segment displays, a hexadecimal keypad, and a counter.It uses MMIO to explore
interrupt-driven I/O in an engaging setting.More information is available from its Help feature.Many thanks!
MARS 4.0 requires Java 1.5 (5.0) instead of 1.4.If this is an issue for you, let me know.
Mars 3.8 was released in January 2010.Enhancements and bug fixes include:
A new feature to temporarily suspend breakpoints you have previously set.Use it
when you feel confident enough to run your program without the breakpoints but not
confident enough to clear them!Use the Toggle Breakpoints item in the Run menu, or
simply click on the “Bkpt” column header in the Text Segment window.Repeat, to re-activate.
Two new Tools contributed by Ingo Kofler of Klagenfurt University in Austria.
One generates instruction statistics and the other simulates branch prediction using
a Branch History Table.
Two new print syscalls.Syscall 34 prints an integer in hexadecimal format.
Syscall 35 prints an integer in binary format.Suggested by Bernardo Cunha of Portugal.
A new Setting to control whether or not the MIPS program counter will be
initialized to the statement with global label ‘main’ if such a statement exists.If
the setting is unchecked or if checked and there is no ‘main’, the program counter
will be initialized to the default starting address.Release 3.7 was programmed
to automatically initialize it to the statement labeled ‘main’.This led to
problems with programs that use the standard SPIM exception handler exceptions.s
because it includes a short statement sequence at the default starting address
to do some initialization then branch to ‘main’.Under 3.7 the initialization
sequence was being bypassed.By default this setting is unchecked.This
option can be specified in command mode using the ‘sm’ (Start at Main) option.
Mars Tools that exist outside of Mars can now be included in the Tools
menu by placing them in a JAR and including it in a command that launches
the Mars IDE.For example: java -cp plugin.jar;Mars.jar Mars
Thanks to Ingo Kofler for thinking of this technique and providing the
patch to implement it.
Corrections and general improvements to the MIDI syscalls.Thanks to Max Hailperin
of Gustavus Adolphus College for supplying them.
Correction to an assembler bug that flagged misidentified invalid MIPS instructions
as directives.
Mars 3.7 was released in August 2009.Enhancements and bug fixes include:
A new feature for changing the address space configuration of the
simulated MIPS machine.The 32-bit address space configuration used by
all previous releases remains the default.We have defined two
alternative configurations for a compact 32KB address space.One starts the
text segment at address 0 and the other starts the data segment at address 0.
A 32KB address space permits commonly-used load/store pseudo-instructions
using labels, such as lw$t0,increment, to expand to a single basic
instruction since the label’s full address will fit into the 16-bit address
offset field without sign-extending to a negative value.This was done in response to
several requests over the years for smaller addresses and simplified expansions
to make assembly programs easier to comprehend.This release does not
include the ability to define your own customized configuration, although we
anticipate adding it in the future.It is available both through the command
mode (option mc) and the IDE.
See Memory Configuration… at the bottom of the Settings menu.
Related to the previous item: load and store pseudo-instructions of the form
lw $t0,label and lw $t0,label($t1) will expand to a single
instruction (addi for these examples) if the current memory configuration assures the
label’s full address will fit into the low-order 15 bits.Instructions
for which this was implemented are: la, lw, lh, lb, lhu, lbu, lwl, lwr, ll,
lwc1, ldc1, l.s, l.d, sw, sh, sb, swl, swr, sc, swc1, sdc1,
s.s, and s.d.
If a file contains a global statement label “main” (without quotes, case-sensitive), then execution will
begin at that statement regardless of its address.Previously, program execution
always started at the base address of the text segment.This will be handy for
multi-file projects because you no longer need to have the “main file” opened in
the editor in order to run the project.Note that main has to be declared global
using the .globl directive.
We have added a Find/Replace feature to the editor.This has been another
frequent request.Access it through the Edit menu or Ctrl-F.Look for major
enhancements to the editor in 2010!
The syscalls for Open File (13), Read from File (14), and Write to File (15)
all now place their return value into register $v0 instead of $a0.The table
in Computer Organization and Design’s Appendix B on SPIM specifies
$a0 but SPIM itself consistently uses $v0 for the return values.
Pseudo-instructions for div, divu, mulo, mulou, rem, remu, seq, sne, sge,
sgeu, sgt, sgtu, sle, sleu now accept a 16- or 32-bit immediate as their third operand.
Previously the third operand had to be a register.
Existing Tools were tested using reconfigured memory address space (see first item).Made some
adaptations to the Keyboard and Display Simulator Tool that allow it to be used for
Memory Mapped I/O (MMIO) even under the compact memory model, where the MMIO base address
is 0x00007f00 instead of 0xffff0000.Highlighting is not perfect in this scenario.
Bug Fix:The syscall for Open File (13) reversed the meanings of the
terms mode and flag.Flags are used to indicate the intended
use of the file (read/write).Mode is used to set file permissions in specific situations.
MARS implements selected flags as supported by Java file streams,
and ignores the mode if specified.For more details, see the Syscalls
tab under Help.The file example in that tab has been corrected.
Bug Fix: The assembler incorrectly generated an
error on Jump instructions located in the kernel text segment.
Bug Fix: The project (p) option in the command interface worked incorrectly
when MARS was invoked within the directory containing the files to be assembled.
Acknowledgement: The development of Release 3.7 was supported by a SIGCSE
Special Projects Grant.
Mars 3.6 was released in January 2009.Enhancements and bug fixes include:
We’ve finally implemented the most requested new feature: memory and register cells will
be highlighted when written to during timed or stepped simulation!The
highlighted memory/register cell thus represents the result of the instruction just completed.
During timed or stepped execution, this is NOT the highlighted instruction.During back-stepping,
this IS the highlighted instruction.The highlighted instruction is the next one
to be executed in the normal (forward) execution sequence.
In conjunction with cell highlighting, we’ve added the ability to customize the highlighting
color scheme and font.Select Highlighting in the Settings menu.In the resulting dialog,
you can select highlight background color, text color, and font for the different runtime tables (Text segment,
Data segment, Registers).You can also select them for normal, not just
highlighted, display by even- and odd-numbered row but not by table.
Cool new Labels Window feature: the table can be sorted in either ascending or descending
order based on either the Label (alphanumeric) or the Address (numeric) column.Just click on
the column heading to select and toggle between ascending (upright triangle) or descending
(inverted triangle).Addresses are sorted based on unsigned 32 bit values.
The setting persists across sessions.
The Messages panel, which includes the Mars Messages and Run I/O tabs, now displays using
a mono-spaced (fixed character width) font.This facilitates text-based graphics when running
from the IDE.
The Mars.jar distribution file now contains all files needed to produce
a new jar file.This will make it easier for you to expand the jar, modify source files,
recompile and produce a new jar for local use.CreatMarsJar.bat contains the jar instruction.
The Help window now includes a tab for Acknowledgements.This recognizes MARS contributors
and correspondents.
We’ve added a new system call (syscall) for generating MIDI tones synchronously, syscall 33.
The original MIDI call returns immediately when the tone is generated.The new one will not return
until the tone output is complete regardless of its duration.
The Data Segment display now scrolls 8 rows (half a table) rather than 16 when the
arrow buttons are clicked.This makes it easier to view a sequence of related cells that
happen to cross a table boundary.Note you can hold down either button for rapid scrolling.
The combo box with various data address boundaries also works better now.
Bug Fix: Two corrections to the Keyboard and Display Simulator Tool.Transmitter Ready bit was
not being reset based on instruction count
when running in the kernel text segment, and the Status register’s Exception Level bit was not
tested before enabling the interrupt service routine (could lead to looping if interrupts occur
w/i the interrupt service routine).Thanks to Michael Clancy and Carl Hauser for bringing these
to my attention and suggesting solutions.
Bug Fix: Stack segment byte addresses not on word boundaries were not being processed
correctly.This applies to little-endian byte order (big-endian is not enabled or tested in MARS).
Thanks to Saul Spatz for recognizing the problem and providing a patch.
Minor Bug Fixes include: Correcting a fault leading to failure when launching MARS in command
mode, clarifying assembler error message for too-few or too-many operands error, and correcting the
description of lhu and lbu instructions from “unaligned” to “unsigned”.
Mars 3.5 was released in August 2008.Major enhancements and bug fixes include:
A new Tool, the Keyboard and Display MMIO Simulator, that supports polled and interrupt-driven
input and output operations through Memory-Mapped I/O (MMIO) memory.The MIPS program writes to
memory locations which serve as registers for simulated devices.Supports keyboard input and a
simulated character-oriented display.Click the tool’s Help button for more details.
A new Tool, the Instruction Counter, contributed by MARS user Felipe Lessa.It will count the
number of MIPS instructions executed along with percentages for R-format, I-format, and J-format
instructions. Thanks, Felipe!
Program arguments can now be provided to the MIPS program at runtime, through either an IDE setting or
command mode.See the command mode “pa” option for more details on command mode operation.The argument
count (argc) is placed in $a0 and the address of an array of null-terminated strings containing the
arguments (argv) is placed in $a1.They are also available on the runtime stack ($sp).
Two related changes permit MARS to assemble source code produced by certain compilers such as gcc.
One change is to issue warnings rather than errors for unrecognized directives.MARS implements a
limited number of directives.Ignore these warnings at your risk, but the assembly can continue.
The second change is to allow statement labels to contain, and specifically begin with, ‘$’.
In command mode, final register values are displayed by giving the register name as an option.
Register names begin with ‘$’, which is intercepted by certain OS command shells.The
convention for escaping it is not uniform across shells.We have enhanced the options so now you can
give the register name without the ‘$’.For instance, you can use t0 instead of $t0 as the option.
You cannot refer to registers by number in this manner, since an integer option is interpreted by
the command parser as an instruction execution limit.Thanks to Lucien Chaubert for reporting
this problem.
Minor enhancements: The command mode dump feature has been extended to permit memory address ranges as well
as segment names. If you enter a new file extension into the Open dialog, the extension will remain available throughout
the interactive session. The data segment value repetition operator ‘:’ now
works for all numeric directives (.word, .half, .byte, .float, .double).
This allows you to initialize multiple consecutive memory locations to the same value.For
example:
ones: .half 1 : 8# Store the value 1 in 8 consecutive halfwords
Major change:Hexadecimal constants containing less than 8 digits will be interpreted as though the
leading digits are 0’s.For instance, 0xFFFF will be interpreted as 0x0000FFFF, not 0xFFFFFFFF as before.
This was causing problems with immediate operands in the range 32768 through 65535, which were
misinterpreted by the logical operations as signed 32 bit values rather than unsigned 16 bit values.
Signed and unsigned 16 bit values are now distinguished by the tokenizer based on the prototype
symbols -100 for signed and 100 for unsigned (mainly logical operations).
Many thanks to Eric Shade of Missouri State University and Greg Gibeling of UC Berkeley for
their extended efforts in helping me address this situation.
Minor Bug Fixes: round.w.s and round.w.d have been modified to correctly perform IEEE
rounding by default.Thanks to Eric Shade for pointing this out.
Syscall 12 (read character) has been changed to leave the character in $v0 rather then $a0.The
original was based on a misprint in Appendix A of Computer Organization and Design.
MARS would not execute from the executable Mars.jar file if it was stored in a directory
path those directory names contain any non-ASCII characters.This has been corrected.Thanks to
Felipe Lessa for pointing this out and offering a solution.
MARS will now correctly detect the EOF condition when reading from a file using syscall 14.
Thanks to David Reimann for bringing this to our attention.
Mars 3.4.1 was released on 23 January 2008.It is a bug fix release to address two bugs.
One bug shows up in pseudo-instructions in which the expansion includes branch instructions.The fixed branch
offsets were no longer correct due to changes in the calculation of branch offsets in Release 3.4.
At the same time, we addressed the issue of expanding such pseudo-instructions when
delayed branching is enabled.Such expansions will now include a nop instruction following the
branch.
We also addressed an off-by-one error that occurred in generating the lui instruction in the
expansion of conditional branch pseudo-instructions whose second operand is a 32 bit immediate.
The expansions for a number of pseudo-instructions were modified to eliminate internal branches.
These and other expansions were also optimized for sign-extended loading of 16-bit immediate operands
by replacing the lui/ori or lui/sra sequence with addi.Pseudo-instructions affected by one
or both of these modifications include: abs, bleu, bgtu, beq, bne, seq, sge, sgeu, sle, sleu, sne,
li, sub and subi.These modifications were suggested by Eric Shade of Missouri State University.
Mars 3.4 was released in January 2008.Major enhancements are:
A new syscall (32) to support pauses of specified length in milliseconds (sleep) during simulated execution.
Five new syscalls (40-44) to support the use of pseudo-random number generators.An unlimited number of these generators are available,
each identified by an integer value, and for each you have the ability to: set the seed value, generate a 32 bit integer value from the Java
int range, generate a 32 bit integer value between 0 (inclusive) and a specified upper bound (exclusive), generate a 32-bit float value between 0 (inclusive) and 1 (exclusive),
and generate a 64-bit double value between 0 (inclusive) and 1 (exclusive).All are based on the java.util.Random class.
Ten new syscalls (50-59) to support message dialog windows and data input dialog windows.The latter are distinguished from
the standard data input syscalls in that a prompting message is specified as a syscall argument and displayed in the input dialog.
All are based on the javax.swing.JOptionPane class.
The capability to dump .text or .data memory contents to file in various formats.The dump can be performed
before or after program execution from either the IDE (File menu and toolbar) or from command mode.It can also be performed
during an execution pause from the IDE.Look for the “Dump Memory” menu item in the File menu, or the “dump” option in command
mode.A .text dump will include only locations containing an instruction.A .data dump will include a multiple
of 4KB “pages” starting at the segment base address and ending with the last 4KB “page” to be referenced by the
program.Current dump formats include pure binary (java.io.PrintStream.write() method), hexadecimal text with one word (32 bits)
per line, and binary text with one word per line.An interface, abstract class, and format loader have been developed to facilitate
development and deployment of additional dump formats.This capability was prototyped by Greg Gibeling of UC Berkeley.
Changed the calculation of branch offsets when Delayed Branching setting is disabled.
Branch instruction target addresses are represented by
the relative number of words to branch.With Release 3.4, this value reflects delayed branching,
regardless of whether the Delayed Branching setting is enabled or not.
The generated binary code for branches will now match that of examples in the Computer Organization
and Design textbook.This is a change from the past, and was made after extensive discussions
with several MARS adopters.Previously, the branch offset was 1 lower if the Delayed Branching setting
was enabled — the instruction label: beq $0,$0,label would generate 0x1000FFFF if
Delayed Branching was enabled and 0x10000000 if it was disabled.Now it will generate 0x1000FFFF in
either case.The simulator will always branch to the correct location; MARS does not allow assembly under one
setting and simulation under the other.
Bug fix: The mars.jar executable JAR file can now be run from a different working directory.Fix was
suggested by Zachary Kurmas of Grand Valley State University.
Bug fix: The problem of MARS hanging while assembling a pseudo-instruction with a label operand that
contains the substring “lab”, has been fixed.
Bug fix: No Swing-related code will be executed when MARS is run in command mode.This fixes a problem that
occurred when MARS was run on a “headless” system (no monitor).Swing is the Java library to support
programming Graphical User Interfaces.Fix was provided by Greg Gibeling of UC Berkeley.
The ‘ ’ character is now recognized when it appears in string literals.
MARS 3.3 was released in July 2007.Major enhancements are:
Support for MIPS delayed branching.All MIPS computers implement this but it can be confusing for
programmers, so it is disabled by default.Under delayed branching, the next instruction after a branch
or jump instruction will always be executed, even if the branch or jump is taken!Many
programmers and assemblers deal with this by inserting a do-nothing “nop” instruction after every branch or jump.
The MARS assembler does not insert a “nop”.Certain pseudo-instructions expand to
a sequence that includes a branch; such instructions will not work correctly under delayed
branching.
Delayed branching is available in command mode with the “db” option.
A new tool of interest mainly to instructors.The Screen Magnifier tool, when selected from
the Tools menu, can be used to produce an enlarged static image of the pixels that lie beneath it.
The image can be annotated by dragging the mouse over it to produce a scribble line.It enlarges
up to 4 times original size.
You now have the ability to set and modify the text editor font family, style and size.Select
“Editor…” from the Settings menu to get the dialog. Click the Apply button to see the new
settings while the dialog is still open.Font settings are retained from one session to the next.
The font family list begins with 6 fonts commonly used across platforms (selected from lists
found at www.codestyle.org), followed by a complete list.
Two of the six are monospaced fonts, two are proportional serif, and two are proportional sans serif.
The Labels window on the Execute pane, which displays symbol table information, has been
enhanced.When you click on a label name or its address, the contents of that address are
centered and highlighted in the Text Segment window or Data Segment window as appropriate.This makes
it easier to set breakpoints based on text labels, or to find the value stored at a label’s address.
If you re-order the columns in the Text Segment window by dragging a column header,
the new ordering will be remembered and applied from that time forward, even from one MARS session to the next.The Text Segment
window is where source code, basic code, binary code, code addresses, and breakpoints are displayed.
If a MIPS program terminates by “running off the bottom” of the program, MARS terminates, as
before, without an exception, but now will display a more descriptive termination message in the
Messages window.Previously, the termination message was the same as that generated after executing an Exit syscall.
A new system call (syscall) to obtain the system time rivetis now available.It is service
30 and is not available in SPIM.Its value is obtained from the java.util.Date.getTime() method.
See the Syscall tab in MIPS help for further information.
A new system call (syscall) to produce simulated MIDI sound through your sound card is now available.
It is service 31 and is not available in SPIM.Its implementation is based on the
javax.sound.midi package.It has been tested only under Windows.
See the Syscall tab in MIPS help for further information.
MARS 3.2.1 was released in January 2007.It is a bug fix release that addresses the
following bug in 3.2: a NullPointerException occurs when MIPS program execution terminates
by “dropping off the bottom” of the program rather than by using one of the Exit system
calls.
MARS 3.2 was released in December 2006.Major enhancements are:
It fixes several minor bugs, including one that
could cause incorrect file sequencing in the Project feature.
It includes the
AbstractMarsToolAndApplication abstract class to serve as a framework for easily
constructing “tools” and equivalent free-standing applications that use the MARS assembler
and simulator engines (kudos to the SIGCSE 2006 audience member who suggested this capability!).
A subclass of this abstract class can be used both ways (tool or application).
The floating
point and data cache tools were elaborated in this release and a new tool for animating and
visualizing memory references was developed.All are AbstractMarsToolAndApplication
subclasses.
This release includes support for exception handlers: the kernel data and text
segments (.kdata and .ktext directives), the MIPS trap-related instructions, and the ability
to automatically include a selected exception (trap) handler with each assemble operation.
Items in the Settings menu became persistent with this release.
Added default assembly file extensions “asm” and “s” to the Config.properties file and used
those not only to filter files for the File Open dialog but also to filter them for the “assemble all”
setting.
Implemented a limit to the amount of text scrollable in the Mars Messages and Run I/O message
tabs – default 1 MB is set in the Config.properties file.
For programmer convenience, labels can now be referenced in the operand field of integer
data directives (.word, .half, .byte).The assembler will substitute the label’s address (low order
half for .half, low order byte for .byte).
For programmer convenience, character literals (e.g. ‘b’, ‘
’, ‘377’) can be used anywhere that integer literals are
permitted.The assembler converts them directly to their equivalent 8 bit integer value. Unicode is not supported and
octal values must be exactly 3 digits ranging from ‘ 00’ to ‘377’.
Replaced buttons for selecting Data Segment display base addresses with a combo box and added more
base addresses: MMIO (0xFFFF0000), .kdata (0x90000000), .extern (0x10000000).
MARS 3.1 was released in October 2006.The major issues and features are listed here:
It addressed several minor limits (Tools menu items
could not be run from the JAR file, non-standard shortcuts for Mac users, inflexible and
sometimes inappropriate sizing of
GUI components).
It changed the way SYSCALLs are implemented, to allow anyone to define
new customized syscall services without modifying MARS.
It added a primitive
Project capability through the “Assemble operation applies to all files in current directory.”
setting (also available as “p” option in command mode).The command mode also allows you
to list several file names not necessarily in the same directory to be assembled and linked.
Multi-file assembly also required implementing the “.globl” and “.extern” directives.
And although “Mars tools” are not officially part of MARS releases, MARS 3.1 includes the
initial versions of two tools: one for learning about floating point representation and another
for simulating data caching capability.
MARS 3.0 was released in August 2006, with one bug fix and two major additions.
The bug fix was corrected instruction format for the slti and sltiu instructions.
One major addition is a greatly expanded MIPS-32 instruction
set (trap instructions are the only significant ones to remain unimplemented).This includes, via
pseudo-instructions, all reasonable memory addressing modes for the load/store instructions.
The
second major addition is ability to interactively step “backward” through program execution
one instruction at a time to “undo” execution steps.It will buffer up to 2000 of the most
recent execution steps (this limit is stored in a properties file and can be changed).
It will undo changes made to MIPS memory, registers or condition flags,
but not console or file I/O.This should be a great debugging aid.
It is available anytime execution is paused and at termination (even if terminated due to
exception).
A number of IDE settings, described
above, are now available through the Settings menu.
MARS 2.2 was released in March 2006 with additional bug fixes and implemented command
line options (run MARS from command line with h option for command line help).This also coincides with our
SIGCSE 2006 paper “MARS: An Education-Oriented MIPS Assembly Language Simulator”.
MARS 2.1 was released in October 2005 with some bug fixes.
MARS 2.0 was released in September 2005.It incorporated significant
modifications to both the GUI and the assembler, floating point registers and instructions
most notably.
MARS 1.0 was released in January 2005 and
publicized during a poster presentation at SIGCSE 2005.
Dr. Ken Vollmar initiated MARS development in 2002 at Missouri State University.In
2003, Dr. Pete Sanderson of Otterbein College and his student Jason Bumgarner continued
implementation.Sanderson implemented the assembler and simulator that summer, and
the basic GUI the following summer, 2004.
The development of Releases 3.1 and 3.2 in 2006 and 4.0 in 2010 were supported by the Otterbein College
sabbatical leave program.The development of Release 3.7 during summer 2009 was supported by
a SIGCSE Special Projects Grant.
RARS 1.3 help contents
RARS – RISC-V Assembler and Runtime Simulator
Release 1.0
August 2017
Operating Requirements
RARS is written in Java and
requires at least Release 1.8 of the Java SE Java Runtime Environment (JRE) to work.
The graphical IDE is implemented using Swing. It has been tested on Windows 8 and Ubuntu 16;
it should also work on Windows XP and 7 as well as Mac OS X.
Some RARS Assembler and Simulator Limitations
RARS aims to assemble RV32IMFN.
Limitations of RARS as of Release 1.0 include:
Memory segments (text, data, stack) are limited to 4MB each starting at their
respective base addresses.
There is no pipelined mode.
If you open a file which is a link or shortcut to another file, RARS will not
open the target file.The file open dialog is implemented using Java Swing’s JFileChooser,
which does not support links.
Very few configuration changes, besides those in the Settings menu, are saved from one session to the next.
The editor settings, which include font settings and display of line numbers, are saved.
The IDE will work only with the RARS assembler. It cannot be used
with any other compiler, assembler, or simulator. The RARS assembler and simulator
can be used either through the IDE or from a command prompt.
Floating point support is not completely compliant because Java does not provide low enough level access to
floating point operations.
Control and status registers cannot be referenced by name in instructions. This is a fully fixable issue.
Interrrupt support is a little flawed there is more work to be done to make it close to compliant with the specification.
Bug: The error message highlighter does not automatically select the code for the first assembly
error if the file containing the error is not open at the time of assembly (assemble-on-open, assemble-all).
Bug: There appears to be a memory leak in the Editor.Several different people have independently
reported the same behavior: severe slowdown in editor response during an extended interactive session.
If RARS is exited and restarted, this behavior disappears and the editor responds instantly to actions.
RARS 1.3 help contents
RARS – RISC-V Assembler and Runtime Simulator
Release 1.0
August 2017
Cool Capability: Plug-in Tools
RARS is capable of running externally-developed software that interacts with an executing
program and system resources.
The requirements for such a program are:
It implements the rars.tools.Tool interface.
It is part of the rars.tools package.
It compiles cleanly into a “.class” file, stored in the rars/tools directory.
RARS will detect all qualifying tools upon startup and include them in
its Tools menu.
When a tool’s menu item is selected, an instance of it will be created using its no-argument
constructor and its action() method will be invoked.
If no qualifying tools are found at startup, the Tools menu will not
appear.
To use such a tool, load and assemble a program of interest then select the desired tool
from the Tools menu.The tool’s window will open and depending on how it is written it will either
need to be “connected” to the program by clicking a button or will already be connected.Run
the program as you normally would, to initiate tool interaction with the executing program.
The abstract class rars.tools.AbstractToolAndApplication
is included in the RARS distribution to provide
a substantial framework for implementing your own Tool.A subclass that extends it by
implementing at least its two abstract methods can be run not only from the Tools menu but also
as a free-standing application that uses the RARS assembler and simulator in the background.
Several Tools developed by subclassing AbstractMarsToolAndApplication are included
with RARS: an Introduction to Tools, a Data Cache Simulator, a Memory Reference Visualizer, and
a Floating Point tool.The last one is quite useful even when not connected to a program
because it displays binary, hexadecimal and decimal representations for a 32 bit floating point
value; when any of them is modified the other two are updated as well.
Adding more system calls
System calls (ecall instruction) are implemented using
a technique similar to that for tools.This permits anyone to add a new syscall by defining
a new class that meets these requirements:
It extends the rars.riscv.AbstractSyscall class.
It is part of the rars.riscv.syscalls package.
It compiles cleanly into a “.class” file, stored in the
rars/riscv/syscalls directory.
An entry is added to Syscall.properties
Extending the instruction set
You can add customized pseudo-instructions to the instruction set by editing
the PseudoOps.txt. Instruction specification formats are explained in the file itself.
The specification of a pseudo-instruction is one line long.It consists of
an example of the instruction, constructed using available instruction specification symbols, followed by a semicolon-separated
list of the basic instructions it will expand to.Each is an instruction template
constructed using
instruction specification symbols combined with special template
specification symbols.The latter permit substitution at program
assembly time of operands from the user’s program into the expanded
pseudo-instruction.
PseudoOps.txt is read and processed at startup, and error messages will
be produced if a specification is not correctly formatted.Note that if you wish to
edit it you first have to extract it from the JAR file.
RARS Acknowledgements
RARS Acknowledgements
Updated 26 August 2017
This project was built off of MARS and owes a lot to the work of Pete Sanderson and Kenneth Vollmar.
In addition to the main contributors of MARS many people have helped throughout its development and their work is greatly appreciated.
Torsten Mahne, Umberto Villano and others who took care of the
bug with certain European keyboards that require an Alt key combo to form
essential MIPS assembly characters like $ and #.I had no means of testing it.
Eric Wang at Washington State University, who suggested adding
cursor positioning to the Keyboard and Display MMIO Simulator tool.
Carl Burch of Hendrix College, who developed the mechanism for
simulating the execution of straight binary code.Previously, execution was based on
ProgramStatement objects generated by the assembler. This, combined with the added capabilities
to write to the text segment and
branch/jump into the data segment at runtime, permits one to produce self-modifying
programs, simulate buffer overflow attacks, and the like.
Tom Bradford, Slava Pestov and others, who developed the jEdit Syntax Package (syntax.jedit.org)
at the heart of the syntax-aware color highlighting editor.It was old but the licensing was right and it was
written for embedding into Java applications.
Mohammad Sekhavat from Sharif University in Tehran, who developed the
macro capability.
Greg Gibeling of UC Berkeley, who introduced capabilities into his customized version
of MARS that have subsequently been expanded and integrated into our release.
These include the ability to dump memory contents to file and parser improvements
to distinguish signed from unsigned hexadecimal constants.
Eric Shade of Missouri State University, who suggested several improvements to
pseudo-instruction expansions such as elimination of internal branches
and improvements to the sign-extended loading of 16-bit immediate operands.
Saul Spatz of the University of Missouri Kansas City, who noticed and provided a solution
for a flaw in the calculation of byte-oriented addresses in the simulated memory stack segment.
He has also suggested several improvements that we have implemented.
Zachary Kurmas of Grand Valley State University, who suggested several bug fixes and
who encorporated MARS into his own successful JLSCircuitTester digital logic simulator software.
Felipe Lessa, who contributed the Instruction Counter tool and suggested a solution
for the problem of MARS inability to launch when stored in a directory whose name
contained non-ASCII characters.
Carl Hauser of Washington State University, who pointed out and provided a solution to
a flaw in the Keyboard and Display Simulator Tool in how it used the Exception Level bit in the
Coprocessor1 Status register.Also thanks to Michael Clancy of UC Berkeley for pointing out a flaw in the
tool’s mechanism for resetting the Transmit Ready bit when operating in kernel memory.
Dave Poplawski of Michigan Technological University, for his assistance in working through
some issues with signed/unsigned constants and with output redirection.
Ingo Kofler of Klagenfurt University in Austria, who contributed two Tools: a tool
to collect Instruction Statistics, and a tool to simulate branch prediction
with a Branch History Table.
Brad Richards and Steven Canfield from the University of Puget Sound, for providing
a technique that improved file loading performance.
Jan Schejbal and Jan-Peter Kleinhans of Darmstadt technical university in Germany, for
suggesting and providing a patch to display Run I/O text in a constant-width font.
Max Hailperin of Gustavus Adolphus College, who made several
improvements to the MIDI syscalls.
David Patterson of UC Berkeley, for making time in his busy schedule for Ken’s demo of MARS.
Denise Penrose and Nate McFadden of Morgan Kaufmann Publishers, for their
assistance as editors of
Computer Organization and Design.
Ricardo Pascual of University of Murcia in Spain, who contributed the code to permit input syscall
keystrokes to be typed directly into the Run I/O window instead of through a popup dialog.
Didier Teifreto of Université de Franche-Comté in France, who contributed the Digital Lab Sim tool.
Facundo Agriel of the University of Illinois at Chicago, who added font selection to the Keyboard and
Display Simulator tool.
Patrik Lundin for contributing the code to add scrolling to the keyboard and display simulator.
Otterbein students Robert Anderson, Jonathan Barnes, Sean Pomeroy and Melissa Tress
for contributing the new command-mode options for specifying MARS exit codes when
assembly or simulation errors occur.This was sparked by a comment from
Zheming Jim of the University of South Carolina.
The unknown audience member at our SIGCSE 2006 conference presentation,
who suggested that MARS would also be useful running in the background
in support of an external application.This led directly to our development of the Tools
framework and API that truly distinguishes MARS from all other MIPS simulators.
RoundingMode
package jsoftfloat;
public final synchronized enum RoundingMode {
public static final RoundingMode even;
public static final RoundingMode away;
public static final RoundingMode min;
public static final RoundingMode max;
public static final RoundingMode zero;
public static RoundingMode[] values();
public static RoundingMode valueOf(String);
private void RoundingMode(String, int);
static void
}
Float32
package jsoftfloat.types;
public synchronized class Float32 extends Floating {
public static final Float32 Zero;
public static final Float32 NegativeZero;
public static final Float32 NaN;
public static final Float32 Infinity;
public static final Float32 NegativeInfinity;
public final int bits;
private static final int sigbits = 23;
private static final int expbits = 8;
private static final int maxexp = 128;
private static final int minexp = -127;
private static final int sigmask = 8388607;
public void Float32(int);
public void Float32(boolean, int, int);
public int exponent();
public static Float32 fromInteger(int);
public Float32 negate();
public Float32 abs();
public Float32 copySign(Float32);
public boolean isSignMinus();
public boolean isInfinite();
public boolean isNormal();
public boolean isSubnormal();
public boolean isNaN();
public boolean isSignalling();
public boolean isCanonical();
public boolean isZero();
public Float32 NaN();
public Float32 Zero();
public Float32 NegativeZero();
public Float32 Infinity();
public Float32 NegativeInfinity();
public Float32 fromExactFloat(jsoftfloat.internal.ExactFloat, jsoftfloat.Environment);
public static Float32 fromExact(jsoftfloat.internal.ExactFloat, jsoftfloat.Environment);
public jsoftfloat.internal.ExactFloat toExactFloat();
public int maxPrecision();
static void
}
Floating
package jsoftfloat.types;
public abstract synchronized class Floating {
public void Floating();
public abstract boolean isSignMinus();
public abstract boolean isInfinite();
public boolean isFinite();
public abstract boolean isNormal();
public abstract boolean isSubnormal();
public abstract boolean isNaN();
public abstract boolean isSignalling();
public abstract boolean isCanonical();
public abstract boolean isZero();
public abstract int maxPrecision();
public abstract Floating NaN();
public abstract Floating Zero();
public abstract Floating NegativeZero();
public abstract Floating Infinity();
public abstract Floating NegativeInfinity();
public abstract Floating fromExactFloat(jsoftfloat.internal.ExactFloat, jsoftfloat.Environment);
public abstract jsoftfloat.internal.ExactFloat toExactFloat();
public abstract Floating negate();
}
Float32$1
package jsoftfloat.types;
synchronized class Float32$1 {
static void
}
Environment
package jsoftfloat;
public synchronized class Environment {
public java.util.EnumSet flags;
public RoundingMode mode;
public void Environment(RoundingMode);
public void Environment();
}
Flags
package jsoftfloat;
public final synchronized enum Flags {
public static final Flags inexact;
public static final Flags underflow;
public static final Flags overflow;
public static final Flags divByZero;
public static final Flags invalid;
public static Flags[] values();
public static Flags valueOf(String);
private void Flags(String, int);
static void
}
ExactFloat
package jsoftfloat.internal;
public synchronized class ExactFloat implements Comparable {
public final boolean sign;
public final int exponent;
public final java.math.BigInteger significand;
public void ExactFloat(boolean, int, java.math.BigInteger);
public void ExactFloat(java.math.BigInteger);
public ExactFloat add(ExactFloat);
public ExactFloat multiply(ExactFloat);
public ExactFloat divide(ExactFloat, int);
public ExactFloat squareRoot(int);
public ExactFloat shiftRight(int);
public ExactFloat normalize();
public ExactFloat roundToIntegral(jsoftfloat.Environment);
public java.math.BigInteger toIntegral(jsoftfloat.Environment);
public int compareTo(ExactFloat);
public ExactFloat abs();
public ExactFloat negate();
public boolean isZero();
static void
}
Arithmetic
package jsoftfloat.operations;
public synchronized class Arithmetic {
public void Arithmetic();
public static jsoftfloat.types.Floating add(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating subtraction(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating multiplication(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating squareRoot(jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating fusedMultiplyAdd(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating division(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
static void
}
Conversions
package jsoftfloat.operations;
public synchronized class Conversions {
public void Conversions();
public static jsoftfloat.types.Floating roundToIntegral(jsoftfloat.types.Floating, jsoftfloat.Environment);
public static java.math.BigInteger convertToIntegral(jsoftfloat.types.Floating, java.math.BigInteger, java.math.BigInteger, jsoftfloat.Environment, boolean);
public static int convertToInt(jsoftfloat.types.Floating, jsoftfloat.Environment);
public static int convertToInt(jsoftfloat.types.Floating, jsoftfloat.Environment, boolean);
public static int convertToUnsignedInt(jsoftfloat.types.Floating, jsoftfloat.Environment, boolean);
public static jsoftfloat.types.Floating convertFromInt(java.math.BigInteger, jsoftfloat.Environment, jsoftfloat.types.Floating);
}
Comparisons
package jsoftfloat.operations;
public synchronized class Comparisons {
public void Comparisons();
private static jsoftfloat.types.Floating nonNaNmin(jsoftfloat.types.Floating, jsoftfloat.types.Floating);
private static jsoftfloat.types.Floating handleNaN(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
private static jsoftfloat.types.Floating handleNaNNumber(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating minimum(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating maximum(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating minimumNumber(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating maximumNumber(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating minNum(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static jsoftfloat.types.Floating maxNum(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietEqual(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean equalSignaling(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietLessThan(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareSignalingtLessThan(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietLessThanEqual(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareSignalingLessThanEqual(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietGreaterThan(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareSignalingtGreaterThan(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietGreaterThanEqual(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareSignalingGreaterThanEqual(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
public static boolean compareQuietUnordered(jsoftfloat.types.Floating, jsoftfloat.types.Floating, jsoftfloat.Environment);
}
gitdir: ../../.git/modules/src/jsoftfloat
AssemblyException
package rars;
public synchronized class AssemblyException extends Exception {
private ErrorList errs;
public void AssemblyException(ErrorList);
public ErrorList errors();
}
AbstractToolAndApplication$10
package rars.tools;
synchronized class AbstractToolAndApplication$10 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$10(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
MemoryReferenceVisualization$8
package rars.tools;
synchronized class MemoryReferenceVisualization$8 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$8(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$4
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$4 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$4(KeyboardAndDisplaySimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
CacheSimulator$5
package rars.tools;
synchronized class CacheSimulator$5 implements java.awt.event.ActionListener {
void CacheSimulator$5(CacheSimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
TimerTool
package rars.tools;
public synchronized class TimerTool extends AbstractToolAndApplication {
private static String heading;
private static String version;
private static final int TIME_ADDRESS;
private static final int TIME_CMP_ADDRESS;
private static javax.swing.JPanel panelTools;
private TimerTool$TimePanel timePanel;
private static long time;
private static long startTime;
private static long savedTime;
private static TimerTool$TimeCmpDaemon timeCmp;
private java.util.Timer timer;
private TimerTool$Tick tick;
private static boolean updateTime;
private static boolean running;
public void TimerTool();
public void TimerTool(String, String);
public static void main(String[]);
public String getName();
protected javax.swing.JComponent buildMainDisplayArea();
private void startTimeCmpDaemon();
protected void performSpecialClosingDuties();
public void start();
public void play();
public void pause();
protected void reset();
public void stop();
private synchronized void updateMMIOControlAndData(int, int);
protected javax.swing.JComponent getHelpComponent();
static void
}
TimerTool$Tick
package rars.tools;
synchronized class TimerTool$Tick extends java.util.TimerTask {
public volatile boolean updateTimecmp;
private void TimerTool$Tick(TimerTool);
public void run();
private boolean bitsEnabled();
public void reset();
}
MemoryReferenceVisualization$ColorChooserControls$1
package rars.tools;
synchronized class MemoryReferenceVisualization$ColorChooserControls$1 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$ColorChooserControls$1(MemoryReferenceVisualization$ColorChooserControls, MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay$4
package rars.tools;
synchronized class BitmapDisplay$4 implements java.awt.event.ActionListener {
void BitmapDisplay$4(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
TimerTool$1
package rars.tools;
synchronized class TimerTool$1 implements java.awt.event.ActionListener {
void TimerTool$1(TimerTool);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$7
package rars.tools;
synchronized class AbstractToolAndApplication$7 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$7(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
FloatRepresentation$InstructionsPane
package rars.tools;
synchronized class FloatRepresentation$InstructionsPane extends javax.swing.JLabel {
void FloatRepresentation$InstructionsPane(FloatRepresentation, java.awt.Component);
public void setText(String);
}
AbstractToolAndApplication$MessageField
package rars.tools;
synchronized class AbstractToolAndApplication$MessageField extends javax.swing.JTextField {
public void AbstractToolAndApplication$MessageField(AbstractToolAndApplication, String);
private void displayTerminatingMessage(String);
private void displayNonTerminatingMessage(String);
private void displayMessage(String, boolean);
}
TimerTool$3
package rars.tools;
synchronized class TimerTool$3 implements java.awt.event.ActionListener {
void TimerTool$3(TimerTool);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$5
package rars.tools;
synchronized class AbstractToolAndApplication$5 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$5(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay$6
package rars.tools;
synchronized class BitmapDisplay$6 implements java.awt.event.ActionListener {
void BitmapDisplay$6(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
FloatRepresentation$1
package rars.tools;
synchronized class FloatRepresentation$1 implements java.awt.event.ActionListener {
void FloatRepresentation$1(FloatRepresentation);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator
package rars.tools;
public synchronized class KeyboardAndDisplaySimulator extends AbstractToolAndApplication {
private static String version;
private static String heading;
private static String displayPanelTitle;
private static String keyboardPanelTitle;
private static char VT_FILL;
public static java.awt.Dimension preferredTextAreaDimension;
private static java.awt.Insets textAreaInsets;
private final KeyboardAndDisplaySimulator$TransmitterDelayTechnique[] delayTechniques;
public static int RECEIVER_CONTROL;
public static int RECEIVER_DATA;
public static int TRANSMITTER_CONTROL;
public static int TRANSMITTER_DATA;
private boolean countingInstructions;
private int instructionCount;
private int transmitDelayInstructionCountLimit;
private int currentDelayInstructionLimit;
private int intWithCharacterToDisplay;
private boolean displayAfterDelay;
private boolean displayRandomAccessMode;
private int rows;
private int columns;
private KeyboardAndDisplaySimulator$DisplayResizeAdapter updateDisplayBorder;
private KeyboardAndDisplaySimulator simulator;
private javax.swing.JPanel keyboardAndDisplay;
private javax.swing.JScrollPane displayScrollPane;
private javax.swing.JTextArea display;
private javax.swing.JPanel displayPanel;
private javax.swing.JPanel displayOptions;
private javax.swing.JComboBox delayTechniqueChooser;
private KeyboardAndDisplaySimulator$DelayLengthPanel delayLengthPanel;
private javax.swing.JSlider delayLengthSlider;
private javax.swing.JCheckBox displayAfterDelayCheckBox;
private javax.swing.JPanel keyboardPanel;
private javax.swing.JScrollPane keyAccepterScrollPane;
private javax.swing.JTextArea keyEventAccepter;
private javax.swing.JButton fontButton;
private java.awt.Font defaultFont;
public static final int EXTERNAL_INTERRUPT_KEYBOARD = 64;
public static final int EXTERNAL_INTERRUPT_DISPLAY = 128;
private static final char CLEAR_SCREEN = 12;
private static final char SET_CURSOR_X_Y = 7;
public void KeyboardAndDisplaySimulator(String, String);
public void KeyboardAndDisplaySimulator();
public static void main(String[]);
public String getName();
protected void initializePreGUI();
protected void addAsObserver();
protected javax.swing.JComponent buildMainDisplayArea();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
private void displayCharacter(int);
protected void initializePostGUI();
protected void reset();
private void initializeDisplay(boolean);
private void repaintDisplayPanelBorder();
private java.awt.Dimension getDisplayPanelTextDimensions();
protected javax.swing.JComponent getHelpComponent();
private javax.swing.JComponent buildDisplay();
private javax.swing.JComponent buildKeyboard();
private void updateMMIOControl(int, int);
private void updateMMIOControlAndData(int, int, int, int);
private synchronized void updateMMIOControlAndData(int, int, int, int, boolean);
private static boolean isReadyBitSet(int);
private static int readyBitSet(int);
private static int readyBitCleared(int);
private void initializeTransmitDelaySimulator();
private int generateDelay();
static void
}
CacheSimulator$3
package rars.tools;
synchronized class CacheSimulator$3 implements java.awt.event.ActionListener {
void CacheSimulator$3(CacheSimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$2
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$2 implements javax.swing.event.CaretListener {
void KeyboardAndDisplaySimulator$2(KeyboardAndDisplaySimulator);
public void caretUpdate(javax.swing.event.CaretEvent);
}
AbstractToolAndApplication$EnterKeyListener
package rars.tools;
public synchronized class AbstractToolAndApplication$EnterKeyListener extends java.awt.event.KeyAdapter {
javax.swing.AbstractButton myButton;
public void AbstractToolAndApplication$EnterKeyListener(AbstractToolAndApplication, javax.swing.AbstractButton);
public void keyPressed(java.awt.event.KeyEvent);
}
AbstractToolAndApplication$GUIUpdater
package rars.tools;
synchronized class AbstractToolAndApplication$GUIUpdater implements Runnable {
private void AbstractToolAndApplication$GUIUpdater(AbstractToolAndApplication);
public void run();
}
CacheSimulator
package rars.tools;
public synchronized class CacheSimulator extends AbstractToolAndApplication {
private static boolean debug;
private static final String version = Version 1.2;
private static final String heading = Simulate and illustrate data cache performance;
private javax.swing.JComboBox cacheBlockSizeSelector;
private javax.swing.JComboBox cacheBlockCountSelector;
private javax.swing.JComboBox cachePlacementSelector;
private javax.swing.JComboBox cacheReplacementSelector;
private javax.swing.JComboBox cacheSetSizeSelector;
private javax.swing.JTextField memoryAccessCountDisplay;
private javax.swing.JTextField cacheHitCountDisplay;
private javax.swing.JTextField cacheMissCountDisplay;
private javax.swing.JTextField cacheSizeDisplay;
private javax.swing.JProgressBar cacheHitRateDisplay;
private CacheSimulator$Animation animations;
private javax.swing.JPanel logPanel;
private javax.swing.JScrollPane logScroll;
private javax.swing.JTextArea logText;
private javax.swing.JCheckBox logShow;
private javax.swing.border.EmptyBorder emptyBorder;
private java.awt.Font countFonts;
private java.awt.Color backgroundColor;
private int[] cacheBlockSizeChoicesInt;
private int[] cacheBlockCountChoicesInt;
private static final String[] cacheBlockSizeChoices;
private static final String[] cacheBlockCountChoices;
private static final String[] placementPolicyChoices;
private static final int DIRECT = 0;
private static final int FULL = 1;
private static final int SET = 2;
private static final String[] replacementPolicyChoices;
private static final int LRU = 0;
private static final int RANDOM = 1;
private String[] cacheSetSizeChoices;
private static final int defaultCacheBlockSizeIndex = 2;
private static final int defaultCacheBlockCountIndex = 3;
private static final int defaultPlacementPolicyIndex = 0;
private static final int defaultReplacementPolicyIndex = 0;
private static final int defaultCacheSetSizeIndex = 0;
private CacheSimulator$AbstractCache theCache;
private int memoryAccessCount;
private int cacheHitCount;
private int cacheMissCount;
private double cacheHitRate;
private java.util.Random randu;
public void CacheSimulator(String, String);
public void CacheSimulator();
public static void main(String[]);
public String getName();
protected javax.swing.JComponent buildMainDisplayArea();
private javax.swing.JComponent buildLogArea();
private javax.swing.JComponent buildOrganizationArea();
private javax.swing.JComponent buildPerformanceArea();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
protected void initializePostGUI();
protected void reset();
protected void updateDisplay();
private String[] determineSetSizeChoices(int, int);
private void updateCacheSetSizeSelector();
private CacheSimulator$AbstractCache createNewCache();
private void resetCounts();
private void updateMemoryAccessCountDisplay();
private void updateCacheHitCountDisplay();
private void updateCacheMissCountDisplay();
private void updateCacheHitRateDisplay();
private void updateCacheSizeDisplay();
private javax.swing.JPanel getPanelWithBorderLayout();
private void resetLogDisplay();
private void writeLog(String);
static void
}
AbstractToolAndApplication$1
package rars.tools;
synchronized class AbstractToolAndApplication$1 extends java.awt.event.WindowAdapter {
void AbstractToolAndApplication$1(AbstractToolAndApplication);
public void windowClosing(java.awt.event.WindowEvent);
}
BitmapDisplay$2
package rars.tools;
synchronized class BitmapDisplay$2 implements java.awt.event.ActionListener {
void BitmapDisplay$2(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
CacheSimulator$CacheAccessResult
package rars.tools;
synchronized class CacheSimulator$CacheAccessResult {
private final boolean hitOrMiss;
private final int blockNumber;
public void CacheSimulator$CacheAccessResult(CacheSimulator, boolean, int);
public boolean isHit();
public int getBlock();
}
KeyboardAndDisplaySimulator$DisplayResizeAdapter
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$DisplayResizeAdapter extends java.awt.event.ComponentAdapter {
private void KeyboardAndDisplaySimulator$DisplayResizeAdapter(KeyboardAndDisplaySimulator);
public void componentResized(java.awt.event.ComponentEvent);
}
AbstractToolAndApplication$3
package rars.tools;
synchronized class AbstractToolAndApplication$3 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$3(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
CacheSimulator$AbstractCache
package rars.tools;
abstract synchronized class CacheSimulator$AbstractCache {
private final int numberOfBlocks;
private final int blockSizeInWords;
private final int setSizeInBlocks;
private final int numberOfSets;
protected CacheSimulator$CacheBlock[] blocks;
protected void CacheSimulator$AbstractCache(CacheSimulator, int, int, int);
public int getNumberOfBlocks();
public int getNumberOfSets();
public int getSetSizeInBlocks();
public int getBlockSizeInWords();
public int getCacheSizeInWords();
public int getCacheSizeInBytes();
public int getSetNumber(int);
public int getTag(int);
public int getFirstBlockToSearch(int);
public int getLastBlockToSearch(int);
public void reset();
public abstract CacheSimulator$CacheAccessResult isItAHitThenReadOnMiss(int);
}
CacheSimulator$Animation
package rars.tools;
synchronized class CacheSimulator$Animation {
private javax.swing.Box animation;
private javax.swing.JTextField[] blocks;
public final java.awt.Color hitColor;
public final java.awt.Color missColor;
public final java.awt.Color defaultColor;
public void CacheSimulator$Animation(CacheSimulator);
private javax.swing.Box getAnimationBox();
public int getNumberOfBlocks();
public void showHit(int);
public void showMiss(int);
public void reset();
private void fillAnimationBoxWithCacheBlocks();
}
CacheSimulator$1
package rars.tools;
synchronized class CacheSimulator$1 implements java.awt.event.ItemListener {
void CacheSimulator$1(CacheSimulator);
public void itemStateChanged(java.awt.event.ItemEvent);
}
CacheSimulator$AnyCache
package rars.tools;
synchronized class CacheSimulator$AnyCache extends CacheSimulator$AbstractCache {
private final int SET_FULL;
private final int HIT;
private final int MISS;
public void CacheSimulator$AnyCache(CacheSimulator, int, int, int);
public CacheSimulator$CacheAccessResult isItAHitThenReadOnMiss(int);
private int selectBlockToReplace(int, int);
}
FloatRepresentation$HexToBinaryGraphicPanel
package rars.tools;
synchronized class FloatRepresentation$HexToBinaryGraphicPanel extends javax.swing.JPanel {
void FloatRepresentation$HexToBinaryGraphicPanel(FloatRepresentation);
public void paintComponent(java.awt.Graphics);
}
KeyboardAndDisplaySimulator$FontChanger
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FontChanger implements java.awt.event.ActionListener {
private void KeyboardAndDisplaySimulator$FontChanger(KeyboardAndDisplaySimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$4
package rars.tools;
synchronized class AbstractToolAndApplication$4 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$4(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay
package rars.tools;
public synchronized class BitmapDisplay extends AbstractToolAndApplication {
private static String version;
private static String heading;
private javax.swing.JComboBox visualizationUnitPixelWidthSelector;
private javax.swing.JComboBox visualizationUnitPixelHeightSelector;
private javax.swing.JComboBox visualizationPixelWidthSelector;
private javax.swing.JComboBox visualizationPixelHeightSelector;
private javax.swing.JComboBox displayBaseAddressSelector;
private java.awt.Graphics drawingArea;
private javax.swing.JPanel canvas;
private javax.swing.JPanel results;
private javax.swing.border.EmptyBorder emptyBorder;
private java.awt.Font countFonts;
private java.awt.Color backgroundColor;
private static final String[] visualizationUnitPixelWidthChoices;
private static final int defaultVisualizationUnitPixelWidthIndex = 0;
private static final String[] visualizationUnitPixelHeightChoices;
private static final int defaultVisualizationUnitPixelHeightIndex = 0;
private static final String[] displayAreaPixelWidthChoices;
private static final int defaultDisplayWidthIndex = 3;
private static final String[] displayAreaPixelHeightChoices;
private static final int defaultDisplayHeightIndex = 2;
private int unitPixelWidth;
private int unitPixelHeight;
private int displayAreaWidthInPixels;
private int displayAreaHeightInPixels;
private String[] displayBaseAddressChoices;
private int[] displayBaseAddresses;
private int defaultBaseAddressIndex;
private int baseAddress;
private BitmapDisplay$Grid theGrid;
public void BitmapDisplay(String, String);
public void BitmapDisplay();
public static void main(String[]);
public String getName();
protected void addAsObserver();
protected javax.swing.JComponent buildMainDisplayArea();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
protected void initializePostGUI();
protected void reset();
protected void updateDisplay();
protected javax.swing.JComponent getHelpComponent();
private javax.swing.JComponent buildOrganizationArea();
private javax.swing.JComponent buildVisualizationArea();
private void initializeDisplayBaseChoices();
private void updateBaseAddress();
private java.awt.Dimension getDisplayAreaDimension();
private void resetCounts();
private int getIntComboBoxSelection(javax.swing.JComboBox);
private javax.swing.JPanel getPanelWithBorderLayout();
private BitmapDisplay$Grid createNewGrid();
private void updateColorForAddress(rars.riscv.hardware.MemoryAccessNotice);
static void
}
TimerTool$2
package rars.tools;
synchronized class TimerTool$2 implements java.awt.event.ActionListener {
void TimerTool$2(TimerTool);
public void actionPerformed(java.awt.event.ActionEvent);
}
InstructionMemoryDump$1
package rars.tools;
synchronized class InstructionMemoryDump$1 implements java.awt.event.ActionListener {
void InstructionMemoryDump$1(InstructionMemoryDump);
public void actionPerformed(java.awt.event.ActionEvent);
}
CacheSimulator$CacheBlock
package rars.tools;
synchronized class CacheSimulator$CacheBlock {
private boolean valid;
private int tag;
private int sizeInWords;
private int mostRecentAccessTime;
public void CacheSimulator$CacheBlock(CacheSimulator, int);
}
CacheSimulator$4
package rars.tools;
synchronized class CacheSimulator$4 implements java.awt.event.ActionListener {
void CacheSimulator$4(CacheSimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
FloatRepresentation$BinaryFractionDisplayTextField
package rars.tools;
synchronized class FloatRepresentation$BinaryFractionDisplayTextField extends javax.swing.JTextField {
public void FloatRepresentation$BinaryFractionDisplayTextField(FloatRepresentation, String, int);
public void paintComponent(java.awt.Graphics);
}
Tool
package rars.tools;
public abstract interface Tool {
public abstract String getName();
public abstract void action();
}
KeyboardAndDisplaySimulator$TransmitterDelayTechnique
package rars.tools;
abstract interface KeyboardAndDisplaySimulator$TransmitterDelayTechnique {
public abstract int generateDelay(double);
}
BitmapDisplay$5
package rars.tools;
synchronized class BitmapDisplay$5 implements java.awt.event.ActionListener {
void BitmapDisplay$5(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$6
package rars.tools;
synchronized class AbstractToolAndApplication$6 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$6(AbstractToolAndApplication, AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay$1
package rars.tools;
synchronized class BitmapDisplay$1 implements java.awt.event.ActionListener {
void BitmapDisplay$1(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$2
package rars.tools;
synchronized class AbstractToolAndApplication$2 extends java.awt.event.WindowAdapter {
void AbstractToolAndApplication$2(AbstractToolAndApplication);
public void windowClosing(java.awt.event.WindowEvent);
}
InstructionStatistics
package rars.tools;
public synchronized class InstructionStatistics extends AbstractToolAndApplication {
private static String NAME;
private static String VERSION;
private static String HEADING;
private static final int MAX_CATEGORY = 5;
private static final int CATEGORY_ALU = 0;
private static final int CATEGORY_JUMP = 1;
private static final int CATEGORY_BRANCH = 2;
private static final int CATEGORY_MEM = 3;
private static final int CATEGORY_OTHER = 4;
private javax.swing.JTextField m_tfTotalCounter;
private javax.swing.JTextField[] m_tfCounters;
private javax.swing.JProgressBar[] m_pbCounters;
private int m_totalCounter;
private int[] m_counters;
private String[] m_categoryLabels;
protected int lastAddress;
public void InstructionStatistics(String, String);
public void InstructionStatistics();
public String getName();
protected javax.swing.JComponent buildMainDisplayArea();
protected void addAsObserver();
protected int getInstructionCategory(rars.ProgramStatement);
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
protected void reset();
protected void updateDisplay();
static void
}
FloatRepresentation$DecimalDisplayKeystokeListenter
package rars.tools;
synchronized class FloatRepresentation$DecimalDisplayKeystokeListenter extends java.awt.event.KeyAdapter {
private void FloatRepresentation$DecimalDisplayKeystokeListenter(FloatRepresentation);
public void keyTyped(java.awt.event.KeyEvent);
public void keyPressed(java.awt.event.KeyEvent);
private boolean isDecimalFloatDigit(char);
}
DigitalLabSim$SevenSegmentPanel
package rars.tools;
public synchronized class DigitalLabSim$SevenSegmentPanel extends javax.swing.JPanel {
public DigitalLabSim$SevenSegmentDisplay[] display;
public void DigitalLabSim$SevenSegmentPanel(DigitalLabSim);
public void modifyDisplay(int, char);
public void resetSevenSegment();
}
KeyboardAndDisplaySimulator$1
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$1 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$1(KeyboardAndDisplaySimulator, String);
public void actionPerformed(java.awt.event.ActionEvent);
}
FloatRepresentation$BinaryDisplayKeystrokeListener
package rars.tools;
synchronized class FloatRepresentation$BinaryDisplayKeystrokeListener extends java.awt.event.KeyAdapter {
private int bitLength;
public void FloatRepresentation$BinaryDisplayKeystrokeListener(FloatRepresentation, int);
public void keyTyped(java.awt.event.KeyEvent);
public void keyPressed(java.awt.event.KeyEvent);
private boolean isBinaryDigit(char);
}
KeyboardAndDisplaySimulator$NormallyDistributedDelay
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$NormallyDistributedDelay implements KeyboardAndDisplaySimulator$TransmitterDelayTechnique {
java.util.Random randn;
public void KeyboardAndDisplaySimulator$NormallyDistributedDelay(KeyboardAndDisplaySimulator);
public String toString();
public int generateDelay(double);
}
KeyboardAndDisplaySimulator$DelayLengthPanel$DelayLengthListener
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$DelayLengthPanel$DelayLengthListener implements javax.swing.event.ChangeListener {
private void KeyboardAndDisplaySimulator$DelayLengthPanel$DelayLengthListener(KeyboardAndDisplaySimulator$DelayLengthPanel);
public void stateChanged(javax.swing.event.ChangeEvent);
}
CacheSimulator$2
package rars.tools;
synchronized class CacheSimulator$2 implements java.awt.event.ActionListener {
void CacheSimulator$2(CacheSimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$3
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$3 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$3(KeyboardAndDisplaySimulator);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$FontSettingDialog
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FontSettingDialog extends rars.venus.util.AbstractFontSettingDialog {
private boolean resultOK;
public void KeyboardAndDisplaySimulator$FontSettingDialog(KeyboardAndDisplaySimulator, java.awt.Frame, String, java.awt.Font);
private java.awt.Font showDialog();
protected void closeDialog();
private void performCancel();
protected java.awt.Component buildControlPanel();
protected void apply(java.awt.Font);
}
KeyboardAndDisplaySimulator$UniformlyDistributedDelay
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$UniformlyDistributedDelay implements KeyboardAndDisplaySimulator$TransmitterDelayTechnique {
java.util.Random randu;
public void KeyboardAndDisplaySimulator$UniformlyDistributedDelay(KeyboardAndDisplaySimulator);
public String toString();
public int generateDelay(double);
}
BitmapDisplay$3
package rars.tools;
synchronized class BitmapDisplay$3 implements java.awt.event.ActionListener {
void BitmapDisplay$3(BitmapDisplay);
public void actionPerformed(java.awt.event.ActionEvent);
}
MemoryReferenceVisualization$GraphicsPanel
package rars.tools;
synchronized class MemoryReferenceVisualization$GraphicsPanel extends javax.swing.JPanel {
private void MemoryReferenceVisualization$GraphicsPanel(MemoryReferenceVisualization);
public void paint(java.awt.Graphics);
private void paintHashMarks(java.awt.Graphics, MemoryReferenceVisualization$Grid);
private void paintGrid(java.awt.Graphics, MemoryReferenceVisualization$Grid);
private java.awt.Color getContrastingColor(java.awt.Color);
}
AbstractToolAndApplication$CreateAssembleRunProgram$1
package rars.tools;
synchronized class AbstractToolAndApplication$CreateAssembleRunProgram$1 implements java.util.Observer {
void AbstractToolAndApplication$CreateAssembleRunProgram$1(AbstractToolAndApplication$CreateAssembleRunProgram, String);
public void update(java.util.Observable, Object);
}
MemoryReferenceVisualization$3
package rars.tools;
synchronized class MemoryReferenceVisualization$3 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$3(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay$Grid
package rars.tools;
synchronized class BitmapDisplay$Grid {
java.awt.Color[][] grid;
int rows;
int columns;
private void BitmapDisplay$Grid(BitmapDisplay, int, int);
private int getRows();
private int getColumns();
private java.awt.Color getElement(int, int);
private java.awt.Color getElementFast(int, int);
private void setElement(int, int, int);
private void setElement(int, int, java.awt.Color);
private void reset();
}
KeyboardAndDisplaySimulator$FontSettingDialog$3
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FontSettingDialog$3 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$FontSettingDialog$3(KeyboardAndDisplaySimulator$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
BHTSimGUI$1
package rars.tools;
synchronized class BHTSimGUI$1 extends javax.swing.table.DefaultTableCellRenderer {
private java.text.DecimalFormat formatter;
void BHTSimGUI$1(BHTSimGUI);
public void setValue(Object);
}
KeyboardAndDisplaySimulator$FontSettingDialog$1
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FontSettingDialog$1 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$FontSettingDialog$1(KeyboardAndDisplaySimulator$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
MemoryReferenceVisualization$1
package rars.tools;
synchronized class MemoryReferenceVisualization$1 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$1(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
BHTSimGUI
package rars.tools;
public synchronized class BHTSimGUI extends javax.swing.JPanel {
private javax.swing.JTextField m_tfInstruction;
private javax.swing.JTextField m_tfAddress;
private javax.swing.JTextField m_tfIndex;
private javax.swing.JComboBox m_cbBHTentries;
private javax.swing.JComboBox m_cbBHThistory;
private javax.swing.JComboBox m_cbBHTinitVal;
private javax.swing.JTable m_tabBHT;
private javax.swing.JTextArea m_taLog;
public static final java.awt.Color COLOR_PREPREDICTION;
public static final java.awt.Color COLOR_PREDICTION_CORRECT;
public static final java.awt.Color COLOR_PREDICTION_INCORRECT;
public static final String BHT_TAKE_BRANCH = TAKE;
public static final String BHT_DO_NOT_TAKE_BRANCH = NOT TAKE;
public void BHTSimGUI();
private javax.swing.JTable createAndInitTable();
private javax.swing.JPanel buildInfoPanel();
private javax.swing.JPanel buildConfigPanel();
private javax.swing.JPanel buildLogPanel();
public javax.swing.JComboBox getCbBHTentries();
public javax.swing.JComboBox getCbBHThistory();
public javax.swing.JComboBox getCbBHTinitVal();
public javax.swing.JTable getTabBHT();
public javax.swing.JTextArea getTaLog();
public javax.swing.JTextField getTfInstruction();
public javax.swing.JTextField getTfAddress();
public javax.swing.JTextField getTfIndex();
static void
}
AbstractToolAndApplication$ConnectButton
package rars.tools;
public synchronized class AbstractToolAndApplication$ConnectButton extends javax.swing.JButton {
private static final String connectText = Connect to Program;
private static final String disconnectText = Disconnect from Program;
public void AbstractToolAndApplication$ConnectButton(AbstractToolAndApplication);
public void connect();
public void disconnect();
public boolean isConnected();
}
InstructionCounter
package rars.tools;
public synchronized class InstructionCounter extends AbstractToolAndApplication {
private static String name;
private static String version;
private static String heading;
private int counter;
private javax.swing.JTextField counterField;
private int counterR;
private javax.swing.JTextField counterRField;
private javax.swing.JProgressBar progressbarR;
private int counterR4;
private javax.swing.JTextField counterR4Field;
private javax.swing.JProgressBar progressbarR4;
private int counterI;
private javax.swing.JTextField counterIField;
private javax.swing.JProgressBar progressbarI;
private int counterS;
private javax.swing.JTextField counterSField;
private javax.swing.JProgressBar progressbarS;
private int counterB;
private javax.swing.JTextField counterBField;
private javax.swing.JProgressBar progressbarB;
private int counterU;
private javax.swing.JTextField counterUField;
private javax.swing.JProgressBar progressbarU;
private int counterJ;
private javax.swing.JTextField counterJField;
private javax.swing.JProgressBar progressbarJ;
private int lastAddress;
public void InstructionCounter(String, String);
public void InstructionCounter();
public String getName();
protected javax.swing.JComponent buildMainDisplayArea();
protected void addAsObserver();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
protected void reset();
protected void updateDisplay();
static void
}
KeyboardAndDisplaySimulator$KeyboardKeyListener
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$KeyboardKeyListener implements java.awt.event.KeyListener {
private void KeyboardAndDisplaySimulator$KeyboardKeyListener(KeyboardAndDisplaySimulator);
public void keyTyped(java.awt.event.KeyEvent);
public void keyPressed(java.awt.event.KeyEvent);
public void keyReleased(java.awt.event.KeyEvent);
}
DigitalLabSim
package rars.tools;
public synchronized class DigitalLabSim extends AbstractToolAndApplication {
private static String heading;
private static String version;
private static final int IN_ADRESS_DISPLAY_1;
private static final int IN_ADRESS_DISPLAY_2;
private static final int IN_ADRESS_HEXA_KEYBOARD;
private static final int IN_ADRESS_COUNTER;
private static final int OUT_ADRESS_HEXA_KEYBOARD;
public static final int EXTERNAL_INTERRUPT_TIMER = 256;
public static final int EXTERNAL_INTERRUPT_HEXA_KEYBOARD = 512;
private static javax.swing.JPanel panelTools;
private DigitalLabSim$SevenSegmentPanel sevenSegPanel;
private static int KeyBoardValueButtonClick;
private DigitalLabSim$HexaKeyboard hexaKeyPanel;
private static boolean KeyboardInterruptOnOff;
private static int CounterValueMax;
private static int CounterValue;
private static boolean CounterInterruptOnOff;
private static DigitalLabSim$OneSecondCounter SecondCounter;
public void DigitalLabSim(String, String);
public void DigitalLabSim();
public static void main(String[]);
public String getName();
protected void addAsObserver();
public void update(java.util.Observable, Object);
protected void reset();
protected javax.swing.JComponent buildMainDisplayArea();
private synchronized void updateMMIOControlAndData(int, int);
protected javax.swing.JComponent getHelpComponent();
public void updateSevenSegment(int, char);
public void updateHexaKeyboard(char);
public void updateOneSecondCounter(char);
static void
}
MemoryReferenceVisualization$ColorChooserControls$ColorChooserListener
package rars.tools;
synchronized class MemoryReferenceVisualization$ColorChooserControls$ColorChooserListener implements javax.swing.event.ChangeListener {
private void MemoryReferenceVisualization$ColorChooserControls$ColorChooserListener(MemoryReferenceVisualization$ColorChooserControls);
public void stateChanged(javax.swing.event.ChangeEvent);
}
BHTSimulator
package rars.tools;
public synchronized class BHTSimulator extends AbstractToolAndApplication implements java.awt.event.ActionListener {
public static final int BHT_DEFAULT_SIZE = 16;
public static final int BHT_DEFAULT_HISTORY = 1;
public static final boolean BHT_DEFAULT_INITVAL = 0;
public static final String BHT_NAME = BHT Simulator;
public static final String BHT_VERSION = Version 1.0 (Ingo Kofler);
public static final String BHT_HEADING = Branch History Table Simulator;
private BHTSimGUI m_gui;
private BHTableModel m_bhtModel;
private int m_pendingBranchInstAddress;
private boolean m_lastBranchTaken;
public void BHTSimulator();
protected void addAsObserver();
protected javax.swing.JComponent buildMainDisplayArea();
public String getName();
protected void reset();
public void actionPerformed(java.awt.event.ActionEvent);
protected void resetSimulator();
protected void handlePreBranchInst(rars.ProgramStatement);
protected void handleExecBranchInst(int, boolean);
protected static int extractBranchAddress(rars.ProgramStatement);
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
static void
}
MemoryReferenceVisualization$5
package rars.tools;
synchronized class MemoryReferenceVisualization$5 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$5(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
BHTEntry
package rars.tools;
public synchronized class BHTEntry {
private boolean[] m_history;
private boolean m_prediction;
private int m_incorrect;
private int m_correct;
public void BHTEntry(int, boolean);
public boolean getPrediction();
public void updatePrediction(boolean);
public int getStatsPredIncorrect();
public int getStatsPredCorrect();
public double getStatsPredPrecision();
public String getHistoryAsStr();
public String getPredictionAsStr();
}
MemoryReferenceVisualization$7
package rars.tools;
synchronized class MemoryReferenceVisualization$7 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$7(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
BitmapDisplay$GraphicsPanel
package rars.tools;
synchronized class BitmapDisplay$GraphicsPanel extends javax.swing.JPanel {
private void BitmapDisplay$GraphicsPanel(BitmapDisplay);
public void paint(java.awt.Graphics);
private void paintGrid(java.awt.Graphics, BitmapDisplay$Grid);
}
DigitalLabSim$SevenSegmentDisplay
package rars.tools;
public synchronized class DigitalLabSim$SevenSegmentDisplay extends javax.swing.JComponent {
public char aff;
public void DigitalLabSim$SevenSegmentDisplay(DigitalLabSim, char);
public void modifyDisplay(char);
public void SwitchSegment(java.awt.Graphics, char);
public void paint(java.awt.Graphics);
}
AbstractToolAndApplication$8
package rars.tools;
synchronized class AbstractToolAndApplication$8 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$8(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$1$1
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$1$1 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$1$1(KeyboardAndDisplaySimulator$1, javax.swing.JDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
DigitalLabSim$1
package rars.tools;
synchronized class DigitalLabSim$1 implements java.awt.event.ActionListener {
void DigitalLabSim$1(DigitalLabSim);
public void actionPerformed(java.awt.event.ActionEvent);
}
MemoryReferenceVisualization$Grid
package rars.tools;
synchronized class MemoryReferenceVisualization$Grid {
int[][] grid;
int rows;
int columns;
private void MemoryReferenceVisualization$Grid(MemoryReferenceVisualization, int, int);
private int getRows();
private int getColumns();
private int getElement(int, int);
private int getElementFast(int, int);
private int incrementElement(int, int);
private void reset();
}
DigitalLabSim$HexaKeyboard
package rars.tools;
public synchronized class DigitalLabSim$HexaKeyboard extends javax.swing.JPanel {
public javax.swing.JButton[] button;
public void DigitalLabSim$HexaKeyboard(DigitalLabSim);
public void resetHexaKeyboard();
}
DigitalLabSim$HexaKeyboard$EcouteurClick
package rars.tools;
public synchronized class DigitalLabSim$HexaKeyboard$EcouteurClick implements java.awt.event.MouseListener {
private int buttonValue;
public void DigitalLabSim$HexaKeyboard$EcouteurClick(DigitalLabSim$HexaKeyboard, int);
public void mouseEntered(java.awt.event.MouseEvent);
public void mouseExited(java.awt.event.MouseEvent);
public void mousePressed(java.awt.event.MouseEvent);
public void mouseReleased(java.awt.event.MouseEvent);
public void mouseClicked(java.awt.event.MouseEvent);
}
DigitalLabSim$OneSecondCounter
package rars.tools;
public synchronized class DigitalLabSim$OneSecondCounter {
public void DigitalLabSim$OneSecondCounter(DigitalLabSim);
public void resetOneSecondCounter();
}
AbstractToolAndApplication$MessageField$MessageWriter
package rars.tools;
synchronized class AbstractToolAndApplication$MessageField$MessageWriter implements Runnable {
private String text;
private boolean terminatingMessage;
public void AbstractToolAndApplication$MessageField$MessageWriter(AbstractToolAndApplication$MessageField, String, boolean);
public void run();
}
AbstractToolAndApplication$CreateAssembleRunProgram
package rars.tools;
synchronized class AbstractToolAndApplication$CreateAssembleRunProgram implements Runnable {
private void AbstractToolAndApplication$CreateAssembleRunProgram(AbstractToolAndApplication);
public void run();
}
TimerTool$TimePanel
package rars.tools;
public synchronized class TimerTool$TimePanel extends javax.swing.JPanel {
javax.swing.JLabel currentTime;
public void TimerTool$TimePanel(TimerTool);
public void updateTime();
}
FloatRepresentation$BinaryToDecimalFormulaGraphic
package rars.tools;
synchronized class FloatRepresentation$BinaryToDecimalFormulaGraphic extends javax.swing.JPanel {
final String subtractLabelTrailer;
final int arrowHeadOffset;
final int lowerY;
final int upperY;
int centerX;
int exponentCenterX;
int subtractLabelWidth;
int subtractLabelHeight;
int centerY;
int upperYArrowHead;
int currentExponent;
void FloatRepresentation$BinaryToDecimalFormulaGraphic(FloatRepresentation);
public void paintComponent(java.awt.Graphics);
public void drawSubtractLabel(int);
private void drawSubtractLabel(java.awt.Graphics, String);
private String buildSubtractLabel(int);
}
AbstractToolAndApplication
package rars.tools;
public abstract synchronized class AbstractToolAndApplication extends javax.swing.JFrame implements Tool, java.util.Observer {
protected boolean isBeingUsedAsATool;
private javax.swing.JDialog dialog;
protected java.awt.Window theWindow;
private javax.swing.JLabel headingLabel;
private String title;
private String heading;
private javax.swing.border.EmptyBorder emptyBorder;
private java.awt.Color backgroundColor;
private int lowMemoryAddress;
private int highMemoryAddress;
private volatile boolean observing;
private java.io.File mostRecentlyOpenedFile;
private Runnable interactiveGUIUpdater;
private AbstractToolAndApplication$MessageField operationStatusMessages;
private javax.swing.JButton openFileButton;
private javax.swing.JButton assembleRunButton;
private javax.swing.JButton stopButton;
private boolean multiFileAssemble;
protected AbstractToolAndApplication$ConnectButton connectButton;
protected void AbstractToolAndApplication(String, String);
public abstract String getName();
protected abstract javax.swing.JComponent buildMainDisplayArea();
public void go();
public void action();
protected void initializePreGUI();
protected void initializePostGUI();
protected void reset();
protected javax.swing.JComponent buildHeadingArea();
protected javax.swing.JComponent buildButtonAreaForTool();
protected javax.swing.JComponent buildButtonAreaStandAlone();
public void update(java.util.Observable, Object);
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void performSpecialClosingDuties();
protected void addAsObserver();
protected void addAsObserver(int, int);
protected void addAsObserver(rars.riscv.hardware.Register);
protected void deleteAsObserver();
protected void deleteAsObserver(rars.riscv.hardware.Register);
protected boolean isObserving();
protected void updateDisplay();
protected javax.swing.JComponent getHelpComponent();
private void performToolClosingDuties();
private void performAppClosingDuties();
}
BHTableModel
package rars.tools;
public synchronized class BHTableModel extends javax.swing.table.AbstractTableModel {
private java.util.Vector m_entries;
private int m_entryCnt;
private String[] m_columnNames;
private Class[] m_columnClasses;
public void BHTableModel(int, int, boolean);
public String getColumnName(int);
public Class getColumnClass(int);
public int getColumnCount();
public int getRowCount();
public Object getValueAt(int, int);
public void initBHT(int, int, boolean);
public int getIdxForAddress(int);
public boolean getPredictionAtIdx(int);
public void updatePredictionAtIdx(int, boolean);
}
MemoryReferenceVisualization$2
package rars.tools;
synchronized class MemoryReferenceVisualization$2 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$2(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$FontSettingDialog$2
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FontSettingDialog$2 implements java.awt.event.ActionListener {
void KeyboardAndDisplaySimulator$FontSettingDialog$2(KeyboardAndDisplaySimulator$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeyboardAndDisplaySimulator$DelayLengthPanel
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$DelayLengthPanel extends javax.swing.JPanel {
private static final int DELAY_INDEX_MIN = 0;
private static final int DELAY_INDEX_MAX = 40;
private static final int DELAY_INDEX_INIT = 4;
private double[] delayTable;
private javax.swing.JLabel sliderLabel;
private volatile int delayLengthIndex;
public void KeyboardAndDisplaySimulator$DelayLengthPanel(KeyboardAndDisplaySimulator);
public double getDelayLength();
private String setLabel(int);
}
FloatRepresentation$FlavorsOfFloat
package rars.tools;
synchronized class FloatRepresentation$FlavorsOfFloat {
String hexString;
String binaryString;
String decimalString;
String expansionString;
int intValue;
private void FloatRepresentation$FlavorsOfFloat(FloatRepresentation);
public FloatRepresentation$FlavorsOfFloat buildOneFromHexString(String);
private FloatRepresentation$FlavorsOfFloat buildOneFromBinaryString();
private FloatRepresentation$FlavorsOfFloat buildOneFromDecimalString(String);
private FloatRepresentation$FlavorsOfFloat buildOneFromInt(int);
public String buildExpansionFromBinaryString(String);
private String getFullBinaryStringFromDisplays();
private String addLeadingZeroes(String, int);
}
MemoryReferenceVisualization$ColorChooserControls
package rars.tools;
synchronized class MemoryReferenceVisualization$ColorChooserControls {
private javax.swing.JLabel sliderLabel;
private javax.swing.JSlider colorRangeSlider;
private javax.swing.JButton currentColorButton;
private javax.swing.JPanel colorChooserRow;
private javax.swing.JPanel countDisplayRow;
private volatile int counterIndex;
private void MemoryReferenceVisualization$ColorChooserControls(MemoryReferenceVisualization);
private String setLabel(int);
}
MemoryReferenceVisualization$6
package rars.tools;
synchronized class MemoryReferenceVisualization$6 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$6(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractToolAndApplication$9
package rars.tools;
synchronized class AbstractToolAndApplication$9 implements java.awt.event.ActionListener {
void AbstractToolAndApplication$9(AbstractToolAndApplication);
public void actionPerformed(java.awt.event.ActionEvent);
}
MemoryReferenceVisualization$CounterColorScale
package rars.tools;
synchronized class MemoryReferenceVisualization$CounterColorScale {
MemoryReferenceVisualization$CounterColor[] counterColors;
void MemoryReferenceVisualization$CounterColorScale(MemoryReferenceVisualization, MemoryReferenceVisualization$CounterColor[]);
private java.awt.Color getColor(int);
private int getHighEndOfRange(int);
private void insertOrReplace(MemoryReferenceVisualization$CounterColor);
}
TimerTool$TimeCmpDaemon
package rars.tools;
public synchronized class TimerTool$TimeCmpDaemon implements java.util.Observer {
public boolean postInterrupt;
public long value;
public void TimerTool$TimeCmpDaemon(TimerTool);
public void addAsObserver();
public void update(java.util.Observable, Object);
}
KeyboardAndDisplaySimulator$FixedLengthDelay
package rars.tools;
synchronized class KeyboardAndDisplaySimulator$FixedLengthDelay implements KeyboardAndDisplaySimulator$TransmitterDelayTechnique {
private void KeyboardAndDisplaySimulator$FixedLengthDelay(KeyboardAndDisplaySimulator);
public String toString();
public int generateDelay(double);
}
MemoryReferenceVisualization
package rars.tools;
public synchronized class MemoryReferenceVisualization extends AbstractToolAndApplication {
private static String version;
private static String heading;
private javax.swing.JComboBox wordsPerUnitSelector;
private javax.swing.JComboBox visualizationUnitPixelWidthSelector;
private javax.swing.JComboBox visualizationUnitPixelHeightSelector;
private javax.swing.JComboBox visualizationPixelWidthSelector;
private javax.swing.JComboBox visualizationPixelHeightSelector;
private javax.swing.JComboBox displayBaseAddressSelector;
private javax.swing.JCheckBox drawHashMarksSelector;
private java.awt.Graphics drawingArea;
private javax.swing.JPanel canvas;
private javax.swing.JPanel results;
private javax.swing.border.EmptyBorder emptyBorder;
private java.awt.Font countFonts;
private java.awt.Color backgroundColor;
private static final String[] wordsPerUnitChoices;
private static final int defaultWordsPerUnitIndex = 0;
private static final String[] visualizationUnitPixelWidthChoices;
private static final int defaultVisualizationUnitPixelWidthIndex = 4;
private static final String[] visualizationUnitPixelHeightChoices;
private static final int defaultVisualizationUnitPixelHeightIndex = 4;
private static final String[] displayAreaPixelWidthChoices;
private static final int defaultDisplayWidthIndex = 2;
private static final String[] displayAreaPixelHeightChoices;
private static final int defaultDisplayHeightIndex = 2;
private static final boolean defaultDrawHashMarks = 1;
private int unitPixelWidth;
private int unitPixelHeight;
private int wordsPerUnit;
private int visualizationAreaWidthInPixels;
private int visualizationAreaHeightInPixels;
private MemoryReferenceVisualization$CounterColor[] defaultCounterColors;
private int[] countTable;
private static final int COUNT_INDEX_INIT = 10;
private String[] displayBaseAddressChoices;
private int[] displayBaseAddresses;
private int defaultBaseAddressIndex;
private int baseAddress;
private MemoryReferenceVisualization$Grid theGrid;
private MemoryReferenceVisualization$CounterColorScale counterColorScale;
public void MemoryReferenceVisualization(String, String);
public void MemoryReferenceVisualization();
public static void main(String[]);
public String getName();
protected void addAsObserver();
protected javax.swing.JComponent buildMainDisplayArea();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
protected void initializePostGUI();
protected void reset();
protected void updateDisplay();
protected javax.swing.JComponent getHelpComponent();
private javax.swing.JComponent buildOrganizationArea();
private javax.swing.JComponent buildVisualizationArea();
private void initializeDisplayBaseChoices();
private void updateBaseAddress();
private java.awt.Dimension getDisplayAreaDimension();
private void resetCounts();
private int getIntComboBoxSelection(javax.swing.JComboBox);
private javax.swing.JPanel getPanelWithBorderLayout();
private MemoryReferenceVisualization$Grid createNewGrid();
private void incrementReferenceCountForAddress(int);
static void
}
MemoryReferenceVisualization$CounterColor
package rars.tools;
synchronized class MemoryReferenceVisualization$CounterColor implements Comparable {
private int colorRangeStart;
private java.awt.Color associatedColor;
public void MemoryReferenceVisualization$CounterColor(MemoryReferenceVisualization, int, java.awt.Color);
public int compareTo(MemoryReferenceVisualization$CounterColor);
}
MemoryReferenceVisualization$4
package rars.tools;
synchronized class MemoryReferenceVisualization$4 implements java.awt.event.ActionListener {
void MemoryReferenceVisualization$4(MemoryReferenceVisualization);
public void actionPerformed(java.awt.event.ActionEvent);
}
FloatRepresentation$HexDisplayKeystrokeListener
package rars.tools;
synchronized class FloatRepresentation$HexDisplayKeystrokeListener extends java.awt.event.KeyAdapter {
private int digitLength;
public void FloatRepresentation$HexDisplayKeystrokeListener(FloatRepresentation, int);
public void keyTyped(java.awt.event.KeyEvent);
public void keyPressed(java.awt.event.KeyEvent);
private boolean isHexDigit(char);
}
InstructionMemoryDump
package rars.tools;
public synchronized class InstructionMemoryDump extends AbstractToolAndApplication {
private static String name;
private static String version;
private static String heading;
private int lastAddress;
private StringBuffer log;
private javax.swing.JTextField dumpLogFilename;
private int lowDataSegmentAddress;
private int highDataSegmentAddress;
public void InstructionMemoryDump(String, String);
public void InstructionMemoryDump();
protected javax.swing.JComponent buildMainDisplayArea();
public String getName();
protected void addAsObserver();
protected void processRISCVUpdate(java.util.Observable, rars.riscv.hardware.AccessNotice);
protected void initializePreGUI();
public void dumpLog();
protected void reset();
protected void updateDisplay();
static void
}
FloatRepresentation
package rars.tools;
public synchronized class FloatRepresentation extends AbstractToolAndApplication {
private static String version;
private static String heading;
private static final String title = Floating Point Representation, ;
private static final String defaultHex = 00000000;
private static final String defaultDecimal = 0.0;
private static final String defaultBinarySign = 0;
private static final String defaultBinaryExponent = 00000000;
private static final String defaultBinaryFraction = 00000000000000000000000;
private static final int maxLengthHex = 8;
private static final int maxLengthBinarySign = 1;
private static final int maxLengthBinaryExponent = 8;
private static final int maxLengthBinaryFraction = 23;
private static final int maxLengthBinaryTotal = 32;
private static final int maxLengthDecimal = 20;
private static final String denormalizedLabel =significand (denormalized – no ‘hidden bit’);
private static final String normalizedLabel =significand (‘hidden bit’ underlined) ;
private static final java.awt.Font instructionsFont;
private static final java.awt.Font hexDisplayFont;
private static final java.awt.Font binaryDisplayFont;
private static final java.awt.Font decimalDisplayFont;
private static final java.awt.Color hexDisplayColor;
private static final java.awt.Color binaryDisplayColor;
private static final java.awt.Color decimalDisplayColor;
private static final String expansionFontTag = ;
private static final String instructionFontTag = ;
private static final int exponentBias = 127;
private rars.riscv.hardware.Register attachedRegister;
private rars.riscv.hardware.Register[] fpRegisters;
private javax.swing.JPanel binarySignDecoratedDisplay;
private javax.swing.JPanel binaryExponentDecoratedDisplay;
private javax.swing.JPanel binaryFractionDecoratedDisplay;
private javax.swing.JTextField hexDisplay;
private javax.swing.JTextField decimalDisplay;
private javax.swing.JTextField binarySignDisplay;
private javax.swing.JTextField binaryExponentDisplay;
private javax.swing.JTextField binaryFractionDisplay;
private javax.swing.JLabel expansionDisplay;
private javax.swing.JLabel significandLabel;
private FloatRepresentation$BinaryToDecimalFormulaGraphic binaryToDecimalFormulaGraphic;
private FloatRepresentation$InstructionsPane instructions;
private String defaultInstructions;
private static final String zeroes = 0000000000000000000000000000000000000000000000000000000000000000;
private static final String HTMLspaces = ;
public void FloatRepresentation(String, String);
public void FloatRepresentation();
public static void main(String[]);
public String getName();
protected void addAsObserver();
protected void deleteAsObserver();
protected javax.swing.JComponent buildMainDisplayArea();
public void update(java.util.Observable, Object);
protected void reset();
protected javax.swing.JComponent buildDisplayArea();
private synchronized void updateAnyAttachedRegister(int);
private void updateDisplays(FloatRepresentation$FlavorsOfFloat);
private void updateDisplaysAndRegister(FloatRepresentation$FlavorsOfFloat);
private void updateSignificandLabel(FloatRepresentation$FlavorsOfFloat);
static void
}
Settings$Bool
package rars;
public final synchronized enum Settings$Bool {
public static final Settings$Bool EXTENDED_ASSEMBLER_ENABLED;
public static final Settings$Bool ASSEMBLE_ON_OPEN;
public static final Settings$Bool ASSEMBLE_OPEN;
public static final Settings$Bool ASSEMBLE_ALL;
public static final Settings$Bool LABEL_WINDOW_VISIBILITY;
public static final Settings$Bool DISPLAY_ADDRESSES_IN_HEX;
public static final Settings$Bool DISPLAY_VALUES_IN_HEX;
public static final Settings$Bool EXCEPTION_HANDLER_ENABLED;
public static final Settings$Bool EDITOR_LINE_NUMBERS_DISPLAYED;
public static final Settings$Bool WARNINGS_ARE_ERRORS;
public static final Settings$Bool PROGRAM_ARGUMENTS;
public static final Settings$Bool DATA_SEGMENT_HIGHLIGHTING;
public static final Settings$Bool REGISTERS_HIGHLIGHTING;
public static final Settings$Bool START_AT_MAIN;
public static final Settings$Bool EDITOR_CURRENT_LINE_HIGHLIGHTING;
public static final Settings$Bool POPUP_INSTRUCTION_GUIDANCE;
public static final Settings$Bool POPUP_SYSCALL_INPUT;
public static final Settings$Bool GENERIC_TEXT_EDITOR;
public static final Settings$Bool AUTO_INDENT;
public static final Settings$Bool SELF_MODIFYING_CODE_ENABLED;
private String name;
private boolean value;
public static Settings$Bool[] values();
public static Settings$Bool valueOf(String);
private void Settings$Bool(String, int, String, boolean);
boolean getDefault();
void setDefault(boolean);
String getName();
static void
}
TokenList
package rars.assembler;
public synchronized class TokenList implements Cloneable, Iterable {
private java.util.ArrayList tokenList;
private String processedLine;
public void TokenList();
public java.util.Iterator iterator();
public void setProcessedLine(String);
public String getProcessedLine();
public Token get(int);
public void set(int, Token);
public int size();
public void add(Token);
public void remove(int);
public boolean isEmpty();
public String toString();
public String toTypeString();
public Object clone();
}
Directives
package rars.assembler;
public final synchronized class Directives {
private static java.util.ArrayList directiveList;
public static final Directives DATA;
public static final Directives TEXT;
public static final Directives WORD;
public static final Directives ASCII;
public static final Directives ASCIZ;
public static final Directives STRING;
public static final Directives BYTE;
public static final Directives ALIGN;
public static final Directives HALF;
public static final Directives SPACE;
public static final Directives DOUBLE;
public static final Directives FLOAT;
public static final Directives EXTERN;
public static final Directives GLOBL;
public static final Directives EQV;
public static final Directives MACRO;
public static final Directives END_MACRO;
public static final Directives INCLUDE;
public static final Directives SECTION;
private String descriptor;
private String description;
private void Directives(String, String);
public static Directives matchDirective(String);
public static java.util.ArrayList prefixMatchDirectives(String);
public String toString();
public String getName();
public String getDescription();
public static java.util.ArrayList getDirectiveList();
public static boolean isIntegerDirective(Directives);
public static boolean isFloatingDirective(Directives);
static void
}
TokenTypes
package rars.assembler;
public final synchronized enum TokenTypes {
public static final TokenTypes COMMENT;
public static final TokenTypes DIRECTIVE;
public static final TokenTypes OPERATOR;
public static final TokenTypes DELIMITER;
public static final TokenTypes REGISTER_NAME;
public static final TokenTypes REGISTER_NUMBER;
public static final TokenTypes FP_REGISTER_NAME;
public static final TokenTypes CSR_NAME;
public static final TokenTypes ROUNDING_MODE;
public static final TokenTypes IDENTIFIER;
public static final TokenTypes LEFT_PAREN;
public static final TokenTypes RIGHT_PAREN;
public static final TokenTypes INTEGER_5;
public static final TokenTypes INTEGER_12;
public static final TokenTypes INTEGER_20;
public static final TokenTypes INTEGER_32;
public static final TokenTypes REAL_NUMBER;
public static final TokenTypes QUOTED_STRING;
public static final TokenTypes PLUS;
public static final TokenTypes MINUS;
public static final TokenTypes COLON;
public static final TokenTypes ERROR;
public static final TokenTypes MACRO_PARAMETER;
public static final TokenTypes HI;
public static final TokenTypes LO;
public static final TokenTypes TAG;
public static final String TOKEN_DELIMITERS =,();
public static TokenTypes[] values();
public static TokenTypes valueOf(String);
private void TokenTypes(String, int);
public String toString();
public static TokenTypes matchTokenType(String);
public static boolean isIntegerTokenType(TokenTypes);
public static boolean isFloatingTokenType(TokenTypes);
public static boolean isValidIdentifier(String);
static void
}
Assembler$AddressSpace
package rars.assembler;
synchronized class Assembler$AddressSpace {
int address;
private void Assembler$AddressSpace(Assembler, int);
private int get();
private void set(int);
private void increment(int);
}
Tokenizer
package rars.assembler;
public synchronized class Tokenizer {
private rars.ErrorList errors;
private rars.RISCVprogram sourceRISCVprogram;
private java.util.HashMap equivalents;
private static final String escapedCharacters = ‘”
tbrf0;
private static final String[] escapedCharactersValues;
public void Tokenizer();
public void Tokenizer(rars.RISCVprogram);
public java.util.ArrayList tokenize(rars.RISCVprogram) throws rars.AssemblyException;
private java.util.ArrayList processIncludes(rars.RISCVprogram, java.util.Map) throws rars.AssemblyException;
public TokenList tokenizeExampleInstruction(String) throws rars.AssemblyException;
public TokenList tokenizeLine(int, String);
public TokenList tokenizeLine(int, String, rars.ErrorList);
public TokenList tokenizeLine(int, String, rars.ErrorList, boolean);
public TokenList tokenizeLine(rars.RISCVprogram, int, String, boolean);
private TokenList processEqv(rars.RISCVprogram, int, String, TokenList);
public rars.ErrorList getErrors();
private void processCandidateToken(char[], rars.RISCVprogram, int, String, int, int, TokenList);
private String preprocessCharacterLiteral(String);
static void
}
MacroPool
package rars.assembler;
public synchronized class MacroPool {
private rars.RISCVprogram program;
private java.util.ArrayList macroList;
private Macro current;
private java.util.ArrayList callStack;
private java.util.ArrayList callStackOrigLines;
private int counter;
public void MacroPool(rars.RISCVprogram);
public void beginMacro(Token);
public void commitMacro(Token);
public Macro getMatchingMacro(TokenList, int);
public boolean matchesAnyMacroName(String);
public Macro getCurrent();
public void setCurrent(Macro);
public int getNextCounter();
public java.util.ArrayList getCallStack();
public boolean pushOnCallStack(Token);
public void popFromCallStack();
public String getExpansionHistory();
}
Macro
package rars.assembler;
public synchronized class Macro {
private String name;
private rars.RISCVprogram program;
private java.util.ArrayList labels;
private int fromLine;
private int toLine;
private int origFromLine;
private int origToLine;
private java.util.ArrayList args;
public void Macro();
public String getName();
public void setName(String);
public rars.RISCVprogram getProgram();
public void setProgram(rars.RISCVprogram);
public int getFromLine();
public int getOriginalFromLine();
public void setFromLine(int);
public void setOriginalFromLine(int);
public int getToLine();
public int getOriginalToLine();
public void setToLine(int);
public void setOriginalToLine(int);
public java.util.ArrayList getArgs();
public void setArgs(java.util.ArrayList);
public boolean equals(Object);
public void addArg(String);
public String getSubstitutedLine(int, TokenList, long, rars.ErrorList);
private boolean tokenIsMacroLabel(String);
private String replaceToken(String, Token, String);
public static boolean tokenIsMacroParameter(String, boolean);
public void addLabel(String);
public void readyForCommit();
}
Assembler$DataSegmentForwardReferences
package rars.assembler;
synchronized class Assembler$DataSegmentForwardReferences {
private java.util.ArrayList forwardReferenceList;
private void Assembler$DataSegmentForwardReferences(Assembler);
private int size();
private void add(int, int, Token);
private void add(Assembler$DataSegmentForwardReferences);
private void clear();
private void resolve(SymbolTable);
private void generateErrorMessages(rars.ErrorList);
}
SourceLine
package rars.assembler;
public synchronized class SourceLine {
private String source;
private String filename;
private rars.RISCVprogram program;
private int lineNumber;
public void SourceLine(String, rars.RISCVprogram, int);
public String getSource();
public String getFilename();
public int getLineNumber();
public rars.RISCVprogram getRISCVprogram();
}
SymbolTable
package rars.assembler;
public synchronized class SymbolTable {
private static String startLabel;
private String filename;
private java.util.ArrayList table;
public static final int NOT_FOUND = -1;
public void SymbolTable(String);
public void addSymbol(Token, int, boolean, rars.ErrorList);
public void removeSymbol(Token);
public int getAddress(String);
public int getAddressLocalOrGlobal(String);
public Symbol getSymbol(String);
public Symbol getSymbolGivenAddress(String);
public Symbol getSymbolGivenAddressLocalOrGlobal(String);
public java.util.ArrayList getDataSymbols();
public java.util.ArrayList getTextSymbols();
public java.util.ArrayList getAllSymbols();
public int getSize();
public void clear();
public void fixSymbolTableAddress(int, int);
public static String getStartLabel();
static void
}
DataTypes
package rars.assembler;
public final synchronized class DataTypes {
public static final int DOUBLE_SIZE = 8;
public static final int FLOAT_SIZE = 4;
public static final int WORD_SIZE = 4;
public static final int HALF_SIZE = 2;
public static final int BYTE_SIZE = 1;
public static final int CHAR_SIZE = 1;
public static final int MAX_WORD_VALUE = 2147483647;
public static final int MIN_WORD_VALUE = -2147483648;
public static final int MAX_HALF_VALUE = 32767;
public static final int MIN_HALF_VALUE = -32768;
public static final int MAX_IMMEDIATE_VALUE = 2047;
public static final int MIN_IMMEDIATE_VALUE = -2048;
public static final int MAX_UPPER_VALUE = 1048575;
public static final int MIN_UPPER_VALUE = 0;
public static final int MAX_BYTE_VALUE = 127;
public static final int MIN_BYTE_VALUE = -128;
public static final double MAX_FLOAT_VALUE = 3.4028234663852886E38;
public static final double LOW_FLOAT_VALUE = -3.4028234663852886E38;
public void DataTypes();
public static int getLengthInBytes(Directives);
public static boolean outOfRange(Directives, int);
public static boolean outOfRange(Directives, double);
}
Token
package rars.assembler;
public synchronized class Token {
private TokenTypes type;
private String value;
private rars.RISCVprogram sourceProgram;
private int sourceLine;
private int sourcePos;
private rars.RISCVprogram originalProgram;
private int originalSourceLine;
public void Token(TokenTypes, String, rars.RISCVprogram, int, int);
public void setOriginal(rars.RISCVprogram, int);
public rars.RISCVprogram getOriginalProgram();
public int getOriginalSourceLine();
public TokenTypes getType();
public void setType(TokenTypes);
public String getValue();
public String toString();
public rars.RISCVprogram getSourceProgram();
public int getSourceLine();
public int getStartPos();
}
Assembler
package rars.assembler;
public synchronized class Assembler {
private rars.ErrorList errors;
private boolean inDataSegment;
private boolean inMacroSegment;
private int externAddress;
private boolean autoAlign;
private Directives dataDirective;
private rars.RISCVprogram fileCurrentlyBeingAssembled;
private TokenList globalDeclarationList;
private Assembler$AddressSpace textAddress;
private Assembler$AddressSpace dataAddress;
private Assembler$DataSegmentForwardReferences currentFileDataSegmentForwardReferences;
private Assembler$DataSegmentForwardReferences accumulatedDataSegmentForwardReferences;
public void Assembler();
public rars.ErrorList getErrorList();
public java.util.ArrayList assemble(java.util.ArrayList, boolean, boolean) throws rars.AssemblyException;
private void catchDuplicateAddresses(java.util.ArrayList, rars.ErrorList);
private java.util.ArrayList parseLine(TokenList, String, int, boolean);
private void detectLabels(TokenList, Macro);
private TokenList stripComment(TokenList);
private void stripLabels(TokenList);
private boolean parseAndRecordLabel(TokenList);
private boolean tokenListBeginsWithLabel(TokenList);
private void executeDirective(TokenList);
private void transferGlobals();
private void executeDirectiveContinuation(TokenList);
private java.util.ArrayList matchInstruction(Token);
private void storeNumeric(TokenList, Directives, rars.ErrorList);
private void storeInteger(Token, Directives, rars.ErrorList);
private void storeRealNumber(Token, Directives, rars.ErrorList);
private void storeStrings(TokenList, Directives, rars.ErrorList);
private boolean passesDataSegmentCheck(Token);
private int writeToDataSegment(int, int, Token, rars.ErrorList);
private void writeDoubleToDataSegment(double, Token, rars.ErrorList);
private int alignToBoundary(int, int);
static void
}
OperandFormat
package rars.assembler;
public synchronized class OperandFormat {
public void OperandFormat();
static boolean tokenOperandMatch(TokenList, rars.riscv.Instruction, rars.ErrorList);
static rars.riscv.Instruction bestOperandMatch(TokenList, java.util.ArrayList);
private static boolean numOperandsCheck(TokenList, rars.riscv.Instruction, rars.ErrorList);
private static boolean operandTypeCheck(TokenList, rars.riscv.Instruction, rars.ErrorList);
private static void generateMessage(Token, String, rars.ErrorList);
}
Symbol
package rars.assembler;
public synchronized class Symbol {
private String name;
private int address;
private boolean data;
public void Symbol(String, int, boolean);
public int getAddress();
public String getName();
public boolean getType();
public void setAddress(int);
}
Assembler$DataSegmentForwardReferences$DataSegmentForwardReference
package rars.assembler;
synchronized class Assembler$DataSegmentForwardReferences$DataSegmentForwardReference {
int patchAddress;
int length;
Token token;
void Assembler$DataSegmentForwardReferences$DataSegmentForwardReference(Assembler$DataSegmentForwardReferences, int, int, Token);
}
PropertiesFile
package rars.util;
public synchronized class PropertiesFile {
public void PropertiesFile();
public static java.util.Properties loadPropertiesFromFile(String);
}
EditorFont
package rars.util;
public synchronized class EditorFont {
private static final String[] styleStrings;
private static final int[] styleInts;
public static final String DEFAULT_STYLE_STRING;
public static final int DEFAULT_STYLE_INT;
public static final int MIN_SIZE = 6;
public static final int MAX_SIZE = 72;
public static final int DEFAULT_SIZE = 12;
private static final String[] allCommonFamilies;
private static final String TAB_STRING = ;
private static final char TAB_CHAR = 9;
private static final String SPACES = ;
private static final String[] commonFamilies;
public void EditorFont();
public static String[] getCommonFamilies();
public static String[] getAllFamilies();
public static String[] getFontStyleStrings();
public static int styleStringToStyleInt(String);
public static String styleIntToStyleString(int);
public static String sizeIntToSizeString(int);
public static int sizeStringToSizeInt(String);
public static java.awt.Font createFontFromStringValues(String, String, String);
public static String substituteSpacesForTabs(String);
public static String substituteSpacesForTabs(String, int);
private static String[] actualCommonFamilies();
static void
}
MemoryDump
package rars.util;
public synchronized class MemoryDump {
private static final String[] segmentNames;
private static int[] baseAddresses;
private static int[] limitAddresses;
public void MemoryDump();
public static Integer[] getSegmentBounds(String);
public static String[] getSegmentNames();
public static int[] getBaseAddresses(String[]);
public static int[] getLimitAddresses(String[]);
static void
}
Binary
package rars.util;
public synchronized class Binary {
private static char[] chars;
private static final long UNSIGNED_BASE = 4294967296;
public void Binary();
public static String intToBinaryString(int, int);
public static String intToBinaryString(int);
public static String longToBinaryString(long, int);
public static String longToBinaryString(long);
public static int binaryStringToInt(String);
public static long binaryStringToLong(String);
public static String binaryStringToHexString(String);
public static String hexStringToBinaryString(String);
public static char binaryStringToHexDigit(String);
public static String intToHexString(int);
public static String intToHalfHexString(int);
public static String longToHexString(long);
public static String unsignedIntToIntString(int);
public static String intToAscii(int);
public static int stringToInt(String) throws NumberFormatException;
public static Integer stringToIntFast(String);
public static long stringToLong(String) throws NumberFormatException;
public static int highOrderLongToInt(long);
public static int lowOrderLongToInt(long);
public static long twoIntsToLong(int, int);
public static int bitValue(int, int);
public static int bitValue(long, int);
public static int setBit(int, int);
public static int clearBit(int, int);
public static int setByte(int, int, int);
public static int getByte(int, int);
public static boolean isHex(String);
public static boolean isOctal(String);
static void
}
FilenameFinder$RarsFileFilter
package rars.util;
synchronized class FilenameFinder$RarsFileFilter extends javax.swing.filechooser.FileFilter {
private java.util.ArrayList extensions;
private String fullDescription;
private boolean acceptDirectories;
private void FilenameFinder$RarsFileFilter(java.util.ArrayList, String, boolean);
private String buildFullDescription(String, java.util.ArrayList);
public String getDescription();
public boolean accept(java.io.File);
}
SystemIO
package rars.util;
public synchronized class SystemIO {
public static final int SYSCALL_BUFSIZE = 128;
public static final int SYSCALL_MAXFILES = 32;
public static String fileErrorString;
private static final int O_RDONLY = 0;
private static final int O_WRONLY = 1;
private static final int O_RDWR = 2;
private static final int O_APPEND = 8;
private static final int O_CREAT = 512;
private static final int O_TRUNC = 1024;
private static final int O_EXCL = 2048;
private static final int SEEK_SET = 0;
private static final int SEEK_CUR = 1;
private static final int SEEK_END = 2;
private static final int STDIN = 0;
private static final int STDOUT = 1;
private static final int STDERR = 2;
private static java.io.BufferedReader inputReader;
public void SystemIO();
public static int readInteger(int);
private static String readStringInternal(String, String, int);
public static float readFloat(int);
public static void printString(String);
public static String readString(int, int);
public static int readChar(int);
public static int writeToFile(int, byte[], int);
public static int readFromFile(int, byte[], int);
public static int seek(int, int, int);
public static int openFile(String, int);
public static void closeFile(int);
public static void resetFiles();
public static String getFileErrorMessage();
private static java.io.BufferedReader getInputReader();
public static SystemIO$Data swapData(SystemIO$Data);
static void
}
SystemIO$FileIOData
package rars.util;
synchronized class SystemIO$FileIOData {
private static String[] fileNames;
private static int[] fileFlags;
private static java.io.Closeable[] streams;
private void SystemIO$FileIOData();
private static void resetFiles();
private static void setupStdio();
private static void setStreamInUse(int, java.io.Closeable);
private static java.io.Closeable getStreamInUse(int);
private static boolean filenameInUse(String);
private static boolean fdInUse(int, int);
private static void close(int);
private static int nowOpening(String, int);
static void
}
FilenameFinder
package rars.util;
public synchronized class FilenameFinder {
private static final String JAR_EXTENSION = .jar;
private static final String FILE_URL = file:;
private static final String JAR_URI_PREFIX = jar:;
private static final boolean NO_DIRECTORIES = 0;
public static String MATCH_ALL_EXTENSIONS;
public void FilenameFinder();
public static java.util.ArrayList getFilenameList(ClassLoader, String, String);
public static java.util.ArrayList getFilenameList(ClassLoader, String, java.util.ArrayList);
public static java.util.ArrayList getFilenameList(String, String);
public static java.util.ArrayList getFilenameList(String, java.util.ArrayList);
public static java.util.ArrayList getFilenameList(java.util.ArrayList, String);
public static java.util.ArrayList getFilenameList(java.util.ArrayList, java.util.ArrayList);
public static String getExtension(java.io.File);
public static javax.swing.filechooser.FileFilter getFileFilter(java.util.ArrayList, String, boolean);
public static javax.swing.filechooser.FileFilter getFileFilter(String, String, boolean);
public static boolean fileExtensionMatch(String, String);
private static java.util.ArrayList getListFromJar(String, String, String);
private static String extractJarFilename(String);
private static String checkFileExtension(String);
static void
}
SystemIO$Data
package rars.util;
public synchronized class SystemIO$Data {
private String[] fileNames;
private int[] fileFlags;
public java.io.Closeable[] streams;
public void SystemIO$Data(boolean);
}
HelpHelpAction$1
package rars.venus;
synchronized class HelpHelpAction$1 extends java.awt.event.WindowAdapter {
void HelpHelpAction$1(HelpHelpAction, javax.swing.JDialog);
public void windowClosing(java.awt.event.WindowEvent);
}
EditFindReplaceAction$FindReplaceDialog$2
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog$2 implements java.awt.event.ActionListener {
void EditFindReplaceAction$FindReplaceDialog$2(EditFindReplaceAction$FindReplaceDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog extends javax.swing.JDialog implements java.awt.event.ActionListener {
javax.swing.JTextField[] addressDisplay;
javax.swing.JLabel[] nameDisplay;
SettingsMemoryConfigurationAction$ConfigurationButton selectedConfigurationButton;
SettingsMemoryConfigurationAction$ConfigurationButton initialConfigurationButton;
private void SettingsMemoryConfigurationAction$MemoryConfigurationDialog(SettingsMemoryConfigurationAction, java.awt.Frame, String, boolean);
private javax.swing.JPanel buildDialogPanel();
private java.awt.Component buildConfigChooser();
private java.awt.Component buildConfigDisplay();
public void actionPerformed(java.awt.event.ActionEvent);
private java.awt.Component buildControlPanel();
private void performApply();
private void performClose();
private void performReset();
private void setConfigDisplay(rars.riscv.hardware.MemoryConfiguration);
}
SettingsHighlightingAction$BackgroundChanger
package rars.venus.settings;
synchronized class SettingsHighlightingAction$BackgroundChanger implements java.awt.event.ActionListener {
private int position;
public void SettingsHighlightingAction$BackgroundChanger(SettingsHighlightingAction, int);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$2
package rars.venus.settings;
synchronized class SettingsHighlightingAction$2 extends javax.swing.JCheckBox {
void SettingsHighlightingAction$2(SettingsHighlightingAction);
protected void processMouseEvent(java.awt.event.MouseEvent);
protected void processKeyEvent(java.awt.event.KeyEvent);
}
SettingsEditorAction$EditorFontDialog$8
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$8 implements javax.swing.event.ChangeListener {
void SettingsEditorAction$EditorFontDialog$8(SettingsEditorAction$EditorFontDialog);
public void stateChanged(javax.swing.event.ChangeEvent);
}
SettingsHighlightingAction$ForegroundChanger
package rars.venus.settings;
synchronized class SettingsHighlightingAction$ForegroundChanger implements java.awt.event.ActionListener {
private int position;
public void SettingsHighlightingAction$ForegroundChanger(SettingsHighlightingAction, int);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$6
package rars.venus.settings;
synchronized class SettingsHighlightingAction$6 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$6(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$DefaultChanger
package rars.venus.settings;
synchronized class SettingsHighlightingAction$DefaultChanger implements java.awt.event.ItemListener {
private int position;
public void SettingsHighlightingAction$DefaultChanger(SettingsHighlightingAction, int);
public void itemStateChanged(java.awt.event.ItemEvent);
}
SettingsEditorAction$EditorFontDialog$ForegroundChanger
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$ForegroundChanger implements java.awt.event.ActionListener {
private int row;
public void SettingsEditorAction$EditorFontDialog$ForegroundChanger(SettingsEditorAction$EditorFontDialog, int);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$BoldItalicChanger
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$BoldItalicChanger implements java.awt.event.ActionListener {
private int row;
public void SettingsEditorAction$EditorFontDialog$BoldItalicChanger(SettingsEditorAction$EditorFontDialog, int);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$4
package rars.venus.settings;
synchronized class SettingsHighlightingAction$4 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$4(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction
package rars.venus.settings;
public synchronized class SettingsEditorAction extends rars.venus.GuiAction {
private javax.swing.JDialog editorDialog;
private static final int gridVGap = 2;
private static final int gridHGap = 2;
private static final javax.swing.border.Border ColorSelectButtonEnabledBorder;
private static final javax.swing.border.Border ColorSelectButtonDisabledBorder;
private static final String GENERIC_TOOL_TIP_TEXT = Use generic editor (original RARS editor, similar to Notepad) instead of language-aware styled editor;
private static final String SAMPLE_TOOL_TIP_TEXT = Current setting; modify using buttons to the right;
private static final String FOREGROUND_TOOL_TIP_TEXT = Click, to select text color;
private static final String BOLD_TOOL_TIP_TEXT = Toggle text bold style;
private static final String ITALIC_TOOL_TIP_TEXT = Toggle text italic style;
private static final String DEFAULT_TOOL_TIP_TEXT = Check, to select defaults (disables buttons);
private static final String BOLD_BUTTON_TOOL_TIP_TEXT = B;
private static final String ITALIC_BUTTON_TOOL_TIP_TEXT = I;
private static final String TAB_SIZE_TOOL_TIP_TEXT = Current tab size in characters;
private static final String BLINK_SPINNER_TOOL_TIP_TEXT = Current blinking rate in milliseconds;
private static final String BLINK_SAMPLE_TOOL_TIP_TEXT = Displays current blinking rate;
private static final String CURRENT_LINE_HIGHLIGHT_TOOL_TIP_TEXT = Check, to highlight line currently being edited;
private static final String AUTO_INDENT_TOOL_TIP_TEXT = Check, to enable auto-indent to previous line when Enter key is pressed;
private static final String[] POPUP_GUIDANCE_TOOL_TIP_TEXT;
public void SettingsEditorAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
static void
}
SettingsEditorAction$EditorFontDialog$9
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$9 extends javax.swing.JCheckBox {
void SettingsEditorAction$EditorFontDialog$9(SettingsEditorAction$EditorFontDialog);
protected void processMouseEvent(java.awt.event.MouseEvent);
protected void processKeyEvent(java.awt.event.KeyEvent);
}
SettingsHighlightingAction$3
package rars.venus.settings;
synchronized class SettingsHighlightingAction$3 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$3(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
ColorSelectButton
package rars.venus.settings;
synchronized class ColorSelectButton extends javax.swing.JButton {
private static final javax.swing.border.Border ColorSelectButtonEnabledBorder;
private static final javax.swing.border.Border ColorSelectButtonDisabledBorder;
void ColorSelectButton();
public void setEnabled(boolean);
static void
}
SettingsHighlightingAction$1
package rars.venus.settings;
synchronized class SettingsHighlightingAction$1 extends java.awt.event.WindowAdapter {
void SettingsHighlightingAction$1(SettingsHighlightingAction);
public void windowClosing(java.awt.event.WindowEvent);
}
SettingsHighlightingAction$5
package rars.venus.settings;
synchronized class SettingsHighlightingAction$5 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$5(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction
package rars.venus.settings;
public synchronized class SettingsHighlightingAction extends rars.venus.GuiAction {
javax.swing.JDialog highlightDialog;
private static final int[] backgroundSettingPositions;
private static final int[] foregroundSettingPositions;
private static final int[] fontSettingPositions;
javax.swing.JButton[] backgroundButtons;
javax.swing.JButton[] foregroundButtons;
javax.swing.JButton[] fontButtons;
javax.swing.JCheckBox[] defaultCheckBoxes;
javax.swing.JLabel[] samples;
java.awt.Color[] currentNondefaultBackground;
java.awt.Color[] currentNondefaultForeground;
java.awt.Color[] initialSettingsBackground;
java.awt.Color[] initialSettingsForeground;
java.awt.Font[] initialFont;
java.awt.Font[] currentFont;
java.awt.Font[] currentNondefaultFont;
javax.swing.JButton dataHighlightButton;
javax.swing.JButton registerHighlightButton;
boolean currentDataHighlightSetting;
boolean initialDataHighlightSetting;
boolean currentRegisterHighlightSetting;
boolean initialRegisterHighlightSetting;
private static final int gridVGap = 2;
private static final int gridHGap = 2;
private static final String SAMPLE_TOOL_TIP_TEXT = Preview based on background and text color settings;
private static final String BACKGROUND_TOOL_TIP_TEXT = Click, to select background color;
private static final String FOREGROUND_TOOL_TIP_TEXT = Click, to select text color;
private static final String FONT_TOOL_TIP_TEXT = Click, to select text font;
private static final String DEFAULT_TOOL_TIP_TEXT = Check, to select default color (disables color select buttons);
public static final String CLOSE_TOOL_TIP_TEXT = Apply current settings and close dialog;
public static final String APPLY_TOOL_TIP_TEXT = Apply current settings now and leave dialog open;
public static final String RESET_TOOL_TIP_TEXT = Reset to initial settings without applying;
public static final String CANCEL_TOOL_TIP_TEXT = Close dialog without applying current settings;
private static final String DATA_HIGHLIGHT_ENABLE_TOOL_TIP_TEXT = Click, to enable or disable highlighting in Data Segment window;
private static final String REGISTER_HIGHLIGHT_ENABLE_TOOL_TIP_TEXT = Click, to enable or disable highlighting in Register windows;
private static final String fontButtonText = font;
public void SettingsHighlightingAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
private javax.swing.JPanel buildDialogPanel();
private String getHighlightControlText(boolean);
private void initializeButtonColors();
private void setHighlightingSettings();
private void resetButtonColors();
private void closeDialog();
static void
}
SettingsExceptionHandlerAction$ExceptionHandlerSettingAction
package rars.venus.settings;
synchronized class SettingsExceptionHandlerAction$ExceptionHandlerSettingAction implements java.awt.event.ActionListener {
private void SettingsExceptionHandlerAction$ExceptionHandlerSettingAction(SettingsExceptionHandlerAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$7
package rars.venus.settings;
synchronized class SettingsHighlightingAction$7 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$7(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsAction
package rars.venus.settings;
public synchronized class SettingsAction extends rars.venus.GuiAction {
private rars.Settings$Bool setting;
public void SettingsAction(String, String, rars.Settings$Bool);
public void actionPerformed(java.awt.event.ActionEvent);
public void handler(boolean);
}
SettingsEditorAction$EditorFontDialog$1
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$1 implements java.awt.event.ActionListener {
void SettingsEditorAction$EditorFontDialog$1(SettingsEditorAction$EditorFontDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$FontSettingDialog$2
package rars.venus.settings;
synchronized class SettingsHighlightingAction$FontSettingDialog$2 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$FontSettingDialog$2(SettingsHighlightingAction$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsExceptionHandlerAction
package rars.venus.settings;
public synchronized class SettingsExceptionHandlerAction extends rars.venus.GuiAction {
private javax.swing.JDialog exceptionHandlerDialog;
private javax.swing.JCheckBox exceptionHandlerSetting;
private javax.swing.JButton exceptionHandlerSelectionButton;
private javax.swing.JTextField exceptionHandlerDisplay;
private boolean initialSelected;
private String initialPathname;
public void SettingsExceptionHandlerAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
private javax.swing.JPanel buildDialogPanel();
private void performOK();
private void closeDialog();
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog$4
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog$4 implements java.awt.event.ActionListener {
void SettingsMemoryConfigurationAction$MemoryConfigurationDialog$4(SettingsMemoryConfigurationAction$MemoryConfigurationDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsExceptionHandlerAction$2
package rars.venus.settings;
synchronized class SettingsExceptionHandlerAction$2 implements java.awt.event.ActionListener {
void SettingsExceptionHandlerAction$2(SettingsExceptionHandlerAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$3
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$3 implements java.awt.event.ActionListener {
void SettingsEditorAction$EditorFontDialog$3(SettingsEditorAction$EditorFontDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$7
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$7 implements javax.swing.event.ChangeListener {
void SettingsEditorAction$EditorFontDialog$7(SettingsEditorAction$EditorFontDialog);
public void stateChanged(javax.swing.event.ChangeEvent);
}
SettingsHighlightingAction$FontSettingDialog
package rars.venus.settings;
synchronized class SettingsHighlightingAction$FontSettingDialog extends rars.venus.util.AbstractFontSettingDialog {
private boolean resultOK;
public void SettingsHighlightingAction$FontSettingDialog(SettingsHighlightingAction, java.awt.Frame, String, java.awt.Font);
private java.awt.Font showDialog();
protected void closeDialog();
private void performOK();
private void performCancel();
protected java.awt.Component buildControlPanel();
protected void apply(java.awt.Font);
}
SettingsMemoryConfigurationAction
package rars.venus.settings;
public synchronized class SettingsMemoryConfigurationAction extends rars.venus.GuiAction {
public void SettingsMemoryConfigurationAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$DefaultChanger
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$DefaultChanger implements java.awt.event.ItemListener {
private int row;
public void SettingsEditorAction$EditorFontDialog$DefaultChanger(SettingsEditorAction$EditorFontDialog, int);
public void itemStateChanged(java.awt.event.ItemEvent);
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog$2
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog$2 implements java.awt.event.ActionListener {
void SettingsMemoryConfigurationAction$MemoryConfigurationDialog$2(SettingsMemoryConfigurationAction$MemoryConfigurationDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog extends rars.venus.util.AbstractFontSettingDialog {
private javax.swing.JButton[] foregroundButtons;
private javax.swing.JLabel[] samples;
private javax.swing.JToggleButton[] bold;
private javax.swing.JToggleButton[] italic;
private javax.swing.JCheckBox[] useDefault;
private int[] syntaxStyleIndex;
private rars.venus.editors.jeditsyntax.SyntaxStyle[] defaultStyles;
private rars.venus.editors.jeditsyntax.SyntaxStyle[] initialStyles;
private rars.venus.editors.jeditsyntax.SyntaxStyle[] currentStyles;
private java.awt.Font previewFont;
private javax.swing.JPanel dialogPanel;
private javax.swing.JPanel syntaxStylePanel;
private javax.swing.JPanel otherSettingsPanel;
private javax.swing.JSlider tabSizeSelector;
private javax.swing.JSpinner tabSizeSpinSelector;
private javax.swing.JSpinner blinkRateSpinSelector;
private javax.swing.JSpinner popupPrefixLengthSpinSelector;
private javax.swing.JCheckBox lineHighlightCheck;
private javax.swing.JCheckBox genericEditorCheck;
private javax.swing.JCheckBox autoIndentCheck;
private javax.swing.text.Caret blinkCaret;
private javax.swing.JTextField blinkSample;
private javax.swing.ButtonGroup popupGuidanceButtons;
private javax.swing.JRadioButton[] popupGuidanceOptions;
private boolean syntaxStylesAction;
private int initialEditorTabSize;
private int initialCaretBlinkRate;
private int initialPopupGuidance;
private boolean initialLineHighlighting;
private boolean initialGenericTextEditor;
private boolean initialAutoIndent;
public void SettingsEditorAction$EditorFontDialog(SettingsEditorAction, java.awt.Frame, String, boolean, java.awt.Font);
protected javax.swing.JPanel buildDialogPanel();
protected java.awt.Component buildControlPanel();
protected void apply(java.awt.Font);
protected void reset();
private void resetOtherSettings();
private javax.swing.JPanel buildOtherSettingsPanel();
private javax.swing.JPanel buildSyntaxStylePanel();
private void initializeSyntaxStyleChangeables();
private void setSampleStyles(javax.swing.JLabel, rars.venus.editors.jeditsyntax.SyntaxStyle);
}
SettingsEditorAction$EditorFontDialog$5
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$5 implements java.awt.event.ItemListener {
void SettingsEditorAction$EditorFontDialog$5(SettingsEditorAction$EditorFontDialog);
public void itemStateChanged(java.awt.event.ItemEvent);
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog$5
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog$5 implements java.awt.event.ActionListener {
void SettingsMemoryConfigurationAction$MemoryConfigurationDialog$5(SettingsMemoryConfigurationAction$MemoryConfigurationDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsExceptionHandlerAction$3
package rars.venus.settings;
synchronized class SettingsExceptionHandlerAction$3 implements java.awt.event.ActionListener {
void SettingsExceptionHandlerAction$3(SettingsExceptionHandlerAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$FontSettingDialog$1
package rars.venus.settings;
synchronized class SettingsHighlightingAction$FontSettingDialog$1 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$FontSettingDialog$1(SettingsHighlightingAction$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$8
package rars.venus.settings;
synchronized class SettingsHighlightingAction$8 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$8(SettingsHighlightingAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$2
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$2 implements java.awt.event.ActionListener {
void SettingsEditorAction$EditorFontDialog$2(SettingsEditorAction$EditorFontDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsHighlightingAction$FontSettingDialog$3
package rars.venus.settings;
synchronized class SettingsHighlightingAction$FontSettingDialog$3 implements java.awt.event.ActionListener {
void SettingsHighlightingAction$FontSettingDialog$3(SettingsHighlightingAction$FontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsExceptionHandlerAction$1
package rars.venus.settings;
synchronized class SettingsExceptionHandlerAction$1 extends java.awt.event.WindowAdapter {
void SettingsExceptionHandlerAction$1(SettingsExceptionHandlerAction);
public void windowClosing(java.awt.event.WindowEvent);
}
SettingsHighlightingAction$FontChanger
package rars.venus.settings;
synchronized class SettingsHighlightingAction$FontChanger implements java.awt.event.ActionListener {
private int position;
public void SettingsHighlightingAction$FontChanger(SettingsHighlightingAction, int);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsExceptionHandlerAction$ExceptionHandlerSelectionAction
package rars.venus.settings;
synchronized class SettingsExceptionHandlerAction$ExceptionHandlerSelectionAction implements java.awt.event.ActionListener {
private void SettingsExceptionHandlerAction$ExceptionHandlerSelectionAction(SettingsExceptionHandlerAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog$3
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog$3 implements java.awt.event.ActionListener {
void SettingsMemoryConfigurationAction$MemoryConfigurationDialog$3(SettingsMemoryConfigurationAction$MemoryConfigurationDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsEditorAction$EditorFontDialog$4
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$4 implements java.awt.event.ActionListener {
void SettingsEditorAction$EditorFontDialog$4(SettingsEditorAction$EditorFontDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
SettingsMemoryConfigurationAction$ConfigurationButton
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$ConfigurationButton extends javax.swing.JRadioButton {
private rars.riscv.hardware.MemoryConfiguration configuration;
public void SettingsMemoryConfigurationAction$ConfigurationButton(SettingsMemoryConfigurationAction, rars.riscv.hardware.MemoryConfiguration);
public rars.riscv.hardware.MemoryConfiguration getConfiguration();
}
SettingsEditorAction$EditorFontDialog$6
package rars.venus.settings;
synchronized class SettingsEditorAction$EditorFontDialog$6 implements javax.swing.event.ChangeListener {
void SettingsEditorAction$EditorFontDialog$6(SettingsEditorAction$EditorFontDialog);
public void stateChanged(javax.swing.event.ChangeEvent);
}
SettingsMemoryConfigurationAction$MemoryConfigurationDialog$1
package rars.venus.settings;
synchronized class SettingsMemoryConfigurationAction$MemoryConfigurationDialog$1 extends java.awt.event.WindowAdapter {
void SettingsMemoryConfigurationAction$MemoryConfigurationDialog$1(SettingsMemoryConfigurationAction$MemoryConfigurationDialog, SettingsMemoryConfigurationAction);
public void windowClosing(java.awt.event.WindowEvent);
}
VenusUI$16
package rars.venus;
synchronized class VenusUI$16 extends GuiAction {
void VenusUI$16(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$6
package rars.venus;
synchronized class VenusUI$6 extends GuiAction {
void VenusUI$6(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$14
package rars.venus;
synchronized class VenusUI$14 extends GuiAction {
void VenusUI$14(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$4
package rars.venus;
synchronized class VenusUI$4 extends GuiAction {
void VenusUI$4(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
MessagesPane$Asker$1$1
package rars.venus;
synchronized class MessagesPane$Asker$1$1 implements Runnable {
void MessagesPane$Asker$1$1(MessagesPane$Asker$1, javax.swing.event.DocumentEvent);
public void run();
}
EditPane$2
package rars.venus;
synchronized class EditPane$2 implements java.awt.event.ItemListener {
void EditPane$2(EditPane);
public void itemStateChanged(java.awt.event.ItemEvent);
}
MessagesPane$Asker
package rars.venus;
synchronized class MessagesPane$Asker implements Runnable {
java.util.concurrent.ArrayBlockingQueue resultQueue;
int initialPos;
int maxLen;
final javax.swing.event.DocumentListener listener;
final javax.swing.text.NavigationFilter navigationFilter;
final rars.simulator.Simulator$StopListener stopListener;
void MessagesPane$Asker(MessagesPane, int);
public void run();
void cleanup();
void returnResponse();
String response();
}
MonoRightCellRenderer
package rars.venus;
public synchronized class MonoRightCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
public static final java.awt.Font MONOSPACED_PLAIN_12POINT;
public void MonoRightCellRenderer();
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
static void
}
GuiAction
package rars.venus;
public synchronized class GuiAction extends javax.swing.AbstractAction {
protected void GuiAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
FileDumpMemoryAction$DumpFormatComboBoxRenderer
package rars.venus;
synchronized class FileDumpMemoryAction$DumpFormatComboBoxRenderer extends javax.swing.plaf.basic.BasicComboBoxRenderer {
private javax.swing.JComboBox myMaster;
public void FileDumpMemoryAction$DumpFormatComboBoxRenderer(FileDumpMemoryAction, javax.swing.JComboBox);
public java.awt.Component getListCellRendererComponent(javax.swing.JList, Object, int, boolean, boolean);
}
FileStatus
package rars.venus;
public synchronized class FileStatus {
public static final int NO_FILE = 0;
public static final int NEW_NOT_EDITED = 1;
public static final int NEW_EDITED = 2;
public static final int NOT_EDITED = 3;
public static final int EDITED = 4;
public static final int RUNNABLE = 5;
public static final int RUNNING = 6;
public static final int TERMINATED = 7;
public static final int OPENING = 8;
private static int systemStatus;
private static boolean systemAssembled;
private static boolean systemSaved;
private static boolean systemEdited;
private static String systemName;
private static java.io.File systemFile;
private int status;
private java.io.File file;
public static void set(int);
public static int get();
public static void setAssembled(boolean);
public static void setSaved(boolean);
public static void setEdited(boolean);
public static void setName(String);
public static void setFile(java.io.File);
public static java.io.File getFile();
public static String getName();
public static boolean isAssembled();
public static boolean isSaved();
public static boolean isEdited();
public static void reset();
public void FileStatus();
public void FileStatus(int, String);
public void setFileStatus(int);
public int getFileStatus();
public boolean isNew();
public boolean hasUnsavedEdits();
public void setPathname(String);
public void setPathname(String, String);
public String getPathname();
public String getFilename();
public String getParent();
public void updateStaticFileStatus();
}
NumberDisplayBaseChooser
package rars.venus;
public synchronized class NumberDisplayBaseChooser extends javax.swing.JCheckBox {
public static final int DECIMAL = 10;
public static final int HEXADECIMAL = 16;
public static final int ASCII = 0;
private int base;
private javax.swing.JCheckBoxMenuItem settingMenuItem;
public void NumberDisplayBaseChooser(String, boolean);
public int getBase();
public void setBase(int);
public static String formatUnsignedInteger(int, int);
public static String formatNumber(int, int);
public static String formatNumber(float, int);
public static String formatNumber(double, int);
public String formatNumber(int);
public String formatUnsignedInteger(int);
public static String formatFloatNumber(int, int);
public static String formatDoubleNumber(long, int);
public void setSettingsMenuItem(javax.swing.JCheckBoxMenuItem);
public static int getBase(boolean);
}
EditFindReplaceAction
package rars.venus;
public synchronized class EditFindReplaceAction extends GuiAction {
private static String searchString;
private static boolean caseSensitivity;
private static final String DIALOG_TITLE = Find and Replace;
private MainPane mainPane;
private javax.swing.JDialog findReplaceDialog;
public void EditFindReplaceAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
static void
}
DataSegmentWindow$NextButton
package rars.venus;
synchronized class DataSegmentWindow$NextButton extends util.RepeatButton {
public void DataSegmentWindow$NextButton(DataSegmentWindow, javax.swing.Icon);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$10
package rars.venus;
synchronized class VenusUI$10 extends GuiAction {
void VenusUI$10(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditFindReplaceAction$FindReplaceDialog$4
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog$4 implements java.awt.event.ActionListener {
void EditFindReplaceAction$FindReplaceDialog$4(EditFindReplaceAction$FindReplaceDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$2
package rars.venus;
synchronized class VenusUI$2 extends java.awt.event.WindowAdapter {
void VenusUI$2(VenusUI);
public void windowClosing(java.awt.event.WindowEvent);
}
AbstractFontSettingDialog$ComboBoxRenderer
package rars.venus.util;
synchronized class AbstractFontSettingDialog$ComboBoxRenderer extends javax.swing.JLabel implements javax.swing.ListCellRenderer {
javax.swing.JSeparator separator;
public void AbstractFontSettingDialog$ComboBoxRenderer(AbstractFontSettingDialog);
public java.awt.Component getListCellRendererComponent(javax.swing.JList, String, int, boolean, boolean);
}
PopupListener
package rars.venus.util;
public synchronized class PopupListener extends java.awt.event.MouseAdapter {
private javax.swing.JPopupMenu popup;
public void PopupListener(javax.swing.JPopupMenu);
public void mousePressed(java.awt.event.MouseEvent);
public void mouseReleased(java.awt.event.MouseEvent);
private void maybeShowPopup(java.awt.event.MouseEvent);
}
RepeatButton
package rars.venus.util;
public synchronized class RepeatButton extends javax.swing.JButton implements java.awt.event.ActionListener, java.awt.event.MouseListener {
private boolean pressed;
private boolean repeatEnabled;
private javax.swing.Timer timer;
private int initialDelay;
private int delay;
private int modifiers;
private static boolean testing;
public void RepeatButton();
public void RepeatButton(javax.swing.Action);
public void RepeatButton(javax.swing.Icon);
public void RepeatButton(String);
public void RepeatButton(String, javax.swing.Icon);
private void init();
public int getDelay();
public void setDelay(int);
public int getInitialDelay();
public void setInitialDelay(int);
public boolean isRepeatEnabled();
public void setRepeatEnabled(boolean);
public void setEnabled(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
public void mouseClicked(java.awt.event.MouseEvent);
public void mousePressed(java.awt.event.MouseEvent);
public void mouseReleased(java.awt.event.MouseEvent);
public void mouseEntered(java.awt.event.MouseEvent);
public void mouseExited(java.awt.event.MouseEvent);
public static void main(String[]);
static void
}
AbstractFontSettingDialog
package rars.venus.util;
public abstract synchronized class AbstractFontSettingDialog extends javax.swing.JDialog {
javax.swing.JDialog editorDialog;
javax.swing.JComboBox fontFamilySelector;
javax.swing.JComboBox fontStyleSelector;
javax.swing.JSlider fontSizeSelector;
javax.swing.JSpinner fontSizeSpinSelector;
javax.swing.JLabel fontSample;
protected java.awt.Font currentFont;
String initialFontFamily;
String initialFontStyle;
String initialFontSize;
private static String SEPARATOR;
public void AbstractFontSettingDialog(java.awt.Frame, String, boolean, java.awt.Font);
protected javax.swing.JPanel buildDialogPanel();
protected abstract java.awt.Component buildControlPanel();
public java.awt.Font getFont();
protected void performApply();
protected void closeDialog();
protected void reset();
protected abstract void apply(java.awt.Font);
private java.util.Vector makeVectorData(String[][]);
static void
}
AbstractFontSettingDialog$2
package rars.venus.util;
synchronized class AbstractFontSettingDialog$2 implements javax.swing.event.ChangeListener {
void AbstractFontSettingDialog$2(AbstractFontSettingDialog);
public void stateChanged(javax.swing.event.ChangeEvent);
}
AbstractFontSettingDialog$4
package rars.venus.util;
synchronized class AbstractFontSettingDialog$4 implements java.awt.event.ActionListener {
void AbstractFontSettingDialog$4(AbstractFontSettingDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractFontSettingDialog$3
package rars.venus.util;
synchronized class AbstractFontSettingDialog$3 implements javax.swing.event.ChangeListener {
void AbstractFontSettingDialog$3(AbstractFontSettingDialog);
public void stateChanged(javax.swing.event.ChangeEvent);
}
AbstractFontSettingDialog$BlockComboListener
package rars.venus.util;
synchronized class AbstractFontSettingDialog$BlockComboListener implements java.awt.event.ActionListener {
javax.swing.JComboBox combo;
Object currentItem;
void AbstractFontSettingDialog$BlockComboListener(AbstractFontSettingDialog, javax.swing.JComboBox);
public void actionPerformed(java.awt.event.ActionEvent);
}
AbstractFontSettingDialog$1
package rars.venus.util;
synchronized class AbstractFontSettingDialog$1 extends java.awt.event.WindowAdapter {
void AbstractFontSettingDialog$1(AbstractFontSettingDialog);
public void windowClosing(java.awt.event.WindowEvent);
}
VenusUI$12
package rars.venus;
synchronized class VenusUI$12 extends GuiAction {
void VenusUI$12(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$8
package rars.venus;
synchronized class DataSegmentWindow$8 implements java.awt.event.ActionListener {
void DataSegmentWindow$8(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditFindReplaceAction$FindReplaceDialog$1
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog$1 extends java.awt.event.WindowAdapter {
void EditFindReplaceAction$FindReplaceDialog$1(EditFindReplaceAction$FindReplaceDialog, EditFindReplaceAction);
public void windowClosing(java.awt.event.WindowEvent);
}
LabelsWindow$LabelsForSymbolTable
package rars.venus;
synchronized class LabelsWindow$LabelsForSymbolTable {
private rars.RISCVprogram program;
private Object[][] labelData;
private javax.swing.JTable labelTable;
private java.util.ArrayList symbols;
private rars.assembler.SymbolTable symbolTable;
private String tableName;
public void LabelsWindow$LabelsForSymbolTable(LabelsWindow, rars.RISCVprogram);
public String getSymbolTableName();
public boolean hasSymbols();
private javax.swing.JTable generateLabelTable();
public void updateLabelAddresses();
}
TextSegmentWindow$MyTableColumnMovingListener
package rars.venus;
synchronized class TextSegmentWindow$MyTableColumnMovingListener implements javax.swing.event.TableColumnModelListener {
private void TextSegmentWindow$MyTableColumnMovingListener(TextSegmentWindow);
public void columnAdded(javax.swing.event.TableColumnModelEvent);
public void columnRemoved(javax.swing.event.TableColumnModelEvent);
public void columnMarginChanged(javax.swing.event.ChangeEvent);
public void columnSelectionChanged(javax.swing.event.ListSelectionEvent);
public void columnMoved(javax.swing.event.TableColumnModelEvent);
}
ToolLoader
package rars.venus;
public synchronized class ToolLoader {
private static final String CLASS_PREFIX = rars.tools.;
private static final String TOOLS_DIRECTORY_PATH = rars/tools;
private static final String TOOLS_MENU_NAME = Tools;
private static final String TOOL_INTERFACE = Tool.class;
private static final String CLASS_EXTENSION = class;
public void ToolLoader();
public static javax.swing.JMenu buildToolsMenu();
private static java.util.ArrayList loadTools();
}
VenusUI$5
package rars.venus;
synchronized class VenusUI$5 extends GuiAction {
void VenusUI$5(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
LabelsWindow$LabelDisplayMouseListener
package rars.venus;
synchronized class LabelsWindow$LabelDisplayMouseListener extends java.awt.event.MouseAdapter {
private void LabelsWindow$LabelDisplayMouseListener(LabelsWindow);
public void mouseClicked(java.awt.event.MouseEvent);
}
VenusUI$15
package rars.venus;
synchronized class VenusUI$15 extends GuiAction {
void VenusUI$15(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$MyTippedJTable$1
package rars.venus;
synchronized class DataSegmentWindow$MyTippedJTable$1 extends javax.swing.table.JTableHeader {
void DataSegmentWindow$MyTippedJTable$1(DataSegmentWindow$MyTippedJTable, javax.swing.table.TableColumnModel);
public String getToolTipText(java.awt.event.MouseEvent);
}
HelpHelpAction$2
package rars.venus;
synchronized class HelpHelpAction$2 implements java.awt.event.ActionListener {
void HelpHelpAction$2(HelpHelpAction, javax.swing.JDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
LabelsWindow$LabelItemListener
package rars.venus;
synchronized class LabelsWindow$LabelItemListener implements java.awt.event.ItemListener {
private void LabelsWindow$LabelItemListener(LabelsWindow);
public void itemStateChanged(java.awt.event.ItemEvent);
}
TextEditingArea
package rars.venus.editors;
public abstract interface TextEditingArea {
public static final int TEXT_NOT_FOUND = 0;
public static final int TEXT_FOUND = 1;
public static final int TEXT_REPLACED_FOUND_NEXT = 2;
public static final int TEXT_REPLACED_NOT_FOUND_NEXT = 3;
public abstract void copy();
public abstract void cut();
public abstract int doFindText(String, boolean);
public abstract int doReplace(String, String, boolean);
public abstract int doReplaceAll(String, String, boolean);
public abstract int getCaretPosition();
public abstract javax.swing.text.Document getDocument();
public abstract String getSelectedText();
public abstract int getSelectionEnd();
public abstract int getSelectionStart();
public abstract void select(int, int);
public abstract void selectAll();
public abstract String getText();
public abstract javax.swing.undo.UndoManager getUndoManager();
public abstract void paste();
public abstract void replaceSelection(String);
public abstract void setCaretPosition(int);
public abstract void setEditable(boolean);
public abstract void setSelectionEnd(int);
public abstract void setSelectionStart(int);
public abstract void setText(String);
public abstract void setFont(java.awt.Font);
public abstract java.awt.Font getFont();
public abstract boolean requestFocusInWindow();
public abstract java.awt.FontMetrics getFontMetrics(java.awt.Font);
public abstract void setBackground(java.awt.Color);
public abstract void setEnabled(boolean);
public abstract void grabFocus();
public abstract void redo();
public abstract void revalidate();
public abstract void setSourceCode(String, boolean);
public abstract void setCaretVisible(boolean);
public abstract void setSelectionVisible(boolean);
public abstract void undo();
public abstract void discardAllUndoableEdits();
public abstract void setLineHighlightEnabled(boolean);
public abstract void setCaretBlinkRate(int);
public abstract void setTabSize(int);
public abstract void updateSyntaxStyles();
public abstract java.awt.Component getOuterComponent();
}
InputHandler$insert_tab
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$insert_tab implements java.awt.event.ActionListener {
public void InputHandler$insert_tab();
public void actionPerformed(java.awt.event.ActionEvent);
}
DefaultInputHandler$BindingMap
package rars.venus.editors.jeditsyntax;
synchronized class DefaultInputHandler$BindingMap extends DefaultInputHandler$Binding {
java.util.Hashtable map;
void DefaultInputHandler$BindingMap(DefaultInputHandler);
void clear();
void put(javax.swing.KeyStroke, DefaultInputHandler$Binding);
DefaultInputHandler$Binding get(javax.swing.KeyStroke);
}
KeywordMap
package rars.venus.editors.jeditsyntax;
public synchronized class KeywordMap {
protected int mapLength;
private KeywordMap$Keyword[] map;
private boolean ignoreCase;
public void KeywordMap(boolean);
public void KeywordMap(boolean, int);
public byte lookup(javax.swing.text.Segment, int, int);
public void add(String, byte);
public boolean getIgnoreCase();
public void setIgnoreCase(boolean);
protected int getStringMapKey(String);
protected int getSegmentMapKey(javax.swing.text.Segment, int, int);
}
InputHandler$backspace_word
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$backspace_word implements java.awt.event.ActionListener {
public void InputHandler$backspace_word();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$MacroRecorder
package rars.venus.editors.jeditsyntax;
public abstract interface InputHandler$MacroRecorder {
public abstract void actionPerformed(java.awt.event.ActionListener, String);
}
InputHandler
package rars.venus.editors.jeditsyntax;
public abstract synchronized class InputHandler extends java.awt.event.KeyAdapter {
public static final String SMART_HOME_END_PROPERTY = InputHandler.homeEnd;
public static final java.awt.event.ActionListener BACKSPACE;
public static final java.awt.event.ActionListener BACKSPACE_WORD;
public static final java.awt.event.ActionListener DELETE;
public static final java.awt.event.ActionListener DELETE_WORD;
public static final java.awt.event.ActionListener END;
public static final java.awt.event.ActionListener DOCUMENT_END;
public static final java.awt.event.ActionListener SELECT_ALL;
public static final java.awt.event.ActionListener SELECT_END;
public static final java.awt.event.ActionListener SELECT_DOC_END;
public static final java.awt.event.ActionListener INSERT_BREAK;
public static final java.awt.event.ActionListener INSERT_TAB;
public static final java.awt.event.ActionListener HOME;
public static final java.awt.event.ActionListener DOCUMENT_HOME;
public static final java.awt.event.ActionListener SELECT_HOME;
public static final java.awt.event.ActionListener SELECT_DOC_HOME;
public static final java.awt.event.ActionListener NEXT_CHAR;
public static final java.awt.event.ActionListener NEXT_LINE;
public static final java.awt.event.ActionListener NEXT_PAGE;
public static final java.awt.event.ActionListener NEXT_WORD;
public static final java.awt.event.ActionListener SELECT_NEXT_CHAR;
public static final java.awt.event.ActionListener SELECT_NEXT_LINE;
public static final java.awt.event.ActionListener SELECT_NEXT_PAGE;
public static final java.awt.event.ActionListener SELECT_NEXT_WORD;
public static final java.awt.event.ActionListener OVERWRITE;
public static final java.awt.event.ActionListener PREV_CHAR;
public static final java.awt.event.ActionListener PREV_LINE;
public static final java.awt.event.ActionListener PREV_PAGE;
public static final java.awt.event.ActionListener PREV_WORD;
public static final java.awt.event.ActionListener SELECT_PREV_CHAR;
public static final java.awt.event.ActionListener SELECT_PREV_LINE;
public static final java.awt.event.ActionListener SELECT_PREV_PAGE;
public static final java.awt.event.ActionListener SELECT_PREV_WORD;
public static final java.awt.event.ActionListener REPEAT;
public static final java.awt.event.ActionListener TOGGLE_RECT;
public static final java.awt.event.ActionListener CLIP_COPY;
public static final java.awt.event.ActionListener CLIP_PASTE;
public static final java.awt.event.ActionListener CLIP_CUT;
public static final java.awt.event.ActionListener INSERT_CHAR;
private static java.util.Hashtable actions;
protected java.awt.event.ActionListener grabAction;
protected boolean repeat;
protected int repeatCount;
protected InputHandler$MacroRecorder recorder;
public void InputHandler();
public static java.awt.event.ActionListener getAction(String);
public static String getActionName(java.awt.event.ActionListener);
public static java.util.Enumeration getActions();
public abstract void addDefaultKeyBindings();
public abstract void addKeyBinding(String, java.awt.event.ActionListener);
public abstract void removeKeyBinding(String);
public abstract void removeAllKeyBindings();
public void grabNextKeyStroke(java.awt.event.ActionListener);
public boolean isRepeatEnabled();
public void setRepeatEnabled(boolean);
public int getRepeatCount();
public void setRepeatCount(int);
public InputHandler$MacroRecorder getMacroRecorder();
public void setMacroRecorder(InputHandler$MacroRecorder);
public abstract InputHandler copy();
public void executeAction(java.awt.event.ActionListener, Object, String);
public static JEditTextArea getTextArea(java.util.EventObject);
protected void handleGrabAction(java.awt.event.KeyEvent);
static void
}
InputHandler$repeat
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$repeat implements java.awt.event.ActionListener, InputHandler$NonRecordable {
public void InputHandler$repeat();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$delete_word
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$delete_word implements java.awt.event.ActionListener {
public void InputHandler$delete_word();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$insert_break
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$insert_break implements java.awt.event.ActionListener {
public void InputHandler$insert_break();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$prev_word
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$prev_word implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$prev_word(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$backspace
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$backspace implements java.awt.event.ActionListener {
public void InputHandler$backspace();
public void actionPerformed(java.awt.event.ActionEvent);
}
DefaultInputHandler$Binding
package rars.venus.editors.jeditsyntax;
synchronized class DefaultInputHandler$Binding {
private void DefaultInputHandler$Binding(DefaultInputHandler);
}
InputHandler$insert_char
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$insert_char implements java.awt.event.ActionListener, InputHandler$NonRepeatable {
public void InputHandler$insert_char();
public void actionPerformed(java.awt.event.ActionEvent);
}
PopupHelpItem
package rars.venus.editors.jeditsyntax;
public synchronized class PopupHelpItem {
private String tokenText;
private String example;
private String description;
private boolean exact;
private int exampleLength;
private static final String spaces = ;
public void PopupHelpItem(String, String, String, boolean);
public void PopupHelpItem(String, String, String);
public String getTokenText();
public String getExample();
public String getDescription();
public boolean getExact();
public int getExampleLength();
public String getExamplePaddedToLength(int);
public void setExample(String);
public void setDescription(String);
public static int maxExampleLength(java.util.ArrayList);
}
JEditTextArea$AdjustHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$AdjustHandler implements java.awt.event.AdjustmentListener {
void JEditTextArea$AdjustHandler(JEditTextArea);
public void adjustmentValueChanged(java.awt.event.AdjustmentEvent);
}
JEditTextArea$ScrollLayout
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$ScrollLayout implements java.awt.LayoutManager {
private java.awt.Component center;
private java.awt.Component right;
private java.awt.Component bottom;
private java.util.Vector leftOfScrollBar;
void JEditTextArea$ScrollLayout(JEditTextArea);
public void addLayoutComponent(String, java.awt.Component);
public void removeLayoutComponent(java.awt.Component);
public java.awt.Dimension preferredLayoutSize(java.awt.Container);
public java.awt.Dimension minimumLayoutSize(java.awt.Container);
public void layoutContainer(java.awt.Container);
}
SyntaxUtilities
package rars.venus.editors.jeditsyntax;
public synchronized class SyntaxUtilities {
public static boolean popupShowing;
public static javax.swing.Popup popup;
public static boolean regionMatches(boolean, javax.swing.text.Segment, int, String);
public static boolean regionMatches(boolean, javax.swing.text.Segment, int, char[]);
public static SyntaxStyle[] getDefaultSyntaxStyles();
public static SyntaxStyle[] getCurrentSyntaxStyles();
public static int paintSyntaxLine(javax.swing.text.Segment, tokenmarker.Token, SyntaxStyle[], javax.swing.text.TabExpander, java.awt.Graphics, int, int);
private void SyntaxUtilities();
static void
}
InputHandler$clip_copy
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$clip_copy implements java.awt.event.ActionListener {
public void InputHandler$clip_copy();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$NonRepeatable
package rars.venus.editors.jeditsyntax;
public abstract interface InputHandler$NonRepeatable {
}
InputHandler$end
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$end implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$end(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$prev_page
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$prev_page implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$prev_page(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea
package rars.venus.editors.jeditsyntax;
public synchronized class JEditTextArea extends javax.swing.JComponent {
public static String LEFT_OF_SCROLLBAR;
public static java.awt.Color POPUP_HELP_TEXT_COLOR;
private static final int VERTICAL_SCROLLBAR_UNIT_INCREMENT_IN_LINES = 1;
private static final int LINES_PER_MOUSE_WHEEL_NOTCH = 3;
private javax.swing.JScrollBar lineNumbersVertical;
javax.swing.JPopupMenu popupMenu;
protected static String CENTER;
protected static String RIGHT;
protected static String BOTTOM;
protected static JEditTextArea focusedComponent;
protected static javax.swing.Timer caretTimer;
protected TextAreaPainter painter;
protected javax.swing.JPopupMenu popup;
protected javax.swing.event.EventListenerList listenerList;
protected JEditTextArea$MutableCaretEvent caretEvent;
protected boolean caretBlinks;
protected boolean caretVisible;
protected boolean blink;
protected boolean editable;
protected int caretBlinkRate;
protected int firstLine;
protected int visibleLines;
protected int electricScroll;
protected int horizontalOffset;
protected javax.swing.JScrollBar vertical;
protected javax.swing.JScrollBar horizontal;
protected boolean scrollBarsInitialized;
protected InputHandler inputHandler;
protected SyntaxDocument document;
protected JEditTextArea$DocumentHandler documentHandler;
protected javax.swing.text.Segment lineSegment;
protected int selectionStart;
protected int selectionStartLine;
protected int selectionEnd;
protected int selectionEndLine;
protected boolean biasLeft;
protected int bracketPosition;
protected int bracketLine;
protected int magicCaret;
protected boolean overwrite;
protected boolean rectSelect;
protected boolean unredoing;
public void JEditTextArea(javax.swing.JComponent);
public void JEditTextArea(TextAreaDefaults, javax.swing.JComponent);
public final TextAreaPainter getPainter();
public final InputHandler getInputHandler();
public void setInputHandler(InputHandler);
public final boolean isCaretBlinkEnabled();
public void setCaretBlinkEnabled(boolean);
public final boolean isCaretVisible();
public void setCaretVisible(boolean);
public final void blinkCaret();
public final int getElectricScroll();
public final void setElectricScroll(int);
public void updateScrollBars();
public final int getFirstLine();
public void setFirstLine(int);
public final int getVisibleLines();
public final void recalculateVisibleLines();
public final int getHorizontalOffset();
public void setHorizontalOffset(int);
public boolean setOrigin(int, int);
public boolean scrollToCaret();
public boolean scrollTo(int, int);
public int lineToY(int);
public int yToLine(int);
public final int offsetToX(int, int);
public int _offsetToX(int, int);
public int xToOffset(int, int);
public int xyToOffset(int, int);
public final javax.swing.text.Document getDocument();
public void setDocument(SyntaxDocument);
public final tokenmarker.TokenMarker getTokenMarker();
public final void setTokenMarker(tokenmarker.TokenMarker);
public final int getDocumentLength();
public final int getLineCount();
public final int getLineOfOffset(int);
public int getLineStartOffset(int);
public int getLineEndOffset(int);
public int getLineLength(int);
public String getText();
public void setText(String);
public final String getText(int, int);
public final void getText(int, int, javax.swing.text.Segment);
public final String getLineText(int);
public final void getLineText(int, javax.swing.text.Segment);
public final int getSelectionStart();
public int getSelectionStart(int);
public final int getSelectionStartLine();
public final void setSelectionStart(int);
public final int getSelectionEnd();
public int getSelectionEnd(int);
public final int getSelectionEndLine();
public final void setSelectionEnd(int);
public final int getCaretPosition();
public final int getCaretLine();
public final int getMarkPosition();
public final int getMarkLine();
public final void setCaretPosition(int);
public final void selectAll();
public final void selectNone();
public void select(int, int);
public final String getSelectedText();
public void setSelectedText(String);
public final boolean isEditable();
public final void setEditable(boolean);
public final javax.swing.JPopupMenu getRightClickPopup();
public final void setRightClickPopup(javax.swing.JPopupMenu);
public final int getMagicCaretPosition();
public final void setMagicCaretPosition(int);
public void overwriteSetSelectedText(String);
public final boolean isOverwriteEnabled();
public final void setOverwriteEnabled(boolean);
public final boolean isSelectionRectangular();
public final void setSelectionRectangular(boolean);
public final int getBracketPosition();
public final int getBracketLine();
public final void addCaretListener(javax.swing.event.CaretListener);
public final void removeCaretListener(javax.swing.event.CaretListener);
public void cut();
public void copy();
public void paste();
public void removeNotify();
public void processKeyEvent(java.awt.event.KeyEvent);
protected void fireCaretEvent();
protected void updateBracketHighlight(int);
protected void documentChanged(javax.swing.event.DocumentEvent);
public String getSyntaxSensitiveToolTipText(int, int);
public String getAutoIndent();
public String getLeadingWhiteSpace();
private java.util.ArrayList getSyntaxSensitiveHelpAtLineOffset(int, int, boolean);
private void applySyntaxSensitiveHelp();
private void checkAutoIndent(java.awt.event.KeyEvent);
private void checkPopupMenu(java.awt.event.KeyEvent);
private boolean checkPopupCompletion(java.awt.event.KeyEvent);
static void
}
SyntaxDocument
package rars.venus.editors.jeditsyntax;
public synchronized class SyntaxDocument extends javax.swing.text.PlainDocument {
protected tokenmarker.TokenMarker tokenMarker;
public void SyntaxDocument();
public tokenmarker.TokenMarker getTokenMarker();
public void setTokenMarker(tokenmarker.TokenMarker);
public void tokenizeLines();
public void tokenizeLines(int, int);
public void beginCompoundEdit();
public void endCompoundEdit();
public void addUndoableEdit(javax.swing.undo.UndoableEdit);
protected void fireInsertUpdate(javax.swing.event.DocumentEvent);
protected void fireRemoveUpdate(javax.swing.event.DocumentEvent);
}
InputHandler$home
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$home implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$home(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
KeywordMap$Keyword
package rars.venus.editors.jeditsyntax;
synchronized class KeywordMap$Keyword {
public char[] keyword;
public byte id;
public KeywordMap$Keyword next;
public void KeywordMap$Keyword(KeywordMap, char[], byte, KeywordMap$Keyword);
}
JEditTextArea$FocusHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$FocusHandler implements java.awt.event.FocusListener {
void JEditTextArea$FocusHandler(JEditTextArea);
public void focusGained(java.awt.event.FocusEvent);
public void focusLost(java.awt.event.FocusEvent);
}
InputHandler$next_char
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$next_char implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$next_char(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$clip_cut
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$clip_cut implements java.awt.event.ActionListener {
public void InputHandler$clip_cut();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$Wrapper
package rars.venus.editors.jeditsyntax;
public abstract interface InputHandler$Wrapper {
}
RISCVTokenMarker
package rars.venus.editors.jeditsyntax.tokenmarker;
public synchronized class RISCVTokenMarker extends TokenMarker {
private static rars.venus.editors.jeditsyntax.KeywordMap cKeywords;
private static String[] tokenLabels;
private static String[] tokenExamples;
private rars.venus.editors.jeditsyntax.KeywordMap keywords;
private int lastOffset;
private int lastKeyword;
public void RISCVTokenMarker();
public void RISCVTokenMarker(rars.venus.editors.jeditsyntax.KeywordMap);
public static String[] getRISCVTokenLabels();
public static String[] getRISCVTokenExamples();
public byte markTokensImpl(byte, javax.swing.text.Segment, int);
public java.util.ArrayList getTokenExactMatchHelp(Token, String);
public java.util.ArrayList getTokenPrefixMatchHelp(String, Token, Token, String);
private java.util.ArrayList getTextFromDirectiveMatch(String, boolean);
private java.util.ArrayList getTextFromInstructionMatch(String, boolean);
private static rars.venus.editors.jeditsyntax.KeywordMap getKeywords();
private void doKeyword(javax.swing.text.Segment, int, char);
}
TokenMarker
package rars.venus.editors.jeditsyntax.tokenmarker;
public abstract synchronized class TokenMarker {
protected Token firstToken;
protected Token lastToken;
protected TokenMarker$LineInfo[] lineInfo;
protected int length;
protected int lastLine;
protected boolean nextLineRequested;
public Token markTokens(javax.swing.text.Segment, int);
protected abstract byte markTokensImpl(byte, javax.swing.text.Segment, int);
public boolean supportsMultilineTokens();
public void insertLines(int, int);
public void deleteLines(int, int);
public int getLineCount();
public boolean isNextLineRequested();
public java.util.ArrayList getTokenExactMatchHelp(Token, String);
public java.util.ArrayList getTokenPrefixMatchHelp(String, Token, Token, String);
protected void TokenMarker();
protected void ensureCapacity(int);
protected void addToken(int, byte);
}
Token
package rars.venus.editors.jeditsyntax.tokenmarker;
public synchronized class Token {
public static final byte NULL = 0;
public static final byte COMMENT1 = 1;
public static final byte COMMENT2 = 2;
public static final byte LITERAL1 = 3;
public static final byte LITERAL2 = 4;
public static final byte LABEL = 5;
public static final byte KEYWORD1 = 6;
public static final byte KEYWORD2 = 7;
public static final byte KEYWORD3 = 8;
public static final byte OPERATOR = 9;
public static final byte INVALID = 10;
public static final byte MACRO_ARG = 11;
public static final byte ID_COUNT = 12;
public static final byte INTERNAL_FIRST = 100;
public static final byte INTERNAL_LAST = 126;
public static final byte END = 127;
public int length;
public byte id;
public Token next;
public void Token(int, byte);
public String toString();
}
TokenMarker$LineInfo
package rars.venus.editors.jeditsyntax.tokenmarker;
public synchronized class TokenMarker$LineInfo {
public byte token;
public Object obj;
public void TokenMarker$LineInfo(TokenMarker);
public void TokenMarker$LineInfo(TokenMarker, byte, Object);
}
InputHandler$prev_line
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$prev_line implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$prev_line(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
SyntaxStyle
package rars.venus.editors.jeditsyntax;
public synchronized class SyntaxStyle {
private java.awt.Color color;
private boolean italic;
private boolean bold;
private java.awt.Font lastFont;
private java.awt.Font lastStyledFont;
private java.awt.FontMetrics fontMetrics;
public void SyntaxStyle(java.awt.Color, boolean, boolean);
public java.awt.Color getColor();
public String getColorAsHexString();
public boolean isPlain();
public boolean isItalic();
public boolean isBold();
public java.awt.Font getStyledFont(java.awt.Font);
public java.awt.FontMetrics getFontMetrics(java.awt.Font);
public void setGraphicsFlags(java.awt.Graphics, java.awt.Font);
public String toString();
}
InputHandler$overwrite
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$overwrite implements java.awt.event.ActionListener {
public void InputHandler$overwrite();
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$select_all
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$select_all implements java.awt.event.ActionListener {
public void InputHandler$select_all();
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$2
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$2 implements Runnable {
void JEditTextArea$2(JEditTextArea, javax.swing.MenuElement[]);
public void run();
}
InputHandler$document_end
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$document_end implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$document_end(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
TextAreaDefaults
package rars.venus.editors.jeditsyntax;
public synchronized class TextAreaDefaults {
private static TextAreaDefaults DEFAULTS;
public InputHandler inputHandler;
public SyntaxDocument document;
public boolean editable;
public boolean caretVisible;
public boolean caretBlinks;
public boolean blockCaret;
public int caretBlinkRate;
public int electricScroll;
public int tabSize;
public int cols;
public int rows;
public SyntaxStyle[] styles;
public java.awt.Color caretColor;
public java.awt.Color selectionColor;
public java.awt.Color lineHighlightColor;
public boolean lineHighlight;
public java.awt.Color bracketHighlightColor;
public boolean bracketHighlight;
public java.awt.Color eolMarkerColor;
public boolean eolMarkers;
public boolean paintInvalid;
public javax.swing.JPopupMenu popup;
public void TextAreaDefaults();
public static TextAreaDefaults getDefaults();
}
JEditTextArea$PopupHelpActionListener
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$PopupHelpActionListener implements java.awt.event.ActionListener {
private String tokenText;
private String text;
public void JEditTextArea$PopupHelpActionListener(JEditTextArea, String, String);
public void actionPerformed(java.awt.event.ActionEvent);
}
TextAreaPainter
package rars.venus.editors.jeditsyntax;
public synchronized class TextAreaPainter extends javax.swing.JComponent implements javax.swing.text.TabExpander {
int currentLineIndex;
tokenmarker.Token currentLineTokens;
javax.swing.text.Segment currentLine;
protected JEditTextArea textArea;
protected SyntaxStyle[] styles;
protected java.awt.Color caretColor;
protected java.awt.Color selectionColor;
protected java.awt.Color lineHighlightColor;
protected java.awt.Color bracketHighlightColor;
protected java.awt.Color eolMarkerColor;
protected boolean blockCaret;
protected boolean lineHighlight;
protected boolean bracketHighlight;
protected boolean paintInvalid;
protected boolean eolMarkers;
protected int cols;
protected int rows;
protected int tabSize;
protected int tabSizeChars;
protected java.awt.FontMetrics fm;
protected TextAreaPainter$Highlight highlights;
public void TextAreaPainter(JEditTextArea, TextAreaDefaults);
public final boolean isManagingFocus();
public int getTabSize();
public void setTabSize(int);
public final SyntaxStyle[] getStyles();
public final void setStyles(SyntaxStyle[]);
public final java.awt.Color getCaretColor();
public final void setCaretColor(java.awt.Color);
public final java.awt.Color getSelectionColor();
public final void setSelectionColor(java.awt.Color);
public final java.awt.Color getLineHighlightColor();
public final void setLineHighlightColor(java.awt.Color);
public final boolean isLineHighlightEnabled();
public final void setLineHighlightEnabled(boolean);
public final java.awt.Color getBracketHighlightColor();
public final void setBracketHighlightColor(java.awt.Color);
public final boolean isBracketHighlightEnabled();
public final void setBracketHighlightEnabled(boolean);
public final boolean isBlockCaretEnabled();
public final void setBlockCaretEnabled(boolean);
public final java.awt.Color getEOLMarkerColor();
public final void setEOLMarkerColor(java.awt.Color);
public final boolean getEOLMarkersPainted();
public final void setEOLMarkersPainted(boolean);
public boolean getInvalidLinesPainted();
public void setInvalidLinesPainted(boolean);
public void addCustomHighlight(TextAreaPainter$Highlight);
public String getToolTipText(java.awt.event.MouseEvent);
public java.awt.FontMetrics getFontMetrics();
public void setFont(java.awt.Font);
public void paint(java.awt.Graphics);
public final void invalidateLine(int);
public final void invalidateLineRange(int, int);
public final void invalidateSelectedLines();
public float nextTabStop(float, int);
public java.awt.Dimension getPreferredSize();
public java.awt.Dimension getMinimumSize();
protected void paintLine(java.awt.Graphics, tokenmarker.TokenMarker, int, int);
protected void paintPlainLine(java.awt.Graphics, int, java.awt.Font, java.awt.Color, int, int);
protected void paintSyntaxLine(java.awt.Graphics, tokenmarker.TokenMarker, int, java.awt.Font, java.awt.Color, int, int);
protected void paintHighlight(java.awt.Graphics, int, int);
protected void paintLineHighlight(java.awt.Graphics, int, int);
protected void paintBracketHighlight(java.awt.Graphics, int, int);
protected void paintCaret(java.awt.Graphics, int, int);
}
InputHandler$next_word
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$next_word implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$next_word(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditBasedTextArea$1
package rars.venus.editors.jeditsyntax;
synchronized class JEditBasedTextArea$1 implements javax.swing.event.UndoableEditListener {
void JEditBasedTextArea$1(JEditBasedTextArea);
public void undoableEditHappened(javax.swing.event.UndoableEditEvent);
}
JEditBasedTextArea
package rars.venus.editors.jeditsyntax;
public synchronized class JEditBasedTextArea extends JEditTextArea implements rars.venus.editors.TextEditingArea, javax.swing.event.CaretListener {
private rars.venus.EditPane editPane;
private javax.swing.undo.UndoManager undoManager;
private javax.swing.event.UndoableEditListener undoableEditListener;
private boolean isCompoundEdit;
private javax.swing.undo.CompoundEdit compoundEdit;
private JEditBasedTextArea sourceCode;
public void JEditBasedTextArea(rars.venus.EditPane, javax.swing.JComponent);
public void setFont(java.awt.Font);
public java.awt.Font getFont();
public void setLineHighlightEnabled(boolean);
public void setCaretBlinkRate(int);
public void setTabSize(int);
public void updateSyntaxStyles();
public java.awt.Component getOuterComponent();
public void discardAllUndoableEdits();
public void caretUpdate(javax.swing.event.CaretEvent);
public void replaceSelection(String);
public void setSelectionVisible(boolean);
public void setSourceCode(String, boolean);
public javax.swing.undo.UndoManager getUndoManager();
public void undo();
public void redo();
public int doFindText(String, boolean);
public int nextIndex(String, String, int, boolean);
public int doReplace(String, String, boolean);
public int doReplaceAll(String, String, boolean);
}
JEditTextArea$MouseHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$MouseHandler extends java.awt.event.MouseAdapter {
void JEditTextArea$MouseHandler(JEditTextArea);
public void mousePressed(java.awt.event.MouseEvent);
private void doSingleClick(java.awt.event.MouseEvent, int, int, int);
private void doDoubleClick(java.awt.event.MouseEvent, int, int, int) throws javax.swing.text.BadLocationException;
private void doTripleClick(java.awt.event.MouseEvent, int, int, int);
}
InputHandler$next_page
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$next_page implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$next_page(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$CaretBlinker
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$CaretBlinker implements java.awt.event.ActionListener {
void JEditTextArea$CaretBlinker();
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$ComponentHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$ComponentHandler extends java.awt.event.ComponentAdapter {
void JEditTextArea$ComponentHandler(JEditTextArea);
public void componentResized(java.awt.event.ComponentEvent);
}
JEditTextArea$MutableCaretEvent
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$MutableCaretEvent extends javax.swing.event.CaretEvent {
void JEditTextArea$MutableCaretEvent(JEditTextArea);
public int getDot();
public int getMark();
}
DefaultInputHandler$BindingAction
package rars.venus.editors.jeditsyntax;
synchronized class DefaultInputHandler$BindingAction extends DefaultInputHandler$Binding {
java.awt.event.ActionListener actionListener;
void DefaultInputHandler$BindingAction(DefaultInputHandler, java.awt.event.ActionListener);
}
InputHandler$document_home
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$document_home implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$document_home(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$CaretUndo
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$CaretUndo extends javax.swing.undo.AbstractUndoableEdit {
private int start;
private int end;
void JEditTextArea$CaretUndo(JEditTextArea, int, int);
public boolean isSignificant();
public String getPresentationName();
public void undo() throws javax.swing.undo.CannotUndoException;
public void redo() throws javax.swing.undo.CannotRedoException;
public boolean addEdit(javax.swing.undo.UndoableEdit);
}
JEditTextArea$1
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$1 implements java.awt.KeyEventDispatcher {
void JEditTextArea$1(JEditTextArea);
public boolean dispatchKeyEvent(java.awt.event.KeyEvent);
}
TextAreaPainter$Highlight
package rars.venus.editors.jeditsyntax;
public abstract interface TextAreaPainter$Highlight {
public abstract void init(JEditTextArea, TextAreaPainter$Highlight);
public abstract void paintHighlight(java.awt.Graphics, int, int);
public abstract String getToolTipText(java.awt.event.MouseEvent);
}
InputHandler$prev_char
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$prev_char implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$prev_char(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$AdjustHandler$1
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$AdjustHandler$1 implements Runnable {
void JEditTextArea$AdjustHandler$1(JEditTextArea$AdjustHandler, java.awt.event.AdjustmentEvent);
public void run();
}
TextUtilities
package rars.venus.editors.jeditsyntax;
public synchronized class TextUtilities {
public void TextUtilities();
public static int findMatchingBracket(javax.swing.text.Document, int) throws javax.swing.text.BadLocationException;
public static int findWordStart(String, int, String);
public static int findWordEnd(String, int, String);
}
InputHandler$clip_paste
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$clip_paste implements java.awt.event.ActionListener {
public void InputHandler$clip_paste();
public void actionPerformed(java.awt.event.ActionEvent);
}
DefaultInputHandler
package rars.venus.editors.jeditsyntax;
public synchronized class DefaultInputHandler extends InputHandler {
private DefaultInputHandler$BindingMap bindings;
private DefaultInputHandler$BindingMap currentBindings;
public void DefaultInputHandler();
public void addDefaultKeyBindings();
public void addKeyBinding(String, java.awt.event.ActionListener);
public void removeKeyBinding(String);
public void removeAllKeyBindings();
public InputHandler copy();
public void keyPressed(java.awt.event.KeyEvent);
public void keyTyped(java.awt.event.KeyEvent);
public static javax.swing.KeyStroke parseKeyStroke(String);
private void DefaultInputHandler(DefaultInputHandler);
}
JEditTextArea$DragHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$DragHandler implements java.awt.event.MouseMotionListener {
void JEditTextArea$DragHandler(JEditTextArea);
public void mouseDragged(java.awt.event.MouseEvent);
public void mouseMoved(java.awt.event.MouseEvent);
}
InputHandler$NonRecordable
package rars.venus.editors.jeditsyntax;
public abstract interface InputHandler$NonRecordable {
}
InputHandler$next_line
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$next_line implements java.awt.event.ActionListener {
private boolean select;
public void InputHandler$next_line(boolean);
public void actionPerformed(java.awt.event.ActionEvent);
}
InputHandler$toggle_rect
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$toggle_rect implements java.awt.event.ActionListener {
public void InputHandler$toggle_rect();
public void actionPerformed(java.awt.event.ActionEvent);
}
JEditTextArea$MouseWheelHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$MouseWheelHandler implements java.awt.event.MouseWheelListener {
void JEditTextArea$MouseWheelHandler(JEditTextArea);
public void mouseWheelMoved(java.awt.event.MouseWheelEvent);
}
InstructionMouseEvent
package rars.venus.editors.jeditsyntax;
synchronized class InstructionMouseEvent extends java.awt.event.MouseEvent {
private javax.swing.text.Segment line;
public void InstructionMouseEvent(java.awt.Component, int, int, javax.swing.text.Segment);
public javax.swing.text.Segment getLine();
}
JEditTextArea$DocumentHandler
package rars.venus.editors.jeditsyntax;
synchronized class JEditTextArea$DocumentHandler implements javax.swing.event.DocumentListener {
void JEditTextArea$DocumentHandler(JEditTextArea);
public void insertUpdate(javax.swing.event.DocumentEvent);
public void removeUpdate(javax.swing.event.DocumentEvent);
public void changedUpdate(javax.swing.event.DocumentEvent);
}
InputHandler$delete
package rars.venus.editors.jeditsyntax;
public synchronized class InputHandler$delete implements java.awt.event.ActionListener {
public void InputHandler$delete();
public void actionPerformed(java.awt.event.ActionEvent);
}
GenericTextArea$1
package rars.venus.editors.generic;
synchronized class GenericTextArea$1 implements javax.swing.event.ChangeListener {
void GenericTextArea$1(GenericTextArea);
public void stateChanged(javax.swing.event.ChangeEvent);
}
GenericTextArea
package rars.venus.editors.generic;
public synchronized class GenericTextArea extends javax.swing.JTextArea implements rars.venus.editors.TextEditingArea {
private rars.venus.EditPane editPane;
private javax.swing.undo.UndoManager undoManager;
private javax.swing.event.UndoableEditListener undoableEditListener;
private javax.swing.JTextArea sourceCode;
private javax.swing.JScrollPane editAreaScrollPane;
private boolean isCompoundEdit;
private javax.swing.undo.CompoundEdit compoundEdit;
public void GenericTextArea(rars.venus.EditPane, javax.swing.JComponent);
public void setLineHighlightEnabled(boolean);
public void updateSyntaxStyles();
public void setCaretBlinkRate(int);
public java.awt.Component getOuterComponent();
public void setSourceCode(String, boolean);
public void discardAllUndoableEdits();
public void setText(String);
public void setCaretVisible(boolean);
public void setSelectionVisible(boolean);
public javax.swing.undo.UndoManager getUndoManager();
public void undo();
public void redo();
public int doFindText(String, boolean);
public int nextIndex(String, String, int, boolean);
public int doReplace(String, String, boolean);
public int doReplaceAll(String, String, boolean);
}
GenericTextArea$2
package rars.venus.editors.generic;
synchronized class GenericTextArea$2 implements javax.swing.event.UndoableEditListener {
void GenericTextArea$2(GenericTextArea);
public void undoableEditHappened(javax.swing.event.UndoableEditEvent);
}
EditPane$1
package rars.venus;
synchronized class EditPane$1 implements javax.swing.event.DocumentListener {
void EditPane$1(EditPane);
public void insertUpdate(javax.swing.event.DocumentEvent);
public void removeUpdate(javax.swing.event.DocumentEvent);
public void changedUpdate(javax.swing.event.DocumentEvent);
}
MessagesPane$Asker$1$2
package rars.venus;
synchronized class MessagesPane$Asker$1$2 implements Runnable {
void MessagesPane$Asker$1$2(MessagesPane$Asker$1, javax.swing.event.DocumentEvent);
public void run();
}
LabelsWindow$MyTippedJTable
package rars.venus;
synchronized class LabelsWindow$MyTippedJTable extends javax.swing.JTable {
void LabelsWindow$MyTippedJTable(LabelsWindow, LabelsWindow$LabelTableModel);
protected javax.swing.table.JTableHeader createDefaultTableHeader();
public java.awt.Component prepareRenderer(javax.swing.table.TableCellRenderer, int, int);
}
VenusUI$7
package rars.venus;
synchronized class VenusUI$7 extends GuiAction {
void VenusUI$7(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$17
package rars.venus;
synchronized class VenusUI$17 extends GuiAction {
void VenusUI$17(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditFindReplaceAction$FindReplaceDialog$3
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog$3 implements java.awt.event.ActionListener {
void EditFindReplaceAction$FindReplaceDialog$3(EditFindReplaceAction$FindReplaceDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$PrevButton
package rars.venus;
synchronized class DataSegmentWindow$PrevButton extends util.RepeatButton {
public void DataSegmentWindow$PrevButton(DataSegmentWindow, javax.swing.Icon);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI
package rars.venus;
public synchronized class VenusUI extends javax.swing.JFrame {
VenusUI mainUI;
public javax.swing.JMenuBar menu;
private javax.swing.JToolBar toolbar;
private MainPane mainPane;
private registers.RegistersPane registersPane;
private registers.RegistersWindow registersTab;
private registers.FloatingPointWindow fpTab;
private registers.ControlAndStatusWindow csrTab;
private MessagesPane messagesPane;
private javax.swing.JSplitPane splitter;
private javax.swing.JSplitPane horizonSplitter;
javax.swing.JPanel north;
private int frameState;
private static int menuState;
private boolean reset;
private boolean started;
Editor editor;
private javax.swing.JMenu file;
private javax.swing.JMenu run;
private javax.swing.JMenu window;
private javax.swing.JMenu help;
private javax.swing.JMenu edit;
private javax.swing.JMenu settings;
private javax.swing.JMenuItem fileNew;
private javax.swing.JMenuItem fileOpen;
private javax.swing.JMenuItem fileClose;
private javax.swing.JMenuItem fileCloseAll;
private javax.swing.JMenuItem fileSave;
private javax.swing.JMenuItem fileSaveAs;
private javax.swing.JMenuItem fileSaveAll;
private javax.swing.JMenuItem fileDumpMemory;
private javax.swing.JMenuItem fileExit;
private javax.swing.JMenuItem editUndo;
private javax.swing.JMenuItem editRedo;
private javax.swing.JMenuItem editCut;
private javax.swing.JMenuItem editCopy;
private javax.swing.JMenuItem editPaste;
private javax.swing.JMenuItem editFindReplace;
private javax.swing.JMenuItem editSelectAll;
private javax.swing.JMenuItem runGo;
private javax.swing.JMenuItem runStep;
private javax.swing.JMenuItem runBackstep;
private javax.swing.JMenuItem runReset;
private javax.swing.JMenuItem runAssemble;
private javax.swing.JMenuItem runStop;
private javax.swing.JMenuItem runPause;
private javax.swing.JMenuItem runClearBreakpoints;
private javax.swing.JMenuItem runToggleBreakpoints;
private javax.swing.JCheckBoxMenuItem settingsLabel;
private javax.swing.JCheckBoxMenuItem settingsPopupInput;
private javax.swing.JCheckBoxMenuItem settingsValueDisplayBase;
private javax.swing.JCheckBoxMenuItem settingsAddressDisplayBase;
private javax.swing.JCheckBoxMenuItem settingsExtended;
private javax.swing.JCheckBoxMenuItem settingsAssembleOnOpen;
private javax.swing.JCheckBoxMenuItem settingsAssembleAll;
private javax.swing.JCheckBoxMenuItem settingsAssembleOpen;
private javax.swing.JCheckBoxMenuItem settingsWarningsAreErrors;
private javax.swing.JCheckBoxMenuItem settingsStartAtMain;
private javax.swing.JCheckBoxMenuItem settingsProgramArguments;
private javax.swing.JCheckBoxMenuItem settingsSelfModifyingCode;
private javax.swing.JMenuItem settingsExceptionHandler;
private javax.swing.JMenuItem settingsEditor;
private javax.swing.JMenuItem settingsHighlighting;
private javax.swing.JMenuItem settingsMemoryConfiguration;
private javax.swing.JMenuItem helpHelp;
private javax.swing.JMenuItem helpAbout;
private javax.swing.JButton Undo;
private javax.swing.JButton Redo;
private javax.swing.JButton Cut;
private javax.swing.JButton Copy;
private javax.swing.JButton Paste;
private javax.swing.JButton FindReplace;
private javax.swing.JButton SelectAll;
private javax.swing.JButton New;
private javax.swing.JButton Open;
private javax.swing.JButton Save;
private javax.swing.JButton SaveAs;
private javax.swing.JButton SaveAll;
private javax.swing.JButton DumpMemory;
private javax.swing.JButton Run;
private javax.swing.JButton Assemble;
private javax.swing.JButton Reset;
private javax.swing.JButton Step;
private javax.swing.JButton Backstep;
private javax.swing.JButton Stop;
private javax.swing.JButton Pause;
private javax.swing.JButton Help;
private javax.swing.Action fileNewAction;
private javax.swing.Action fileOpenAction;
private javax.swing.Action fileCloseAction;
private javax.swing.Action fileCloseAllAction;
private javax.swing.Action fileSaveAction;
private javax.swing.Action fileSaveAsAction;
private javax.swing.Action fileSaveAllAction;
private javax.swing.Action fileDumpMemoryAction;
private javax.swing.Action fileExitAction;
private javax.swing.Action editUndoAction;
private javax.swing.Action editRedoAction;
private javax.swing.Action editCutAction;
private javax.swing.Action editCopyAction;
private javax.swing.Action editPasteAction;
private javax.swing.Action editFindReplaceAction;
private javax.swing.Action editSelectAllAction;
private javax.swing.Action runAssembleAction;
private javax.swing.Action runGoAction;
private javax.swing.Action runStepAction;
private javax.swing.Action runBackstepAction;
private javax.swing.Action runResetAction;
private javax.swing.Action runStopAction;
private javax.swing.Action runPauseAction;
private javax.swing.Action runClearBreakpointsAction;
private javax.swing.Action runToggleBreakpointsAction;
private javax.swing.Action settingsLabelAction;
private javax.swing.Action settingsPopupInputAction;
private javax.swing.Action settingsValueDisplayBaseAction;
private javax.swing.Action settingsAddressDisplayBaseAction;
private javax.swing.Action settingsExtendedAction;
private javax.swing.Action settingsAssembleOnOpenAction;
private javax.swing.Action settingsAssembleOpenAction;
private javax.swing.Action settingsAssembleAllAction;
private javax.swing.Action settingsWarningsAreErrorsAction;
private javax.swing.Action settingsStartAtMainAction;
private javax.swing.Action settingsProgramArgumentsAction;
private javax.swing.Action settingsExceptionHandlerAction;
private javax.swing.Action settingsEditorAction;
private javax.swing.Action settingsHighlightingAction;
private javax.swing.Action settingsMemoryConfigurationAction;
private javax.swing.Action settingsSelfModifyingCodeAction;
private javax.swing.Action helpHelpAction;
private javax.swing.Action helpAboutAction;
public void VenusUI(String);
private void createActionObjects();
private javax.swing.JMenuBar setUpMenuBar();
javax.swing.JToolBar setUpToolBar();
public void setMenuState(int);
private void setMenuStateInitial();
void setMenuStateNotEdited();
void setMenuStateEditing();
void setMenuStateEditingNew();
void setMenuStateRunnable();
void setMenuStateRunning();
void setMenuStateTerminated();
public static int getMenuState();
public void setReset(boolean);
public void setStarted(boolean);
public boolean getReset();
public boolean getStarted();
public Editor getEditor();
public MainPane getMainPane();
public MessagesPane getMessagesPane();
public registers.RegistersPane getRegistersPane();
public javax.swing.JCheckBoxMenuItem getValueDisplayBaseMenuItem();
public javax.swing.JCheckBoxMenuItem getAddressDisplayBaseMenuItem();
public javax.swing.Action getRunAssembleAction();
public void haveMenuRequestFocus();
public void dispatchEventToMenu(java.awt.event.KeyEvent);
public void updateUndoAndRedoState();
private javax.swing.ImageIcon loadIcon(String);
private javax.swing.KeyStroke makeShortcut(int);
static void
}
VenusUI$13
package rars.venus;
synchronized class VenusUI$13 extends GuiAction {
void VenusUI$13(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$9
package rars.venus;
synchronized class DataSegmentWindow$9 implements java.awt.event.ActionListener {
void DataSegmentWindow$9(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
FileDumpMemoryAction
package rars.venus;
public synchronized class FileDumpMemoryAction extends GuiAction {
private javax.swing.JDialog dumpDialog;
private static final String title = Dump Memory To File;
private String[] segmentArray;
private int[] baseAddressArray;
private int[] limitAddressArray;
private int[] highAddressArray;
private String[] segmentListArray;
private int[] segmentListBaseArray;
private int[] segmentListHighArray;
private javax.swing.JComboBox segmentListSelector;
private javax.swing.JComboBox formatListSelector;
private VenusUI mainUI;
public void FileDumpMemoryAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
private void dumpMemory();
private javax.swing.JDialog createDumpDialog();
private javax.swing.JPanel buildDialogPanel();
private boolean performDump(int, int, rars.riscv.dump.DumpFormat);
private void closeDialog();
}
VenusUI$3
package rars.venus;
synchronized class VenusUI$3 extends GuiAction {
void VenusUI$3(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
LabelsWindow$MyTippedJTable$SymbolTableHeader$SymbolTableHeaderMouseListener
package rars.venus;
synchronized class LabelsWindow$MyTippedJTable$SymbolTableHeader$SymbolTableHeaderMouseListener implements java.awt.event.MouseListener {
private void LabelsWindow$MyTippedJTable$SymbolTableHeader$SymbolTableHeaderMouseListener(LabelsWindow$MyTippedJTable$SymbolTableHeader);
public void mouseClicked(java.awt.event.MouseEvent);
public void mouseEntered(java.awt.event.MouseEvent);
public void mouseExited(java.awt.event.MouseEvent);
public void mousePressed(java.awt.event.MouseEvent);
public void mouseReleased(java.awt.event.MouseEvent);
}
TextSegmentWindow$CheckBoxTableCellRenderer
package rars.venus;
synchronized class TextSegmentWindow$CheckBoxTableCellRenderer extends javax.swing.JCheckBox implements javax.swing.table.TableCellRenderer {
javax.swing.border.Border noFocusBorder;
javax.swing.border.Border focusBorder;
public void TextSegmentWindow$CheckBoxTableCellRenderer(TextSegmentWindow);
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
EditTabbedPane
package rars.venus;
public synchronized class EditTabbedPane extends javax.swing.JTabbedPane {
EditPane editTab;
MainPane mainPane;
private VenusUI mainUI;
private Editor editor;
private EditTabbedPane$FileOpener fileOpener;
public void EditTabbedPane(VenusUI, Editor, MainPane);
public EditPane getCurrentEditTab();
public void setCurrentEditTab(EditPane);
public EditPane getCurrentEditTabForFile(java.io.File);
public void newFile();
public boolean openFile();
public boolean openFile(java.io.File);
public boolean closeCurrentFile();
public boolean closeAllFiles();
public boolean saveCurrentFile();
private boolean saveFile(EditPane);
public boolean saveAsCurrentFile();
private java.io.File saveAsFile(EditPane);
public boolean saveAllFiles();
public String[] getOpenFilePaths();
public void remove(EditPane);
private void updateTitlesAndMenuState(EditPane);
private void updateTitles(EditPane);
public EditPane getEditPaneForFile(String);
public boolean editsSavedOrAbandoned();
private int confirm(String);
}
HelpHelpAction$MyCellRenderer
package rars.venus;
synchronized class HelpHelpAction$MyCellRenderer extends javax.swing.JLabel implements javax.swing.ListCellRenderer {
private void HelpHelpAction$MyCellRenderer(HelpHelpAction);
public java.awt.Component getListCellRendererComponent(javax.swing.JList, String, int, boolean, boolean);
}
EditFindReplaceAction$FindReplaceDialog$5
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog$5 implements java.awt.event.ActionListener {
void EditFindReplaceAction$FindReplaceDialog$5(EditFindReplaceAction$FindReplaceDialog);
public void actionPerformed(java.awt.event.ActionEvent);
}
HelpHelpAction
package rars.venus;
public synchronized class HelpHelpAction extends GuiAction {
private VenusUI mainUI;
static java.awt.Color altBackgroundColor;
public static final String descriptionDetailSeparator = :;
public void HelpHelpAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, VenusUI);
private java.awt.Dimension getSize();
public void actionPerformed(java.awt.event.ActionEvent);
private javax.swing.JPanel createHTMLHelpPanel(String);
private javax.swing.JPanel createCopyrightInfoPanel();
private javax.swing.JPanel createRarsHelpInfoPanel();
private javax.swing.JPanel createHelpInfoPanel();
private javax.swing.JScrollPane createDirectivesHelpPane();
private javax.swing.JScrollPane createSyscallsHelpPane();
private javax.swing.JScrollPane createInstructionHelpPane(Class);
private StringBuilder convertToHTMLTable(String[][], String[]);
private StringBuilder loadFiletoStringBuilder(String);
static void
}
FloatingPointWindow
package rars.venus.registers;
public synchronized class FloatingPointWindow extends RegisterBlockWindow {
private static final String[] regToolTips;
public void FloatingPointWindow();
protected String formatRegister(rars.riscv.hardware.Register, int);
protected void beginObserving();
protected void endObserving();
protected void resetRegisters();
static void
}
RegisterBlockWindow$MyTippedJTable
package rars.venus.registers;
synchronized class RegisterBlockWindow$MyTippedJTable extends javax.swing.JTable {
private String[] regToolTips;
private String[] columnToolTips;
private void RegisterBlockWindow$MyTippedJTable(RegisterBlockWindow, RegisterBlockWindow$RegTableModel, String[], String[]);
public String getToolTipText(java.awt.event.MouseEvent);
protected javax.swing.table.JTableHeader createDefaultTableHeader();
}
RegisterBlockWindow$1
package rars.venus.registers;
synchronized class RegisterBlockWindow$1 extends RegisterBlockWindow$MyTippedJTable {
void RegisterBlockWindow$1(RegisterBlockWindow, RegisterBlockWindow$RegTableModel, String[], String[]);
}
RegisterBlockWindow$MyTippedJTable$1
package rars.venus.registers;
synchronized class RegisterBlockWindow$MyTippedJTable$1 extends javax.swing.table.JTableHeader {
void RegisterBlockWindow$MyTippedJTable$1(RegisterBlockWindow$MyTippedJTable, javax.swing.table.TableColumnModel);
public String getToolTipText(java.awt.event.MouseEvent);
}
RegistersPane
package rars.venus.registers;
public synchronized class RegistersPane extends javax.swing.JTabbedPane {
private RegistersWindow regsTab;
private FloatingPointWindow fpTab;
private ControlAndStatusWindow csrTab;
private rars.venus.VenusUI mainUI;
public void RegistersPane(rars.venus.VenusUI, RegistersWindow, FloatingPointWindow, ControlAndStatusWindow);
public RegistersWindow getRegistersWindow();
public FloatingPointWindow getFloatingPointWindow();
public ControlAndStatusWindow getControlAndStatusWindow();
}
RegisterBlockWindow$RegisterCellRenderer
package rars.venus.registers;
synchronized class RegisterBlockWindow$RegisterCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
private java.awt.Font font;
private int alignment;
private void RegisterBlockWindow$RegisterCellRenderer(RegisterBlockWindow, java.awt.Font, int);
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
RegisterBlockWindow
package rars.venus.registers;
public abstract synchronized class RegisterBlockWindow extends javax.swing.JPanel implements java.util.Observer {
private javax.swing.JTable table;
private boolean highlighting;
private int highlightRow;
private rars.riscv.hardware.Register[] registers;
private static final int NAME_COLUMN = 0;
private static final int NUMBER_COLUMN = 1;
private static final int VALUE_COLUMN = 2;
private rars.Settings settings;
public void RegisterBlockWindow(rars.riscv.hardware.Register[], String[], String);
protected abstract String formatRegister(rars.riscv.hardware.Register, int);
protected abstract void beginObserving();
protected abstract void endObserving();
protected abstract void resetRegisters();
private Object[][] setupWindow();
public void clearWindow();
public void clearHighlighting();
public void refresh();
public void updateRegisters();
private void highlightCellForRegister(rars.riscv.hardware.Register);
public void update(java.util.Observable, Object);
}
RegistersWindow
package rars.venus.registers;
public synchronized class RegistersWindow extends RegisterBlockWindow {
private static final String[] regToolTips;
public void RegistersWindow();
private static rars.riscv.hardware.Register[] getRegisters();
protected String formatRegister(rars.riscv.hardware.Register, int);
protected void beginObserving();
protected void endObserving();
protected void resetRegisters();
static void
}
ControlAndStatusWindow
package rars.venus.registers;
public synchronized class ControlAndStatusWindow extends RegisterBlockWindow {
private static final String[] regToolTips;
public void ControlAndStatusWindow();
protected String formatRegister(rars.riscv.hardware.Register, int);
protected void beginObserving();
protected void endObserving();
public void resetRegisters();
static void
}
RegisterBlockWindow$RegTableModel
package rars.venus.registers;
synchronized class RegisterBlockWindow$RegTableModel extends javax.swing.table.AbstractTableModel {
final String[] columnNames;
private Object[][] data;
private void RegisterBlockWindow$RegTableModel(RegisterBlockWindow, Object[][]);
public int getColumnCount();
public int getRowCount();
public String getColumnName(int);
public Object getValueAt(int, int);
public Class getColumnClass(int);
public boolean isCellEditable(int, int);
public void setValueAt(Object, int, int);
private void setDisplayAndModelValueAt(Object, int, int);
}
VenusUI$11
package rars.venus;
synchronized class VenusUI$11 extends GuiAction {
void VenusUI$11(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
ExecutePane
package rars.venus;
public synchronized class ExecutePane extends javax.swing.JDesktopPane {
private registers.RegistersWindow registerValues;
private registers.FloatingPointWindow fpRegValues;
private registers.ControlAndStatusWindow csrValues;
private DataSegmentWindow dataSegment;
private TextSegmentWindow textSegment;
private LabelsWindow labelValues;
private VenusUI mainUI;
private NumberDisplayBaseChooser valueDisplayBase;
private NumberDisplayBaseChooser addressDisplayBase;
private boolean labelWindowVisible;
public void ExecutePane(VenusUI, registers.RegistersWindow, registers.FloatingPointWindow, registers.ControlAndStatusWindow);
public void setWindowBounds();
public void setLabelWindowVisibility(boolean);
public void clearPane();
public TextSegmentWindow getTextSegmentWindow();
public DataSegmentWindow getDataSegmentWindow();
public registers.RegistersWindow getRegistersWindow();
public registers.FloatingPointWindow getFloatingPointWindow();
public registers.ControlAndStatusWindow getControlAndStatusWindow();
public LabelsWindow getLabelsWindow();
public int getValueDisplayBase();
public int getAddressDisplayBase();
public NumberDisplayBaseChooser getValueDisplayBaseChooser();
public NumberDisplayBaseChooser getAddressDisplayBaseChooser();
public void numberDisplayBaseChanged(NumberDisplayBaseChooser);
}
VenusUI$1
package rars.venus;
synchronized class VenusUI$1 extends java.awt.event.WindowAdapter {
void VenusUI$1(VenusUI);
public void windowOpened(java.awt.event.WindowEvent);
}
DataSegmentWindow$7
package rars.venus;
synchronized class DataSegmentWindow$7 implements java.awt.event.ActionListener {
void DataSegmentWindow$7(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
TextSegmentWindow$MachineCodeCellRenderer
package rars.venus;
synchronized class TextSegmentWindow$MachineCodeCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
void TextSegmentWindow$MachineCodeCellRenderer(TextSegmentWindow);
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
VenusUI$20
package rars.venus;
synchronized class VenusUI$20 extends settings.SettingsAction {
void VenusUI$20(VenusUI, String, String, rars.Settings$Bool);
public void handler(boolean);
}
MessagesPane$Asker$3
package rars.venus;
synchronized class MessagesPane$Asker$3 implements rars.simulator.Simulator$StopListener {
void MessagesPane$Asker$3(MessagesPane$Asker);
public void stopped(rars.simulator.Simulator);
}
DataSegmentWindow$DataTableModel
package rars.venus;
synchronized class DataSegmentWindow$DataTableModel extends javax.swing.table.AbstractTableModel {
String[] columnNames;
Object[][] data;
public void DataSegmentWindow$DataTableModel(DataSegmentWindow, Object[][], String[]);
public int getColumnCount();
public int getRowCount();
public String getColumnName(int);
public Object getValueAt(int, int);
public boolean isCellEditable(int, int);
public Class getColumnClass(int);
public void setValueAt(Object, int, int);
private void setDisplayAndModelValueAt(Object, int, int);
private void printDebugData();
}
LabelsWindow
package rars.venus;
public synchronized class LabelsWindow extends javax.swing.JInternalFrame {
private java.awt.Container contentPane;
private javax.swing.JPanel labelPanel;
private javax.swing.JCheckBox dataLabels;
private javax.swing.JCheckBox textLabels;
private java.util.ArrayList listOfLabelsForSymbolTable;
private LabelsWindow labelsWindow;
private static final int MAX_DISPLAYED_CHARS = 24;
private static final int PREFERRED_NAME_COLUMN_WIDTH = 60;
private static final int PREFERRED_ADDRESS_COLUMN_WIDTH = 60;
private static final int LABEL_COLUMN = 0;
private static final int ADDRESS_COLUMN = 1;
private static final String[] columnToolTips;
private static String[] columnNames;
private java.util.Comparator tableSortComparator;
private final java.util.ArrayList tableSortingComparators;
private static final int[][] sortStateTransitions;
private static final char ASCENDING_SYMBOL = 9650;
private static final char DESCENDING_SYMBOL = 9660;
private static final String[][] sortColumnHeadings;
private int sortState;
public void LabelsWindow();
public void setupTable();
public void clearWindow();
private javax.swing.JScrollPane generateLabelScrollPane();
public void updateLabelAddresses();
static void
}
LabelsWindow$MyTippedJTable$SymbolTableHeader
package rars.venus;
synchronized class LabelsWindow$MyTippedJTable$SymbolTableHeader extends javax.swing.table.JTableHeader {
public void LabelsWindow$MyTippedJTable$SymbolTableHeader(LabelsWindow$MyTippedJTable, javax.swing.table.TableColumnModel);
public String getToolTipText(java.awt.event.MouseEvent);
}
TextSegmentWindow$CodeCellRenderer
package rars.venus;
synchronized class TextSegmentWindow$CodeCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
void TextSegmentWindow$CodeCellRenderer(TextSegmentWindow);
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
MainPane$1
package rars.venus;
synchronized class MainPane$1 implements javax.swing.event.ChangeListener {
void MainPane$1(MainPane);
public void stateChanged(javax.swing.event.ChangeEvent);
}
TextSegmentWindow$MyTippedJTable
package rars.venus;
synchronized class TextSegmentWindow$MyTippedJTable extends javax.swing.JTable {
private javax.swing.table.JTableHeader tableHeader;
private String[] columnToolTips;
void TextSegmentWindow$MyTippedJTable(TextSegmentWindow, TextSegmentWindow$TextTableModel);
protected javax.swing.table.JTableHeader createDefaultTableHeader();
public java.awt.Rectangle getRectForColumnIndex(int);
}
EditFindReplaceAction$FindReplaceDialog
package rars.venus;
synchronized class EditFindReplaceAction$FindReplaceDialog extends javax.swing.JDialog {
javax.swing.JButton findButton;
javax.swing.JButton replaceButton;
javax.swing.JButton replaceAllButton;
javax.swing.JButton closeButton;
javax.swing.JTextField findInputField;
javax.swing.JTextField replaceInputField;
javax.swing.JCheckBox caseSensitiveCheckBox;
javax.swing.JRadioButton linearFromStart;
javax.swing.JRadioButton circularFromCursor;
private javax.swing.JLabel resultsLabel;
public static final String FIND_TOOL_TIP_TEXT = Find next occurrence of given text; wraps around at end;
public static final String REPLACE_TOOL_TIP_TEXT = Replace current occurrence of text then find next;
public static final String REPLACE_ALL_TOOL_TIP_TEXT = Replace all occurrences of text;
public static final String CLOSE_TOOL_TIP_TEXT = Close the dialog;
public static final String RESULTS_TOOL_TIP_TEXT = Outcome of latest operation (button click);
public static final String RESULTS_TEXT_FOUND = Text found;
public static final String RESULTS_TEXT_NOT_FOUND = Text not found;
public static final String RESULTS_TEXT_REPLACED = Text replaced and found next;
public static final String RESULTS_TEXT_REPLACED_LAST = Text replaced; last occurrence;
public static final String RESULTS_TEXT_REPLACED_ALL = Replaced;
public static final String RESULTS_NO_TEXT_TO_FIND = No text to find;
public void EditFindReplaceAction$FindReplaceDialog(EditFindReplaceAction, java.awt.Frame, String, boolean);
private javax.swing.JPanel buildDialogPanel();
private java.awt.Component buildInputPanel();
private java.awt.Component buildOptionsPanel();
private java.awt.Component buildControlPanel();
private void performFind();
private void performReplace();
private void performReplaceAll();
private void performClose();
}
NumberDisplayBaseChooser$1
package rars.venus;
synchronized class NumberDisplayBaseChooser$1 implements java.awt.event.ItemListener {
void NumberDisplayBaseChooser$1(NumberDisplayBaseChooser);
public void itemStateChanged(java.awt.event.ItemEvent);
}
MessagesPane$4
package rars.venus;
synchronized class MessagesPane$4 implements Runnable {
void MessagesPane$4(MessagesPane, String);
public void run();
}
DataSegmentWindow$AddressCellRenderer
package rars.venus;
synchronized class DataSegmentWindow$AddressCellRenderer extends javax.swing.table.DefaultTableCellRenderer {
void DataSegmentWindow$AddressCellRenderer(DataSegmentWindow);
public java.awt.Component getTableCellRendererComponent(javax.swing.JTable, Object, boolean, boolean, int, int);
}
DataSegmentWindow$MyTippedJTable
package rars.venus;
synchronized class DataSegmentWindow$MyTippedJTable extends javax.swing.JTable {
private String[] columnToolTips;
void DataSegmentWindow$MyTippedJTable(DataSegmentWindow, DataSegmentWindow$DataTableModel);
protected javax.swing.table.JTableHeader createDefaultTableHeader();
}
MessagesPane$Asker$1
package rars.venus;
synchronized class MessagesPane$Asker$1 implements javax.swing.event.DocumentListener {
void MessagesPane$Asker$1(MessagesPane$Asker);
public void insertUpdate(javax.swing.event.DocumentEvent);
public void removeUpdate(javax.swing.event.DocumentEvent);
public void changedUpdate(javax.swing.event.DocumentEvent);
}
VenusUI$22
package rars.venus;
synchronized class VenusUI$22 extends settings.SettingsAction {
void VenusUI$22(VenusUI, String, String, rars.Settings$Bool);
public void handler(boolean);
}
DataSegmentWindow$5
package rars.venus;
synchronized class DataSegmentWindow$5 implements java.awt.event.ActionListener {
void DataSegmentWindow$5(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
HelpHelpAction$HelpHyperlinkListener$2
package rars.venus;
synchronized class HelpHelpAction$HelpHyperlinkListener$2 implements java.awt.event.ActionListener {
void HelpHelpAction$HelpHyperlinkListener$2(HelpHelpAction$HelpHyperlinkListener);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$1
package rars.venus;
synchronized class DataSegmentWindow$1 implements java.awt.event.ActionListener {
void DataSegmentWindow$1(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
FileDumpMemoryAction$1
package rars.venus;
synchronized class FileDumpMemoryAction$1 extends java.awt.event.WindowAdapter {
void FileDumpMemoryAction$1(FileDumpMemoryAction);
public void windowClosing(java.awt.event.WindowEvent);
}
MessagesPane
package rars.venus;
public synchronized class MessagesPane extends javax.swing.JTabbedPane {
javax.swing.JTextArea assemble;
javax.swing.JTextArea run;
private javax.swing.JPanel assembleTab;
private javax.swing.JPanel runTab;
public static final int MAXIMUM_SCROLLED_CHARACTERS;
public static final int NUMBER_OF_CHARACTERS_TO_CUT;
public void MessagesPane();
private javax.swing.Box createBoxForButton(javax.swing.JButton);
public void selectErrorMessage(String, int, int);
public void selectEditorTextLine(String, int, int);
public javax.swing.JTextArea getAssembleTextArea();
public javax.swing.JTextArea getRunTextArea();
public void postMessage(String);
public void postRunMessage(String);
public void selectMessageTab();
public void selectRunMessageTab();
public String getInputString(String);
public String getInputString(int);
static void
}
EditTabbedPane$FileOpener
package rars.venus;
synchronized class EditTabbedPane$FileOpener {
private java.io.File mostRecentlyOpenedFile;
private javax.swing.JFileChooser fileChooser;
private int fileFilterCount;
private java.util.ArrayList fileFilterList;
private java.beans.PropertyChangeListener listenForUserAddedFileFilter;
private Editor theEditor;
public void EditTabbedPane$FileOpener(EditTabbedPane, Editor);
private boolean openFile();
private boolean openFile(java.io.File);
private void setChoosableFileFilters();
}
TextSegmentWindow
package rars.venus;
public synchronized class TextSegmentWindow extends javax.swing.JInternalFrame implements java.util.Observer {
private javax.swing.JPanel programArgumentsPanel;
private javax.swing.JTextField programArgumentsTextField;
private static final int PROGRAM_ARGUMENT_TEXTFIELD_COLUMNS = 40;
private javax.swing.JTable table;
private javax.swing.JScrollPane tableScroller;
private Object[][] data;
private int[] intAddresses;
private java.util.Hashtable addressRows;
private java.util.Hashtable executeMods;
private java.awt.Container contentPane;
private TextSegmentWindow$TextTableModel tableModel;
private java.awt.Font tableCellFont;
private boolean codeHighlighting;
private boolean breakpointsEnabled;
private int highlightAddress;
private javax.swing.event.TableModelListener tableModelListener;
private static String[] columnNames;
private static final int BREAK_COLUMN = 0;
private static final int ADDRESS_COLUMN = 1;
private static final int CODE_COLUMN = 2;
private static final int BASIC_COLUMN = 3;
private static final int SOURCE_COLUMN = 4;
private static final java.awt.Font monospacedPlain12Point;
private static final String modifiedCodeMarker =—— ;
public void TextSegmentWindow();
public void setupTable();
public String getProgramArguments();
public void addProgramArgumentsPanel();
public void removeProgramArgumentsPanel();
public void clearWindow();
public void registerTableModelListener(javax.swing.event.TableModelListener);
public void updateCodeAddresses();
public void updateBasicStatements();
public void update(java.util.Observable, Object);
public void resetModifiedSourceCode();
int getIntCodeAddressAtRow(int);
public int getBreakpointCount();
public int[] getSortedBreakPointsArray();
public void clearAllBreakpoints();
public void highlightStepAtPC();
public void highlightStepAtAddress(int);
public void setCodeHighlighting(boolean);
public boolean getCodeHighlighting();
public void unhighlightAllSteps();
void selectStepAtAddress(int);
public void toggleBreakpoints();
private void addAsTextSegmentObserver();
private void deleteAsTextSegmentObserver();
private void reorderColumns();
private int findRowForAddress(int) throws IllegalArgumentException;
static void
}
LabelsWindow$LabelAddressAscendingComparator
package rars.venus;
synchronized class LabelsWindow$LabelAddressAscendingComparator implements java.util.Comparator {
private void LabelsWindow$LabelAddressAscendingComparator(LabelsWindow);
public int compare(rars.assembler.Symbol, rars.assembler.Symbol);
}
FileDumpMemoryAction$3
package rars.venus;
synchronized class FileDumpMemoryAction$3 implements java.awt.event.ActionListener {
void FileDumpMemoryAction$3(FileDumpMemoryAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
MessagesPane$2
package rars.venus;
synchronized class MessagesPane$2 extends java.awt.event.MouseAdapter {
void MessagesPane$2(MessagesPane);
public void mouseClicked(java.awt.event.MouseEvent);
}
VenusUI$9
package rars.venus;
synchronized class VenusUI$9 extends GuiAction {
void VenusUI$9(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
LabelsWindow$LabelNameAscendingComparator
package rars.venus;
synchronized class LabelsWindow$LabelNameAscendingComparator implements java.util.Comparator {
private void LabelsWindow$LabelNameAscendingComparator(LabelsWindow);
public int compare(rars.assembler.Symbol, rars.assembler.Symbol);
}
VenusUI$19
package rars.venus;
synchronized class VenusUI$19 extends GuiAction {
void VenusUI$19(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$3
package rars.venus;
synchronized class DataSegmentWindow$3 implements java.awt.event.ActionListener {
void DataSegmentWindow$3(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditTabbedPane$1
package rars.venus;
synchronized class EditTabbedPane$1 implements javax.swing.event.ChangeListener {
void EditTabbedPane$1(EditTabbedPane);
public void stateChanged(javax.swing.event.ChangeEvent);
}
TextSegmentWindow$MyTippedJTable$TextTableHeader
package rars.venus;
synchronized class TextSegmentWindow$MyTippedJTable$TextTableHeader extends javax.swing.table.JTableHeader {
public void TextSegmentWindow$MyTippedJTable$TextTableHeader(TextSegmentWindow$MyTippedJTable, javax.swing.table.TableColumnModel);
public String getToolTipText(java.awt.event.MouseEvent);
}
HelpAboutAction
package rars.venus;
public synchronized class HelpAboutAction extends GuiAction {
private VenusUI mainUI;
public void HelpAboutAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
TextSegmentWindow$TextTableModel
package rars.venus;
synchronized class TextSegmentWindow$TextTableModel extends javax.swing.table.AbstractTableModel {
Object[][] data;
public void TextSegmentWindow$TextTableModel(TextSegmentWindow, Object[][]);
public int getColumnCount();
public int getRowCount();
public String getColumnName(int);
public Object getValueAt(int, int);
public Class getColumnClass(int);
public boolean isCellEditable(int, int);
public void setValueAt(Object, int, int);
private void printDebugData();
}
LabelsWindow$LabelTableModel
package rars.venus;
synchronized class LabelsWindow$LabelTableModel extends javax.swing.table.AbstractTableModel {
String[] columns;
Object[][] data;
public void LabelsWindow$LabelTableModel(LabelsWindow, Object[][], String[]);
public int getColumnCount();
public int getRowCount();
public String getColumnName(int);
public Object getValueAt(int, int);
public Class getColumnClass(int);
public void setValueAt(Object, int, int);
private void printDebugData();
}
FileDumpMemoryAction$4
package rars.venus;
synchronized class FileDumpMemoryAction$4 implements java.awt.event.ActionListener {
void FileDumpMemoryAction$4(FileDumpMemoryAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
MainPane
package rars.venus;
public synchronized class MainPane extends javax.swing.JTabbedPane {
EditPane editTab;
ExecutePane executeTab;
EditTabbedPane editTabbedPane;
private VenusUI mainUI;
public void MainPane(VenusUI, Editor, registers.RegistersWindow, registers.FloatingPointWindow, registers.ControlAndStatusWindow);
public EditPane getEditPane();
public javax.swing.JComponent getEditTabbedPane();
public ExecutePane getExecutePane();
public ExecutePane getExecuteTab();
}
DataSegmentWindow$4
package rars.venus;
synchronized class DataSegmentWindow$4 implements java.awt.event.ActionListener {
void DataSegmentWindow$4(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
VenusUI$23
package rars.venus;
synchronized class VenusUI$23 extends settings.SettingsAction {
void VenusUI$23(VenusUI, String, String, rars.Settings$Bool);
public void handler(boolean);
}
HelpHelpAction$HelpHyperlinkListener
package rars.venus;
synchronized class HelpHelpAction$HelpHyperlinkListener implements javax.swing.event.HyperlinkListener {
javax.swing.JDialog webpageDisplay;
javax.swing.JTextField webpageURL;
private static final String cannotDisplayMessage =
private void HelpHelpAction$HelpHyperlinkListener(HelpHelpAction);
public void hyperlinkUpdate(javax.swing.event.HyperlinkEvent);
}
VenusUI$21
package rars.venus;
synchronized class VenusUI$21 extends settings.SettingsAction {
void VenusUI$21(VenusUI, String, String, rars.Settings$Bool);
public void handler(boolean);
}
DataSegmentWindow
package rars.venus;
public synchronized class DataSegmentWindow extends javax.swing.JInternalFrame implements java.util.Observer {
private static final String[] dataSegmentNames;
private static Object[][] dataData;
private static javax.swing.JTable dataTable;
private javax.swing.JScrollPane dataTableScroller;
private java.awt.Container contentPane;
private javax.swing.JPanel tablePanel;
private javax.swing.JButton dataButton;
private javax.swing.JButton nextButton;
private javax.swing.JButton prevButton;
private javax.swing.JButton stakButton;
private javax.swing.JButton globButton;
private javax.swing.JButton heapButton;
private javax.swing.JButton extnButton;
private javax.swing.JButton mmioButton;
private javax.swing.JButton textButton;
private javax.swing.JCheckBox asciiDisplayCheckBox;
private static final int VALUES_PER_ROW = 8;
private static final int NUMBER_OF_ROWS = 16;
private static final int NUMBER_OF_COLUMNS = 9;
private static final int BYTES_PER_VALUE = 4;
private static final int BYTES_PER_ROW = 32;
private static final int MEMORY_CHUNK_SIZE = 512;
private static final int PREV_NEXT_CHUNK_SIZE = 256;
private static final int ADDRESS_COLUMN = 0;
private static final boolean USER_MODE = 0;
private static final boolean KERNEL_MODE = 1;
private boolean addressHighlighting;
private boolean asciiDisplay;
private int addressRow;
private int addressColumn;
private int addressRowFirstAddress;
private rars.Settings settings;
private int firstAddress;
private int homeAddress;
private boolean userOrKernelMode;
private javax.swing.JComboBox baseAddressSelector;
private String[] displayBaseAddressChoices;
private int[] displayBaseAddresses;
private int defaultBaseAddressIndex;
private javax.swing.JButton[] baseAddressButtons;
private static final int EXTERN_BASE_ADDRESS_INDEX = 0;
private static final int GLOBAL_POINTER_ADDRESS_INDEX = 3;
private static final int TEXT_BASE_ADDRESS_INDEX = 5;
private static final int DATA_BASE_ADDRESS_INDEX = 1;
private static final int HEAP_BASE_ADDRESS_INDEX = 2;
private static final int STACK_POINTER_BASE_ADDRESS_INDEX = 4;
private static final int MMIO_BASE_ADDRESS_INDEX = 6;
private int[] displayBaseAddressArray;
String[] descriptions;
public void DataSegmentWindow(NumberDisplayBaseChooser[]);
public void updateBaseAddressComboBox();
void selectCellForAddress(int);
public void highlightCellForAddress(int);
private java.awt.Point displayCellForAddress(int);
private void initializeBaseAddressChoices();
private String[] createBaseAddressLabelsArray(int[], String[]);
private int getBaseAddressIndexForAddress(int);
private javax.swing.JScrollPane generateDataPanel();
private String getHeaderStringForColumn(int, int);
public void setupTable();
public void clearWindow();
public void clearHighlighting();
private int getValueDisplayFormat();
public void updateModelForMemoryRange(int);
public void updateCell(int, int);
public void updateDataAddresses();
public void updateValues();
public void resetMemoryRange();
public void resetValues();
private void disableAllButtons();
private void enableAllButtons();
private void addButtonActionListenersAndInitialize();
private int setFirstAddressAndPrevNextButtonEnableStatus(int);
public void update(java.util.Observable, Object);
static void
}
MessagesPane$Asker$2
package rars.venus;
synchronized class MessagesPane$Asker$2 extends javax.swing.text.NavigationFilter {
void MessagesPane$Asker$2(MessagesPane$Asker);
public void moveDot(javax.swing.text.NavigationFilter$FilterBypass, int, javax.swing.text.Position$Bias);
public void setDot(javax.swing.text.NavigationFilter$FilterBypass, int, javax.swing.text.Position$Bias);
}
RunGoAction$1
package rars.venus.run;
synchronized class RunGoAction$1 implements java.util.Observer {
void RunGoAction$1(RunGoAction);
public void update(java.util.Observable, Object);
}
RunStepAction
package rars.venus.run;
public synchronized class RunStepAction extends rars.venus.GuiAction {
private String name;
private rars.venus.ExecutePane executePane;
private rars.venus.VenusUI mainUI;
public void RunStepAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, rars.venus.VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
public void stepped(boolean, rars.simulator.Simulator$Reason, rars.SimulationException);
private void processProgramArgumentsIfAny();
}
RunGoAction$2
package rars.venus.run;
synchronized class RunGoAction$2 {
static void
}
RunAssembleAction
package rars.venus.run;
public synchronized class RunAssembleAction extends rars.venus.GuiAction {
private static java.util.ArrayList programsToAssemble;
private static boolean extendedAssemblerEnabled;
private static boolean warningsAreErrors;
private static final int LINE_LENGTH_LIMIT = 60;
private rars.venus.VenusUI mainUI;
public void RunAssembleAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, rars.venus.VenusUI);
public static java.util.ArrayList getProgramsToAssemble();
static boolean getExtendedAssemblerEnabled();
static boolean getWarningsAreErrors();
public void actionPerformed(java.awt.event.ActionEvent);
private String buildFileNameList(String, java.util.ArrayList);
}
RunStepAction$1
package rars.venus.run;
synchronized class RunStepAction$1 implements java.util.Observer {
void RunStepAction$1(RunStepAction);
public void update(java.util.Observable, Object);
}
RunClearBreakpointsAction
package rars.venus.run;
public synchronized class RunClearBreakpointsAction extends rars.venus.GuiAction implements javax.swing.event.TableModelListener {
public void RunClearBreakpointsAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
public void tableChanged(javax.swing.event.TableModelEvent);
}
RunBackstepAction
package rars.venus.run;
public synchronized class RunBackstepAction extends rars.venus.GuiAction {
private String name;
private rars.venus.ExecutePane executePane;
private rars.venus.VenusUI mainUI;
public void RunBackstepAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, rars.venus.VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
RunSpeedPanel$RunSpeedListener
package rars.venus.run;
synchronized class RunSpeedPanel$RunSpeedListener implements javax.swing.event.ChangeListener {
private void RunSpeedPanel$RunSpeedListener(RunSpeedPanel);
public void stateChanged(javax.swing.event.ChangeEvent);
}
RunSpeedPanel
package rars.venus.run;
public synchronized class RunSpeedPanel extends javax.swing.JPanel {
public static final double UNLIMITED_SPEED = 40.0;
private static final int SPEED_INDEX_MIN = 0;
private static final int SPEED_INDEX_MAX = 40;
private static final int SPEED_INDEX_INIT = 40;
private static final int SPEED_INDEX_INTERACTION_LIMIT = 35;
private double[] speedTable;
private javax.swing.JLabel sliderLabel;
private javax.swing.JSlider runSpeedSlider;
private static RunSpeedPanel runSpeedPanel;
private volatile int runSpeedIndex;
public static RunSpeedPanel getInstance();
private void RunSpeedPanel();
public double getRunSpeed();
private String setLabel(int);
static void
}
RunGoAction
package rars.venus.run;
public synchronized class RunGoAction extends rars.venus.GuiAction {
public static int defaultMaxSteps;
public static int maxSteps;
private String name;
private rars.venus.ExecutePane executePane;
private rars.venus.VenusUI mainUI;
public void RunGoAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, rars.venus.VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
public void paused(boolean, rars.simulator.Simulator$Reason, rars.SimulationException);
public void stopped(rars.SimulationException, rars.simulator.Simulator$Reason);
public static void resetMaxSteps();
private void processProgramArgumentsIfAny();
static void
}
RunResetAction
package rars.venus.run;
public synchronized class RunResetAction extends rars.venus.GuiAction {
private rars.venus.VenusUI mainUI;
public void RunResetAction(String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke, rars.venus.VenusUI);
public void actionPerformed(java.awt.event.ActionEvent);
}
Editor
package rars.venus;
public synchronized class Editor {
public static final int MIN_TAB_SIZE = 1;
public static final int MAX_TAB_SIZE = 32;
public static final int MIN_BLINK_RATE = 0;
public static final int MAX_BLINK_RATE = 1000;
private VenusUI mainUI;
private EditTabbedPane editTabbedPane;
private String mainUIbaseTitle;
private int newUsageCount;
private String defaultOpenDirectory;
private String currentOpenDirectory;
private String defaultSaveDirectory;
private String currentSaveDirectory;
public void Editor(VenusUI);
public String[] getOpenFilePaths();
public void setEditTabbedPane(EditTabbedPane);
public String getCurrentOpenDirectory();
void setCurrentOpenDirectory(String);
public String getCurrentSaveDirectory();
void setCurrentSaveDirectory(String);
public String getNextDefaultFilename();
public void setTitle(String, String, int);
public void newFile();
public boolean close();
public boolean closeAll();
public boolean save();
public boolean saveAs();
public boolean saveAll();
public boolean open();
public boolean editsSavedOrAbandoned();
}
DataSegmentWindow$6
package rars.venus;
synchronized class DataSegmentWindow$6 implements java.awt.event.ActionListener {
void DataSegmentWindow$6(DataSegmentWindow);
public void actionPerformed(java.awt.event.ActionEvent);
}
LabelsWindow$DescendingComparator
package rars.venus;
synchronized class LabelsWindow$DescendingComparator implements java.util.Comparator {
private java.util.Comparator opposite;
private void LabelsWindow$DescendingComparator(LabelsWindow, java.util.Comparator);
public int compare(rars.assembler.Symbol, rars.assembler.Symbol);
}
ToolAction
package rars.venus;
public synchronized class ToolAction extends javax.swing.AbstractAction {
private rars.tools.Tool tool;
public void ToolAction(rars.tools.Tool);
public void actionPerformed(java.awt.event.ActionEvent);
}
TextSegmentWindow$MyTippedJTable$TextTableHeader$TextTableHeaderMouseListener
package rars.venus;
synchronized class TextSegmentWindow$MyTippedJTable$TextTableHeader$TextTableHeaderMouseListener implements java.awt.event.MouseListener {
private void TextSegmentWindow$MyTippedJTable$TextTableHeader$TextTableHeaderMouseListener(TextSegmentWindow$MyTippedJTable$TextTableHeader);
public void mouseClicked(java.awt.event.MouseEvent);
public void mouseEntered(java.awt.event.MouseEvent);
public void mouseExited(java.awt.event.MouseEvent);
public void mousePressed(java.awt.event.MouseEvent);
public void mouseReleased(java.awt.event.MouseEvent);
}
TextSegmentWindow$ModifiedCode
package rars.venus;
synchronized class TextSegmentWindow$ModifiedCode {
private Integer row;
private Object code;
private Object basic;
private Object source;
private void TextSegmentWindow$ModifiedCode(TextSegmentWindow, Integer, Object, Object, Object);
private Integer getRow();
private Object getCode();
private Object getBasic();
private Object getSource();
}
MessagesPane$3
package rars.venus;
synchronized class MessagesPane$3 implements java.awt.event.ActionListener {
void MessagesPane$3(MessagesPane);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditTabbedPane$FileOpener$ChoosableFileFilterChangeListener
package rars.venus;
synchronized class EditTabbedPane$FileOpener$ChoosableFileFilterChangeListener implements java.beans.PropertyChangeListener {
private void EditTabbedPane$FileOpener$ChoosableFileFilterChangeListener(EditTabbedPane$FileOpener);
public void propertyChange(java.beans.PropertyChangeEvent);
}
DataSegmentWindow$CustomComboBoxModel
package rars.venus;
synchronized class DataSegmentWindow$CustomComboBoxModel extends javax.swing.DefaultComboBoxModel {
public void DataSegmentWindow$CustomComboBoxModel(DataSegmentWindow, String[]);
private void forceComboBoxUpdate(int);
}
FileDumpMemoryAction$2
package rars.venus;
synchronized class FileDumpMemoryAction$2 implements java.awt.event.ActionListener {
void FileDumpMemoryAction$2(FileDumpMemoryAction);
public void actionPerformed(java.awt.event.ActionEvent);
}
HelpHelpAction$HelpHyperlinkListener$1
package rars.venus;
synchronized class HelpHelpAction$HelpHyperlinkListener$1 implements javax.swing.event.HyperlinkListener {
void HelpHelpAction$HelpHyperlinkListener$1(HelpHelpAction$HelpHyperlinkListener);
public void hyperlinkUpdate(javax.swing.event.HyperlinkEvent);
}
VenusUI$18
package rars.venus;
synchronized class VenusUI$18 extends GuiAction {
void VenusUI$18(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
DataSegmentWindow$2
package rars.venus;
synchronized class DataSegmentWindow$2 implements java.awt.event.ItemListener {
void DataSegmentWindow$2(DataSegmentWindow);
public void itemStateChanged(java.awt.event.ItemEvent);
}
VenusUI$8
package rars.venus;
synchronized class VenusUI$8 extends GuiAction {
void VenusUI$8(VenusUI, String, javax.swing.Icon, String, Integer, javax.swing.KeyStroke);
public void actionPerformed(java.awt.event.ActionEvent);
}
EditPane
package rars.venus;
public synchronized class EditPane extends javax.swing.JPanel implements java.util.Observer {
private editors.TextEditingArea sourceCode;
private VenusUI mainUI;
private String currentDirectoryPath;
private javax.swing.JLabel caretPositionLabel;
private javax.swing.JCheckBox showLineNumbers;
private javax.swing.JLabel lineNumbers;
private static int count;
private boolean isCompoundEdit;
private javax.swing.undo.CompoundEdit compoundEdit;
private FileStatus fileStatus;
private static final String spaces = ;
private static final char newline = 10;
public void EditPane(VenusUI);
public void setSourceCode(String, boolean);
public void discardAllUndoableEdits();
public String getLineNumbersList(javax.swing.text.Document);
public int getSourceLineCount();
public String getSource();
public void setFileStatus(int);
public int getFileStatus();
public String getFilename();
public String getPathname();
public void setPathname(String);
public boolean hasUnsavedEdits();
public boolean isNew();
public void tellEditingComponentToRequestFocusInWindow();
public void updateStaticFileStatus();
public javax.swing.undo.UndoManager getUndoManager();
public void copyText();
public void cutText();
public void pasteText();
public void selectAllText();
public void undo();
public void redo();
public void updateUndoAndRedoState();
public boolean showingLineNumbers();
public void setShowLineNumbersEnabled(boolean);
public void displayCaretPosition(int);
public void displayCaretPosition(java.awt.Point);
public java.awt.Point convertStreamPositionToLineColumn(int);
public int convertLineColumnToStreamPosition(int, int);
public void selectLine(int);
public void selectLine(int, int);
public int doFindText(String, boolean);
public int doReplace(String, String, boolean);
public int doReplaceAll(String, String, boolean);
public void update(java.util.Observable, Object);
private java.awt.Font getLineNumberFont(java.awt.Font);
static void
}
MessagesPane$Asker$4
package rars.venus;
synchronized class MessagesPane$Asker$4 implements Runnable {
void MessagesPane$Asker$4(MessagesPane$Asker);
public void run();
}
MessagesPane$1
package rars.venus;
synchronized class MessagesPane$1 implements java.awt.event.ActionListener {
void MessagesPane$1(MessagesPane);
public void actionPerformed(java.awt.event.ActionEvent);
}
Launch$1
package rars;
synchronized class Launch$1 implements Runnable {
void Launch$1(Launch);
public void run();
}
ProgramStatement$BasicStatementList$ListElement
package rars;
synchronized class ProgramStatement$BasicStatementList$ListElement {
int type;
String sValue;
int iValue;
void ProgramStatement$BasicStatementList$ListElement(ProgramStatement$BasicStatementList, int, String, int);
}
ErrorList
package rars;
public synchronized class ErrorList {
private java.util.ArrayList messages;
private int errorCount;
private int warningCount;
public static final String ERROR_MESSAGE_PREFIX = Error;
public static final String WARNING_MESSAGE_PREFIX = Warning;
public static final String FILENAME_PREFIX =in ;
public static final String LINE_PREFIX =line ;
public static final String POSITION_PREFIX =column ;
public static final String MESSAGE_SEPARATOR = : ;
public void ErrorList();
public java.util.ArrayList getErrorMessages();
public boolean errorsOccurred();
public boolean warningsOccurred();
public void add(ErrorMessage);
public void add(ErrorMessage, int);
public int errorCount();
public int warningCount();
public boolean errorLimitExceeded();
public int getErrorLimit();
public String generateErrorReport();
public String generateWarningReport();
public String generateErrorAndWarningReport();
private String generateReport(boolean);
}
WaitException
package rars;
public synchronized class WaitException extends SimulationException {
public void WaitException();
}
Globals
package rars;
public synchronized class Globals {
private static String configPropertiesFile;
private static String syscallPropertiesFile;
public static riscv.InstructionSet instructionSet;
public static RISCVprogram program;
public static assembler.SymbolTable symbolTable;
public static riscv.hardware.Memory memory;
public static final java.util.concurrent.locks.ReentrantLock memoryAndRegistersLock;
public static boolean debug;
static Settings settings;
public static String userInputAlert;
public static final String imagesPath = /images/;
public static final String helpPath = /help/;
private static boolean initialized;
static venus.VenusUI gui;
public static final String version = 1.3;
public static final java.util.ArrayList fileExtensions;
public static final int maximumMessageCharacters;
public static final int maximumErrorMessages;
public static final int maximumBacksteps;
public static final String copyrightYears;
public static final String copyrightHolders;
public static final String ASCII_NON_PRINT;
public static final String[] ASCII_TABLE;
public static int exitCode;
public static boolean runSpeedPanelExists;
public void Globals();
private static String getCopyrightYears();
private static String getCopyrightHolders();
public static void setGui(venus.VenusUI);
public static venus.VenusUI getGui();
public static Settings getSettings();
public static void initialize(boolean);
private static int getMessageLimit();
private static int getErrorLimit();
private static int getBackstepLimit();
public static String getAsciiNonPrint();
public static String[] getAsciiStrings();
private static int getIntegerProperty(String, String, int);
private static java.util.ArrayList getFileExtensions();
public static String getPropertyEntry(String, String);
public java.util.ArrayList getSyscallOverrides();
static void
}
SimulationException
package rars;
public synchronized class SimulationException extends Exception {
public static final int SOFTWARE_INTERRUPT = -2147483648;
public static final int TIMER_INTERRUPT = -2147483644;
public static final int EXTERNAL_INTERRUPT = -2147483640;
public static final int INSTRUCTION_ADDR_MISALIGNED = 0;
public static final int INSTRUCTION_ACCESS_FAULT = 1;
public static final int ILLEGAL_INSTRUCTION = 2;
public static final int LOAD_ADDRESS_MISALIGNED = 4;
public static final int LOAD_ACCESS_FAULT = 5;
public static final int STORE_ADDRESS_MISALIGNED = 6;
public static final int STORE_ACCESS_FAULT = 7;
public static final int ENVIRONMENT_CALL = 8;
private int cause;
private int value;
private ErrorMessage message;
public void SimulationException();
public void SimulationException(ProgramStatement, String, int);
public void SimulationException(ProgramStatement, String);
public void SimulationException(ProgramStatement, riscv.hardware.AddressErrorException);
public void SimulationException(String);
public void SimulationException(String, int);
public ErrorMessage error();
public int cause();
public int value();
}
BackStepper$Action
package rars.simulator;
final synchronized enum BackStepper$Action {
public static final BackStepper$Action MEMORY_RESTORE_RAW_WORD;
public static final BackStepper$Action MEMORY_RESTORE_WORD;
public static final BackStepper$Action MEMORY_RESTORE_HALF;
public static final BackStepper$Action MEMORY_RESTORE_BYTE;
public static final BackStepper$Action REGISTER_RESTORE;
public static final BackStepper$Action PC_RESTORE;
public static final BackStepper$Action CONTROL_AND_STATUS_REGISTER_RESTORE;
public static final BackStepper$Action CONTROL_AND_STATUS_REGISTER_BACKDOOR;
public static final BackStepper$Action FLOATING_POINT_REGISTER_RESTORE;
public static final BackStepper$Action DO_NOTHING;
public static BackStepper$Action[] values();
public static BackStepper$Action valueOf(String);
private void BackStepper$Action(String, int);
static void
}
BackStepper
package rars.simulator;
public synchronized class BackStepper {
private static final int NOT_PC_VALUE = -1;
private boolean engaged;
private final BackStepper$BackstepStack backSteps;
public void BackStepper();
public boolean enabled();
public void setEnabled(boolean);
public boolean empty();
public void backStep();
private int pc();
public int addMemoryRestoreRawWord(int, int);
public int addMemoryRestoreWord(int, int);
public int addMemoryRestoreHalf(int, int);
public int addMemoryRestoreByte(int, int);
public int addRegisterFileRestore(int, int);
public int addPCRestore(int);
public int addControlAndStatusRestore(int, int);
public int addControlAndStatusBackdoor(int, int);
public int addFloatingPointRestore(int, int);
public void addDoNothing(int);
}
Simulator
package rars.simulator;
public synchronized class Simulator extends java.util.Observable {
private Simulator$SimThread simulatorThread;
private static Simulator simulator;
private static Runnable interactiveGUIUpdater;
private java.util.ArrayList stopListeners;
public static Simulator getInstance();
private void Simulator();
public Simulator$Reason simulate(int, int, int[]) throws rars.SimulationException;
public void startSimulation(int, int, int[]);
private void interruptExecution(Simulator$Reason);
public void stopExecution();
public void pauseExecution();
public void addStopListener(Simulator$StopListener);
public void removeStopListener(Simulator$StopListener);
private void notifyObserversOfExecution(SimulatorNotice);
public void interrupt();
static void
}
Simulator$SimThread
package rars.simulator;
synchronized class Simulator$SimThread implements Runnable {
private int pc;
private int maxSteps;
private int[] breakPoints;
private boolean done;
private rars.SimulationException pe;
private volatile boolean stop;
private Simulator$Reason constructReturnReason;
void Simulator$SimThread(Simulator, int, int, int[]);
public synchronized void setStop(Simulator$Reason);
private void startExecution();
private void stopExecution(boolean, Simulator$Reason);
private synchronized void interrupt();
private boolean handleTrap(rars.SimulationException, int);
private boolean handleInterrupt(int, int, int);
public void run();
static void
}
Simulator$StopListener
package rars.simulator;
public abstract interface Simulator$StopListener {
public abstract void stopped(Simulator);
}
Simulator$Reason
package rars.simulator;
public final synchronized enum Simulator$Reason {
public static final Simulator$Reason BREAKPOINT;
public static final Simulator$Reason EXCEPTION;
public static final Simulator$Reason MAX_STEPS;
public static final Simulator$Reason NORMAL_TERMINATION;
public static final Simulator$Reason CLIFF_TERMINATION;
public static final Simulator$Reason PAUSE;
public static final Simulator$Reason STOP;
public static Simulator$Reason[] values();
public static Simulator$Reason valueOf(String);
private void Simulator$Reason(String, int);
static void
}
BackStepper$BackstepStack
package rars.simulator;
synchronized class BackStepper$BackstepStack {
private final int capacity;
private int size;
private int top;
private final BackStepper$BackStep[] stack;
private void BackStepper$BackstepStack(BackStepper, int);
private synchronized boolean empty();
private synchronized void push(BackStepper$Action, int, int, int);
private synchronized void push(BackStepper$Action, int, int);
private synchronized void push(BackStepper$Action, int);
private synchronized BackStepper$BackStep pop();
private synchronized BackStepper$BackStep peek();
}
BackStepper$1
package rars.simulator;
synchronized class BackStepper$1 {
static void
}
BackStepper$BackStep
package rars.simulator;
synchronized class BackStepper$BackStep {
private BackStepper$Action action;
private int pc;
private rars.ProgramStatement ps;
private int param1;
private int param2;
private void BackStepper$BackStep(BackStepper);
private void assign(BackStepper$Action, int, int, int);
}
ProgramArgumentList
package rars.simulator;
public synchronized class ProgramArgumentList {
private java.util.ArrayList programArgumentList;
public void ProgramArgumentList(String);
public void ProgramArgumentList(String[]);
public void ProgramArgumentList(String[], int);
public void ProgramArgumentList(java.util.ArrayList);
public void ProgramArgumentList(java.util.ArrayList, int);
public void storeProgramArguments();
}
Simulator$UpdateGUI
package rars.simulator;
synchronized class Simulator$UpdateGUI implements Runnable {
private void Simulator$UpdateGUI(Simulator);
public void run();
}
SimulatorNotice
package rars.simulator;
public synchronized class SimulatorNotice {
private int action;
private int maxSteps;
private Simulator$Reason reason;
private boolean done;
private rars.SimulationException exception;
private double runSpeed;
private int programCounter;
public static final int SIMULATOR_START = 0;
public static final int SIMULATOR_STOP = 1;
public void SimulatorNotice(int, int, double, int, Simulator$Reason, rars.SimulationException, boolean);
public int getAction();
public int getMaxSteps();
public double getRunSpeed();
public int getProgramCounter();
public Simulator$Reason getReason();
public rars.SimulationException getException();
public boolean getDone();
public String toString();
}
BreakpointException
package rars;
public synchronized class BreakpointException extends SimulationException {
public void BreakpointException();
}
ErrorMessage
package rars;
public synchronized class ErrorMessage {
private boolean isWarning;
private String filename;
private int line;
private int position;
private String message;
private String macroExpansionHistory;
public static final boolean WARNING = 1;
public static final boolean ERROR = 0;
public void ErrorMessage(RISCVprogram, int, int, String);
public void ErrorMessage(boolean, RISCVprogram, int, int, String);
public void ErrorMessage(ProgramStatement, String);
private java.util.ArrayList parseMacroHistory(String);
public String getFilename();
public int getLine();
public int getPosition();
public String getMessage();
public boolean isWarning();
public String generateReport();
public String getMacroExpansionHistory();
private static String getExpansionHistory(RISCVprogram);
}
Settings
package rars;
public synchronized class Settings extends java.util.Observable {
private static String settingsFile;
public static final int EXCEPTION_HANDLER = 0;
public static final int TEXT_COLUMN_ORDER = 1;
public static final int LABEL_SORT_STATE = 2;
public static final int MEMORY_CONFIGURATION = 3;
public static final int CARET_BLINK_RATE = 4;
public static final int EDITOR_TAB_SIZE = 5;
public static final int EDITOR_POPUP_PREFIX_LENGTH = 6;
private static final String[] stringSettingsKeys;
private static String[] defaultStringSettingsValues;
public static final int EDITOR_FONT = 0;
public static final int EVEN_ROW_FONT = 1;
public static final int ODD_ROW_FONT = 2;
public static final int TEXTSEGMENT_HIGHLIGHT_FONT = 3;
public static final int TEXTSEGMENT_DELAYSLOT_HIGHLIGHT_FONT = 4;
public static final int DATASEGMENT_HIGHLIGHT_FONT = 5;
public static final int REGISTER_HIGHLIGHT_FONT = 6;
private static final String[] fontFamilySettingsKeys;
private static final String[] fontStyleSettingsKeys;
private static final String[] fontSizeSettingsKeys;
private static final String[] defaultFontFamilySettingsValues;
private static final String[] defaultFontStyleSettingsValues;
private static final String[] defaultFontSizeSettingsValues;
public static final int EVEN_ROW_BACKGROUND = 0;
public static final int EVEN_ROW_FOREGROUND = 1;
public static final int ODD_ROW_BACKGROUND = 2;
public static final int ODD_ROW_FOREGROUND = 3;
public static final int TEXTSEGMENT_HIGHLIGHT_BACKGROUND = 4;
public static final int TEXTSEGMENT_HIGHLIGHT_FOREGROUND = 5;
public static final int TEXTSEGMENT_DELAYSLOT_HIGHLIGHT_BACKGROUND = 6;
public static final int TEXTSEGMENT_DELAYSLOT_HIGHLIGHT_FOREGROUND = 7;
public static final int DATASEGMENT_HIGHLIGHT_BACKGROUND = 8;
public static final int DATASEGMENT_HIGHLIGHT_FOREGROUND = 9;
public static final int REGISTER_HIGHLIGHT_BACKGROUND = 10;
public static final int REGISTER_HIGHLIGHT_FOREGROUND = 11;
private static final String[] colorSettingsKeys;
private static String[] defaultColorSettingsValues;
private java.util.HashMap booleanSettingsValues;
private String[] stringSettingsValues;
private String[] fontFamilySettingsValues;
private String[] fontStyleSettingsValues;
private String[] fontSizeSettingsValues;
private String[] colorSettingsValues;
private java.util.prefs.Preferences preferences;
private String[] syntaxStyleColorSettingsValues;
private boolean[] syntaxStyleBoldSettingsValues;
private boolean[] syntaxStyleItalicSettingsValues;
private static final String SYNTAX_STYLE_COLOR_PREFIX = SyntaxStyleColor_;
private static final String SYNTAX_STYLE_BOLD_PREFIX = SyntaxStyleBold_;
private static final String SYNTAX_STYLE_ITALIC_PREFIX = SyntaxStyleItalic_;
private static String[] syntaxStyleColorSettingsKeys;
private static String[] syntaxStyleBoldSettingsKeys;
private static String[] syntaxStyleItalicSettingsKeys;
private static String[] defaultSyntaxStyleColorSettingsValues;
private static boolean[] defaultSyntaxStyleBoldSettingsValues;
private static boolean[] defaultSyntaxStyleItalicSettingsValues;
public void Settings();
public void Settings(boolean);
public boolean getBackSteppingEnabled();
public void reset(boolean);
public void setEditorSyntaxStyleByPosition(int, venus.editors.jeditsyntax.SyntaxStyle);
public venus.editors.jeditsyntax.SyntaxStyle getEditorSyntaxStyleByPosition(int);
public venus.editors.jeditsyntax.SyntaxStyle getDefaultEditorSyntaxStyleByPosition(int);
private void saveEditorSyntaxStyle(int);
private void initializeEditorSyntaxStyles();
private void getEditorSyntaxStyleSettingsFromPreferences();
public boolean getBooleanSetting(Settings$Bool);
public String getExceptionHandler();
public String getMemoryConfiguration();
public java.awt.Font getEditorFont();
public java.awt.Font getFontByPosition(int);
public java.awt.Font getDefaultFontByPosition(int);
public int[] getTextColumnOrder();
public int getCaretBlinkRate();
public int getEditorTabSize();
public int getEditorPopupPrefixLength();
public int getDefaultEditorTabSize();
public String getLabelSortState();
public java.awt.Color getColorSettingByKey(String);
public java.awt.Color getDefaultColorSettingByKey(String);
public java.awt.Color getColorSettingByPosition(int);
public java.awt.Color getDefaultColorSettingByPosition(int);
public void setBooleanSetting(Settings$Bool, boolean);
public void setBooleanSettingNonPersistent(Settings$Bool, boolean);
public void setExceptionHandler(String);
public void setMemoryConfiguration(String);
public void setCaretBlinkRate(int);
public void setEditorTabSize(int);
public void setEditorPopupPrefixLength(int);
public void setEditorFont(java.awt.Font);
public void setFontByPosition(int, java.awt.Font);
public void setTextColumnOrder(int[]);
public void setLabelSortState(String);
public void setColorSettingByKey(String, java.awt.Color);
public void setColorSettingByPosition(int, java.awt.Color);
private void initialize();
private void applyDefaultSettings();
private void internalSetBooleanSetting(Settings$Bool, boolean);
private void setStringSetting(int, String);
private void setColorSetting(int, java.awt.Color);
private java.awt.Color getColorValueByKey(String, String[]);
private java.awt.Color getColorValueByPosition(int, String[]);
private boolean readSettingsFromPropertiesFile(String);
private void getSettingsFromPreferences();
private void saveBooleanSetting(String, boolean);
private void saveStringSetting(int);
private void saveFontSetting(int, String[], String[]);
private void saveColorSetting(int);
private int[] getTextSegmentColumnOrder(String);
static void
}
RISCVprogram
package rars;
public synchronized class RISCVprogram {
private boolean steppedExecution;
private String filename;
private java.util.ArrayList sourceList;
private java.util.ArrayList tokenList;
private java.util.ArrayList parsedList;
private java.util.ArrayList machineList;
private simulator.BackStepper backStepper;
private assembler.SymbolTable localSymbolTable;
private assembler.MacroPool macroPool;
private java.util.ArrayList sourceLineList;
private assembler.Tokenizer tokenizer;
public void RISCVprogram();
public java.util.ArrayList getSourceList();
public void setSourceLineList(java.util.ArrayList);
public java.util.ArrayList getSourceLineList();
public String getFilename();
public java.util.ArrayList getTokenList();
public assembler.Tokenizer getTokenizer();
public java.util.ArrayList createParsedList();
public java.util.ArrayList getParsedList();
public java.util.ArrayList getMachineList();
public simulator.BackStepper getBackStepper();
public assembler.SymbolTable getLocalSymbolTable();
public boolean backSteppingEnabled();
public String getSourceLine(int);
public void fromString(String);
public void readSource(String) throws AssemblyException;
public void tokenize() throws AssemblyException;
public java.util.ArrayList prepareFilesForAssembly(java.util.ArrayList, String, String) throws AssemblyException;
public ErrorList assemble(java.util.ArrayList, boolean) throws AssemblyException;
public ErrorList assemble(java.util.ArrayList, boolean, boolean) throws AssemblyException;
public simulator.Simulator$Reason simulate(int) throws SimulationException;
public void startSimulation(int, int[]);
public assembler.MacroPool createMacroPool();
public assembler.MacroPool getLocalMacroPool();
public void setLocalMacroPool(assembler.MacroPool);
}
Options
package rars.api;
public synchronized class Options {
public boolean pseudo;
public boolean warningsAreErrors;
public boolean startAtMain;
public boolean selfModifyingCode;
public int maxSteps;
public void Options();
}
Program
package rars.api;
public synchronized class Program {
private Options set;
private rars.RISCVprogram code;
private rars.util.SystemIO$Data fds;
private java.io.ByteArrayOutputStream stdout;
private java.io.ByteArrayOutputStream stderr;
private rars.riscv.hardware.Memory assembled;
private rars.riscv.hardware.Memory simulation;
private int startPC;
private int exitCode;
public void Program();
public void Program(Options);
public rars.ErrorList assemble(java.util.ArrayList, String) throws rars.AssemblyException;
public rars.ErrorList assemble(String) throws rars.AssemblyException;
public rars.ErrorList assembleString(String) throws rars.AssemblyException;
private rars.ErrorList assemble(java.util.ArrayList) throws rars.AssemblyException;
public void setup(java.util.ArrayList, String);
public rars.simulator.Simulator$Reason simulate() throws rars.SimulationException;
public String getSTDOUT();
public String getSTDERR();
public int getRegisterValue(String);
public void setRegisterValue(String, int);
public int getExitCode();
public rars.riscv.hardware.Memory getMemory();
}
ProgramStatement
package rars;
public synchronized class ProgramStatement implements Comparable {
private RISCVprogram sourceProgram;
private String source;
private String basicAssemblyStatement;
private String machineStatement;
private assembler.TokenList originalTokenList;
private assembler.TokenList strippedTokenList;
private ProgramStatement$BasicStatementList basicStatementList;
private int[] operands;
private int numOperands;
private riscv.Instruction instruction;
private int textAddress;
private int sourceLine;
private int binaryStatement;
private boolean altered;
private static final String invalidOperator =
public void ProgramStatement(RISCVprogram, String, assembler.TokenList, assembler.TokenList, riscv.Instruction, int, int);
public void ProgramStatement(int, int);
public int compareTo(ProgramStatement);
public void buildBasicStatementFromBasicInstruction(ErrorList);
public void buildMachineStatementFromBasicStatement(ErrorList);
private int toJumpImmediate(int);
private int fromJumpImmediate(int);
private int toBranchImmediate(int);
private int fromBranchImmediate(int);
public String toString();
public void setBasicAssemblyStatement(String);
public void setMachineStatement(String);
public void setBinaryStatement(int);
public void setSource(String);
public RISCVprogram getSourceProgram();
public String getSourceFile();
public String getSource();
public int getSourceLine();
public String getBasicAssemblyStatement();
public String getPrintableBasicAssemblyStatement();
public String getMachineStatement();
public int getBinaryStatement();
public assembler.TokenList getOriginalTokenList();
public assembler.TokenList getStrippedTokenList();
public riscv.Instruction getInstruction();
public int getAddress();
public int[] getOperands();
public int getOperand(int);
private int readBinaryCode(String, char, int);
private void insertBinaryCode(int, char, ErrorList);
private ProgramStatement$BasicStatementList buildBasicStatementListFromBinaryCode(int, riscv.BasicInstruction, int[], int);
}
Launch
package rars;
public synchronized class Launch {
private api.Options options;
private boolean simulate;
private int displayFormat;
private boolean verbose;
private boolean assembleProject;
private boolean countInstructions;
private static final String rangeSeparator = -;
private static final int memoryWordsPerLine = 4;
private static final int DECIMAL = 0;
private static final int HEXADECIMAL = 1;
private static final int ASCII = 2;
private java.util.ArrayList registerDisplayList;
private java.util.ArrayList memoryDisplayList;
private java.util.ArrayList filenameList;
private int instructionCount;
private java.io.PrintStream out;
private java.util.ArrayList dumpTriples;
private java.util.ArrayList programArgumentList;
private int assembleErrorExitCode;
private int simulateErrorExitCode;
public static void main(String[]);
private void Launch(String[]);
private void displayAllPostMortem(api.Program);
private void dumpSegments(api.Program);
private void launchIDE();
private boolean parseCommandArgs(String[]);
private api.Program runCommand();
private String[] checkMemoryAddressRange(String) throws NumberFormatException;
private void displayMiscellaneousPostMortem(api.Program);
private void displayRegistersPostMortem(api.Program);
private String formatIntForDisplay(int);
private void displayMemoryPostMortem(riscv.hardware.Memory);
private void processDisplayMessagesToErrSwitch(String[], String);
private void displayCopyright(String[], String);
private void displayHelp();
static void
}
LH
package rars.riscv.instructions;
public synchronized class LH extends Load {
public void LH();
public int load(int) throws rars.riscv.hardware.AddressErrorException;
}
SLT
package rars.riscv.instructions;
public synchronized class SLT extends Arithmetic {
public void SLT();
public int compute(int, int);
}
FusedFloat
package rars.riscv.instructions;
public abstract synchronized class FusedFloat extends rars.riscv.BasicInstruction {
public void FusedFloat(String, String, String);
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
public static void flipRounding(jsoftfloat.Environment);
protected abstract jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
FNMSUBS
package rars.riscv.instructions;
public synchronized class FNMSUBS extends FusedFloat {
public void FNMSUBS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
Arithmetic
package rars.riscv.instructions;
public abstract synchronized class Arithmetic extends rars.riscv.BasicInstruction {
public void Arithmetic(String, String, String, String);
public void simulate(rars.ProgramStatement);
protected abstract int compute(int, int);
}
SB
package rars.riscv.instructions;
public synchronized class SB extends Store {
public void SB();
public void store(int, int) throws rars.riscv.hardware.AddressErrorException;
}
SRL
package rars.riscv.instructions;
public synchronized class SRL extends Arithmetic {
public void SRL();
public int compute(int, int);
}
Branch
package rars.riscv.instructions;
public abstract synchronized class Branch extends rars.riscv.BasicInstruction {
public void Branch(String, String, String);
public void simulate(rars.ProgramStatement);
public abstract boolean willBranch(rars.ProgramStatement);
}
FLES
package rars.riscv.instructions;
public synchronized class FLES extends rars.riscv.BasicInstruction {
public void FLES();
public void simulate(rars.ProgramStatement);
}
CSRRC
package rars.riscv.instructions;
public synchronized class CSRRC extends rars.riscv.BasicInstruction {
public void CSRRC();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FENCEI
package rars.riscv.instructions;
public synchronized class FENCEI extends rars.riscv.BasicInstruction {
public void FENCEI();
public void simulate(rars.ProgramStatement);
}
BNE
package rars.riscv.instructions;
public synchronized class BNE extends Branch {
public void BNE();
public boolean willBranch(rars.ProgramStatement);
}
AND
package rars.riscv.instructions;
public synchronized class AND extends Arithmetic {
public void AND();
public int compute(int, int);
}
LBU
package rars.riscv.instructions;
public synchronized class LBU extends Load {
public void LBU();
public int load(int) throws rars.riscv.hardware.AddressErrorException;
}
MULH
package rars.riscv.instructions;
public synchronized class MULH extends Arithmetic {
public void MULH();
public int compute(int, int);
}
JALR
package rars.riscv.instructions;
public synchronized class JALR extends rars.riscv.BasicInstruction {
public void JALR();
public void simulate(rars.ProgramStatement);
}
BLTU
package rars.riscv.instructions;
public synchronized class BLTU extends Branch {
public void BLTU();
public boolean willBranch(rars.ProgramStatement);
}
FDIVS
package rars.riscv.instructions;
public synchronized class FDIVS extends Floating {
public void FDIVS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
FCVTWS
package rars.riscv.instructions;
public synchronized class FCVTWS extends rars.riscv.BasicInstruction {
public void FCVTWS();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
JAL
package rars.riscv.instructions;
public synchronized class JAL extends rars.riscv.BasicInstruction {
public void JAL();
public void simulate(rars.ProgramStatement);
}
SUB
package rars.riscv.instructions;
public synchronized class SUB extends Arithmetic {
public void SUB();
public int compute(int, int);
}
FEQS
package rars.riscv.instructions;
public synchronized class FEQS extends rars.riscv.BasicInstruction {
public void FEQS();
public void simulate(rars.ProgramStatement);
}
LW
package rars.riscv.instructions;
public synchronized class LW extends Load {
public void LW();
public int load(int) throws rars.riscv.hardware.AddressErrorException;
}
FCLASSS
package rars.riscv.instructions;
public synchronized class FCLASSS extends rars.riscv.BasicInstruction {
public void FCLASSS();
public void simulate(rars.ProgramStatement);
}
SLL
package rars.riscv.instructions;
public synchronized class SLL extends Arithmetic {
public void SLL();
public int compute(int, int);
}
SRAI
package rars.riscv.instructions;
public synchronized class SRAI extends rars.riscv.BasicInstruction {
public void SRAI();
public void simulate(rars.ProgramStatement);
}
FLW
package rars.riscv.instructions;
public synchronized class FLW extends rars.riscv.BasicInstruction {
public void FLW();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FMADDS
package rars.riscv.instructions;
public synchronized class FMADDS extends FusedFloat {
public void FMADDS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
REMU
package rars.riscv.instructions;
public synchronized class REMU extends Arithmetic {
public void REMU();
public int compute(int, int);
}
SLTIU
package rars.riscv.instructions;
public synchronized class SLTIU extends ImmediateInstruction {
public void SLTIU();
public int compute(int, int);
}
FSGNJNS
package rars.riscv.instructions;
public synchronized class FSGNJNS extends rars.riscv.BasicInstruction {
public void FSGNJNS();
public void simulate(rars.ProgramStatement);
}
BEQ
package rars.riscv.instructions;
public synchronized class BEQ extends Branch {
public void BEQ();
public boolean willBranch(rars.ProgramStatement);
}
FCVTSW
package rars.riscv.instructions;
public synchronized class FCVTSW extends rars.riscv.BasicInstruction {
public void FCVTSW();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FSGNJXS
package rars.riscv.instructions;
public synchronized class FSGNJXS extends rars.riscv.BasicInstruction {
public void FSGNJXS();
public void simulate(rars.ProgramStatement);
}
FSGNJS
package rars.riscv.instructions;
public synchronized class FSGNJS extends rars.riscv.BasicInstruction {
public void FSGNJS();
public void simulate(rars.ProgramStatement);
}
ORI
package rars.riscv.instructions;
public synchronized class ORI extends ImmediateInstruction {
public void ORI();
public int compute(int, int);
}
FCVTWUS
package rars.riscv.instructions;
public synchronized class FCVTWUS extends rars.riscv.BasicInstruction {
public void FCVTWUS();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FADDS
package rars.riscv.instructions;
public synchronized class FADDS extends Floating {
public void FADDS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
URET
package rars.riscv.instructions;
public synchronized class URET extends rars.riscv.BasicInstruction {
public void URET();
public void simulate(rars.ProgramStatement);
}
ADD
package rars.riscv.instructions;
public synchronized class ADD extends Arithmetic {
public void ADD();
public int compute(int, int);
}
LHU
package rars.riscv.instructions;
public synchronized class LHU extends Load {
public void LHU();
public int load(int) throws rars.riscv.hardware.AddressErrorException;
}
AUIPC
package rars.riscv.instructions;
public synchronized class AUIPC extends rars.riscv.BasicInstruction {
public void AUIPC();
public void simulate(rars.ProgramStatement);
}
MULHU
package rars.riscv.instructions;
public synchronized class MULHU extends Arithmetic {
public void MULHU();
public int compute(int, int);
}
FMAXS
package rars.riscv.instructions;
public synchronized class FMAXS extends Floating {
public void FMAXS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
DIV
package rars.riscv.instructions;
public synchronized class DIV extends Arithmetic {
public void DIV();
public int compute(int, int);
}
DIVU
package rars.riscv.instructions;
public synchronized class DIVU extends Arithmetic {
public void DIVU();
public int compute(int, int);
}
FSW
package rars.riscv.instructions;
public synchronized class FSW extends rars.riscv.BasicInstruction {
public void FSW();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
MULHSU
package rars.riscv.instructions;
public synchronized class MULHSU extends Arithmetic {
public void MULHSU();
public int compute(int, int);
}
CSRRW
package rars.riscv.instructions;
public synchronized class CSRRW extends rars.riscv.BasicInstruction {
public void CSRRW();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FENCE
package rars.riscv.instructions;
public synchronized class FENCE extends rars.riscv.BasicInstruction {
public void FENCE();
public void simulate(rars.ProgramStatement);
}
FMINS
package rars.riscv.instructions;
public synchronized class FMINS extends Floating {
public void FMINS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
FMSUBS
package rars.riscv.instructions;
public synchronized class FMSUBS extends FusedFloat {
public void FMSUBS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
SLTI
package rars.riscv.instructions;
public synchronized class SLTI extends ImmediateInstruction {
public void SLTI();
public int compute(int, int);
}
BGEU
package rars.riscv.instructions;
public synchronized class BGEU extends Branch {
public void BGEU();
public boolean willBranch(rars.ProgramStatement);
}
MUL
package rars.riscv.instructions;
public synchronized class MUL extends Arithmetic {
public void MUL();
public int compute(int, int);
}
CSRRS
package rars.riscv.instructions;
public synchronized class CSRRS extends rars.riscv.BasicInstruction {
public void CSRRS();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FMVSX
package rars.riscv.instructions;
public synchronized class FMVSX extends rars.riscv.BasicInstruction {
public void FMVSX();
public void simulate(rars.ProgramStatement);
}
ADDI
package rars.riscv.instructions;
public synchronized class ADDI extends ImmediateInstruction {
public void ADDI();
public int compute(int, int);
}
Store
package rars.riscv.instructions;
public abstract synchronized class Store extends rars.riscv.BasicInstruction {
public void Store(String, String, String);
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
protected abstract void store(int, int) throws rars.riscv.hardware.AddressErrorException;
}
SLLI
package rars.riscv.instructions;
public synchronized class SLLI extends rars.riscv.BasicInstruction {
public void SLLI();
public void simulate(rars.ProgramStatement);
}
Floating
package rars.riscv.instructions;
public abstract synchronized class Floating extends rars.riscv.BasicInstruction {
public static final String ROUNDING_MODE = qqq;
protected void Floating(String, String, String);
protected void Floating(String, String, String, String);
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
public static void setfflags(jsoftfloat.Environment);
public static jsoftfloat.RoundingMode getRoundingMode(int, rars.ProgramStatement) throws rars.SimulationException;
public abstract jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
public static boolean subnormal(float);
public static boolean signallingNaN(float);
}
CSRRSI
package rars.riscv.instructions;
public synchronized class CSRRSI extends rars.riscv.BasicInstruction {
public void CSRRSI();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
FSUBS
package rars.riscv.instructions;
public synchronized class FSUBS extends Floating {
public void FSUBS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
FCVTSWU
package rars.riscv.instructions;
public synchronized class FCVTSWU extends rars.riscv.BasicInstruction {
public void FCVTSWU();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
WFI
package rars.riscv.instructions;
public synchronized class WFI extends rars.riscv.BasicInstruction {
public void WFI();
public void simulate(rars.ProgramStatement) throws rars.WaitException;
}
ECALL
package rars.riscv.instructions;
public synchronized class ECALL extends rars.riscv.BasicInstruction {
public void ECALL();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
XORI
package rars.riscv.instructions;
public synchronized class XORI extends ImmediateInstruction {
public void XORI();
public int compute(int, int);
}
SRA
package rars.riscv.instructions;
public synchronized class SRA extends Arithmetic {
public void SRA();
public int compute(int, int);
}
FMULS
package rars.riscv.instructions;
public synchronized class FMULS extends Floating {
public void FMULS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
FSQRTS
package rars.riscv.instructions;
public synchronized class FSQRTS extends rars.riscv.BasicInstruction {
public void FSQRTS();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
CSRRWI
package rars.riscv.instructions;
public synchronized class CSRRWI extends rars.riscv.BasicInstruction {
public void CSRRWI();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
ImmediateInstruction
package rars.riscv.instructions;
public abstract synchronized class ImmediateInstruction extends rars.riscv.BasicInstruction {
public void ImmediateInstruction(String, String, String);
public void simulate(rars.ProgramStatement);
protected abstract int compute(int, int);
}
BLT
package rars.riscv.instructions;
public synchronized class BLT extends Branch {
public void BLT();
public boolean willBranch(rars.ProgramStatement);
}
CSRRCI
package rars.riscv.instructions;
public synchronized class CSRRCI extends rars.riscv.BasicInstruction {
public void CSRRCI();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
SH
package rars.riscv.instructions;
public synchronized class SH extends Store {
public void SH();
public void store(int, int) throws rars.riscv.hardware.AddressErrorException;
}
SLTU
package rars.riscv.instructions;
public synchronized class SLTU extends Arithmetic {
public void SLTU();
public int compute(int, int);
}
FNMADDS
package rars.riscv.instructions;
public synchronized class FNMADDS extends FusedFloat {
public void FNMADDS();
public jsoftfloat.types.Float32 compute(jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.types.Float32, jsoftfloat.Environment);
}
REM
package rars.riscv.instructions;
public synchronized class REM extends Arithmetic {
public void REM();
public int compute(int, int);
}
BGE
package rars.riscv.instructions;
public synchronized class BGE extends Branch {
public void BGE();
public boolean willBranch(rars.ProgramStatement);
}
SRLI
package rars.riscv.instructions;
public synchronized class SRLI extends rars.riscv.BasicInstruction {
public void SRLI();
public void simulate(rars.ProgramStatement);
}
FLTS
package rars.riscv.instructions;
public synchronized class FLTS extends rars.riscv.BasicInstruction {
public void FLTS();
public void simulate(rars.ProgramStatement);
}
LB
package rars.riscv.instructions;
public synchronized class LB extends Load {
public void LB();
public int load(int) throws rars.riscv.hardware.AddressErrorException;
}
FMVXS
package rars.riscv.instructions;
public synchronized class FMVXS extends rars.riscv.BasicInstruction {
public void FMVXS();
public void simulate(rars.ProgramStatement);
}
ANDI
package rars.riscv.instructions;
public synchronized class ANDI extends ImmediateInstruction {
public void ANDI();
public int compute(int, int);
}
EBREAK
package rars.riscv.instructions;
public synchronized class EBREAK extends rars.riscv.BasicInstruction {
public void EBREAK();
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
SW
package rars.riscv.instructions;
public synchronized class SW extends Store {
public void SW();
public void store(int, int) throws rars.riscv.hardware.AddressErrorException;
}
XOR
package rars.riscv.instructions;
public synchronized class XOR extends Arithmetic {
public void XOR();
public int compute(int, int);
}
Load
package rars.riscv.instructions;
public abstract synchronized class Load extends rars.riscv.BasicInstruction {
public void Load(String, String, String);
public void simulate(rars.ProgramStatement) throws rars.SimulationException;
protected abstract int load(int) throws rars.riscv.hardware.AddressErrorException;
}
LUI
package rars.riscv.instructions;
public synchronized class LUI extends rars.riscv.BasicInstruction {
public void LUI();
public void simulate(rars.ProgramStatement);
}
OR
package rars.riscv.instructions;
public synchronized class OR extends Arithmetic {
public void OR();
public int compute(int, int);
}
FloatingPointRegisterFile
package rars.riscv.hardware;
public synchronized class FloatingPointRegisterFile {
private static final RegisterBlock instance;
public void FloatingPointRegisterFile();
public static void setRegisterToFloat(int, float);
public static float getFloatFromRegister(int);
public static float getFloatFromRegister(String);
public static int updateRegister(int, int);
public static int getValue(int);
public static int getValue(String);
public static Register[] getRegisters();
public static Register getRegister(String);
public static void resetRegisters();
public static void addRegistersObserver(java.util.Observer);
public static void deleteRegistersObserver(java.util.Observer);
static void
}
AccessNotice
package rars.riscv.hardware;
public abstract synchronized class AccessNotice {
public static final int READ = 0;
public static final int WRITE = 1;
private int accessType;
private Thread thread;
protected void AccessNotice(int);
public int getAccessType();
public Thread getThread();
public boolean accessIsFromGUI();
public boolean accessIsFromRISCV();
}
MemoryAccessNotice
package rars.riscv.hardware;
public synchronized class MemoryAccessNotice extends AccessNotice {
private int address;
private int length;
private int value;
void MemoryAccessNotice(int, int, int, int);
public void MemoryAccessNotice(int, int, int);
public int getAddress();
public int getLength();
public int getValue();
public String toString();
}
RegisterFile
package rars.riscv.hardware;
public synchronized class RegisterFile {
public static final int GLOBAL_POINTER_REGISTER = 3;
public static final int STACK_POINTER_REGISTER = 2;
private static final RegisterBlock instance;
private static Register programCounter;
public void RegisterFile();
public static int updateRegister(int, int);
public static void updateRegister(String, int);
public static int getValue(int);
public static int getValue(String);
public static Register[] getRegisters();
public static Register getRegister(String);
public static void initializeProgramCounter(int);
public static void initializeProgramCounter(boolean);
public static int setProgramCounter(int);
public static int getProgramCounter();
public static Register getProgramCounterRegister();
public static int getInitialProgramCounter();
public static void resetRegisters();
public static void incrementPC();
public static void addRegistersObserver(java.util.Observer);
public static void deleteRegistersObserver(java.util.Observer);
static void
}
Register
package rars.riscv.hardware;
public synchronized class Register extends java.util.Observable {
private String name;
private int number;
private int resetValue;
private volatile int value;
public void Register(String, int, int);
public String getName();
public synchronized int getValue();
public synchronized int getValueNoNotify();
public int getResetValue();
public int getNumber();
public synchronized int setValue(int);
public synchronized int setValueBackdoor(int);
public synchronized void resetValue();
public synchronized void changeResetValue(int);
private void notifyAnyObservers(int);
}
MemoryConfigurations
package rars.riscv.hardware;
public synchronized class MemoryConfigurations {
private static java.util.ArrayList configurations;
private static MemoryConfiguration defaultConfiguration;
private static MemoryConfiguration currentConfiguration;
private static final String[] configurationItemNames;
private static int[] defaultConfigurationItemValues;
private static int[] dataBasedCompactConfigurationItemValues;
private static int[] textBasedCompactConfigurationItemValues;
public void MemoryConfigurations();
public static void buildConfigurationCollection();
public static java.util.Iterator getConfigurationsIterator();
public static MemoryConfiguration getConfigurationByName(String);
public static MemoryConfiguration getDefaultConfiguration();
public static MemoryConfiguration getCurrentConfiguration();
public static boolean setCurrentConfiguration(MemoryConfiguration);
public static int getDefaultTextBaseAddress();
public static int getDefaultDataSegmentBaseAddress();
public static int getDefaultExternBaseAddress();
public static int getDefaultGlobalPointer();
public static int getDefaultDataBaseAddress();
public static int getDefaultHeapBaseAddress();
public static int getDefaultStackPointer();
public static int getDefaultStackBaseAddress();
public static int getDefaultUserHighAddress();
public static int getDefaultKernelBaseAddress();
public static int getDefaultMemoryMapBaseAddress();
public static int getDefaultKernelHighAddress();
public int getDefaultDataSegmentLimitAddress();
public int getDefaultTextLimitAddress();
public int getDefaultStackLimitAddress();
public int getMemoryMapLimitAddress();
static void
}
ReadOnlyRegister
package rars.riscv.hardware;
public synchronized class ReadOnlyRegister extends Register {
public void ReadOnlyRegister(String, int, int);
}
MaskedRegister
package rars.riscv.hardware;
public synchronized class MaskedRegister extends Register {
private int mask;
public void MaskedRegister(String, int, int, int);
public synchronized int setValue(int);
}
InterruptController
package rars.riscv.hardware;
public synchronized class InterruptController {
public static final Object lock;
private static boolean externalPending;
private static int externalValue;
private static boolean timerPending;
private static int timerValue;
private static boolean trapPending;
private static rars.SimulationException trapSE;
private static int trapPC;
public void InterruptController();
public static void reset();
public static boolean registerExternalInterrupt(int);
public static boolean registerTimerInterrupt(int);
public static boolean registerSynchronousTrap(rars.SimulationException, int);
public static boolean externalPending();
public static boolean timerPending();
public static boolean trapPending();
public static int claimExternal();
public static int claimTimer();
public static rars.SimulationException claimTrap();
static void
}
MemoryConfiguration
package rars.riscv.hardware;
public synchronized class MemoryConfiguration {
private String configurationIdentifier;
private String configurationName;
private String[] configurationItemNames;
private int[] configurationItemValues;
public void MemoryConfiguration(String, String, String[], int[]);
public String getConfigurationIdentifier();
public String getConfigurationName();
public int[] getConfigurationItemValues();
public String[] getConfigurationItemNames();
public int getTextBaseAddress();
public int getDataSegmentBaseAddress();
public int getExternBaseAddress();
public int getGlobalPointer();
public int getDataBaseAddress();
public int getHeapBaseAddress();
public int getStackPointer();
public int getStackBaseAddress();
public int getUserHighAddress();
public int getKernelBaseAddress();
public int getMemoryMapBaseAddress();
public int getKernelHighAddress();
public int getDataSegmentLimitAddress();
public int getTextLimitAddress();
public int getStackLimitAddress();
public int getMemoryMapLimitAddress();
}
Memory
package rars.riscv.hardware;
public synchronized class Memory extends java.util.Observable {
public static int textBaseAddress;
public static int dataSegmentBaseAddress;
public static int externBaseAddress;
public static int globalPointer;
public static int dataBaseAddress;
public static int heapBaseAddress;
public static int stackPointer;
public static int stackBaseAddress;
public static int userHighAddress;
public static int kernelBaseAddress;
public static int memoryMapBaseAddress;
public static int kernelHighAddress;
public static final int WORD_LENGTH_BYTES = 4;
public static final boolean LITTLE_ENDIAN = 1;
private static boolean byteOrder;
public static int heapAddress;
private java.util.Collection observables;
private static final int BLOCK_LENGTH_WORDS = 1024;
private static final int BLOCK_TABLE_LENGTH = 1024;
private int[][] dataBlockTable;
private int[][] stackBlockTable;
private static final int MMIO_TABLE_LENGTH = 16;
private int[][] memoryMapBlockTable;
private static final int TEXT_BLOCK_LENGTH_WORDS = 1024;
private static final int TEXT_BLOCK_TABLE_LENGTH = 1024;
private rars.ProgramStatement[][] textBlockTable;
public static int dataSegmentLimitAddress;
public static int textLimitAddress;
public static int stackLimitAddress;
public static int memoryMapLimitAddress;
private static Memory uniqueMemoryInstance;
private static final boolean STORE = 1;
private static final boolean FETCH = 0;
public void Memory();
public boolean copyFrom(Memory);
public static Memory swapInstance(Memory);
public static Memory getInstance();
public void clear();
public static void setConfiguration();
private void initialize();
public int allocateBytesFromHeap(int) throws IllegalArgumentException;
public int set(int, int, int) throws AddressErrorException;
public int setRawWord(int, int) throws AddressErrorException;
public int setWord(int, int) throws AddressErrorException;
public int setHalf(int, int) throws AddressErrorException;
public int setByte(int, int) throws AddressErrorException;
public double setDouble(int, double) throws AddressErrorException;
public void setStatement(int, rars.ProgramStatement) throws AddressErrorException;
public int get(int, int) throws AddressErrorException;
private int get(int, int, boolean) throws AddressErrorException;
public int getRawWord(int) throws AddressErrorException;
public Integer getRawWordOrNull(int) throws AddressErrorException;
public int getAddressOfFirstNull(int, int) throws AddressErrorException;
public int getWord(int) throws AddressErrorException;
public int getWordNoNotify(int) throws AddressErrorException;
public int getHalf(int) throws AddressErrorException;
public int getByte(int) throws AddressErrorException;
public rars.ProgramStatement getStatement(int) throws AddressErrorException;
public rars.ProgramStatement getStatementNoNotify(int) throws AddressErrorException;
private rars.ProgramStatement getStatement(int, boolean) throws AddressErrorException;
public static boolean wordAligned(int);
private static void checkLoadWordAligned(int) throws AddressErrorException;
private static void checkStoreWordAligned(int) throws AddressErrorException;
public static boolean doublewordAligned(int);
public static boolean inTextSegment(int);
public static boolean inDataSegment(int);
public static boolean inMemoryMapSegment(int);
public void addObserver(java.util.Observer);
public void addObserver(java.util.Observer, int) throws AddressErrorException;
public void addObserver(java.util.Observer, int, int) throws AddressErrorException;
public int countObservers();
public void deleteObserver(java.util.Observer);
public void deleteObservers();
public void notifyObservers();
public void notifyObservers(Object);
private java.util.Collection getNewMemoryObserversCollection();
private void notifyAnyObservers(int, int, int, int);
private int storeBytesInTable(int[][], int, int, int);
private int fetchBytesFromTable(int[][], int, int);
private synchronized int storeOrFetchBytesInTable(int[][], int, int, int, boolean);
private synchronized int storeWordInTable(int[][], int, int);
private synchronized int fetchWordFromTable(int[][], int);
private synchronized Integer fetchWordOrNullFromTable(int[][], int);
private int replaceByte(int, int, int, int);
private void storeProgramStatement(int, rars.ProgramStatement, int, rars.ProgramStatement[][]);
private rars.ProgramStatement readProgramStatement(int, int, rars.ProgramStatement[][], boolean);
static void
}
RegisterBlock
package rars.riscv.hardware;
public synchronized class RegisterBlock {
private final Register[] regFile;
private final char prefix;
protected void RegisterBlock(char, Register[]);
public void showRegisters();
public int updateRegister(Register, int);
public int updateRegister(int, int);
public int updateRegister(String, int);
public int getValue(int);
public int getValue(String);
public Register getRegister(int);
public Register getRegister(String);
public Register[] getRegisters();
public void resetRegisters();
public void addRegistersObserver(java.util.Observer);
public void deleteRegistersObserver(java.util.Observer);
}
Memory$MemoryObservable
package rars.riscv.hardware;
synchronized class Memory$MemoryObservable extends java.util.Observable implements Comparable {
private int lowAddress;
private int highAddress;
public void Memory$MemoryObservable(Memory, java.util.Observer, int, int);
public boolean match(int);
public void notifyObserver(MemoryAccessNotice);
public int compareTo(Memory$MemoryObservable);
}
LinkedRegister
package rars.riscv.hardware;
public synchronized class LinkedRegister extends Register {
private Register base;
private int mask;
private int shift;
public void LinkedRegister(String, int, Register, int);
public synchronized int getValue();
public synchronized int getValueNoNotify();
public synchronized int setValue(int);
public synchronized void resetValue();
}
AddressErrorException
package rars.riscv.hardware;
public synchronized class AddressErrorException extends Exception {
private final int address;
private final int type;
public void AddressErrorException(String, int, int);
public int getAddress();
public int getType();
}
ControlAndStatusRegisterFile
package rars.riscv.hardware;
public synchronized class ControlAndStatusRegisterFile {
public static final int EXTERNAL_INTERRUPT = 256;
public static final int TIMER_INTERRUPT = 16;
public static final int SOFTWARE_INTERRUPT = 1;
public static final int INTERRUPT_ENABLE = 1;
private static final RegisterBlock instance;
public void ControlAndStatusRegisterFile();
public static boolean updateRegister(int, int);
public static boolean updateRegister(String, int);
public static int updateRegisterBackdoor(int, int);
public static int updateRegisterBackdoor(String, int);
public static boolean orRegister(int, int);
public static boolean orRegister(String, int);
public static boolean clearRegister(int, int);
public static boolean clearRegister(String, int);
public static int getValue(int);
public static int getValue(String);
public static int getValueNoNotify(String);
public static Register[] getRegisters();
public static int getRegisterPosition(Register);
public static void resetRegisters();
public static void addRegistersObserver(java.util.Observer);
public static void deleteRegistersObserver(java.util.Observer);
static void
}
RegisterAccessNotice
package rars.riscv.hardware;
public synchronized class RegisterAccessNotice extends AccessNotice {
private String registerName;
void RegisterAccessNotice(int, String);
public String getRegisterName();
public String toString();
}
BinaryDumpFormat
package rars.riscv.dump;
public synchronized class BinaryDumpFormat extends AbstractDumpFormat {
public void BinaryDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
AbstractDumpFormat
package rars.riscv.dump;
public abstract synchronized class AbstractDumpFormat implements DumpFormat {
private final String name;
private final String commandDescriptor;
private final String description;
private final String extension;
public void AbstractDumpFormat(String, String, String, String);
public String getFileExtension();
public String getDescription();
public String toString();
public String getCommandDescriptor();
public abstract void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
SegmentWindowDumpFormat
package rars.riscv.dump;
public synchronized class SegmentWindowDumpFormat extends AbstractDumpFormat {
public void SegmentWindowDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
AsciiTextDumpFormat
package rars.riscv.dump;
public synchronized class AsciiTextDumpFormat extends AbstractDumpFormat {
public void AsciiTextDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
HexTextDumpFormat
package rars.riscv.dump;
public synchronized class HexTextDumpFormat extends AbstractDumpFormat {
public void HexTextDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
DumpFormat
package rars.riscv.dump;
public abstract interface DumpFormat {
public abstract String getFileExtension();
public abstract String getDescription();
public abstract String getCommandDescriptor();
public abstract String toString();
public abstract void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
BinaryTextDumpFormat
package rars.riscv.dump;
public synchronized class BinaryTextDumpFormat extends AbstractDumpFormat {
public void BinaryTextDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
DumpFormatLoader
package rars.riscv.dump;
public synchronized class DumpFormatLoader {
private static final String CLASS_PREFIX = rars.riscv.dump.;
private static final String DUMP_DIRECTORY_PATH = rars/riscv/dump;
private static final String CLASS_EXTENSION = class;
private static java.util.ArrayList formatList;
public void DumpFormatLoader();
public static java.util.ArrayList getDumpFormats();
public static DumpFormat findDumpFormatGivenCommandDescriptor(String);
static void
}
IntelHexDumpFormat
package rars.riscv.dump;
public synchronized class IntelHexDumpFormat extends AbstractDumpFormat {
public void IntelHexDumpFormat();
public void dumpMemoryRange(java.io.File, int, int, rars.riscv.hardware.Memory) throws rars.riscv.hardware.AddressErrorException, java.io.IOException;
}
SyscallLoader
package rars.riscv;
public synchronized class SyscallLoader {
private static final String CLASS_PREFIX = rars.riscv.syscalls.;
private static final String SYSCALLS_DIRECTORY_PATH = rars/riscv/syscalls;
private static final String CLASS_EXTENSION = class;
private static java.util.ArrayList syscallList;
public void SyscallLoader();
private static java.util.ArrayList processSyscallNumberOverrides(java.util.ArrayList);
public static AbstractSyscall findSyscall(int);
public static java.util.ArrayList getSyscallList();
static void
}
ExtendedInstruction
package rars.riscv;
public synchronized class ExtendedInstruction extends Instruction {
private java.util.ArrayList translationStrings;
public void ExtendedInstruction(String, String, String);
public void ExtendedInstruction(String, String);
public int getInstructionLength();
public java.util.ArrayList getBasicIntructionTemplateList();
public static String makeTemplateSubstitutions(rars.RISCVprogram, String, rars.assembler.TokenList, int);
private static String substitute(String, String, String);
private static String substituteFirst(String, String, String);
private java.util.ArrayList buildTranslationList(String);
private int getInstructionLength(java.util.ArrayList);
}
BasicInstructionFormat
package rars.riscv;
public final synchronized enum BasicInstructionFormat {
public static final BasicInstructionFormat R_FORMAT;
public static final BasicInstructionFormat R4_FORMAT;
public static final BasicInstructionFormat I_FORMAT;
public static final BasicInstructionFormat S_FORMAT;
public static final BasicInstructionFormat B_FORMAT;
public static final BasicInstructionFormat U_FORMAT;
public static final BasicInstructionFormat J_FORMAT;
public static BasicInstructionFormat[] values();
public static BasicInstructionFormat valueOf(String);
private void BasicInstructionFormat(String, int);
static void
}
AbstractSyscall
package rars.riscv;
public abstract synchronized class AbstractSyscall implements Comparable {
private int serviceNumber;
private String serviceName;
private String description;
private String inputs;
private String outputs;
protected void AbstractSyscall(String);
protected void AbstractSyscall(String, String);
protected void AbstractSyscall(String, String, String, String);
public String getName();
public String getDescription();
public String getInputs();
public String getOutputs();
public void setNumber(int);
public int getNumber();
public abstract void simulate(rars.ProgramStatement) throws rars.ExitingException;
public int compareTo(AbstractSyscall);
static void
}
BasicInstruction
package rars.riscv;
public abstract synchronized class BasicInstruction extends Instruction {
private String instructionName;
private BasicInstructionFormat instructionFormat;
private String operationMask;
private int opcodeMask;
private int opcodeMatch;
public void BasicInstruction(String, String, BasicInstructionFormat, String);
public void BasicInstruction(String, BasicInstructionFormat, String);
public String getOperationMask();
public BasicInstructionFormat getInstructionFormat();
public int getOpcodeMask();
public int getOpcodeMatch();
public abstract void simulate(rars.ProgramStatement) throws rars.SimulationException;
}
Instruction
package rars.riscv;
public abstract synchronized class Instruction {
public static final int INSTRUCTION_LENGTH = 4;
public static final int INSTRUCTION_LENGTH_BITS = 32;
public static char[] operandMask;
protected String mnemonic;
protected String exampleFormat;
protected String description;
protected rars.assembler.TokenList tokenList;
public void Instruction();
public String getName();
public String getExampleFormat();
public String getDescription();
public rars.assembler.TokenList getTokenList();
public int getInstructionLength();
protected String extractOperator(String);
protected void createExampleTokenList();
static void
}
InstructionSet$MatchMap
package rars.riscv;
synchronized class InstructionSet$MatchMap implements Comparable {
private int mask;
private int maskLength;
private java.util.HashMap matchMap;
public void InstructionSet$MatchMap(int, java.util.HashMap);
public boolean equals(Object);
public int compareTo(InstructionSet$MatchMap);
public BasicInstruction find(int);
}
InstructionSet
package rars.riscv;
public synchronized class InstructionSet {
private static final String CLASS_PREFIX = rars.riscv.instructions.;
private static final String INSTRUCTIONS_DIRECTORY_PATH = rars/riscv/instructions;
private static final String CLASS_EXTENSION = class;
private java.util.ArrayList instructionList;
private java.util.ArrayList opcodeMatchMaps;
public void InstructionSet();
public java.util.ArrayList getInstructionList();
public void populate();
public BasicInstruction findByBinaryCode(int);
private void addBasicInstructions();
private void addPseudoInstructions();
public java.util.ArrayList matchOperator(String);
public java.util.ArrayList prefixMatchOperator(String);
public static void findAndSimulateSyscall(int, rars.ProgramStatement) throws rars.SimulationException;
public static void processBranch(int);
public static void processJump(int);
public static void processReturnAddress(int);
}
SyscallNumberOverride
package rars.riscv;
public synchronized class SyscallNumberOverride {
private String serviceName;
private int newServiceNumber;
public void SyscallNumberOverride(String, String);
public String getName();
public int getNumber();
}
SyscallClose
package rars.riscv.syscalls;
public synchronized class SyscallClose extends rars.riscv.AbstractSyscall {
public void SyscallClose();
public void simulate(rars.ProgramStatement);
}
SyscallRandInt
package rars.riscv.syscalls;
public synchronized class SyscallRandInt extends rars.riscv.AbstractSyscall {
public void SyscallRandInt();
public void simulate(rars.ProgramStatement);
}
SyscallMidiOutSync
package rars.riscv.syscalls;
public synchronized class SyscallMidiOutSync extends rars.riscv.AbstractSyscall {
static final int rangeLowEnd = 0;
static final int rangeHighEnd = 127;
public void SyscallMidiOutSync();
public void simulate(rars.ProgramStatement);
}
SyscallReadInt
package rars.riscv.syscalls;
public synchronized class SyscallReadInt extends rars.riscv.AbstractSyscall {
public void SyscallReadInt();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallSbrk
package rars.riscv.syscalls;
public synchronized class SyscallSbrk extends rars.riscv.AbstractSyscall {
public void SyscallSbrk();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallPrintString
package rars.riscv.syscalls;
public synchronized class SyscallPrintString extends rars.riscv.AbstractSyscall {
public void SyscallPrintString();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
NullString
package rars.riscv.syscalls;
public synchronized class NullString {
public void NullString();
public static String get(rars.ProgramStatement) throws rars.ExitingException;
public static String get(rars.ProgramStatement, String) throws rars.ExitingException;
}
SyscallMessageDialogString
package rars.riscv.syscalls;
public synchronized class SyscallMessageDialogString extends rars.riscv.AbstractSyscall {
public void SyscallMessageDialogString();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallWrite
package rars.riscv.syscalls;
public synchronized class SyscallWrite extends rars.riscv.AbstractSyscall {
public void SyscallWrite();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallConfirmDialog
package rars.riscv.syscalls;
public synchronized class SyscallConfirmDialog extends rars.riscv.AbstractSyscall {
public void SyscallConfirmDialog();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallMidiOut
package rars.riscv.syscalls;
public synchronized class SyscallMidiOut extends rars.riscv.AbstractSyscall {
private static final int rangeLowEnd = 0;
private static final int rangeHighEnd = 127;
public void SyscallMidiOut();
public void simulate(rars.ProgramStatement);
}
SyscallTime
package rars.riscv.syscalls;
public synchronized class SyscallTime extends rars.riscv.AbstractSyscall {
public void SyscallTime();
public void simulate(rars.ProgramStatement);
}
SyscallReadString
package rars.riscv.syscalls;
public synchronized class SyscallReadString extends rars.riscv.AbstractSyscall {
public void SyscallReadString();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallLSeek
package rars.riscv.syscalls;
public synchronized class SyscallLSeek extends rars.riscv.AbstractSyscall {
public void SyscallLSeek();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallRandFloat
package rars.riscv.syscalls;
public synchronized class SyscallRandFloat extends rars.riscv.AbstractSyscall {
public void SyscallRandFloat();
public void simulate(rars.ProgramStatement);
}
SyscallReadChar
package rars.riscv.syscalls;
public synchronized class SyscallReadChar extends rars.riscv.AbstractSyscall {
public void SyscallReadChar();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
EndOfTrackListener
package rars.riscv.syscalls;
synchronized class EndOfTrackListener implements javax.sound.midi.MetaEventListener {
private boolean endedYet;
void EndOfTrackListener();
public synchronized void meta(javax.sound.midi.MetaMessage);
public synchronized void awaitEndOfTrack() throws InterruptedException;
}
Tone
package rars.riscv.syscalls;
synchronized class Tone implements Runnable {
public static final int TEMPO = 1000;
public static final int DEFAULT_CHANNEL = 0;
private byte pitch;
private int duration;
private byte instrument;
private byte volume;
private static java.util.concurrent.locks.Lock openLock;
public void Tone(byte, int, byte, byte);
public void run();
private void playTone();
static void
}
SyscallPrintChar
package rars.riscv.syscalls;
public synchronized class SyscallPrintChar extends rars.riscv.AbstractSyscall {
public void SyscallPrintChar();
public void simulate(rars.ProgramStatement);
}
SyscallMessageDialog
package rars.riscv.syscalls;
public synchronized class SyscallMessageDialog extends rars.riscv.AbstractSyscall {
public void SyscallMessageDialog();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallInputDialogString
package rars.riscv.syscalls;
public synchronized class SyscallInputDialogString extends rars.riscv.AbstractSyscall {
public void SyscallInputDialogString();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallRandIntRange
package rars.riscv.syscalls;
public synchronized class SyscallRandIntRange extends rars.riscv.AbstractSyscall {
public void SyscallRandIntRange();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallSleep
package rars.riscv.syscalls;
public synchronized class SyscallSleep extends rars.riscv.AbstractSyscall {
public void SyscallSleep();
public void simulate(rars.ProgramStatement);
}
SyscallPrintIntUnsigned
package rars.riscv.syscalls;
public synchronized class SyscallPrintIntUnsigned extends rars.riscv.AbstractSyscall {
public void SyscallPrintIntUnsigned();
public void simulate(rars.ProgramStatement);
}
SyscallPrintInt
package rars.riscv.syscalls;
public synchronized class SyscallPrintInt extends rars.riscv.AbstractSyscall {
public void SyscallPrintInt();
public void simulate(rars.ProgramStatement);
}
SyscallRandSeed
package rars.riscv.syscalls;
public synchronized class SyscallRandSeed extends rars.riscv.AbstractSyscall {
public void SyscallRandSeed();
public void simulate(rars.ProgramStatement);
}
SyscallPrintFloat
package rars.riscv.syscalls;
public synchronized class SyscallPrintFloat extends rars.riscv.AbstractSyscall {
public void SyscallPrintFloat();
public void simulate(rars.ProgramStatement);
}
ToneGenerator
package rars.riscv.syscalls;
synchronized class ToneGenerator {
public static final byte DEFAULT_PITCH = 60;
public static final int DEFAULT_DURATION = 1000;
public static final byte DEFAULT_INSTRUMENT = 0;
public static final byte DEFAULT_VOLUME = 100;
private static java.util.concurrent.Executor threadPool;
void ToneGenerator();
public void generateTone(byte, int, byte, byte);
public void generateToneSynchronously(byte, int, byte, byte);
static void
}
RandomStreams
package rars.riscv.syscalls;
public synchronized class RandomStreams {
static final java.util.HashMap randomStreams;
public void RandomStreams();
static java.util.Random get(String);
static void
}
SyscallExit
package rars.riscv.syscalls;
public synchronized class SyscallExit extends rars.riscv.AbstractSyscall {
public void SyscallExit();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallExit2
package rars.riscv.syscalls;
public synchronized class SyscallExit2 extends rars.riscv.AbstractSyscall {
public void SyscallExit2();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallPrintIntHex
package rars.riscv.syscalls;
public synchronized class SyscallPrintIntHex extends rars.riscv.AbstractSyscall {
public void SyscallPrintIntHex();
public void simulate(rars.ProgramStatement);
}
SyscallMessageDialogInt
package rars.riscv.syscalls;
public synchronized class SyscallMessageDialogInt extends rars.riscv.AbstractSyscall {
public void SyscallMessageDialogInt();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallOpen
package rars.riscv.syscalls;
public synchronized class SyscallOpen extends rars.riscv.AbstractSyscall {
public void SyscallOpen();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallMessageDialogFloat
package rars.riscv.syscalls;
public synchronized class SyscallMessageDialogFloat extends rars.riscv.AbstractSyscall {
public void SyscallMessageDialogFloat();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallPrintIntBinary
package rars.riscv.syscalls;
public synchronized class SyscallPrintIntBinary extends rars.riscv.AbstractSyscall {
public void SyscallPrintIntBinary();
public void simulate(rars.ProgramStatement);
}
SyscallGetCWD
package rars.riscv.syscalls;
public synchronized class SyscallGetCWD extends rars.riscv.AbstractSyscall {
public void SyscallGetCWD();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallReadFloat
package rars.riscv.syscalls;
public synchronized class SyscallReadFloat extends rars.riscv.AbstractSyscall {
public void SyscallReadFloat();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallInputDialogInt
package rars.riscv.syscalls;
public synchronized class SyscallInputDialogInt extends rars.riscv.AbstractSyscall {
public void SyscallInputDialogInt();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallInputDialogFloat
package rars.riscv.syscalls;
public synchronized class SyscallInputDialogFloat extends rars.riscv.AbstractSyscall {
public void SyscallInputDialogFloat();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
SyscallRead
package rars.riscv.syscalls;
public synchronized class SyscallRead extends rars.riscv.AbstractSyscall {
public void SyscallRead();
public void simulate(rars.ProgramStatement) throws rars.ExitingException;
}
ProgramStatement$BasicStatementList
package rars;
synchronized class ProgramStatement$BasicStatementList {
private java.util.ArrayList list;
void ProgramStatement$BasicStatementList(ProgramStatement);
void addString(String);
void addAddress(int);
void addValue(int);
public String toString();
}
ExitingException
package rars;
public synchronized class ExitingException extends SimulationException {
public void ExitingException();
public void ExitingException(ProgramStatement, String);
public void ExitingException(ProgramStatement, riscv.hardware.AddressErrorException);
}
Documentation
package rars.extras;
public synchronized class Documentation {
public void Documentation();
public static void main(String[]);
public static String createDirectiveMarkdown();
public static String createSyscallMarkdown();
public static String createInstructionMarkdown(Class);
}
Reviews
There are no reviews yet.