12/31/00 V0.01

 I have made the main core of the intel assembler, (or, remade) this time,
it's in assembly. The loading of the lines (getline) is slow, because it
loads one line at a time rather then a larger chunk, and then verifying.
 I will update this some time after i fix it all.. I may be able to delete
a whole section (64K) But, does it really matter?

 I also have started on the instruction identifaction algorythmn, to make it
smaller, as well as faster, and easier to update, i am making it a library
format. I will explain how it works some time later. I suggest not to touch
it yet (incomplete)

 Primary functions include:

 1) Loading Assembly file, and filtering out empty lines and comments.
 2) Uppercase everything (except for within the "'s)
 3) Identify and use labels (also prepairing, based also on CPX)

 Coming functions:

 1) Identifying the Instructions (with extensive information)
 2) adding more label support (+, -)
 3) Adding more number support (getnum will add and subtract as well)
 4) Includes    (allowing the Includes, also, a special Instruction, INCLUDE)
 (INCLUDE will tell it where to paste all the include data, so the rest of
 the data (at the end, labels?) Are un-effected)
 5) update every CPX on every label ($)
 6) Identify and use $


 List of Reserved Label names, and information:

 DB - Direct Byte, Straight input (built in) (text allowed)
 DW - Direct Word, Straight input
 DQ - Direct Quad, Straight input
 DDW- Direct Double Word (same as quad)

 <INCLUDE> - Location to paste includes.
 <INSTUCTION>:
 A special set, you can put in a number (computer version, 386 ect)

 16 BIT - Native 16 bit instructions
 32 BIT - Native 32 bit instructions
 <RESEARCH ??>
 This tells it how many loops it must preform before the final phase.
 (minimum of 1)

 <VERSION ?????>
 Saves a text for the FASTFILE (for comparing, so you don't make faulty
software, should the text fail to match, it will display an error, and skip
the fast file, resuming normally (a little slower, but will work))

1/10/01 v.02
 Working on the instruction identifyer, this is no easy task. I have also
come up with an idea for software compadibility, and extending the sets,
slightly.. This will save SOME programming time, and a few lines of code,
Technically, they are Macro's, but as long as they are within 16 bytes, and
saves everyone from having to write too much to do the same thing, i am
happy with it. Best part, is they don't take up that much more space, so you
can write software for 386+, and then compile it for 8086+, and it will
still run. (i don't think there are THAT many people that use it that much)

 Also, a slight 'Extended' Set, is allowing segment/segment manipulations, and
a few other tasks. But these will get big after a while, unless i come up
with a new method to encode it, which makes my work VERY slow.

 Anyway, i have the single instructions completed, for now i will finnish
the main core, after i touch up the code.

1/26/01 v.03
 Some updates..

 I have added complete Addition and subtraction with labels. You can now do
that to all labels, instead of CPX. Also, i put a little shortcut in, and
when you work with CPX, it will recodnize it, and update it accordingly. So
that's working. (+ -)

 I found a bug in my Instruction Identifyer, and i have fixed it. Right now
it only does the single instructions, without any input data, but that will
fix soon enough. I will have a beta out soon enough.

 I've also added Debug printing.. I haven't quite got it finnished, but a few
more minor changes, and the core is complete.

 What i need to add in:
 Addition and subtraction in the number identifyer. This will allow a lot of
flexibility. Once i get it working anyway.
 And updated Getline, to get 1 line, but this way MUCH faster, it will take
some time.

 Instruction Identifyer:

 1 and 2 data in's to complete the list.
 Identifying jumps, and other bits
 Section Identifyer completing (bugged)
 
 The program is on the way :)
2/3/01 v.04
 I have added in the new GETLINE command, built to be faster, and more
effective. Only a touchup required for it to be ready.

 Also, in the hew GETLINE, it supports UNICODE loading.. from UNICODE, and
ASCII. This allows for a stable, useful, translator. (before using GETLINE,
use GETLINE_CLEAR which will prepair a 64K block for use with getline. Each
64K block will work with 1 file(Buffer?))

 I have added the special controls in, and i have a beta of the program
working. Adding in are various tools, but i have overruled a new set for
jumps. Instead i have devised a smaller, more complete routine, that will
work for the time being. in fact, it should work reguardless..

 A few bugs, in the PART identifyer (identifies the first and second data
parts) and it works now.. will identify 0,1 and 2 parts. (3 parts are special,
i might build one, should i understand HOW it works..)

NOTE: INCLUDE, This special instruciton will include the INCLUDE information.
(special run) Also, ALL information directly involving 'Structures' will start
to be supported. I will supply rules for the structures and includes.

2/5/01 v.05
 More work on the instruction Identifyer, and also. I have rebuilt the entire
GETLINE command. This new command, is just bigger. It also works a whole 64K
section for a file buffer.. This way, in basic terms.. Is faster, because
it doesn't keep requesting just 1 bytes.. instead, finds the line, and
copies it.. All of it isn't there? oh well...
 To make it easier, i have changed the instruction set part in for the set
you wish to use.. You add a period in now. (like Microsoft's one.. so it's
compadible, and you get the feel of it..)

3/5/01 V.06
 Fixed a bug, and i have the main of the instructions with 1 input in working
but needs work. The bug was not printing the whole line of it's current
information, as well as finding a bug in my V.23 compiler. (can't fix yet)
 I also have the whole instructions (text only) working. I can do basic
programming for tests now, but they don't need a lot of work. so the SET is
done for now, supporinting about 60 instructions (single, MMX, FPU?, and
others)

5/18/01 V.07
 Working in on some of the instruction set, while adding in parts for Register
access. The Identifying parts are done, as well as the registers in, for the
set file. I have tested, and it works well. There seems to be 2 bugs present
that make a large difference. First, is if you leave a label empty (without
and instruction immedately following) the last instruction will repeat.

 The second bug, has to do with the Call (jumps?). But a bit more is done.
The special instructions of DB has to be entered in manually for it's own
section (being built in) as well as specials need to be finnished.

5/19/01 V.08
 Completed, Several bugs have come forth, in a beta test, and i have found
and removed the most of them. Including a number bug, where it was searching
for the wrong thing. And also, the num_type check, if you have WORD or BYTE
in, it will have that overwritten.. now if it's unused, it will add it. All
number computatiions (if not locked) will be flexible now, based on the number
before it creates the code. Also, several instructions were added.

5/21/01 V.09
 Fixed the last of the original bugs, and the 'Exact' formula is working.
Other parts are being put in and tested as of yet. The empty label is now
fixed. Negatives are fixed, and negative identifacation, is working
(and updated), for now. Registers are up and running, with their exacts.
What's left is the memory (the hardest part). Afterwards, all single input
instructions will be added in.

5/21/01 V.10
 Some more bugs found. Based on the instruction set and database. Several new
checkers are in place, and will notify when the database holds bad codes. The
original 'standalone' instructions had a couple bugs, and needed a major fix.
The 'Opinclude' is now limited to the first 3 for those (rarely used) but
otherwise works fine. As well as an update to the code for it, where it no
longer just adjusts it if it's 32 bit, but also for 16 bit (same as single
and dual inputs).

 Most of the Single instructions (1 input) have been added, but they lack the
power of memory access (yet) which will be done soon. Backups of special
'exact' instructions have been made, until it's complete. And the general
ones are left on (also alternate encodings), which will work until it's all
complete. In the set file, i had to change a bunch, and fix my own errors.

 I have also added in a special encoding for the single instructions (1 input)
When it's doing a register, the space that was reserved for numbers only, was
opened up, allowing lots of flexible programming. Rather then having to add
tons of exacts, it will free up the special encodings for the single
instructions. When complete, i will take on the challenge of the duals.

5/22/01 V.11
 Another bug found. This bug simply, was wrong. Every time the database was
searched, the new instruction (reguardless if it was used) was saved as the
new information. Should it be skipped through (unknown instruction) it might
write a 32bit change.. Now it will not save it until it's properly written in.

5/25/01 V.12
 Getnum has new codes in it to understand the end of the number. And adding
power to the DB, DW and DQ/DD commands, for internal instructions. So far
they understand, and computate numbers. Also input's Text, but requires the
DUP half of the instruction, in the following format:
 DUP(datasize), number/text
    Ex. DB DUP(255),45
 OR Ex. DB DUP(255),"TEST" (will loop TEST until 255 characters are met)
But some updates still need to be done. 

5/26/01 V.13
 But in REPLACE found. Two parts, if the value was 0, it was emptied, but
never replaced. Now works with 0's. Also, it only looked for the first one.
Now will find all matches and replace them.

5/27/01 V.14
 More bugs, Involved in the identify. There's a bug with an empty line
(just after using a label) i am going to fix it, since i haven't yet. As well
as some slight re-arangements will remove all error codes from getting involed
until they are ready. The direct code seems to work Flawlessly, and will
not be changed for now.

7/09/01 V.15
 Work on the memory is slow and tedious (as my assembler is slow right now)
but it's getting there. I have just completed the majority of the work, now
to add in the codes, and get it going. Memory_part Done.

7/14/01 V.15
 Memory functions are done, i've also fixed a distance32 bug, having set in
the wrong values. Now they will read right. In a couple days, all single
instructions will be entered.

7/16/01 V.16
 Well, in the process of testing it, i ran it through it's own source code.
I ran into a problem, it died. When i looked in the temp file, a single line
was being re-written over and over and over again.. never ending.. I spend
plenty of time, when i looked at the next line, it was all spaces. That was
the bug, and now it's sifted out, looking for that before trying to use the
line as code. (annoying little devil). Anyway, the assembler is VERY fast :)

12/24/01 V.17
 Programming away. I am putting in the EXACTS for the two inputs, and
finnishing my incomplete work. Oh, all single instructions, and single in,
instructions are in. Time for this part to finnish the rest.

12/25/01 V.18
 Annoying bug found, In a previously 'done' section (1 input) i found a
Nasty little bug, when executed for a memory location, and then the memory
size wasn't right, it skipped the next instruction in listing.. that could
easily MISS the next one in line.. Which is what it did. Though i would
bring him up, he's a special one :) the bug is from when the ADD SI,4. When
then later, executed the instruction 'jmp near nomatch4' which adds 3, it
gets lost and skips the instruction. Bad way to go. Now it's fixed.

12/27/01 V.19
 More tidbits fixed. Also Started writing in the codes for the rest of the
2 input instructions. We will see how it comes out.

12/29/01 V.19
 Things to ADD:
 Local Loops: ".label" These are the same as labels, only you can have more
              then one of them. The closest one to CPX will be the one used.
              (in the code, will have locations (32bit) for all labels of
              the name of the local loop)

 Macros:      Preset assembly sets. Either in DB form, or in actual code.
              That is up to the user. (probably code) notes allowed too.

 Object code: I am not sure, depends on how the hooks work.

 Workaround:  ENTER (2 immediates), and for 2 regs, that are backwards.
              (the uncertain code (2 bits) may determine that information)

 Variables:   Variables, common in other systems without the label Colon :

 Setless:     Clear the SET segment before starting. (Without the set, stable)

 Signed mem:  Signed Memory (with immediates) need help. Probably the uncertain
              2 bytes will help here.

01/01/02 V0.20
 Workaround complete, along with a few other settings. Found another bug,
this bug has to do with the SETS file. if a SET file isn't there, the
program closes a wrong port, and tries to read from a bad port too. should
be fixed now.

01/02/02 V0.21
 Found the segment codes were wrong, they are fixed now. There's some bug
with larger files, that memory functions (with immediates) don't work right,
working at it now.

01/04/02 V0.23
 Fixing little details and bugs that needed to be fixed. Fixed a bug allowing
two exact registers should work right now. (or better anyways)
01/05/02 V0.26
 Fixed and added in for Jumps, if they aren't set, it tests them, and sets
then either SHORT, or NEAR. But it won't show in the code. (Nasty bugs there)
Anyways, got new versions of that going, other bugs gone, it works, and
other programs work too, with minor adjustments. V0.27 will be selfcomplete,
not needing a SET file, but the set file will have to be included in it.
(Reminds me of other features to add)

 Features added already: Setless, Signed Mem, 'undefined' jumps / calls,
fixed ENTER bug, and backwards codes.

01/05/02 V0.27
 Self sufficiant program, ready to run :) set files for special cases, if no
set file, it runs it's own :)

01/05/02 V0.29
 Added and finnished the FASTFILE Make, and FASTFILE read. Makes those
projects easier. Also got some emulated instructions in the IDTEST.

01/06/02 V0.30
 With a small experiment, saw that there was a problem in the 'undefined'
jumps, a chance that it could not work.. that's fixed now. And reconfigured
the Self Sufficiant part.

01/06/02 V0.33
 ! * # includes are in and working.
 *Filename: Immediate input, total from file. In this spot
 #Filename: Functions to get from
 !Function: Functions to get

01/07/02 V0.35
 Optimazation added. This coding will ignore the codes set forth by means of
SHORT and NEAR.. and choose the best of them, and of the instructions. For
Simple programming, make all jumps and calls NEAR, and then use this to
shrink when space is needed, or when you are done the final product.
 Also fixed a bug, and added more error codes in, in case functions aren't
put in right.

01/07/02 V0.36
 Fixed minor bug, and added a feature, that may never be used. But it's there.

01/07/02 V0.37
 Put Workaround for 3 inputs, the third being a number. (MMX)  

01/08/02 V0.38
 Fixed a few bugs, And added a few override, allowing certain MMX features to
come along. Also allowing the FPU to work easier. And found bugs there to.
That was hard work :)

01/08.02 V0.40
 Few bugs fixed, and the Distance for FPU functions are finnally working.
Extended options, so when you use 64bit, it changes the number function, so
it's X4 of what you put in. so here's the chart.
        Bytes       Bits
Input: 0 1 2 3    0 1  2  3
Not64: 0 1 2 4    0 8  16 32
Now64: 0 4 8 16   0 32 64 128

01/08/02 V0.41
 Added 64bit support to Single instructions, for FPU's.

01/09/02 V0.42
 Fixed small bug, for smaller files using the Optimize, it ensures that there
are a minimum of loops for the fixes.

01/10/02 V0.43
 Found a strange bug with the DUP() command. the bug wasn't obvious, unless
it tried to write at FFFD or higher, because that overrides the size, making
a segment overrun. (Major error) It now checks to see if it will do that,
and if so, will put them in place. they should fix themselfs, usually 0's
or negs, and will do fine :)

01/14/02 V0.44
 Well, i noticed a bug, that negs weren't fixed. I fixed it with a slight
change. If it's a neg, it will make 1 of the smallest size. (minimum) and
if it's larger then it should be? Well, it makes it at the max. simple as
that.

01/14/02 V0.45
 Removed annoy spaces from the : to the instruction in the 'debug' file, and
output.

01/14/02 V0.46
 Removed the spaces in the 'debug' file, from labels ends. took a little work

01/16/02 V0.47
 Finnished Specials (for now) Allowing Switching between 32 bit, 16 bit, and
different computer versions. Here they are now. (These will be fine, until
more are needed.)

 Computer Version   Ex: <.286>
 Originate location Ex: <ORG 100h>
 16 Bit Processing  Ex: <16 BITS>
 32 Bit Processing  Ex: <32 BITS>

01/03/02 V0.48
 Fixed a bug with the segment overrides.. it would mix up labels, if they
ended with the segment similar. Example: test_cs:   this makes the error.
it should be fixed now.

01/03/02 V0.49
 Added QUICK feature. This is for when you want a program quicker out, and
will assume ALL jumps to be at least a near.

 MAJOR NOTE: When doing a FAST make or FAST use. Always assume it's going to
use Optimized. Otherwise there could be bugs. (Or unless otherwise specified)

02/09/02 V0.50
 Workarounds have been added for: ENTER. (which needed 2 numbers) the data
for now is perminently set for the first half to be a word. Second part is
the size for determined input. This allow enabled the 'exact memory' that i
delayed on working on. That is now in, and working.

02/18/02 V0.51
 Added check support for the TEST.SET file. Main concern is with
compadibility with the version. Some newer versions of the TEST.SET won't
work with older versions of the program, as other workarounds and features
are added. So the version will take effect, for what version is needed (at
least) for it to work.

 Also a note. FAR jumps have NOT beed added as of yet. When they are needed
I will add them.

04/11/02 V0.52
 Seems somewhere along the way i deleted my specials. Had to re-add them,
so here they are again. NOTE, this time around i've added another. SET
for the optional includes. Should be most interesting :)
