Changelog

   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.

   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 (Win32Inc/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.