Changelog

   __/__/2011, v2.07:

   Bugfixes:
   -  ELF format: size of .bss segment wasn't set.
   -  ELF format: segments of class "CONST" weren't marked as read-only
      in the ELF module.
   -  segment attribute INFO wasn't handled for ELF.
   -  Win64: in v2.05-v2.06, VARARG didn't work for the - first 4 - register
      arguments.
   -  when a procedure's prologue and epilogue code was generated, it was
      assumed that radix was 10.
   -  if the size of a byte array in a structure was defined by the length
      of a quoted string initializer, it wasn't marked internally as array
      and hence the initialization of data items of this type may have been
      wrong.
   -  if wasn't checked if a string initializer for a simple byte field
      in a struct was too long.
   -  if a struct contains fields with negative offset, the struct's size
      was calculated incorrectly.
   -  JWASMR.EXE: in a few circumstances, negative constants were rejected.
   -  in v2.04-2.06, it wasn't detected if a group contained an undefined
      segment.
   -  INVOKE: if the argument for a VARARG parameter was a structure, it
      was rejected in some cases.
   -  a line that contained both a comment and a directive which triggered
      source line generation (INVOKE, hll directives, ... ) messed up the
      listing.
   -  EQU/= directive: optional type coercions weren't stored, just the
      value of the constant.

   Other changes:
   -  IF[N]DEF and .ERR[N]DEF directives: argument may be a structure and
      member name, separated by a dot.
   -  cmdline option -Fd: filename argument for this option is no longer
      mandatory for COFF output format.
   -  FADDP, FMULP, FDIV[R]P and FSUB[R]P variants with no arguments added.
   -  COFF/ELF: missing support for segment attribute ALIAS added.

   07/22/2011, v2.06e:
   
   Bugfixes:
   -  ELF64 format: in v2.05-v2.06d, addends weren't handled correctly.

   07/02/2011, v2.06d:

   Bugfixes:
   -  64-bit: in v2.05-v2.06c, a relocatable constant was often assumed
      to have a magnitude of 32, thus accepting operands which are invalid
      ( "mov m64, offset label" or "push offset label" ).

   06/29/2011, v2.06c:

   Bugfixes:
   -  v2.06-v2.06b, directives DB, DW: if the result of a subtraction of
      2 labels ( dw label1 - label2 ) was negative, it was rejected.

   06/28/2011, v2.06b:

   Bugfixes:
   -  struct fields that were forward referenced may have caused warnings
      or errors in v2.06-v2.06a.
   -  in v2.04-v2.06a, if a pointer to a struct was redefined and the
      redefinition used a type alias, the redefinition failed (see 
      regression test types5.asm)

   06/26/2011, v2.06a:

   Bugfixes:
   -  in v2.06 was a regression for IMUL with 3 operands: if the third
      operand's value was 127 < x < 256, the instruction was encoded
      incorrectly.

   06/26/2011, v2.06:

   Bugfixes:
   -  relative pathes for filenames containing '/' may have caused
      problems in non-Unix versions.
   -  register "assumes" on the right side of the binary '+' operator
      were ignored.
   -  64-bit: in v2.05, "MOV <reg>,offset <label>" was created with a
      32-bit immediate (and fixup).
   -  JWASMR.EXE: struct sizes > 32767 caused problems.
   -  for RECORD types used in an expression, the default value must be the
      record's mask, not the record's size in bytes.
   -  offset of a struct member may have been calculated wrongly if the base
      was just a type (not a variable) AND the first member also had a
      struct type ("mov eax, <struct_type>.<mbr>.<mbr>").
   -  inside struct declarations, a '?' was accepted as initializer of struct
      members.
   -  segment combine type COMMON was displayed as '?' in listing.
   -  in v2.00-v2.05, PUSH/POP of a 64-bit memory operand wasn't rejected
      in 16/32-bit code.
   -  in v2.05, quoted filenames in the cmdline didn't work.
   -  division operator '/' did interpret operands as unsigned values.
   -  instructions BT, BTC, BTR and BTS did accept memory byte operands.
   -  instruction PALIGNR wasn't encoded correctly.
   -  OPTION RENAMEKEYWORD: restoring of the keywords failed.
   -  instructions INSx and OUTSx weren't encoded correctly if arguments
      were given.
   -  INVOKE, 64-bit: float constants may have caused a GPF.
   -  INVOKE: size check for constants was missing.
   -  in v2.05, indirect addressing may have failed with 'structure field
      expected' if address was in format [reg].<member>[reg].
   -  an erroneous redefinition of a RECORD type may have caused a GPF.
   -  if multiple files were assembled with different output formats,
      some combinations didn't work as expected due to unwanted side
      effects.
   -  LABEL directive: code labels (NEAR, FAR, PROC) cannot be defined
      anymore if CS is assumed ERROR. Previously this check was done only
      when the label was defined through a trailing colon.
   -  operator THIS was accepted in expressions outside segments.
   -  XLAT, XLATB: memory operand of any size was accepted.
   -  IMUL: syntax check was sloppy.
   -  CMOVcc: byte registers were accepted as first operand.
   -  if an instruction has just a memory operand, but with multiple
      possible sizes, no error was emitted if size of current argument
      was unspecified.
   -  in IF blocks, multiple ELSE branches weren't rejected.
   -  size of fixup for absolute externals may have been wrong in a few
      cases ( i.e. second operand of BT[c|r|s] instructions ).
   -  check for REAL4 initializer limits was missing.
   -  arrays in unions weren't taken into account with their full size.
   -  it wasn't checked if names of fields of anonymous struct members were
      already used in a struct.
   -  magnitude test of numbers wasn't strict enough.
   -  in v2.05, if the argument of EQU was a number with a
      magnitude > 32 bits, the equate wasn't created as a text macro.
   -  operator DUP: if initial value was a quoted string and size of the
      data item was > 1, every second repetition was incorrect.
   -  64-bit: max. width of RECORD was 32 - changed to 64.
   -  64-bit: if OPTION FRAME:AUTO was set and a XMM register was added
      in the USES list or a PROC, the offsets of local variables wasn't
      calculated correctly and the generated epilogue may have used a wrong
      value to restore RSP.
   -  if a text macro, defined via cmdline option -D, was also defined in
      the source and the value of both definitions was an empty string,
      a GPF did occur.
   -  HADDPD, HADDPS, HSUBPD, HSUBPS: variant with m128 as second operand
      was rejected.
   -  64-bit: PEXTRQ/PINSRQ were encoded incorrectly if a m64 operand
      was destination or source.
   -  syntax 'INVOKE <struct_name>.<mbr>[reg]' caused a GPF in v2.05 (and
      didn't work in v1.96-v2.04).
   -  expansion of macro arguments changed so text macros are expanded
      earlier ( needed in cases when a macro argument was a text macro
      and the value of the text macro was a macro function call - see
      macparm.asm regression test ).

   Other changes:
   -  cmdline option -Sf added.
   -  OPTION RENAMEKEYWORD, OPTION MZ: syntax changed. Both options used
      comma-separated values, which made it impossible to use them in a
      "multiple-option" line.
   -  operators LOW32/HIGH32 supported.
   -  INVOKE: 64-bit constants (integer and floating-point) supported as
      parameters.
   -  Value of predefined text macro @Version changed from <615> to <800>.
   -  OC.mak added to support the Orange C compiler (LadSoft).
   -  result of SHL operator is now 64-bit, same as with Masm v8+.
   -  OPTION DLLIMPORT added.
   -  cmdline option -Fd added.
   -  cmdline option -Fr (set error file name) changed to -Fw, since
      option name -Fr is already used by Masm (limited browser info).
   -  instructions XSAVE, XRSTOR, XGETBV, XSETBV, XSAVEOPT supported.
   -  AVX instruction set supported.

   03/02/2011, v2.05:

   Bugfixes:
   -  PROC directive: it wasn't checked that VARARG parameter was last
      parameter.
   -  ASSUME directive: using an arbitrary pointer type as argument
      didn't work as expected.
   -  CVTSI2SD, CVTSI2SS: memory operand could be of any size. Also, if
      it was m64 in 64-bit, no REX-W prefix was generated.
   -  MOVD: 64-bit memory operand wasn't accepted in 64-bit mode.
   -  PINSRW: memory operands of any size were accepted.
   -  in v2.04, a macro name which was located behind a '::' wasn't
      expanded, which usually resulted in a syntax error.
   -  "undefined" types may have caused a GPF if -Zi was set.
   -  some errors fixed in INVOKE support of Open Watcom fastcall register
      calling convention.
   -  most conditional error directives did emit their errors in pass one,
      which was too early.
   -  there was a risk that macro functions in an EQU argument were
      expanded (if the macro invocation was hidden in a text macro).
   -  check for conflicting parameter types for PROC/PROTO wasn't as
      rigid as Masm's.
   -  EXTERN and EXTERNDEF didn't accept prototype type symbols.
   -  prologue code generation was triggered slightly differently compared
      to Masm.
   -  syntax check of macro "local" lines was too sloppy.
   -  when searching macro parameter and local names in macro lines, the
      search was always case-sensitive, ignoring current case-mapping
      setting.
   -  ELF64 format: relocations were stored in sections of type SHT_REL.
      Changed to SHT_RELA.
   -  in v2.04, SIZE operator might have returned wrong results for
      structured variables (SIZEOF had no problems).
   -  in v1.93-v2.04, initialization of an array of structures may have
      given a wrong result if both DUP and comma operators were used.
   -  check if a data definition directive was preceded by a code label
      - which isn't allowed without -Zm option - wasn't fool-proved.
   -  the tokenizer did scan numbers not exactly like Masm does, which
      caused problems if a number was immediately followed by an identifier.
   -  MZ format: segment fixups for a segment in a group were wrong if both
      the group and the segment weren't located at 0.
   -  INVOKE, 16-bit code, VARARG parameter: in v2.04, if argument was a
      32-bit register, register SP was adjusted wrongly after the call.
   -  it wasn't checked if GOTO labels inside macros were reserved words.
   -  INVOKE, 64-bit Windows: in v2.04, it wasn't possible to call functions
      which had a VARARG parameter.
   -  PURGE directive: directive arguments weren't expanded.
   -  preprocessor directives [ELSE]IF[E] weren't always able to detect
      undefined symbols in their argument.
   -  EXITM: syntax check of the directive's argument wasn't too strict.
   -  SIZESTR: the directive's label wasn't expanded.
   -  GOTO: a macro label placed just before the ENDM line wasn't found.
   -  PUSH/POP: there was no error msg when the argument was a structured
      variable with an unsuitable size.
   -  expression evaluator was unable to handle floating-point constants.
      Unary operators +, -, OPATTR and .TYPE are supposed to accept those.
   -  JWasm's dot operator (.) accepted arguments that Masm does only if
      OPTION OLDSTRUCTS is active.
   -  in a few cases the end of "undelimited" strings wasn't detected.
      This mostly applies to string macros (@CatStr) used as arguments
      for other macros.
   -  "assumed" predefined types were ignored by the TYPE operator.
   -  in v2.03-2.04, an "empty" argument in a macro VARARG parameter list
      did reset the list.
   -  if the expansion operator (%) was used to convert a numeric expression
      to text. it was always handled. This was an error, because it is
      supposed to be accepted for arguments of preprocessor directives or
      macros only.
   -  line concatenation triggered by a comma as last token wasn't fully
      Masm-compatible: if the line is an instruction, a comma should NOT
      trigger the concatenation. OTOH, if the comma is a result of a
      (text) macro expansion, it should trigger concatenation.
   -  if a source file argument wasn't the first and the file couldn't
      be found, a GPF occured.
   -  INC/DEC: in v1.94-2.04, "unsized" memory operands were accepted.
   -  SHLD/SHRD: syntax check was too sloppy.

   Other changes:
   -  cmdline option -eq added.
   -  cmdline option -zld added.
   -  INVOKE support for Open Watcom register calling convention enabled.
   -  OWWinDll.mak and MsvcDll.mak added to create JWasm as a Win32 dll.
   -  source code in listing file now starts at column 32.

   10/17/2010, v2.04c:

   Bugfixes:
   -  in v2.04-2.04b, a type coercion of NEAR or FAR for a memory operand
      (sometimes used for indirect calls or jumps ) didn't work correctly.

   10/08/2010, v2.04b:

   Bugfixes:
   -  in v2.04 + v2.04a, if IMUL's second argument was a forward reference
      and a third argument was also given, then error 'invalid instruction
      operands' was emitted.
   -  an empty PROC located outside of a segment block didn't emit error
      'Must be inside segment block' - and in v2.04 additionally an access
      violation did occur.
   -  using ALIAS names in expressions was rejected in v2.04. Previously,
      this wasn't rejected, but fixups were wrong, which wasn't better.

   10/05/2010, v2.04a:

   Bugfixes:
   -  in v2.04, if operator OFFSET was used in an indirect addressing
      expression ( mov ax,[bx+offset var] ), the variable's type information
      wasn't removed.
   -  in v2.04, value of assembly time variables were evaluated wrong if they
      were forward referenced.
   -  in v2.04, error 'symbol type conflict' did occur if a type was defined
      twice, first as an arbitrary type, second as a scalar type, and the
      arbitrary type was just an alias of the scalar type. Example:
        type1 typedef ptr
        type2 typedef type1
        type2 typedef ptr
   -  operator SEG didn't enforce the argument to have size WORD.

   10/04/2010, v2.04:

   Bugfixes:
   -  ELF fixups for 16-bit relative offsets (GNU extension) were wrong.
   -  PUSHCONTEXT|POPCONTEXT didn't accept multiple arguments.
   -  a code segment defined with simplified segment directive .CODE,
      with a name argument and which was added to a group BEFORE the
      definition, was created with default attributes.
   -  MZ format: segment fixups in the MZ header weren't always calculated
      correctly.
   -  ALIGN, EVEN: "filler" bytes were emitted unless the segment was
      "absolute" or "bss". Now this is done only when data or code was
      emitted just before the directive.
   -  COFF format: JWasm expected to use the ".drectve" section exclusively.
      If it was defined within the source, an error occured.
   -  COFF format: option -SAFESEH didn't emit a "@feat.00" absolute
      symbol in the object module, as requested by the MS COFF specification.
   -  JWASMR.EXE: v2.03 often fell into an endless loop due to an error in
      fixup management for backpatching.
   -  in v2.03, constants with -65536 < value < -32768 were not accepted
      for 16-bit targets in MOVs.
   -  a label was accepted even when there already existed a proto with the
      same name.
   -  operator TYPE ignored a possible coercion for a type argument.
   -  a duplicate RECORD definition was rejected, even if both definitions
      were identical.
   -  an absolute external used as a byte immediate may have caused invalid
      code to be generated ( extern x:abs - or al,xx ). MOV and PUSH were
      not affected, though.
   -  in v2.00-2.03, PROTOs were listed in the "Symbols" section, not in
      the "Procedures" section.
   -  for COMMunal variables, there was no check if the symbol was defined
      with a different kind already.
   -  if .STARTUP or .EXIT occured before any code or data definition
      lines, the code generated by those directives might have get
      truncated.
   -  INVOKE: a FWORD parameter caused an error if the argument to be
      pushed was a constant.
   -  LOCAL and INVOKE: a local or a parameter of size 0 confused the
      assembler.
   -  MOVD didn't accept a REAL4 memory operand as second argument.
   -  EXTERN directive: altname was ignored if external was a prototype.
   -  EXTERN directive: altname symbol was rejected if it was external.
   -  OMF output format: no WKEXT comment records were written for
      EXTERNal items with an alternate name.
   -  if floating-point emulation fixups were to be generated, there was
      no NOP inserted before FWAIT if current CPU was 80386 or better.
   -  INVOKE, VARARG parameter: if cpu was < 80386 and a constant value
      which didn't fit into a word was to be pushed, JWasm complained.
   -  INVOKE, VARARG parameter: the calculation of the stack adjustment
      value was wrong in the following cases:
      a) when a byte register was pushed
      b) when the argument consisted of 2 registers ('ds::bx')
   -  JWASMR.EXE: freeing a PROC's local items was done with the wrong
      linked list. This often resulted in an abnormal termination.
   -  in v2.03, if Win64 output format was selected, a GPF did occur if
      a stack variable was used as an argument for INVOKE.
   -  SHR and SHL operator didn't reject negative shift counts. Also,
      shift counts >= 64 returned compiler-dependant results.
   -  if a text literal defined with SUBSTR was referenced before definition,
      the definition failed.
   -  INVOKE for Win64 didn't work for VARARG parameters.
   -  syntax ASSUME <reg>: ERROR|NOTHING rejected 8-bit registers.
   -  directive ASSUME: argument types for segment register assumes
      weren't restricted to segment, groups or segment registers.
   -  codeview debugging info: in v2.02-2.03, type info for structures and
      unions wasn't written. Without this info, it wasn't possible to examine
      the contents of structure members in a debugger.
   -  text macros used to initialize an byte array within a struct did cause
      error 'invalid symbol type in expression' it the macro wasn't enclosed
      in angle brackets.
   -  in v2.01-v2.03, it was possible to redefine a numeric equate if it
      was calculated as the difference of two labels.
   -  on certain conditions the expression evaluator skipped type information,
      and emitted a warning then. Example: mov [eax-<n>](<type>.<member>),0
   -  JWASMR.EXE: setting radix to 16 made the assembler accept no numbers
      anymore.
   -  64-bit: LAR and LSL weren't implemented ML64-compatible, they accepted
      DWORD/QWORD memory operands.
   -  in a few cases (where JWasm assumed forward references to be labels,
      which later turned out to be numbers) there was a risk that a short
      destination for a jump wasn't detected and hence not the smallest
      possible code was generated.
   -  comparisons of TYPE expressions may have failed for expressions with
      type coercion.
   -  in v2.03, false conditionals were always listed (.LISTIF).
   -  in v2.00-v2.03, a code label in front of conditional directives gave
      syntax errors.
   -  directive TYPEDEF: type conflicts of some pointer types were undetected.

   Other changes:
   -  OPTION NOSIGNEXTEND supported.
   -  OPTION WIN64 added.
   -  new cmdline switch -Zv8.
   -  INVOKE generates smaller code for constant arguments with 8086 cpu.
   -  INVOKE for Win64 watches if register parameter values are destroyed.
   -  INVOKE for Win64: type checking of arguments is now more strict.
   -  to increase Masm-compatibility, floating-point initialization with
      "real-number designator" (R) supported. Example: "var REAL4 3f800000r".
   -  INVOKE support for Open Watcom fastcall register convention
      implemented ( disabled by default ).
   -  Djgpp variant of COFF supported ( disabled by default ).
   -  JWASMR.EXE: stack size increased from 16 kB to 20 kB.

   08/03/2010, v2.03:

   Bugfixes:
   -  invalid cmdline option behind source filename caused a GPF.
   -  expressions in a data field initializer were evaluated when the
      structure was instanced. This gave incorrect results or assembly
      errors if the expression contained an assembly time variable
      ( including $ ).
   -  INVOKE directive: if register EAX|RAX was used for indirect addressing
      of a parameter, there was no check if the content of the register has
      been overwritten previously due to an ADDR operator.
   -  INVOKE directive, 64-bit: if a parameter beyond the first four was an
      address which had to be loaded into register RAX to store it onto the
      stack, the generated source was either invalid or a GPF occured.
   -  TYPEDEF directive: pointer definitions did use the default size for
      data pointers, which isn't correct if the pointer is defined as a
      function pointer and memory model is COMPACT or MEDIUM.
   -  64-bit: assembly time variables or immediate operands with a value
      magnitude > 32 bits were rejected.
   -  macro expansion: expansion operator at the start of a line and more
      than one macro function call within this line might have resulted
      in garbage.
   -  DUP operator: count (first operand) was rejected if it was a string.
   -  float initializer in BSS segments wasn't rejected.
   -  OMF format: when a listing was to be written (-Fl) and a large array
      was defined, a GPF might have occured.
   -  error 'Symbol redefinition' occured if an equate's expression contained
      another equate which was the result of a subtraction of 2 labels AND
      a phase error caused this difference to change.
   -  comments weren't displayed in listing.
   -  in v1.96-2.02, if cmdline option -mf was set, the cpu wasn't
      automatically set to a 386 as it was done before.
   -  format COFF: symbols defined as weak externals were created as normal
      externals if the EXTERN directive was used for the definition.
   -  64-bit: opcodes MOVSXD and CQO (both 64-bit) were missing.
   -  64-bit: opcode CDQE was encoded without the REX prefix, thus it was
      a CWDE in fact.
   -  64-bit: QWORD type coercion for an immediate operand didn't force the
      operand's size to 64-bit.
   -  64-bit: MOVs with a segment register as operand didn't accept 64-bit
      registers as the other operand ("mov ds, rax").
   -  64-bit: SLDT, SMSW and STR didn't accept 32- and 64-bit registers as
      operand.
   -  a displacement which didn't fit into 32-bits caused error 'Constant
      value too large' in versions 2.00 - 2.02. This has been changed to a
      warning (level 3) in 16- and 32-bit. In 64-bit code, it is still an
      error.
   -  In expressions, types combined with the open (square) bracket operator
      ( "mov eax, DWORD [ebx] ) weren't rejected.
   -  comparisons of TYPE expressions did compare the type's size only.
   -  Name of a macro proc used as a macro argument caused a syntax error.
   -  for indirect calls/jumps, a struct field used as displacement didn't
      qualify the type of the call/jump, resulting in an error msg.
   -  A .MODEL directive which occured AFTER code definition lines may
      have confused JWasm.
   -  in JWasm v2.00-2.02, when a RECORD variable had to be initialized,
      there was a risk that an erroneous padding byte was added.
   -  initialization of DWORD/QWORD items with constants in string format
      may have been incorrect due to wrong little-endian conversion.
   -  empty lines - or lines containing just a comment - in macros weren't
      counted, thus a wrong line number might have been displayed if an
      error occured inside a macro.
   -  name arguments for .DATA? and .CONST were always accepted, but
      ignored. Now they are accepted only if -Zne isn't set and the name
      is NOT ignored then.
   -  64-bit: for -win64, default for GS register assumption was "ERROR".
      Assumption changed to NOTHING.
   -  64-bit: JWasm always used RIP-relative direct addressing mode, even
      if there was a segment override with a segment register which wasn't
      assumed to be FLAT.
   -  64-bit: encoding of indirect addressing with base registers R12/R13
      and no index registers wasn't correct.
   -  64-bit: encoding of indirect addressing with base registers
      RBP/R13/R13D + index register and no displacement wasn't correct.
   -  64-bit: register R12D was rejected as base for indirect addressing.
   -  PURGE made macros "invalid" (it should just delete the macro content).
   -  listing of macro invokations started with a "non-existing" empty line.
   -  TEXTEQU: if the % operator was to evaluate a numeric argument which
      contained other text equates, the equates were expanded incorrectly.
   -  TEXTEQU: the % operator returned a signed value for numeric arguments.
      For strict Masm compatibility, it has to be an unsigned value.
   -  OPTION DOTNAME: in v2.0-v2.02, this option may have caused macro
      parameters not being recognized in macro source lines if the parameter
      was preceded by a dot.
   -  in v2.0-v2.02, the % operator didn't work reliably for VARARG macro
      arguments.
   -  a text macro which contained a macro function call and extra chars
      might not have been expanded correctly if it was used as an argument
      in one of the string directives.
   -  a GOTO to an undefined macro label didn't display an error.
   -  macro locals used as macro labels didn't work.
   -  in v2.00-2.02, there was a risk that JWasm generated a near jump
      ( or an "extended" conditional jump if cpu is < 80386 ) when a short
      (conditional) jump would have been ok.
   -  ALIGN directive without argument inside struct definitions created
      bad offsets.
   -  left part of equates in listing sometimes got copied to the next line.
   -  no warnings were emitted on warning level 3+ if procedure arguments
      or locals weren't referenced.

   Other changes:
   -  OW v1.9 used to create the JWasm binaries.
   -  opcode RDTSCP supported.
   -  option -nc wasn't documented.
   -  the (average) number of passes needed to assemble a source has been
      reduced. This should also have a positive impact on assembly time.

   01/19/2010, v2.02:

   Bugfixes:
   -  in v2.00-v2.01, option -Zg disabled alignment padding for structures.
   -  in v1.96-v2.01, if argument of a PUSH immediate was a segment or
      group value, the short 'byte' form of the PUSH opcode was generated,
      which - in conjunction with the fixup for this value - resulted in
      bad code.
   -  literal-character operator (!) was ignored within arguments of
      directives IFIDN[I] and IFDIF[I].
   -  literal-character operator (!) wasn't handled in literals of .ERRxx
      directives.
   -  FOR/IRP/FORC/IRPC: parameter placeholder names beginning with a '.'
      were always rejected.
   -  FORC/IRPC: additional items after the literal argument weren't
      rejected.
   -  in v2.01, arithmetic instructions with a forward memory reference
      as first operand and an immediate value as second operand were
      rejected if cpu was < .386.
   -  for formats other than OMF, the buffer which hold the contents of a
      segment might have been allocated too small if the segment was a
      code segment and contained forward references but no labels.
   -  OMF format: there was a risk that WLink refused the object module
      generated by JWasm because size of code sections did shrink in
      assembly passes > 2 but file size wasn't adjusted accordingly.
   -  CMPSx string instruction: if first operand had a DS prefix, it was
      generated, although it's superfluous.
   -  XCHG with 2 register operands: encoding of registers differed from
      Masm's (unless one operand was AX/EAX).
   -  in v1.95-v2.01, MMX/SSE instructions did emit prefix byte (0x66) in
      16-bit code if one operand was a 32bit standard register.
   -  opcodes CALL/JMP in 64-bit code: rex prefix wasn't emitted if operand
      was a register, which caused "call r8" to be encoded like "call rax".
   -  64-bit indirect addressing: if memory operand was second argument and
      address used both base+index register, the REX_X bit wasn't set.
   -  in 64-bit code segments, the filler bytes created by ALIGN/EVEN
      directives weren't valid NOPs in all cases.
   -  there was no check whether type coercions for registers ( DWORD PTR
      EAX ) were consistent.
   -  for all formats besides OMF, there was no message if a 16-bit segment
      exceeded 64 kB.
   -  runtime conditionals: the 'logical NOT' operator ! did not invert
      logical operators && and ||.
   -  INVOKE directive: for models with default far data pointers ( COMPACT,
      LARGE, HUGE ), the ADDR operator didn't make the segment part to be
      pushed if parameter had the VARARG attribute.
   -  OMF format: in v2.00-v2.01, there was a risk that a fixup record might
      have contained a fixup for the NEXT ledata record, which is invalid.
   -  OMF format: COMMunal variables with size > 128 caused object module
      corruption.
   -  OMF format: if an array of far COMMunal variables exceeded 128 items,
      a fatal error ("internal error in omf.c") occured.
   -  16-bit floating-point fixups: generated fixup frame specifier differed
      from Masm's ( F4 [FRAME_LOC] vs F5 [FRAME_TARG] ).

   12/12/2009, v2.01:

   Bugfixes:
   -  shift and rotate opcodes accepted any 8-bit register as second
      argument. If it wasn't CL, wrong code was generated.
   -  IN/OUT opcodes accepted any 16-bit register as source/target, not
      just DX. If it wasn't DX, wrong code was generated.
   -  an unnecessary DS prefix for OUTS string instruction wasn't removed.
   -  16-bit indirect addressing-mode with a scale > 1 wasn't rejected and
      invalid code was generated.
   -  if errors occured JWasm still returned error code 0.
   -  indirect CALL/JMP needed a size, even if -Zm was set.
   -  with -Zm, the offset of a struct member wasn't correct if the struct
      was nested and the member was referenced without the 'dot' operator.
   -  in v2.0, error 'Constant value too large' may have occured if the
      SHL operator was used in expressions to define an immediate value
      and the result didn't fit in 32-bits.
   -  directive '=': expression wasn't rejected if it contained externals.
      Now error 'Constant expected' is displayed.
   -  JWASMR only: detecting the size of an immediate operand often failed,
      which then gave error 'immediate data out of range'.
   -  segment/group override used in an argument for the OFFSET operator
      was ignored.
   -  format BIN: offsets were always group-relative (OPTION OFFSET:SEGMENT
      was ignored).
   -  arithmetic instructions with immediate operand: the signed (=shortest)
      variant of the instruction wasn't generated if the immediate operand
      was a negative WORD value.
   -  absolute segments weren't correctly displayed in the listing file.
   -  formats MZ: fixups with references to absolute segments weren't
      handled correctly.
   -  SSE2 CMPSD/MOVSD: memory operand of type QWORD was rejected.
   -  SSSE3 instructions: indirect addressing with ESP didn't emit the
      SIB byte.
   -  in v2.0, a struct field with a name which matched an arbitrary type
      was rejected if the type of the struct field was a predefined TYPE
      (example:  name1 WORD ? ; [<name1> is both a struct field name
      and an arbitrary type name] ).
   -  OMF format: if the LNAME index of a group name was > 255, the link
      between the name and the group definition record became broken.
   -  syntax "EXTERN:" and "EXTERNDEF:" (directive + colon, but no type),
      was rejected, but seems to be valid Masm-syntax.
   -  for PUSHD, only immediate operands were accepted.
   -  in JWasm, using a text macro before it is defined is to cause
      a warning. This worked for text macros defined with EQU only, but
      didn't if the macro was defined with CATSTR or TEXTEQU.
   -  for segment registers, the assume search order in v1.96 and v2.0
      didn't match Masm's.
   -  macro loop directives (REPEAT, FOR, FORC, WHILE) with no data
      lines caused a GPF.
   -  if a text macro contained multiple macro function calls, only the
      first one was evaluated on some conditions.

   Other changes:
   -  equates and assembly time variables: magnitude of values has been
      increased by 1 bit. Now it's 32bit plus a sign bit - similar to Masm v8.
   -  multiple overrides in an expression will give a warning.
   -  if an equate was assigned a PROC, the proc-specific info wasn't stored,
      which made it impossible to use the equate for the INVOKE directive.
   -  instruction sets SSE4.1 and SSE4.2 supported.
   -  data types MMWORD and XMMWORD supported.

   10/12/2009, v2.00:

   Bugfixes:
   -  for output format OMF, the listing contained "random" values of data
      bytes in BSS segments.
   -  syntax check for WHILE didn't reject additional arguments.
   -  PUSH/POP instruction: a forward reference to a variable caused an
      error if cpu was 8086.
   -  for most MMX and SSE instructions, type of memory operand wasn't
      checked too strictly.
   -  ALIGN for data segments did emit the same bytes as for code segments.
   -  in 16-bit code, PUSH <imm> with -65535 <= imm <= -129 made JWasm push
      a DWORD value or - if cpu was < 80386 - caused error 'instruction form
      requires 80386'.
   -  in v1.96, usage of a not-yet-defined symbol in a data definition may
      have caused error "initializer magnitude too large".
   -  .NO87 had no effect in v1.96.
   -  OMF format: size of LNAMES record may have exceeded 1024 bytes.
   -  in v1.96, if -Zm was set, structure fields had offset 0 when they were
      referenced without the structure name.
   -  inside macros, value of predefined symbol @Line was current macro line
      number instead of current source line number.
   -  support for IMAGEREL and SECTIONREL operators was effectively disabled.
   -  missing quotation mark in strings wasn't flagged.
   -  JWASMR.EXE: array initialization strings caused a syntax error.
   -  JWASMR.EXE: value of equates was truncated to 16bit.
   -  argument of INCLUDE directive was always expanded. Now it's only
      expanded if the expansion operator (%) is the line's first character
      (Masm compatible).
   -  -Zp switch was ignored.
   -  padding of a struct's last member didn't depend on the largest type
      of the structure, thus it was incompatible with common C compilers.
   -  ECHO without argument might have displayed garbage.
   -  alignment of members of type STRUCT didn't work as expected.
   -  equate @FileCur always returned the main source filename.
   -  in v1.96, indirectly calling a function with a different offset
      magnitude by type coercion (call PF16 ptr [ebx]) created wrong code.
   -  the argument of REPEAT was treated as unsigned integer, but should be
      a signed integer.
   -  JWasm complained about a missing <text> argument for IRC/IRPC, but
      this is actually a valid syntax.
   -  If a struct member's name was also a type name and the member's type
      was of arbitrary type, a syntax error occured.
   -  directive ASSUME <reg>:ptr <type> caused an error in pass 2 if <type>
      still wasn't defined. Now it's just skipped, which is what Masm does.
   -  DB directive: empty string argument ("") wasn't rejected if directive
      was used without label.
   -  directives [ELSE]IF[N]DEF without argument caused a warning.
   -  code generated by runtime conditionals might have been wrong if
      expression had the format (<expr> && (<expr> || <expr>))
   -  INCBIN was ignored if it was first instruction to insert bytes.
   -  if cpu was 8086, INVOKE failed for constant arguments.
   -  operators SIZE and LENGTH worked like SIZEOF/LENGTHOF if expression
      contained the DUP operator.
   -  directives INCLUDE, INCLUDELIB and INCBIN: filenames beginning with
      a digit may have caused a GPF.
   -  indirect addressing mode: usage of multiple index registers wasn't
      detected in all cases.

   Other changes:
   -  support for 64-bit enabled.
   -  new cmdline options -win64 and -elf64.
   -  new cmdline cpu options -7, -8, -9, -10.
   -  object module is accessed with standard stream functions, low-level
      file i/o isn't used anymore.
   -  format of error/warning msgs is more Masm-compatible.
   -  directives for 64-bit SEH added (.ALLOCSTACK, .PUSHFRAME, ... )
   -  OPTION FRAME added.
   -  type SQWORD supported.
   -  OPTION DOTNAME | NODOTNAME fully supported (previously NODOTNAME was
      ignored).
   -  directive .SAFESEH and cmdline option -safeseh supported.
   -  cmdline option -Zd implemented for COFF output format.
   -  cmdline option -Zi implemented for OMF and COFF output formats.
   -  cmdline option -zld removed. File dependency records are written
      when options -Zd or -Zi are set.
   -  Masm compatible cmdline option -Zs added, and existing cmdline option
      -zs renamed to -zt to avoid ambiguity.
   -  operators IMAGEREL and SECTIONREL work with BIN format, which makes it
      possible to create PE binaries using this format.
   -  BIN format: initial ORG in any segment will just set current offset.
      Prior to v2.0 this was true for the very first segment only.
   -  ELF32 format: LD extensions for 8/16-bit relocations supported.
   -  OPTION ELF added.
   -  PUSHCONTEXT/POPCONTEXT ALIGNMENT added.
   -  option -j removed.
   -  directive OPTION RENAMEKEYWORD added.
   -  optional attribute LABEL for first macro parameter supported.
   -  macro loop iteration displayed in error msgs.
   -  expansion of macro parameters improved.
   -  regression tests added to source package.
   -  -Zi switch for COFF output format may have caused an exception when
      code was written without using PROC/ENDP.

   07/29/2009, v1.96a:

   Bugfixes:
   -  JWASMR.EXE in v1.96 contained a bug in the ASSUME directive which
      made it unusable.

   Other changes:
   -  JWASMR.EXE is now distributed in a separate package.

   07/26/2009, v1.96:

   Bugfixes:
   -  BIN format: fixups related to $ were always resolved to 0.
   -  offset <seg_name> didn't return the segment's highest offset.
   -  if ASSUME forward referenced a type, the type's validity wasn't
      checked in pass 2 if the directive was located before any code
      or data definitions.
   -  BIN format: in v1.95, a stack segment generally wasn't written, but
      this rule has turned out to be too simple. Now a segment isn't written
      if the segment itself AND all segments following it don't contain
      initialized data.
   -  BIN format: if .DOSSEG was set, segments might have got lost in the
      binary.
   -  if a macro which contained EXITM was placed behind a code label, the
      code label was duplicated, giving error msg "symbol already defined".
   -  INVOKE directive, cpu 8086: if ADDR operator was used to push the
      direct address of a memory variable, a "PUSH OFFSET <address>" was
      generated. However, push with immediate operands isn't supported by
      this cpu.
   -  BIN output format: operators LOW and HIGH were rejected.
   -  OMF output format: in code lines, the HIGH operator was ignored,
      resulting in a wrong fixup type.
   -  cmdline "-Fo<directory>\ *.asm" didn't work reliably, the <directory>
      information got lost after the first file had been assembled. Same for
      -Fr and -Fl.
   -  the JWasm versions for DOS 16-bit, OS/2 and Linux had problems if a
      cmdline option and its argument were separated by a white space
      (i.e.: -Fo Sample.com).
   -  nesting of response files wasn't handled properly.
   -  if name of response file contained spaces, it wasn't parsed correctly.
   -  type coercion within () did force the whole operand to this type.
      example: mov (<type PTR ds:[mem_addr]).<struct_field>, ax
   -  a macro function invoked by EXITM might have caused a line number mess.
   -  JWasm did complain if a character was found in a number without 'h'
      suffix. This is too rigid if current radix is > 10.
   -  output format COFF, ELF: a buffer was allocated for segments which
      contain just uninitialized data. This isn't necessary.
   -  output format COFF: segments with combine type STACK were marked as
      'uninitialized', even if they contained initialized data.
   -  no error msg was displayed if a non-segment register was on the left
      side of the ':' operator.
   -  no error msg was displayed if a segment register which was assumed to
      error was used in an expression.
   -  if a data label was defined more than once, an error was displayed.
      However, this is to happen only if the label's address or type differs
      from the previous definition.
   -  (invalid) fixups were created for data items consisting of a
      segment override and a number (i.e. "dw ds:[12h]").
   -  -fpc option was virtually ineffective because cpu directives also
      set a default fpu mode.
   -  SYSENTER was erroneously marked as a privileged instruction.
   -  in v1.95, there was a regression if a literal enclosed in <> contained
      (double) quotes and was used as a parameter for FORC,IRPC.
   -  OPTION PROC:PUBLIC caused a syntax error.
   -  EXITM did restore the line number too late. Thus the macro's line number
      was displayed in error msgs, although the macro function itself ran
      successfully.
   -  regressions in v1.95: for SSE2 instructions CMPSD/MOVSD, the code
      which was generated wasn't correct.
   -  no check was done to ensure that index for ST(n) doesn't exceed 7.
   -  there was no error msg if a third argument was given for instructions
      which accept two arguments at most.
   -  INVOKE: a general-purpose register which was assumed to be a function
      pointer wasn't accepted as first argument.
   -  OPTION OLDSTRUCTS didn't work the way it does in Masm.

   Other changes:
   -  -mz format option added.
   -  directive OPTION MZ added.
   -  a segment map was added to the listing file of binary formats.
   -  undocumented (and useless) cmdline option -7 removed.
   -  samples Mixed216 and Mixed232 added.
   -  invalid cmdline options don't abort the assembly process anymore,
      just a warning is displayed.
   -  GccDos.MAK, PellesC.MAK, BCC.MAK and TCC.MAK added.
   -  the 16bit version, JWASMR, no longer supports -coff and -elf. It
      didn't work reliably in v1.95.
   -  Makefile: creating JWASMD.EXE now also works with OW v1.8.
   -  OW v1.8 used to create the JWasm binaries. Previously it was v1.7a.
   -  INVOKE: extending a memory argument from word to dword won't destroy
      content of register EAX if option -Zg is set.
   -  experimental support for x86-64 added to the source (not active in
      the binaries).
   -  support for FASTCALL implemented, replaces language WATCOM_C.
   -  options -zf0 and -zf1 added.
   -  options -zzo and -zzp renamed to -zs0 and -zs1 for better
      name consistency. Option -zs2 added.
   -  options -fp5 and -fp6 removed. They were useless.
   -  instruction UD2 added (requires cpu .686)

   05/26/2009, v1.95:

   Bugfixes:
   -  listing of items in initialized structures was wrong.
   -  listing for .STARTUP and .EXIT was messed up.
   -  optional value behind .EXIT directive wasn't parsed correctly.
   -  .LISTIF didn't display true conditionals inside macros.
   -  -Sa cmdline option didn't set .LISTMACROALL
   -  "if" state wasn't saved/restored if a macro had to be run in a
      line with expansion operator at the beginning of the line.
   -  bit 6 returned by OPATTR was set for local variables only, but
      is has to be set for any indirect memory reference related to SS.
   -  TYPE with indirect memory operand and a type coercion returned 0.
   -  line continuation caused by a comma as last token did ignore empty
      lines. However, an empty line must stop the continuation.
   -  OPATTR didn't accept expressions as operands which contained the
      OFFSET operator.
   -  if the expression evaluator found a macro name, it changed the
      symbol's type to a label. Now error 'invalid symbol type in
      expression' is displayed.
   -  if an INVOKE directive was first line to emit code bytes and was
      placed outside of a PROC, the code which was generated was wrong.
   -  names of locals in macros beginning with a digit weren't rejected.
   -  using OFFSET operator in 'LEA <reg>,[ OFFSET <symbol>]' was rejected.
   -  if an array of data items was defined, a terminating comma caused a
      syntax error.
   -  if a term '<variable>.<type>' was found in an expression, it wasn't
      handled similar to '<type> PTR <variable>'.
   -  @InStr and @SizeStr returned result as string in radix 10, but
      current radix is to be used instead (which "usually" IS 10).
   -  AT segments didn't work in v1.94.
   -  ALIGN directive did emit bytes in BSS and AT segments.
   -  OMF output format: segment and class names must be converted to
      uppercase for both OPTION CASEMAP:ALL and OPTION CASEMAP:NOTPUBLIC.
   -  syntax check of LABEL directive wasn't restrictive enough.
   -  labels within structure definitions wasn't rejected.
   -  TYPE with struct operand returned wrong result in v1.94 if size of
      struct was > 8.
   -  ASSUME did reject forward references to types.
   -  syntax check for PUBLIC, EXTERN, EXTERNDEF, GROUP, ENDS, LOCAL
      wasn't fool-proved.
   -  @SizeStr's parameter wasn't optional.
   -  it wasn't possible to define an array of 0 items with the LOCAL
      directive, size was silently changed to 1 item then.
   -  a forward reference to a symbol of RECORD type gave an error.
   -  the MOD operator didn't check if second operand was zero.
   -  syntax check for conditional assembly directives did accept invalid
      formats.
   -  value of $ was wrong inside structure or array definitions.
   -  reserved word '.386C' was missing.
   -  once the cpu was set > .8086 it wasn't possible to set .8086 again.
   -  wrong fixup generated for 32bit addressing modes if the symbol was
      16bit.
   -  JWasm got confused if a macro's VARARG parameter did start with a ','.
   -  in v1.94, OPTION SEGMENT:USE32 set default segment size to USE16.
   -  JWasm didn't reject an undefined symbol in an expression after IF.
   -  OPATTR for code labels returned wrong value.
   -  .NOCREF/.XCREF directives didn't accept arguments.
   -  type conflicts for symbols which had an additional EXTERNDEF entry
      were detected for data labels only.
   -  IF[N]DEF <symbol> failed if <symbol> was a forward reference.
   -  ':' operator did clear a type which was set by the PTR operator.
      Test case: <type> PTR ds:[0].
   -  hll expression evaluator did always handle the '()' operator, while
      it should handle it only if the expression enclosed contains a
      hll operator.
   -  -D cmdline option didn't tolerate spaces between -D and macro name.
   -  IF[N]DEF directive didn't work reliably in pass two. This was hardly
      noticed because in JWasm all passes except the first one handle
      preprocessed input only - usually.
   -  protection exception occured if a parameter for INVOKE consist of a
      register pair (DS::SI) and value of register [E]AX was modified before.
   -  forward references of assembly time variables were evaluated to 0,
      but the value must be the variable's value after pass one is finished.
   -  in v1.94, data initializer of strings within structures didn't cover
      the full array length.
   -  ASSUME ignored the PTR operator and accepted invalid types for register.
   -  ENDP didn't complain if tokens were found behind the directive.
   -  support for WATCOM_C calling convention was 32bit only.
   -  for WATCOM_C, it was assumed that the caller does stack cleanup if not
      all parameters did fit into registers.  However, this is true for
      VARARG procs only.
   -  for WATCOM_C, register parameters weren't displayed correctly in the
      symbol list.
   -  output format BIN: fixups might have been written multiple times,
      which then caused a bad binary.
   -  output format BIN: relative offsets (jumps and calls) were calculated
      wrong.
   -  OPTION PROC:PRIVATE made procedures private even if PUBLIC
      directives existed for them.
   -  PROTOs will no longer accept PUBLIC attribute (Masm also rejects).
   -  a PROC with attribute PRIVATE and a PUBLIC directive for the very
      same symbol wasn't rejected.
   -  empty line in a COMMENT block may have been interpreted as EOF.
   -  a forward reference to a symbol in a DB directive was rejected
      (initializer magnitude too large).
   -  if two macro params were separated by one substitution operator (&)
      and the first param additionally had a & prefix, then the second param
      wasn't recognized (and substituted).
   -  CMPSx string instruction was rejected if two segment overrides were
      used. Now it's rejected only if the second one is != ES:.
   -  CTRL-Z in input files wasn't interpreted as EOF.
   -  output format BIN: uninitialized variables located at the start of
      a segment were skipped.
   -  output format BIN: stack segment was always written. Now it's written
      only if it isn't the last segment.
   -  if radix was > 10, the literal created by the % operator may have
      contained lowercase letters ('a'-'f'), which isn't Masm-compatible.
   -  if -Zm (OPTION M510) is set, reserved words which were introduced
      in "later" cpus should be free to use. For JWasm this still isn't
      fully true, but it's now possible to use the names introduced by
      MMX/K3D/SSE extensions.
   -  OFFSET operator applied to a non-relocatable constant wasn't ignored.
   -  listing of LABEL directive didn't display current offset.
   -  handling of macro parameters improved so that strings enclosed in
      (double)quotes and containing '>' work similiar to Masm.
   -  OMF format: size of PUBDEF records might have exceeded 1024.
   -  for errors detected in pass two or later the source filename which
      was displayed may have been wrong.

   Other changes:
   -  -Zg option implemented.
   -  a hash table for local symbols has been implemented since the old
      implementation (linked list) was too slow if lots of local labels
      were defined.
   -  OPTION OFFSET:SEGMENT supported.
   -  GccUnix.mak added, MinGW.mak renamed to GccWin.mak.
   -  -X option supported.
   -  warning level for PAGE, TITLE, SUBTITLE changed from 3 to 4.
   -  instruction FFREEP supported.
   -  OWDOS16.mak and OWOS2.mak added.
   -  -zze option added.
   -  samples Window4, Mixed1 and OS232 added.

   12/24/2008, v1.94c, bugfixes:
   -  multiple filename arguments in cmdline didn't work in v1.94-v1.94b.

   12/21/2008, v1.94b, bugfixes:
   -  initialization of structure date items embedded in another
      structure data item didn't work in v1.94/v1.94a.

   12/20/2008, v1.94a, bugfixes:
   -  .LISTALL didn't enable listing.
   -  ".IF 1" doesn't generate code, which made problems in v1.94.

   12/19/2008, v1.94:

   Bugfixes:
   -  INVOKE rejected a byte register if the parameter type was BYTE.
   -  if additional cmdline options were given in a separate file - by
      '@<filename>' - then an exception might have occured.
   -  syntax 'exitm<>' (no white space after 'exitm') wasn't accepted.
   -  an external absolute symbol was sometimes forced to 16bit, which
      was a problem if the symbol was used in an operand for PUSH.
   -  include paths set with -I had less precedence than include paths
      set in INCLUDE environment variable.
   -  expression after .WHILE and .UNTIL wasn't optional.
   -  keywords removed with OPTION NOKEYWORD weren't restored when another
      source module was to be assembled.
   -  if more than one file was to be assembled, there was a risk that
      setting the include path by either option -I or environment variable
      INCLUDE caused a GPF.
   -  size information was lost in an expression if a register plus
      displacement or scale factor was located AFTER the structure field.
   -  in COMM directive, a language type followed by the NEAR|FAR keyword
      wasn't accepted and caused a syntax error.
   -  invalid size of memory operands for CALL/JMP was silently changed to
      WORD/DWORD.
   -  substitution operator (&) didn't work for macro function calls if the
      expansion operator (%) was first character on a line.
   -  "TYPE <number>" returned value of <number>. Now 0 is returned.
   -  "SIZE <simple type>" wasn't accepted.
   -  invalid fixup types for COFF format were accepted without error message.
   -  if the filename parameter of an INCLUDE directive wasn't enclosed in <>
      and did start with a number, the file wasn't found.
   -  MASK and WIDTH operators worked with bitfields only, not with RECORD
      types.
   -  if OPTION OLDSTRUCTS was set, multiple occurances of the same struct
      definition may have caused error "symbol already defined".
   -  access to memory locations without fixup, but with a segment override,
      was assumed with an offset magnitude equal to current CS, which isn't
      necessarily true.
   -  it wasn't allowed to open a segment which was already "opened".
   -  initializer for a structure wasn't ensured to be a literal enclosed
      in <> or {}.
   -  the parser didn't distinguish between a single item and an array of
      size 1. Since data initialization is to be handled differently for
      these cases, this behavior wasn't compatible.
   -  there was no test for a max. nesting level implemented if a macro
      called itself. Usual result was an "endless" loop.
   -  if option -Fl was set and the assembly source didn't contain any
      instructions or data definitions, then all lines were listed twice.
   -  if a required macro parameter was to be expanded, but expansion failed
      due to an undefined symbol, an access violation might have occured.
   -  expansion of macro function calls in text equates failed if the
      string contained a '<', '>' or '!' character.
   -  OPATTR <literal> returned 36 and OPATTR without operand caused a
      syntax error. In both cases OPATTR will now return 0.
   -  SHORT operator did accept any operand types.
   -  if a short jump destination was a forward reference and too far away,
      the error was displayed when the destination label was parsed. Now the
      error is displayed when the jump instruction is parsed.
   -  environment variable "JWASM" wasn't handled as expected.
   -  cmdline option -nd didn't work as expected.
   -  expansion operator in TEXTEQU/CATSTR may have given unexpected results.
   -  SIZEOF returned double the size for an internal item if it first was
      declared by an EXTERNDEF directive.
   -  since v1.9, warning count was reset for every pass.
   -  if a macro parameter was expanded due to the expansion operator %, it
      didn't work if at the first nesting level a macro function was expanded
      and at the next level a text macro had to be expanded.
   -  numbers > 0xFFFFFFFFh weren't stored as text macros in all cases.
   -  precedence of operator PTR changed from 5 to 4. This change makes
      syntax "TYPE <type> PTR <label>" possible. Masm docs also states that
      PTR should have precedence 4.
   -  items FNRSTOR[D|W] removed from instruction table.
   -  some instructions, which should have accepted a word-sized memory
      operand only, did accept any operand size: LLDT/SLDT, LMSW/SMSW,
      LTR/STR, FLDCW/FSTCW, FNSTCW, FSTSW, VERR/VERW.
   -  the variants of string instructions (CMPS, INS, LODS, MOVS, OUTS,
      SCAS, STOS) WITH suffix (B,D or W) didn't accept the optional (memory)
      operand(s).
   -  the '=' directive didn't work with values enclosed in quotes.
   -  for COFF, the start label is now stored in the decorated form, but
      without leading underscore (example: label LibEntry, language stdcall,
      3 DWORD params is exported as "LibEntry@12").
   -  if a data item was a segment or group symbol, a wrong fixup was
      generated.
   -  if INVOKE had to push a far address, its assumptions about what
      to push as the segment part were a bit too simple.
   -  LABEL directive did accept near/far labels with incompatible
      offset size qualifier (i.e. "near32" if current segment is 16bit).
   -  TR6 register wasn't accepted for cpu 80386.
   -  GROUP directive didn't ensure that the segment's offset magnitude
      matches the group's one.
   -  in data items, segment/group name overrides were rejected if the
      offset part wasn't a label. Example: mov ax, DGROUP:[0].
   -  for cpu < 80386, conditional NEAR jump was rejected, but it should
      be allowed if OPTION LJMP is on (which is the default).
   -  if a "relocatable number" has been defined with EQU it wasn't checked
      in later passes if the value did change.
   -  .EXIT didn't work if OS_OS2 was selected with .MODEL directive.
   -  syntax "TYPE offset <label>" was rejected, but should return size of
      <label>'s offset (2 or 4).
   -  if an error was displayed, then the current line often wasn't written
      to the listing file.
   -  the INCLUDE directive wasn't handled by the preprocessor. As a result,
      if the -EP cmdline option was set to print preprocessed lines to stdout,
      the content of include files wasn't contained in the output.
   -  the lines displayed on stdout when -EP was set wasn't just pure
      assembly source, it contained generated code, the JWasm logo and
      things displayed by the ECHO directive.
   -  if a source filename was found in the cmdline without extension, then
      ".asm" was added automatically, which is an error.
   -  OPTION PROLOGUE and OPTION EPILOGUE did verify the correctness of the
      user-defined prologue/epilogue macros, which was too early.
   -  if the end delimiter was missing for the COMMENT directive, an
      infinite loop might have occured.
   -  "short jump extension" didn't work if the jump to the target was far,
      external and needed an operand size prefix (66h).
   -  type coercion for conditional near jumps (near16/near32) was ignored.
   -  nested procedures were rejected, but they should be allowed as long as
      they don't have parameters, locals or register "uses".
   -  .RADIX expects its parameter in decimal, the current radix is ignored.
   -  if an item was defined both as PUBLIC and EXTERNDEF, but wasn't defined
      in the module, an error ("Cannot define as PUBLIC...") was displayed.

   Other changes:
   -  ALIGN(n) supported as segment attribute for COFF/ELF.
   -  'characteristics' accepted as segment attributes for COFF:
      INFO, READ, WRITE, EXECUTE, SHARED, NOPAGE, NOCACHE, DISCARD.
   -  32bit floating-point immediate values accepted ("mov eax, 1.0").
   -  INCBIN directive added.
   -  new -Zne cmdline option to enforce strict Masm compatibility.
   -  PROC <prologuearg> supported, default prologue understands
      FORCEFRAME and LOADDS.
   -  NOT and MOD operators work on 64bit operands (Masm v8 compatible).
   -  PARA, USE16, USE32 removed from the table of reserved words.
   -  "type expressions" now supported.
   -  clean-up of the expression evaluator's source code.
   -  OPTION FIELDALIGN and OPTION PROCALIGN added.
   -  support for alternative names in EXTERN has been added. Syntax is
        EXTERN name ( altname ) :qualifiedtype
   -  display of include file nesting structure on errors improved.
   -  cmdline option -Zf added.
   -  the guess about a segment's type using the segment's name - which
      is done if the class gives no hint - has been restricted to OMF
      output format.
   -  warning is displayed if a text macro is used BEFORE it's defined.
   -  for LEA instruction, segment overrides are skipped.
   -  remaining hard-coded text constants moved to file msgdef.h.
   -  after 10000 assembly passes a warning is displayed.
   -  Makefile MinGW.MAK added to allow to create JWasm with MinGW.
   -  sample OS216.asm added.
   -  directives .LISTIF (.LFCOND), .NOLISTIF (.SFCOND) and .TFCOND
      supported.
   -  directives .LISTMACRO (.XALL), .NOLISTMACRO (.SALL) and
      .LISTMACROALL (.LALL) supported.
   -  directive .LISTALL supported.
   -  Cmdline options -Sa and -Sx supported.
   -  Cmdline options -Cu and -Cx supported.
   -  OPTION CASEMAP:NOTPUBLIC implemented.
   -  size of symbol hash table increased from 2003 to 8009. Gives a speed
      boost of 10-20% for programs with lots of symbols (WinInc/Masm32).
   -  symbol table listing is created a lot faster.
   -  wildcards allowed in source filename parameter.
    - the max. line length has been increased to 600 (512), the max. number
      of tokens in a line is now 150 (128).

   10/26/2008, v1.93:

   Bugfixes:
   -  possible buffer overflow wasn't detected during macro expansion.
   -  on fatal errors there was a try to close a file twice, resulting
      in an access violation.
   -  if there were multiple ".stack <size>" lines, the last one determined
      the stack size. However, the highest <size> is to be the stack size.
   -  in the listing, the "current location" was displayed as segment size,
      which isn't necessarily the same.
   -  if an 'EXTERN:varname' line occurs AFTER <varname> has been defined,
      the EXTERN directive is ignored by Masm (a Masm bug?). Now JWasm
      behaves similar.
   -  JWasm did expand macro function calls within string function parameters
      later than Masm. Sometimes this was incompatible.
   -  some invalid numbers weren't detected.
   -  there was a risk that POPCONTEXT caused a nesting error if the
      matching PUSHCONTEXT was done before any code bytes were emitted.
   -  for SHLD & SHRD, acccepted format of 3. operand was restricted.
   -  there was no error displayed when a 16bit segment's size exceeded
      the 64k limit.
   -  in medium, large and huge memory models the module name, which is
      used as name prefix for the default code segment, wasn't transformed
      to upper case.
   -  in v1.90-1.92, if /Zd was set, there was a risk that the first line
      number stored was 0.
   -  SSE3 instructions ADDSUBPD/ADDSUBPS were silently skipped if second
      operand was a memory reference.
   -  for ELF format, type of externals was 0x0B, should be 0x0 (STT_NOTYPE).
   -  OPTION directive allowed one argument only. Now multiple arguments,
      separated by commas, are accepted.

   Other changes:
   -  option '-o' removed. Optionally it can be activated in the source.
   -  C style hex numbers with "0x" prefix no longer accepted (was an
      undocumented "feature"). Optionally it can be activated in the source.
   -  .RADIX supported.
   -  for OMF, 32bit segment definition records are now used only if
      necessary (segment size >= 64 kB), similar to Masm.
   -  Supplemental SSE3 (SSSE3) instruction set supported.
   -  files opcodes.tok and Bin\mkopcode.exe became obsolete and have been
      removed from the source package.

   09/20/2008, v1.92:

   Bugfixes:
   -  if an assembly time variable was assigned a value which doesn't
      fit in 32bits, the assignment failed.
   -  for some instructions a forward reference to a variable might
      have caused error "invalid instruction operands".
   -  a '&' after (or before?) a double quote in a macro might have
      confused JWasm and prevented a parameter or local to be replaced by the
      current value.
   -  in a C expression, operators && and || weren't detected if
      immediately followed by a '(' or '['.
   -  MOV <seg_reg>, <memory> and MOV <memory>, <seg_reg> caused
      error 'invalid instruction operands' in v1.8 - v1.91 if <memory> was
      a forward reference.
   -  the linux binaries in v1.9 and v1.91 caused a "segmentation
      fault" if JWasm tried to display an error.
   -  offset operator didn't skip a label's type information. So
      "mov eax,[esi+offset buffer]" was rejected if TYPE of buffer wasn't 4.
   -  for INVOKE, it was detected if EAX was overwritten, but AX
      wasn't checked.
   -  register arguments in INVOKE weren't expanded (for 32bit code,
      an 8bit or 16bit register must be expanded to 32bit; for 16bit code,
      an 8bit register must be expanded to 16bit).
   -  due to special handling of INCLUDE and INCLUDELIB arguments macro
      functions and text macros didn't work as expected after these
      directives.
   -  OPTION EPILOGUE:NONE did translate RET to RET <nnn>.
   -  if the '=' directive was used to assign a relocatable value to a
      variable, usage of OFFSET operator in the expression caused error
      "constant expected".
   -  the epilogue code generated by RET wasn't parsed immediately
      if the instruction was located inside a FOR|REPEAT|WHILE loop.
   -  the code which detected local macros wasn't safe and didn't
      account for '&' operators or macro function calls before the MACRO
      keyword.
   -  in v1.91, evaluation operator % used before a text macro name did
      double the '!' if the text macro was a parameter in a string macro
      function call.
   -  in v1.90 and v1.91, "literal concatenation" - a literal enclosed
      in <> or {} is continued if last non-space character of the line
      is a comma - didn't work for data initializers.
   -  INCLUDE directive in a FOR/REPEAT/WHILE loop didn't immediatedly
      include the file's content, but waited until the loop was finished.
   -  if an error occured inside a macro the line number displayed was
      one too high.
   -  if a parameter for a string function (CATSTR, SUBSTR, ...) is a
      text macro id, the "evaluated" value of the existing id is to be
      assigned to the new id. The "depth" of the evaluation has been
      adjusted to almost match Masm, but there are still small differences.
   -  if a macro parameter had an invalid name, no error was displayed.
   -  if a macro parameter was followed by a ':', no error was displayed
      if the token following wasn't '=', REQ or VARARG.
   -  if the rvalue of EQU contained a text equate name, the lvalue became
      also a text equate. Now the rvalue is expanded and THEN tested if
      it evaluates to a numeric value.
   -  array initializers within struct initializers had problems to
      detect the end of the initialization string.
   -  if a literal missed the closing delimiter '>' or '}', it was always
      flagged as an error, which turned out to be too restrictive.
   -  syntax "mov eax,4(5)" was rejected (brackets allow to omit the
      '+' operator).
   -  in the line "ifaneb EQU .if eax != ebx" the exclamation char was
      lost because the rvalue is stored as a string enclosed in <>, which
      requires that '!' are doubled.
   -  errors which occured when the listing file was opened were ignored.
   -  type comparison of public data items which also had an externdef entry
      was too rigid and often failed for arbitrary types.
   -  for INVOKE, if an address was to be pushed (ADDR operator) and the
      parameter wasn't declared FAR, just the offset was pushed. Now the
      segment part is also pushed if the parameter's size is @wordsize+2
      (which is 4+2 in 32bit and 2+2 in 16bit).
   -  for INVOKE, if cpu was < 80386 and a dword-sized constant value had
      to be pushed, there was a risk that the value was calculated wrong.
   -  simplified segment directives didn't accept segment names beginning
      with a dot.
   -  syntax "invoke (ExitProcess)" wasn't accepted.

   Other changes:
   -  MSVC.MAK has been adjusted to make it compatible with NMAKE v8 of
      MS VC++ EE 2005. Additionally, the source has been modified: header
      file windows.h is no longer used and thus the MS PSDK isn't needed
      anymore.
   -  MAKEFILE has been adjusted to allow to create the JWasm DOS version
      with native WLINK cmdline options.
   -  INCLUDELIB library paths are no longer added to the symbol table.
   -  PARITY? and OVERFLOW? supported.
   -  names for macro locals now consist of a "??" prefix and a hexadecimal
      number suffix. Previously it was a decimal number suffix.
   -  fatal error displayed if writes to the object module are failing.
   -  WIN16.ASM sample added.

   08/19/2008, v1.91:

   Bugfixes:
   -  for /elf, section flag WRITEABLE wasn't set for .data and .bss.
   -  for /elf, self-relative fixups need an inline addend of -4
      which was missing.
   -  POPAW opcode was missing and POPA was always encoded as 16bit.
   -  ORG outside segment block was accepted without error.
   -  SizeStr and InStr lines were doubled in listing.
   -  for INSTR, value of optional <start> parameter was ignored.
   -  AT was handled as a separate segment attribute, not as a
      combine type value like PUBLIC or COMMON.
   -  address value of segment attribute AT wasn't calculated
      correctly.
   -  there was a severe risk that the code generated by the hll
      directives wasn't parsed immediately if the directive was inside a
      FOR|REPEAT|WHILE loop.
   -  ALIGN/EVEN inside a STRUCT did set the struct's alignment
      value. This isn't the way Masm does it. Now it'll adjust the offset
      of the next field only.
   -  if "far call optimization" or "automatic jump expansion" occured
      in a FOR|REPEAT|WHILE loop, wrong code might have been generated.
   -  in v1.9, "far call optimization" and "automatic jump expansion"
      might have caused wrong code to be generated if a forward reference
      was involved.
   -  for output formats COFF and ELF, relocateable items referencing
      an assembly time variable were always fixed with the variable's final
      value, which is an error.
   -  JWasm didn't complain if a label was reused as an assembly
      time variable. Also no complains if an equate defined with the EXTERN
      directive was redefined.
   -  symbol '$' used inside a STRUCT definition always returned 0,
      but should return the struct's current offset instead.
   -  ORG inside a STRUCT definition didn't set the struct's
      current offset.
   -  in a hll logical expression, just the first operand was
      examined if it is a signed value, the second operand was ignored.
   -  a buffer overflow occured if the total size of a translated
      hll expression exceeded 512.
   -  operands for LxS instructions weren't checked for matching
      sizes.
   -  macro labels did work in the first macro level only. (Since
      FOR, REPEAT and WHILE loops are - technically - local macros, GOTOs
      didn't work within such loops if they were embedded in a macro.)
   -  EXITM/GOTO in a macro didn't prevent expression evaluation for
      conditional assembly directives in the lines after EXITM/GOTO and
      before ENDM. This might have caused message "text item required" to
      appear.
   -  if a macro parameter was a macro function and the expansion
      operator (%) was put before the macro, the expansion was skipped.

   Other changes:
   -  TextEqu, CatStr, InStr, SizeStr, SubStr macros will now accept text
      literals enclosed in <> only, to increase Masm compatibility. Literals
      enclosed in quotes or {} are rejected ("text item required").
   -  To avoid problems with angle brackets inside literals the macro
      functions @CatStr, @InStr, @SizeStr and @SubStr have been changed
      to internal functions.
   -  Max. parameters for @CatStr() increased from 10 to 20.
   -  /bin cmdline parameter added.
   -  for INSTR/@INSTR/SUBSTR/@SUBSTR, if value of <start> parameter is
      larger than size of string, an error is displayed now.
   -  for SUBSTR/@SUBSTR, if value of <count> parameter is too large,
      an error is displayed now. Also, parameter <size> must be >= 0.
   -  support for .ALPHA implemented.
   -  REAL4, REAL8 and REAL10 will accept floating-point initializers
      only.
   -  ALIGN will now use one-instruction no-op "lea esp,[esp+00000000]"
      for a 7-byte filler in 32bit code segments.
   -  NDEBUG wasn't defined in release version, which caused assert()
      to be active and thus bloating the binary by 5 kB.

   07/24/2008, v1.9:

   Bugfixes:
   -  a forward jump to a PROC label which wasn't reachable with
      a short jump might have caused invalid code to be generated.
   -  for OMF, if a starting address was specified, there was
      a MODEND record emitted anyway, but for 32bit segments it must
      be a MODE32 record, else the highword of the address' offset
      is ignored.
   -  if a data item contained a label offset and the item's size
      was >= 4, there was a 32bit fixup record generated, no matter what
      the label's segment was telling about the offset's magnitude.
   -  an equate with format <name> EQU <override>:[number], that
      is, the value is an address without a symbol, caused an exception.
   -  "nested" procedures are no longer supported (actually, they
      never were, but now an error is displayed).
   -  opcode PUSHAW was missing.
   -  PUSHA always generated the 16-bit form. In Masm PUSHA will
      generate PUSHAW in 16-bit segments and PUSHAD in 32-bit segments.
   -  procedure parameters which were function pointers weren't
      accepted by INVOKE.
   -  if a label was defined which had an associated EXTERNDEF,
      the optional language specifier of the EXTERNDEF wasn't used.
   -  optional simple expression after .UNTILCXZ was ignored.
   -  if the difference of two offsets was calculated, it wasn't
      ensured that the two labels are in the same segment.
   -  operator LROFFSET was accepted, but handled just like the
      OFFSET operator.
   -  parameters for OPTION directive weren't expanded.
   -  if the RVALUE of a '=' directive wasn't a constant number,
      error message "undefined symbol" was displayed. Changed to message
      "constant expected".
   -  literal character operator ('!') wasn't handled the way Masm
      does. So sometimes a '!' in a literal got "lost".
   -  padding a struct with bytes because of alignment didn't work
      reliably.
   -  an undefined segment in a group wasn't flagged as error.
   -  || operator in .WHILE didn't work reliable.
   -  if a start label is emitted undecorated in /coff and its
      language type is NONE, the underscore prefix must be omitted which
      wasn't done.
   -  syntax errors in control-flow directives (.IF, .WHILE, ...)
      weren't noticed sometimes.
   -  if an assembly error occured in a line which contained a %s
      and -Fl switch was set, a GPF might have occured.
   -  .model parameter FARSTACK didn't set text equate @stack to
      'STACK'.
   -  stack segment was added to DGROUP even if .model parameter
      FARSTACK was set.
   -  changing language with <OPTION language> didn't update assembly
      time variable @Interface.

   Other changes:
   -  if instruction is RET[F] <value> and <value> is 0 (and it is not
      external, it's now optimized to the one-byte short RET[F].
   -  EXTERNDEF's type comparison was too rigid for arbitrary types.
      Now a symbol type conflict will be reported only if the base types
      differ.
   -  type modifiers for DWORD data items containing label addresses will
      now affect code generation.
   -  reserved words EQU2, .XMM2 and .XMM3 (all WASM specific) removed.
   -  error message texts no longer stored as string resources.
   -  there's now a JWasm binary for Linux available, distributed in a
      separate package.
   -  speed optimisation: the second and further passes will no longer
      scan the full source.
   -  the DOS binary JWASMD.EXE now includes the HDPMI DOS extender code,
      making it a stand-alone binary.
   -  directives ELSEIF1, ELSEIF2, .ERR1 and .ERR2 supported.
   -  -Zi option added (currently it's a no-op).
   -  better syntax check for the NAME directive to help to avoid using
      this reserved name as an identifier.
   -  IMAGEREL and SECTIONREL operators supported for /coff.
   -  previous versions allowed instruction names used as labels. This
      has been deactivated.
   -  -Zp[n] option added.
   -  structure fields are displayed in standard listing, not just in
      symbol-table listing.
   -  for /coff, default library names are now enclosed in double quotes
      only if the name contains a space (some linkers have problems with
      the quotes).
   -  OPTION NOKEYWORD now works with all reserved words.
   -  improved syntax check for parameters of OPTION directive.
   -  ELF output format supported.
   -  OPTION NOREADONLY and OPTION NOOLDMACROS accepted (dummies).
   -  cmdline option -G<c|d|z> implemented.
   -  PUSHCONTEXT/POPCONTEXT implemented.
   -  level of warning 'cannot access label with segment registers' changed
      from 3 to default level 2.

   06/21/2008, v1.8:

   Bugfixes:
   -  expression after .BREAK/.CONTINUE wasn't evaluated correctly
      if it contained "&&" or "||" operators.
   -  if a userdefined prologue macro was executed, the first
      line of the procedure was "lost".
   -  the value returned by a userdefined prologue macro function
      was ignored.
   -  a forward reference to a segment name caused a "General
      Failure" error.
   -  a text symbol defined with cmdline parameter -D got default
      value <1> if no value was specified, which isn't what Masm does.
      Now <> is assigned.
   -  bugfix (known bug): syntax
        mov eax, [edi.<TYPE>].<Field_name>
      is accepted now.
   -  bugfix (known bug): sometimes a superfluous type name wasn't skipped,
      resulting in an error msg of "Symbol <TYPE>.<TYPE> is not defined".
   -  bugfix (known bug): a macro function had always to be called with
      parameters enclosed in brackets, even if EXITM will return nothing.
      This has been corrected.
   -  TYPE operator didn't accept register or type operands.
   -  if there were both an EXTERNDEF and a PUBLIC definition for
      a symbol, a PUBDEF entry was added to the object module, even if the
      symbol wasn't defined in the module.
   -  LENGTH operator didn't accept a structure field.
   -  communal variables were stored in one COMDEF record, no matter
      how large this record might have grown. Now it is ensured that record
      size won't exceed 1024.
   -  forward reference of a label in a LxS instructions failed
      with error 'invalid instruction operands'.
   -  labels in data items were stored without optional offset.
   -  FLAT as a group override ("mov eax, offset FLAT:<symbol>")
      was rejected.
   -  '%' used as COMMENT delimiter didn't work.
   -  alignment was ignored if the offset of a nested structure
      was to be calculated.
   -  COMMENT directive wasn't recognized in an inactive IF block.
   -  an invalid optimization was triggered if a question mark was
      the last of multiple items in a DUP argument (i.e. "DUP (?,?)"). As
      a result, the total amount of space reserved was too short.
   -  in 16bit code segments, value 0xFC was used to pad 1 byte,
      which is the CLD instruction. Now 0x90 (NOP) is used.
   -  a typecast to force JWasm to use the long format of an
      instruction was ignored. Example:
        cmp ax,1          ; the "short" (byte) format (83 F8 01) is used
        cmp ax,word ptr 1 ; the "long" (word) format (3D 0001) is to be used
      Now the typecast will make JWasm create the "long" format.
   -  .STARTUP created wrong code for TINY model.
   -  field initializer for a bit-field in a RECORD definition was
      accepted, but wasn't stored.
   -  if a PROC parameter had no explicit type associated with it
      (that is, the ":<type>" part was missing), then JWasm's behavior tended
      to be hazardous due to the usage of uninitialized stack variables.
   -  if the fields in a RECORD didn't total exactly to 8,16 or 32,
      the record wasn't shifted right.
   -  a label before a .ERRxx directive caused a syntax error.
   -  bugfix (known bug): labels in lines containing a "conditional assembly"
      directive (IF, ELSE, ENDIF, ...) were ignored.
   -  if a memory operand was pushed/poped, there was no type check.
      So memory items with sizes < WORD or > DWORD were accepted.
   -  stack <stacksize> reported error "constant operand expected"
      if stacksize wasn't a single number.
   -  stacksize stored for stack segments was a 16bit value only.
   -  macro parameter expansion operator % might have caused a GPF
      if the parameter was the last one and was intended to convert a number
      to a literal.
   -  lines with the FOR/FORC directives were expanded. This was a
      problem if the directive's first parameter was a valid text macro name.
   -  COMMENT delimiter wasn't detected if it was located behind
      a ';'.
   -  if a numeric equate's magnitude exceeded 32bit, the high bits
      were skipped. Now the equate will be stored as a text macro in this
      case.
   -  there was no parameter syntax check for [ELSE]IFIDN[I],
      [ELSE]IFDIF[I], [ELSE]IFB, [ELSE]IFNB.
   -  if a segment was open when the END directive was detected,
      the segment's content was skipped, no error message was displayed.
   -  if a FOR parameter string contained a call of a macro function
      which had more than 1 parameter, a syntax error occured.
   -  parameter syntax check for .ERRxx directive was missing.
   -  .ERRDEF and .ERRNDEF checked whether the symbol was defined
      in all passes, but this can't be done in pass one due to possible
      forward references.
   -  initialization of a structure/union embedded in another
      structure might have failed if there were leading spaces before the
      initialization string.
   -  a text macro defined with cmdline option -D must not have
      contained a '-' or '/'.
   -  code for ALIAS didn't check whether the alias name was defined
      elsewhere in the source.
   -  logical operators EQ, NE, LT, LE, GT, GE did accept constant
      operands only, but they must also work with relocatable direct
      addresses.
   -  there was a chance that an invalid OMF record was written
      if lots of externals were defined which exceeded the max size of one
      record.
   -  if a byte array in a structure was initialized with a string,
      there were too many bytes emitted.

   Other changes:
   -  error msg 'Too many arguments to INVOKE' displayed instead of just
      'Syntax error'.
   -  undefined publics are now flagged as error when the PUBLIC directive
      occurs in the source, not at the end of assembly pass one.
   -  if the expression after .WHILE is a constant value != 0, the initial
      jump to test the condition is superfluous and is skipped now. Same
      behavior as Masm.
   -  cmdline options -Wn, -w and -WX synch'ed with Masm, option -we deleted.
   -  added missing directives .LALL, .NOLISTMACRO and .NOLISTIF.
   -  source modules in subdirs WATCOM and WOMP included to the project,
      so object modules in WATCOM and WOMP could be deleted.
   -  string resource handling switched to native Win32, WRES.LIB no longer
      necessary and deleted.
   -  speed boost achieved (reduced number of necessary passes) by better
      handling of forward references.
   -  GOTO supported.
   -  more than one source file in the command line accepted.
   -  directive .UNTILCXZ supported.
   -  operator THIS implemented.
   -  OPTION LANGUAGE:<language> implemented.
   -  OPTION SEGMENT:<segSize> implemented.
   -  OPTION M510/NOM510 implemented
   -  OPTION OLDSTRUCTS/NOOLDSTRUCTS implemented.
   -  OPTION SCOPED/NOSCOPED implemented.
   -  OPTION LJMP/NOLJMP implemented.
   -  OPTION EMULATOR/NOEMULATOR implemented.
   -  .RADIX 10 accepted (it's a noop).
   -  -Zm, -Sn, -nologo, -zlf, -zls options added.
   -  -zz option renamed to -zzp for consistency.
   -  -omf, -coff options added
   -  -bt option removed.
   -  -Sg, -c added (noops)
   -  listing is supported.
   -  default for floating point instructions has been changed to -FPi87,
      that is, no emulator fixups are created.
   -  initialization for RECORD data items implemented.
   -  support for COFF output format implemented.
   -  code generated by .STARTUP is now similar to what Masm creates.
   -  support for segment attribute IGNORE removed.
   -  predefined numeric equate @WordSize added

   05/20/2008, v1.7 (initial):

   Changes in JWasm compared to Open Watcom's WASM v1.7.

   Bugfixes:
   -  string equates now handled the way MASM does.
   -  fixup of start address now refers to the group of the start
      address's segment. WASM still has problems if the
      start address is in a segment which isn't the first one in a group.
   -  EXTERNDEFs which aren't referenced in the source now won't
      cause a EXTDEF entry to be created in the object module.
   -  EXTERNDEFs for a symbol which were contained several times in the
      source caused several PUBDEFs to be created in the object module if
      the symbol was actually defined.
   -  SIZEOF (sometimes?) returned double the size of a variable.
   -  structure field names were stored in the global symbol table.
      This caused various problems and often bad code was created.
   -  some "reserved" words in WASM, which aren't reserved in MASM
      were removed from this list: "ERROR", "PRIVATE", "COMMON", "EXPORT",
      "READONLY", "IGNORE", "CASEMAP", "SMALL", "MEMORY", "COMPACT", "ABS",
      "NOTHING", "MEDIUM", "LARGE", "TINY", "HUGE", "USES", "FARSTACK",
      "NEARSTACK", "OS_DOS", "OS_OS2".
   -  symbol type conflicts are now detected and reported as errors.
   -  default type of LOCAL variables was always WORD.
   -  alignment of LOCAL variables wasn't MASM-like.
   -  quotes and curly-bracket delimiting strings were removed during
      the tokenisation process. This isn't MASM compatible.
   -  string equates were "evaluated" very early, making it impossible to
      define a string equate which contained another string equate.
   -  a macro local caused a text equate with identical name to be generated
      or changed. This side-effect wasn't expected.
   -  WASM needed ':REQ' in capitals to make a macro parameter "required".
      MASM is not case sensitive here.
   -  macro parameters in the macro definition were expanded, which is a
      bad idea. Thus it was impossible to give macro parameters a name
      which was already used in the namespace (for example the name of a
      previously defined macro).
   -  a macro name given as parameter in a IFDEF/IFNDEF line was "evaluated".
   -  if a source line ends with a comma, it was generally concatenated with
      the next line. This caused problems with invokation of macros with
      "empty" arguments. The automatic concatenation is now just done if
      a text item (enclosed in <> or {}) is still open at the end of the
      line and last character of the line is a comma.
   -  the object module to write was not always deleted if an error occured.
   -  arrays with 0 items caused a GPF.
   -  macros couldn't be redefined.
   -  number suffix 't' to define a decimal number) was not implemented.
   -  ALIAS directive syntax differed from MASM's.
   -  it was impossible to have a PROC with locals in a macro.
   -  LENGTHOF didn't work if a DB statement contained strings.
   -  PUBLIC + EXTERNDEF for the same label caused 2 PUBDEF records to
      be written to the object module.

   Other changes:
   -  local labels in procedures supported.
   -  '::' operator supported to make a label inside a procedure global.
   -  PROTO directive supported.
   -  INVOKE supported.
   -  TYPEDEF supported.
   -  UNION supported.
   -  RECORD supported.
   -  nested (and anonymous) STRUCTs and UNIONs supported.
   -  alignment argument for STRUCT supported.
   -  some MASM "options" are accepted:
      + option proc: private | public | export
      + option dotname | nodotname (nodotname is dummy)
      + option casemap:none | notpublic | all  (notpublic is dummy)
      + option prologue: none | prologuedef | <macroname>
      + option epilogue: none | epiloguedef | <macroname>
      + option nokeyword: <reserved_word>
   -  FLAT accepted as segment attribute.
   -  EXTERNDEF will accept structure names as item's type.
   -  /Cp option added to make JWasm preserve case of identifiers.
   -  /zcw option added to let JWasm use the Watcom C name mangler.
      (/zcm is the default now).
   -  LOW, HIGH, LOWWORD, HIGHWORD, OPATTR, .TYPE, TYPE, WIDTH and MASK
      operators implemented.
   -  PROC: procedure parameters and locals are now true symbols with type
      information, internally handled similiar to "structure fields".
      The original approach handled these items as strings, which needs
      an additional "string expansion" step inside procedures and type
      information for such symbols was unavailable for the code generator.
   -  LOCAL directive accepts all variations which MASM does.
   -  LOCALs may have structured types.
   -  PROC parameters may have structured types.
   -  STRUCT "redefinitions" accepted (as long as it doesn't change the
      "structure").
   -  numeric equates can be contained multiple times in the source as long
      as their values are identical.
   -  macro functions and EXITM supported.
   -  CATSTR, SUBSTR, SIZESTR and INSTR directives supported.
   -  predefined macro functions @CATSTR, @SUBSTR, @SIZESTR, @INSTR supported.
   -  ECHO implemented.
   -  types REAL4, REAL8 and REAL10 supported.
   -  pointer qualifiers NEAR16, NEAR32, FAR16 and FAR32 supported in TYPEDEF.
   -  VARARG as macro parameter qualifier supported.
   -  .IF, .ELSE, .ELSEIF, .ENDIF, .WHILE, .ENDW, .REPEAT, .UNTIL, .BREAK
      and .CONTINUE implemented.
   -  predefined equates @Cpu, @CurSeg, @code, @data, @stack, @Date, @Time,
      @FileName supported.
   -  missing conditional directives (ELSEIFB, ELSEIFIDN, ...) implemented.
   -  evaluation operator "%" supported.
   -  literal character operator "!" supported.
   -  cmdline options made more MASM alike (-d1 changed to -Zd, ...).
   -  JWasm's -D cmdline option always defines a "text macro", similiar to
      MASM.
   -  PURGE implemented.
   -  ASSUME <stdreg>:<ptr type> is supported.
   -  WHILE implemented.
   -  @Environ macro function supported.
   -  lots of debug messages added.
   -  type PWORD has been removed (was an alias for FWORD).
   -  directive DP has been removed (was an alias for DF).
   -  directive GLOBAL has been removed (was an alias for EXTERNDEF).
   -  support for JMPF/CALLF has been removed.