r3120 (2023-09-10)
==================

About time to make another release. There are some fixes for reported
problems (thanks!) and for some more I've noticed myself. For new
features check below.

**Fixes**

* Line numbers didn't always show up in listing file when requested.
  Was a regression, there was a workaround but it's not necessary now
* Listing file didn't listed labels at the end of functions/macros.
  Now it does
* When .binclude failed it could cause an unexpected too many passes error.
  No such surprises now on filename typos.
* Some versions of GCC miscompiled the source with LTO optimization
  It resulted in an immediate crash at startup. It's worked around now.
* Possible issues fixed with (0, x) style indexed indirect addressing
  This workaround should have been done more carefully. Should work now.
* When outputting a specific section the output was incomplete in some cases
  I usually used complicated arrangements which worked so it was
  surprising to find that in special a simple one it didn't
* Parsing errors could cause unnecessary undefined label errors
  It does not do this any more, so less noise in error messages.
* Zero length concatenation of inverted bits/bytes was not correct
  A very special case.
* The order of indirect parameters in format() was wrong (broke in r2345)
  Haven't used it until now and was surprised to find this.
* The line number was at the wrong place in listing in some cases
  Now it's always in front where it should be.
* There was a complicated way to cause a crash through encoding definition
  One of those what would happen if experiments. Unlikely anyone
  encountered this.
* Katepart syntax file was incompatible with newer version
  There were silly mistakes in XML which were accepted in earlier versions.
* Possible crash fixed related to iterated bfor error handling
  The error case handling had a mistake.

**Changes**

* .align and .page directives have offset parameters now.
  It can be useful to shift the page windows up/down
* Listing time uses file modification times if possible
  So the time stamp can remain the same across re-compilations
* Improved documentation
  .page moved to the new alignment section. And lots of other fixes.
* Deprecation warning for non-spaced @b, @w and @l
  It's planned that more than one letter will be used after the @ symbol
  in the future. Once that's implemented any following non-spaced
  separated label or number will become part of the symbol! So it's
  advised now to add the missing spaces to avoid broken code after a
  future upgrade.

**New**

* Added -Wpriority command line option
  Common operator priority mistakes like >lbl1 != >lbl2 are reported now.
* Added -Walign command line option
  Wasted space on doing alignments can be diagnosed now.
* Added .alignblk/.endalignblk directives
  Alignment block for avoiding page crosses without wasting to many bytes
* Added .alignind and .alignpageind directives
  It's now possible to align further ahead than the target location
* Added --simple-labels command line option
  Label files in traditional label=$1234 style for simple parsing.
* Added --mesen-labels command line option
  Experimental Mesen label file output.
* Added --labels-add-prefix command line option
  When listing labels it's possible to add a prefix to symbols now
* Added --labels-section command line option
  Label listing can be limited to labels pointing to a certain section.
* Added .from directive
  For defining a symbol based on an already existing one somewhere else
* Added --dependencies-append command line option
  For consistency.
* Added .elif directive
  An alias for those who tend to mistype .elsif
* Added --c256-pgx and --c256-pgz command line options
  Both are simple formats and a variant of existing ones.
* Binary and hexadecimal can be bits instead of int.
  So format("%~#x", ~$2) is "~$2".
* Added --output-exec command line option
  Now the execution address can be defined for those output which have
  such concept

r2974 (2023-01-11)
==================

This is a bugfix release due to the broken multi file output. There were
a bunch of encoding related work meanwhile so these are included as well.

**Fixes**

* There was a mistake which could cause crashes (usually on Windows)
  when outputting sections to multiple files.
* Linking to older versions of MS C library could result in unexpected
  behaviour when Unicode characters were attempted to be output due to
  differences to ISO-C. Such functions are not used anymore. The
  precompiled binary used a recent enough toolchain and so was not
  affected.
* Map file output not written to a file could still report a file open
  error if the standard output was redirected and that couldn't be written.
* In some cases ANSI colour sequences could end up in text output to files.
  This shouldn't happen now.
* Memory maps written to files were not added to makefile as outputs.
* The Notepad++ syntax file was incompatible with dark-mode as it set the
  text background to white instead of transparent.
* When running on DOS the code page was not detected with some versions
  of the OS.
* Attempting to use it on Windows versions without wide character
  support resulted in immediate exit. Now it can be used as normal.
* When trying to use options with non-ASCII characters the error message
  showed garbage.
* Coloured diagnostic messages only worked in console window but not in
  mintty (unless compiled for Cygwin). Now it should work with the
  native version as well.
* Depending on the C library memory map output could hang due to a
  mistake. (e.g. on Amiga)

**Changes**

* On Windows the file encoding for "ANSI" files were assumed to use the
  encoding from the current locale. However this can be different from
  the active code page what text editors are using. Now such files are
  assumed to use the active code page unless the locale is set differently
  in the environment. Regardless UTF-8 sources are best for portability.
* On Windows text output (e.g. listing) was UTF-8 or ASCII depending on
  the toolchain used. Now the default encoding is the active code page.
  This can be UTF-8 on recent systems but in any case it can be forced by
  setting an UTF-8 locale through the environment.
* Depending on C library version printable Unicode characters showed
  placeholders even if the encoding would allow for it (e.g. UTF-8).
  This is now determined internally to be consistent across platforms.
* The subset of Unicode characters usable in identifiers got more strict
  now.
* Updated to Unicode 13.

r2900 (2022-11-05)
==================

It's time to release a version now. People are looking for fixes which were in
trunk for a long time now.

**Fixes**

* Paths with parent references don't give bogus portability warnings any more
  On Windows the due to an oversight parent referencing paths incorrectly
  triggered the portability warning originally intended for detecting a
  filename case mismatch.
* Arbitrary length int right shift was wrong in some cases.
  Now it's correct.
* .bfor didn't accepted .endfor closing in some cases
  Now it's correct. Did always work with .next and I didn't transitioned the
  test sources...
* (0, x) is now recognized as indexed indirect for opcodes
  The parser of course did recognize (0,x) just fine for opcodes. However
  writing (0, x) is a tuple and so does something else.  There's a workaround
  now to recognize such a construct as indexed indirect instead. This should
  avoid bad surprises for those unaware that the indexing operator should not
  have a white space there.
* Writing to standard output suppresses messages in all cases
  This only worked for output files but now for everything (e.g. listing
  to "-" didn't suppressed messages while --output "-" did).
* The TASM compatibility text macro parameter expansion was wrong
  It didn't remove the quotes from strings. It broke quite long ago, now
  works again.
* Output append didn't reproduce gaps working correctly in some cases
  Padding was corrected and now it does.
* Output could have garbage in gaps on non-POSIX conforming systems
  Unlikely anyone got that far in porting but gaps should be correctly
  filled with zeros now

**Changes**

* JMP and JML are distinct now
  JMP could be unexpectedly upgraded to JML in some cases (e.g. bank 0 address in
  another program bank) which is bad as the program bank will be changed when
  that happens. Now it's consistent with JSR/JSL.
* label = 1,2,3 is the tuple (1,2,3) now
  That makes it actually useful for something. Before it was an object
  with one couldn't do much with.
* .switch and .if blocks labels have size now
  Everything else with regular code blocks worked that way already.
* %c in format() applies padding now
  For consistency with the rest of the format parameters.
* Oversize integer diagnostic in bytes and bits now
  It was in bits all the time but if the limit was set in bytes it makes
  sense to give the error in bytes as well.
* Compound assignments can now change variables in parent scope
  Without this using .bwhile is a pain as the loop condition variable is
  usually declared out of the loop (and so the scope).
* The memory map was improved or at least is different now.
  With the former memory map there were lots of redundancy if one used
  sections. It was even worse with nested sections. The new memory map
  tries to display overlaps more compact. However for most people with simple
  projects the difference would be the length display in decimal on the left
  and that gaps between data areas are shown now.
* Per output memory map, also writable to file.
  The memory map was global before. Now if a specific section is output
  then only the relevant parts of the map is shown. This also means that
  if there are multiple output files then there are as many memory maps.
  As a side effect .virtual blocks aren't displayed any more as these
  don't really belong to an output file.
* The .enc directive now requires an expression
  In the past one could write the name of encodings without quotes. Soon there
  was a need to allow labels to hold a name so there was a warning to quote the
  names for the past 5 years or so. Now that custom encodings can be assigned
  to labels there's an even greater need to be able to use labels. Therefore
  the old style unquoted encoding names will be now interpreted as labels and
  will likely fail to be found. Please quote the old name or as a workaround
  define the missing labels with a string of the encoding name (e.g screen =
  "screen").

**New**

* .symbol in namespace
  Now it's possible to check if a variable exists in a namespace. May be useful
  to check if a variable is defined. No, this does not work with constant
  definitions.
* Function parameter conversion
  This allows to have a parameter like "data : binary" which calls
  binary() and its result is assigned to the parameter. This allows to
  load data relative to the caller's file and not relative to the file the
  function is located in.
* !in and !== operator
  Instead of !(a in b) now it's possible to write a !in b. Also the ===
  operator got its !== pair.
* Multi operand opcodes do broadcast now
  It was only working for single operand ones so far, now it's consistent.
* Bit strings can be iterated now
  Just like character and byte strings did already
* ::= reassign operator
  This can change a variable in parent scope. Unlike := which instead
  would create/update a variable in the current scope instead.
* Better reporting of unexpected characters
  Strings should be quoted with straight quotes. Using fancy quotes did
  result in an error but it was difficult to make sense of it as the
  difference is hard to spot. Now the diagnostic is more clear.
* --mos-hex for MOS Technology HEX format
  There was Intel and Motorola before but not MOS yet. There are 6502 platforms
  needing this.
* --list-append added
  Now listing can be appended too, just in case.
* .encode/.endencode encoding area
  This allows to have local encoding definitions. Such definitions can be
  assigned to a label to allow reuse in other areas. Can be used as string
  conversion function as well.
* Added .tdef for easier encoding definition
  It was not easy to define translation for randomly scattered Unicode
  characters so far as .cdef was made for ranges like A-Z. One had to
  define a bunch of single character ranges but such a workaround can be
  replaced now.

r2625 (2021-04-25)
==================

The last release got more than a year old now and there were
plenty of pending corrections to be released. Some planned
features still didn't made it in. Maybe next time.

**Fixes**

* .fill/.align multi byte pattern fix
  Broke due to changes in r1845.
* Wrong diagnostic for incomplete byte string
  The missing closing quote was pointed at the wrong place
* Incomplete diagnostic message
  The opcode was not displayed in some cases
* Diagnostic locations fixed
  In some cases the location was wrong
* Duplicate diagnostic messages avoided
  In some cases redundant diagnostics was output
* Crash while .function declaration and macro init parameters
  Found by Pierre
* Improved filename portability checks
  In some cases case insensitive filenames were not recognized
* Diagnostics of non-portable filename characters improved
  Now points at the problematic character.
* Functions did not execute as loop and other conditions
  Now they do.
* Can't calculate errors related to functions
  In some cases these were incorrectly reported
* 4510 missed had () instead of (),z addressing mode
  Now same as 65CE02 in this regard
* Improved format() diagnostics
  It's more strict now
* Floating point bitops didn't work as intended
  Actually in some cases they did work but mostly not
* Dot eor operator works again in TASM compatible mode
  Got broken due to syntax clash with hexadecimal floats
* Wrong message text for invalid unary operators
  Tried to diagnose them like binary by mistake
* Improved syntax highlighting
  In some case it didn't highlight well on vim
* Byte string compare didn't work properly
  In case a byte string was inverted.
* In some cases .null failed to detect zeros
  For example for ~$ff

**Changes**

* Comment nesting
  Directives are not recognized now in commented block
* Negative size an error now, size extension a warning
  If an offset reduces a memory area beyond 0 it's a fault now
  (instead of 0) and extension beyond the original size a warning.
  Controllable through -Wsize-large.
* PC bank wrapping gone now
  Seemed like a good idea but crossing banks with long data gave
  unexpected results for many people.
* VICE label de-duplication is gone now
  Was intended to avoid warnings on import but actually breaks
  symbolic breakpoints if the needed label gets deduplicated...
* -Wswitch-case gone now
  Could cause unexpected side effects which is a no-no for diagnostics
* Ident renamed to symbol
  For less confusing diagnostic messages
* Long values not displayed in listing by default
  They cluttered up the listing. They are still displayed in verbose
  mode.
* Dictionary keys must be identical and not equal
  Otherwise bit strings can't be matched properly for example.
* Hex float format from format() gone now
  Seemed like it's easy to add without much effort but it was not cross
  platform.
* Bit string extraction operators now return bit string
  Did return bytes for a long while but now I realized those may not
  compare as expected in some cases.
* Multi line expressions are gone now
  Seemed like a good idea back then but they cause more problems than
  they solve. They were never documented due to all the unsolved edge
  cases anyway.
* Duplicated label files do not append automatically
  It must be done now explicitly with --labels-append
* Unnamed values not listed in listing any more
  There's no label so makes no sense

**New**

* Immediate operand to branches
  It's now possible to write 'bne #0' (for self modifying code)
* Hexadecimal byte string literal separation with spaces
  Space is accepted now in hexadecimal byte strings like x'ab cd'
* Various byte string functions added
  Like byte(), word() and friends
* New --output-append parameter
  For appending the output to a file instead of overwriting it
* New --no-output option
  For cases where no output file is needed
* Symbol definition syntax
  May be defined with a dot prefix. Useful as dictionary keys.
* New .sfunction directive
  For defining single line functions which only do calculations
* Alternative end directives
  Bit more verbose but more consistent and easier to remember.
  E.g. .endpage vs. .endp
* Identity operator (===)
  For exact matching
* --no-error and --error-append
  To not save or append error messages
* Broadcasting conditional operator is '??'
  Sometimes broadcasting is needed but that's not compatible with the
  regular '?' conditional operator
* Diagnostics for interrupted compilation
  Now it's displayed where it happened for improved infinite loop
  debugging.
* --labels-append
  For appending to label files.

r2200 (2020-04-07)
==================

This is a bug fix release to fix the unintended performance degradation on some
systems like BSDs.

**Fixes**

* Revert buffering changes
  These caused really slow performance on some systems which I forgot to test.
* Makefile name escaping
  It's not the same as for shells and is more limited. So names with spaces
  should work now but otherwise it's advised to avoid incompatible file naming.
* Bold black is not be visible on black background
  Changed to cyan.
* Unicode parameter file names didn't work on some platforms
  Forgot a conversion so only UTF-8 worked

**New**

* Coloured output on windows console and DOS.
  This was available for a while but not for these platforms. Real DOS needs
  ANSI loaded and TERM set.

r2176 (2020-03-23)
==================

There were quite many changes in trunk so it's time to release another version.

**Changes**

* Removed -Wtype-mixing 
  It was a transitional warning just in case someone relied on an undocumented
  tuple/list mixing which changed earlier.
* Floor rounding is used by default now, added -Wfloat-round
  The old method was to truncate but it was not consistent with the integer
  division and was problematic when using floating point to represent
  fixed point numbers. The difference only shows for negative numbers.
  Just to be on the safe side there's a new warning now for cases where
  the programmer could use one of the rounding functions explicitly to avoid
  a rounding ambiguity.
* Handling of address space wraps in calculations
  There are various address space wraps depending on the CPU. As an example the
  zero page may wrap or may not with indexed addressing. 64tass now tries to
  wrap when an offset is applied to an address to keep it in the same address
  space. E.g. a label at $10 in the expression lda label-$20,x results in
  lda $f0,x for a 6502 but lda $fffff0,x for a 65816. In all cases there are
  warnings issued for such an ambiguity. If it's intentional it may be
  suppressed but usually it's not.
* -Wmem-wrap and -Wpc-wrap renamed now to -Wwrap-mem and -Wwrap-pc
  To make them in line with the other bunch of new -Wwrap-something switches.
  Please update your build scripts. They won't fail just yet but may in future.
* Only --export-labels references labels
  Listing labels incorrectly referenced .proc blocks and so just by doing a
  label list unused .proc blocks got suddenly compiled in. This is unexpected
  and should not happen for a simple label list therefore it won't any more. If
  otherwise unused .proc blocks are needed in the label listing please add the
  new --export-labels option to get them listed and compiled.
* Star is finally a label now
  Before it was only a number but as the theory goes it should be the
  memory location at the beginning of the line. This means label = \* + 1
  constructs are now correctly referring to memory locations.
* Variables are not listed in VICE label list any more
  They are ambiguous as may be assigned multiple times and usually don't refer
  to memory locations
* Dictionaries are order preserving and iterable now
  Earlier order was undefined.
* I/O error messages or in C locale now
  As the rest of the messages aren't localized either.

**New**

* Add -Wmacro-prefix
  Warns about macro calls without any prefix in front
* Add WDM opcode
  It was requested for 65816
* Added .while and .bwhile
  Could be done with .for before but it's cleaner this way
* Add .breakif and .continueif
  Simplifies .if .break .fi and .if .continue .fi sequences
* Functions got a namespace
  The function itself can hold symbols now so there's no need for an
  additional label just to store data across invocations. That is
  "functionname.stuff := 4" works now.
* Lists can be used as keys in dictionaries
  On query th                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     