Code completion ...
The Code Completion Feature comes under 3 different forms, in order to try to adapt its functionality to the real everyday usage. They are:
1. User Defined Symbols Completion
2. Api Calls Completion
3. OS Equates Completion
In the [Configuration] Tab [Source Editor], you may choose to enable the Code Competion feature.
Once this Flag is set on, you initially will, in all cases, have the OS Equates and Api Completions. After the first successful Compilation, you will also have the Completion for the symbols as defined in your actual Source.
The Code Completions attempts begin when the 3rd Character is entered.
User defined Symbols Completion
In the Completion mode, a Symbols Table is built, after each Compilation, with all the Equates, Code and Data Labels, and Macros Declarations found in your Source. This Functionality is effective after a successful Compilation only.
When typing in, a Routine checks the table for a matching Symbol. If a matching Symbol is found, your typed name prefix is underlined. Once underlined, if you hit [Ctrl]/[Space], the Completion is performed.
There is no ListBox coming out with this form of Completion because, if your symbols are correctly choosen, you should not, usually have many Symbols beginning with the same Prefix. In most cases, the ListBox would not even come out, because it would hold only one Symbol.
Another good reason for not having a ListBox, with this form of Completion, is that the Names inside the Compiled List are under the cooked form the Assembler requires before parsing, this is to say entirely upper-case with underscore ripped off. It would be a bit confusing, for you, when seeing your symbols in that form.
This is why, for this form of Completion, the underlinement is proposed only in cases of univoque Item.
The final replacement takes its model from the first identical name found inside your Source, in order to take care of the Cases and of the underscores, if any. This enables you to have an easy and quick way for having clean, consistent and standardized Cases and underscores used all throughout your Source. Example:
Say, you have in your Source:
[M00_File 2001 ... ]
Now, you type in:
.... m00f
The feature detects the fitting Symbol:
.... m00f
Then, if you hit [Ctrl]/[Space], it becomes:
.... M00_File
The underlining occurs only in case a possible choice is ensured. For Example, if you have (like we do have in ''Base3.exe'' File), 3 Symbols like these:
Hexprnt // Hexprint // HexprintString
When you type in:
hexpr
... nothing happens because there are two or more conflicting solutions. But if you type:
hexpri
It is then underlined, and [Ctrl]/[Space] will perform:
Hexprint
Then, if you hit an 's', you get a one an alternate choice:
Hexprints
and, if you hit [Ctrl]/[Space] again, the completion will turn it into:
HexprintString
Api calls Completion
When typing a call to some Api Function, the underlining does not wait for a univoque option, the way it does it for your own Symbols (it would be of little help, given the number of Functions beginning, for example, by 'Create....'.). So, in case of multiple choices, when you hit [Ctrl]/[Space], a ListBox is run, instead, offering the various matching Functions Names. In case of univoque option, the replacement is done, the same discrete and quick way it is done for the user defined Symbols.
To open the Api ListBox, you just hit [Ctrl]/[Space] when your inputted prefix is underlined.
While the ListBox is open, you can go on typing your Prefix, in your Source, in order to reduce the choices number accordingly. You can, of course, choose an Item by any of the usual methods, in the ListBox, or go on typing in, up to the point when there will only remain one single possible choice. To enable the List Box with the Arrow and Return Key actions, you have, first, to give the Focus to the ListBox, otherwise, Arrow and Return Key, while you are typing in, in the Source Editor, will only affect the Source Editor.
Just like the OS Api, this feature is case sensitive (as opposed to the User Symbols version).
If the DLL Name is also found by the replacement Routine, it becomes part of the replacement. This is to say that, in such cases (actually not all cases, because our List is not yet complete), if your writing does not have any DLL name, or a wrong DLL Name, the proper DLL name will be provided for free by this magic Functionality.
This feature will not work, if the Location for the Functions.api File is missing in the your Configuration of RosAsm.
OS Equates Completion
When you start some input with ''&'', the Completion considers it to be for an OS Equate, in all cases.
No matter if this input fits with some effective Equate or not, because of the size of this List: In all cases, the underlinement will come out. Then, when you hit [Ctrl]/[Space], the feature's behavior will depend on the situation:
One single Item fits with you input: The replacement is done.
Several Items fit with you input: The ListBox is run, with the same behavior as for Api.
No symbol found: You are proposed to load the whole List for a search. This Functionality is optional because, on older Computers, given the time required to recreate and to load such a huge list, it would be utterly unusable. Also, it is not desirable to keep such a huge list in Memory, for such infrequent use.
As all OS Equates are upper case, this feature is case insensitive. You may as well input your OS Equates Names lower case, and you will have them upper case after Completion.
~~~~~~~