instructions presentation

[Onkar Shinde]

it would be good if there was a way for users to decide how they want to be presented with the instruction set listing, i.e. unsorted/alphabetically or categorized based on purpose (i.e. data flow (branching), data storage, data retrieval...)

[Bug Importer (bug-importer)]

Logged In: NO

Candidate groups taken from http://cavehill.uwi.edu/fpas/cmp/online/el21c/lesson18.html would be:

- Data Transfer Group
- Arithmetic Group
- Logical Group
- Branch Group
- Stack Group
- I/O
- Machine Control

If not presented on a different tab, one could also use a simple treeview

[Bug Importer (bug-importer)]

Logged In: NO

you may want to check out the free(ware) Win32 "8085Simulator" which provides a logically split view of the various instructions:

http://www.angelfire.com/electronic2/8085simulator/run1.htm

[Bug Importer (bug-importer)]

Logged In: NO

The presentation could be further simplified by following the current way of "inserting" instructions which can be customized using combo boxes, if this is slightly extended, you could provide pretty high level dialogs, i.e. "compare", where the user could say what sort of compare he wants to take place, providing enough info to enable the wizard to pick the right instruction, likewise the same applies to movs or jumps. For example, user picks "MOV", dialog pops up "customize mov instruction" [immediate/register/memory] [argument].

This would basically have the power to serve as a tutorial, too!
In particular, if the instruction to be created is dynamically created and shown within the dialog while the user customizes it.

[Bug Importer (bug-importer)]

Logged In: NO

on top of this one could even provide very simple wizards for high level building blocks in a program, for example to allow wizard-based creation and customization of templates for functions, function calls, comparisons, loops, memory storage, stack ops and other frequently needed snippets, that users may then simply customize using a dialog.

[Bug Importer (bug-importer)]

Logged In: NO

I would agree that a more informative presentation might be pretty useful, in particular if it also provides details about instruction side effects and costs, this could for example be accomplished using a treeview with multiple columns providing details about an instruction (size, args, side effects, costs/cycles), all this info could also be displayed as a tooltip, too.

[Bug Importer (bug-importer)]

Logged In: NO

regarding instruction presentation, to be truly useful we should consider providing:
  - mnemonic of instruction
  - size of instruction
  - number of operands expected
    - type of operands expected (register, memory, register pair, immediate)
    - size op operands
  - execution cost
  - side effects (mutated registers & flags)

For the keypab view, it would also be helpful to provide a detailed text description and possibly even a short example for each mnemonic.

All instructions could thus be grouped into a basic treeview with columns for the above mentioned meta information.

Some more links for possible doc integration:

- http://neil.franklin.ch/Info_Texts/Instruction_Set_8080
- http://faculty.lacitycollege.edu/Colantrs/c30new/notes/c308085.html
- http://www.rocw.raifoundation.org/electronics/BTechElectronics&Comm/computerarchitecture&microprocessosystems/lecture-notes/lecture-30.pdf
- http://www.retroarchive.org/cpm/cdrom/SIMTEL/SIGM/VOLS100/VOL173/8080.HLP

[Bug Importer (bug-importer)]

Logged In: NO

Regarding templated wizards, I was also thinking of creating something like this - so that we could provide XML-based configuration files for wizard files, that are then loaded by the UI to provide a dialog that offers various customizable options.

That way, there could be a "wizards" directory with XML files, that are loaded at startup to dynamically create (very simple) dialog-based template customization wizards, for example to automatically create commonly redundant stuff.

This could for example be used to help provide automatically built procedure or function stubs, where the user may be presented with a choice like:

 - "name of function/procedure" (becomes label)
 - "amount and types of arguments" (to automatically create function prologue and epilogue)
 - "parameter passing mode" (via registers, via memory, via stack)

Boris

[Bug Importer (bug-importer)]

Logged In: NO

here's another website that shows how the instructions may be put into proper groups:
http://www.thornhill.ss.yrdsb.edu.on.ca/Departments/Computer%20Science/ICE4M/8085OpCodes.htm

[Bug Importer (bug-importer)]

Logged In: NO

the following might also serve as an inspiration: http://wiki.answers.com/Q/74_basic_instructions_set_in_8085_microprocessor

[Bug Importer (bug-importer)]

this is another idea that would contribute to a positive user experience in educational settings

[Bug Importer (bug-importer)]

the following website also provide an overview of instruction classes:
http://www.8085projects.info/instr_set.asp

[The Escapist (wisd00m)]

creating a treeview instead of a table doesn't seem to be a bad idea, and it's also easy to do:

Anybody looking into this should have a look at the function "create_me" in gui-keypad.c: http://bazaar.launchpad.net/~gnusim8085-admins/gnusim8085/trunk/annotate/head%3A/src/gui-keypad.c

There is a nested loop that creates ROWS x COLUMNS entries for the table.

The table is created at the beginning of the function with the gtk_table_new() call, this would need to be replaced with gtk_tree_view_new() instead: http://library.gnome.org/devel/gtk/unstable/GtkTreeView.html

Entries would then need to be added accordingly.

It would be possible to either replace the nested loop with hard coded calls to set up the tree view manually, or to use an XML file instead and parse it instead.

[The Escapist (wisd00m)]

The list at http://www.8085projects.info/page/8085-Instruction-set-list.aspx uses the following categories:

- data transfer instructions
- arithmetic instructions
- branching instructions
- logical instructions
- control instructions