diff options
Diffstat (limited to 'NEWS')
| -rw-r--r-- | NEWS | 748 |
1 files changed, 748 insertions, 0 deletions
@@ -0,0 +1,748 @@ +mcpu-cpp 1.0.2 +=============== + +Implemented LibMPU, LibMPUIO congiguring check using libmpu.m4, libmpuio.m4. + + +mcpu-cpp 1.0.1 +=============== + +Integrate the mcpu-cpp(1) manual pages. + +* Add English man/mcpu-cpp.1 and Russian man/ru/mcpu-cpp.1. +* Install the pages through Automake's standard man directory hierarchy. + +mcpu-cpp 1.0.0 +=============== + +Remove Russian preprocessing-directive aliases and prepare the public interface +for another verification cycle before 1.0.0. + +* Accept only canonical English preprocessing-directive names; Unicode support + for identifiers and ordinary source text is unchanged. +* Remove Russian-alias regression cases without changing the underlying macro, + conditional, include, diagnostic, language-stack, or output engines. +* Retitle manual section 10 as "GNU-compatible features" and summarize the + documented behaviors intentionally aligned with GNU CPP. +* Remove references to the predecessor preprocessor from both normative manuals. + +mcpu-cpp 0.0.50 +=============== + +Refresh and bilingualize the normative manual and add a developer bootstrap. + +* Replace the single doc/mcpu-cpp.md with synchronized Russian and English + manuals: doc/mcpu-cpp-ru.md and doc/mcpu-cpp-en.md. +* Bring the manual up to the 0.0.49 feature set, fix stale future-work text and + conditional-expression subsection numbering, and document the current + intentionally unsupported legacy features. +* Add a root bootstrap script, modeled after the LibMPU/LibMPUIO bootstrap + workflow, that regenerates the ZUBR parser and Autotools-generated files. +* Add a root .gitignore describing files that a developer Git tree may omit; + keep release archives self-contained and the ordinary release build unchanged. + +mcpu-cpp 0.0.49 +=============== + +Compact invisible output lines while preserving exact source coordinates. + +* Track the next visible logical source position instead of materializing every + consumed directive/comment/blank source line in .E output. +* Match GNU CPP's 0..7 newline versus 8+ corrective-linemarker boundary. +* Preserve include entry/return markers and avoid synthetic progress markers + for completely silent included files. +* Keep __LINE__, diagnostics, #line and logical coordinates independent of the + compacted physical output representation. + +mcpu-cpp 0.0.48 +=============== + +Normalize whitespace that belongs to macro replacement lists. + +* Canonicalize replacement-list whitespace to one ASCII space after line + splicing while preserving ordinary source formatting and actual-argument + whitespace. +* Preserve literal contents and preprocessing-token boundaries around #, ##, + __VA_ARGS__, __VA_OPT__ and placemarkers. + +mcpu-cpp 0.0.47 +=============== + +Add the standard __VA_OPT__(pp-tokens) mechanism. + +* Decide variadic emptiness after normal macro substitution. +* Support balanced parentheses, stringification, token concatenation, + placemarkers and rescan integration. +* Intentionally omit GNU named variadics and the historical comma-swallow + extension , ## __VA_ARGS__. + +mcpu-cpp 0.0.46 +=============== + +Add C99-style variadic function-like macros. + +* Accept ... as the final macro parameter and substitute __VA_ARGS__. +* Preserve ordinary prescan, raw stringification and token-paste semantics for + the complete variadic tail, including empty-tail placemarkers. +* Keep the old GNU named form args... and __VA_OPT__ outside this release. +* Preserve variadic definitions in macro dumps and document the exact contract. +* Add dedicated regression coverage for expansion, #, ##, dumps and errors. + +mcpu-cpp 0.0.45 +=============== + +Add GNU-like missing-generated dependency handling. + +* Implement -MG for dependency-only -M/-MM modes. +* Record unresolved includes in the existing ordered dependency registry while + keeping their textual identity separate from physical st_dev/st_ino identity. +* Preserve GNU-like user/system filtering for missing quoted/angle includes and + system-header context; tolerate missing -include/-imacros operands under -MG. +* Keep -MG invalid with -MD/-MMD or without -M/-MM. +* Document the unresolved-dependency model and add dedicated regression coverage. + +mcpu-cpp 0.0.44 +=============== + +Add explicit dependency targets and complete the forced-file documentation. + +* Implement GNU-like -MT TARGET and -MQ TARGET, including attached forms. +* Allow repeated -MT/-MQ options and multiple targets in one dependency rule. +* Keep -MT literal while -MQ applies Make quoting; suppress the default target + whenever an explicit target is present. +* Document -include/-imacros and -MT/-MQ in doc/mcpu-cpp.md. +* Add dedicated dependency-target regression coverage. + +mcpu-cpp 0.0.41 +=============== + +Clean the public interface and formalize selected Russian directive aliases. + +* Remove obsolete compatibility options from the command-line parser so they + are diagnosed as unknown options instead of remaining dormant handlers. +* Keep -E as the intentional compiler-driver compatibility no-op. +* Document --object-suffix in --help and require its argument. +* Add Russian aliases for define, line, include, include_next, undef, pragma + and lang; normalize non-once #управление output to #pragma. +* Rename the product description to "MCPU languages preprocessor" and remove + predecessor-oriented wording from source comments and documentation. +* Add interface-cleanup and Russian-alias regression coverage. + +mcpu-cpp 0.0.40 +=============== + +Add explicit warning-control semantics. + +* Implement -Wcomment/-Wcomments and negative forms for nested block-comment + openers and backslash-newline continuation of // comments. +* Make -Wall enable the optional comment-warning class while preserving the + priority of an explicit -Wno-comment regardless of option order. +* Implement -Werror/-Wno-error for every warning actually emitted by mcpu-cpp, + without making -Werror enable optional warning classes. +* Route #warning, zNNN width warnings, macro redefinition and invalid ## paste + through the common warning policy. +* Add dedicated regression coverage and a normative documentation section. + +mcpu-cpp 0.0.39 +=============== + +Split final macro dumping into ordinary and predefined views. + +* Make -dM dump only source/include and command-line macros. +* Implement -dMP as predefined macros first, followed by ordinary macros. +* Preserve deterministic name sorting inside each group and final #undef state. +* Keep context-dependent special macros out of the static dump. +* Leave -dD semantics unchanged. +* Add dedicated regression coverage and document the macro-origin contract. + +mcpu-cpp 0.0.38 +=============== + +Extend dependency generation with side-effect dependency files. + +* Add GNU-like -MD and -MMD without suppressing normal preprocessing output. +* Add -MF FILE, including attached -MFfile spelling and -MF - for stdout. +* Derive the default .d filename from the input basename, or from ordinary -o + output when present. +* Reuse the existing -M/-MM dependency graph and system-header classification. +* Add dedicated regression coverage and document the dependency-output rules. + +mcpu-cpp 0.0.37 +=============== + +Make the MCPU installation tree relocatable and shared by the future toolchain. + +* Install under `$libdir/mcpu` rather than `$libdir/mcpu-VERSION`. +* Resolve the real executable at run time and derive `<root>/include` and + `<root>/etc/mcpu-cpp.conf` from the physical MCPU root. +* Keep `/etc/mcpu/mcpu-cpp.conf` and `$HOME/.mcpu/mcpu-cpp.conf` as higher + priority overrides, including full replacement of MCPU_CPP_SYSTEM_INCLUDE_PATH. +* Remove the absolute installation default from the packaged config and runtime + binary contract. +* Add a regression that physically moves a complete MCPU tree and verifies the + new root, include search, packaged config and symlink invocation. +* Document one relocatable `bin/etc/include/lib` root as a general MCPU + ecosystem principle for mcpu-cpp, mcpu-as, mcpu-ld and mcpu-run. + +mcpu-cpp 0.0.36 +=============== + +Correct --no-config so it suppresses configuration-file reads without +discarding the compiled installation defaults. + +* Keep the compiled MCPU_CPP_SYSTEM_INCLUDE_PATH active under --no-config. +* Make -dsearch-dirs, -dconfig and -v expose that built-in default even when + every configuration file is ignored. +* Preserve explicit -I/-isystem/-idirafter ordering around the compiled system + tree and keep -nostdinc as the switch that suppresses standard-system paths. +* Add dedicated regression coverage and document the distinction between + compiled defaults, configuration files and -nostdinc. + +mcpu-cpp 0.0.35 +=============== + +Implement the first dependency-generation stage. + +* Add -M make-rule output including system headers. +* Add -MM user-dependency output excluding system headers and descendants + reachable only from system-header contexts. +* Collect dependencies directly from the existing include/#include_next + pipeline and deduplicate physical files by device/inode identity. +* Keep #line logical filenames out of dependency output and preserve a file in + -MM when it is also reached through a user include context. +* Add dedicated dependency-generation regression coverage and documentation. + +mcpu-cpp 0.0.33 +=============== + +Align the configure-time console presentation with the LibMPU/LibMPUIO/ZUBR +package family and normalize the author's given name spelling. + +* Add the shared-style mcpu-cpp configure headline and AC_MSG_CFG_PART section + headings to make configure output follow the same visual structure as the + other MCPU/LibMPU projects. +* Keep the existing detailed configuration summary as its own final section. +* Normalize every textual occurrence of the author given name to `Andrey` + throughout the maintained project tree. + +mcpu-cpp 0.0.32 +=============== + +Polish include-path diagnostics after the 0.0.31 installation/search contract. + +* Make -v print each effective include configuration variable once, after all + configuration layers have been resolved. +* Add -dsearch-dirs to print effective include search directories in semantic + priority order and stop without preprocessing. +* Document the distinction between effective configuration values and the + expanded global search-directory chain. + +mcpu-cpp 0.0.31 +=============== + +Introduce the versioned MCPU installation/configuration contract. + +* Install mcpu-cpp under `$libdir/mcpu-0.0.31/bin` and its packaged + configuration under `$libdir/mcpu-0.0.31/etc`. +* Install `$bindir/mcpu-cpp` as a symbolic link to the versioned executable. +* Do not install or create `/etc/mcpu`; treat `/etc/mcpu/mcpu-cpp.conf` only as + an optional distributor/administrator override. +* Load configuration in increasing priority: compiled versioned defaults, + versioned packaged config, optional `/etc` override, then the unversioned + `$HOME/.mcpu/mcpu-cpp.conf` user override. +* Restore `MCPU_CPP_SYSTEM_INCLUDE_PATH` as the replaceable effective system + include root, defaulting to `$libdir/mcpu-0.0.31/include`. Derive + `<root>/<lang>` internally; no per-language system variables exist. +* Let a higher-priority config replace the system tree completely or disable it + with an empty value. +* Keep the normative include and #include_next search order established in + 0.0.30, now using the effective `MCPU_CPP_SYSTEM_INCLUDE_PATH`. +* Document the versioned tree, configuration precedence, sandbox workflow and + wrapper-header rationale as normative interfaces. + +mcpu-cpp 0.0.30 +=============== + +Define and enforce the normative include-search contract discovered by manual +wrapper-header testing. + +* Give explicit command-line -I, -isystem and -idirafter directories priority + over persistent configuration classes. +* Search configured user language paths before MCPU_CPP_INCLUDE_PATH. +* Replace MCPU_CPP_SYSTEM_INCLUDE_PATH with the singular + MCPU_CPP_SYSTEM_INCLUDE_DIR system-tree root. Derive the fixed <root>/<lang> + directory internally and then search <root>; no per-language system config + variables exist. +* Allow an empty MCPU_CPP_SYSTEM_INCLUDE_DIR to disable the configured system + tree. -nostdinc suppresses the same configured system classes for one run + without suppressing explicit -isystem. +* Keep explicit -idirafter before MCPU_CPP_AFTER_INCLUDE_PATH and never derive + language-specific AFTER directories. +* Make #include_next traverse this exact effective chain by physical provenance. +* Add a dedicated manual-style regression that places the same header in all + eight search classes and verifies the complete #include_next order. +* Add a separate normative documentation section explaining the search order, + configurable user paths, fixed system subdirectory names and wrapper-header + purpose. + +mcpu-cpp 0.0.29 +=============== + +Implement GNU-style #include_next wrapper-header search. + +* Track the exact configured include-directory entry that supplied each nested + header and continue #include_next strictly after that entry. +* Preserve the semantic search order across -I, explicit -isystem, configured + system directories and -idirafter directories. +* Do not re-search the current source-file directory for #include_next; the + directive intentionally does not distinguish between "file" and <file>. +* Support macro-expanded #include_next operands through the ordinary include + operand parser and macro-expansion path. +* Keep physical include provenance independent of logical #line filenames. +* Add regression coverage for the wrapper -> configured-system -> idirafter + chain, quoted-source origin, macro operands, inactive branches and failure + when no later header exists. + +mcpu-cpp 0.0.28 +=============== + +Implement #error and #warning diagnostics. + +* Active #error emits a source-location error diagnostic and stops preprocessing. +* Active #warning emits a source-location warning and preprocessing continues. +* Diagnostic directive arguments are not macro-expanded, following the directive contract; whitespace between tokens is folded while quoted text is kept. +* Diagnostic directives are consumed and never copied to normal or -dD output. +* Inactive conditional branches suppress both directives completely. +* Historical Russian aliases #ошибка and #предупреждение are recognized. + +mcpu-cpp 0.0.27 +=============== + +Define the MCPU integer-width suffix contract for conditional expressions and +remove the obsolete assertion command-line heritage. + +* Accept `zNNN`/`ZNNN` and optional trailing `U`/`u` on integer constants. + NNN is always decimal, including forms with leading zeroes. +* `z8`, `z16`, `z32` and `z64` normalize the low N bits by sign extension; + an optional U/u selects zero extension. All later expression evaluation is + still exactly 64-bit and does not retain the source width. +* Widths above 64 are errors in conditional directives. Invalid widths up to + 64 are ignored with a warning; a trailing U/u remains effective. +* Remove C-style L/LL integer suffix acceptance from the #if lexer. +* Diagnose a suffix that runs into an identifier instead of splitting it into + unrelated tokens. +* Remove the obsolete `-A` assertion option, the assertion action kind and the + `-dMA` assertion-dump modifier. +* Document the complete normalization and 64-bit evaluation model. +* Add regression coverage for width suffixes, sign/zero extension, truncation, + 64-bit post-normalization operations, errors and removed assertion options. + +mcpu-cpp 0.0.26 +=============== + +Use the ZUBR grammar architecture for #if expression parsing. + +* Add mcpp-expr.zubr with the grammar and UCS-2 lexical analyzer; generated + mcpp-expr.c uses the mcpp_zubr_* prefix from ZUBR 4.1.0. +* Keep the established defined() preprocessing and macro-expansion front end. +* Move fixed-width #if arithmetic to mcpp-semantic.c/h; expression integers + use LibMPU 64-bit types rather than host long/intmax_t. +* Parse binary/octal/decimal/hexadecimal integer lexemes through LibMPU + iatoui() after validating/copying the ASCII subset from UCS-2. +* Character units are UCS-2 __mpu_uint16_t values; multi-character + packing is retained up to the 64-bit expression width. +* Preserve the defined precedence, negative-shift direction and short-circuit + behavior for &&, || and ?:. +* Ship the generated C source; ZUBR is needed only when the .zubr grammar is + regenerated. The obsolete code-page -T option is not used. +* Add a dedicated ZUBR expression regression. + +mcpu-cpp 0.0.25 +=============== + +Refine preprocessing identifiers and command-line macro declarator parsing. + +* Permit `$` after the first preprocessing-identifier character, while keeping + `$` forbidden as an identifier start. +* Apply the same `$` continuation rule throughout macro names, parameters, + conditionals, expansion, # stringification and ## rescanning. +* Parse the -D declarator separately from its replacement value so an invalid + tail before '=' is discarded instead of becoming replacement text. +* Apply the same valid-identifier-prefix rule to -U command-line actions. +* Document shell quoting explicitly: single quotes already protect `$`; an + unquoted or double-quoted `$` must be escaped when literal text is intended. +* Extend Unicode/command-line macro regressions for `$`, invalid tails, -U and + forbidden `$` at identifier start. + +mcpu-cpp 0.0.24 +=============== + +Correct -dD origin markers for command-line macro definitions. + +* Macros installed by -D are tagged as command-line definitions internally. +* -dD emits `# 0 "<command-line>"` before command-line definitions instead of + incorrectly reporting them as `# 0 "<built-in>"`. +* Predefined/builtin macros retain the `# 0 "<built-in>"` marker. +* Added a regression covering Unicode -D names and both marker classes. + +mcpu-cpp 0.0.23 +=============== + +Implement command-line macro definition and undefinition. + +* -DNAME defines NAME as 1; -DNAME=VALUE defines VALUE, including an empty + replacement after an explicit '='. +* Function-like command-line macros use the same parser and macro engine as + source #define directives, including # stringification and ## concatenation. +* -D and -U payloads alone are decoded from UTF-8 to strict UCS-2; filenames, + include paths and all other command-line arguments remain byte strings. +* Unicode command-line macro names use the same XID_Start/XID_Continue rules + as source identifiers. Invalid UTF-8 and non-UCS-2 characters are rejected. +* -D/-U actions are applied in command-line order after predefined/builtin + macros are installed, so -U may remove a predefined macro and later -D may + define it again. +* Added dedicated regression coverage for ASCII and Unicode command-line + macros, order, function macros, #/##, conditionals and invalid encodings. + +mcpu-cpp 0.0.22 +=============== + +Use LibMPUIO 1.0.4 strict UCS-2 Unicode 18.0.0 XID classification for +preprocessing identifiers. + +* Identifier start is `_` or Unicode XID_Start. +* Identifier continuation is `_` or Unicode XID_Continue. +* Macro names and parameters may therefore use UCS-2 letters from supported + scripts, combining marks in continuation positions, and non-ASCII decimal + digits in continuation positions. +* The same identifier rules are used by #define/#undef, #ifdef/#ifndef, + defined(), ordinary macro expansion, stringification, token concatenation + rescanning. +* Classification is locale-independent and inherits LibMPUIO strict UCS-2 + semantics; surrogate code units are never identifiers. +* Configure now verifies that the required LibMPUIO UCS-2 ctype API is present. + +mcpu-cpp 0.0.21 +=============== + +Implement GNU-compatible token concatenation (##). + +* ## now pastes preprocessing tokens in both object-like and function-like + macro replacement lists. +* A formal parameter adjacent to ## uses its raw, unexpanded actual argument; + the completed replacement list is rescanned afterwards. This preserves the + standard two-level CAT/XCAT expansion technique. +* Empty pasted arguments use placemarker semantics, and multi-token arguments + paste only the token adjacent to ##. +* Pasting can form identifiers, preprocessing numbers, multi-character + punctuators and prefixed string/character tokens. +* An invalid paste is diagnosed and the original two tokens are emitted; ## at + either end of a replacement list is rejected when the macro is defined. +* Stringification (#) and concatenation (##) may be used in the same macro. +* Added dedicated token-concatenation regression coverage and updated macro + error tests. + +mcpu-cpp 0.0.20 +=============== + +Corrective release of the quoted #lang contract introduced in 0.0.19. + +* The #lang implementation contract is unchanged: exactly one quoted language + name, no whitespace inside the quotes, no escape processing, same-physical-line + termination, ASCII case-insensitive validation against the internal language + table only, original spelling preserved, and normalized external whitespace. +* Regression coverage explicitly checks the accepted spellings "diff", "Diff", + "DIFF" and "dIfF", as well as all other internal languages. +* All package-version regression expectations are synchronized with 0.0.20; + this fixes the stale-version test failures seen in the first 0.0.19 test run. + +mcpu-cpp 0.0.19 +=============== + +Tighten and normalize the #lang directive contract. + +* #lang now requires a quoted language name, for example `#lang "diff"`; + the unquoted form is rejected. +* The quoted text must be one non-empty word without whitespace, must close on + the same physical source line, and may be followed only by whitespace. +* Escape sequences are not interpreted inside the #lang string. +* Language lookup is ASCII case-insensitive but is restricted to the internal + language table: diff, dift, alg, as, avm and ACS. +* Output preserves the spelling inside the quotes while normalizing external + whitespace to exactly `#lang "name"`. +* Updated existing language tests and added a dedicated #lang string-contract + regression. + +mcpu-cpp 0.0.18 +=============== + +Implement conditional-compilation control flow. + +* #if, #ifdef, #ifndef, #elif, #else and #endif are consumed by the + preprocessor and never copied to normal or -dD output. +* Inactive branches are skipped without executing definitions, includes or + ordinary macro expansion; nested conditionals remain balanced. +* #if expressions follow the expr.zubr precedence model, including + defined, unknown identifiers as zero, integer operators, ?: and short-circuit + evaluation. +* Include files keep independent conditional-stack boundaries and diagnose + unbalanced or unterminated groups. +* Generated source-location information now uses GNU linemarkers (`# N "file"`) + instead of emitting `#line`; include entry/return markers carry flags 1 and 2. +* Input #line directives are consumed, macro-expanded and update __LINE__ and + __FILE__; the resulting location is emitted as a GNU linemarker. +* Added regression coverage for include guards, nested groups, all conditional + directives, defined, macro-expanded expressions, malformed groups and line + control. + +mcpu-cpp 0.0.17 +=============== + +Finish comment whitespace cleanup. + +* Removing a // or /* ... */ comment at the end of a non-empty source line no + longer leaves a trailing blank before the newline. +* The same rule applies when a block comment begins after program text and + continues onto following physical lines. +* Inline comments between tokens still preserve a separating blank where it is + required to prevent accidental token concatenation. + +mcpu-cpp 0.0.16 +=============== + +Implement -dD and correct comment/UCS-2 phase behavior. + +* -dD preserves normal preprocessed output, emits predefined macro definitions + with <built-in> markers, and keeps encountered #define directives. +* Comment-only lines are left truly empty after // or /* ... */ removal while + inline comments still preserve token separation. +* Valid UTF-8 scalars outside UCS-2 are accepted inside comments and rejected + only if they remain in program text after comment removal. +* Added regression coverage for -dD, comment-only whitespace and non-UCS-2 + characters inside versus outside comments. + +mcpu-cpp 0.0.13 +=============== + +Implement macro stringification (#). + +* Function-like macro replacement lists now support #parameter stringification. +* Stringification uses the raw, unexpanded actual argument, trims leading and + trailing whitespace, folds internal whitespace outside quoted tokens, and + escapes quotes/backslashes in the generated string literal. +* Ordinary argument expansion is now lazy, matching the established raw-vs-expanded + argument semantics and preserving nested calls of the same macro. +* Empty actual arguments are represented correctly; zero-argument macros keep + their established behavior. +* Invalid # uses are diagnosed at definition time. ## remains deliberately + rejected for the next separate token-concatenation port. +* Added regression coverage for raw-vs-expanded stringification, whitespace, + quoted text, empty arguments, diff apostrophe semantics, diagnostics and -dM. + +mcpu-cpp 0.0.12 +=============== + +Correct integer DECIMAL_DIG semantics. + +* Replaced direct use of LibMPU _int_digs() for predefined integer precision + metadata with mcpu-cpp integer-only helpers based on the known type width. +* __INT<bits>_DECIMAL_DIG__ now counts decimal digits of INT<bits>_MAX only; + it excludes both the sign and any terminating NUL. +* __UINT<bits>_DECIMAL_DIG__ now counts decimal digits of UINT<bits>_MAX only; + it excludes any terminating NUL. +* Added exact regression values for every integer family width from 8 through + 65536 bits. + +mcpu-cpp 0.0.11 +=============== + +Complete predefined precision metadata and MCPU byte/word-order naming. + +* Added __INT<bits>_DECIMAL_DIG__ and __UINT<bits>_DECIMAL_DIG__ from LibMPU + _int_digs() for every configured integer width through NB_I_MAX * 8; MAX + values remain capped at 256 bits. +* Added __REAL<bits>_DECIMAL_DIG__ and __REAL<bits>_MANT_DIG__ for every Real + width through MPU_REAL_IO_LIMIT; large numeric MAX/MIN/EPSILON/exponent + values remain capped at 256 bits. +* Replaced __FLOAT_WORD_ORDER__ with __MCPU_BYTE_ORDER__ and + __MCPU_WORD_ORDER__; __BYTE_ORDER__ remains as an alias to + __MCPU_BYTE_ORDER__. +* Added __MCPU_INT_MAX_WIDTH__, __MCPU_REAL_MAX_WIDTH__ and + __MCPU_COMPLEX_MAX_WIDTH__ capability macros. +* Renamed __SIZEOF_PTRDIFF_T__ to language-native __SIZEOF_PTRDIFF__. +* Extended predefined ABI/range regression coverage for the complete integer + and Real families. + +mcpu-cpp 0.0.10 +=============== + +Predefined ABI naming cleanup and complete Real text-buffer metadata. + +* Replaced the C-style public size family with __MCPU_SIZE_TYPE__, WIDTH, + SIZEOF_SIZE and MAX; renamed __MCPU_SIZEOF_SSIZE_T__ to + __MCPU_SIZEOF_SSIZE__. +* Renamed __SIZEOF_CHAR8_T__/__SIZEOF_CHAR16_T__ to the language-native + __SIZEOF_CHAR8__/__SIZEOF_CHAR16__. +* Added __SIZEOF_REAL<bits>_EXP__ from LibMPU _sizeof_exp() for every Real + width through MPU_REAL_IO_LIMIT. +* Added __REAL<bits>_MAX_STRLEN__ from _real_max_string() for every Real width; + the value is a character count, not a byte count. +* Extended -dM regression coverage to verify the new names and the largest + configured Real family. + +mcpu-cpp 0.0.9 +============== + +Complete structural predefined metadata across LibMPU type ranges. + +* Corrected MCPU ptrdiff to signed int64 with max 0x7fffffffffffffff. +* Added the MCPU-specific signed-size family: __MCPU_SSIZE_TYPE__, WIDTH, + SIZEOF and MAX from the configured LibMPU __mpu_ssize_t profile. +* Integer TYPE/WIDTH/SIZEOF families now extend through NB_I_MAX * 8; + numeric MAX/DECIMAL_DIG values remain capped at 256 bits. +* Real/Complex TYPE/WIDTH/SIZEOF families now extend through + MPU_REAL_IO_LIMIT; numeric Real characteristics remain capped at 256 bits. +* Corrected __COMPLEX<bits>_WIDTH__ to the language type parameter <bits>; + __SIZEOF_COMPLEX<bits>__ remains twice the corresponding Real storage. +* Added exhaustive -dM regression coverage across all advertised integer, + Real and Complex structural families. + +mcpu-cpp 0.0.8 +============== + +Predefined ABI refinement and derived system language include paths. + +* Renamed __VERSION__ to __MCPU_CPP_VERSION__ and report the mcpu-cpp version. +* Renamed LibMPU-profile predefines to the __MCPU_* namespace. +* Character type spellings are now char8 and char16. +* MCPU pointer and ptrdiff contracts are fixed at 64 bits independently of host; + ptrdiff is currently uint64 by ABI decision. +* Integer/Real textual value constants are emitted only through 256 bits. + Wider families retain only type and width macros. +* Removed computed integer MIN predefines. +* Added integer DECIMAL_DIG values from _int_digs(). +* Replaced REAL<bits>_DIG with REAL<bits>_DECIMAL_DIG from _real_digs(); + MANT_DIG comes from _real_mant_digs(). +* Configured system include roots automatically add active-language + subdirectories such as /usr/include/mcpu/diff without extra config variables. +* Added regression coverage for the refined predefined environment and derived + system language include search. + +mcpu-cpp 0.0.7 +============== + +Predefined ABI/environment layer and inspection tools. + +* GNU GCC is now an explicit mandatory build compiler. +* Ported the LibMPU/LibMPUIO GCC type-size, endian and machine-register probes + into mcpu-cpp acsite.m4 under project-specific macro names. +* Configure reads and verifies the installed LibMPU real-I/O/math limits, + byte/word order, addressable-unit width, size_t and ptrdiff_t profile. +* Added _ARCH_MCPU and GCC-compatible byte-order, pointer, size_t/ptrdiff_t and + assembler-prefix predefined macros. +* Added fixed-width int/uint predefined families through 65536 bits. +* Added Real/Complex type families through 65536 bits; Real numeric limits are + generated with LibMPU and real_to_ascii up to MPU_REAL_IO_LIMIT. +* Large Real numeric predefined values are generated lazily so ordinary + preprocessing remains fast. +* __VERSION__ is now the future high-level compiler version placeholder 0.0.0. +* Added `-dM` for deterministic macro-table dumps and `-dconfig` for effective + configuration dumps; neither requires an input file. +* Added ABI, dump-macro and dump-config regression tests. + +mcpu-cpp 0.0.6 +============== + +Implement predefined macros. + +* Added the dynamic predefined macros __FILE__, __LINE__, __BASE_FILE__, + __INCLUDE_LEVEL__, __DATE__, __TIME__ and __VERSION__. +* __FILE__/__LINE__/__INCLUDE_LEVEL__ follow nested #include processing; + __BASE_FILE__ remains the original translation-unit input file. +* __DATE__ and __TIME__ are fixed once at preprocessing startup, matching the + translation-unit timestamp model. +* __VERSION__ expands to the mcpu-cpp package version, as preprocessor used its own + package version for the corresponding macro. +* Predefined expansions are emitted without rescanning, following the established + special-symbol behavior. +* Built-ins share the normal macro table and can therefore be undefined or + explicitly redefined. +* K-specific legacy built-ins (__STDK__, __K__, __kxLab__, and related names) + are not carried into the MCPU language family. + +mcpu-cpp 0.0.5 +============== + +Extend the macro engine. + +* Moved project-owned Autoconf macros from m4/ to the root acsite.m4; m4/ is + reserved for external/vendor macros. +* Documented the future developer-only Bison workflow: make parser, make tests, + then make dist. Normal release builds do not require Bison. +* Added function-like #define macros with zero or more formal parameters. +* Added nested argument parsing with defined parenthesis/comma rules. +* Actual arguments are macro-expanded before ordinary substitution, including + nested calls such as min(min(a,b),c). +* Added diagnostics for duplicate parameters, malformed definitions, incomplete + calls and wrong argument counts. +* # and ## are explicitly rejected until their semantics are implemented, avoiding silent partial preprocessing. + +mcpu-cpp 0.0.4 +============== + +Implement the first macro-processing layer. + +* Added doc/mcpu-cpp.md as a living implementation-order manual as the normative MCPU preprocessing manual. +* Added the preprocessing phase needed before directive and macro processing: + backslash-newline splicing and comment removal with preserved source lines. +* Added object-like #define and #undef. +* Added recursive/cascaded object-macro expansion with recursion blocking. +* Macro names are not expanded inside quoted strings; the historical diff + apostrophe rule remains in force. +* Added computed #include through macro expansion. +* Preserved literal #include <...> lexical behavior for comment-like text. +* Began reusing macro regression cases; the self-referential macro + case is now part of the mcpu-cpp test suite. + +mcpu-cpp 0.0.3 +============== + +Include-root and configuration-layout correction. + +* MCPU_CPP_INCLUDE_PATH is now a common user include root visible in every + language state. +* Active language-specific include directories are additional search paths + and precede the common configured root. +* Explicit names such as <diff/a.h> can therefore be used through the common + root regardless of the current #lang state. +* The system configuration moved to /etc/mcpu/mcpu-cpp.conf. +* The per-user configuration moved to $HOME/.mcpu/mcpu-cpp.conf. + +mcpu-cpp 0.0.2 +============== + +Language-contract cleanup before macro-engine development. + +* Establish initial language state 0. +* Language 0 is active at startup and cannot be named by #lang. +* Canonical #lang set is: diff, dift, alg, as, avm, ACS. +* Historical vasm was replaced by as for the real MCPU assembler. +* MCPU_CPP_VASM_INCLUDE_PATH became MCPU_CPP_AS_INCLUDE_PATH. +* Removed the temporary MCPU_CPP_C_INCLUDE_PATH. The root + MCPU_CPP_INCLUDE_PATH is the main include directory of the unnamed base + base MCPU language (state 0) and is selected only in that state. +* Added the public `make tests` target. + +mcpu-cpp 0.0.1 +============== + +Initial architectural release. + +* New UTF-8 external / UCS-2 internal source model with strict NUL rejection. +* No legacy code-page machinery. +* Hand-written preprocessing scanner; flex is not used. +* Scanner honors quoted strings and the diff apostrophe rule. +* Source/include stack with #include support. +* #lang/#endlang language stack defined for the MCPU language stack. +* Configuration-file and command-line include search paths. +* Initial language set: c, diff, dift, alg, vasm, avm, ACS. |