Note: When an item has a matching GitHub ticket, the ticket number is behind the item in parentheses prefixed with #. You can find these tickets by going to:
https://github.com/X-Sharp/XSharpPublic/issues/nnn , where nnn is the ticket number.
If you find an issue in X#, we recommend that you report it on GitHub. You will be notified of the progress on the work on your issue.

Changes in 2.21.0.5

Possibly breaking changes in 2.21.0.5

All dialects

Until now, the compiler had several built-in defaults for command line options based on the dialect.

That meant that when a command line option was NOT present and a certain dialect was chosen, then that option would be automatically enabled. We are talking about the following options:

 

 

This was confusing for some of you (and also for us). For example, you would have to explicitly add the command line option /initlocals- when compiling in the FoxPro dialect if you wanted to disable the option.

 

On top of that, the MsBuild system also did not pass command line arguments to the compiler, if a certain property that matched that compiler option was not present in the project file. So, if the project file did not contain the <AllowDot> node, then the command line option /allowdot would be enabled if the project was compiled in the Core dialect, but disabled when the project was compiled in the VO or Xbase++ dialect. Very confusing!

 

To fix this, we have done the following

•The defaults are removed from the compiler.

•The Build system will generate command line options with a '-' flag for options that are not defined in the project file. This will happen for X# specific commandline options only. Compiler options that we have "inherited" from Roslyn, such as /debug, /optimize etc. will remain working like before.

•When opening a project file inside Visual Studio, we will check for the dialect and the options that are listed above. If an option is missing from the projectfile then we will add that option with the value "true". We will also remove options that are not relevant to the dialect. For example: for the core dialect, the foxpro and xpp specific settings will be removed.

 

This should normally result in the same compilation as before. The only difference that you may see is that project files are automatically updated when you open them with this build.

FoxPro dialect

Until now the DEFINE CLASS syntax could be used to create classes that inherit from the FoxPro Compatible Custom class, but also from other .Net classes. That has proven to be a bit complicated.

There also was a /fox1 compiler option that makes the AS ParentClass clause from the DEFINE CLASS command optional. Classes without AS ParentClass will then automatically inherit from Custom.

 

We have made the following changes:

•The AS BaseType clause will be mandatory like in Visual FoxPro

•The ParentType must be Custom, or a class derived from Custom.

•The /fox1 compiler is now obsolete

 

If you want to inherit from a class outside the VFP class hierarchy (a standard .Net class) then you will have to use the CLASS ... END CLASS syntax.

Compiler

Bug fixes

•Fixed Internal Compiler Error with duplicate declaration of fields/memvars (#1475)

•Fixed a bogus warning when calling a function with in VFP dialect with /fox2 enabled (#1476)

•Fixed problem with Min/Max IEnumerable extension methods of FLOAT type (#1482)

•Fixed a StackOverflowException on access/assign method in the XBase++ dialect (#1483)

•Fixed problem reading clipper/harbour .prg files with end of file marker (#1485)

•Fixed problem with the extended expression match marker in the preprocessor (#1487)

•Fixed problem passing array reference or ivar by reference in the XBase++ dialect (#1492)

•Fixed AmbiguousMatchException in Evaluate() function for methods included in an interface (#1494)

•Fixed problem with /fox1 switch being ignored in some cases (#1496)

•The Build System now automatically adds a TargetFramework Attribute to assemblies compiled with X# (#1507)

•Fixed an ambiguity problem with identical names in namespace and property, and several issues encountered when the /allowdot option is disabled (#1515)

•Fixed problem in TEXT TO/ENDTEXT with TEXTMERGE clause (#1517)

•Fixed misleading line number reported in the compiler error about requiring the /memvar option (#1531)

•Fixed some issues with defining indexed properties (#1543)

•Fixed several issues with the /vo9 (handle missing RETURN statements and return values) compiler option (#1544)

•Fixed parser problem with END DEFINE, END PROCEDURE and END FUNCTION in the VFP dialect (#1564)

•Fixed problem with using attributes in CLASS Statement in the FoxPro dialect (#1566)

•Fixed macro compiler problem with compiling strongly typed codeblocks (#1591)

•Fixed problem with Attributes being ignored for properties defined with the DEFINE CLASS syntax in the VFP dialect (#1612)

•The compiler could crash when building a solution that has a .editorconfig file

•Fixed an issue with generating the property output for attributes on Members inside a FoxPro style class definition

•Fixed typo in error message about defining a class without an AS clause in the VFP dialect (#1611)

•Added support for generic types without type parameters, like in typeof(List< >) and typeof(Dictionary<,>) (#1623)

•Changes to the FoxPro compatible DEFINE CLASS (see above)

•Changes to the way how missing commandline arguments are handled (see above)

•We have added the double colon (::) separator for interpolated strings to separate the expression from the format specifier. C# uses the single colon (:) but that character is also used as member access operator in X#.See the String Literals topic for more information.

Build System

•We have fixed an issue in the build system that would sometimes lead to a recompilation, even when nothing was changed.

•Fixed an issue where the language in the machine.config did not match the language defines in the built system

•Fixed a problem that caused the .xml doc files to be written to the wrong folder

•Changes on how missing project file properties are translated to command line arguments (see above)

Runtime

Bug fixes

•Fixed some DBSetFilter() incompatibilities with VO (#1489)

•Fixed problem with DBSetFilter() with no matching records causing subsequent calls to DBSetFilter() or DBClearFilter() to fail (#1493)

•Fixed problem (missing implementation) with the WITH CDX clause in the FoxPro COPY command (#1497)

•Fixed problem with SCATTER/GATHER MEMO MEMVAR (#1510, #1534)

•Fixed a problem with the Collection class not increasing the Count property when adding an item (FoxPro dialect) (#1528)

•Fixed problem with the APPEND FROM command with a FOR clause (#1529)

•Fixed macro compiler problem with using Str() in the FoxPro dialect (which was causing problems in the INDEX ON command) (#1535)

•Fixed a macro compiler problem with some language keywords (like REF, FIELD, DEFAULT) used as identifiers (#1557)

•Fixed problems with the REPLACE, DELETE and UPDATE commands in the VFP dialect (#1574, #1575, #1576, #1577)

•Fixed an issue in the USUAL type where CompareTo for Float values was not correctly implemented (#1616)

•Fixed an issue in the USUAL type where the ! operator was not producing the correct results compared with the (LOGIC) cast.

•We have fixed several issues in the XSharp.VFP.UI library

RDD System

•Fixed a problem in DbZap() with DBFNTX (#1509)

•Fixed problem with DBSetOrder(0) always returning FALSE in DBFNTX (#1520)

•Suppressed runtime error when using FieldPut() when workarea is at EOF, for compatibility with VO (#1542)

•Fixed problem in OrderDescend() with the AXDBFCDX driver (#1608)

•Fixed problems with reading variable-length fields in DBF files stored using MultiByte encoding.

•Fixed a problem where DBFs encoded with Simplified Chinese were interpreted as Cantonese.

•Fixed an issue in the DBF RDD where the currentbuffer was not reloaded after a record or file lock was acquired.

•We have fixed an issue with DBF files larger than 2 Gb (0x7FFFFFFF bytes)

•Creating UNIQUE indexes in the DBFCDX driver would exclude the first record from the DBF file

VOSDK

•Fixed typo in Window:__CommandFromEvent that was causing commands from SEUIXP to throw a runtime error.

Visual Studio integration

Bug fixes

•Fixed problem with saving/reading the OldStyleAssignment compiler option project setting (#1495, #1582)

•Fixed an issue in VS2022 where several features in the editor were no longer working due to a change in VS (#1545)

•Fixed editor indentation problem with SCAN...END SCAN (#1549)

•Fixed a problem with putting the .resx file for windows forms user controls in an incorrect location in the Solution Explorer (#1560)

•Fixed problem with editor snippets no longer working in VS 2022 version 17.11 (#1564)

•Fixed problem with the parameter list auto-showing tooltip when using <Enter> to accept a method from the member completion list (#1570)

•Fixed a problem with indenting lines with end keywords, such as NEXT and ENDDO, when these keywords were following by 'garbage'.

•Opening a form in the VS Form designer could fail when one of the include files declared entities, such as USING SomeNameSpace (#1595, #1596)

•Fixed an issue in the debugger where identifiers that start with a '$' character, such as "$exception" in the exception dialog were not properly evaluated (#1602)

•Fixed a problem with the indentation of VFP Style classes declared with DEFINE CLASS  ... ENDDEFINE (#1609)

New features

•The TargetFramework attribute is now automatically added to the assembly when building any project type in VS. (#1507)

•Added support for the GotoBrace command.This works for normal braces, but also for keyword pairs such as IF .. ENDIF. (#1522)

•The editor now has a combobox on the top left that shows the project in which the file is defined.

•When a file is present in multiple projects (as Linked file), the project's combobox will show the names of all projects that use the file.

•When selecting a different project from this combobox, the buffer will be repainted, because conditional compilation symbols may differ for each of the projects.

•When you use intellisense in the editor, the lookup engine will use the project selected. So, if a file is used in 2 projects, the references and source files of the selected project will be used to find reference data.

•Added support for correct indentation with FoxPro variations of closing keywords, such as ENDFOR and ENDWITH.

•We have moved several X# language related features from the Project System to the Language Service to prepare for the new Project System for SDK projects.

•We have added support for Snippets in the CompletionLists at "file" level.

•We no longer create an X# intellisense database for solutions that do not have any X# projects.

•We have made several changes to the X# intellisense database structure. When you open a solution with an existing database, the database will be deleted and all source files will be rescanned (only once).

•The X# source code editor now has an extra combobox on the top, listing the projects where a file is included. When a file is included in more than one project, all these projects can be seen. Switching to a new project will change the 'evaluation context'. Conditional compiles (#ifdef) will reflect the change in the editor.

•We have added support for the commands Edit.NextMethod and Edit.PreviousMethod in the editor. There usually is no shortcut for these commands, but you can assign them with the "Customize" option on the Toolbar in Visual Studio. You could assign Ctrl-DownArrow and Ctl-UpArrow for example.

•Improved the Clone Window selection dialog in the VOWED (#1508)

•When selecting multiple controls in the VOWED, now that lastly selected control becomes the "active" one for the Properties window

•When pasting a control in the VOWED, it now goes to the bottom of the control order list

•Added option in the VOWED Control Order dialog to start adjusting the control order of controls after the currently selected one when using "Use Mouse"

•The VO binary editors now preserve the SEALED modifier when generating code. Also PROTECT fields of sealed classes become PRIVATE (#1628)

•Updated the Mono.Cecil library to 0.11.6

•Project files are adjusted when properties that were "implicit" before are missing (see above)

XIDE

General

•Replaced System.Reflection with Mono.Cecil in intellisense for improved performance and stability.

•The Toolbox Editor also now uses Mono.Cecil for reading controls from dlls.

•When closing a file directly after opening it (without first activating another file), focus now goes back to the previously active file just before opening the new one.

•Improved support for standalone files, added options in their properties window for dialect, references etc.

•Changed default names of various XIDE support files to "xi" instead of "vi" (.xiaef, xiapp etc).

•Fixed problem with accidentally calling older versions of the XIDE resource compiler and toolbox editor.

•Added "%OUTPUTEXT% (extension of output assembly) macro in build events.

•Added support for the /allowdot compiler option in the application properties, enabled by default in all applications.

•Fixed problem with not properly saving the compiler options /initlocals, /modernsyntax, /allowoldstyleassignments and /namedargs.

•The Clipboard item in the main XIDE window statusbar now shows the current clipboard contents in a tooltip.

•The Clipboard selection context menu now also displays the contents of every virtual clipboard.

•Added Open Bin Folder context menu option for the project node in the Project tool window.

•Added option to the windows resource editor to include strings and text files.

•Added application templates for FoxPro, XBase++, and Harbour dialects.

•Application templates shown in the New Application dialog are now sorted by the GalleryIndex setting of each gallery file template.

•Implemented new menu options View|Load/Save/Reset Layout, for switching between different layouts for the IDE window and tool windows

•Added some new templates (code snippets) in template.cfg

•Added project support for the /vo15 compiler option

•Added standalone files default setting for the allowdot compiler option (Preferences/Compiler)

•Added option to set the console location when running console apps (Preferences/Advanced)

•Included several "hidden" commands in the main menu (File/Navigate and Edit/Advanced)

•Improved deletion of items in the Watch tool window

•Improved the About XIDE dialog.

Editor

•Improved Recognition of positional keywords in the code.

•Fixed recognition of two-letter long functions in code.

•Fixed problem with intellisense on functions defined in core dialect apps.

•Added intellisense support for FOREACH VAR.

•Fixed crash with VAR locals in the editor.

•Fixed several issues with LOCAL IMPLIED.

•Fixed problem with parsing modified classes in namespaces.

•Improved editor support for the FoxPro, Harbour, and XBase++ dialects.

•Added editor support for a lot of FoxPro keywords.

•Added editor support for FoxPro functions.

•The editor now recognizes && for line comments marker in FoxPro dialect.

•Added intellisense support for Nullable types specified with the ? postfix (for example, INT?).

•Added intellisense support for the ?: operator.

•Added intellisense support for IF <identifier> IS <type> VAR <local>

•Added option (Preferences/Editor/Edit) to automatically adjust numeric literals containing underscores

•Added context menu Surround with options for REPEAT..UNTIL and BEGIN SCOPE...END

•Added (experimental) option to sort entities in the editor (Edit->Sort Entities)

 

Designers

•Items in the properties window of the VOWED are now sorted by name.

•Controls in the WED can now be resized through the keyboard, using SHIFT+ Arrow keys.

•When loading a WindowsForms form in the designer, all TabControls now have their first TabPage selected initially.

•Auto-generated eventhandler method names now include an underscore between the control- and event-part of the name

•Added option (Preferences/Designers) to add an END (METHOD, CONSTRUCTOR, etc.) statement in generated code.

•Added option (Preferences/Designers) to enter current OS scaling setting (fixes problem with showing lasso lines at the wrong place when creating/moving controls in non-default settings).

•Added toolbar button to Lock/Unlock controls in the Windows.Forms and VO Window editors.

•Locked state of controls is now preserved in the Windows.Forms designer (needs a Save Form to apply).

•Fixed problem with setting the Text property of strip items to empty.

•Added option in the VOWED Control Order dialog to start adjusting the control order of controls after the currently selected one when using "Use Mouse".

•Added components SaveFileDialog, OpenFileDialog and FolderBrowserDialog in the Windows.Forms toolbox

 

Debugger

•Exception dialog while debugging now properly shows the exception message.

•Fixed a problem with incorrectly breaking on excluded handled exceptions.

•Fixed a common crash that could happen in the debugger.

 

Plugin System

•Some small corrections to the Plugin System (you may need to recompile your plugins)

•Added Plugin:OnAfterCompileApplication(oApp AS Application, eResult AS CompileResult) callback method

•Added Editor:SetSelection() method to select text in the editor

•Entity objects returned from the plugin system no longer include END CLASS and END NAMESPACE statements

Documentation

Bug fixes

•Made many corrections to the documentation (#1504, #1506, #1514).

New Features

•Several updates on the Chinese documentation.

•Added missing SCAN...ENDSCAN documentation (#1548).

•Added missing available constants for DBOrderInfo() function topic (#1565).

•Fixed incorrect text in documentation about the -memvar option (#1621)

 

Changes in 2.20.0.3

Compiler

Bug fixes

•Fixed problem with the USE command with an AGAIN clause in the FoxPro dialect (#235).

•Fixed problem with calling typed array constructors with named parameters when compiling with the /namedargs compiler option enabled (#1430).

•Fixed inconsistency with the INSTANCE keyword and the use inside the class (#1432).

•Fixed problem with the REPLACE UDC that could prevent the use of a variable named "replace" (#1443).

•Fixed problem with the /vo9 (handle missing RETURN statements) compiler option with ACCESSes in PARTIAL classes (#1450).

•Fixed problem with the Lexer recognizing line continuation characters inside a string in the FoxPro dialect (#1453).

•Fixed problem with the memvar pragma option (#1454).

•Fixed a problem with the /xpp compiler option. (#1243, #1458).

•Fixed a problem with accessing Hidden class members in a method from the class where the member was defined, when the object involved was untyped (#1335, #1457).

•Fixed an internal compiler error with a line of code containing a single comma (#1462).

•Fixed a problem with the USE command when the filename was specified as a bracketed string (#1468).

New Features

•You can now use the NULL() and DEFAULT() expression to initialize any variable with a default value. This is the equivalent of the default keyword in C#.

•We have added a new compiler option /modernsyntax (#1394). This disables certain legacy features:

o&& for line comments;

o* at the start of a line for a comment line;

oBracketed strings;

oParenthesized expression lists (making it easier to recognize tuples).

•Added support for IS NULL and IS NOT NULL pattern (#1422).

•Added support for file wide FIELD statements in the Harbour dialect (#1436).

Runtime

Bug fixes

•Fixed runtime error in Transform() with PTR argument (#1428).

•Fixed problem with several String runtime functions throwing a runtime error when passed a PSZ argument (#1429).

•Fixed problem with OrdKeyVal() and ADS/ADT files in the ADS RDD (#1434).

•Fixed incompatibilities with various xBase dialects with creating and using orders with long names (#1438).

•Fixed VO incompatibility in OrderKeyNo() with the ADS RDD when the setting Ax_SetExactKeyPos() is TRUE (#1444).

•Fixed a problem in the macro compiler with passing more than two arguments by reference (#1445).

•Fixed problem with DBSetIndex() seting the record pointer at eof (#1448).

•Fixed problem reading fields from OEM dbfs (#1449).

New Features

•Implemented the DBFMEMO driver (#604).

•Implemented the DBFBLOB driver (#605).

•Added missing SetColor() function overload with no parameters (#1440).

•This version includes the new XSharp.VFP.UI.DLL that is used by forms exported from Visual FoxPro with the VFP Exporter.

Visual Studio integration

Bug fixes

•Fixed a problem with "Jump to File" command in VS 2019 (#1146).

•Fixed problem with "Go to definition" not working for local function (#1415).

•Fixed problem with the Class navigation box showing the wrong current entry in some cases (#1426).

•Fixed problem with setting the "enable named arguments" project option (#1431).

•Fixed problem with the code generator for types in external assemblies not generating parameters for Indexed properties (#1442).

•Fixed problem with the VODBServer editor not saving access/assigns and other entities of the [DBSERVER] section in CAVOFED.TPL (#1452).

•Fixed problem with loading supplemental files provided in the cavowed.inf file for the VO Window Editor with absolute or relative paths (#1470).

•Fixed some indentation issues in the editor (#1541).

•Fixed a problem in the VS2022 Debugger when different DLLs contained the same namespace but different casing.

•Fixed an issue where the entity parser inside the editor did not correctly determine the end of an entity containing a local function or procedure.

•Fixed a problem where the entity parser inside the editor failed to handle a param token at the start of a line when the /memvars compiler option was NOT enabled.

New features

•We have added a menu entry to the Help menu for the Chinese version of the documentation.

VOXporter

Bug fixes

•Fixed problem with incorrectly converting attributes to string literals (#1404).

New Features

•It is now possible to define special TEXTBLOCK entities in the VO code in any module with name "VXP-TOP" or "{VOXP:TOP}", and VOXporter will automatically insert the contents of the text block in the beginning of the exported X# .prg file for the module. This is particularly helpful for specifying top level commands like #using statements (#1425).

VFPXporter

•This version of X# includes the VFP Exporter. This tool takes a Visual FoxPro project file and converts that into a Visual Studio solution

XIDE

•Added option when trying to debug a 32/64bit app in the wrong XIDE version, to automatically open the alternative version.

•Fixed coloring of several positional keywords in the editor.

•Improved editor support for TEXT...END TEXT.

•Added editor support for the NOT NULL code pattern.

•Added project support for the compiler options /namedargs, /initlocals, /modernsyntax and /allowoldstyleassignments.

•When pressing the SHIFT key on startup, the layout of the IDE is now reset to default positions (rather than saved on exit).

•Added menu command View->Save Current Layout.

•Fixed a problem with toggling case (CTR+U) of text selected in a column selection.

•Fixed several issues with incorrectly identifying a line with identifiers like PROC or FUNC as entity definitions.

Documentation

Bug fixes

•Fixed typo in the /namedargs compiler option topic.

New Features

•We have added several chapters about modifiers.

•We have added a (partially) translated help file in (Simplified) Chinese.

Changes in 2.19.0.2

Compiler

Bug fixes

•Now the compiler properly reports an error when duplicate field names are defined in a type (#1385)

•Fixed problem with defining multiple type constraints in a generic type (#1389)

•Fixed problem with global MEMVARs hiding local variables or parameters with the same name (#1294)

•Bogus compiler error messages with not found type (#1396)

•Fixed compiler crash with missing reference to XSharp.VFP in the FoxPro dialect (#1405)

•Fixed problem with /initlocals compiler option incorrectly also initializing class fields (#1408)

•Fixed a problem in the preprocessor where an extended match symbol would not properly match an expression that started with a string literal

New features

•We added support for dimensioning (FoxPro) class properties, such as in
 
       DIMENSION this.Field(10)
 

•We have added support for FOREACH AWAIT, like in the following example. (Works in .Net Core, .Net 5 and later)

 
 FOREACH AWAIT VAR data IN GenerateNumbersAsync(number)
           SELF:oListView1:Items:Add(data)
         NEXT

•We have added support for "Coalescing Member Access, such as in the following example where FirstName and LastName are both properties of the oPerson object:

 

 ? oPerson:(FirstName+" "+LastName)

 

•The WITH command now also recognizes the AS DataType clause

•XBase++ Class declarations now also allow “END CLASS” as closing token.

•Now the compiler reports an error when attempting to convert from Lambda Expression to usual (#1343)

•We have added support for TUPLE datatypes. This includes declaring local variables, parameters, return value etc.
We also support decomposition of a tuple return value into multiple locals. See the TUPLE help topic for more information.

Runtime

Bug fixes

•Fixed problem calling DoEvents() from the macro compiler (#872 )

•Fixed problem with __Mem2StringRaw() (undocumented) function (#1302)

•Fixed problem opening DBFCDX index file with incorrect collation information in the header #1360

•Fixed problem with OrdSetFocus() resetting the current order when called without arguments (#1362)

•Fixed problems with some index files after a DBPack() (#1367)

•Fixed problem with Deleted() returning TRUE on a table with all records deleted (#1370)

•Fixed problem with opening and writing to a file with FWrite() etc functions when opened in exclusive and write only mode (#1382)

•Fixed several problems (VO incompatibilities) with the SplitPath() function (#1384)

•Now when there is no codepage found in a dbf header, then the DOS codepage from the RuntimeState is used and no longer the hardcoded codepage 437 (#1386)

•Replaced the Dictionary<,> class used in some areas of the runtime with ConcurrentDictionary<,> to avoid issues in multi threaded apps (#1391)

•Fixed problem with NoIVarget when using IDynamicProperties (FoxPro dialect) (#1401)

•Fixed problem with Hex2C() giving different results with lower case letters than with upper case.
Note that this bug existed also in VO, so now the behavior of Hex2C() with lower case hex letters in X# with is different to VO (#1402)

•Accessing properties on a closed DbServer object that was opened with the Advantage RDD could cause problems in the debugger. The DbServer class now returns empty values when the server is closed.

New features

•Implemented CREATE CURSOR command [FoxPro] (#247). Also implemented CREATE TABLE and ALTER TABLE (FoxPro dialect)

•Implemented INSERT INTO commands (FoxPro dialect for inserting variables from values, arrays, objects and memory variables. INSERT INTO from a SQL query does not work yet.  (FoxPro dialect)

•Implemented new FoxPro-compatible version of Str() function in XSharp.VFP (#386)

•Now an error is thrown when opening an index file fails (#1358)

•Added AscA() function and made Asc() dependent on the SetAnsi() setting in the runtime (#1376)

Header files

Bug fixes

•Implemented several missing commands (#1407)

•Fixed typo in the SET DECIMALS TO command (#1406)

•Added missing clauses NAME and MEMVAR for the GATHER command (FoxPro) (#1409)

•Updated several commands to make some tokens optional and more compatible to various dialects (#1410, #1412)

•Fixed various incompatibilities with COMMIT command in various dialects (#1411)

Visual Studio Integration

Bug fixes

•Fixed problem with looking up public static field in type referenced by static using (#1307)

•Fixed intellisense problem with locals defined inside block statements (#1345)

•Fixed problem with intellisense incorrectly resolving type specified in code with full name to another from the usings list (#1363)

•Fixed problem with member completion incorrectly showing static methods after typing a colon (#1379)

•Fixed editor freezing with specific code (#1380)

•Fixed problem with Class Navigation bar not showing the method name in certain cases (#1381)

New features

•Added support for IEnumerable and DataTable Debugger visualizers (#1373).
Please note that when browsing X# arrays the results in the visualizer are really ugly because the visualizer ignores attributes to hide properties and fields for our USUAL class.

•Adjusted the Globals, Workareas etc debugger windows to respect the global theme selected in VS (#1375). Also added status panel to the Workarea window, so you can see the workarea status or field names/values

•Added intellisense support for locals declared with USING VAR or USING (LOCAL) IMPLIED (#1390)

•Now the intellisense database uses an SQLite package that has ARM support, so the it will work also on a Mac and other platforms (#1397)

VOXporter

Fixes

•Fixed problem with VOXporter incorrectly modifying previously commented code with {VOXP:UNC} tags (#1404)

Documentation

Bug Fixes

•The documentation of functions in the runtime help was describing functions incorrectly.
For example the topic title for the "Left" function was "Functions.Left Method" This has been changed to "Left Function"

•The "SingleLineEdit" class in the documentation was called "Real4LineEdit". This has been fixed.

New Features

•We have added additional documentation to the X# Programming guide about several subjects.

Changes in 2.18.0.4

Compiler

Bug fixes

•Fixed some preprocessor issues with XBase++ related commands (#1213, #1288, #1337)

•Fixed problem with implicit access to static class members (XBase++ dialect) (#1215)

•Fixed a parser error with the DIMENSION command (VFP dialect) (#1267)

•Fixed preprocessor problem with UDCs in code spanning in multiple lines (#1298)

•Now each "unused variable" warning is reported at the exact location of a variable definition, instread of always at the first one (#1310)

•Fixed bogus "unreachable code" warning in the SET RELATION command (#1312)

•Fixed a problem in generating XML documentation for the compiler generated <Module>.$AppInit and <Module>.$AppExit methods (#1316)

•Fixed problem with accessing hidden fields of another object (XBase++ dialect) (#1335)

•Fixed problem with calling parent methods with an explicit class indication (Xbase++ dialect) (#1338)

•Fixed problem with incorrectly calling function twice, in code like "SLen(c := SomeFunction())" (#1339)

•Fixed problem with parent Сlass methods not being visible in derived classes (Xbase++ dialect) (#1349)

•Fixed problem with ::new() not working properly in class methods (Xbase++ dialect) (#1350)

•Fixed an exception when an error occurred for a token that was defined in a header file

•Fixed a compiler error when returning super:Init() from a XBase++ method (#1357)

•Fixed a problem with STATIC DEFINEs in same named .prg files (#1361)

New features

•Introduced warning for not specifying the OUT keyword for OUT parameters (#1295)

•The parser rules for method and constructor calls without parameters have been updated. This may result in a bit faster compilation.

•SLen() is no longer "inlined" by the compiler. If you reference XSharp.Core in your app, SLen() now gets resolved to the SLen() function inside X# Core.
If you compile without X# runtime, or compile against the Vulcan Runtime you now need to add a SLen() function to your code.
This is the code inside X# Core that you can use as a template
FUNCTION SLen(cString AS STRING) AS DWORD
  LOCAL len := 0 AS DWORD
  IF cString != NULL
     len := (DWORD) cString:Length
  ENDIF
  RETURN len

•Added support for preprocessor commands #ycommand and #ytranslate that are also supported by Harbour. They work the same as #xcommand and #xtranslate, but the tokens are compared in case sensitive mode (#1314)

•Code generation for some of the Xbase++ specific features has changed.

•We have added several more UDCs with the IN <cursor> clause

•We have added UDC support for the FoxPro CAST expression

•Several more SET commands now also support the & operator

•The compiler now supports "Late bound names" in more locations, such as in the REPLACE command, With command etc. This now compiles without problems:

cVar := "FirstName"
WITH oCustomer
  .&cVar := "John"
END WITH
and this too
 
cVar := "FirstName"
REPLACE &cVar with "John"

Runtime

Bug fixes

•Fixed problem with incorrectly closing dbf file before relations are cleared (#1237)

•Fixed incorrect index scope visibility immediately after file creation (#1238)

•Fixed problem in FFirst()/FNext() not finding all files specified by filter (#1315)

•Fixed problem with DBSetIndex()/VoDbOrdListAdd() always reseting the controlling order to 1 (#1341)

•Fixed problem with updating index keys in the DBFCDX driver when the key expression was of type DATE.

•Fixed a problem when Str() and StrZero() had a built-in maximum string length of 30.(#1352)

•The RegisteredRDD Class now uses a ConcurrentDictionary.

•Fixed a bug in the RDD TransRec() method when a field is missing in the target table (#1372)

•Fixed a problem in the Advantage RDD to prevent ADS functions from being called when the table is closed

•Fixed a problem in the Advantage RDD that could occur when an field with an incorrect name was read

•Fixed a problem in the CurDir() function when the current directory is a UNCPath (\\Server\Share\SomeDir) (#1378)

New features

•Added support for accessing indexers in the USUAL type (#1296 )

•We have added a DbCurrency type that is returned from the RDD when a currency field is read.

•Implemented the TEXT TO FILE command (#1304)

•Now the RDD reports an error (dialog) when tagname > maximum length when creating an index order (#1305)

•Added a function _CreateInstance() that accepts a System.Type parameter

•The late binding code now detects from where Send(), IVarGet() and IVarPut() are called and allow access to private/hidden fields when the calling code is of the same type as the type where the class members were declared. This is used in some of the XBase++ related changes.

•The classes in the XBase++ have been restructured a bit.

•The mapping of several DBF / Workarea / Cursor related UDCs has been changed to be more FoxPro compatible.

•We have added runtime support for the FoxPro CAST expression

•We have done some small code optimizations w.r.t. dictionaries(#1371)

•Several DbServer properties no longer call into the RDD when the server is closed, but return blank values instead.

Typed SDK classes

•Added a DbServer:Append() overload without parametrs (#1320)

•Added missing DataServer:LockcurrentRecord() method (#1321)

•Fixed runtime error when creating a DataWindow with a ShellWindow as owner (#1324)

•Changed DataWindow:Show() method to CLIPPER for compatibility with existing code (#1325)

•Fixed exception when using a ComboBox on a VO Window (#1328)

•Fixed error when opening a datawindow with an assigned server (#1332)

•Fixed runtime error when instantiating a DBServer object with an untyped FileSpec object as first argument (#1348)

•Fixed problem with displaying items in Comboboxes and Listboxes (#1347)

•Several DbServer properties no longer call into the RDD when the server is closed, but return blank values instead.

Visual Studio Integration

Bug fixes

•Fixed problem with the "allow dot" setting in the project file (#1192)

•Several macros such as $CALLSTACK were not returning values in expected format. This has been fixed (#1236)

•Fixed build problem when there is a block comment in the first line of form.prg (#1334)

•Fixed probelm with block commenting a code snippet in a single line (#1336)

•Fixed failing project build when the project file contains a property <GenerateAssemblyInfo>True</GenerateAssemblyInfo> (#1344)

•Fixed a problem in the Parser that was causing errors parsing DebuggerDisplay attributes in the expression evaluator.

•The new debugger windows were not following the current windows theme. This is now partially fixed. (#1375)

VO Compatible Editors

•Fixed design time display issue with CheckBox and RadioButton captions with specific fonts in the VOWED (#796)

•Fixed problem with the VOWED editor changing all existing classes in the prg to PARTIAL (#814)

•Fixed problem with incorrectly adding constructor code to instantiate the DataBrowser in the VOWED, even when there are no (non-deleted) data columns (#1365)

•Fixed several problems in the VOMED with menu item define names in source code and resource files (#1374)

VOXporter

New features

•Introduced options (inline in existing code) to comment, uncomment and delete lines from the original VO code (#1303)

- {VOXP:COM} // comment out line

- {VOXP:UNC} // uncomment line

- {VOXP:DEL} and // {VOXP:REM} // remove line

Installer

New features

•The installer now detects if the required Visual Studio components "Core Editor" and ".Net Desktop Development" are installed.
When it finds one or more VS installations but none of these installations has both the required components then a warning is shown.

Changes in 2.17.0.3

Compiler

Bug fixes

•Fixed several incompatibilities with XBase++ regarding using class members (#1215) UNCONFIRMED

•Fixed /vo3 option not working correctly in XBase++ dialect. Also added support for modifiers final, introduce and override (#1244)

•Fixed problem with using the NEW modifier on class fields (#1246)

•Fixed several preprocessor issues with XPP dialect UDCs (#1247, #1250)

•Fixed VO incompatibility with special handling of INSTANCE fields in methods and properties (#1253)

•Fixed problem with the debugger erratically stepping to incorrect lines (#1254, #1264)

•Fixed problem with showing the wrong error line number in some cases with nested statements (#1268)

•Fixed problem where a DO CASE statement without CASE lines was producing an internal error in the compiler (#1281)

•Fixed a couple preprocessor issues (#1284, #1289)

•Fixed missing compiler error on calling with SUPER a method that does not exist, when late binding is enabled (#1285)

•Fixed a Failed to emit Module error with CONST class field missing value assignment (#1293)

•Fixed a problem with repeated match markers (such as in the SET INDEX TO command) in the preprocessor.

•Fixed a problem that an property definition with an explicit interface prefix could lead to a compiler crash when the interface was "unknown" at compile time and/or the property name was not "Item" (#1306)

New features

•Added support for "classic" INIT PROCEDURE and EXIT PROCEDURE (#1290)

•Added warnings when statement list inside case blocks, if blocks and other blocks are empty. To suppress the warning you can add a NOP statement in your code.

•We have made some changes to the lexer and parser in the compiler. This may result in a bit smaller memory footprint and faster compilation speed for code with many nested blocks.

Runtime

Bug fixes

•Fixed several problems (incompatibilities with VO) in CToD() (#1275)

•Added support for 3rd parameter in AAdd() for specifying where to insert the new element (#1287)

•The Default() function now no longer updates usuals that have a value of NULL_OBJECT to be compatible with Visual Objects.(#1119)

•We have added support for parameters for the AdsSQLServer class (#1282)

Visual Studio integration

New Features

•We have added debugger pane windows for the following items:

oGlobal variables

oDynamic memory variables (Privates and Publics)

oWorkareas

oSettings

•You can open these windows from the Debug/XSharp menu during debugging. There is also a special "X# Debugger Toolbar" which is also only shown during debugging.

•These windows will only show information when the app being debugged uses the X# runtime (so they will not work in combination with the Vulcan Runtime).
If you are debugging an application written in another language that uses the X# runtime then these windows will also show information.
We have planned to add more features to these windows in future builds, like the properties of the current selected area and the field/values in the current selected workarea

•We have added support for "FileCodeModel" for X# files. This is used by the WPF designer and XAML editor.
This now also fixes the Goto definition in the XAML editor (#1026)

•Several properties of X# projects are now cached. This should result in slightly faster performance.

•We have added support for "Goto Definition" for User Defined commands. For example choosing "Goto definition" on the USE keyword from the USE command will bring you to its definition in our standard header file.

Bug fixes

•Fixed member completion issue with Type[,] arrays (#980)

•Fixed missing member completion in class inside namespace when same named class exists without namespace (#1204)

•Fixed an auto indent problem when an entity has an attribute in the precessing line (#1210)

•Fixed intellisense problems with static members in some cases (#1212)

•Fixed some intellisense issues with code or declarations spanning in multiple lines (#1221, #1260)

•Fixed intellisense problem with nested classes inside a namespace (#1222)

•Fixed incorrect resolving of VAR local type, when using a type cast (#1224)

•Fixed several problems with collapsing/expanding code in the editor (#1233)

•Fixed showing of bogus member completion list with unknown types (#1255)

•Fixed some problems with auto typing text with Ctrl + Space (complete Word) (#1256)

•Fixed coloring of Text .. EndText statements (#1257)

•Fixed several issues with tooltip hints with generic types (#1258, #1259, #1273)

•Fixed problem with delegate signature not showing in intellisense tooltips (#1265)

•Fixed invalid coloring of code with multiline comments (#1269)

•Fixed invalid entries in member completion after typing "self." (#1270)

•Fixed problem with calling the disassembler when path specified (in option X# Custom Editors\Other Editors\Disassembler) with spaces (#1271)

•Fixed editor coloring completely stopping when using some UDC calls (#1272)

•Fixed problem with hint not showing on CONSTANT locals in FOR statements (#1274)

•Fixed auto indent problem when code contains a LOOP or EXIT keyword (#1278)

•Fixed an exception in the editor when typing a parenthesis under specific circumstances (#1279)

•Fixed problem with incorrectly trying to open in design mode files with filenames starting with an opening bracket (#1292 )

•The "XSharp Website" menu option inside VS was broken (#1297)

•Fixed problem with the Match Identical Identifiers functionality that could slow down Visual Studio

•Fixed a VS lock up that could happen when a file was opened during debugging.

•Parameter tips for classes with a static constructor and a normal constructor were not processed correctly. This has been fixed.

•When a project was opened where the dependency between a dependent item (like a .resx file or a .designer.prg file) and its parent was missing, then an exception could occur, which prevented the project from opening. This has been fixed.

•When 2 compiler errors occurred on the same line with the same error code they were sometimes shown in the VS output window but not in the Error List. This has been fixed (#1308)

VOXporter

New Features

•Added support for special tags {VOXP:COM}, {VOXP:UNC} and {VOXP:DEL} / {VOXP:REM} to comment out, uncomment and remove lines from the original VO code (#1303)

Changes in 2.16.0.5

Compiler

New Features Xbase++ dialect

We have made several changes in the way how Xbase++ class definitions are generated. Please check your code extensively with this new build !

•We now generate a class function for all classes. This returns the same object as the ClassObject() method for Xbase++ classes.
This class function is generated, regardless of the /xpp1 compiler option.
The Class function depends on the function __GetXppClassObject and the XSharp.XPP.StaticClassObject class that both can be found in the XSharp.XPP assembly(#1235).
From the Class function you can access class variables and class methods.

•In Xbase++ you can have fields (VAR) and properties (ACCESS / ASSIGN METHOD) with the same name, even with same visibility. Previously this was not supported.
The compiler now automatically makes the field protected (or private for FINAL classes) and marks it with the [IsInstance] attribute.
Inside the code of the class the compiler will now resolve the name to the field. In code outside of the class the compiler will resolve the name to the property.

•For derived classes the compiler now automatically generates a property with the name of the parentclass, that is declared as the parent class and returns the equivalent to SUPER.

•We have fixed an issue with the FINAL, INTRODUCE and OVERRIDE keywords for Xbase++ methods (#1244)

•We have fixed some issues with accessing static class members in the XBase++ dialect (#1215)

•You can now use the "::" prefix to access class variables and class methods inside class methods.

•When a class is declared as subclass from another class then the compiler generates a (typed) property in the subclass to access the parent class, like Xbase++ does. This property returns the value "super".

•We are now supporting the READONLY clause for Vars and Class Vars. This means that the variable must be assigned in the Init() method (instance variables) or InitClass() method (Class vars)

 

New Features other dialects

•Inside Visual Objects you could declare fields with the INSTANCE keyword and add ACCESS/ASSIGN methods with the same name as the INSTANCE field.
In previous builds of X# this was not supported.
The compiler now handles this correctly and resolves the name to the field in code inside methods/properties of the class and resolves the name to the property in code outside of the class.

•The PPO file now contains the original white space from user defined commands and translates.

Bug fixes

•Fixed some method overload resolution issues in the VO dialect (#1211).

•Fixed internal compiler error (insufficient stack) with huge DO CASE statements and huge IF ELSEIF statements (#1214).

•Fixed a problem with the Interpolated/Extended string syntax (#1218).

•Fixed some issues with incorrectly allowing accessing static class members with the colon operator or instance members with the dot operator (#1219,#1220).

•Fixed Incorrect visibility of MEMVARs created with MemVarPut() (#1223).

•Fixed problem with _DLL FUNCTION with name in Quotes not working correctly (#1225).

•If the preprocessor generated date and/or datetime literals, then these were not recognized. This has been fixed (#1232).

•Fixed a problem with the preprocessor matching of the last optional token (#1241)

•Fixed a problem with recognizing the ENDSEQUENCE keyword in the Xbase++ dialect (#1242).

•Using a default parameter value of NIL is now only supported for parameters of type USUAL. Using NIL for other parameter types will generate a (new) warning XS9117 .
Also assigning NIL to a Symbol or using NIL as parameter to a function/method call that expects a SYMBOL will now also generate that warning (#1231).

•Fixed a problem in the preprocessor where two adjacent tokens were not merged into one token in the result stream. (#1247).

•Fixed a problem in the preprocessor where the preprocessor was not detecting an optional element when the element started with a Left parenthesis (#1250)

•Fixed a problem with interpolated strings that contained literal double quotes like in i"SomeText""{iNum}"" "

•Fixed a problem that was introduced in an earlier build of 2.16 with local functions / procedures.

•A warning generated at parse time could lead to another warning about a preprocessor define even when that is not needed. This has been fixed.

•Fixed issue with default parameter values for parameters declared as "a := NIL,b := NIL as USUAL" introduced in an earlier build of  2.16

•Fixed issue with erratic debugger behavior introduced in an earlier build of  2.16.

•When you are referring to a type in an external assembly that depends on another external assembly, but you did not have a reference to that other external assembly, then compilation could fail without proper explanation. Now we are producing the normal error that you need to add a reference to that other assembly.

•Omitting the type for a parameter for a function or method  that does not have the CLIPPER calling convention is allowed. These parameters are assumed to be of type USUAL.
This now produces a new warning XS9118.

Breaking changes

If you are using our parser to parse source code, please check your code. We have made some changes to the language definition for the handling of if ... else statements as well as for the case statements (a new condBlock rule that is shared by both rules). This removes some recursion in the language. Also some of the Xbase++ specific rules have been changed. Please check the language definition online

Runtime

New Features

•Added the DOY() function.

•Addeding missing ADS_LONG and ADS_LONGLONG defines.

•Improved the speed of CDX skip operations on network drives (#1165).

Bug fixes

•Fixed a problem with DbSetRelation() and RLock() (#1226).

•Adjusted implicit conversion from NULL_PSZ to string to now return NULL instead of an empty string.

•Some initialization code is now moved from _INIT procedures to the static constructor of the SQLConnection Class, in order to make it easier to use this class from non-X# apps.

•Fixed an issue with the visibility of dynamic memory variables that were created with the MemVarPut function (#1223).

•Fixed a problem with the DbServer class in exclusive mode (#1230).

•Implicit conversions from NULL_PSZ to string were returning an empty string and not NULL (#1234).

•Fixed a problem in the CTOD() function when the day, month or year were prefixed with spaces.

•Fixed an issue with OrderListAdd() in the ADS RDD. When the index is already open, then the RDD no longer returns an error.

•Fixed an issue with MemRealloc where the second call on the same pointer would return NULL_PTR (#1248).

VOSDK

•Global arrays in the SDK classes are now initialized from the class constructor of the SQLConnection class to fix problems when the main app does not include a link to the SQL Classes assembly.

Visual Studio integration

Debugger

•The debugger expression evaluator now also evaluates late bound properties and fields (if that compiler option is enabled inside your project).
If this causes negative side effects then you can disable that in the "Tools/Options Debugging/X# Debugger options screen".

•The debugger expression evaluator now is initialized with the compiler options from your main application (if that application is an X# project).
The settings on the Debugger Options dialog are now only used when debugging DLLs that are loaded by a non X# startup project.

•The debugger expression evaluator now always accepts a '.' character for instance fields, properties and methods, regardless of the setting in the project options.
This is needed because several windows in the VS debugger automatically insert '.' characters when adding expressions to the watch window or when changing values for properties or fields.

New Features

•Added support for importing Indexes in the DbServer editor.

•The X# project system now remembers which Windows were opened in the Windows editor in design mode and reopens them correctly when a solution is reopened.

•We have added templates for a Harbour console application and Harbour class library.

•We have added item templates for FoxPro syntax classes and Xbase++ syntax classes.

•The Class templates for the FoxPro and XBase++ dialect now include a class definition in that dialect.

•We have improved the support for PPO files in the VS Editor.

•We have updated some of the project templates.

Bug fixes

•Fixed a problem with incorrectly showing member list in the editor for the ":=" operator (#1061).

•Fixed VOMED generation of menu item DEFINE names that were different to the ones generated by VO (#1208).

•Fixed VOWED incorrect order of generated lines of code in some cases (#1217).

•Switched back to our own version of Mono.Cecil to avoid issues on computers that have the Xamarin (MAUI) workload in Visual Studio.

•Fixed a problem opening a form in the Form Designer that contains fields that are initialized with a function call (#1251).

•Windows that were in [Design] mode when a solution is closed, are now properly opened in [Design] mode when the solution is reopened.

Changes in 2.15.0.3

Compiler

New Features

•Implemented the STACKALLOC syntax for allocating a block of memory on the stack (instead of the heap) (#1084)

•Added ASYNC support to XBase++ methods (#1183)

Bug fixes

•Fixed missing compiler error in a few specific cases when using the dot for accessing instance members, when /allowdot is disabled (#1109)

•Fixed some issues with passing parameters by reference (#1166)

•Fixed some issues with interpolated strings (#1184)

•Fixed a problem with the macro compiler not detecting an error with incorrectly accessing static/instance members (#1186)

•Fixed incorrect line number reported for error messages on ELSEIF and UNTIL statements (#1187)

•Fixed problem with using an iVar named "Value" inside a property setter, when option /cs is enabled (#1189)

•Fixed incorrect file/line info reported in error message when the Start() function is missing (#1190)

•Fixed bogus warning about ambiguous methods in some cases (#1191)

•Fixed a preprocessor problem with nested square brackets (in SUM and REPLACE commands) (#1194)

•Fixed incorrect method overload resolution in some cases in the VO dialect (#1195)

•Fixed incorrect ambiguous call error with OBJECT/IntPtr parameters (#1197)

•Fixed erratic debugging while stepping over code in some cases (#1200, #1202)

•Fixed a problem where a missing "end keyword", such as ENDIF, NEXT, ENDDO was not reported when the code between the start and end contained a compiler warning (#1203)

•Fixed a problem in the build system where sometimes an error message about an incorrect "RuntimeIdentifier" was shown

Runtime

Bug fixes

•Fixed runtime error in DBSort() (#1196)

•Fixed error in the ConvertFromCodePageToCodePage function

•A change in the startup code for the XSharp.RuntimeState could lead to incorrect codepages

Visual Studio integration

New Features

•Added VS option for the WED to manually adjust the x/y positions/sizes in the generated resource with multipliers (#1199)

•Added new options page to control where the editor looks for identifiers on the Complete Word (Ctrl+Space) command.

•A lot of improvements to the debugger expression evaluator (#1050). Please note that this debugger expression evaluator is only available in Visual Studio 2019 and later

•Added a debugger options page that controls how expression are parsed by the new debugger expression evaluator.
You can also change the setting here that disallows editing while debugging.

•We have added context help to the Visual Studio source code editor. When you press F1 on a symbol then we inspect the symbol. If it comes from X# then the relevant page in the help file is opened. When it comes from Microsoft then we open the relevant page from the Microsoft Documentation online.
In a next build we will probably add an option for 3rd parties to register their help collections too.

•When a keyword is selected in the editor that is part of a block, such as CASE, OTHERWISE, ELSE, ELSEIF then the editor will now highlight all keywords from that block.

•The Jump Keywords EXIT and LOOP are now also highlighted as part of the repeat block that they belong to.

•When a RETURN keyword is selected in the editor, then the matching "Entity" keyword, such as FUNCTION, METHOD will be highlighted too.

•Added a warning to the Application project options page, when switching the target framework.

Bug fixes

•Fixed previously broken automatic case synchronization, when using the cursor keys to move to a different line in the editor (#722)

•Fixed some issues with using Control+Space for code completion (#1044, #1140)

•Fixed an intellisense problem with typing ":" in some cases (#1061)

•Fixed parameter tooltips in a multiline expressions (method/function calls) (#1135)

•Fixed problem with Format Document and the PUBLIC modifier (#1137)

•Fixed a problem with Go to definition not working correctly with multiple partial classes defined in the same file (#1141)

•Fixed some issues with auto-indenting (#1142, #1143)

•Fixed a problem with not showing values for identifiers in the beginning of a new line when debugging (#1157)

•Fixed Intellisense problem with LOGICs in some cases (#1185)

•Fixed an issue where the completionlist could contain methods that were not visible from the spot where the completionlist was shown (#1188)

•Fixed an issue with the display of nested types in the editor (#1198)

•Cleaned up several X# project templates, fixing problems with incorrect placement of Debug/Output folders (#1201)

•Undoing a case synchronization in the VS editor was not working, because the editor would immediately synchronize the case again (#1205)

•Rebuilding the intellisense database no longer restarts Visual Studio (#1206)

•Now the VO Menu Editor uses the same menu item DEFINE values, as those used in the original VO app (re-porting of the app is necessary for this to work) (#1207)

•A Change to our project system and language service could lead to broken "Find in Files" functionality in some versions of Visual Studio.  This has been fixed.

•Fixed an issue where goto definition was not working for protected or private members

•Fixed an issue where for certain files the Dropdown combo boxes on top of the editor were not correctly synchronized.

Documentation

Changes

•Some methods in the typed SDK were documented as Function. They are now properly documented as Method

•Property Lists and Method lists for classes now include references to methods that are inherited from parent classes. Methods that are inherited from .Net classes, such as ToString() from System.Object are NOT included.

Changes in 2.14.0.2, 3 & 4

Visual Studio Integration

Bug fixes

•Fixed an exception in the X# Editor when opening a PRG file in VS 2017

•Selecting a member from a completion list with the Enter key on a line immediately after an entry that has an XML comment could lead to extra triple slash (///) characters to be inserted in the editor

•The triple slash command to insert XML comments was not working. This has been fixed.

•Fixed a problem with entity separators not shown on the right line for entities with leading XML comments

•Fixed a peek definition problem with types in source code that do not have a constructor

•Fixed a problem with the Implement Interface action when the keyword case was not upper case

•Fixed a problem that the keyword case was prematurely synchronized in the current line.

•Fixed a problem with indenting after keywords such as IF, DO WHILE etc

•Fixed a problem with selecting words at the end of a line when debugging

•Fixed a problem where Format Document could lock up VS

•Fixed a problem that accessors such as GET and SET were not indented inside the property block

•Fixed a problem that Format Document was not working for some documents

•Changed the priority of the background scanner that is responsible for keyword colorization and derived tasks inside VS.

Changes in 2.14.0.1

Compiler

Bug fixes

•Fixed a problem with date literals resulting in a message about an unknown alias "gloal" (#1178)

•Fixed a problem that leading 0 characters in AssemblyFileVersion and AssemblyInformationalVersion were lost. If the attribute does not have the wildcard '*' then these leading zeros are preserved (#1179)

Runtime

Bug fixes

•The runtime DLLs for 2.14.0.0 were marked with the TargetFramework Attribute. This caused problems. The attribute is no longer set on the runtime DLLs (#1177)

Changes in 2.14.0.0

Compiler

Bug fixes

•Fixed a problem resolving methods when a type  and a local have the same name (#922)

•Improved XML doc messages for methods implicitly generated by the compiler (INITs, implicit constructors) (#1128)

•Fixed an internal compiler error with DELEGATEs with default parameter values (#1129)

•Fixed a problem with incorrect calculation of the memory address offset when obtaining a pointer to a structure element (#1132)

•Fixed problematic behavior of #pragma warning directive unintentionally enabling/.disabling other warnings (#1133)

•Fixed a problem with marking the complete current executing line of code while debugging (#1136)

•Fixed incompatible to VO behavior with value initialization when declaring global MEMVAR (#1144)

•Fixed problem with compiler rule for DO not recognizing the "&" operator (#1147 )

•Fixed inconsistent behavior of the ^ operator regarding narrowing conversion warnings (#1160)

•Fixed several issues with CLOSE and INDEX UDC commands (#1162, #1163)

•Fixed incorrect error line reported for error XS0161: not all code paths return a value (#1164)

•Fixed bogus filename reported in error message when the Start() function is missing (#1167)

•The PDB information for a command defined in a UDC now highlights the entire row and not just the first keyword

•Fixed a problem in the CLOSE ALL and CLOSE DATABASES UDC.

Runtime

New Features

•Added 2 new values to the DbNotificationType enum: BeforeRecordDeleted and BeforeRecordRecalled. Also added AfterRecordDeleted and AfterRecordRecalled which are aliases for the already existent RecordDeleted and RecordRecalled (#1174)

Bug fixes

•Added/updated several defines in the Win32API SDK library (#696)

•Fixed a problem with "SkipUnique" not working correctly (#1117)

•Fixed an RDD scope problem when the bottom scope is larger than the highest available key value (#1121)

•Fixed signature of LookupAccountSid() function in the Win32API SDK library (#1125)

•Improved exception error message when attempting to use functions like Trim() (which alter the key string length) in index expressions (#1148)

•Fixed a Macro Compiler runtime exception when there is an assignment in an IIF statement (#1149)

•Fixed a problem with resolving the correct overloaded method in late bound calls (#1158)

•Fixed a problem with parametrized SQLExec() statements in the FoxPro Dialect

•Fixed a problem in the Days() function where the incorrect number of seconds in a day was used.

•Fixed a problem in the Advantage RDD when a FieldGet returned fields with trailing 0 characters. These are now replaced with a space.

•Fixed a problem with DBI_LUPDATE in the ADS RDDs

•Fixed the Debugger display of the USUAL type.

Visual Studio integration

New Features

•Now using the "Reference Manager" instead of the "Add Reference Dialog Box" for adding References (#21, #1005)

•Added an option to the Solution Explorer context menu to split a Windows Form in a form.prg and form.designer.prg (#33)

•We have added an options page to the Tools / Options TextEditor/X# settings that allows you to enable/disable certain features in the X# source code editor, such as "Highlight Word", "Brace Matching" etc. The option to backup the source code for the Windows Forms Editor has been moved from the Texteditor options page to the Custom Editor options page. Search for 'Backup" in the Tools/Options dialog to find the setting.

•Tooltips for all source code items now contain the Location (file name and the line/column).

•We have added "search keywords" to all of our option page. you may be able to find a page by typing the keyword that you are looking for in the search control.

Bug fixes

•Fixed  a problem renaming files when a solution is under SCC with Team Foundation Server (#49)

•The WinForms designer now ignores differences in the namespaces specified in the form.prg and designer.prg files (the one from form.prg is used) (#464)

•Fixed incorrect mouse tooltip for a class in some cases (#871)

•Fixed a code completion issue on enum types with extension methods (#1027)

•Fixed some intellisense problems with enums (#1064)

•Fixed a problem with Nuget packages in VS 2022 causing first attempts to build projects to fail (#1114)

•Fixed a formatting problem in XML documentation tooltips (#1127)

•Fixed a problem with including bogus extra static members in the code completion list in the editor (#1130)

•Fixed problem with Extension methods not included in Goto Definition, Peek definition, QuickInfo tips and Parameter Tips (#1131)

•Fixed a problem in determining the correct parameter number for parameter tips when a compiler pseudo function such as IIF() was used inside the parameter list (#1134)

•Fixed a problem with selecting words with mouse double-click in the editor with underscores while debugging (#1138)

•Fixed a problem with evaluating values of identifiers with underscores in their names while debugging (#1139)

•Fixed identifier highlighting causing the VS Editor to hang in certain situations (#1145)

•Fixed indenting of generated event handler methods in the WinForms designer (#1152)

•Fixed a problem with the WinForms designer duplicating fields when adding new controls (#1154)

•Fixed a problem with the WinForms designer removing #region directives (#1155)

•Fixed a problem with the WinForms designer removing PROPERTY declarations (#1156)

•Fixed a problem that the type lookup for locals was failing in some cases (#1168)

•Fixed a problem where the existence of extension methods in code was causing a problem filling the member list (#1170)

•Fixed a problem when completing the member completion list without selecting an item (#1171)

•Fixed a problem with showing member completion on types of static members of a class (#1172)

•Fixed a problem with the indentation after single line entities, such as GLOBAL, DEFINE, EXPORT etc. (#1173)

•Fixed a problem with parameter tips for extension methods (#1175)

•Fixed a problem with tooltips for namespaces and nested classes (#1176)

•Optional tokens in UDCs were not colored as Keyword in the source code editor

•Fixed a problem in the CodeDom provider that failed to load on a Build Server because of  a dependency to Microsoft.VisualStudio.Shell.Design version 15.0 when generating code for WPF projects.

Changes in 2.13.2.2

Compiler

Bug fixes

•Class members declared with only the INSTANCE modifier were generated as public. This has been changed to protected, just like in Visual Objects (#1115)

Runtime

Bug fixes

•IVarGetInfo() returned incorrect values for PROTECTED and INSTANCE members. This has been fixed.(#1116)

•The Default() function was changing usual variables initialized with NULL_OBJECT to the new value. This was not compatible with Visual Objects (#1119)

Visual Studio integration

New Features

•The Rebuild Intellisense Database menu option now asks for confirmation before restarting Visual Studio (#1120)

•The "Include Files" node in the solution explorer can now be hidden (Tools/ Options X# Custom Editors/Other Editors)

Bug fixes

•The type information for variables declared in a CATCH clause was not available. This has been fixed (#1118)

•Fixed several issues with parameter tips (#1098, #1065)

•Fixed a performance issue when the cursor was on a undeclared identifier in a "global" entity such as a function or procedure in VERY large projects

•The "Include Files" node could contain duplicate references when the source code for an #include statement contained relative paths, such as
#include "..\GlobalDefines.vh"

•Suppressed the expansion of the "Include Files" node in the Solution Explorer when a solution is opened.

•Single character words (like i, j, k) were not highlighted with the 'highlight word' feature

•The type 'ptr' was not marked in the keyword color in quickinfo tooltips

•The nameof, typeof and sizeof keywords were not synchronized in the keyword case

Changes in 2.13.2.1

Compiler

New Features

•The parser now recognizes AS <type> clause for PUBLIC and PRIVATE memory variable declarations but ignores these with a warning

•We have added support for AS <type> for locals declared with LPARAMETERS. The function/procedure is still clipper calling convention, but the local variable is of the declared type.

Bug fixes

•The PUBLIC and PRIVATE keywords are sometimes misinterpreted as memvar declarations when the /memvar compiler option is not even selected. We have added parser rules to prevent this from happening: when /memvar is not selected then PUBLIC and PRIVATE are only used as visibility modifiers

•Fix to an issue with selecting function and method overloads (#1096, #1101)

•Build 2.13.2.0 introduced a problem that could cause a big performance problem for VERY large source files. This has been fixed in 2.13.2.1.

 

Runtime

Bug fixes

•When the runtime cannot resolve a late bound call to an overloaded method it produces an error message that includes a list of all relevant overloads (#875, #1096).

•The .NULL. related behavior that was added for the FoxPro dialect was breaking existing code that involves usuals. In the FoxPro dialect DBNull.Value is now seen as .NULL. but in the other dialects as a NULL_OBJECT / NIL

•Several internal members of the PropertyContainer class in the VFP library are now public

Visual Studio integration

Bug fixes

•The lookup code for Peek definition, Goto definition etc. was filtering out instance methods and only returning static methods. This has been fixed (#1111, #1100)

•Several changes to fix issues with indentation while typing (#1094)

•Fixed several problems with parameter tips (#1098, #1066, #1110)

•A recent change to support the wizard that converts packages.config to package references has had a negative impact on nuget restore operations during builds inside Visual Studio. This was fixed. (#1113 and #1114)

•Fixed recognition of variables in lines such as CATCH, ELSEIF, FOR, FOREACH etc (#1118)

•Fixed recognition of types in the default namespace (#1122)

Changes in 2.13.1

Compiler

New Features

•The PUBLIC and PRIVATE statements in the FoxPro dialect now support inline assignments, such as in
PUBLIC MyVar := 42
Without initialization the value of the PUBLIC will be FALSE, with the exception of the variable with the name "FOXPRO" and "FOX". These will be initialized with TRUE in the FoxPro dialect

Bug fixes

•Fixed a problem with initialization of File Wide publics in the foxpro dialect

•Column numbers for error messages were not always correct for complex expressions. This has been fixed (#1088)

•Corrected an issue in the lexer where line numbers were incorrect when the source contains statements that span multiple lines (by using a semicolon as line continuation character) (#1105)

•Fixed a problem in the overload resolution when one or more overloads have a Nullable parameter(#1106), such as in
  class Dummy    
    method Test (param as usual) as int
     .
     method Test(param as Int? as int
     .
  end class

•Fixed a problem with the code generation for late bound method calls and/or array access in the FoxPro dialect with the /fox2 compiler compiler option ("compatible array handling") for variables of unknown type (#1108).
An expression such as          
 
  undefinedVariable.MemberName(1)
 
was interpreted as an array access but it could also be a method call.
The compiler now generates code that calls a runtime function that checks at runtime if "MemberName" is either a method or a property.
If it is a property then the runtime will assume that it is an array and access the first element.
Code with more than 2 parameters or with non-numeric parameters, such as
 
  undefinedVariable.DoSomething("somestring")
 
was not affected, since "somestring"  cannot be an array index.
TIP: We recommend however, to always declare variables and specify their type. This helps to find problems at compile time and will generate MUCH faster code.

 

Runtime

New Features

•Added functions to resolve method calls or array access at runtime  (#1108)

•Added GoTo record number functionality to the WorkareasWindow in the XSharp.RT.Debugger library

Visual Studio Integration

New Features

•Now the VS Project tree shows (in a special node) include files that are used by a project (#906).
This includes include files inside the project itself but also include files in the XSharp folder or Vulcan folder (when applicable).

•We are using the built-in images of Visual Studio in the project tree and on several other locations when possible.

•Our background parser inside VS is now paused during the built process to interfere less with the build.

•We have added a setting to the indentation options so you can control the indentation for class fields and properties separately from methods.
So you can choose to indent the fields and properties and to not indent the methods. This has also been added to the .editorconfig file

Bug Fixes

•Fixed problems with Peek Definition and Goto Definition

•When looking up Functions we were (accidentally) sometimes also including static methods in other classes.

•When parsing tokens for QuickInfo and Peek Definition then a method name would not be found if there was a space following the name and before the open parenthesis.

•Fixed a problem where project wide resources and settings (added from the project properties page) did not get the code behind file when saving

•Quick Info and Goto definition on a line that calls a constructor will now show / goto the first constructor of the type and no longer to the type declaration

•When the build process of a project was failing due to missing resources or other resource related problems, then the error list was not properly updated. This has been fixed (#1102)

•The XSharpDebugger.DLL was not installed properly into VS2017 and VS2019.

Changes in 2.13

Compiler

New Features

•We have implemented a new compiler option /allowoldstyleassignments, which allows using the "=" operator instead of ":=" for assignments.
This option is enabled by default in the VFP dialect and disabled by default in all other dialects.

•We have revised the behavior of the /vo4 and /vo11 command line options that are related to numeric conversions.
Before /vo4 only was related to conversions between integral numbers. It has now been extended to also include conversions between fractional numbers (such as float, real8, decimal and currency) and integral numbers.
In the original languages (VO, FoxPro) you can assign a fractional number to a variable with integral value without problems.
In .Net you can't do that but you will have to add a cast to the assignment:

LOCAL integerValue as INT
LOCAL floatValue := 1.5 as FLOAT
integerValue := floatValue         // no conversion: this will not compile in .Net without conversion
integerValue := (INT) floatValue   // explicit conversion: this does compile in .Net
? integerValue
 
If you enable the compiler option /vo4 then the assignment without the cast will also work.
The /vo4 compiler option adds an implicit conversion
In both cases the compiler will produce a warning:
warning XS9020: Narrowing conversion from 'float' to 'int' may lead to loss of data or overflow errors
The value of the integer integerValue above is controlled by the /vo11 compiler option:
By default in .Net conversions from a fractional value to an integer value will round towards zero, so the value will then be 1.
If you enable the compiler option /vo11 then the fractional number will be rounded to the nearest even integral value, so the value of integerValue in the example will be 2.
This is not new.
We have made a change in build 2.13, to make sure that this difference is no longer determined at runtime for the X# numeric types but at compile time.
In earlier builds this was handled inside conversion operators from the FLOAT and CURRENCY types in the runtime.
These classes choose the rounding method based on the /vo11 setting from the main program which is stored in the RuntimeState object.
However that could lead to unwanted side effects when an assembly was compiled with /vo11 but the main program was not.
This could happen for example with ReportPro or bBrowser.
If the author of such a library now chooses to compile with /vo11 then he can be certain that all these conversions in his code will follow rounding to zero or rounding to the nearest even integer, depending on his choice.

•The DebuggerDisplay attribute for Compile Time Codeblocks has changed. You now see the source code for compile time codeblocks in the debugger.

Bug fixes

•Fixed a code generation issue with ASYNC/AWAIT (#1049)

•Fixed an Internal compiler error with Evaluate() in CODEBLOCK in VFP dialect (#1043)

•Fixed an Internal compiler error with UDCs incorrectly inserted after an END FUNCTION statement

•Fixed a problem in the preprocessor with #region and #endregion in nested include files (#1046)

•Fixed some problems with evaluating DEFINEs based on the order they appear (#866, #1057)

•Fixed a compiler error with nested BEGIN SEQUENCE .. END SEQUENCE statements (#1055)

•Fixed some problems with codeblocks containing complex expressions (#1056)

•Fixed problem assigning function to delegate, when /undeclared+ is enabled (#1051)

•Fixed a bogus warning when defining a LOCAL FUNCTION in the Fox dialect (#1017)

•Fixed a problem with the Linq Operation Sum on FLOAT values (#965)

•Fixed a problem with using SELF in an anonymous method/lamda expression (#1058)

•Fixed an InvalidCastException when casting a Usual to a Enum defined as DWord (#1069)

•Fixed incorrect emitted code when calling AScan() with param nStart supplied and similar functions (#1062, #1063)

•Fixed a problem with resolving the correct one form overloads of the same function that span across different assemblies (#1079)

•Fixed unexpected behavior of the preprocessor with #translate for specific XBase++ code (#1073)

•Fixed a problem with unexpected behavior of "ARRAY OF" (#885)

•Fixed some issues with calling specific overloads of functions accepting an ARRAY as a first argument (#1074)

•Fixed a bogus XS0460 error when using the PUBLIC keyword on a method (#1072)

•Fixed incorrect behavior when enabling Named Arguments option (#1071)

•Fixed Access violation when calling a function/method with DECIMAL argument with default value (#1075)

•Fixed some issues with #xtranslate not recognizing the Regular match marker in the preprocessor. Also fixed an issue with recognizing the double colon (::) inside expression tokens in the preprocessor. (#1077)

•Fixed some issues with declaring arrays in the VFP dialect (#848)

 

Runtime

Bug fixes

•Fixed some incompatibilities with VO in the Mod() function

•Fixed an exception with Copy to array in the VFP dialect when dimensions do not match (#993)

•Fixed a seeking problem with SetDeleted(TRUE) and DESCEND order (#986)

•Fixed a problem with DataListView incorrectly showing (empty) deleted records with SetDeleted(TRUE) (#1009)

•Fixed problem with SetOrder() failing with SYMBOL argument (#1070)

•Reverted a previous incorrect change in the SDK in DBServer:FieldGetFormatted() (#1076)

•Fixed several issues with StrEvaluate(), including not recognizing MEMVARs with underscores in their names (#1078)

•Fix for a problem with InList() and string values (#1095)

•The Empty() function now returns false for the values .NULL. and DBNull.Value to be compatible with FoxPro

•Fixed a problem with GetDefault()/ SetDefault() to make them compatible with Visual Objects (#1099)

 

New Features

•Enhancements for Unicode AnyCpu SQL classes (#1006):

•Added a property to open a Sqlselect in readonly mode. This should prevent Append(), Delete() and FieldPut()

•Implemented delay creating InsertCmd, DeleteCmd, UpdateCmd until really needed

•Added callback mechanism so customers can override the commandtext for these command (and for example route them to stored Procedures)

•When a late bound method call cannot be resolved because the method is overloaded then a better error message is now generated that also includes the prototypes of the methods found (#1096)

 

 

FoxPro dialect

•Added ADatabases() function

Visual Studio Integration

New features

•You can now control how indenting is done through the Tools/Options Text Editor/X# option pages. We have added several options that control indenting of your source code. You can also set these from an .editorconfig file if you want to enforce indenting rules inside your company.

•We have now added extensive code formatting options to the source code editor. See Tools/Options/Text Editor/X#/Indentation for available options (#430)

•We have implemented the option "Identifier Case Synchronization". This works as follows: The editor picks up the first occurrence of an Identifier (class name, variable name etc) in a source file and make sure that all other occurrences of that identifier in the same source file use the same case. This does NOT enforce casing across source files (that would be way too slow)

•We have added color settings to the VS Color dialog for Matched braces, Matched keyword and Matched identifiers. Open the Tools/Options dialog, Choose Environment/Fonts and Colors and look for the colors in the listbox that start with the word "X#". You can customize these to your liking.

•X# projects that use the Vulcan Runtime now have a context menu item that allows you to convert them to the X# runtime. Standard Vulcan assemblies will be replaced with the equivalent X# runtime assemblies. If you are using 3rd party components such as bBrowser or ReportPro then you need to replace the references to these components yourself.(#32)

•We have added an option to the language page of the project properties to set the new /allowoldstyleassignments commandline option for the compiler

 

Bug fixes

•Fixed a problem with Get Latest Version for solution that is under TFS (#1045)

•Fixed WinForm designer changing formatting in main-prg file (#806)

•Fixed some problems with code generation in the WinForms designer (#1042, #1052)

•Fixed a problem with formatting of DO WHILE (#923)

•Fixed problem with Light Bulb "Generate default constructor" feature (#1034)

•Fixed problem with ToolTips in the Debugger. We now parse the complete expression from the first token until the cursor location. (#1015)

•Fixed some remaining intellisense issues with .Net array locals defined with VAR (#569)

•Fixed a problem with indenting not working correctly in some cases (#421)

•Fixed a problem with auto outdenting (#919)

•Several improvements to keyword pair matching (#904)

•Fixed a problem with Code Completion showing also static members after typing a dot in "ClassName{}." #1081

•Fixed a performance Issue when typing . for .and. (#1080)

•Fixed a problem with the navigation bar while typing new classes/methods (#1041)

•Fixed incorrect info tooltips on keywords (#979)

•Fixed a possible VS freeze when using "Clean Solution" (#1053)

•Fixed incorrect positioning of caret in eventhandlers in the form designer (#1092)

•Fixed a problem with the form designer failing to open forms after creating a new one (#1093)

•Right Click on a packages.config file and choosing the option "Migrate to packagereferences" did not work because inside Visual Studio there is a hardcoded list of supported project types. We are now "faking" the projecttype to make VS happy and enable the wizard.

Build System

•The XSharp.Build.Dll, which is responsible for creating the command line when compiling X# projects in VS, was not properly passing the /noconfig and /shared compiler options to the compiler. As a result the shared compiler was not used, even when the project property to use the Shared Compiler was enabled. Also the compiler was automatically including references to all the assemblies that are listed inside the file xsc.rsp, which is located inside the XSharp\bin folder.
You may experience now that assemblies will not compile because of missing types. This will happen if you are using a type that is inside an assembly that is listed inside xsc.rsp. You should add explicit references to these assemblies in your X# project now.

Changes in 2.12.2.0

Compiler

Bug fixes

•Fixed a bug in the code generation for handling FoxPro array access with parenthesized indices (#988, #991)

•The compiler was generating incorrect warnings for locals declared with IS. This has been fixed.

•The compiler was not reporting an error on invalid usage of the OVERRIDE modifier on ACCESS/ASSIGNs, this has been fixed (#981)

•Fixed inconsistent behavior in reporting warnings and errors in several cases when converting from various numeric data types to another (#951, #987)

•Fixed some "failed to emit module" issues with iif() statements in some cases (#989)

•Fixed a problem with compiling X# code scripts (#1002)

•Fixed a problem with using classes for some specific assemblies in the macro compiler (#1003)

•Fix an incorrect error message when adding an INT to a pointer in AnyCPU mode (#1007)

•Fixed a problem with casting STRING to PTR syntax (#1013)

•Fixed a problem with PCount() when passing a single NULL argument to a CLIPPER function/method (#1016)

New Features

•We have added support for the TEXT .. ENDTEXT command in all dialects. Please note that there are several variations of this command. One variation work in ALL dialects (TEXT TO varName). Other variations depend on the dialect chosen. We have moved the support for TEXT .. ENDTEXT now also from the compiler to the preprocessor. This means that there are also 2 new preprocessor directives, #text and #endtext (#977, #1029)

•Implemented new compiler option /vo17, which implements a more compatible to VO behavior for the BEGIN SEQUENCE..RECOVER command (#111, #881, #916):

oFor code that contains a RECOVER USING, a check is made for wrapped exceptions. When the exception is not a wrapped exception then a function in the runtime is called (FUNCTION _SequenceError(e AS Exception) AS USUAL) that can process the error. It can for example call the error handler, or throw the error

oWhen there is no RECOVER USING clause , then the compiler generates one and from within this generated clause detects if the RECOVER was reached with a wrapped exception or a normal exception. For wrapped exceptions it gets the value and calls a special function in the runtime (FUNCTION _SequenceRecover(uBreakValue AS USUAL) AS VOID). When the generated recover is called with a 'normal' exception then _SequenceError function from the previous bullet is called.

•We have added support for CCALL() and CCALLNATIVE()

•The #pragma directives are now handled by the preprocessor. As a result you can add #pragma lines anywhere in your code: between entities, inside the body of an entity etc.

Runtime

Bug fixes

•Changed the prototype for AdsGetFTSIndexInfo (#966)

•Fixed a problem with TransForm and decimal types (#1001)

•Added several missing return types in the VFP assembly

•Fixed a problem with browsing a DBFVFP table in the FoxPro dialect

•Fixed an inconsistency with handling values provided by BREAK commands inside surrounding BEGIN...RECOVER statements, depending on if early or late bound call is used (#883)

•Fixed a problem with floating point format when assigning a System.Decimal value to a USUAL var (#1001)

•Fixed a runtime error with DbCopyToArray() when copying to an array that has more columns than the table, in the FoxPro dialect (#993)

•Fixed a problem with the typecast expression and numeric literals with the +/- sign in the macro compiler (#1025)

•Fixed problem in the Late binding code where a string was sometimes passed in and not properly converted to symbol

•IVarPut()/IVarGet() now throw an appropriate exception when trying to use an inaccessible (due to limiting visibility modifiers) property getter/setter (ACCESS/ASSIGN) (#1023)

•Fixed an issue with IVarGet() and IVarPut() for properties that are redefined in a subclass with the NEW modifier (#1030)

•DbDataSource now tries to lock a record when deleting or recalling the record

•Foreach was not working correctly on properties containing collections that were returned from a late bound property access such as IVarGet()(#1033)

New Features

•You can now register a delegate in the runtime state that allows you to control how the macro compiler caches types from loaded assemblies(#998).
This delegate has to have the format:
 
DELEGATE MacroCompilerIncludeAssemblyInCache(ass as Assembly) AS LOGIC
 
Example:
 
XSharp.RuntimeState.MacroCompilerIncludeAssemblyInCache := { a  =>  DoNotCacheDevExpress(a)}
FUNCTION DoNotCacheDevExpress(ass as Assembly) AS LOGIC)
  // do not cache DevExpress assemblies
  RETURN ass:Location:IndexOf("devexpress", StringComparison.OrdinalIgnoreCase) == -1

Compatible VO SDK

•Fixed an issue where SetAnsi(FALSE) causes SingleLineEdit controls with pictures to show random characters when entering umlauts (#1038)

Typed VO SDK

There are 2 new properties for the SQLSelect class.

•ReadOnly - which makes the SQLSelect Readonly

•BatchUpdates - which controls how updates are handled

ReadOnly cursors and delayed creation of command objects

Previously the SQLSelect class created DbCommand objects to update, insert and delete changes made to a cursor immediately when the result set was opened.
That could cause problems when a complex query was used to select data, because the DbCommandBuilder object could not figure out how to create these statements.

We are now delaying the creation of these commands until the first time they are needed.
At the same time we have now added a ReadOnly property with a default value of FALSE.

If you set ReadOnly to true then:

•Calling FieldPut(), Delete() and Append() will generate an error with Gencode EG_READONLY.

•No Command objects will be created for the SQLSelect, because the cursor cannot be updated.

If ReadOnly remains FALSE then the command objects to update, insert and delete will be created the first time they are needed.
These commands are created in the __CreateDataAdapter() method.
You can override this method and create the commands in your own subclass when you want.
The command creation and the updates work as follows:

•First a DataAdapter (of type DbDataAdapter) is created using the CreateDataAdapter method from the SQLFactory class

•Then a CommandBuilder object (of type DbCommandBuilder) is created from the CreateCommandBuilder method of the SQLFactory class

•Then the Insert, Delete and Update Command objects (all of type DbCommand) are created from the GetInsertCommand() etc methods from the DbCommandBuilder object. The DBCommandBuilder object takes the Select statement and creates commands with parameters based on the SQLSelect command

•These command objects are assigned to the DataAdapter and then the DataAdapter:Update() method is called with the DataTable that is behind the SQLSelect as argument.

Batch Updates

Normally updates in a SQLSelect will be sent to the server when you move the record pointer to a new row, or when you call Update()

If you set the BatchUpdates property to TRUE then the SQLSelect will delay sending updates to the server and will not do that for each record movement, but will wait until you call the Update() method with an argument TRUE. This will then write all the buffered changes to the server. This may then also trigger the creation of the DBCommand objects (see before).
If your table has autoincrement fields then you may want to call Requery() afterwards to see the newly assigned key values.

Visual Studio Integration

Bug fixes

•Fixed the handling for project property pages for flavored projects (#992)

•When trying to start the debugger with a non existing working directory or program file name, now an appropriate error is displayed (#996)

•Fixed a problem with the form designer generating sometimes invalid code with #regions (#1020, #935)

•The WinForms designer now by default adds the OVERRIDE keyword modifier to the generated Dispose() method (was added in the template) (#1004)

•Due to a changed threading model inside the latest VS2022 releases, error messages were sometimes not shown in the output window and the error list. This has been fixed

•Fixed a problem in the windows forms designer code generation with nested classes inside the main form class (#1031).

•Fixed problem with windows forms editor failing to open form with command based on UDC (#1037).

Sourcecode Editor

•Type lookups on full names were sometimes failing because the fullname was defined as case sensitive (#978)

•Nested type lookup was sometimes failing. This has been fixed.

•The indenting options can now also be overridden in the .editorconfig file (#999)

•When a source file was loaded in the editor then the combo boxes with types and members were not activated until the caret was moved in the buffer (#995)

•The member combobox in the editor was getting confused for code that contains local functions or local procedures.

•Fixed a lookup problem for expressions inside a conversion or cast with a keyword, such as DWORD( SomeExpression). There were no quick info tips for the expression inside the parentheses for the conversion (#997)

•Fixed an intellisense problem with DATATYPE(<expression>) conversion expressions (#997)

•Fixed a problem with properties declared with the => symbol in their implementation causing Navigation Bar contents to be incomplete (#1008)

•Fixed several issues with code folding and formatting (#975)

•Fixed problem with typing a comma inside an argument list did not invoke the Parameters Tooltip (#1019)

•Fixed some issues with the detection of variable types for the VAR keyword (#903)

•Fixed an Intellisense problem with typing ":" or "." inside a string literal (#1021)

•Fixed a problem with unknown identifiers sometimes causing bogus member completion list to show (#1022)

•Pressing CTRL+SPACE in the editor now always invokes a code completion list (#957)

New Features

•Added options to insert page and reorder pages in a tabcontrol, in the VOWED (#1024)

•We have updated the WPF Application template. The Main window is now called  "MainWindow".

•Added the following new settings to the .editorconfig file to set indentation options (#999).

•indent_entity_content (true or false)

•indent_block_content (true or false)

•indent_case_content (true or false)

•indent_case_label (true or false)

•indent_continued_lines (true or false)

 

VOXporter

•The VOXporter now correctly enabled or disables the Allow MEMVAR/Undeclared vars compiler options, if they were enabled in the VO app (#1000)

Changes in 2.11.0.1

Compiler

Bug fixes

•Fixed an internal compiler error with CLIPPER calling convention delegates (#932)

•Fixed an AccessViolationException at runtime with the Null-conditional operator ?. on a usual property (#770)

•[XBase++ dialect] Fixed a problem with parsing method declarations with parentheses (#927)

•[XBase++ dialect] Fixed a problem with parsing the (obsolete in X#) ANNOUNCE and REQUEST statements (#929)

•[XBase++ dialect] Fixed a problem with parsing INLINE ACCESS and ACCESS ASSIGN statements (#926)

•[VFP dialect] Fixed a problem with parsing FOR EACH statements containing "M." variables usage where the variable was not typed in the FOR EACH line (#911) .

•Fixed a problem where the PPO files contains some output twice, when a single UDC was producing several statements (#933)

•Fixed some issues with the "FIELDS" clause in several UDCs (#931, #795)

•Fixed a problem in the preprocessor with parentheses in #xtranslate directives (#963)

•Fixed several more issues with #command and #translate directives (#915)

•In some cases, the compiler would emit code that does not throw a runtime exception, when casting/converting from one type to an incompatible one. This has been fixed (#961, #984)

•The compiler was not reporting narrowing conversion warnings in several cases, this has been fixed (#951)

•The compiler was not reporting signed/unsigned conversion warnings. This has been fixed (#971)

•Fixed a problem that could lead to the "Could not emit module" error message, caused by NULL values inside IIF() expressions(#989)

New features

•Added compiler option /noinit to not generate $Init calls for libraries without INIT procedures for the sake of postponed loading (#854)

•Added preprocessor support for #stdout and #if. (#912)

•The full contents of #include files is now written to the ppo file (#920)

•When a parser error occurs because an identifier was replaced by a define with the same name, then the compiler will now generate a second warning.

•If a header file contains actual code and this code is called during debugging then the debugger will now step into the header file when debugging this code.
Previously all statements were linked to the #include line from the place where the header was included. (#967)

•When you are suppressing compiler errors with the /vo11 (Compatible numeric conversion) compiler option you will now see a XS9020 "narrowing" warning indicating that a runtime error may happen or that data may be lost.

•When you are suppressing conversion errors between signed and unsigned integers with /vo4 then you will now see as XS9021 warning indicating that data may be lost or an overflow error may occur.

Visual Studio Integration

New features

•The source code editor now also supports the new #if and #stdout preprocessor commands  (#912)

•There is new "Lightbulb" option to generate constructors for classes.

Bug Fixes

•Fixed a problem with specifying custom preprocessor defines in the project properties (#909)

•The VO-style editors now retain existing "CLIPPER" clause to methods/constructors when generating code (#913)

•Fixed incorrect parsing of classes as nested to each other (#939)

•Fixed a problem with using embedded variables in the form of $(SomeName) in the project settings (#928)

•Fixed a problem where deleting items from a project would fail.

•Fixed a problem resolving the DLL produced by project files from other development languages, in particular SDK style C# projects (#950)

•Fixed a problem with quick info tooltip after an unrecognized identifier (#894)

•Fixed a problem with the editor incorrectly adding parentheses after auto typing a property (#974)

•Fixed extremely slow editor response when creating a new line after an #endif directive (#970)

•Fixed some intellisense issues with .Net array types (#569)

•Fixed a problem with the DevExpress DocumentManager control at design time (#976)

•Fixed an ArgumentNullException in the Output window when "Show output from" is set to "Extension" (#940)

Runtime

New features

•Added a constructor with IEnumerable to the array class (#943)

•Implemented missing functions AdsSetTableTransactionFree() and AdsGetFTSIndexInfo() (#966)

•Moved functions GetRValue(), GetGValue() and GetBValue() from the Win32API library to XSharp.RT, so they can be used by AnyCPU code (#972)

•[VFP dialect] Implemented function APrinters() (#952)

•[VFP dialect] Implemented function GetColor() (#973)

•[VFP dialect] Implemented functions Payment(), FV() and PV() (#964)

•[VFP dialect] Implemented commands MKDIR, RMDIR and CHDIR (#614)

Bug fixes

•Fixed a problem with the ListView TextColor and TextBackgroundColor ACCESSes in the SDK (#896)

•Fixed a problem with soft Seek not respecting order scope when to strict key is found (#905)

•Fixed DBUseArea() search logic for files in various folders. Also SetDefault() is no longer initialized with the current directory (for VO compatibility) (#908)

•Fixed problem with creating dbfs with character fields with length > 255 (#917)

•Fixed a problem with the buffered read system in some cases when a dbf was being read, closed, overwritten and then reopened (#968)

•Fixed a VO compatibility problem with how DBSetIndex() changes the active order when opening index files (#958)

•Fixed a problem with db append, copy etc, when both source and destination files have the same structure and include a memo file (#945)

•Fixed an incorrect result of DBOrderInfo(DBOI_ORDERCOUNT) with a non existing or not open index file (#954)

•[VFP dialect] Added optional parameter to Program( [,lShowSignature default=.f.] ) (#712)

•[VFP dialect] Fixed several issues with the Type() function (#747, #942)

•[VFP dialect] Fixed a problem with ExecScriptFast() (#823)

•[VFP dialect] Fixed a problem with SQLExec() not putting the record pointer on the first record (#864)

•[VFP dialect] Fixed a problem with SQLExec() with null values (#941)

•[VFP dialect] Fixed a write error in the buffer returned from SqlExec() (#948)

•[VFP dialect] Fixed a problem with the DBFVFP RDD and null columns (#953)

•[VFP dialect] Fixed a problem with SCATTER TO and APPEND FROM ARRAY (#821)

Typed SDK

•Fixed a problem with the FileName property of standard open dialogs

•Fixed a problem with a FOREACH inside the Menu constructor causing handled exceptions

RDD

Bug fixes

•Fixed a problem in the DBFVFP RDD with the calculation of the keysize of nullable keys (#985)

VOXporter

Bug fixes

•Fixed incorrectly detecting pointers to functions inside literal strings and comments (#932)

 

Changes in 2.10.0.3

Compiler

Bug fixes

•Fixed some problems with COPY TO ARRAY command in the FoxPro dialect (#673)

•Fixed a problem with using a System.Decimal type on a SWITCH statement (#725)

•Fixed an internal compiler error with Type() in the FoxPro dialect (#840)

•Fixed a problem with generating XML documentation (#783, #855)

•Prevented a warning from appearing for members of SEALED classes when /vo3 (all members VIRTUAL) is enabled (#785)

•Fixed problems with assigning and comparing "ARRAY OF <type>" vars to NULL_ARRAY (#833)

•Fixed some issues with passing arguments by reference with the @ operator and/or using it as the AddressOf operator (#810, #899, #902)

•Fixed a problem resolving parameters passed by reference with the @ operator when the function/ method had a parameter of the pointer type (#899, #902)

New features

•Added compiler option (-enforceoverride) to make the OVERRIDE modified mandatory when overriding a parent member (#786, #846)

•The compiler now reports an error when using String2Psz() and Cast2Psz() in a non local context (since such PSZs are being released on exiting the current entity) (#775)

•FUNCTIONs and PROCEDUREs now support the ASYNC modifier (#853)

•You can now suppress the automatic generation of the $Init1() and $Exit() functions by passing the compiler commandline
option -noinit (#854). This is NOT yet supported in the VS Properties dialog

•Added support for the ASTYPE operator also for USUAL vars (#857)

•Allowed specifying AS <type> clause in PUBLIC var declarations (ignored by the compiler, but used by the editor in the future for intellisense) (#853)

•The AS <datatype> OF <classlib> clause is now also supported for several other FoxPro compatible commands, such as PARAMETERS and PUBLIC.
Since these variables are untyped at runtime by nature, the clause is ignored by the compiler and a warning is shown.

Build System

Bug Fixes

•Running MsBuild on a X# WPF project could fail (#879)

Visual Studio Integration

New features

•We have added Visual Studio integration for VS 2022

•We have added support for Package References

•Now XML comments are automatically inserted in the editor when the user types "///". (#867, #887) Conditions:

o        Cursor must be on a line before the start of an entity

o        Cursor must NOT be before a comment line

•Now the tooltip on a class includes also information about the parent class and implemented interfaces (if any) (#860)

•We have added tooltips, parameter completion etc for the pseudo functions that are built into the compiler, such as PCount() and String2Psz().

•We have added a first version of Lightbulb tips. For now to implement missing interface members and to convert a field to a Property. More implementations and configuration options will follow

•We have added a new dialog to configure source code formatting with visual examples of the effects of the options.

•We have added the ability to log operations of the X# VS integration to the Windows debug window and/or a logfile.
If you are experiencing unexplainable problems we will contact you and tell you how to enable these options, so you can send us a log file that shows what happened before a problem occurred inside Visual Studio. We have used Serilog for this.

•The Highlight Word feature now is case insensitive and no longer hightlights words that are part of a comment, string or inactive editor region

•We have added 'Brace Completion' to the editor

Bug Fixes

•Fixed some problems with the Format Document command (#552)

•Fixed several issues with Parameter Tooltips (#728, #843)

•Fixed problem with code completion list showing even for not defined vars/identifiers (#793)

•Fixed member completion and parameter tooltips with chained expressions (#838)

•Fixed recognition of type for VAR locals in some cases (#844)

•Fixed member completion and tooltip info problems with VOSTRUCT vars (#851)

•Fixed a problem with ignoring Line Breaks in XML Comments (#858)

•Fixed some WinForms designer problems with CHAR properties (#859)

•Fixed a problem with Goto Definition not working correctly with SUPER() constructor calls (#862)

•Fixed an error with the Rebuild Intellisense Database command, when the solution contains a space in the path (#865)

•Goto Definition for types from external assemblies was failing when there was more than one copy of VS running at the same time.

•Fixed a problem with a VOSTRUCT some times confusing the parser (#868)

•Fixed some more problems with quickinfo and member completion (#870)

•Fixed a problem in the Windows Forms designer (#873)

•Fixed an intellisense problem with ENUMs using no MEMBER keywords (#877)

•Fixed a member completion problem with inherited exception types (#884)

•If an XML topic had sub elements of type <see> or other these were not shown in the editor. This has been fixed (#900)

•Unbalanced braces were sometimes matched in the editor with keywords. This has been fixed (#892)

•Line separators were sometimes flickering. This has been fixed (#792)

•When parsing for local variables we were not processing the include files. This could lead to a situation where a local that was declared in a conditional block (#ifdef SOMEVAR) was not found. This has been fixed. The editor parser now includes the header files and #defines and #undefines found in the code even when parsing a part of the source file (#893)

•#include lines are now included in the fields/members combobox in the editor (when fields are shown). They are also saved to the intellisense database.

•The editor was trying to show QuickInfo tooltips when the cursor was over an inactive preprocessor region (#ifdef). This no longer happens.

Runtime

Bug fixes

•Fixed DBFCDX corruption that could happen with simultaneous updates (#585)

•Fixed a problem opening FoxPro tables with indexes on nullable fields (#631)

•The BlobGet() function was returning a LOGIC instead of the actual field value (#681)

•Greatly improved speed of index creation with large number of fields in the index expression (#711)

•Fixed some problems with  FieldPutBytes() and FieldGetBytes() (#797)

•DBSeek() with 3rd param (lLast) TRUE had incorrect behavior in some cases (#807)

•Fixed a potential NullreferenceException that could happen when creating indexes (#849)

•Improved indentation in the text produced by the method Error.WrapRawException() (#856)

•Fixed a runtime problem when converting .Net Array <-> USUAL (#876)

•DbInfo() was returning TRUE even when an info enum was not supported.(#886)

•Fixed also a possible DBFNTX corruption problem (#889)

•DbEval() could fail in FoxPro when the codeblock was returning NIL or was VOID (#890)

•Fixed a problem with Softseek and descending indexes.

•Fixed a problem where incorrect scope expressions could lead to unexpected results. Now the server goes to (and stays at) EOF with an incorrect scope.

•Fixed a problem with accessing FoxPro arrays with the parenthesis operators in a macro expression (#805).
Please note that for this to work you have to compile the main program with /fox2

 

Changes in 2.9.1.1 (Cahors)

Compiler

Bug fixes

•Fixed a problem introduced in 2.9.0.2 with define symbols not respecting the /cs compiler option in combination with the /vo8 compiler option (#816)

•Fixed an internal compiler error with assignment expressions inside object initializers when the /fox2 compiler option is enabled (#817)

•Fixed some problems with DATEs in VOSTRUCTs (#773)

•Fixed a problem in the preprocessor that would occur when using a list rule like FIELDS <f1> [,<fn> ] in the middle of a UDC.

•Fixed a problem compiling UDCs such as SET CENTURY &cOn because cOn was not parsed as an identifier but as a keyword.

New features

•There is a new result marker (the NotEmpty result marker) in the preprocessor that does the same as the regular result marker, but writes a NIL value to the output when the (optional) match marker is not found in the input.
This can be used when you want to make the result a part of an IIF() expression in the output, since the sections inside an IIF expression may not be empty.
The result marker looks like this: <!marker!>

•Using a Restricted match marker as the first token in an UDC was not allowed before. This has been fixed. You can now write a rule like this, which will output the keyword (SCATTER, GATHER or COPY) followed by the stringified list of options.

#command <cmd:SCATTER,GATHER,COPY> <*clauses*> => ?  <"cmd">, <"clauses">
FUNCTION Start AS VOID
   SCATTER TO TEST   // is preprocessed into ? "SCATTER" , "TO TEST"
  RETURN

Visual Studio Integration

Bug Fixes

•Fixed a problem introduced in 2.9.0.2 with code generation for WPF projects (#820)

•Fixed a VS freezing problem after building (#819)

•Fixed some problems with code collapsing and the navigation bar for source files that contains a SELF property (#825)

•Fixed a problem with the form designer emitting invalid code when the form prg contains nested classes (#828)

•Fixed a problem with code completion showing the wrong members when opened just left to a closing paren (#826)

•Fixed a VS crash when clicking on a generic class (#827)

•Fixed a problem with the keyword colorization for expressions such as SET CENTURY &cOn, where &cOn was colored in the keyword color.

•Parameter tips for nested function calls required an extra space before the name of the nested function (#728)

•Fixed a problem with the form designer deleting delegates and other nested types in the form.prg (#828)

•The background process to load the types in the ClassView / ObjectView windows was slowing down the VS performance. This has been disabled for now.

•Fixed type lookup for Generic types.

•Hovering the mouse over a constructor keyword was showing a tooltip for the class and not for the constructor. This has been fixed.

•Fixed an issue in the code generator for Windows Forms for literal characters with special values (such as '\0') (#859)

•Fixed an exception in the project system when the project system was initialized in the background (for example when no X# projects were opened) (#852)

•Fixed missing code completion for the LONGINT and SHORTINT keywords (#850)

•The context menu option "View in Disassembler" is now only shown for X# projects

•Fixed code generator problem with ARRAY OF <type> (#842)

•Fixed a performance problem when clicking on code in the editor (#829)

•Fixed a problem with loading Windows Forms when the lookup of a nested type failed.

 

New features

•We have added a context item to the project context menu in the solution explorer to edit the project file. This will unload the project when needed and then open the file for editing.

•The Rebuild Intellisense Database menu option in the Tools/XSharp menu now unloads the current solution, deletes the intellisense database and reopens the solution to make sure that the database is recreated correctly.

•We have made some changes to the process that parses the source code for a solution in the background.

•Generic Typenames are now stored in the Name`n format in the Intellisense database, for example IList`1 for IList<T>

Runtime

New features

•Added missing ErrorExec() function (#830)

•Added support for BlobDirectExport, BlobDirectImport, BlobDirectPut and BlobDirectGet (#832)

•Fixed a problem with creating DBF files with custom file extension. Also added support for _SET_MEMOEXT (#834)

•When you do a numeric operation on two USUALs of different types we now make sure that decimal values are no longer lost (#808). For example a LONG + DECIMAL will result in a DECIMAL. See the table in the USUAL type page in this help file for the possible return values when mixed types are used.

 

 

Bug Fixes

•Fixed a problem with _PrivateCount() throwing an InvalidateOperationException (#801)

•Fixed a problem with member completion in the editor sometimes showing methods of the wrong type (#740)

•Fixed some problems with the ACopy() function (#815)

•Fixed a few issues that were remaining related to DATEs in VOSTRUCTs (#773)

Macro compiler

New features

•Added support for the & operator (#835)

•Added support for parameters by reference (both @ and REF are supported) for late bound method calls (#818)

VOXporter

Bug Fixes

•Fixed problem with incorrectly prefixing PUBLIC declarations with "@@"

 

Changes in 2.9.0.2 (Cahors)

Compiler

New features

•The parser now supports class variable declarations and global declarations with multiple types(#709)

 EXPORT var1 AS STRING, var2, var3 as LONG

 GLOBAL globalvar1 AS STRING, globalvar2, globalvar3 as LONG

•If you are using our parser you should be aware that the ClassVarList rule has disappeared and that the ClassVars, VoGlobal and ClassVar rules have changed.

•We have added a command to fill a foxpro array with a single value

 STORE <value> TO ARRAY <arrayName>

 

•When you create a VOSTRUCT or UNION that contains a DATE field, then the compiler will now use the new __WinDate structure that is binary compatible with how DATE values are stored inside a VOSTRUCT or UNION in Visual Objects (#773)

•It is now possible to use parentheses for (instead of brackets) accessing ARRAY elements in the FoxPro dialect. The compiler option /fox2 must be enabled for that to work (#746)

•We have added support (for the FoxPro dialect only) for accessing WITH block expressions inside code of a calling function / method. So you can type .SomeProperty and access the property that belongs to a WITH BLOCK expression inside the calling code. To use this Late Binding must be enabled, since the compiler does not know the type of the expression from the calling code (#811).

 

Bug fixes

•When you use the NEW or OVERRIDE modifier for a method where no (virtual) method in a parent class exists an error will now be generated (#586, #777)

•Fixed a problem with LOGICAL AND and OR for USUAL variables in an array (#597)

•Error messages and Warnings for some compiler generated code (such as Late bound code) were not always pointing to the right line number, but to the first line in the body of the method or function. This has been fixed. (#603)

•Fixed a problem incorrect return values for IIF expressions (#606)

•Fixed a problem in the compiler when parsing multiple method names on a DECLARE METHOD line (#708)

•Fixed a problem in the FoxPro dialect with assigning a single value to an array to fill the array (#720)

•Fixed a problem with the calculation of VOSTRUCT sizes when the structure contained a member of type DATE (734)

•The previous problem caused runtime errors (#735)

•Fixed a problem in code like this (#736)
var aLen := ALen(Aarray)

•Fixed a compiler crash when overriding CLIPPER method with STRICT for methods with typed return value (#761)

•When the interface implementation had different casing then the definition then an incorrect error message was shown (#765)

•Fixed a compiler crash with incorrect function parameters inside a codeblock (#759)

•Recursive definitions of DEFINEs could result in an infinate loop inside the compiler causing a StackOverflowException(#755)

•Fixed a problem with late bound calls and OUT parameters (#771)

•If you compile with warning level 4 or lower then certain warnings for comparing value types to null are not shown. We have changed the default warning level to 5 now. (#772)

•Fixed a compiler crash with multiple PRIVATE &cVarName statements in the same entity (#780)

•Fixed a problem with possibly corrupting the USUAL NIL value when passing USUAL params by reference (#784)

•Fixed a problem with declared PUBLIC variables getting created as PRIVATE in the FoxPro dialect (#753)

•Fixed a problem with using typed defines as default arguments (#718)

•Fixed a problem with typed DEFINEs that could produce constants of the wrong type (#705)

•Fixed a problem with removing whitespace from #warning and #error directive texts (#798)

Runtime

New Features

•We have added several strongly typed overloads for the Empty() function that should result in a bit better performance (#669)

•We have added an event handler to the RuntimeState class. This event handler is called "StateChanged" and expected a method with the following signature:
Method MyStateChangedEventHandler(e AS StateChangedEventArgs) AS VOID
The StateChangeEventArgs type has properties for the Setting Enum, the OldValue and the NewValue.
You can use this if you have to synchronize the state between the X# runtime and an external app, for example a Vulcan App, VO App or for example (this is where we are using it) with an external database server, such as Advantage.

•We have added a new (internal) type __WinDate that is used when you store a DATE value into a VoStruct or Union. This field is binary compatible with the Julian date that VO stores inside structures and unions.

•We have added an entry to the RuntimeState in which the compiler stores the current /fox2 compiler setting for the main app.

•Added runtime support to support filling FoxPro arrays by assigning a single value.

 

Bug Fixes

•Fixed a problem (incompatibility with VO) in the Descend() function (#779) - IMPORTANT NOTE: If you are using Descend() in dbf index expressions, then those indexes need to be reindexed!

•Late bound code that was returning a PSZ value was not correctly storing that inside a USUAL (#603)

•Fixed a problem in the Cached IO that could cause problems with low level file IO (#724)

•The VODbAlias() function now returns String.Empty and not NULL when called on an area where no table is open. (#733)

•Fixed a compatibility problem with the MExec() function (#737)

•The M-> prefix was not recognized correctly inside codeblocks (#738)

•The Explicit DATE -> DWORD cast was returning an incorrect value for NULL_DATE.

•Fixed a problem with late bound calls and OUT parameters (#771)

•Added a new __WinDate type that is used to store DATE values inside a VOSTRUCT or UNION. (#773)

•Fixed several problems with FoxPro arrays

•Removed TypeConstraints on T for functions that manipulate __ArrayBase<T>

•Fixed a problem with Directory() including files that match by shortname but not by longname (#800)

RDDs

•When creating a new DBF with the DBFCDX driver an existing CDX file is not automatically deleted anymore (#603)

•Fixed a problem with updating memo contents in DBFCDX (#782)

•Fixed a runtime exception when creating DBFCDX index files with long filenames (#774)

•Fixed a problem with with DBSeek() with active OrderDescend() finding even deleted records

•Fixed a problem with a missing call to AdsClearCallbackFunction() in the ADS RDD in OrderCreate() (#794)

•Fixed a problem with VODBOrdCreate function failing it the cOrder parameter contains an empty string (#809)

Macro compiler

•Fixed a problem in the Preprocessor

•Added support for parameters passed by reference with the @ operator

•Added support for M->, _MEMVAR-> and MEMVAR-> prefixes in the macro compiler

•When the Macro compiler finds 2 or more functions with the same name it now uses the same precedence rules that the compiler uses:

oFunctions in User Code are used first

oFunctions in the "Specific" runtimes (XSharp.VO, XSharp.XPP, XSharp.VFP, XSharp.Data) take precedence over the ones inside XSharp.RT and XSharp.Core

oFunctions in XSharp.RT take precedence over functions inside XSharp.Core

Visual Studio Integration

In this build we have started to use the "Community toolkit for Visual Studio extensions" that you can find on GitHub. This toolkit contains "best practices" for code for VS Extension writers, like we are. As a result more code is now running asynchronously which should result in better performance.

We have also started to remove 32 bit specific code that would become a problem when migrating to VS 2022 which is a 64 bits version if Visual Studio that is expected to ship in November 2021.

New features

•Added several new features to the editor

oThe editor can now show divider lines between entities. You can enable/disable this in the options dialog (#280)

oKeyword inside QuickInfo tooltips are now colored (#748)

oGoto definition now also works on "external" types. The editor generates a temporary file that contains the type information for the external type. In the options dialog you can also control if the generated code should contains comments (as read from the XML file that comes with an external DLL). (#763)

oYou can control which keyword is used for PUBLIC visibility from the Tools/Optons menu entry (PUBLIC, EXPORT or No modifier at all)

oYou can control which keyword is used for PRIVATE visibility from the Tools/Optons menu entry (PRIVATE or HIDDEN).

•The various code generators inside VS now follow the capitalization rules from the source code editor.

•The intellisense database now has views that return the unique namespaces in the source code and in the external assemblies

•The X# specific menu points in the Tools menu have been moved to a separate submenut

•Added option for the WinForms designer to generate backup (.bak) files of form.prg and form.designer.prg files when saving (#799)

Bug Fixes

•Fixed several problems in the editor:

oWe have made several improvements to increase the speed inside the editor (#689, #701)        

oFixed a problem in the type lookup of variables for FOREACH loops (#697)

oParameter tips were not shown for methods selected from a completion list (#706)

oKeyword case synchronization did not work when the keyword was not followed by a space (#722)

oGoto definition always went to line 1 / column 1 in the file where a function was defined (#726)

oCode completion for Constant members of classes (#727)

oQuickInfo for DEFINES (#730, #739)

oVOSTRUCT Member completion with the '.' operator (#731)

oThe ENUM and FUNC keywords are now recognized as identifier and not case synchronized in these cases.(#732)

oFixed a problem when opening files (#742)

oFixed parameter tip display for default values NULL, NULL_DATE and NULL_OBJECT (#743)

oFixes broken parameter tips for constructors (#744)

oNested classes were not always handled correctly by the intellisense (#745)

oFixed a problem in the type lookup of variables declared with ARRAY OF <something> (#749)

oThe Editor could sometimes "freeze" when the buffer contained invalid code (#751)

oNon-existing namespaces would produce a bogus completion list (#760)

oFixed an editor exception in some cases when typing invalid code (#791)

•The code generator for Windows Forms was replacing tab characters with spaces. This has been fixed.(#438)

•Fixed a problem with the Form Designer corrupting code that contains EXPORT ARRAY OF <type>

•Fixed a problem with the Form Designer that when removing an event handler in the editor, some code was deleted (#812)

•Fixed a problem with the Form Designer converting EXPORT, INSTANCE and HIDDEN keywords to PUBLIC and PRIVATE (#802)

VO-Compatible Editors

•Now all VO-compatible editors support full Undo/Redo functionality. Also added cut/copy/paste functionality to the Menu editor

•Fixed several visual problems with VOWED controls in Design and Test mode (#741)

•Fixed a VS crash when Alt-Tabbing out of the editors, with the Properties window having focus (#764)

•Adjusted ComboBoxEx controls to have the same fixed height, as in VO. Also allowed the previous behavior, when the user has manually increased the height by more than 50 pixels, then this height is being used instead (#750)

•Added a bitmap thumbnail for the "Button Bmp" property of the Menu Editor in the Properties Window

•Added support for specifying a Ribbon in the Menu Editor. The ribbon (bitmap) to be used needs to be specified as a filename in the properties of the Menu's main item (#714)

•Fixed some issues with event code generation in the Window Editor (#441, #46)

 

Changes in 2.8.3.15 (Cahors)

Compiler

New features

•You can now use the .AND. logical operator and .OR. logical operator between variable names or numbers without leading or trailing whitespace (a.AND.b)

•The PRIVATE declaration in the FoxPro dialect no longer allows an initializer.

•Added support for the FoxPro NULL date ( { / / }, { - - } and { . . }) in the FoxPro dialect

Bug fixes

•Fixed a problem with a DIM array that uses a DEFINE for its dimension (#638)

•Fixed a problem with the FoxPro PUBLIC ARRAY command (The ARRAY keyword is no longer mandatory)  (#662).

•Fixed a problem with DEFAULT(Usual) expressions as parameters for function / method calls (#664)

•Fixed a problem with variables declared with the LOCAL declaration and dimensioned with the DIMENSION command (#683)

•Fixed issue with overloads with the same name in different X# runtime assemblies that manifested itself with problems with FRead()(#686)

•Fixed a problem with passing PRIVATE and PUBLIC memory variables by reference (#691)

•Fixed a problem with PARAMETERS statement (#691)

•Fixed a problem with real numbers (#704) that was caused by the change in handling of .AND. and .OR.

•Fixed a problem parsing the DECLARE METHOD / ACCESS / ASSIGN lines inside class declarations.

•Fixed a problem with truncating results for binary operators (+, -, *, /) for mixed integral types (e.g. int and word)

Runtime

Bug Fixes

•The _shutdown flag in the Runtime State is now set when the system shuts down.

•Fixed a problem with the FoxPro ALen() function (#650)

•Added default values on several locations (#678)

•Fixed a problem where FRead() on a file opened by an RDD would go into an endless loop (#688)

•Fixed a problem with FieldGet() when the file is at EOF (#698)

•Fixed a scope problem when the scope was empty and a record matching the scope was added in another workarea or by another workstation (#699)

•Fixed a problem with the BOF setting after a Skip(0) (#700)

MacroCompiler

New features

•You can now use the .AND. operator between variable names or numbers without leading or trailing whitespace

•Added support for the FoxPro NULL date ( { / / }, { - - } and { . . }) in the FoxPro dialect

•Strings containing .AND. and .OR. are no longer reformatted by the macro compiler (#694)

•We have added an experimental new faster script compiler. This script compiler allows to compile statements, so no functions, classes etc.
This new script compiler is much faster than the existing script compiler and uses a lot less memory.
To call this script compiler use the new function ExecScriptFast() which has the same parameters as ExecScript().
You can compile multiline scripts. The compiler should recognize all statements including PARAMETERS and LPARAMETERS to receive parameters.
If you are using scripts in your code we would love to hear feedback.
An example of code that should work:

 
FUNCTION Start() AS VOID
LOCAL ctest AS STRING
TRY
   cTest := "? 'Hello world'"
   ExecScriptFast(cTest)
   cTest :=String.Join(e"\n",<STRING>{;
       "PARAMETERS a,b,c",;
       "RETURN CallMe(a,b,c)"})
   ? ExecScriptFast(cTest,1,2,3)
   cTest :=String.Join(e"\n",<STRING>{;
       "LPARAMETERS a,b,c",;
       "RETURN CallMe(a,b,c)"})
   ? ExecScriptFast(cTest,1,2,3)
 
CATCH e AS Exception
   ? e:ToString()
  END TRY
 
wait
RETURN
 
 
FUNCTION CallMe(a,b,c) AS USUAL
   ? "Inside function, parameters received",a,b,c
  RETURN a+b+c

 
Please test this new functionality and let us know what you think of it.

Visual Studio Integration

New Features

•"Highlight word" now highlights words in the whole file when the cursor is outside of an entity (for example on the USING statements in the start of the file).

Bug Fixes

•Fixed a problem with displaying names of custom controls in the toolbox of the VO compatible Windows Editor

•Fixed a problem with extra spaces when loading settings from cavowed.inf for the VO compatible Windows Editor

•Fixed a problem with an incorrect completion list after an assignment statement (#658)

•Fixed an exception in the editor after deleting code (#674)

•Fixed a "freeze" problem in the VS IDE when attaching a file to the shell window (#676)

•Fixed a problem when using dot instead of colon in VO Dialect with AllowDot (#679)

•Fixed a problem with showing a completion list inside class (#685)

•Fixed a performance problem in the editor (#689)

•Fixed a problem with showing function overloads in the editor (#692)

•Fixed a problem with intellisense after a !, .NOT. or other operator (#693)

•Fixed a problem where the incorrect methods were shown in the completion list (#695)

Tools

•Fixed an issue in VOXPorter with resources and the copying to the Resources subfolder

 

Changes in 2.8.2.13 (Cahors)

Compiler

•Fixed issues with extension methods that were not marked as STATIC (#660)

•Fixed problem with IIF() expressions that returned an OBJECT and were assigned to a Decimal

•The pragma commands were not checking for the current dialect

•Fixed an exception in the preprocessor

•The FoxPro LOCAL ARRAY was not generating a LOCAL variable but a PRIVATE variable.

•Functions in XSharp.RT that are overridden in XSharp.VO, XSharp.VFP or XSharp.RT will no longer generate a warning. The version that is not in XSharp.RT will have preference

•Enumerating a USUAL variable in a FOREACH loop will now call a runtime function that returns the ARRAY inside the USUAL or throws an error otherwise

•Implicit conversions from OBJECT -> NUMERIC are now supported when /vo7 is enabled.

Runtime

•Enumerating a USUAL variable in a FOREACH loop will now call a runtime function that returns the ARRAY inside the USUAL or throws an error otherwise (#246)

•Fixed a problem creating index with an Eval block and 0 records (#619)

•Fixed an incompatibility with the ALen() function and array handling compared to FoxPro (#642)

•We have fixed some issues in FoxPro AIns() function (#650)

•We have added a ShowFoxArray() function that will be automatically called when you call ShowArray() on a FoxPro array (650)

•Added support for OClone()

•The _Quit() function now closes all databases and then kills the current running process (#665)

•Fixed a problem with DbOrderInfo (#666)

•Fixed a problem with the unary minus operator for currency values (#670)

•Fixed a problem in the Integer function when a Currency value was sent in (#671)

•We have added an implementation of MemCheckPtr() (#677)

 

Macro compiler

•Fixed a problem calling functions after a new assembly was loaded with Assembly.Load()

•Added support for passing variables by references (not yet for functions with Clipper calling convention) (#653)

VO SDK

•Fixed a problem in GetObjectByHandle() in the GUI Classes(#677)

Visual Studio Integration

•Fixed an exception on the Build Options page inside VS (#654)

•The project system did not write back the right property for the XML documentation generation (#654)

•Intellisense could crash in header files (#657)

•We have added #defines and user defined commands (#command, #translate) to the members combobox in the editor as members of the global type. You can now also do a Goto definition on a value defined with #define.

•We have fixed a problem with member completion for enums (656)

•We have fixed a problem with the Windows Forms Editor that could happen if another VS extension had loaded an older version of Mono.Cecil (#661)

•Code completion was not showing instance members when the project option "Allow dot" was enables (#679)

•The "header" new item template had a .VH extension. This has been changed to .XH

•Fix a crash in the VO Compatible windows editor that happened with an incorrect CAVOWED.INF

•Code completion inside parentheses for a method or function call was not working correctly

•Improved Build Speed in Visual Studio when no files are changed (#675)

Tools

•VO Xporter was generating 2 lines in the .xsproj file for the output folder (#672)

 

 

Changes in 2.8.1.12 (Cahors)

Compiler

•Fixed issues with interpolated strings (#598, #622):

oThe script compiler now correctly sets the AllowDot compiler option from the current active dialect in the runtime (Core & FoxPro: AllowDot = true)

oWhen compiling with DOT(.) as instance method separator then the ":" character is used inside interpolated strings to prefix the format string.

oWhen compiling with COLON (:) as instance method separator then the colon can not be used to separate expressions from the format string inside interpolated strings. In that case we now support a double colon (::) between the expression and the format string. For example

LOCAL num as LONG
num := 42
? i"num = {num::F2}" // this diplays num with 2 decimals
WAIT

•You can now use DATE fields inside VOSTRUCT and UNION (#595)

•Fixed an assertion error 'UnconvertedConditionalOperator' (#616)

•Fixed an assertion error in the compiler when the namespace "xsharp" is used (#618)

•Fixed an "failed to emit" problem for methods defined in COM assemblies with default arguments and arguments passed by reference (#626)

•Fixed a problem with the handling of default parameters and method calls (#629)

•Fixed a problem where the _SizeOf() operator was not calculating the right size for a VOSTRUCT (#635).
Please note that _SizeOf() can only be calculated at compile time when your application is compiled for x86 or x64 mode. When compiling for AnyCpu we will be calculating _SizeOf() at runtime.

•Fixed a problem where the "IS Pattern" was not always working correctly for variables of type USUAL (#636)

Runtime

•Implemented the FoxPro Evl() function (#389)

•DbCloseArea() was returning TRUE even when no area was open. This was incompatible with VO. We are returning FALSE now.(#611)

•Macro compiler was not able to find functions in assemblies that were loaded dynamically (#607)

•When a DBF file was opened "readonly" and then an index was created, then a runtime error would happen when the file was closed, because the RDD was trying to set the "production index" flag in the DBF header. This flag is no longer set for files that are opened "readonly" (#610)

•Fixed an exception (that was caught) inside DbOrderInfo(DBOI_KEYCOUND) (#613)

•Fixed a problem with the Workareas debug window (#625)

•DbOrderInfo() was returning incorrect values when an index was not abailable (#627)

•Fixed a problem with TransForm() and symbol arguments (#628)

•Fixed a problem with the StrZero function (#637)

•Fixed a problem with the AELement() function (#639)

RDD System

•Fixed a problem with indexes on workareas/cursors created with the SqlExec() function when the index expression contained "nullable" fields (#630)

Macrocompiler

•The macro compiler had problems finding functions that were inside an assembly that was loaded later (#607)

Visual Studio Integration

•Fix problem with saving dialect from General Page

•Quick info and Goto definition were not working for members inside the same class when they were not prefixed with SELF:

•Fix code completion for nullable types with the '?' syntax (#567)

•Methods combobox was not correctly synchronized (#602)

•Todo comments were not always parsed correctly, They were also included when they were part of another word or when they were not the first word on the line. This has been fixed.(#617)

•Fix problem that "warnings as errors" was not saved from the Build properties page (#621)

•Fix problems that would start occurring after editor window was split (#641)

•After selecting a member of type "Assign" from the completion list the editor was incorrectly inserting a '(' character (#643)

•Typing '(' on the declaration line of an entity (function, method) would trigger parameter completion. This has been fixed.(#643)

•Parameter tips were not shown for Constructor calls (#645)

•Completion list was incorrectly including static members (#646)

•QuickInfo for external types was not including "AS Type" for the parameters (#647)

•Fixed a problem when resolving parser options for a project that was not yet completely loaded (#649)

•Local variables were not always recognized with their correct type in the editor (#651)

Installer

•The installer was adding an incorrect version of XSharp.CodeAnalysis.dll to the Global Assembly Cache. This has been fixed.

 

Changes in 2.8.0.0 (Cahors)

Compiler

General

•We have migrated to the latest version of the Roslyn source code.

•Passing a typed variable by reference to a function/method with clipper calling convention (untyped parameters) was not updating the local variable. This has been fixed.

•Using the @ operator in a program in the VO Dialect when the /vo7 compiler option is NOT enabled could generate code that produces an error "Cannot be boxed". (#551)

•The generated code for NULL_PSZ and NULL_SYMBOL has been optimized (#398)

•The generated VoStructAttribute on structures and unions had the wrong size when an element with the PSZ type was used. This has been fixed.

•Fixed an internal compiler error when converting NULL to LOGIC

•The _SIZEOF() operator will generate a constant now for VOSTRUCTS and UNIONS. (#545)

•Using a keyword as field name could cause problems. For example FIELD->NEXT was not handled properly. The compiler now allows that. Of course you can also use the @@ prefix to tell the compiler that in a particular case you do not mean the keyword but an identifier.

•Parenthesized expression that contained an expression list were not compiled correctly. This has been fixed.
This could happen when you wanted to have more than one expression as part of an IIF() expression.
 
  LOCAL l AS LOGIC
  LOCAL v AS STRING
  l := TRUE                
  v := "abcd"
  ? iif (l, (v := Upper(v), Left(v,3)), (v := Lower(v), Left(v,4)))              
Since Roslyn (the C# compiler) does not allow an expression list inside a conditional expression, we are converting the parenthesized expression now to a function call to a local function. The expressions inside the Parenthesized expression become the body of the new local function and the compiler calls the generated local function.

•The compiler now warns if you call a Function in a class that has a member with the same name. For example

 

CLASS Test
METHOD Left(sValue as STRING, nLen as DWORD) AS STRING
  RETURN "Test"
METHOD ToString() AS STRING
  RETURN Left("abc",2)   // This will generate a warning that the function Left() is called and not the method Left().
                        // if you want to call the method you will have to prefix the call with SELF:
END CLASS

New language features

•We have added support for LOCAL FUNCTION and LOCAL PROCEDURE statements.
These functions and procedures become part of the statement list of another function, procedure, method etc. They have the following restrictions:

oA LOCAL FUNCTION must be terminated with END FUNCTION, a LOCAL PROCEDURE must be terminated with END PROCEDURE

oThe full "signature" of normal functions is supported, so Parameters, Return type, Type Parameters and Type Parameter constraints.

oThey cannot have Attributes (they are not compiler into methods but in a special kind of Lambda expression)

oThe only valid Modifiers for a local function are UNSAFE and ASYNC

oBecause they cannot have Attributes, we also do not support untyped parameters, so all parameters must be typed

oIf you need a local function with a variable number of parameters then you can define default parameter values or use a PARAMS array

oLocal functions can access local variables from its surrounding code. Roslyn creates a special structure where it stores the variables that are shared between the local function and its surrounding code.

 

•Added support for Expression bodied members. Expression body definitions let you provide a member's implementation in a very concise, readable form. You can use an expression body definition whenever the logic for any supported member, such as a method or property, consists of a single expression. An expression body definition has the following general syntax:
MEMBER => expression
An expression-bodied method consists of a single expression that returns a value whose type matches the method's return type, or, for methods that return void, that performs some operation. For example, types that override the ToString method typically include a single expression that returns the string representation of the current object.
An example of this could be

CLASS MyClass
METHOD ToString() AS STRING => "My Class"
END CLASS
 
The result of this code is exactly the same as
 
CLASS MyClass
METHOD ToString() AS STRING
  RETURN "My Class"
END CLASS
 

So you could say that the => operator replaces the RETURN keyword.

 

•We have added support for the Null Coalescing Operator (??) like C# has as well as the Null Coalescing assignment operator (??=).
This operator does a check for != null. The operator will only work on Reference types so not on value types like USUAL, DATE and the built-in types like INT.

FUNCTION Start() AS VOID
LOCAL s := NULL AS STRING
s := s ?? "abc"           // The ?? is the Null Coalescing Operator
s ??= "abc"               // This is the same as the line before but compacter
? s
RETURN
// So this will not compile
LOCAL i := 0 AS LONG
i := i ?? 42     // Operator '??' cannot be applied to operands of type 'int' and 'int'
// But this will compile
LOCAL i := NULL AS LONG?   // Nullable LONG
i := i ?? 42      

•We have added support for the Properties with INIT accessors. These accessors allow you to assign a value to a property but only in the constructor. The property will be read only outside of he constructor of the class / structure.

•We have added a new compiler option /enforceself. When this option is used then all calls to instance methods inside a class must be prefixed with SELF (or SUPER). In the FoxPro dialect THIS is supported too. Please note that some generated code, such as inside the Windows Forms editor does not use SELF: and applying this compiler option may force you to change the generated code, or may force you to add an #pragma options("enforceself", disable) to the code to disable the option for that file.

•We have added a new compiler option /allowdot. With this option you can control if the DOT (".") operator is allowed to be used to access instance members. The default for the Core and FoxPro dialect is /allowdot+. The default for the other dialects is /allowdot-. You can also use this with a #pragma: #pragma options("allowdot", enable)

•XML comments in the source code no longer require fully qualified cref names (#467)

Preprocessor

•The preprocessor now automatically declares a match marker with the name <udc>. This match marker will contain all the tokens that were matched with the UDC by the preprocessor. This can be used for example to add the original source as string to the result:
#command INSERT INTO <*dbfAndFields*> FROM MEMVAR => __FoxSqlInsertMemVar(<"udc">)

•Wildcard markers (such as the dbfAndFields marker in the previous bullet) now can also appear in the middle of a UDC. They will continue to match until the first token after the Wildcard marker (in the above example the FROM keyword) is found.

•The standard header files (from the XSharp\Include folder) are now also included in the compiler as resource. When the file is missing then these files will be loaded from the resource.

•The preprocessor was not generating macros for __FOX2__ . This has been fixed (but it is now obsolete, see the FoxPro dialect)

•When wildcard tokens are included with a stringify result marker then the white space between these tokens is correctly included in the output of the UDC.

FoxPro dialect

•The feature to allow parentheses as array delimiters for the FoxPro dialect that was added in the previous build had too many side effects. We have removed this feature for now. You have to use bracketed array arguments again.

•The /fox2 compiler option is no longer needed (and ignored by the compiler).
The compiler now checks to see if a runtime function is marked NeedsAccessToLocalsAttribute, which is defined in the XSharp.Internal namespace.
If the compiler finds a function that is marked with this attribute, such as the Type() function or the SQLExec() function then it will add some code before and after the function call to allow these functions to access the locals on the stack. This will only happen if the /memvar compiler option is enabled and only in the FoxPro dialect.
The NeedsAccessToLocalsAttribute has a mandatory parameter which indicates if a function is expected to write to the locals or only read the locals.
When the function is expected to write to locals then the compiler will generate extra code after the call to make sure that the locals are updated when needed.

•We have added a standard header file for the FoxPro embedded SQL statements. This header file should parse embedded SQL but will output warnings that the embedded SQL is not yet supported.

•We have added the FoxPro array support, with a special subtype of the Array type in the runtime and support for DIMENSION and (Re)DIMENSION and filling arrays by assigning a single value. (#523)

Runtime

General

•Fixed a problem with the return value of FSeek() and FSeek3()

•AsHexString() and AsString() were not displaying the same result for PTR values as Visual Objects.

•Fixed a problem with SetScope() for the DBFCDX RDD when the previous scope was empty. (#578)

•Adjusted the Secs() function to make it more Visual Objects compatible.

•The enumerator for Array and Array Of now returns an enumerator for a clone of the internal data, to prevent runtime errors when you are modifying the array from within your code.

•The various Xbase types (DATE, FLOAT, CURRENCY, BINARY, ARRAY, USUAL etc.) are now marked with a [Serializable] attribute and implement ISerializable. They all work fine with the BinaryFormatter() classes, since that class not only stores the values but also the values in the stream. Most of the types also work with the JsonSerializer, however not all of values can be correctly deserialized with the Json serializers. (#529)

•The CompareTo() operator on the Date type was not sorting the values correctly because it was making an incorrect assumption about the memory layout of the elements in the structure. This has been fixed.

•We have made some changes in the error handling for functions such as DbUseArea() and DbSkip(). They were not always behaving the same as Visual Objects when an error occurs (for example when a file could not be opened). We have now also added an error handler similar to the default error handler in Visual Objects with a dialog that has the Abort, Retry and Ignore buttons. The Retry button is only enabled when the error object has the property "CanRetry" set to TRUE. (#587, #594)

•Fixed Val() incompatibility with string that has more than one decimal place (#572)

•Fixed a problem with comparing dates "in reverse" (#543)

•We have added a couple of functions that bring up dialogs to display the current open workareas, settings, globals and private and public memory variables. See DbgShowGlobals(), DbgShowWorkareas(), DbgShowMemvars() and DbgShowSettings()

RDD system

•DbCommit and DbCommitAll were failing when a workarea is opened Read only. This has been fixed. (#554)

•When FoxPro CDX file has more than one tag and one of the tags has an invalid index expression (for example a missing closing parenthesis, which was accepted by Visual Objects) then the RDD system did not open the CDX at all. We now open the CDX with the exception of the tag with the corrupted index expression. (#542)

•Added support for Advantage GUID and Int64 columns. GUIDs are returned as string and INT64 as INT64. We have also added some missing DEFINE values from the ACE header file.

•Fixed a problem with incorrect negative Lock Offsets in the DBFNTX driver.

•We have fixed several "exotic" problems with index "information" (KeyCount, KeyNo) etc. with indexes with Scopes, Descending indices etc. (#423, #578, #579, #580, #582, #583, #593, #599)

•Fixed problems when opening MEMO files (Fpt and DBT) from different threads and different workstations (#577)

•We have fixed a locking and corruption problem that could occur when 2 stations were frequently writing to the same CDX file. (#575, #592)

•Improved Locking Speed when a lock fails. (#576)

•SetOrder(0) was not working for ADS tables (#570)

•Changed several method prototypes for ADS to have the correct IN / OUT modifiers (#568)

Macro Compiler

•Fixed a problem in the FoxPro dialect assigning a value to an expression in the form of VariableName.PropertyName

•The X# macro compiler was allowing to reference GLOBAL and DEFINE values in macros. This made the compiler incompatible with VO and this would cause problems when indexing on a field with the same name as a GLOBAL or DEFINE. The support to reference GLOBALs or DEFINEs has been removed from the macro compiler. (#554)

•The Macro compiler had a problem with a variable name was surrounded with parentheses. It was seeing that as a typecast. This has been fixed. (#584)

Visual Objects SDK

•Added some missing defines to the Win32APILibrary assembly, such as DUPLICATE_SAME_ACCESS.

•DbServer:Filter was sometimes returning NIL instead of an empty string (#558)

 

VO Dialect

•We have added support for SysObject (#596)

Xbase++ dialect

•Fixed a problem with XPP Collation tables that was introduced in 2.7

FoxPro dialect

•Added the NeedsAccessToLocalsAttribute for the /fox2 compiler option

•Adjusted the code that exposes the values of LOCAL variables to functions such as Type() and SqlExec().

•Several functions have been marked with the new attributes so they will be able to "see" local variables.

•Added an overload of TransForm() with a single argument.

•Fixed a problem with the SQLExec() function and sql statements that contain a ":" (colon) character.

•We have added the Bit..() functions (thanks Antonio)

•We have added CapsLock(), NumLock() and InsMde (hanks Karl-Heinz)

•We have improved the FoxPro array code (#523)

 

Runtime Scripting

This build introduces Runtime Scripting through the ExecScript() function. At this moment you will have to include the Full macro compiler (XSharp.MacroCompiler.Full.dll) and its support DLLs (XSharp.Scripting.dll , XSharp.CodeAnalysis.dll ) if you use Runtime scripting,

We are working on a light weight version of the Runtime Scripting which will be included in one of the next builds.

See the topic Runtime Scripting for more information.

Visual Studio Integration

The Visual Studio integration in this build no longer supports Visual Studio 2015. Only Visual Studio 2017 and 2019 are supported.

General

•New code templates in a subfolder were generated with a namespace name that starts with "global::". This has been fixed.

•Added support for LOCAL FUNCTION and LOCAL PROCEDURE.

•Adding an item from the Class template in a folder prefixed the namespace with "global::". This has been fixed.

•When the intellisense database file on disk was corrupted then an error occurred. Now the file is deleted and all code information is collected again.

•The Editor options in the Tools/Options dialog are now marked with "X#" and no longer with "XSharp".

•We have added a window under Tools/Options where you can set several values for our VO compatible editors, such as the grid size, paste offset etc. Look for X# in the tools options dialog.(#279, #440)

•We have added 2 new options to the formatting options for the editor: "Trim Trailing Whitespace" and "Insert Final Newline"

•Loading a MsTest project did not always work. The project file for MsTest projects will be adjusted when opening the project. (#563)

•We have added support for t4 templates (text files with a .tt extension containing scripts to generate code)

•Adding an existing  .resx file did not make it a child of a parent form.prg (#197)

•The project property dialogs have been completely redesigned.

 

Source code editor

•Longer QuickInfo tooltips are now shown over multiple lines to make them easier to read.

•Refactored the "type lookup" code to improve the speed of the source code editor

•Member completion in the source code editor was not always working for variables declared with the VAR keyword where there were nested curly braces and/or parentheses. (#541, #560)

•Fixed a problem with member completion for project references (#540)

•Fixed an exception when uncommenting a block of lines when one of the lines in the block was an empty line.

•We have added support for .editorconfig files. See the chapter about .editorconfig files in the documentation file.

•Collapsing the last entity om the editor did not work correctly (#564)

•Fixed a problem with syntax highlighting after line continuation comments(#556)

•Added parameter completion for delegates (#581)

•Fixed a problem with certain cyrillic characters in QuickInfo tooltips (#504)

 

Code generator

•Character literals are now always prefixed with the 'c' prefix and values > 127 are written in Hex notation to make sure they work in all codepages.

Windows Forms Editor

•We have fixed several issues with DevExpress controls.

•Fixed a problem with a control that has the same name as a X# keyword (#566)

•Fixed a problem with a control that has a property of type DWORD (#588)

•Fixed a problem with the code generation for character literals (#550)

•The .designer.prg no longer has to have the "INHERIT FROM " clause. (#533)

Object Browser

•Goto definition was not working when you had performed a search first (#565)

VO Compatible Forms editor

•Added support in the WED for correctly visually displaying custom controls that do not have the expected control class inheritance defined

•Fixed a problem with custom controls in cavowed.inf not recognized that are not data aware

•Added support for Cloning Windows (#508)

•Fixed a problem with the display of Checkboxes (#573)

•Fixed a problem with the code generation (#553)

•There is a menu option in Tools/Options to set several settings (#279, #440)

Debugger

•The debugger now fully supports 64 bits debugging

•Added support for the new type names for CURRENCY and BINARY

Templates

•We have made adjustments to several VS item templates and project templates (#589)

•We have added a new X# t4 template (.tt file)

 

Changes in 2.7.0.0 (Cahors)

Compiler

General

•Fixed a problem with Nullable types that were missing an explicit cast for an assignment

•Fixed a problem with calling a parent constructor in a class hierarchy where a parent level was being skipped and the constructor for the grandparent was called instead.

•The /usenativeversion commandline option was not checking +/- switches. This has been fixed.

•Fixed a problem with PCall() and PCallNative() in source files with an embedded DOT in the filename (my.file.prg)

•We have added a new header files to the files in the XSharp\Include files that helps to add custom User Defined Commands or defines that you want to include in every project. This file (CustomDefs.xh) will be automatically include by our XSharpDefs.xh.
The default contents of this file is just some comments.
The installer will NOT overwrite the file in this folder and will not delete it when the product is uninstalled.
You can choose to customize this file in the Include folder under Project Files. However you can also add a file with the same name to your project folder or to a common include folder for your project/solution. That last location allows you to keep the header file under source code control with the rest of your source code.

FoxPro dialect

•The compiler now allows a M Dot (M.) prefix in LOCAL, PRIVATE and PUBLIC declarations. (LOCAL m.Name)

•The compiler now also accepts parentheses as array delimiters in the Foxpro Dialect (aMyArray(1,2))

•The compiler now allows (and ignores) AS Type OF Classlib clauses for PRIVATE, PUBLIC, PARAMETERS and LPARAMETERS declarations.

•Support for TO keyword in CATCH clause of TRY CATCH

•Added support for the ASSERT command and SET ASSERT

•Added support for SET CONSOLE and SET ALTERNATE

•Assignments to macros with a single equals operator were not working ( &myVar = 42). This has been fixed.

•Added support for zero length binary literals (0h)

Build System

•Added a project property to control if RC4005 errors (duplicate defines) should be suppressed for the Native Resource compiler

Runtime

General

•IsMethod() now returns TRUE for overloaded methods.

•AbsFloat() was "losing" the settings for # of decimal places. This has been fixed.

•Binary:ToString() was using single digit numbers for binary values < 15. This has been fixed.

•Added an implicit operator to assign a usual to a binary.

•Added an implicit conversion for USUAL values that contain an integer to an Intptr.

•Some low level functions now set the OS error number  FERROR_EOF when operations fail, just like in VO.

•Exceptions in late bound code were not always showing the correct location where the error occurred. This has been fixed.

•We have added support for DataSessions. The list of open workareas/cursors in the runtime is now called "DataSession" (the old name Workareas is still available).
You can have multiple datasessions. You can also swap the "active" DataSession in the RuntimeState with a new method SetDataSession on the RuntimeState class.
FoxPro databases are opened in their own datasession.
You can inspect the open DataSessions in the debugger by adding the watch expression: XSharp.RDD.DataSession.Sessions
Each DataSession is associated with a Thread. When the Thread is stopped or aborted then the DataSession will be closed, which also closes all of its tables.
At program shutdown all DataSessions are closed including their tables. This is done through an AppDomain:ProcessExit event handler.

•Low level File IO functions (including the RDD system) that open a file in Exclusive mode now use "buffered IO". This should result in faster performance.

•The (undocumented) functions to convert a Stream from/to a MemoryStream have been removed. This is replaced with the buffer I/O from the previous bullet.

•We have added System.Enum types for the FoxPro CursorProperties, DatabaseProperties and SQLProperties.

•We have added a DatabasePropertyCollection type. This type is used to add "additional" properties to Fields, such as the DBF fields for FoxPro tables.

Terminal API

•We have added support for Alternate files. SET ALTERNATE TO SomeFile.txt. Also SET ALTERNATE ON and SET ALTERNATE OFF

•The ? statement now respects the sessions for Set Console and Set Alternate .

•We have added support for the SET COLOR command. Only the fist color in the settings is used and the blink attribute is ignored and interpreted as "highlight". For example SET COLOR TO w+/b

•We have added a CLEAR SCREEN command

FoxPro dialect

•Added an Assert dialog

•Added support for DBC files. This includes the SET DATABASE to commands, DbGetProp() and reading properties for files that are part of a database without explicitly opening the database first. DbSetProp() does not do anything yet. Also functions like DbAlias() and similar have been implemented.

•The Runtime now works with DataSession object. The DBC files are opened in their own datasession as well of the files per thread. Each datasession has a list of open tables and a unique list of aliases and cursor/workarea numbers.

•AutoIncrement columns in cursors returned by SqlExec() now have a numbering scheme that starts with -1 and subtracts 1 for every new row added.

•Several settings needed for the FoxPro dialect have been added to the Set Enum.

Macro Compiler

•Until now the macro compiler was producing runtime codeblocks that take an array of objects and return an object return value. There was a class in the runtime that wrapped this and took care of usual -> object conversion for the parameters and for object-> usual conversion of the return value. This caused a problem when macros were returning a NIL value because that was converted to NULL_OBJECT.
The reason for the OBJECT API is that the macro compiler needs to be used in the Core dialect (in the RDD system) and this dialect does not support the USUAL type.
We have now added a new IMacroCompilerUsual interface in the XSharp.RT assembly that allows you to compile a string into a codeblock that supports USUAL arguments and a USUAL return value. The macro compiler now supports both this interface as well as the 'old' interface. As a result you may see a (very small) performance improvement when compiling macros.

•Calling Altd() and _GetInst() inside a macro was not supported. This has been fixed.

•The macro compiler was reporting an error when you had overridden a built-in function in your own code. We have now implemented a default MacroCompilerResolveAmbiguousMatch delegate in the runtime that now gives preference to functions that are defined in your code over functions in our code.

•When choosing between 2 overloads of a method or function the Macro compiler now chooses the method with a USUAL parameter over a method without a USUAL parameter

•Fixed a problem with calling functions/methods with a parameter by reference or an out parameter

•Added support for the CURRENCY and BINARY types to the macro compiler.

RDD System

•Exclusive DBF access now works in "buffered" mode which should make it a lot faster

•Internally the RDDs now work with the Stream objects, which makes it a bit faster.

•Fixed a problem when updating a key in an index where many duplicate key values existed.

•Removed duplicate Foxpro "machine" collations for several codepages, since they were all the same.

•For VFP compatible DBF files with field names > 10 characters you can now use the short (10 char) or the full fieldname to retrieve the values.

•The DBFVFP driver now uses the built in DBC support in the runtime to read "extended" properties for DBF files. These properties are the longer fieldname, but also the Caption etc. When a DBFVFP table is used as datasource for a DbDataSource or DbDataTable and when this data source is assigned to a Grid then the columns headers in the Grid should show the Captions from the DBC.

•DBF files with an empty codepage byte are now opened as DOS - US just like in VO and Vulcan.

•GoTop(), GoBottom() and other operations were failing for when a DBFCDX/DBFVFP area was a child in a SetRelation and when the previous parent value was resulting in an "empty" resultset.

•We have added structures and functions for the ADS Management API to the RDD assembly.

Visual Studio integration

•When creating a new VO compatible UI form in the VS IDE you can now clone an existing form.

•Fixed some problems with custom controls in the VO compatible form editor.

•Fixed several problems in the Windows Forms editor for the code parsing and code generation for DevExpress controls

•Solutions with "flavored" projects (such as MsTest projects) were not always opened correctly. An exception could occur.

•We have added an (internal) property FieldValues() to the workarea class that allows you to inspect the fieldnames and their values for the current record in the debugger. To see the current workarea in the debugger you have to add a watch expression: XSharp.RuntimeState.DataSession.CurrentWorkarea

•Added Project property to set the new flag to suppress RC4005 (duplicate defines) errors for the resource compiler.

 

Changes in 2.6.1.0 (Cahors)

This is a bug fix release with fixes for some issues found in 2.6.0.0

Compiler

•Fixed problems with passing typed variables by reference to late bound code and to untyped constructors

•Fixed an internal compiler error in code where a define containing a logic was cast to a byte
  BYTE(_CAST, LOGICDEFINE).
Of course this is code that should be avoided at all times, but unfortunately even the VO SDK is full of code like this..
The example above should be written as IIF(LOGICDEFINE, 1,0) for example. The compiler will see that the define is constant and will replace that code with either 1 or 0.

•The compiler was not recognizing $.50 as a valid Currency literal (because the 0 is missing). This is now accepted.

Runtime

•Updated the code in the runtime that handles late bound calls to improve the handling of parameters by reference

•Fixed a problem in late bound code when accessing properties such as fInit, dwFuncs and dwVars in the OleAutoObject class

•Added operator TRUE and operator FALSE to the Usual type

•Calling Val() with a NULL_STRING could cause an exception. This has been fixed.

•String properties returned by DbDataTable() and DbDataSource() are now trimmed with the TrimEnd() method of the string class.

•Added a DbTableSave() function to save changes in a DbDataTable to the current workarea.

Visual Studio integration

•Opening and upgrading project files that are under Scc could sometimes cause problems. This has been fixed

•Fixed a regression introduced in 2.6.0.0. causing the task list to no longer be updated.

•Opening a solution that referenced X# projects that do not exist on disk could cause an exception. This has been fixed.

•Opening a X# Project file that is not part of a solution could also cause an exception. This has been fixed. We'll assume the project is part of a solution file in the same folder as the project and with the same name (but different extension) as the project.

•The project system no longer makes backup files of projects that are updated. We assume you're all making backups yourself or using some kind of SCC system.

•Fixed a regression that caused the VS Tasklist not to work for X# projects.

 

Changes in 2.6.0.0 (Cahors)

Please note that there are some breaking changes in this build.
Therefore the Assembly version number of the Runtime Components has been changed and you will need to recompile all your code and you need new versions of 3rd party components!

Compiler

•The compiler was ignoring a (USUAL) cast. This has been fixed.

•When the compiler detects a TRY .. ENDTRY without CATCH and FINALLY then it automatically adds a CATCH class that catches all exceptions silently. This was already the case, but we now generate a warning XS9101 when this happens.

•Passing parameters by reference with an @ sign was not working correctly for late bound method calls. This has been fixed.

•Compiler option vo15 and compiler option vo16 can now also be set with a #pragma

•When /vo16 (Automatically generate Clipper calling convention constructors) was enabled then the compiler was also adding constructors to classes that are marked with the [COMImport] attribute. This has been fixed.

•Currency literals ($12.34) were not compiled into the Currency type but were stored as System.Double. This has been fixed.

•Fixed a problem with automatic version number generation for version numbers that are specified as [assembly: AssemblyVersion ("1.0.*")] or [assembly: AssemblyVersion ("1.0.0.*")].
If you are building with the /deterministic compiler option then an error message XS8357 is shown.

•Fixed a problem when passing a single USUAL argument to a constructor with a parameter array.

•Fixed a problem when calling an overloaded method in a class tree where one level has a parameter of one type and another level the same method name but a parameter of another type and when there is an implicit typecast from the one type to the other (like between Date and Datetime, or between String and Symbol). The compiler now first looks to see if there is an overload with exactly the same type and where there is not then it looks for overloads for which the argument can be passed with an implicit conversion.

•The __CastClass() pseudo function can now be used to box a usual into an object or to unbox a usual from an object.
__CastClass(USUAL, <objectValue>) unboxes the usual that is inside the object.
__CastClass(OBJECT, <usualValue>) boxes the usual into an object.

•The <usualValue> IS SomeType VAR <newVariableOfTypeSomeType> clause was boxing the Usual into the Object before assigning it to the new variable instead of extracting the object from the usual. This has been fixed.

•Late bound assignments (such as obj.&prop = "Jack") were failing when the assignment operator was a single equals character. This has been fixed.

•Aliased Expressions such as SomeArea->(SomeExpression()) were returning an error on the incorrect source code line when SomeArea was not open. This has been fixed.

•We have added support for the BINARY type and BINARY Literals. See the topics about binaries and binary literals in the documentation.

•Expressions such as
       LOCAL dwDim := 512 IS DWORD
were parsed as and compiled into
       LOCAL dwDim := (512 IS DWORD) AS USUAL
As a result dwDim contained a USUAL with a LOGICAL value.
This has been fixed and this code will now throw an error that DWORD variables cannot be declared with the IS keyword.
This also happens for GLOBAL variables and Class Variables.

•We have added a MatchLike preprocessor token to match expressions that contain wildcard characters, such as in the UDC
SAVE ALL LIKE a*,*name TO SomeFileName.
The token to use for MatchLike is <%name%>

•Added support for pattern matching (WHEN clauses) in TRY .. CATCH statements, such as in the example below. The WHEN keyword is positional, so it can also be used as a variable name like in the example.

FUNCTION Test AS VOID
  local when := 42 as long
  TRY
    THROW Exception{"FooBar"}
  CATCH e as Exception WHEN e:Message == "Foo"
     ? "Foo", when, e:Message
  CATCH e as Exception WHEN e:Message == "Bar"
     ? "Bar", when, e:Message
  CATCH WHEN when == 42
     ? "No Foo and No Bar", when
     
  END TRY                
  RETURN

•Added support for pattern matching and filters for SWITCH statements. We support both the "Identifier AS Type" clause as well as the "WHEN expression" filter clause, like in the examples below

  VAR foo := 42
  VAR iValues := <LONG>{1,2,3,4,5}
  FOREACH VAR i IN iValues
    SWITCH i
    CASE 1                       // This is now called the 'constant pattern'
        ? "One"
    CASE 2 WHEN foo == 42         // Filter with a constant pattern
        ? "Two and Foo == 42"
    CASE 2
        ? "Two"
    CASE 3
        ? "Three"
    CASE 4
        ? "Four"
    OTHERWISE
        ? "Other", i
    END SWITCH

VAR oValues := <OBJECT>{1,2.1,"abc", "def", TRUE, FALSE, 1.1m}
  FOREACH VAR o in oValues
    SWITCH o
    CASE i AS LONG         // Pattern matching
        ? "Long", i
    CASE r8 AS REAL8   // Pattern matching
        ? "Real8", r8
    CASE s AS STRING WHEN s == "abc" // Pattern matching with filter
        ? "String abc", s
    CASE s AS STRING     // Pattern matching
        ? "String other", s
    CASE l AS LOGIC   WHEN l == TRUE   // Pattern matching with filter
        ? "Logic", l
    OTHERWISE
        ? o:GetType():FullName, o
    END SWITCH
  NEXT

•Please note that the performance of these patterns and filters is just like normal IF statements or DO CASE statements.
The difference is that the compiler checks for duplicate CASE expressions so you are less likely to make mistakes.

•We have added support for the IN parameter modifier. This declares a parameter that is a REF READONLY parameter. You could consider to use this when passing large structures to methods or functions. Instead of passing the whole structure then the compiler will only pass the address of the structure which is 4 bytes or 8 bytes depending on if you are running in 32 bits or 64 bits.
We are planning to use this in the X# runtime for functions that accept USUAL parameters which should give you a small performance benefit (Usual variables are 16 bytes in 32 bits mode and 20 bytes when running in 64 bit mode).

Runtime

•Error messages in Late Bound code were not always showing the error causing the exception. We now retrieve the "inner most" exception so the message shows the first exception that was thrown.

•We have added runtime state settings for Set.Safety and Set.Compatible and the functions for SetCompatible and SetSafety

•A UDC used to save and restore workareas for various Db..() functions was incorrect, causing the wrong area to be selected after the function call. This has been fixed.

•The VFP MkDir() function has been added.

•Fixed a problem in late bound IVarGet() / IVarPut() when a subclass of a type implements only the Getter or the Setter and the parent class implements both.

•We have added a IDynamicProperties interface and added an implementation of this on the XPP DataObject, VFP Empty and VO OleAutoObject classes. This interface is used to optimize late bound access to properties in these classes.

•An Exception in OleAutoObject.NoMethod was not forwarded "as is" but as an argument exception.

•The Select() function now behaves differently in the FoxPro dialect to be compatible with FoxPro (no exception is thrown when the alias that is passed does not exist)

•When an Error object is created from an exception then the innermost exception is used for the error information.

•The casing of the Default() function has changed.

•We have added a new XSharp.__Binary type. See the compiler topic above for more information.

•We have added the CLOSE ALL UDC to dbcmd.xh as synonym for CLOSE DATABASES.

RDD System

•Fixed a problem in the Advantage RDD for the ADSADT driver when field names were > 10 characters.

•In the Advantage RDD the EOF, BOF and FOUND flags for tables that are a child in a relation were not properly set. This has been fixed.

•In the FoxPro dialect the 'AutoOrder' behavior has changed. In this dialect no longer the first order in the first index is selected. The index file is opened but the file stays in natural order and when opening the file the cursor is positioned on the record number 1.

•When exporting to CSV and SDF there was an exception for empty dates. This has been fixed.

•When an CDX is opened for which one of the order expressions could not be compiled (because a function is missing) then previously the complete CDX was ignored. Now the other tags are opened succesfully. The RuntimeState.LastRddError property will contain an Exception object that contains the error message for the tag that failed to open.

•The calculation of Index keys for fields of type "I" (in the DBFVFP driver) was incorrect. This has been fixed.

•Fixed a problem with the OrdDescend() function/

Visual Studio integration

•Fixed a problem in the VS parser for default expressions in parameter lists

•Parameters for external methods/functions were not always showing the right "As"/"Is" modifiers

•The location on the QuickInfo tooltip is now shown on its own line inside the tooltip.

•Fixed a problem where the XML tooltips or parameter tips for the first member in a XML file were not shown.

•We have made a change to the project file format (see comment below). All project files will be updated when opened with this build of X#.

•Improved the speed of closing a solution inside Visual Studio.

•The project system will no longer try to update SDK style project files.

•When looking for a method such as Foo.SomeMethod() the codemodel sometimes returned a method Bar.SomeMethod().
This was leading to problems when opening forms in the Windows Forms editor. This has been fixed.

VO Compatible editors

•Code generated from the VO Compatible editors now preserves the INTERNAL or other modifiers as well as IMPLEMENTS clauses for classes.

•We have fixed the display of "LoadResString" captions in PushButton controls

Foxpro commands

•We have added support for several new Foxpro compatible commands:

•CLOSE ALL

•SCATTER

•GATHER

•COPY TO ARRAY

•APPEND FROM ARRAY

•COPY TO  SDF|CSV|DELIMITED|FOXPLUS|FOX2X

•APPEND FROM SDF|CSV|DELIMITED|FOXPLUS|FOX2X

•All variations support a fields list, FIELDS LIKE or FIELDS EXCEPT clause and the relevant commands also support the MEMO and BLANK clauses.

•Not all variations from COPY TO and APPEND FROM are supports, such as copying to excel and sylk

•The Database and name clause in the COPY TO command are ignored for now as well as the CodePage clause

Build System

•We have prepared the X# Build System to work with SDK type projects that are used by .Net 5 and .Net Core. See the topic below for what this means for the project files.

•Please note that the source code for the Build System has been moved to the Compiler repository on GitHub, since the build system is also needed for automated builds that run outside of Visual Studio.

Changes to project files

•We are now no longer deploying our MSBuild support to a folder inside each VS version separately but we are only deploying it once in a folder inside the XSharp installation folder.
The installer sets an environment variable XSharpMsBuildDir which points to that folder. As a result all project files will be updated when opened with this version of X#.

•The change that we make is that the macro "$(MSBuildExtensionsPath)\XSharp" is replaced with "$(XSharpMsBuildDir)" which is an environment variable that points to the location of the X# MsBuild support files on your machine. If you are running X# on a build server you can set this environment variable in your build scripts when needed.

•The installer automatically adds this environment variable and points it to the <XSharpDir>\MsBuild folder.

 

Changes in 2.5.2.0 (Cahors)

Compiler

•When a define contains an expression that contains the _Chr() function with a value > 127 then a warning is generated about possible code page differences between the development machine and the end users machine

•Fixed an issue where a define was defined as PTR(_CAST,0)  and this define was also used as a default value for a function/method.

Runtime

•Calling IsAccess, IsAssign and similar methods on a NULL_OBJECT was causing an exception. This has been fixed.

•EmptyUsual now also works for the type OBJECT

•When a float division was returning an Infinite value then no divide by zero exception was generated. This has been fixed.

•When a parameter is skipped in a late bound call, and when that parameter has a default value, then we will now use the default value instead of NIL

•The default value of the 5th parameter (uCount) of StrTran() was "only" 65000 replacements. The default value now takes care of replacing all occurences.

•The variable name passed to NoIVarGet() and NoVarPut() is now converted to Uppercase.

RDD System

•Fixed a problem with skipping forward when a Scoped Descending Cdx was at Eof()

VOSDK

•Several DbServer methods were calling a method to write changes before the correct workarea was selected. This was an old bug originating in VO and has been fixed.

Visual Studio integration

•Looking up XML documentation was sometimes not working in VS 2019. This has been fixed.

•ClassView and Objectview are working "somewhat" now. This needs to be improved.

•Improved the loading of so called "Primary Interop Assemblies"

•Fixed a problem in the Type and Member dropdown bars in the editor window

•Improved the renaming of controls when applying copy/paste in the VO Compatible window editor.

•The X# toolbar for the VO Window editor is now automatically visible when the VO Window editor is opened

•The position and size of the property window and toolbox of the VO Window editor (and the other VO Editors) is now saved between sessions of Visual Studio.

Build System

•The generated XML files were generated in the project folder and not in the intermediate folder. This has been fixed.

Documentation

•The [Source] links were missing for most topics. This has been fixed.

•Corrected some docs

 

Changes in 2.5.1.0 (Cahors)

Compiler

•no changes to the compiler in this build (it is still called 2.5.0.0)

Runtime

•(VO Compatibility) Fixed a VO compatibility issue for arrays . Accessing an single dimensional array with an index with 2 dimensions now returns NIL and does not generate an exception. This is stupid but compatible.

•(VO Compatibility) Comparing a usual with a numeric value with a symbol no longer generates an exception. The numeric value is now casted to a symbol and that symbol is used for the comparison.

•(XPP compatibility) Accessing a USUAL variable with the index operator (u[1]) is not allowed for usuals containing a LONG. This will return TRUE or FALSE and is a simple way to check if a bit is set.

•The Literals for "DB" and "CR" are now stored in the resources and may be changed for other languages.

•Added some optimizations to the support code for late binding

Visual Studio integration

•Reading type information for external assemblies would fail when the external assembly contained 2 types for which the names were only different in case.

•The entity parser did not recognize GET and SET accessors that were prefixed with a visibility modifier (PROTECTED SET)

•The entity parser did not recognize ENUM members that did not start with the MEMBER keyword

•Added support for the Visual Studio Task Window. Source code comments containing the words TODO or HACK (this is configurable in the Tools/Options window) are now added to the Task List. These tasls are persisted in the intellisense database, so all tasks are immediately visible after opening a solution without (re)scanning the source files.

•Fixed a problem in the Type and Member lookup for the WIndows Forms editor

•Fixed a problem in the VS debugger where we were subtracting one from index operators for arrays and collections. This was not correct (obviously).

Build System

•The file name of the generated XML file was derived from the project file name instead of the output assembly name. This has been fixed.

 

 

Changes in 2.5.0.0 (Cahors)

Compiler

•#pragma lines that were followed by incorrect syntax would "eat" the incorrect syntax causing entire methods to be excluded from compilation. This has been fixed.

•Multiline compile time codeblocks in a method /function with a VOID return type were not being compiled correctly. This has been fixed.

•The compiler now allows to type the parameters in a codeblock. Since the codeblock definition requires parameters of type USUAL this gets transformed by the compiler. The parameters will still be of type USUAL, but inside the codeblock a local variable of the proper type will be allocated. So this compiles now

  { | s as string, i as int| s:SubString(i,1) }

•The code to fill in missing parameters was causing problems when passing parameters to COM calls (Word Example from Peter Monadjemi)

•Fixed a problem passing an IntPtr, Typed pointer of the address of a VOSTRUCT to a function that accepts an object.

•We have added code to add an integer value to a PSZ, which results in a new PSZ that starts at a relative location in the original PSZ. No new buffer is allocated.

•We have fixed a problem with complex collection initializers.

•Chr() and _Chr() with an DEFINE as argument, such as _Chr(ASC_TAB) were not properly resolved by the compiler.

•The compiler was not properly parsing the syntax PUBLIC MyVar[123]. This has been fixed.

•Some special characters (such as the Micro Character, U+00B5) were not recognized by the compiler as valid identifiers. We have now adopted the same identifier rules that C# uses.

•Passing a pointer or PSZ in a value of type OBJECT is now handled by "boxing" the variable. So a NULL_PTR is no longer passed as NULL_OBJECT but as an object containing an IntPtr.Zero value.

•The compiler now allows to store IntPtr.Zero to a constant variable

•The compiler now allows to embed quotes inside a string by writing double quotes. So this works:

? "Some String that has an embedded "" character"

•When you declare a MEMVAR with the same name as a function, the compiler will now have no problem anymore resolving the function call. Please note that you HAVE to declare the memvar for this resolution to work.
For example

 
 FUNCTION Start() AS VOID
 MEMVAR Test
 Test := 123     // assign to the memory variable
 Test(Test)     // call the function 'Test' with the value of 'Test'
 RETURN
 FUNCTION Test(a)
 ? a
 RETURN a

 

 

Common Runtime

•The Workareas class no longer has an array of 4096 elements, but uses a dictionary to hold the open RDDs. This reduces the memory used by the runtime state.

•Fixed a problem in the WrapperRDD class

•OrdSetFocus() now returns the previous active tag as STRING

•Fixed a problem in FRead() , it was not ignoring the SetAnsi() setting as it should

•Added operators on the PSZ type for PSZ + LONG and PSZ + DWORD.

•The Usual class now implements the IDisposable() interface. When it contains an object that implements IDisposable then it will call the Dispose method on that object.

•We have added Array index properties with one and two numeric indices to make code that accesses array elements a bit faster

•The code SELECT 10, was not working properly. This has been fixed. Thanks Karl Heinz.

•The return value of VoDbOrdSetFocus() was TRUE even when trying to set the order to a non existing index. This has been fixed.

•We fixed a problem with Set(_SET_CENTURY) when the parameter passed was a string in the "ON" or "OFF" format

•VODbOrdSetFocus() was returning TRUE even when the selected order could not be selected.

•ArrayCreate<T> was not filling the array. This has been fixed.

•Trailing or Leading spaces are now ignored by the CToD() function.

•Calling VoDbSeek() with 2 parameters now does not set lLast to FALSE but to the LAST value from the Current Scope.

•In the previous build the format for the stack trace for errors was changed (the names are all uppercase like in VO). You can now choose to enable or disable this. We have added a function SetErrorStackVOFormat() that takes and returns a logical value. The default format for the error stack is the VO format for the VO and Vulcan dialects and the normal .Net format for the other dialects.

•We have implemented the StrEvaluate() function.

•We have implemented the PtrLen() and PtrLenWrite() functions. These only work on the Windows OS() when running in x86 mode.
For other OSes or for apps running in 64 bits these functions returns the same value as MemLen().

•When dividing 2 float numbers results in a NaN (Not a Number) value because the divisor is zero, then a DivideByZero exception will now be generated.

•When dividing 2 usual numbers results in a NaN (Not a Number) value because the divisor is zero, then a DivideByZero exception will now be generated.

•Please note that dividing 2 REAL8 (System.Double) values can still result in a NaN, because we are not "intervening" with this division.

•The OS() function now returns a more appropriate version description when running on Windows. It reads the version name from the registry and also includes a x86 and x64 flag in the version.

RDD System

•The DBF RDD Now forces a disk flush when writing a record in shared mode.

•Fixed a problem in the DBFCDX rdd that could corrupt indexes.

•We have built in a validation routine inside the DBFCDX RDD that validates the integrity of the current tag. To call this routine call DbOrderInfo with the DBOI_VALIDATE constant.
This will validate:

▪If all records are included exactly once in the index

▪If the values for each record in the index are correct

▪If the order of the index keys in a page is correct

▪If the list of index pages in the index is correct

When a problem is found then this call returns FALSE and a file will be written with the name <BagName>_<TagName>.ERR containing a description of the errors found.

•Most exported variables inside the Workarea class (inside XSharp.Core) and other RDD classes have been changed to PROTECTED.
We have also added some properties for variables that need to be accessed from outside of the RDD

•Fixed a problem that occurred when skipping back repeatedly from the BOF position in a scoped CDX index.

•The Zap() operation for DBFCDX was not clearing one of the internal caches. This has been fixed.

•The DBFCDX driver now closes and deletes a CDX file when the last tag in that CDX has been deleted.

Macro compiler

•The macro compiler was not recognizing 0000.00.00 as an empty date. This has been fixed.

•The macro compiler now also exotic characters in identifiers like the normal compiler. We have added the same identifier name rules that the C# compiler uses.

 

XBase++ Functions

•Fixed a problem in the XPP function SetCollationTable()

•DbCargo() can now also set the cargo value for a workarea to NULL or NIL

•We have added several functions, such as PosUpper(), PosLower(), PosIns() and PosDel().

 

VFP Functions

•Added AllTrim() , RTrim(), LTrim() and Trim() variations for FoxPro (thanks Antonio)

•Added StrToFile() and FileToStr() (thanks Antonio and Karl Heinz)

 

VOSDK

•We have created a Destroy() method on the CSession and CSocket class, so you can 'clean up' objects (in VO you could call Axit(), but that is no longer allowed). The derstructor on these classes will also call Destroy().

•Fixed a problem in TreeView:GetItemAttributes. It can now also be called with a hItem (which happens inside TreeViewSelectionEvent:NewTreeViewItem)

•The OpenDialog class is now resizable.

•Fixed a problem in FormattedString:MatchesTemplChar(), that was causing problems with edit controls with a picture

•Calling DataWindow:__DoValidate() late bound was not working because there are 2 overloads. This has been fixed. Please note that in the VO SDK DataWindow:__DoValidate() expects a parameter of type Control, but inside the DataBrowser code it is called with a parameter of type DataColumn. VO does not complain but in .Net that does not work !

•Fixed a problem in GetMailTimeStamp() in the Internet classes.

•We have included "typed" versions of Consoleclasses, SystemClasses and RDD classes. These are mostly strongly typed and can run in AnyCPU mode.
The SQL classes and GUI classes will follow.

Visual Studio Integration

Code Model

•We have totally rewritten the background parser and code model that is used to parse "entities" in the VS editor and that is used to build a memory model of the types, methods, functions etc in your VS solution. This parser now uses the same lexer that the compiler uses, but the entities are collected with a hand written parser (since the code in the editor buffer may contains incomplete code we can't reliably use the normal parser).

•We are now using a SQLite database to persist the code model between sessions. This reduces the memory needed by the X# project system. We are no longer keeping the entire code model in memory.

•This also means that when you reopen an existing solution we will only have to parse files that have  changed since the last time they were processed. That should speed up loading of large VS solutions.

•We are now also reading type information from external code (assembly references and project references to non X# projects) using the Mono.Cecil library instead of the classes in the System.Reflection namespace. This is faster, uses less memory and, most important, we can easily unload and reload assemblies when they were changed.

•As a result of all of this, opening VS solutions should be faster and "lock up" VS less often (hopefully not at all). Also code completion and other intellisense features should be improved.

 

Source code editor

•Fixed a problem with the dropdown comboboxes above the editor when the cursor is in a line of code before the first entity.

•Fixed a problem that functions in the editor after a class declaration had no collapsible regions

•The code completion inside the editor now also picks up extension methods for the types themselves, but also extension methods for interfaces implemented by these types.

•The editor code now properly recognizes variables declared with the VAR keyword when they are followed by a constructor call

•If you have XML comments in your source code for entities in your solution, then these comments should be picked up by the tooltips inside Visual Studio and by the parameter completion.

•Fixed several problems in the "reformatting" code

Windows Forms editor

•Some inline assignments to fields inside classes that are used by the Windows Forms could make the form unusable by the form editor. This has been fixed.

•The Windows Forms editor was sometimes removing blank lines between entities. This has been fixed.

•User Defined Commands in code parsed by the Windows Forms Editor were not recognized and disappeared when the form was changed and saved. This has been fixed.

•Fixed a problem with setting images and similar properties with resources stored in the project resources file (which are prefixed with "global::" in the source code)

VOXporter

•We have added support to export VO Forms from the AEFs to XML format

•We have added support to export VO Menus from the AEFs to XML format

 

Changes in 2.4.1.0 (Bandol GA 2.4a)

Compiler

•Bracketed strings are now no longer supported in the Core dialect to avoid problems with single line external property declarations that contain attributes between the GET and SET keywords

•The PROPERTY keyword was not properly recognized after an EXTERN modifier.

•Fixed a XS9021 warning for a IIF expressions with 2 numeric constants

•In the FoxPro dialect late bound calls are now always allowed on certain types (even when the /lb compiler option is not enabled), such as USUAL and the Empty class.  These types are marked with the AllowLateBound attributes in the runtime.
They WILL generate a new compiler warning (XS9098).

•We have added a new compiler option -fox2. This option makes local variables visible to the macro compiler and should also be used when you use SQL statements with embedded parameters. This compiler option must be used in combination with -memvar and the FoxPro dialect

Runtime

•Fixed a problem in the DELIM Rdd that would occur when using DbServer:AppendDelimited() and DbServer:CopyDelimited().

•Fixed a problem with DbSetOrder() returning TRUE even when the order was not found.

•Fixed a problem where the File() function would return FALSE when using wildcard characters

•SqlExec() now returns columns of type Date for SQL providers that have a separate Date type

•Workareas/Cursors created with SqlExec() now have the NULL flags, Binary flags etc. set properly according to the settings read from the backend.

•Fixed and added implementation of VFP functions (Gomonth, Quarter, ChrTran, At in various variations, RAt in various variations, DMY, MDY). Thanks Karl Heinz.

•First work on parameterized SQL functions. Not finished yet.

•Some types in the runtime are now marked with a special "AllowLateBound" attribute. These types will be accepted in the FoxPro dialect as candidates for compiling latebound even when the /lb compiler option is not enabled.

•We have added support for the macro compiler to access local variables by name. This is built into the VarGet() and VarPut() functions and also the MemVarGet() and MemVarPut() functions. Local variables will have preference over same named private or public variables. You have to enable the -fox2 compiler option for this.

•ValType() now returns "Y" for currency values and "T" for DateTime values

•No copy of the runtime state is created when that state is accessed in the Garbage collector thread.

•SQLExecute() now returns -1 when an invalid SQL statement is executed.

•Added the VarType() function

•IVarGet() and Send() now return Empty strings when a method returns a NULL_STRING and the return type  is STRING

RDD

•Getting the OrdKeyNo for a scoped index was resetting the index position to the top of the index. This would affect scrollbars in browsers for scoped indexes

VOSDK

•The Console classes assembly is now marked as AnyCpu.

•Fixed a problem introduced in the previous build with the calling convention for certain functions imported from Shell32.DLL such as the Drag and Drop support.

•Fixed a problem in the PrintingDevice constructor for reading of printers when running on a Remote Desktop

•We have changed several calls to IsInstanceOf with <var> IS <Type> constructs

•Fixed typo in several IsInstanceOf() calls

•Improved "column scatter" code for the DataBrowser class

Visual Studio Integration

•If you removed all the characters from the "Commit Completion List" control in the XSharp editor options, then after restarting VS all default characters would appear. We now remember that you have cleared the list and will not refill the list again.

•Fixed a problem that caused the editor not to rescan the current buffer for changed entities

•Added project property for the new -fox2 compiler option

•The VO MDI template now has Drag and Drop enabled

•Fixed a problem in the Debugger with some of the runtime types, such as DATE that could cause an exception while debugging in VS 2019

•Fixed a problem in the part of the editor code that is responsible for showing collapsible regions and updating the comboboxes with type names and member names.

•Fixed the code generation for Tab pages in the VO compatible forms editor

 

Changes in 2.4.0.0 (Bandol GA 2.4)

Compiler

•Fixed problems where certain operations on integers would still return the wrong variable type

•The Unary Minus operator on unsigned integral types (BYTE, WORD, DWORD, UINT64) was returning the same type as the original, so it was not returning a negative value. This has been changed. The return value of this operator is now the next larger signed integral type.

•Using a compiler macro, such as __VERSION__ in an interpolated string was causing an internal error in the compiler. This has been fixed.

•The vo11 compiler option now only works for operations between integral and non integral types. Other behavior has been removed because the VO behavior for mixing integral types was confusing and impossible to emulate.

•Bracketed strings are now also recognized after a RETURN and GET keyword.

Runtime

•Fixed problems when subtracting a dword from a date (related to the signed/unsigned problems in the compiler)

•LUpdate() now returns a NULL_DATE for workareas have no open table.

•Added the missing ErrorStack() function (thanks Leonid)

•Added the Stack property to the Error class

•Added the SQL..() functions from Visual FoxPro. Please note that SQLExec() and SQLPrepare() with embedded parameters in the SQL statements are not supported yet. This requires a change in the compiler that is planned for the next build.

•Added a DbDataTable() function that returns a (detached) DataTable with the data from the current workarea

•Added a DbDataSource() function that returns a BindingList attached to the current workarea. Updates to properties in the bindinglist will be directly written to the attached workarea.

•Added 2 classes DbDataTable and DbDataSource that are returned by the functions with the same name.

•Fixed a problem with incorrectly formatted USUALs with numeric values

•We have added the defines from FoxPro.h to the VFP assembly

•We have added the VFP MessageBox functions, including a message box that automatically closes when a timeout has reached.

•Fixed AsHexString() to display large DWORD values that are stored inside USUALs

•Fixed several incompatibilities with VO for FLOAT->STRING conversions

RDD System

•Fixed a problem with skipping backward in a DBFCDX table with a scope

•Fixed a problem with creating unique indexes with the DBFCDX and DBFNTX drivers

•Writing NULL values to DBF columns is now always supported. When the column is a Nullable column in a DBFVFP table then the null flags are set. For other RDDs a NULL value will be written as a blank value.

•Fixed a performance issue in Append operations for all DBF based RDDs

•Fixed a problem with the DBFCDX driver that could happen when index pages were nearly full with key-value pairs with all blanks

•Fixed a problem in WrapperRDD:Open()

•Added the SDF RDD

•Added a special DbfVFPSQL RDD that is used by the SQL..() functions in the VFP support to store the results from SQL queries. The column information describing the original column from the Sql Resultset can be retrieved with the DbFieldInfo() and the DBS_COLUMINFO define. The return value for this call is an object of the type XSharp.RDD.DbColumnInfo.

•Added the DELIM RDD and 2 subclasses (CSV and TSV). These RDDs all return separated values. The default format for the DELIM RDD is to use the comma as separator. CSV uses semi colons and TSV uses Tabs to delimit the fields. On top of that CSV and TSV write a header row with field names.
The "normal" Delimited operations still use DELIM. If you want to use the CSV or TSV RDDs you need to set a global setting:

RddSetDefault("DBFNTX")
DbUseArea(TRUE,"DBFNTX", "c:\Test\TEST.DBF")
DbCopyDelim("C:\test\test.txt")             // this uses the DELIM RDD
 
RuntimeState.DelimRDD := "CSV"             // Tell the runtime to use the CSV RDD for delimited writes
DbCopyDelim("C:\test\test.csv")             // this uses the CSV RDD
 
RuntimeState.DelimRDD := "TSV"             // Tell the runtime to use the TSV RDD for delimited writes
DbCopyDelim("C:\test\test.tsv")             // this uses the TSV RDD
DbZap()
 
RuntimeState.DelimRDD := "CSV"             // Tell the runtime to use the CSV RDD for delimited reads
DbAppDelim("C:\test\test.csv")             // this uses the CSV RDD

VO SDK

•PrintingDevice:Init() no longer tries to read the default printer from win.ini but from the registry

•Several other locations where the code was still accessing win.ini (with the GetProfile..() funcitons) have been updated.

•The GUI Classes were delay loading several calls to common dialog DLL and winspool.drv. This has changed because that is no longer needed in .Net.

•Cleaned up all PSZ(_CAST operations in GUI Classes.

Visual Studio integration

•Parameter tips for OUT variables were shown as REF

•XML descriptions for member with REF or OUT parameters were not found

•Fixed an exception in the VS Editor

VOXporter

•No changes in this build

 

Changes in 2.3.2 (Bandol GA 2.3b)

Compiler

•Added support for Bracketed Strings ([Some String containing quotes: '' and ' ] )

•Added support for Support for PRIVATE/PUBLIC syntax with &Id and &Id.Suffix notation

•EXE files were created without manifest before, unless you were using a WIN32 resource with a manifest. This manifest is now correctly added to exe files when no manifest is supplied.

•The handling of unmanaged resources in relation to version resources and manifests has changed:

oWhen the compiler detects native resources it will now check to see if there is a version and/or manifest resource included.

oWhen there is no manifest resource, then the default manifest resource will be added to the resources from the Win32 resource file.

oWhen there is a version resource then this version resource will be replaced by the version resource that the compiler generates from the Assembly attributes.

oThis should help people coming from VO, so they can use AssemblyVersion etc for all their assemblies, also the ones that have menu and window resources.
If there happens to be a versioninfo resource in the source then this is ignored.

oOf course we have added a command line option to suppress this: if you use the commandline option "-usenativeversion" then the native version that is included in the Win32 resource will be used. If there is no version resource included in the Win32 resource file, then this commandline option is ignored.

•PCOUNT() and ARGCOUNT() are now supported inside ACCESS/ASSIGN methods. The number of parameters that you can pass is still fixed, but both functions will now return the # of parameters defined in ACCESS and/or ASSIGN methods.

•We fixed a problem that a compiler error "Failed to emit module" was produced instead of showing the real problem in the code (a missing type) .

•Extended match markers in the preprocessor, such as <(file)>  in the USE udc, now also properly match file names.

•Improved the detection algorithm that distinguishes parenthesized expressions and typecasts. This algorithm is now:

oBuilt in type names between parentheses are always seen as a typecast. For example (DWORD), (SHORT) etc.

oOther type names between parentheses may be treated as typecast but also as parenthesized expression. This depends on the token following the closing parenthesis. When this token is an operator such as +, -, / or * then this is seen as parenthesized expression. When the token following the closing parenthesis is an opening parenthesis then the expression is seen as a typecast. Some examples:

? (DWORD) +42              // this is a typecast
? (System.UInt32) +42   // this is a parenthesized expression and will NOT compile
? (System.UInt32) 42   // this is a typecast because there is no operator before 42
? (System.UInt32) (+42) // this is a typecast because +42 is between parentheses

•Code that calls the Axit() method now generates  a compiler error.

•We have implemented the /vo11 compiler option

•We have fixed several signed/unsigned warnings

•You can now use PCall() on typed function pointers stored inside structures (this is used in the VO Internet Server SDK)

•The lexer now recognizes (in the FoxPro dialect) the For() and Field() functions and you do not need to prefix these with @@ anymore.

Runtime

•Fix for StrZero() with negative values

•Fix for IsSpace() crashing with empty or null string

•AFill() in the VFP dialect now fills also elements in subarrays (for multi dimensional arrays)

•NoIVarGet() and NoIvarPut() no longer convert the IVar names to Symbol. That way the original casing is kept when calling the NoIVarGet() and NoIVarPut() methods in a class

•The VFP and XPP Abstract classes are now really abstract.

•Implemented VFP Empty class.

•Implemented VFP AddProperty and VFP RemoveProperty functions.

•Fixed a typo in PropertyVisibility enum name

•Fixed several errors when calling DBF related functions for a workarea that did not contain an open table.

•The Seconds() function now returns 3 decimals when running in the FoxPro dialect. Please note that you have to add SetDecimal(3) to actually see the 3rd decimal

•The Like() function is now case sensitive in the FoxPro dialect and case insensitive in all other dialects. The _Like() function is case sensitive in all dialects.

•ASort() was not accepting a 4th argument of type Object(). This has been correct: when you pass an object that has an Eval() method then this method will be called to determine the right sort order.

•When setting/restoring global State with the Set() function, some values that are synchronized by the runtime could get out of sync. This could result in incorrect date formats or similar errors. This has been fixed.

•Several VFP compatibility functions have been added (some contributed by Thomas Ganss).

•We have added several VFP functions such as

•When you set a "global setting" using the Set() function the runtime now makes sure that related settings are set accordingly. For example Setting Set.DateFormat now also updates the DateFormatNet and DateFormatEmpty.

•Fix for PadC() function with non standard filler

•We have added DBOI_COLLATION and DBS_CAPTION for FoxPro specific properties

VO SDK

•We have removed the versioninfo resource from the GUI classes sourcecode. The version info is now generated from the Assembly attributes

•We have cleaned up the code and removed the warnings 9020 and 9021 from the suppressed warnings, since the compiler now handles this correctly.

RDD system

•The DBFVP driver no longer fails to open a DBF when the DBC file is used exclusively by someone else

•Added support for reading captions with DBS_CAPTION and collations with DBOI_COLLATION

•The DBFNTX driver was not setting the HPLocking flag properly when creating new indexes

Visual Studio integration

•The type lookup for variables declared with a VAR keyword could sometimes go into an infinite loop. This has been fixed.

•Members starting with '__' are now only hidden from completion lists when the 'Hide Advanced members' checkbox in the general editor options is checked

•Added support for colorizing BRACKETED_STRING constants

•Fixed a bug in the keyword case synchronization code.

•The code behind the VS Form editor had problems with methods declared without return type. As a result forms could not be opened. This has been fixed.

•Improved intellisense info for Defines and Enum members

•You can now enable/disable /vo11 in the project properties dialog

VOXporter

•When porting from Clipboard contents, now VOXporter puts back the modified code to the clipboard

•Added option to remove ~ONLYEARLY pragmas

Installer

•The installer now has a new command line parameter "-nouninstall" that prevents the automatic installation of a previous version. This allows you to install multiple versions of X# side by side.
Please note that the installer sets a registry key to the location where X# is last installed. This location will be used by the Visual Studio integration to locate the compiler.
If you don't change this then all VS installations will always use the version of X# that is last installed. See the topic about the build process in VS and with MsBuild for information about how this mechanism works.
Also if you choose to install the X# runtime assemblies in the GAC then newer versions of these runtime DLLs will/may overwrite older versions. This depends on the fact if the newer DLLs have a new Assembly version.
At this moment all X# runtime DLLs (still) have version 2.1.0.0 even when X# itself is now on version 2.3.2.

•The installer now lists all found instances of VS 2017 and VS 2019, including the Visual Studio Buildtools, so you can choose to install in a particular instance of these versions of Visual Studio or simply in all instances.
Please note that when you run X# with the -nouninstall command line option, this will prevent the installer from removing X# from VS installations where it was previously installed.

•We have added some documentation about all the installer command line options to the help file.

Documentation

•Fixed errors in the documentation of escape codes

•We have added a chapter with tips and tricks that contains the following topics at this moment.

•Added description of the installer command line arguments

•Added description of the Build process in VS and with MsBuild

•Added topics describing the dialect "incompatibilities" in the X# runtime. Please note that this topic is not complete yet.

•How to catch errors at startup

•Compiler magic in the startup code

•Special classes generated by the compiler.

 

Changes in 2.3.1.0 (Bandol GA 2.3a)

Compiler

•When compiling in case sensitive mode, the compiler now checks to see if a child class declares a method that only differs from a method in its parent class by case

•The warning message about assigning to a foreach iterator variable has been changed from "Cannot assign" to "Should not assign"

•#pragma warnings was not working with the xs1234 syntax but only with numbers. This has been corrected

 

Runtime

•Added the SetFieldExtent method to the IRdd interface

•The USUAL type no longer "caches" the dialect setting

•Fixed some problems with ACopy() with skipped or negative arguments.

•The return value for Alias() is now in upper case.

VO SDK

•The VO SDK Console class now uses the System.Console class internally. The only functionality that is no longer available is:

oIt does not respond to the mouse anymore

oCreating a "new" console window is not supported.

RDD system

•Fixed a problem in the Advantage RDDs that was caused by a casing problem (a method in a child class had a different case than the method in the parent class that it tried to override). This is why we also added a check to the compiler.

•Creating an NTX with the DBFNTX driver could fail in some situations due to timing issues. This has been fixed.

Visual Studio integration

•Fixed a problem in keyword case synchronization that could corrupt the editor contents.

 

Changes in 2.3.0.0 (Bandol GA 2.3)

Compiler

•Syntax errors (1003) or Parser errors (9002) in a source file could lead to multiple errors in the error list. We are now only reporting the first of these error types in a source file.

•Implemented the -cs (Case Sensitive identifiers) compiler option

•The compiler now includes the source for a compiletime codeblock as string in that codeblock. Calling ToString() on a compile time codeblock will retrieve this string.

•Fixed a problem that memory variables were not updated when passed to a DO <proc> WITH statement

•Accessing or assigning undefined properties or calling undefined methods in typed code was generating a compiler error. The compiler now detects if the type has a NoIVarGet(), NoIVarPut() or NoMethod() method, and when it finds the appropriate methods then a compiler warning (XS9094) is generated instead of a compiler error.

•Casting a numeric to a LOGIC with the LOGIC(_CAST, numValue) construct was only looking at the lowest byte of numValue. If the lowest byte was zero and a higher byte was non zero the result would be FALSE. The compiler now compiles this into (numValue <> 0).

•The compiler now supports an (optional) THEN keyword for the IF statement

•Added support for the FoxPro CURRENCY type.

•The Value keyword is always compiled in lower case in PROPERTY SET methods

•Unterminated strings are now detected at the end of the line.

•Added ENDTRY UDC for FoxPro

•Added support for #pragma warning(s). See the #pragma warnings topic in the help file for more info.

•Added support for #pragma options. See the #pragma options topic in the help file for more info.

Runtime

•Added XSharp.Data.DLL which contains support code for .Net SQL based data access used by the RDD system and the new Unicode SQL classes.

•DbEval() was throwing an exception when no FOR block or no WHILE block was passed

•DbEval() was throwing an exception when the block that is evaluated was not returning a logical expression

•The workarea event for OrdSetFocus() had an error which would result in an "Operation Failed" error for this event, even when the event succeeded.

•The index operator on USUALs containing STRINGS (which is only supported in the Xbase++ dialect) was not taking into account that the indices were already ZERO based,

•Calling DbCreate() with incorrect lengths for Date or Logic fields was throwing an exception, these are now automatically corrected

•Added a fix for converting USUAL values of type STRING with NULL to STRING

•Fixed a problem in __FIeldSetWa() when the area was NIL or "M".

•Added the FoxPro CURRENCY type. These are also supported in USUAL variables. Internally the values of a CURRENCY variable are stored as Decimal but rounded to 4 decimal places.

•Most runtime DLLs are now compiled in Case Sensitive mode.

•Fixed a problem in the STOD() function, so it allows strings that are longer than 8 characters.

•We have added some VFP functions to the runtime, such as the Just..() functions and AddBs(). Several other functions are there but not implemented. They are marked with an [Obsolete] attribute and will throw a NotImplementedException when called.

•When running on windows the low level File IO system now uses native windows File access in stead of the managed access. This also affects the RDD system.

•Fixed problems in ACopy(), Transform(), Str()

VOSDK Classes

•Added DbServer:FieldGetBytes() and DbServer:FieldPutBytes() to read the 'raw' bytes of a string field. Please note that (in ccOptimistic mode) the bytes value is NOT cached and that you have to manually lock and unlock the server when calling FieldPutBytes().

•Added several missing defines

•Synchronized the VO SDK to the VO 2.8 SP4 SDK. The only changes that are not included are the ones from the DateTimePicker class. These changes were causing conflicts with the existing code in the X# VOSDK.

RDD System

•Querying the header size for the Advantage RDD would cause an exception. This has been fixed

•Fixed a problem with DbRlockList() and the advantage RDD

•Skipping in a cursor for the Advantage RDDs was not refreshing the EOF and BOF flags for related tables

•Fixed a problem writing strings in FPT files

•The AX_Get.. Handle() functions were not properly returning the handles

•We have added several missing Advantage related functions.

•The DBFVFP driver was not writing the block for DBC backlinks to the file header when creating a new file, which resulted in negative record numbers.

•We have added (temporary) support for reading field names from DBC files for the DBFVFP driver. As a result CDX files which use the long field names in index expressions are now also opened correctly

•Fixed a problem in the CopyDb() code for the DBF RDD

•The DBFCDX RDD now implements the BLOB_GET and also BlobExport() and BlobImport()

•Packing, Zapping or Rebuilding a CDX index with a Custom or Unique flag would not keep these flags. This has been fixed.

•When you create a file with the DBFVFP driver you can now include Field Flags in the field type of the DbCreate() array by following the type with a colon and one or more flags, where flags is one of:
N or 0:        Nullable
B                Binary
+                AutoIncrement
U                Unicode.  (not supported by FoxPro)
Other flags may follow ( for example Harbour also has E = Encrypted and C = Compressed)
Note:

oPlease note that the size of the field is the # of bytes, so {"NAME","C:U",20,0} declares a Unicode character field of 10 Unicode characters and 20 bytes.

oWe do not validate combinations of flags. For example AutoIncrement is only working for fields of type Integer.

•DbFieldInfo(DBS_PROPERTIES) returns 5 for all RDDs with the exception of the DBFVFP driver. That driver returns 6. The 6th property is the FLAGS field. This field is a combination of the DBFFieldFlags enum values.

•Fixed a problem with AppendDb() and CopyDb() for the Advantage RDD

•Fixed a problem in the Append() code of the DBF RDD. When Append() was called and no data was written then the record that was written to disk could be corrupted. The Append() method now directly writes the new record with blanks..

•The Fully qualified names of the Advantage RDDs inside XSharp.RDD.DLL are now the same as in the AdvantageRDD.DLL for Vulcan.

•We have added a FileCommit event to the notifications. This sent when a workarea is committed.

Macro compiler

•The macro compiler now also recognizes the Array(), Date() and DateTime() functions.

•Fixed problems with Aliased expressions

•On the place where the macro compiler expects a single expression you can now also have an expression list between parentheses. The last expression in the list is seen as the return value of the expression list

Visual Studio integration

•The option to compile case sensitive has been enabled in the VS project system

•The speed of 'Format Document' has improved a lot.

•The XSharp Intellisense Optionspage in Tools/Options now has a scroll bar when needed

•The ToolPalette in the VO Window editor now has icons

•We have added templates for VO MDI windows and VO SDI windows.

Build System

•When compiling native resources the resource compiler now automatically includes a file with some defines such as VS_VERSION_INFO

Debugger

•When you enter a watch expression in the debugger or a breakpoint condition, you can now use 1 based array indices. Our debugger will now automatically subtract 1 when evaluating the expression.

VOXporter

•Fixed a problem in the Windows Forms code generation

•You can now also export single MEF files, single PRG files and data from the Clipboard.

•Code between #ifdef .. #endif is not touched by VOXPorter

 

Changes in 2.2.1.0 (Bandol GA 2.2a)

Compiler

•When compiling code that contained an assign and not an access then trying to read the access could lead to a compiler exception. This has been fixed.

Runtime

•Added a missing _Run() function

Visual Studio integration / Build system

•Fixed a problem that caused a dialog to be shown with the message "The 'XSharp Project System' package did not load correctly."

•Fixed a problem with writing response files for the resource compiler when the source file names contained ASCII characters with accents or other  characters > 128. Even though this is now fixed we still recommend not go to crazy with file names, because these names have to be converted from Unicode to Ansi, since the resource compiler can only read response files in Ansi format.

•Fixed a problem for certain QuickInfo / Tooltip windows

•The VO item templates now have a condition around the #include statements for the Vulcan include files, since these are no longer needed when compiling for the X# runtime.

•Added Support for the "Auto" window in the debugger

•Expressions in the Watch window, Breakpoint conditions etc may now contain SELF, SUPER and a colon separator. Unfortunately they are still case sensitive.

VOXPorter

•we now detect that a class has fieldnames and accesses/assigns with the same name. This was allowed in VO but no longer in .Net. The field names will be prefixed with an underscore inside the class.

•We now prefix the name "Trace" with @@ because this is quite often used to conditional compile tracing code in VS.

 

Changes in 2.2.0.0 (Bandol GA 2.2)

Compiler

•The compiler now recognizes the functions Date(), DateTime() and Array(), even though their names are the same as type names.
Date() with 1 parameter will still be seen as a cast from that parameter to a Date(), like in the following example
LOCAL dwJulianDate AS DWORD
LOCAL dJulianDate AS DATE
dwJulianDate       := DWORD( 1901.01.01)
dJulianDate        := DATE(dwJulianDate) // This is still a cast from Date to DWORD
However when Date is called with 0 or 3 parameters then either the current date is returned (like with Today()) or a date is constructed from the 3 parameters (like in ConDate())
The DateTime() function takes 3 or more parameters and constructs a DateTime() value.
The Array() function takes the same parameters as the ArrayNew() function.

•When choosing overloads for String.Format() and a usual expression is passed as first reference we no longer allow the compiler to choose one of the overloads that expects an IFormatProvider interface.

•Parameters passed by reference to untyped methods/functions now have the IsByRef flag set. You can query for "By Reference" parameters by checking the parameter with IsByRef(uParameter). Please note that after assigning a new value to a parameter, this flag will be cleared.

•The compiler now also allows to pass aliased fields and memvars by reference to untyped functions. Even undeclared memvars are allowed.
Please note that the assignment back to the field and memvar will happen after the call to the function returns. So inside the function the field or memvar will still have its original value.

•Using ':'  as send operator in Interpolated strings is ambiguous because ':' is also used add format specifiers to interpolated strings. The compiler now detects and allows "SELF:", "SUPER:" and "THIS:".
If you want to be safe use the '.' as send operator inside interpolated strings for other variables, or simply don't use interpolated strings, but use String.Format like in:
? String.Format("{0} {1}", oObject:Property1, oObject:Property2)
in stead of
? i"{oObject:Property1} {oObject:Property2}"
This is the code that the compiler will produce anyway

 

Macrocompiler

•The macro compiler now recognizes and compiles nested codeblocks, such as
LOCAL cb := {|e| IIF(e, {||SomeFunc()}, {||SomeOtherFunc}) } AS CODEBLOCK
cb := Eval(cb, TRUE)   // cb will now contain {||SomeFunc()}
? Eval(cb)

•In the FoxPro dialect the macro compiler now recognizes AND, OR, NOT and XOR as logical operators

Runtime

•Added some Xbase++ compatible functions, such as DbCargo(), DbDescend() and DbSetDescend().

•The DateCountry Enum now also the values System and Windows, which both read the date format from the Regional settings in the System.

•We have added a WrapperRDD class that you can inherit from. This allows you to wrap an existing RDD and subclass methods of your choice. See the documentation of WrapperRDD for an example.

•We had added a XPP member to the CollationMode enum with the same number as Clipper. This was confusing to some users. We have now give the XPP member a new number.

•OleAutoObject:NoMethod() now behaves different in the Vulcan dialect (to be compatible with Vulcan). In the Vulcan dialect the method name is inserted at the beginning of the list of arguments. In the other dialects the arguments are unchanged, and you need to call the NoMethod() function to retrieve the name of the method that was originally called.

•All settings in the runtime state are now initialized with a default value, so the Settings() dictionary in the runtimestate will have values for all Set enum values.

•The previous change has fixed a problem with the Set() function when setting values for logical settings with a string "On" or "Off". Because some settings were not initialized with a logic this was not working.

•When creating indexes with SetCollation(#Ordinal) the speed is a bit better now.

•The runtimestate now has a setting EOF. When this is TRUE (which is done automatically for the FoxPro dialect) then MemoWrit() will write a ^Z (chr(26)) after a text file, and MemoRead() will remove that character when it finds it.

•The runtimestate now has a setting EOL. This defaults to CR - LF (chr(13+chr(10)). This setting is used for line delimiters when writing files with FWriteLine().

RDD system

 

•Fixed locking problems in the DBFCDX RDD that were causing problems when opening files shared between multiple apps but also between multiple threads. The RDD now should properly detect that the CDX was updated by another process or thread.

•Fixed a problem with the File IO system when running multiple threads

•Fixed a problem with the File() and FPathName() functions when running multiple threads

•Added support for Workarea Cargo (See DbCargo())

•Numeric columns with trailing spaces were returned as 0. This has been fixed.

•Fixed a problem in the DBFCDX driver that was happening when many keys were deleted / updated and index pages were deleted.

•Fix a read error at EOF for the DBF RDD.

VOSDK

•Fixed a problem in the DbServer destructor when called at application shutdown for a server that was already closed.

Visual Studio integration

•Fixed speed problem in the "Brace Matching" code with the help of a user (thanks Fergus!)

•You should no longer be able to edit source code when the debugger is running.

•We have added a property "Register for COM Interop" to the build options of the Project Properties.

•We have updated the assembly info templates . They now have a GUID and Comvisible attribute.

•Empty lines in the editor buffer could sometimes trigger an exception. This has been fixed

•Text between TEXT .. ENDTEXT is no longer changed by formatting options in the editor, such as indenting or case synchronization.

•Incomplete strings will have the color of normal strings in the editor.

•QuickInfo and Completion lists will follow the "format case" setting of the editor for keywords.

•If a certain option from the Tools/Options was not set then loading a project that was saved with files open in the editor could result in an exception, causing the project to be loaded with no visible items. Unload and Reload would fix that. This will no longer happen.

•We have made some changes to make solutions open and close faster.

•Some colors were difficult to read when the Visual Studio Dark theme was selected. This has been fixed.

•Brace matching was sometimes incorrectly matching an END CLASS with the BEGIN NAMESPACE. This should no longer happen.

•Fixed an exception when opening a solution under certain circumstances which would display an error inside VS that the XSharp Project System was not loaded correctly.

•The Code Generator for Windows Forms, Settings and Resources now respect the keyword case setting from the Tools - Options TextEditor/XSharp page.

VOXPorter

•Folder names ending with a backslash could confuse VOXPorter

 

Changes in 2.1.1.0 (Bandol GA 2.11)

Compiler

•We have added new syntaxes for OUT parameters. You can now use one of the following syntaxes

 
  LOCAL cString as STRING
  cString := "12345"
  IF Int32.TryParse(cString, OUT VAR result)      
 // this declares the out variable inline, the type is derived from the method call
     ? "Parsing succeeded, result is ", result
  ENDIF
  IF Int32.TryParse(cString, OUT result2 AS Int32)  
 // this declares the out variable inline, the type is specified by us
     ? "Parsing succeeded, result is ", result2
  ENDIF
  IF Int32.TryParse(cString, OUT NULL)      
 // this tells the compiler to generate an out variable, we are not interested in the result
     ? "Parsing succeeded"
  ENDIF
  IF Int32.TryParse(cString, OUT VAR _)      
 // this tells the compiler to generate an out variable, we are not interested in the result.

•The compiler now allows the function names Date(), DateTime() and Array(). The runtime has these functions (see below)

•Fixed a preprocessor problem where the <token> match marker inside UDCs was stopping matching tokens when the .not. or ! operator was found after another logical operator such as .AND. or .OR..

•Added support for <usualValue> IS <SomeType>. The compiler will automatically extract the contents of the USUAL and wrap it in an object and then apply the normal IS <SomeType> operation.

•Fixed a problem with Interpolated strings where the '/' character was not properly recognized.

•The compiler now supports the FoxPro syntax for cursor access. When dynamic memory variables are disabled this always gets translated to reading a field from the current cursor/workarea.
 
  USE Customer
  SCAN
     ? Customer.LastName
  END SCAN
  USE

Runtime

•We have added support functions for the FoxPro cursor access syntax.

•In the Vulcan dialect the NoMethod() method now receives the methodname as first parameter (this is NOT compatible with VO)

•Added functions Date() (can have 0 or 3 parameters, equivalent to Today() and ConDate()), DateTime() and Array().

•Added fixes and optimizations for functions such that take an area parameter such as Used(uArea) and Eof(uArea).

•AScan() and AScanExact() now return 0 when a NULL_ARRAY is passed.

 

RDD

•There was a problem reading negative numbers from DBFs. This has been fixed

•Fixed an exception when FPT drivers were writing data blocks in the FPT file with a 0 byte length.

•The DBF() function returns the Full filename in the FoxPro dialect and the alias in the other dialects.

•When creating an CDX index for a completely empy DBF file then an index key would be inserted for the phantom record. This has been fixed.

 

Changes in 2.1.0.0 (Bandol GA 2.1)

Compiler

•We have added support for parameters by reference to function and method calls for untyped parameters

•In the Xbase++ and FoxPro dialect arguments passed with '@' are always treated as BY REF arguments because these dialects do not support the 'AddressOf' functionality

•When /undeclared was used and an entity added a new private then this private was not cleared when the entity went out of scope. This has been fixed.

•Compiling oObject?:Variable was not handled correctly by the compiler

•Fixed an internal compiler error when calling SELF:Axit()

•Parameters for the DO statement are now passed by reference

•Changed the order of 'necessary' assembly names when compiling for not core dialect.

•We have added support for several SET commands, such as SET DEFAULT, SET PATH, SET DATE, SET EXACT etc.

Runtime

•We have made some changes to get XSharp.Core to run on Linux

•We have fixed a problem in the Subtract operator for the Date type. This changes the signature of the Subtract operator which has forced us to increase the Assemblyversion of the runtime.

•The Xbase++ dialect now allows the [] operator on a string inside a usual. This returns a substring of 1 character for the given position.

•We have fixed an incorrect event for the OrderChanged event

•CoreDb.BuffRefresh was sending an incorrect enumerator value to the IRDD.RecInfo() method.

•The IVarList() function was including protected Fields and Properties. This has been fixed.

•IsInstanceOfUsual() could not be used if an objects was of a subclass of CodeBlock. This has now been fixed.

•We have added many overloads of workarea related functions with an extra parameter to indicate a workarea number or workarea name. For example for the EoF(), Recno(), Found() and Deleted() functions

•We have added Xbase++ collation tables. The SetCollationTable() function now selects the right collation.

•Several Array related functions now have better checks for NULL arrays

•The SubcodeText property in the error class is now Read/Write. When the value has not been written then the subcode number is used to lookup the value of the property.

•MExec() was not always evaluating the compiled codeblock. This has been fixed.

•We have added some missing Goniometric functions, such as ACos(), ASin() and more.

•In the Xbase++ dialect the FieldGet() and FieldPut() functions no longer throw an error for incorrect field numbers

•We have added a missing MakeShort() function and SEvalA() function.

•The DateCountry settings now include a System setting which will read the date format from the settings for the current culture.

Macrocompiler

•When the macro compiler detects an ambiguous method or constructor it now includes the signatures of these in the error message

•We have added a new IMacroCompiler2 interface that adds an extra property "Resolver". This property will may receive a Delegate of type "MacroCompilerResolveAmbiguousMatch". This delegate has the following prototype:
DELEGATE MacroCompilerResolveAmbiguousMatch(m1 as MemberInfo, m2 as MemberInfo, args as System.Type[]) AS LONG

•The delegate will be called when the macro compiler detects an ambiguous match and receives the System.Reflection.MemberInfo for possible candidates and an array of the detected types of the arguments (detected at compile time). The delegate can return 1 or 2 to choose between either candidate. Any other value means that the delegate does not know which of the ambiguous members to choose.
If the macro compiler finds more than 2 alternatives, it first calls the delegate with alternatives 1 & 2, and then the selected delegate from these 2 and alternative 3 etc.

•You can register a function or method as delegate with the new function
SetMacroDuplicatesResolver()

•We are now handling (one level of) nested Macros. So the macro compiler correctly compiles a codeblock like
{|e| iif(e, {||TRUE}, {||FALSE})}

•The macrocompiler now allows comparisons between Integers and Logics (just like the Usual type in the runtime). This is still not recommended !

•The macrocompiler now allows the use of '[' and ']' as string delimiters. This is NOT allowed in the normal compiler because these delimiters will be impossible to differentiate from attributes.

•We have fixed a problem when a late bound call was needed for method names that were matching method names or property names in the Usual type (such as a method with the name Item()).

•PCount() for macro compiled codeblocks was always returning 1. This has been fixed.

VOSDK

•Fixes a problem with DbServer objects that were not closed in code.
The existing code was trying to close the workarea from the destructor. But in .Net the destructor runs in a separate thread and in that GC Thread there where no files open...

•Removed unneeded calls to DbfDebug()

•The AdsSqlServer class is now added to the VORDDClasses assembly

RDD

•We have fixed a problem with parsing incorrect or empty dates

•We have fixed a problem with reading Dates in the Advantage RDD that could cause a Heap error when reading dates.

•We have added several 'missing' functions for Advantage support that were in the 'Ace.Aef' for VO

•We have added support for Character fields > 255 characters

•DbSetScope() now moves the record pointer to the first record that matches the new scope.

•DbCreate() for the DBFNTX driver with SetAnsi(TRUE) was creating a file with a first byte of 0x07 (or 0x87) .
This no longer happens in the Xbase++, FoxPro and Harbour dialects because this first byte is VO specific only

•Some FoxPro memo values are written with an extra 0 byte at the end. This extra byte is now suppressed when reading these values.

•We have fixed a problem with the version numbers in CDX files not being updated and also improved CDX locking.

•Xbase++ was not recognizing NTX indices when the tag name in the index header was not in uppercase. This has been fixed.

•We have fixed a (performance and size) problem when creating CDX indexes.

•When opening a DBF file that does not have a codepage byte, we default to the current Windows or DOS codepage, depending on the current SetAnsi() setting.

•Optimized reading numeric, date and logical columns

•

Visual Studio integration

•The WCF Service template has been fixed

•We have migrated the project system to the Asynchronous API. This should make loading of solutions with a large number of X# projects a bit faster.

•Fixed a problem in the Keyword Case synchronization that could lock up the UI for several seconds

•Fixed an exception in the BraceMatching code.

•Uncommenting a block of lines was sometimes leaving the comments in front of empty lines. This has been fixed.

•We have improved the (XML) documentation lookup for types, methods, fields, properties and parameters.

•We have improved the type lookup between X# projects.

VOXPorter

•DbServer and FieldSpec entities are now also exported

•VOXPorter now also can genarate a separate project/application that contains Windows Forms versions of the VO GUI windows found in the VO Applications.

•When running VOXPorter you now can choose to export to XIDE, Visual Studio or Both.

 

Changes in 2.0.8.1 (Bandol GA 2.08a)

Compiler

•Fixed a recursion problem in the preprocessor

•MEMVAR-> and FIELD-> were no longer correcty detected This has been fixed.

•We have fixed several issues in  dbcmd.xh

•Fixed a problem with return statements inside Lambda expressions.

•The = Expression() statements (FoxPro dialect) was not generating any code. This has been fixed.

Runtime

•XPP.Abstract.NoMethod() and XPP.DataObject.NoMethod() were still expecting the method name as 1st parameter.This has been fixed.

•StretchBitmap() was doing the same as ShowBitmap() because of an incorrect parameter. This has been fixed.

Visual Studio integration

•Improved the Format-Document code

•Fixed a problem in the VS Parser when looking up the type for variables defined with the VAR keyword which could send VS in an endless loop.

•The contents of the TEXT .. ENDTEXT block and the line after the \ and \\ tokens now has its own color

 

Changes in 2.0.8 (Bandol GA 2.08)

Compiler

•The compiler had a problem with the "return" attribute target

•Errors inside the "statementblock" rule are now better detected and the compiler will no longer report many errors after these for correct lines of code.

•Fixed a problem with Casts to logic

•Fixed a problem with undeclared variables used as counter for For Loops

•Improved the code generation for FIELDs, MEMVARs and undeclared variables for prefix operation, postfix operations and assignments.

•Improved the code generation for method calls where the parameter is a ref or out variable when default parameters are involved. The compiler now generates extra temporary variables for these calls.

•In the dialects where this relevant the compiler now also supports ENDFOR as alias for NEXT and FOR EACH as alias for FOREACH.

•Added support for the DO <proc> [WITH arguments] syntax

Runtime

•The DbCreate() function now creates a unique alias when the base filename of the file to create is already opened as an alias

•The Numeric overflow checking for USUAL values now follows the overflow checks of the main app

•DbUnLock() now accepts an (optional) record number as parameter

•XMLGetChild() was throwing an exception when no elements were found

•XMLGetChildren() was throwing an exception

•Fixed a problem in 2 rules inside "dbcmds.xh"

•The XSharpDefs.xh  file now automatically includes "dbcmd.xh"

•Some datatype errors were reported incorrectly.

•The "NoMethod" method for late bound code was called with incorrect parameters. This has been fixed.

•Fixed some problems with translating usuals with a NIL value to string or object.

•In Xbase++ the Set() function also accepts strings with the value "ON" or "OFF" for logical settings. We are now allowing this too.

•Set(_SET_AUTOORDER) now accepts a numeric second parameter just like in VO (Vulcan was using a Logic parameter)

•We have added some support classes to the FoxPro class hierarchy for the FoxPro class support (Abstract, Custom and Collection). More classes will follow later.

•Fixed a problem with transform and "@ez" picture.

VOSDK

•Fixed a problem in the SQLSelect class when re-opening a cursor.

RDD System

•Fixed a problem reading Advantage MEMO fields

•Improved the error messages when an index cannot be opened due to an index expression with an error (for example a missing function)

•We have added the option to install an event handler in the RDD system. See the topic Workarea Events for more information.

•Skip, Gobottom and other workarea operations that change the current record will no longer set EOF to FALSE for workareas with 0 records.

•Clearing the scope in an Advantage workarea would throw an exception when there was no scope set. This has been fixed.

•Unlocking a record in an Advantage workarea would throw an exception when there was no record locked. This has been fixed.

•DbSetRelation() was not working correctly. This has been fixed.

VS Integration

•Fixed a problem with the code generation for DbServer and FieldSpec entities

•Added support for the Import and Export buttons in the DbServer Editor

•Improved entity parsing inside the editor in the Xbase++ dialect.

•The VS Parser was not colorizing the UDC tokens (including ENDFOR) unless the source file had preprocessor tokens itself. This has been fixed.

•Improved block detection for new END keywords.

•The VS Integration now recognized the class syntax for VFP type classes.

•Fixed a problem in the code that was checking to see which project system "owns" the PRG extension.

•Added compiler option to the Project Property pages to suppress generating a default Win32 manifest.

VOXporter

•VOXPorter was ignoring entities that were not properly prototyped in VO. This has been fixed

FoxPro dialect

•We have added a compiler option /fox1 that controls the class hierarchy for objects. With /fox1 enabled (the default in the FoxPro dialect) all classes must inherit from the Custom class. The code generation for properties stores the values for properties in a collection inside the Custom class. With /fox1- properties will be generated as "auto" properties with a backing field.

•We have added support for FoxPro classes. See the topic FoxPro class syntax for more information about what works and what doesn't work.

•We have added support for DIMENSION and DECLARE statements (which create a MEMVAR initialized with an array)

 

Changes in 2.0.7 (Bandol GA 2.07)

Possible breaking change

•We have removed the #define CRLF from the standard header file. There is a DEFINE CRLF in XSharp.Core now. If you are compiling against Vulcan and you are seeing an error about a missing CRLF then you may want to add the following to your code:
DEFINE CRLF := e”\r\n”

Compiler

•UDCs that were resulting in an empty list of tokens were triggering a compiler error in the preprocessor. This has been fixed.

•Calling a method on an array would be translated to a ASend() with the method name as parameter when the method does not exist in the underlying array class.
The compiler will generate a warning now when this happens,.

•The compiler was producing incorrect code for (USUAL) casts. This has been fixed. In rare cases this may produce a compilation error. If that happens to you then simply create a usual by calling the USUAL constructor:  USUAL{somevalue}

•Fixed several problems with methods declared outside of a CLASS .. END CLASS

•In the FoxPro dialect NOT, AND, OR and XOR are now allowed as alternate syntax for .NOT.,.AND., .OR. and .XOR.

•In the FoxPro dialect you can now include statements before the first entity in the file. The compiler will recognize these and will automatically create a function with the name of the source file and will add the code in these statements a body of this function.

•The compiler now allows to cast an integer expression to logic when /vo7 is enabled. The LOGIC(_CAST is always supported for expressions of type integer

•Incorrect use of language features (such as using a VOSTRUCT in the Core or FoxPro dialect) is now detected earlier by the compiler leading to somewhat faster compile times for incorrect code.

•The compiler now also initialized multi dimensional string arrays with an empty string when /vo2 is enabled, like in the code below:
CLASS TestClass
  EXPORT DIM aDim[3,3] AS STRING
END CLASS

•In previous builds you could not set breakpoints on the source code line with a SELF() or SUPER() call if this line was immediately after the CONSTRUCTOR(). This has been fixed.

•When a project contains "_DLL METHOD", "_DLL ASSIGN" or "_DLL ACCESS" (after exporting from VO) then the compiler will now generate a more meaningful errormessage.

•The compiler will no longer produce hundreds of the same error messages when a source file contains many of the same error. After 10 errors per source file the compiler will only report unique error numbers. So if your source code has 20 different error messages then you will still see 20 errors reported, but if your source contains the same error type 100 times then the list will be truncated after 10 errors.

•The compiler no longer allows code behind end tokens such as ENDIF or NEXT. The standard header file 'XSharpDefs.xh' now includes rules that will eliminate these tokens.

Runtime

•The ++ and -- operators for the usualtype were not working for Date and Datetime values

•FErase() and FRename() now set FError() to 2 when the source file does not exist

•The File() function was throwing an exception for paths with invalid characters. It now returns FALSE and sets the Ferror()

•Several specific numbers were producing incorrect Str() results. This has been fixed.

•The case of the name of the Value property for several types was changed from Value to VALUE. This caused problems for people that were interfacing with X# code from C# code. The original case has been restored. This change has been reversed.

•Under certain situations the error stack would not contain the complete list of frames. This has been fixed.

•The size of the Close and Copy buttons of the Error Dialog has been enlarged so there is more space for translated strings

•The Pad..() functions were returning a padded version of "NIL" for NIL values. This was not compatible with Xbase++. They now return a string with all spaces. Btw: VO throw an exception when you call Pad..() with a NIL value.

•Fixed a problem with the PadC() function for values > 1 character.

•We have changed the Val() function to be more compatible with Visual Objects

•The runtime contained a second overload for the Space() function that accepted an Int parameter. This was causing problems in the macro compiler. This overload has been removed. You may have to change your code because of that.

•Fixed a problem in EnforceType() and EmptyUsual() with the STRING type

•AEval and AEvalOld() now both pass the array index as second parameter to the codeblock that is evaluated

RDD System

•Fixed a problem that EOF and BOF were not both set to true when opening an empty DBF with an index

•Fixed a problem with DbSeek() and Found() for DBFNTX and DBFCDX

•The DBF class was not properly decoding field names and/or index expressions that contain Ascii characters > 127 (field names like STRAßE)

•File dates were updated when a dbf was closed even when nothing was changed. This has been fixed.

•The runtime now contains code that closes all open workareas at shutdown. This should help to prevent DBF or index corruption.

•The Advantage RDD was automatically doing a GoTop after the index order was changed. This no longer happens.

•The Advantage RDD now retries opening DBF and Index files a couple of times before failing.

•Fixed a small incompatibility between DBFCDX and AXDBFCDX

VS Integration

•The Core Classlibrary template had a typo in a file name which caused it not to be loaded correctly

•The code generator for the Windows Forms editor was duplicating USING statements. This has been fixed. Duplicate using statements will be deleted when a form is opened and saved in the designer.

•The compilation messages on the output window for the compile time and the number of warnings and errors is now only shown for the build verbosity normal and higher. The warnings and errors message is also shown for lower build verbosity if there are compiler errors.

•The project system will no longer update the version number in the project file if the project file was created with build 2.0.1 or later.

•Fixed a problem with setting and clearing the "Specific version" property for Assembly References.

•The default templates for the VO compatible editors are now installed in the XSharp\Templates folder and the editor uses this location as 'fallback' when you don't have templates in your project

•The Properties folder is now placed as first child in the tree of a Project, and the VO Binaries items are placed before resource items in the list of children of a source item in the tree.

VOXporter

•VOXPorter now prefixes Debug tokens with @@

•VOXPorter now removes INSTANCE declaration for properties that are also declared as ACCESS/ASSIGN

•VOXPorter now adds spaces between variable names that are delimited with .AND. or .OR.. So "a.and.b" becomes "a .and. b"

Documentation

•We have "lifted" some of the documentation of the Visual Objects runtime functions and added these to our runtime documentation. This is 'work in progress', some topics will need some extra work.

 

Changes in 2.0.6.0 (Bandol GA 2.06)

General

•We received a request to keep the version numbering simpler. For that reason this new build is called Bandol 2.06 and the file versions for this build are also 2.06. The assembly versions for the runtime assemblies are all 2.0, and we intend to keep those stable as long as possible, so you will not be forced to recompile code that depends on the runtime assemblies.

•Several fixes that were meant to be included in 2.0.5.0 were not included in that build. This has been corrected in 2.0 6.0

Compiler

•A missing ENDTEXT keyword now produces an error XS9086

•Unbalanced textmerge delimiters produce a warning XS9085

•The TEXT keyword in the FoxPro dialect is now only recognized when it is the first non whitespace token on a line. As a result of this you can use tokens like <text> in Preprocessor commands again.

•The VO cast operations on literal strings no longer produce a compiler warning about possible memory leaks.

 

Runtime

•Runtime errors in late bound code were always shown as TargetInvocationException. The true cause of the error was hidden that way. We are now unpacking the error and rethrowing the original error, including the callstack that was leading to that error

•Some texts in the string resources were updated

•Calling the Str() function with a -1 value for length and/or decimals produced results that were not compatible with VO. This was fixed.

•Fixed a problem with DBZap() and files with a DBT memo.

•In some situations EOF and BOF were not set to TRUE when opening an empty DBF file. This has been fixed.

•PSZ values with an incorrect internal pointer are now displayed as "<Invalid PSZ>(..)"

 

RDD System

•The code to read and write to columns in an Advantage workarea now uses separate column objects, just like the code for the DBF RDD. This makes the code a bit easier to understand and should make the code a bit faster.

 

VS Integration

•The text block between TEXT and ENDTEXT is now displayed in the same color as literal strings

•The VO compatible Project Item templates no longer automatically add references to your project

•Project files from version 2.01.0 and later will no longer be "touched" when opening with this version of the X# project system, since there have been no changes to the project file format since that build.

 

VOXporter

•The CATCH block in the generated Start function now calls ErrorDialog() to show the errors. This uses the new language resources to display the full error with VO compatible error information (Gencode, Subcode etc)

 

Changes in 2.0.5.0 (Bandol GA 2.01)

Compiler

•Blank lines after an END PROPERTY could confuse the compiler. This has been fixed

•The TEXT .. ENDTEXT command has been implemented in the compiler (FoxPro dialect only)

•The \ and \\ commands have been implemented (FoxPro dialect only)

•Procedures in the FoxPro dialect may now return values. Also the /vo9 options is now enabled by default in the FoxPro dialect. The default return value for a FUNCTION and PROCEDURE is now TRUE in the foxpro dialect and NIL in the other dialects.

•Error messages no longer refer to Xbase types by their internal names (XSharp.__Usual) but by their normal name (USUAL).

MacroCompiler

•Creating classes with a namespace prefix was not working. This has been fixed.

Runtime

•Fixed a problem with ArrayNew() and multiple dimensions

•When calling constructor of the Array class with a number the elements were already initialized. This was not compatible with Vulcan.NET. There is now an extra constructor whtich takes a logical parameter lFill which can be used to automatically fill the array

•The text for the ERROR_STACK language resource has been updated

•Calling Str() with integer numbers was returning a slightly different result from VO. This has been fixed.

•Added support functions for TEXT .. ENDTEXT and TextMerge and an output text file.

•Fixed a problem in the DTOC() function

•You can now add multiple ImplicitNamespace attributes to an assembly

•We have added several FoxPro system variables (only _TEXT does something at this moment)

RDDs

•Zap and Pack operations were not properly setting the DBF file size

•An Append() in shared mode was not properly setting the RecCount

•Opening a file with one of the Advantage SQL RDDs was not working. This has been fixed.

•Writing DateTime.Minvalue to a DBF would not write an empty date but the date 1.1.1 This has been fixed.

VO SDK

•Fixed a problem in ListView:EnsureVisible().

•Some questionable casts (such as the one that cause the previous problem) have been cleaned up

Visual Studio Integration

•Parameter tips for constructor calls were off by one parameter. This has been fixed.

•When looking for types, the XSharp namespace is now the first namespace that is searched.

 

Changes in 2.0.4.0 (Bandol GA)

Compiler

•Fix a problem in assignment expressions where the Left side is an aliased expression with a workarea in parentheses:
(nArea)->LastName := AnotherArea->LastName

•Multiline statements, such as FOR blocks, no longer generate Multiline breakpoints in the debugger.

•Fixed a problem where blank lines or lines with 'inactive' preprocessor comments after a class definition would generate a compiler error.

•Errors for implicit conversions between INT/DWORD and PTR now produce a better error message when they are not supported.

•USUAL.ToObject() could not be called with the latebinding compiler option was enabled. This has been fixed.

•Fixed an internal compiler error with untyped STATIC LOCALs.

•Fixed a problem with aliased expressions.

•Indexing PSZ values is no longer affected by the /az compiler option

MacroCompiler

•Fixed a problem with some aliased expressions

•The macro compiler now detects that you are overriding a built-in function in your own code and will no longer throw an "ambigous method" exception but will choose function from your code over functions defined in the X# runtime

Runtime

•FIxed several problems in the Directory() function

•Fixed problem with indexing PSZ values

•Added StackTrace property on the Error object so also errors caught in a BEGIN SEQUENCE will have stack information.

•Fixed problems with "special" float values and ToString(), such as NaN, PositiveInfinity

•Fixed a problem with RddSetDefault() with a null parameter

•DbInfo(DBI_RDD_LIST) was not returning a value. This has been fixed.

•We have updated many of the language resources, Also the Error:ToString() now uses the language resources for captions like 'Arguments' and 'Description'.

•Low level file errors now include the callstack

•Fixed some problems in AsHexString()

•The DosErrString() no longer gets its messages from the language string tables. The messages have been removed and also the related members in the XSharp.VOErrors enum.

•Added a Turkish language resource.

RDD System

•Fix locking problem in FPT files

•Fixed several problems with OrdKeyCount() and filters, scopes and SetDeleted() setting

•Some DBF files have a value in the Decimals byte for field definitions for field types that do not support decimals. This was causing problems. These decimals are now ignored.

•Opening and closing a DBF without making changes was updating the time stamp. This has been fixed.

•Fixed problems in Pack() and Zap()

•Fixed a problem where custom indexes were accidentally updated.

•Fixed several problems with OrdKeyCount() in combination with Filters, SetDeleted() and scopes.

VO SDK Classes

•Most of the libraries now compile with "Late Binding" disabled for better performance.
To help in doing this some typed properties have been added such as SqlStatement:__Connection which is typed as SQLConnection.

Visual Studio integration

•Fixed a problem in the Brace matching code

•Improved Brace matching for keywords. Several BEGIN .. END constructs have now been included as well as CASE statements inside DO CASE and SWITCH, RECOVER, FINALLY, ELSE, ELSEIF and OTHERWISE

•Fix a problem with adding and deleting references when unloaded or unavailable references existed.

VOXPorter

•The program is now able to comment, uncomment and delete source code lines from the VO code when exporting to XSharp.
You have to add comments at the end of the line. The following comments are supported:

         // VXP-COM : comments the line when exporting it
         // VXP-UNC : uncomments the line
         // VXP-DEL : deletes the line contents
 
         example:
         // METHOD ThisMethodDoesNotGetDefinedInVOcode() // VXP-UNC
         // RETURN NIL // VXP-UNC

 

Changes in 2.0.3.0 (Bandol RC3)

Compiler

•Code generation for STATIC LOCALs of type STRING was not initializing the variables to an empty string when /vo2 was selected. We have also improved code generation for STATIC LOCALs when they are initialized with a compile time constant

•In preparation for the support for variables passed by reference to functions/methods with clipper calling convention we are now assigning back the locals variables to the parameter array at the end of a function/method with clipper calling convention.

•The compiler would not complain if you were assigning a value of one enum to a variable of another enum. This has been fixed.

•Added support for the FoxPro '=' assignment operators. Other dialects also allow the assignment operator but a warning is generated in the other dialects.

•Xbase++ classes inside BEGIN NAMESPACE .. END NAMESPACE were not recognized. This has been fixed.

•Statements inside WITH blocks are no longer constrained to assignment expressions and method calls. You can now use the WITH syntax for expressions anywhere inside a WITH block. If the compiler can't find the WITH variable then it will output a new error message (XS9082)

•Updated the Aliased Expression rules to make sure that compound expressions properly respect the parentheses.

•The __DEBUG__ macro was not always set correctly. We have changed the algorithm that sets this macro. When the DEBUG define is set then this macro gets defined. When the NDEBUG define is set then this macro is not defined. When both defines are absent then __DEBUG__ is NOT set.

•The compiler was allowing you to use the '+' operator between variables/ expressions of type string and logic. This is now flagged as an error.

MacroCompiler

•Fixed a problem with resolving Field names that were identical to keywords or keyword abbreviations (for example DATE and CODE) and for Field names that are equal to built-in function names (such as SET)

•Fixed a problem where a complicated expression evaluated with an alias prefix was not evaluated correctly.

•The macro compiler initializes itself from the Dialect option in the runtime to enable/disable certain behavior.

•The macro compiler now recognizes the "." operator for workarea access and memvar access when running in the FoxPro dialect.

Runtime

•Added functions FieldPutBytes() and FieldGetBytes()

•Added function ShowArray()

•Added several defines that were missing, such as MAX_ALLOC and ASC_A.

•Added Crypt() overloads that accept BYTE[] arguments

•The ClassDescribe() method for DataObject classes (XPP dialect) now includes properties and methods that were dynamically added.

•Fixed a problem with the RELEASE command for MemVars. This was also releasing variables defined outside the current function / method.

•There is now also a difference between the FoxPro dialect and other dialects in the behavior of the RELEASE command.
FoxPro completely deletes the variables, the other dialect set the value of the variables to NIL.

•New PRIVATE memvars are initialized to FALSE in the FoxPro dialect. In the other dialects they are initialized to NIL.

•Some numeric properties in the RuntimeState were giving a problem when a numeric of one type was written and another numeric type was expected when reading. This has been fixed.

•Fixed a problem with return NIL values from Macro compiled codeblocks.

•The parameter to DbClearScope() is now optional

•The USUAL type now allows to compare between values of type PTR and LONG/INT64 The PTR value is converted to the appropriate Integral type and then an Integral comparison is done.

•The USUAL type now also allows comparisons between any type and NIL.

•Casts from USUAL values to SHORT, WORD, BYTE and SBYTE are no longer checked to be compatible with VO.

RDD System

•Added support for different block sizes in DBFFPT.

•DBFFPT now allows to override the block size (when creating) from the users code. Please note that block sizes < 32 bytes prevent the FPT from opening in Visual FoxPro.

•Added support for reading various Flexfile memo field types, including arrays.

•Added support for writing to FPT files

•When creating FPT files we now also write the FlexFile header. Please note that our FPT driver does not support "record recycling" for deleted blocks like FlexFile does. We also only support writing STRING values to FPT files and Byte[] values.

•Added support for Visual FoxPro created CDX files that were created with the COLLATE option. The RDD dll now contains collation tables for all possible combinations of collation and CodePage.

•Added support for USUALs with a NIL value and the comparison operators (>, >=, <, <=). These operators return FALSE, except the >= and <= operators which return TRUE when both sides of the comparison are NIL.

•We exposed several Advantage related function and types. Also the function AdsConnect60() was defined. We have not created functions for all available functions in Ace32 and Ace64, but only the ones needed in the RDD.

•If you are missing a function in the ACE class, please let us know. All functions should be available and accessible now in the Ace32 and Ace64 classes or in the ACEUNPUB32 or ACEUNPUB64 classes.

•The ADS RDD was returning incorrect values for LOGIC fields.

•Fixed some problems with skipping in CDX indexes and scopes and filters.

•Executing DbGoTop() twice or DbGoBottom() twice for DBFCDX would confuse the RDD. This has been fixed.

•Fixed a problem with Seeking() in an empty DBF file

•FieldPut for STRING fields in the Advantage RDD now truncates the fields to the maximum length of the field before assigning the value

•Fixed a problem with UNIQUE CDX Indexes.

•You can now create VFP compatible DBF files with DBCreate(). To do so use the following field types (apart from the normal CDLMN):

W        Blob
Y        Currency
B        Double
T        DateTime
F        Float
G        General
I        Integer
P        Picture
Q        Varbinary
V        Varchar

Special field flags can be indicated by adding a suffix to the type:

"0" = Nullable
"B" = Binary
"+" = AutoIncrement

So this creates a nullable date: "D0" and this creates an autoincremental integer "I+".

Auto increment columns are initialized with a counter that starts with 1 and a step size of 1. You can change that by calling DbFieldInfo:

                 DbFieldInfo(DBS_COUNTER, 1, 100) // sets the counter for field 1 to 100
                       DbFieldInfo(DBS_STEP, 1, 2)          // sets the step size for field 1 to 2

•Fixed a locking problem with FPT files opened in shared mode

•Fixed several problems related to OrderKeyCount() and various settings of Scopes and SetDeleted()  in the DBFCDX RDD.

VO SDK Classes

•Fixed a problem in the DateTimePicker class when assigning only a time value.

•System classes and RDD classes have been cleaned up somewhat and now compile in AnyCPU mode. So this means that you can use the DbServer class in a 64 bit program !
The projects for these two libraries also no longer have the "Late Binding" compiler option enabled. There is still some late bound code in these libraries but this code now uses explicit late bound calls such as Send(), IVarGet() and IVarPut().

•Because of the change in the handling of __DEBUG__ some SDK assemblies are not better optimized.

Visual Studio integration

•Added support for WITH .. END WITH blocks in the editor

•When generating Native Resources (RC files) the BuildSystem now sets a #define __VERSION__. This will have the fileversion number of the XSharp.Build.DLL without the dots. (2.1.0.0 will be written as "2100")

•The XSharp help item in the VS Help menu now opens the local Help (CHM) file

•Fixed a problem in the WCF service template

•Correction to the multi line indenting for code that uses attributes

•Code generation for new Event handlers now includes a RETURN statement, even when VS does not add one to the statement list

•The intellisense option "Show completionlist after every character" has been disabled since it was having a negative impact on performance and would also insert keywords with @@ characters in front of them.

•Several changes to the code parsing for the Windows Forms editor. Comments and Regions should now be saved and regenerated as well as attributes on classes. Also code generation for images from project resources has been fixed as well as parsing of static fields and enumerators declared in the same assembly.
Please note. If you are using values from types defined in the same assembly as the form then the assembly needs to be (re)compiled first before the form can be successfully opened in the Windows Forms Editor.

•New methods generated from the Windows forms editors will now be generated with a closing RETURN statement.

•We have made some improvements to the presentation of QuickInfo in the source code editor.

Tools

•VOXporter now also exports VERSIONINFO resources

 

Changes in 2.0.2.0 (Bandol RC 2)

Compiler

•File wide PUBLIC declarations (for MEMVARs) were incorrectly parsed as GLOBALs. Therefore they were initialized with NIL and not with FALSE. They are now generated correctly as public Memvars. The creation of the memvars and the initialization is done in after the Init3 procedures in the assembly have run.

•Instance variable initializers now can refer other fields and are allowed to use the SELF keyword. This is still not recommended. The order in which fields are initialized is the order in which they are found in the source code. So make sure the field initializers are defined in the right order in your code.

•AUTO properties are now also initialized with an empty string when /vo2 is enabled.

•The compiler was allowing you to define instance variables for Interfaces. They were ignored during code generation. Now an error message is produced when the compiler detects fields on interfaces.

•When the compiler detects 2 ambiguous symbols with different types (for example a LOCAL and a CLASS with the same name) then the error message now clearly indicates the type for each of these symbols.

•Fixed an exception in the Preprocessor

•Added support for the FoxPro runtime DLL.

•The ANY keyword (an alias for USUAL) is no longer supported.

•Keywords that appear after a COLON (":") DOT (".") or ALIAS (->) operator are no longer parsed as keyword but as identifier. This should solve issues with parsing code that for example accesses the Date property of a DateTime class.

•We have added support for the WITH .. END WITH statement block:
 
LOCAL oPerson as Person
oPerson := Person{}
WITH oPerson
  :FirstName := "John"
  :LastName := "Doe"
  :Speak()
END WITH
You can also use the DOT (.) as prefix for the names. The only expressions allowed inside WITH .. ENDWITH are assignments and method calls (like you can see above)

•Added support for the FoxPro LPARAMETERS statement. Please not that a function or procedure can only have a PARAMETERS keyword OR a LPARAMETERS keyword OR declared parameters (names between parentheses on the FUNCTION/PROCEDURE line)

•Added support for the FoxPro THIS keyword and .NULL. keyword

•We have added support for the FoxPro Date Literal format {^2019-06-21} and FoxPro DateTime Literals {^2019-06-21 23:59:59}.

•Date literals and DateTime literals are now also supported in the Core dialect. Date Literals will be represented as DateTime values in the Core dialect.

•The standard header file xsharpdefs.xh now conditionally includes header files for the Xbase++ dialect and FoxPro dialect. These header files do not have much content at this moment, but that will change in the coming months.

•When the compiler detects that some header files are included but that the defines in these header files are also available as constants in references assemblies then a warning will be generated and the include file will be skipped (XS9081)

•The compiler now supports an implicit function _ARGS(). This will be resolved to the arguments array that is passed to functions/methods with clipper calling convention. This can be used to pass all the arguments of a function/method to another function/method.

•We have added the TEXT ... ENDTEXT command for the FoxPro dialect. The string inbetween the TEXT and ENDTEXT lines is passed to a special runtime function __TextSupport that will receive 5 parameters: the string, the merge, NoShow, Flags and Pretext arguments. You will have to define this function yourself for now. it will be included in the XSharp Foxpro runtime in a future version.

•We have added support for END keywords for all entity types that did not have one yet. The new end keywords are optional. They are listed in the table below. The FoxPro ENDPROC and ENDFUNC keywords will be mapped to END PROCEDURE and END FUNCTION with a UDC.

•The compiler now registers the Dialect of the main in the Dialect property of the RuntimeState (Non Core dialects only)

MacroCompiler

•Fixed a problem with escaped literal strings

•Fixed a problem with implicit narrowing conversions

•Fixed a problem with macro compiled alias operations  (Customer)->&fieldName

Runtime

•Fixed a problem in the Round() function.

•Fixed a problem in the ExecName() function.

•Added FoxPro runtime DLL.

•Added XML support functions in the Xbase++ dialect runtime

•Added support for dynamic class creation in the Xbase++ dialect runtime.

•Fixed a problem in the Push-Pop workarea code for aliased expressions.

•converting a NULL to a symbol would cause an exception. This has been fixed.

RDD system

•Fixed several problems in the ADS RDD

•The DBFCDX RDD is now included

•The DBFVFP RDD is now included. This RDD can be used to access files with DBF/FPT/CDX extension and support the Visual Foxpro field types, such as Integer, Double, DateTime and VarChar. Reading files should be fully supported. Writing should also work with the exception of the Picture and General formats and with the exception of the AutoIncremental Integer fields. You can also use the RDD to open the various "definition" files from VFP such as projects, forms and reports. The RDD 'knows' about the different extensions for indexes and memos. You can also open DBC files as normal tables. In a future version we will support the VFP database functionality.

Visual Studio Integration

•You can now specify that multi line statements should indent on the 2nd and subsequent lines.

•Type lookup for functions inside a BEGIN NAMESPACE .. END NAMESPACE did not include the types in this namespace.

•Started intellisense for INLINE methods in the Xbase++ dialect

•Fixed several problems in intellisense

•Improved intellisense for VAR keywords declared in a FOREACH loop

•Several other (smaller) improvements.

Tools

•VOXporter now writes DEFINES in the RC files and no longer literal values.

•VOXporter: fix for module names with invalid chars for filenames

 

---

 

Changes in 2.0.1.0 (Bandol RC 1)

Compiler

•Added support for the so called IF Pattern Expression syntax, which consists of an IS test and an assignment to a variable, prefixed with the VAR keyword:
IF x is Foo VAR oFoo
  ? oFoo:DoSomething()
ENDIF
 
The variable oFoo introduced in the expression will only be visible inside the IF statement.
Of course you can also use the pattern on other places, such as ELSEIF blocks, CASE statements, WHILE expressions etc:
 
IF x is Foo VAR oFoo
  ? oFoo:DoSomething()
ELSEIF x is Bar VAR oBar
  ? oBar:DoSomethingElse()
ENDIF
 

•Fixed a problem with method modifiers and generic methods

•Fixed a problem with partial classes with different casing and destructors

•Fixed a problem with Interfaces and methods with CLIPPER calling convention

•The compiler now generates an error (9077) when an ACCESS or ASSIGN method has Type Parameters and/or Constraint clauses

•Fixed a problem with DEFINEs with specific binary numeric values. Also overflow checking is now always of when calculating the result of numeric operations for the values of a DEFINE.

•When a constant value was added or subtracted to a numeric value < 32 bits then the result was seen as 32 bits by the compiler. This sometimes forced you to use casts in your code. With this change that cast is no longer necessary.

•The compiler allowed you to concatenate non string values and strings and was automatically calling ToString() on the non strings. This is no longer possible. The compiler now generates an error (9078)when it detects this.

•We have added error trapping code to the compiler that should route internal errors to compiler error XS9999. If you see such an error, please let us know.

•DIM arrays of literal strings are now initialized properly.

•There was a problem when switching between dialects when using the shared compiler. It would sometimes no longer detect dialect specific keywords. This has been fixed.

•Fixed a problem where incorrect code was producing an error "Failure to emit assembly"

•Fixed a problem in code that uses _CAST to cast a 32 bits value to 16 bits

•Fixed a problem with overloaded indexed properties where the index parameter in a subclass has a different type than the index parameter in the super class.

•Changed implementation of several aliased operations (ALIAS->FIELD and (ALIAS)->(Expression))

•Changed preprocessor handling of extended strings ( (<token>) )

•The Roslyn code was not marking some variables as 'assigned but not read' to be compatible with the old C# compiler. We are now flagging these assignments with a warning. This may produce a lot of warnings in your code that were not detected before.
To support this we have received some requests to "open up" the support for 1 based indexes in the compiler. In the past the compiler would only allow 1 based indexing for variables of type System.Array or of the XBase ARRAY Type.
We have now added a couple of interfaces to the runtime. If your type implements one of these interfaces then the compiler will recognize this and allow you to use 1 based indexes in your code and then the compiler will automatically subtract 1 from the numeric index parameter. The XSharp ARRAY type and ARRAY OF type now also implement (one of) these interfaces/
The interfaces are:
  INTERFACE IIndexer
      PUBLIC PROPERTY SELF[index PARAMS INT[]] AS USUAL GET SET
  END INTERFACE
 
  INTERFACE IIndexedProperties
      PROPERTY SELF[index AS INT   ] AS USUAL GET SET
      PROPERTY SELF[name AS STRING] AS USUAL GET SET
  END INTERFACE
  INTERFACE INamedIndexer
    PUBLIC PROPERTY SELF[index AS INT, name AS STRING] AS USUAL GET SET
  END INTERFACE

Runtime

•Fixed some problems in the OrderInfo() function

•Fixed several problems with DB..() functions in the runtime

•Fixed several problems with the macro compiler

•Fixed a problem with the handling of default parameters in late bound calls to methods

•Improved error messages for missing methods and/or properties in late bound code.

•The Select() function was changing the current workarea. This has been fixed.

•Converting a USUAL to a STRING was not throwing the same exceptions as VO. It was always calling ToString() on the USUAL. Now the behavior is the same as in VO.

•F_ERROR has been defined as a PTR now and no longer as numeric

•CreateInstance can now also find classes defined in namespaces

•Fix problems with missing parameters in late bound code. Also added (limited) support for calling overloaded methods and constructors in late bound code.

•Fixed problems with TransForm(), and several of the Str() functions.

•XSharp.Core is now fully compiled as Safe code.

•Fixed a problem with late bound assigns and access

•NIL<-> STRING comparisons are now compatible with Visual Objects

•Fixed problem with AEval() and missing parameters

•Added Set() function. Please be careful when using header files for _SET defines. There are subtle differences between the definitions in Harbour, Xbase++ and VO/Vulcan.
We recommend NOT to use the defines from the header file but to use the defines that are defined inside the X# runtime DLLs

•Changed implementation of the functions used by the compiler for Aliased operations

RDD system

•Added support for DBF character fields up to 64K.

•Implemented the DBFCDX RDD

•Fixed several problems related to the DBFNTX RDD

•The DBF RDD was using the incorrect locking scheme for Ansi DBF files. It now uses the same scheme as VO and Vulcan.

•Macro compiled index expressions are not of the type _CodeBlock and not of the type RuntimeCodeBlock (the RuntimeCodeblock is encapsulated inside the _CodeBlock object).
That prevents problems when storing these expressions inside a USUAL

Visual Studio integration

•Fixed an exception that could occur when typing a VAR expression

•When the project system makes a backup of a project file, we are now making sure that Readonly flags are cleared before writing to or deleting existing files.

•Reading intellisense data from C++ projects could send the intellisense engine into an infinite loop. This has been fixed.

•The changes to the Form.Designer.prg are now written to disk immediately, to make sure that changes to the form are recompiled if you press 'Run' or 'Debug' from the window of the form editor

•Improved support for intellisense for the VAR keyword.

•Added support for FoxPro on the Project Properties page to prepare for the Compiler and Runtime changes for FoxPro.

•.CH files are now also recognized as "X#" files in Visual Studio.

•You can now control the characters that select an entry from a Completion List. For example the DOT and COLON now also select the current selected element. The complete list can be found on the Tools-Options-TextEditor-XSharp-Intellisense page.

•Assemblies added to a project would not be properly resolved until the next time the project was loaded. This has been fixed.

•Fixed a problem in the codedom parser which feeds the windows form editor. You can now inherit a form from another form in the same assembly. You will have to compile the project first (of course).

•The .CH extension is now also registered as relevant for the X# project system.

•Changed auto indentation for #ifdef commands

•Fixed an exception that could occur during loading of project files with COM references.

•Added templates for class libraries in XPP and VO Dialect

•Sometimes a type lookup for intellisense was triggered inside a comments region. This has been fixed.

Tools

•VOXPorter was not removing calling conventions when creating delegates. This has been fixed

•VOXporter was sometimes generating project files with many duplicates of resource items. This has been fixed.

•VOXporter now marks prefix identifiers that conflict with one of the new keywords with "@@"

•The delay for the VOXporter welcome screen has been shortened.

---

 

Changes in 2.0.0.9 (Bandol Beta 9)

Compiler

•The Lexer (the part of the compiler that recognizes keywords, literals etc) has been rewritten and is slightly faster.

•The compiler now supports digit separators for numeric literals. So you can now write 1 million as:
1_000_000

•Fixed problem where static local variables were not initialized with "" even when compiler option -vo2 was selected

•#ifdef commands using preprocessor macros such as __XSHARP_RT__ were not working correctly.

•The Xbase++ dialect now also supports the 'normal' class syntax.

•We had changed the 'Entrypoint' algorithm in Beta 8. This has been restored now and the -main command line option now works again as well. In stead the "body" of the Start method is now encapsulated in an anonymous function.

•Duplicate include files no longer produce an error but a warning

•Fix for problem with default parameter values with 'L' or 'U' suffix

•Added compiler error when specifying default parameter values for methods/functions with clipper calling convention

•DIM arrays of STRING were not initialized with "" when /vo2 was specified. This has been fixed.

•Added support for Dbase style memory variables (MEMVAR, PUBLIC, PRIVATE, PARAMETERS). See the MEMVAR topic in the help file for more information. This is only available for certain dialects and also requires the /memvar commandline option

•Added support for undeclared variables (this is NOT recommended!). This is only available for certain dialects and requires the /memvar AND the /undeclared commandline options

•Fixed a problem for comparisons between USUAL variables and STRING variables

•Fixed a problem with partial classes where the classname had different casing in the various declarations

•Fixed a problem with numeric default parameters with L or U suffixes

•Fixed a problem with line continuation semi colons followed by a single line comment with the multiline comments style.

•Fixed a problem with methods containing YIELD statements in combination with compiler option /vo9

•When a visibility modifier was missing on a generic method then this method was created as a private method. This has been fixed.

•When choosing between overloaded functions in XSharp.RT and XSharp.Core the function in the XSharp.RT assembly would sometimes be chosen although the overload in XSharp.Core was better

•CASE statements without CASE block but only a OTHERWISE block would crash the compiler. This has been fixed and an warning about an empty CASE statement has been added.

Runtime

•Several changes to the Macro compiler, such as the parsing of Hex literals, case sensitivity of parameters (they are no longer case sensitive) and limited support for function overloading.

•Several missing functions have been added, such as _Quit(),

•The return value of several Ord..() functions was incorrect. This has been fixed.

•Fixed a problem with CurDir() for the root directory of a drive

•Fixed a problem with calling Send() with a single parameter with the value NULL_OBJECT.

•Solved problem with incorrect parameters for DiskFree() and DiskSpace()

•MemoRead() and MemoWrit() and FRead..() and FWrite..() now respect the SetAnsi() setting like the functions in the VO Runtime.

•We have added 2 new functions to read/write binary files: MemoReadBinary() and MemoWritBinary()

•Not all DBOI_ enum values had the same value as in Vulcan. This has been solved.

•SetDecimalSep() and SetThousandSep() now also set the numeric separators in the current culture.

•The USUAL -> STRING conversion now calls AsString()

•Added support for Dbase style dynamic memory variables (MEMVAR, PUBLIC, PRIVATE, PARAMETERS). See the Memory Variables topic in the help file for more information.

•The IsDate() function now also returns TRUE for USUALs of type DateTIme. There is also a separate IsDateTime() function. We have also added IsFractional() (FLOAT or DECIMAL) and IsInteger (LONG or INT64) and IsInt64()

•Added missing Cargo slot to the Error class. Also improved Error:ToString()

•Fix for problem in W2String()

•And many more small changes.

Visual Studio Integration

•We have added a new tab page in the Project Properties dialog: Dialect. This contains dialect specific language options.

•2 options from the Build options page (which is configuration dependent) have been moved to the Language page (which is build INdepedent), because that makes more sense:

•Include Path

•NoStdDef

•We have also added a project property on the Language page to specify an alternative standard header file (in stead of XSharpDefs.xh)

•The XSharp.__Array type was shown in the intellisense with the wrong name

•We have added entries on the Project Properties dialog pages to enable MEMVAR support and to enable Undeclared variables

•Fixed a problem in the CodeDom provider (used by the Windows Form editor) where fields with array types were losing their array brackets when writing back to the source.

•When writing changes from the windows form editor we are no longer writing to disk but to the opened (sometimes invisible) windows of the .designer.prg. This should prevent warning messages about the .designer.prg file that was changed outside Visual Studio

•Fixed a problem parsing source code where identifier names were starting with '@@'

•The Debugger was showing UINT64 as typename for ARRAYs. This has been fixed.

•Renaming forms in the Windows Forms editor was not working for forms with a separate .designer.prg. This has been fixed.

•Fixed a (very old) problem where the OutPutPath property in the xsproj file was sometimes set to $(OutputPath).

•Fixed an exception in the editor for empty source files or header files.

•Fixed an exception when the error list was created for errors without errorcode

•Commenting a single line in the editor will now always use the // comment format

Tools

•No changes in this release.

---

 

Changes in 2.0.0.8 (Bandol Beta 8)

Compiler

•The compiler source code has been upgraded to Roslyn 2.10 (C# 7.3). As a result of that there are some new compiler options, such as /refout and we also support the combination of the "PRIVATE PROTECTED" modifier that defines a type member as accessible for subclasses in the same assembly but not for subclasses in other assemblies

•We have added support for Xbase++ class declarations. See the Xbase++ class declaration topic for more information about the syntax and what is supported and what not.

•We have added support for simple macros with the &Identifier syntax

•We have added support for late bound property access:

oThe <Expression>:&<Identifier> syntax.
This translates to IVarGet(<Expression>, <Identifier>).

oThe <Expression>:&(<Expression2>) syntax.
This translates to IVarGet(<Expression>, <Expression2>).

oBoth of these can also be used for assignments and will be translated to IVarPut:
<Expression>:&<Identifier> := <Value>
This becomes IVarPut(<Expression>, <Identifier>, <Value>)

oAll of these will work even when Late Binding is not enabled.

•We have added a new compiler options /stddefs that allows you to change the standard header file (which defaults to XSharpDefs.xh)

•We have added a new preprocessor Match marker <#idMarker> which matches a single token (all characters until the first whitespace character)

•When you select a dialect now, then the compiler will automatically add some compiler macros. The VO dialect declares the macro __VO__, the Vulcan dialect declares the macro __VULCAN__ the harbour dialect declares the macro __HARBOUR__ and the Xbase++ dialect declares the macro __XPP__.

•When compiling against the X# runtime then also the macro __XSHARP_RT__ will be defined.

•We have added a new warning when you pass a parameter without 'ref' modifier (or @ prefix) to a method or function that expects a parameter by reference or an out parameter.

•We have also added a warning that will be shown when you assign a value from a larger integral type into a smaller integral type to warn you about possible overflow problems.

Runtime

•This build includes a new faster macro compiler. It should be fully compatible with the VO macro compiler. Some of the .Net features are not available yet in the macro compiler.

•We moved most of the generic XBase code to XSharp.RT.DLL. XSharp.VO.DLL now only has VO specific code. We have also added XSharp.XPP.DLL for XPP

•Fix Ansi2OEM problem with FRead3(), FWrite3() and FReadStr

•Added  missing functions EnableLBOptimizations() and property Array:Count

•Fixed problem with latebound assign with CodeBlock values

•Fixed problem with AScan() and AEval() with missing parameters

•Changed error return codes for DirChange(), DirMake() and DirRemove()

•Send() was "swallowing" errors. This has been fixed

•Fixed a problem with assigning to multi dimensional arrays

•Fixed a problem with creating objects with CreateInstance() where objects are not in the "global" namespace

•Fixed several problems in the RDD system and support functions.

•Fixed several problems in the late binding support, such as IsMethod, IsAccess, IVarPut, IVarPutSelf etc.

•Fixed several problems with TransForm()

•Integer divisions for usuals containing integers now return either integers or else fractional numbers depending on the compiler setting of the main app.

•We fixed several conversions problems during late bound calls

•We have fixed several problems with the Val() and Str() functions.

•The internal type names for DATE and FLOAT have been changed to __Date and __Float. If you rely on these type names please check your code !

•DebOut32 was not outputting data to the debug terminal if the runtime was compiled in release mode. This has been fixed.

Visual Studio Integration

•Fixed filtering on 'current project' in the error list

•Type lookup for local variables was sometimes failing. This has been fixed

•Fixed a problem with Brace Matching that could cause an exception in VS

•Fixed a problem with Tooltips that could cause an exception in VS

•Fixed a problem with uncommenting that could cause an exception in VS

•New references added in VS would not always be included in the type search in the editor. This has been fixed.

•Member prototypes for constructors now include the type name and curly braces

•We have started work on improved code completion for variables declared with VAR

•We have started with support for code completion for members of Generic types. This is not finished yet.

•PRG files that are not part of a X# project and not part of a Vulcan project are now also colorized in the editor.

Tools

•VulcanXPorter was always adjusting the referenced VO libraries and  was ignoring the "Use X# Runtime" checkbox

•VOXPorter now has an option to copy the resources referenced in the AEF files to the Resources subfolder in the project

•VOXPorter now also copies the cavowed, cavofed and cavoded template files to the properties folders in your project.

---

 

Changes in 2.0.0.7 (Bandol Beta 7)

Compiler

•When calling a runtime function with a USUAL parameter the compiler now automatically prefers methods or functions with "traditional' VO types over the ones with enhanced .Net types. For example when there are 2 overloads, one that takes a byte[] and another that takes a string, then the overload that takes a string will get preference over the overload that takes a byte[].

•Resolved a problem with .NOT. expressions inside IIF() expressions

•Improved debugger break point generation for Invoke expressions ( like String.Compare())

•Fixed a pre-processor error for parameters for macros defined in a #define. These parameters must have the right case now. Parameters with a different case will not be resolved any longer.

•Fixed a pre-processor error where optional match patterns in pre-processor rules were repeated. This is too complicated to explain here in detail <g>.

•The code generated by the compiler for Array operations now uses the new interfaces declared in the X# runtime (see below).

Runtime

•We have added several missing functions, such as _GetCmdLine, Oem2AnsiA() and XSharpLoadLibrary

•Fixed problems in CreateInstance, IVarGet, IVarPut(), CtoDAnsi() and more.

•Added VO Compatible overload for FRead4()

•No longer (cathed) exceptions are produced for empty dates

•Ferror() was not always return the error of a file operation. This has been fixed

•We have added a new FException() function that returns the last exception that occurred for a low level file operation

•Casting a usual containing a PTR to a LONG or DWORD is now supported

•Some new interfaces have been added related to array handling. The compiler no longer inserts a cast to Array inside the code, but inserts a cast to one of these interfaces depending on the type of the index parameter. The USUAL type implements IIndexer and IIndexProperties and dispatches the call to the objects inside the usual when this objects exposes the interface. This is used for indexed access of properties when using AEval or AScan on an ARRAY OF <type>

oXSharp.IIndexer

oXSharp.INamedIndexer        

oXSharp.IIndexedProperties
 

SDK Classes

•We have added the Hybrid UI classes from Paul Piko (with permission from Paul)

Tools

•The Vulcan XPorter now also has an option to replace the runtime and SDK references with references to the X# runtime

---

 

Changes in 2.0.0.6 (Bandol Beta 6)

Compiler

•The compiler was sometimes still generating warnings for unused variables generated by the compiler. This has been fixed.

•The compiler will now produce a warning that #pragmas are not supported yet (9006)

•Added compiler macro __FUNCTION__ that returns the current function/method name in original casing.

•Literal sub arrays for multidimensional arrays no longer need a type prefix when compiling in the Core dialect

•Fixed problem with the Global class name that would happen when building the runtime assemblies (these have a special convention for the global class names)

•When the calling convention of a method in an interface is different from the calling convention of the implementation (CLIPPER vs Not CLIPPER) then a new error (9067) will be generated by the compiler.

•The calling convention for _DLL functions and procedures is now optional and defaults to PASCAL (stdcall)

•The namespace alias for using statements was not working in all cases.

•The compiler will now generate an error for code that incorrectly uses the VIRTUAL and OVERRIDE modifiers.

•The compiler was throwing an exception for a specific kind of incorrect local variable initializer with generic arguments. This has been fixed.

•Visibility modifiers on GET or SET accessors for properties were not working correctly (INTERNAL, PRIVATE etc). This has been fixed.

•The compiler now handles PSZ(_CAST,...) and PSZ(..) differently. When the argument is a literal string, then the PSZ will only be allocated once and stored in a "PSZ Table" in your assembly. The lifetime of this PSZ is then the lifetime of your app. When this happens then the new compiler warning XS9068 will be shown.
When the argument is a string stored in a local or global (or define) then the compiler can't know the lifetime of the PSZ. It will therefore allocate the memory for the PSZ with the StringAlloc() function. This ensures that the PSZ will not go out of scope and be freed. If you use this a lot in your application then you may be repeatedly allocating memory. We recommend that you avoid the use of the cast and conversion operators for PSZs and take control of the lifetime of the PSZ variables by allocating and freeing the PSZ manually. PSZ casts on non strings (numerics or pointers) simply call the PSZ constructor that takes an intptr (this is used on several spots in the Win32API library for 'special' PSZ values).

•Named arguments are now also supported in the Vulcan dialect. This may lead to compiler errors if your code looks like the code below, because the compiler will think that aValue is a named argument of the Empty() function.
 
IF Empty(aValue := SomeExpression())
 

•If you were inheriting a static class from another class then you would get a compiler warning before. This is now a compiler error, because this had a side effect where the resulting assembly contained a corrupted reference.

•The overload resolution code now chooses a type method/function over a method/function with clipper calling convention.

•The Xbase++ dialect is now recognized by the compiler. For the time being it behaves the same as Harbour. We have also added the compiler macro __DIALECT_XBASEPP__ that will be automatically define to TRUE when compiling in Xbase++ mode.

•Fixed a problem in the PDB line number generation that would cause incorrect line numbers in the debugger

Visual Studio integration

•The source code editor was not always showing the correct 'active' region for #defines defined in #include files.

•Opening a source file without entities (e.g. a header file) could result in an error message inside VS.

•Fixed a null reference exception in the editor

•Fixed a problem when un-commenting code in the editor

•Improved load time performance for large solutions with many dependencies.

•Fixed a problem where the intellisense engine could lock a DLL that was used by a project reference or assembly reference.

•Fixed a problem where missing references (for example COM references that were not installed on the developers machine) could cause problems with the type lookup when opening forms in the windows forms editor.

•Added an option to select the Harbour dialect on the project properties page.

The Build System

•The Build system did not recognize that begin NAMESPACE lines in source code were commented out. This has been fixed.

VOXporter

•We have added an option to sort the entities in alphabetical order in the output file.

•We have added an option so you can choose to add the X# Runtime as reference to your application (otherwise the Vulcan runtime is used)

Runtime

•The SetCentury setting was incorrect after calling SetInternational(#Windows). This has been fixed.

•The Descend function for dates now returns a number just like in VO

•The functions ChrA and AscA have been renamed to Chr() and Asc() and the original functions Chr() and Asc() have been removed. The original functions were using the DOS (Oem) codepage and this is not compatible with Visual Objects.

•On several places in the runtime characters were converted from 8 bit to 16 bit using the System.Encoding.Default codepage. This has been changed. We use the codepage that matches the WinCodePage in the Runtimestate now. So by setting the Windows codepage in the runtime state you now also control the conversions from Unicode to Ansi and back

•The Oem2Ansi conversion was incorrect for some low level file functions.

•We have changed several things in the Late Binding support

•All String - PSZ routines (String2PSz(), StringAlloc() etc) now use the Windows Codepage to convert the unicode strings to ansi.

•If you library is compiled with 'Compatible String comparisons' but the main app isn't, then the string comparisons in the library will follow the same rules as the main app because the main app registers the /vo13  setting with the runtime. The "compatible" stringcomparison routines in the runtime now detect that the main app does not want to do VO compatible string comparisons and will simply call the normal .Net comparison routines.
We therefore recommend that 3rd party products always use the Compatible String comparisons in their code.

•Preliminary documentation for the runtime was generated from source code comments and has been included as chapter in this documentation.

The VO SDK

•This build includes the first version of the VO SDK compiled against the X# runtime. We have included the following class libraries

oWin32API

oSystem Classes

oRDD Classes

oSQL Classes

oGUI Classes

oInternet Classes

oConsole Classes

oReport Classes

•All assemblies are named VO<Name>.DLL and the classes in these assemblies are in the VO namespace.

•This SDK is based on the VO 2.8 SP3 source code. The differences between VO 2.8 SP3 and VO 2.8 SP4 will be merged in the source later,

•The Libraries for OLE, OleServer and Internet Server are not included. The OleAutoObject class and its support classes is included in the XSharp.VO library. OleControl and OleObject are not included.

•Preliminary documentation for these classes was generated from source code comments and has been included as chapter in this documentation.

The RDD system

•This build includes the first version of the RDD system. DBF-DBT is ready now. Other RDDs will follow in the next builds. Also most of the RDD related functions are working in this build.

•This build also includes the first version of the Advantage RDD. With this RDD you can access DBF/DBT/NTX files , DBF/FPT/CDX files and ADT/ADM/ADI files. The RDD names are the same as the RDD names for Vulcan. (AXDBFCDX, AXDBFNTX, ADSADT). We also support the AXDBFVFP format and the AXSQLCDX, AXSQLNTX, AXSQLVFP. For more information about the differences and possibilities of these RDD look in the Advantage documentation.
We have coded the Advantage RDD on top of the Advantage Client Engine. Our RDD system detects if you are running in x86 or x64 mode and calls functions in Ace32 or Ace64 accordingly.
To use Advantage you copy the support DLLs from an Advantage Vulcan RDD to the folder of your application. Look at the Advantage docs for Vulcan to see the list of the DLLs. The Advantage RDD is part of the standard XSharp.RDD.DLL which therefore replaces the AdvantageRDD.Dll for Vulcan.

•The XSharp.Core DLL now also has RDD support. We have chosen NOT to implement this in functions, but as static methods inside the CoreDb class. Old code that uses the VoDb..() functions can be simply ported by changing "VoDb" to "CoreDb."
The parameters and return values that are USUAL in VO and Vulcan are implemented as OBJECT in the CoreDb class.
The ..Info() methods have 2 overloads. One that takes an Object and one that takes a reference to an object.
The methods inside CoreDb return success or failure with a logical value like the VODB..() functions in VO. If you want to know what the error was during the last operation then you can access that with the method CoreDb._ErrInfoPtr() . This returns the last exception that occurred in a RDD operation.

•At this moment the CoreDb class only has a FieldGet() that returns an object. We will add some extra methods that return values in a specified type in the next build (such as FieldGetString(), FieldGetBytes() etc). We will also add overloads for FieldPut() that take different parameter types.

•The XSharp.VO DLL has the VoDb..() functions and the higher level functions such as DbAppend(), EOF(), DbSkip() etc.
The VoDb..() functions return success or failure with a logical value. If you want to know what the error was during the last operation then you can access that with the method _VoDbErrInfoPtr() . This returns the last exception that occurred in a RDD operation.

•You can mix calls to the VoDb..() functions and CoreDb...() methods. Under the hood the VoDb..() functions also call the CoreDb methods.

•The higher level functions may throw an exception just like in VO. For example when you call them on a workarea where no table is opened. Some functions simply return an empty value (like Dbf(), Recno()). Others will throw an exception. When you have registered an error handler with ErrorBlock() then this error handler will be called with the error object. Otherwise the system will throw an exception.

•Date values are returned by the RDD system in a DbDate structure, Float values are returned in a DbFloat structure. These structures have no implicit conversion methods. They do however implement IDate and IFloat and they can and will be converted to the Date and Float types when they are stored in a USUAL inside the XSharp.VO DLL. The DbDate structure is simply a combination of a year, month and date. The DbFloat structure holds the value of fields in a Real8, combined with length and the number of decimals.

•More documentation about the RDD system will follow later. Of course you can also look at the help file and source code on GitHub.

 

Changes in 2.0.0.5 (Bandol Beta 5)

Compiler

•The strong named key for assemblies with native resources was invalid. This has been fixed

•When an include file was included twice for the same source (PRG) file then a large number of compiler warnings for duplicate #defines would be generated. Especially when the Vulcan VOWin32APILibrary.vh was included twice then over 15000 compiler warnings would be generated per source file where this happened. This large number of warnings could lead to excessive memory usage by the compiler. We are now outputting a compilation error when we detect that the same file was included twice. We have also added a limit of 500 preprocessor errors per source (PRG) file.

•A change in Beta 4 could result in compiler warnings about unused variables that were introduced automatically by the X# compiler. This warning will no longer be generated.

•The compiler now correctly stores some compiler options in the runtime state of XSharp.

Runtime

•Fixed a problem in the Ansi2OEM and OEM2Ansi functions.

•Fixed a problem in the sorting for SetCollation(#Windows)

•Fixed a problem with string comparisons in runtime functions like ASort(). This now also respects the new runtime property CompilerOptionVO13 to control the sorting

Visual Studio integration

•The sorting of the members in the editor dropdown for members was on methodname and propertyname and did not include the typename. When a source file contained more than one type then the members would be mixed in the members dropdown

Build System

•The default value for VO15 has been changed back from false to undefined.

---

 

Changes in 2.0.0.4 (Bandol Beta 4)

Compiler

•POSSIBLY BREAKING CHANGE: Functions now always take precedence over same named methods. If you want to call a method inside the same class you need to either prefix it with the typename (for static methods) or with the SELF: prefix. If there is no conflicting function name then you can still call the method with just its name. We recommend to prefix the method calls to make your code easier to read.

•The compiler was accepting just an identifier without a INSTANCE, EXPORT or other prefix and without a type inside a class declaration. It would create a public field of type USUAL. That is no longer possible.

•Improved the positional keyword detection algorithm (this also affects the source code editor)

•The || operator now maps to the logical or  (a .OR. b) and not to the binary or (_OR(a,b))

•The VAR statement now also correctly parses
 
VAR x = SomeFunction()
 

•Error messages about conflicting types now include the fully qualified type name.

•The compiler no longer includes the width for literal Floats. This is compatible with VO.

•A Default parameter of type Enum is now allowed.

Runtime

•Added several functions that were missing, such as __Str() and DoEvents()

•Fixed a problem in the macro compiler with non-english culctures.

•Added several overloads for Is..() functions that take a PSZ instead of a string, such as IsAlpha() and IsUpper().

•Added some missing error defines, such as E_DEFAULT and E_RETRY.

•Fix for a problem with SubStr() and a negative argument

•Fix for a problem with IsInstanceOf()

•Fix for a problem with Val() and a hex value with an embedded 'E' character

•Added implicit conversions from ARRAY to OBJECT[] and back.

•Several changes to the code for Transform() and Unformat() to cover several exotic picture formats

•Changes to the code for SetCentury() to automatically also adjust the date format (SetDateFormat())

•Fixes for the Str() family of functions in combination with SetFixed() and SetDigitFixed().

Visual Studio integration

•Fixed a problem when building projects in the latest build of Visual Studio

•Several 'keywords' were not case synchronized before, such as TRUE, FALSE, NULL_STRING etc,

•Keywords are not case synchronized on the current line as long as the user has the cursor on them or immediately after them. That means that when you type String and want to continue to change it to StringComparer then the formatter will no longer kick in and change "String" to the keyword case before you have the chance to complete the word.

•The Control Order dialog inside the form editor was not saving its changes.

•Added an option to include all entities from the editor, or just the members from the current selected type in the right dropdown of the editor

•The editor was also matching braces inside literal strings and comments. This has been fixed.

•Fixed a problem with the CodeDom parser where extended strings (strings containing CRLF tokens or other special tokens) were parsed incorrectly. This resulted in problems in the windows forms editor.

•The member resolution code in the editor was not following the same logic as the compiler: When a function and a method with the same name exist it was resolving to the method in stead of the function. This has been fixed.

•Fixed a problem when debugging in X64 mode.

•Fixed an exception when comparing source code files with SCC integration.

•Fixed several problems w.r.t. the XAML editor:

oCode is now generated with STRICT calling convention to avoid problems when compiler option "Impliciting CLIPPER calling convention" is enabled

oWPF and other templates now include STRICT calling convention for the same reason

oThe XAML editor could not properly load the current DLL or EXE and had therefore problems resolving namespaces and adding user controls to the tool palette. This has been fixed.

•We have added an option to the Tools/Editor/XSharp/Intellisense options that allow you to control how the member combobox in the editor works. You can choose to only show methods & properties of the current type or all entities in the right combobox. The left combobox always shows all types in the file.

•Some of the project and item templates have been updated. Methods and constructors without parameters now have a STRICT calling convention. Also the compiler option /vo15 has been explicitly disabled in templates for the Core dialect.

---

 

Changes in 2.0.0.3 (Bandol Beta 3)

Compiler

•When 2 method overloads have matching prototypes the compiler now prefers the non generic one over the generic one

•Fixed an exception that could occur when compiling a single line of source code with a preprocessor command in it.

Runtime

•Added Mod() function

•Added ArrayNew() overload with no parameters

•Fixed problem in __StringNotEquals() when length(RHS) > length(LHS) and SetExact() == FALSE

•Added missing string resource for USUAL overflow errors

Visual Studio integration

•Improved keyword case synchronization and indenting. Also a source file is 'Keyword Case' synchronized when opened.

•Opening a source file by double clicking the find results window no longer opens a new window for the same source file

•Improved type lookup speed for intellisense

•Fixed a problem that would prevent type lookup for types in the same namespace

•Fix for QuickInfo problem introduced in the latest Visual Studio 2017 builds

•QuickInfo tips are no longer shown in the debugger where they were overlapping with debugger tooltips

•The comboboxes with methods and functions in the editor window no longer shows parameter names and full type names. Now it shows the shortened type names for the parameters

•These same comboboxes now show the file name for methods and properties defined in another source file

•Fixed problem in the window editor with generating code for tab pages

Vulcan XPorter

•Project dependencies defined in the solution file were not properly converted

VO XPorter

•Fixed a problem where resource names were replaced with the value of a define

---

 

Changes in 2.0.0.2 (Bandol Beta 2)

Compiler

•The compiler now transparently accepts both Int and Dword parameters for XBase Array indices

•When the compiler finds a weakly typed function in XSharp.VO and a strongly typed version in XSharp.Core then it will choose the strongly typed version in XSharp.Core now.

•In the VO and Vulcan dialect sometimes an (incorrect) warning 'duplicate usings' was displayed. This is now suppressed.

•The debugger information for the Start function has been improved to avoid unnecessary step back to line 1 at the end of the code

•The debugger break point information for BEGIN LOCK and BEGIN SCOPE has been improved

•The debugger break point information for multi line properties has been improved

•/vo6, /vo7 and /vo11 are now only supported in the VO/Vulcan dialect

Runtime

•Removed DWORD overloads for Array indexers

•Fixed overload problem for ErrString()

•Fixed overload problem for _DebOut()

•Fixed problems in DTOC() and Date:ToString()

•Fixed ASort() incompatibilities with VO

•Fixed memory blocks now get filled with 0xFF when they are released to help detect problems

Visual Studio

•Fix 'Hang' in VS2017 when building

•Fix 'Hang' in VS2017 when a tooltip (QuickInfo) was displayed

•Fixed problem with debugging x64 apps

•You can no longer rename or delete the Properties folder

•Selecting 'Open' from the context menu on the the Properties folder now opens the project properties screen

•Updated several icons in the Project Tree

•Enhancements in the Goto Definition

Build System

•Fix problem with CRLF in embedded resource commandline option

---

 

Changes in 2.0.0.1 (Bandol Beta 1)

Compiler

New features

•Added support for ARRAY OF language construct. See the Runtime chapter  for more information about this.

•Added support for the X# Runtime assemblies when compiling in the VO or Vulcan dialects.

•Added support for the "Pseudo" function ARGCOUNT() that returns the # of declared parameters in a function/method compiled with clipper calling convention.

•Added a new warning number for assigning values to a foreach local variable. Assigning to USING and FIXED locals will generate an error.

Optimizations

•Optimized the code generation for Clipper calling convention functions/methods

•The /cf and /norun compiler options are no longer supported

•The preprocessor no longer strips white space. This should result in better error messages when compiling code that uses the preprocessor.

•Some parser errors are now more descriptive

•Changed the method that is used to determine if we compile against CLR2 or CLR4. The compiler checks at the location either system.dll or mscorlib.dll. When this location is in a path that contains "v2", "2.", "v3" or "3." then we assume we are compiling for CLR2. A path that contains "V4" or "4." is considered CLR4. The /clr commandline option for the compiler is NOT supported.

•The preprocessor now generates an error when it detects recursive #include files.

Bug fixes

•Fixed a problem when using the [CallerMemberAttribute] on parameters when compiling in Vulcan or VO Dialect

•Abstract properties should no longer generate a warning about a body

•You can now correctly use ENUM values as array indexes.

•Fixed a problem for Properties with PUBLIC GET and PRIVATE SET accessors.

•Fixed an issue where assigning an Interface to a USUAL required a cast to Object

•Fixed an issue where IIF expressions with literal types were returning the wrong type (the L or U suffix was ignored)

•Fixed an issue where the declaration LOCAL x[10] was not compiled correctly. This now compiles into a local VO Array with 10 elements.

Visual Studio Integration

•Build 1.2.1 introduced a problem that could cause output files to be locked by the intellisense engine. This has been fixed

•The editor parser had problems with nested types. This has been fixed

•Enum members were not included in code completion for enums inside X# projects

•Some improvements in the code reformatting

•Added option on the Tools/Options for the editor to include keywords in the "All tokens" completion list

•Fixed a problem where assemblies that could not be loaded to retrieve meta information would be retried 'for ever'

•Fixed a problem with retrieving type information from assemblies that contained both managed and unmanaged code.

•Added some properties for referenced assemblies to the IDE Properties window

•Fixed a problem with assembly references and the Windows Forms editor, introduced in one of the latest Visual Studio 2017 updates

•When enabling XML output on the Project Properties window an incorrect filename was shown for assemblies that contain a '.'in the assembly name.

•The editor parser now has better support for parameters of type REF and OUT

•Added support for 'Embed Interop Types' in the property windows for Assembly References and COM references

•Fixed a problem where the codemodel was sometimes locking output DLLs for Project references

Build System

•Fixed a problem with the naming of the XML documentation file.

Runtime

•Added XSharp.Core.DLL, XSharp.VO.DLL and XSharp.Macrocompiler.DLL.
Most runtime functions are implemented and supported. See the X# Runtime chapter for more information
 

VO XPorter

•SDK related options have been removed. They will be moved to a new tool later.

---

 

Changes in 1.2.1

Compiler

•Fixed a problem where a compilation error resulted in the message "Failed to emit module" without further information

•Fixed a problem with ++, -- += and similar operations in aliased expressions (like CUSTOMER->CUSTNO++)

•Constructor initializers and Collection initializers were not working after a constructor with parameters. That has been fixed.

•Fixed an issue with negative literal values stored in a USUAL when overflow checking was enabled.

•For the CATCH clause now both the ID and the TypeName are optional. This means that there are 4 variations.
You can only have one catch clause without type, since this defaults to the System.Exception type. However, you can have many catch clauses without ID.

  CATCH ID AS ExceptionType
  CATCH ID                 // defaults to Exception type
  CATCH AS ExceptionType  
  CATCH           // defaults to Exception type

Visual Studio Integration

•Improved the speed of the background code scanning

•Improved the speed of the background parser inside the editor

•Fixed a problem in the codedom provider that is used by the windows forms editor

---

 

Changes in 1.2.0

Compiler

•You can now pass NULL for parameters declared by reference for compatibility with VO & Vulcan.
We STRONGLY advise not to do this, unless you make sure that the function expects this and does not assign to the reference parameter without checking for a NULL reference first. This will only work when the /vo7 compiler option is enabled.

•We have made some optimizations in the Lexer. The compiler should be a little faster because of that

•We fixed a problem with the automatic constructor generation (/vo16) for classes that inherit from classes defined in an external DLL

•When compiling with /vo2 any string fields assigned in a child class before the super constructor was called would be overwritten with an empty string. The generated code will now only assign an empty string when the string is NULL.
Note: we do not recommend to assign parent fields in the child constructor before calling the super constructor. Manually coded default values for parent fields will still overwrite values assigned in the child constructor before the SUPER call

•Fixed a problem with CHECKED() and UNCHECKED() syntax in the VO dialect

•Fixed a problem with choosing overloads for methods where an overload exists with  a single object parameter and also an overload with an object[] parameter.

•Added support to the parser for LOCAL STATIC syntax

•Fixed a problem with compiler option /vo9 (Allow missing return values) and procedures or methods that return VOID

•Improved debugger sequence point generation. The compiler no longer generates 'hidden' breakpoint information for startup and closedown code in the VO/Vulcan dialects, and for expression statements no longer a double step is necessary.

•ACCESS and ASSIGN for partial classes could generate error messages without source file name. This has been solved.
The compiler now generates slightly different code for these "partial" properties.
The Access and Assign are implemented as compiler generated methods and the property getter and property setter now call these methods.

•The compiler was not recognizing the _WINCALL calling convention. This has been fixed.

•The compiler now generates a warning when the #pragma command is used

Visual Studio Integration

•More performance improvements in the editor. Especially large source files with incorrect code could slow down the editor.

•The editor parser no longer tries to parse include files repeatedly when these files contain #defines only (like the Vulcan header files)

•The source code editor tried to show intellisense for words in a comment region. That has been fixed.

•We have started work on Object Browser and Class Browser.

•Opening and closing of projects should be slightly faster

•The internal code model used by the editors now disposes its loaded information when projects are closed and no projects need this information anymore. This should reduce the memory usage of the X# project system

•Matching keywords, such as IF .. ENDIF and FOR .. NEXT should now be highlighted in the editor

•If you select an identifier in the editor then that identifier will be highlighted in the current method/function on all places where it is used

•We have added several features that you need to enable/disable on the Tools/Options/Text Editor/XSharp/Intellisense dialog:

oThe code completion in the editor also supports instance member completion when a dot is pressed.
Please note that the compiler ONLY accepts this in the Core language, not in the VO & Vulcan dialect. So the option has no effect inside projects with other dialects.

oWe have added some options to control the sorting of the DropDown comboboxes in the editor, as well as if fields/instance variables should be included in these comboboxes. When you do not sort, then the entries in the dropdown box will be shown in the order in which they are found in the source file.

oWe have added the option to autocomplete identifiers when typing. This includes locals, parameters, class fields, namespaces, types etc.

•Overridden methods in subclasses with the same signature as the parent methods they override are no longer counted as overloads in completionlists

•A missing reference DLL could "kill" the intellisense engine. This no longer happens. Of course the type info from a missing referenced DLL is not included.

•Properties and methods in the generated source files for XAML code (the .g.prg files in the OBJ folder) are now also parsed and included in the completion lists in intellisense and in the Class Browser and Object Browser windows.

VOXPorter

•The installer now includes the correct version of VOXPorter <g>

•VOXporter now supports the following commandline options:
       /s:<source folder or aef>

         /d:<destination folder>

         /r:<runtime folder>

         /nowarning

 

•Some code corrections were added for issues found in the GUI classes

•The template files can now also be found when VOXPorter is run from a different working directory

---

 

Changes in 1.1.2

Compiler

•Added compiler warning for code that contains a #pragma

•Fixed a problem with iif() functions and negative literal values

Visual Studio Integration

•Fixed a slowness in the editor after typing a send (: ) operator

•Enum values are now properly decoded in the debugger

•Fixed the CodeDom provider for handling literal FALSE values and negative numbers. As a result, more (Vulcan created) winforms should open without problems

•Some positional keywords (such as ADD and REMOVE) are no longer colored as keyword in the editor for incomplete code when they appear after a colon ‘:’ or dot ‘.’;

VOXPorter

•Fixes for exporting the VO RDD Classes from the SDK

 

---

 

Changes in 1.1.1

Compiler

•Fixed a problem with Debugger Breakpoints for DO CASE and OTHERWISE

•Fixed a problem with Debugger Breakpoints for sourcecode that is defined in #included files

•Added support for the Harbour Global Syntax where the GLOBAL keyword is optional

•Fixed a problem with FOR.. NEXT loops with negative step values

•In some situations the @@ prefix to avoid keyword conflicts was not removed from workarea names or field names. This has been fixed

•In the VO/Vulcan dialect a warning (XS9015) was generated when a default parameterless SUPER constructor call was automatically generated. This error message is now suppressed. However a generated SUPER constructor call with parameters still generates a warning.

•Prepared the compiler for Xbase type names and function names in the XSharp Runtime

Preprocessor

•Fixed a crash in the preprocessor

•The preprocessor was generating an error "Optional block does not contain a match marker" for blocks without match marker. This is now allowed.
(for example for the ALL clause in some of the Database UDCs )

•When the same include files was used by multiple source files, and different sections of this file were included because of different #ifdef conditions, then the preprocessor would get "confused". This has been fixed.

•Debugger file/line number information from source code imported from #include files is not processed correctly.

Visual Studio Integration

•Fixed several issues with the Windows Form Editor

•The class declaration generated by the VO compatible editors now included the PARTIAL modifier.

---

 

Changes in 1.1

Compiler

•Fixed a problem with Codeblocks used in late bound code after the release of X# 1.0.3

•Fixed a problem with overriding properties in a subclass that inherit from a class where only the Assign (Set) or Access (Get) are defined.

•The compiler option /vo16: automatically generate VO Clipper constructors has been implemented.

•Fixed a crash in the compiler for compiler errors that occur on line 1, column 1 of the source file

•Fixed a problem where overflow checking was not following the /ovf compiler option

•Fixed problem with public modifier for interface methods

•Added proper error message with unreachable fields in external DLLs

•Fixed a problem with debugger sequence points (debugger stepping)

•X# generated pdb files are now marked with the X# language GUID so they are recognized as X# in the VS debugger

•DATETIME (26)  and DECIMAL (27) are added as UsualType to the compiler in preparation of the X# runtime that allows usuals of these types

•Compiler options /VO15 and /VO16 now produce an error message when used outside the VO/Vulcan dialect

•Methods declared outside a class (VO style code) would declare a private class and not a public class

•ASTYPE has been changed to a positional keyword

•Fixed a problem with the Chr() and _Chr() functions for literal numbers > 127

•Added support for the __CLR2__ and __CLR4__ compiler macros. The version is derived from the folder name of mscorlib.dll and/or system.dll

•The Codeblock syntax was not working in the Core dialect.

•Some new keywords, such as REPEAT, UNTIL, CATCH, FINALLY,VAR, IMPLIED, NAMESPACE, LOCK, SCOPE, YIELD, SWITCH etc are now also positional and will only be recognized as keyword when at the start of a line or after a matching other keyword.
This should help prevent cryptic error messages when these keywords are used as function names.

Visual Studio

Source code editor

•Added Goto Definition for Functions and Procedures

•Improved Info tips for Functions and Procedures

•Improved case synchronization

•Added first version of smart indenting

•Fixed lookup problems in the intellisense engine that could lock up VS

•Compiler Generated types are now suppressed from the completion lists.

•Added partial support for intellisense for LOCAL IMPLIED and VAR variables

•Added support for Format Document. This also sets the case for identifiers according to the tools defined in the Tools/Options menu

•Performance improvements for the background file scanner. This scanner is also paused during the build process to improve the compilation speed.

Project System and MsBuild

•Fixed a problem in the project files with conditioned property groups. Existing projects will be updated automatically

•Added support for the /vo16 compiler option in MsBuild and the VS Project Property pages.

•Fixed a problem with the /nostddef compiler option which was not working as expected.

•Fixed a problem which would occur when entering resources or settings in the project property dialog

•Fixed a problem with the /nostdlib compiler option

•License.Licx files are now added as "Embedded Resource"

•Fixed a problem with the automatic adding of License files

•When a project has a "broken reference" and a new reference is added with the correct location, then the broken reference will be deleted and the new references will be added instead.

•The MSBuild support DLL was unable to find the location of the compiler and native resource compiler when running inside a 64 bit process

Form Editor

•Improved Windows Form Editor support for types defined in project references. We will now detect the location of the output files for these projects, like the C# and VB project systems.

•The Code parser for the Form Editor was having problems with untyped methods. This has been fixed.

VO Window and Menu Editor

•The code generator for the Window and Menu editor will delete old unused defines.

•Changed the item template for VO windows to fix a problem when adding an event handler to a window that has not been saved yet

•The code generator for the Window editor was not outputting a style for WS_VISIBLE. This has been fixed.

Debugger

This build introduces a first version of the XSharp debugger support

•The Visual Studio debugger now shows the language X# in the callstack window and other places

•Functions, Methods and procedures are now displayed in the X# language style in the callstack window

•Compiler generated variables are no longer shown in the locals list

•The locals list now shows SELF in stead of this

•X# predefined types such as WORD, LOGIC etc are shown with their X# type names in the locals window

Testing

•Added support for the Test Explorer window

•Added templates for unit testing with XUnit, NUnit and Microsoft Test

Other

•Added warning when Vulcan was (re)installed after XSharp, which could cause a problem in the Visual Studio integration

•The VS Parser was marking Interfaces as structure in stead of interface. This has been fixed.

•The tool XPorter tools have better names in the VS Tools Menu

•The VS Background parser gets suspended while looking up type information to improve the intellisense speed

•Several changes were made to the templates that come with X#

XPorter

•Fix problem in propertygroup conditions.

VOXPorter

•Generate clipper constructors is now disabled by default

•Fixed a problem in the VS Template files.

---

 

Changes in 1.0.3

Compiler

•Fixed a problem with the index calculation for Vulcan Arrays indexed with a usual argument

•Fixed a problem with the generation of automatic return values for code that ends with a begin sequence statement or a try statement

•Optimized the runtime performance for literal symbols.
The compiler now generates a symbol table for the literal symbols and each literal symbol used in your app is only created once.
You may experience a little delay at startup if your app uses a LOT (thousands) of literal symbols. But the runtime performance should be better.

•Added a compiler error for code where numerics are casted to an OBJECT with the VO compatible _CAST operator.
This is no longer allowed:
LOCAL nValue as LONG
LOCAL oObject as OBJECT
nValue := 123
oObject := OBJECT(_CAST, nValue)

---

 

Changes in 1.0.2

Compiler

•Added support for XML doc generation. We support the same tags that the C# compiler and other .Net compiler support.

•Improved some parser errors.

•Created separate projects for portable and non portable (.Net framework 4.6) for the compiler and scripting

•Fixed the code generation for conversion from USUAL to a known type. Now the same error is generated that Vulcan produces when the object type in the usual does not match the type of the target variable

•When declaring a type with the same name as the assembly now a compiler error is generated with a suggested work around.

•Fixed a strange compiler message when using a PTR() operation on a method call

•Indexed access to bytes in a PSZ is now 1 based like in VO when the VO dialect is used. The Vulcan dialect needs 0 based index access like Vulcan.

•The error message for compound assignments of FLOAT and USUAL has been removed. The compiler now contains a workaround for the problem in the Vulcan Runtime

•For ambiguous code where the compiler has to choose between a Function call and a static method call in any other class, the compiler now chooses the function call over the method call (Vo and Vulcan dialect). The warning will still be generated.

•When passing a variable by reference with the @ sign the compiler will now check to see if the declared type of the function/method parameter matches the type of the local variable.

•Some compiler warnings for unused variables were being suppressed in the VO/Vulcan dialect. They are activated again.

Scripting

•The scripting was not working in release 1.01

Visual Studio Integration

•QuickInfo could generate a 'hang' in the VS editor. This has been fixed

•Added quickinfo for globals and defines

•Added completionlists for globals and defines

•Added VO Form editor to edit vnfrm/xsfrm files and generate the code and resources

•Added VO Menu editor to edit vnmnu/xsmnu files and generate the code and resources

•Added VO DbServer editor and VO Fieldspec editor to edit vndbs/xsdbs and vnfs/xsfs files and generate the code and resources

•Added keyword and identifier case synchronization.

•Fixed a problem where typing SUPER( in the editor could throw an exception

•Prebuild and Postbuild entries in the project file are now configuration specific

•Added support for XML Doc generation in the project system

•Fixed a 'hang' that could occur with Visual Studio 2017 version 15.3 and later

VO Xporter

•Fixed a problem when importing certain VO 2.7 AEF files

•Fixed a problem with acceptable characters in the solution folder name

•VO Form and menu entities are also included in the xsproj file

•Added an option to the INI files to specify the Vulcan Runtime files location (                )

---

 

Changes in General Release (1.0.1.1)

Compiler

•Fixed a problem with VERY old versions of the Vulcan Runtime

•Variables declared as DIM Byte[] and similar are now Pinned by the compiler

•[Return] attribute was not properly handled by the compiler. This has been fixed

•Compound Assignment (u+= f or -=) from USUAL and FLOAT were causing a stackoverflow at runtime caused by a problem in the Vulcan Runtime. These expressions now generate a compiler error with the suggestion to change to a simple assignment ( u := u + f)

Visual Studio Integration

•Project References between XSharp Projects were also loaded as assemblyreference when resolving types. This could lead to speed problems and unnecessary memory usage

•Improved the speed of the construction of Completion Lists (such as methods and fields for a type).

•We have also added Completion List Tabs, where you can see fields, properties, methods etc. on separate tabs. You can enable/disable this in the Tools/Options/Text Editor/XSharp/Intellisense options page.

VO XPorter

•We have added a check to make sure that the default namespace for a X# project cannot contain a whitespace character

---

 

Changes in General Release (1.0.1)

New Features

•We have added support for ENUM Basetypes (ENUM Foo AS WORD)

•We have added a separate syntax for Lambda Expressions

•We have added support for Anonymous Method Expressions

•Typed local variables can now also be used for PCALL() calls

•Methods with the ExtensionAttribute and Parameters with the ParamArrayAttribute attributes now compile correctly, but with a warning

Compiler

•Fixed a problem with a late bound assign of a literal codeblock

•Resolved several name conflicts

•Improved several of the error messages

•Fixed compilation problem for Properties with only a SET accessor

•Fixed a crash in a switch block with an if .. endif statement

•Fix problem with virtual instance methods and structures

•Fixed name conflict foreach variables used in Array Literals

•Changed resolution for Functions and static methods with the same name.
In the VO/Vulcan dialect functions take precedence over static methods. If you want to call the static method then then you need to prefix the method call with the classname.

•There is a separate topic in this documentation now that describes the syntax differences and similarities between Codeblocks, Lambda Expressions and Anonymous Method Expressions.

•Fixed incorrect error message for Start() function with wrong prototype.

•When an ambiguity is detected between a function and a static method then a warning is displayed

Visual Studio

•Added parameter tips for Functions and methods from "Using Static" classes

•Added parameter tips for Clipper Calling Convention functions and methods

•Added support for generics in Intellisense

•Intellisense will show keywords in stead of native type names (WORD in stead of System.UInt16 for example)

•Parameter tips are now shown when a opening '(' or '{' is typed as well as when the user types a comma ','.

•Parameter tips will show REF OUT and AS modifiers

•Added intellisense for COM references, both for normal COM references as well as for Primary Interop Assemblies. Also members from implemented interfaces are now included in intellisense code completion (this is very common for COM).

•Improved intellisense for Project References from other languages, such as C# and VB.

•Added intellisense for Functions in referenced projects and referenced Vulcan and/or X# assemblies

•Suppress "special type names" in intellisense lists

•Added support for "VulcanClassLibrary" attribute to help find types and functions

•Errors from the Native Resource compiler are now also included in the error list

•Fixed problem with parameter tips for Constructors

•Added memberlist support for X# type keywords such as STRING, REAL4 etc.

•Fixed several issues with the Windows Form editor in relation to ActiveX controls

•Added a menu option to start the VO Xporter tool

•Added background scanning for dependent items, to make sure that newly generated code is scanned and available for intellisense.

•Several changes to the Windows Forms editor and project system:

oAdded support for adding ActiveX controls

oAdded support for Form Inheritance. Our forms are also visible in the C# Inherited form wizard

oAdded support to add our Windows Forms Custom Controls to the ToolBox in Visual Studio

oSome performance enhancements in the Codedom Parser that is used by the Windows Form Editor. You should notice this for larger forms.

•Fixed several crashes reported by users

•Native Resource files (.rc) now open in the Source code editor

•Improved background parsing speed

•Improved keyword colorization speed

•Improved handling of Type and Member dropdowns in the editor

Tools

•Added a first version of the VO Xporter tool

•The installer now registers .xsproj files, .prg, .ppo. .vh, .xh and .xs files so they will be opened with Visual Studio

Documentation

•We have added some chapters on how to convert your VO AEF and/or PRG files to a XIDE project and/or a Visual Studio solution.

---

 

Changes in 0.2.12

Scripting

•We have added the ability to use X# scripts. Some documentation about how this works can be found here. You can also find scripting examples in the
c:\Users\Public\Documents\XSharp\Scripting folder

Compiler

All dialects

•The compiler is now based on the Roslyn source code for C# 7.

•Accesses and Assigns with the same name for the same (partial) class in separate source files are now merged into one property. This will slow down the compiler somewhat. We recommend that you define the ACCESS and ASSIGN in the same source file.

•Added support for repeated result markers in the preprocessor

•We have added the compiler macro __DIALECT_HARBOUR__

•Fixed the name resolution between types, namespaces, fields, properties, methods, globals etc. The core dialect is very close to the C# rules, the other dialect follows the VO rules.

•Some warnings for ambiguous code have been added

•_Chr() with untyped numeric values would crash. This has been fixed.

•We made some changes to the character literal rules. For the VO and Harbour dialect there are now other rules then for Core and Vulcan. See the help topic for more information

VO and Vulcan Dialect

•Several VO compatibility issues have been fixed

•The QUIT, ACCEPT, WAIT, DEFAULT TO and STORE command are now removed from the compiler and defined in our standard header file "XSharpDefs.xh" which is located in the \Program Files(x86)\XSharp\Include folder. These commands are not compiled in the core dialect

•Added support for CONSTRUCTOR() CLASS MyClass and DESTRUCTOR CLASS MyClass (in other words, outside the CLASS .. ENDCLASS construct

•The # (not equal) operator is now recognized when used without space before the keywords NIL, NULL_STRING, NULL_OBJECT etc. so #NIL is not seen as the symbol NIL but as Not Equal To NIL

•SizeOf and _TypeOf were special tokens in VO and could not be abbreviated. We have changed the X# behavior to match this. This prevents name conflicts with variables such as _type.

•We have added support for DLL entrypoints with embedded @ signs, such as "CAVOADAM.AdamCleanupProtoType@12"

•(DWORD) (-1) would require the unchecked operator. This is now compatible with Vulcan and generates a DWORD with the value System.Uint32.MaxValue.

•STATIC VOSTRUCT now gets compiled as INTERNAL VOSTRUCT. This means that you cannot have the same structure twice in your app. Why would you want to do that ?

•Fixed several cases of "incorrect" code that would be compiled by VO, such as a codeblock that looks like:
       cb := { |x|, x[1] == 1 }
Note the extra comma.
This now compiled into the same codeblock as:

•The /vo16 compiler option has been disabled for now (does not do anything) because it had too many side effects.

Visual Studio Integration

•Deleted files and folders are moved them to the Trash can.

•Fixed an intellisense problem in the XAML editor

•Added support for Code Completion between different X# projects

•Added support for Code Completion and other intellisense features for source code in VB and C# projects

•Added support for parameter info

Documentation

•We have added (generated) topics for all undocumented compiler errors. Some topics only contain the text that is shown by the compiler. More documentation will follow. Also some documentation for the X# Scripting has been added.

---

 

Changes in 0.2.11

Compiler

All dialects

•Improved some error messages, such as for unterminated strings

•Added support for the /s (Syntax Check only) command line option

•Added support for the /parseonly command line option which is used by the intellisense parser

•Added some compiler errors and warnings for invalid code

•The preprocessor did not properly handle 4 letter abbreviations for #command and #translate. This has been fixed

•Fixed some problems found with the preprocessor

•We switched to a new Antlr parser runtime. This should result in slightly better performance.

•Changed the way literal characters and strings are defined:

oIn the Vulcan dialect a literal string that is enclosed with single quotes is a char literal. Double quotes are string literals

oIn the Core and VO dialect a literal string that is enclosed with single quotes is a string literal. Double quotes are also string literals.
To specify a char literal in Core and VO you need to prefix the literal with a 'c':

 

    LOCAL cChar as CHAR
     cChar := c'A'        

•Changed the way literal characters and strings are defined:

•sizeof() and _sizeof() no longer generate a warning that they require 'unsafe' code, when compiling for x86 or x64. When compiling for AnyCpu the warning is still produced.

•When the includedir environment variable was not set then the XSharp\Include folder would also not be found automatically.

VO/Vulcan Compatibility

•Added /vo16 compiler option to automatically generate constructors with Clipper calling convention for classes without constructor

Harbour Compatibilty

•Started work on the Harbour dialect. This is identical with the VO/Vulcan dialect. The only difference so far is that the IIF() expressions are optional

Visual Studio

New features / changed behavior:

•Added Brace Matching

•Added Peek definition (Alt-F12)

•All keywords are not automatically part of the Completionlist

•Fixed a member lookup problem with Functions and Procedures inside a Namespace

•Increased background parser speed for large projects

•Fixed type lookup for fields and properties from parent classes

•Fixed problem where CSharp projects could not find the output of a XSharp project reference

•The Intellisense parser now properly used all current projects compiler options.

•Prevent crashes when the X# language buffer is fed with "garbage" such as C# code

Installer

•The local template cache and components cache for VS2017 was not cleared properly this has been fixed.

•Added code to properly unregister an existing CodeDomProvider when installing

Documentation

•Several empty chapters are now hidden.

•Added description of the templates

---

 

Changes in 0.2.10

This build focuses on the last remaining issues in the VO and Vulcan compatibility and adds a lot of new features to the Visual Studio integration.

Compiler

VO/Vulcan Compatibility

•We have completed support for the DEFINE keyword. The type clause is now optional. The compiler will figure out the type of the define when no type is specified.
The DEFINEs will be compiled to a Constant field of the Functions class, or a Readonly Static field, when the expression cannot be determined at compile time (such as for Literal dates or symbols).

•We have extended the preprocessor . It now has support for #command, #translate, #xcommand and #xtranslate. Also "Pseudo function" defines are supported, such as :
 
       #define MAX(x,y) IIF((x) > (y), (x), (y))
 
This works just like a #xtranslate, with the exception that the define is case sensitive (unless you have enabled the "VO compatible preprocessor" option (/vo8).
The only thing that is not working in the preprocessor is the repeated result marker.

•In VO/Vulcan mode the compiler now accepts "garbage" between keywords such as ENDIF and NEXT and the end of the statement, just like the VO compiler.
So you no longer have to remove "comment" tokens after a NEXT or ENDIF. This will compile without changes in the VO and Vulcan dialect:
 
  IF X == Y
      DoSomething()
  ENDIF X == Y
or
  FOR I := 1 to 10
     DoSomething()
  NEXT I
We do not recommend this coding style, but this kind of code is very common...

•Fixed an issue with recognition of single quoted strings. These were always recognized as CHAR_CONST when the length of the string was 1. Now they are treated as STRING_CONST and the compiler backend has been adjusted to convert the STRING literals to CHAR literals when needed.

•In VO and Vulcan dialect when the compiler option /vo1 is used then RETURN statements without value or with a return value of SELF are allowed for the Init() and Axit() methods. Other return values will trigger a compiler warning and will be ignored.

New features / changed behavior:

•The compiler now produces an error when a source file ends with an unterminated multi line comment

•Added ASTYPE expression, similar to the AS construct in other languages. This will assign a value of the correct type or NULL when the expression is not of the correct type:
       

•The Chr() and _Chr() functions are now converted to a string or character literal when the parameter is a compile time constant

•Compilation speed for assemblies with larger numbers of functions, procedures, defines, globals or _dll functions has been improved.

•_DLL FUNCTIONS now automatically are marked with CharSet.Auto

•Fixed some inconsistencies between Colon (:) and Point (.) interoperability and the super keyword

•Fixed several compiler issues reported by FOX subscribers and other users.

Visual Studio

New features / changed behavior:

•Tested and works with the release version of Visual Studio 2017

•We have added support for regions inside the VS editor. At this moment most "entities" are collapsible as well as statement blocks, regions and lists of usings, #includes and comments.

•We have added support for member and type drop downs in the VS Editor

•We have added support for Code completion in the VS editor

•We have added support for Goto definition in the VS Editor

•Errors detected by the intellisense scanner are now also included in the VS error list.

•We have added help links to the errors in the VS error list. The help links will bring you to the appropriate page on the X# website. Not all the help pages are complete yet, but at least the infrastructure is working.

•We have added support for snippets and included several code snippets in the installer

•We have made several changes to the project properties dialogs

oThe pre and post build events are now on a separate page for the Project Properties. These are now also not defined per configuration but are shared between the various configurations.
If you want to copy output results to different folders for  different configurations you should use the $(Configuration) and $(Platform) variables

oWe have  moved the Platform and Prefer32Bits properties to the Build page to make them configuration dependent

oFixed a problem with casing of the AnyCPU platform which would result in duplicate items in the VS Platform combobox

oAdded support for ARM and Itanium platform types

oSome properties were saved in project file groups without a platform identifier. This has been fixed

oWe have added a project property to control how Managed file resources are included: Use Vulcan Compatible Managed Resources
When 'True' then resources files are included in the assembly without namespace prefix. When 'False' then the resource files are prefixed with the namespace of the app, just like in other .Net languages, such as C#

•We have fixed some code generation problems

•The parser that is used in the Windows Forms editor now also properly handles background images. Both images in the resx for the form and also background images in the shared project resources

•We have added Nuget support for our project system.

•We have made several changes to fix problems in project files

oThe project system now silently fixes problems with duplicate items

oFixed a problem with dependencies between xaml files and their dependent designer.prg files and other dependent files

oFixed a problem with dependent items in sub folders or in a folder tree that includes a dot in a folder name.

oFixed a problem in the WPF template

•Fixed a refresh problem when deleting a references node

•Added implementation of the OAProject.Imports property, which is used by JetBrains

XPorter

•Fixed a problem converting WPF style projects

---

 

Changes in 0.2.9

Compiler

With this build you can compile the Vulcan SDK without changes, except for some obvious errors in the Vulcan SDK that Vulcan did not find!
We consider the Vulcan Compatibility of the compiler finished with the current state of the compiler. All Vulcan code should compile without proble now.

VO/Vulcan Compatibility

New features / changed behavior:

•All Init procedures are now properly called at startup. So not only the init procedures in the VOSDK libraries but also init procedures in other libraries and the main exe

•Changed the method and type resolution code:

oA method with a single object parameter is now preferred over a method with an Object[] parameter

oWhen both a function (static method) exists and an instance method we will now call the static method in code inside methods that does not have a SELF: or SUPER: prefix.

oIn situations where the @ operator is used to pass variables by reference.

oTo make it more compatible with Vulcan for overloads with different numeric types.

oTo prefer a method with specific parameters over a method with usual parameters

oTo avoid problems with Types and Namespaces with the same name.

oTo prefer a method with an OBJECT parameter over the one with OBJECT[] parameters when only 1 argument is passed

oWhen 2 identical functions or types are detected in referenced assemblies we now choose the one in the first referenced assembly like Vulcan does, and generate warning 9043

•The sizeof operator now returns a DWORD to be compatible with VO and Vulcan.

•Added support for EXIT PROCEDURES (PROCEDURE MyProcedure EXIT). These procedures will automatically be called during program shutdown, just before all the global variables are cleared.
The compiler now generates an $Exit function for each assembly in which the exit procedures will be called and the reference globals in an assembly will be cleared. In the main app a $AppExit() function is created that will call the $Exit functions in all references X# assemblies. When a Vulcan compiled assembly is referenced, then all the public reference globals will be cleared from the $AppExit() function.

•Added support for PCALL and PCALLNATIVE

•Added support for several Vulcan compatible compiler options:

o/vo1 Allow Init() and Axit() for constructor and destruction

o/vo6 Allow (global) function pointers. DotNet does not "know" these. They are compiled to IntPtr. The function information is preserved so you can use these pointer in a PCALL()

o/ppo. Save the preprocessed compiler output to a file

o/Showdefs Show a list of the defines and their values on the console

o/showincludes Show a list of the included header files on the console

o/verbose Shows includes, source file names, defines and more. on the console

oDEFAULT TO command

oACCEPT command

oWAIT command

•Several code generation changes:

oChanged the code generation for DIM elements inside VOStruct arrays because the Vulcan compiler depends on a specific naming scheme and did not recognize our names.

oImproved the code generation inside methods with CLIPPER calling convention.

Bug fixes

•Implicit namespaces are now only used when the /ins compiler option is enabled. In Vulcan dialect the namespace Vulcan is always included.

•Fixed several problems with the @ operator and VOSTRUCT types

•Fixed a problem with DIM arrays of VOSTRUCT types

•Fixed a problem with LOGIC values inside VOSTRUCT and UNION types

•Fixed several problems with the VOStyle _CAST and Conversion operators.

•Fixed several numeric conversion problems

•Fixed several problems when mixing NULL, NULL_PTR and NULL_PSZ

•Fixed several problems with the _CAST operator

•Fixed several problems with PSZ Comparisons. X# now works just like Vulcan and VO and produces the same (sometimes useless) results

•Fixed a problem with USUAL array indexes for multi dimensional XBase Arrays

•Fixed codeblock problems for codeblocks where the last expression was VOID

•Changed code generation for NULL_SYMBOL

•Preprocessor #defines were sometimes conflicting with class or namespace names. For example when /vo8 was selected the method System.Diagnostics.Debug.WriteLine() could not be called because the DEBUG define was removing the  classname. We have changed the preprocessor so it will no longer replace words immediately before or after a DOT or COLON operator.

•Fixed a compiler crash when calling static methods in the System.Object class when Late Binding was enabled

•Fixed String2Psz() problem inside PROPERTY GET and PROPERTY SET

•And many more changes.

All dialects

New features / changed behavior:

•Several code generation changes:

oThe code generation for ACCESS and ASSIGN has changed. There are no longer separate methods in the class, but the content of these methods is now inlined in the generated Get and Set methods for the generated property.

oOptimized the code generation for IIF statements.

oThe debugger/step information has been improved. The debugger should now also stop on IF statements, FOR statements, CASE statements etc.

•Indexed access to properties defined with the SELF keyword can now also use the "Index" property name

•Functions and Procedures inside classes are not allowed (for now)

•RETURN <LiteralValue> inside an ASSIGN method will no longer allocate a variable and produce an warning

•Several keywords are now also allowed as Identifier (and will no longer have to be prefixed with @@ ):
Delegate, Enum, Event, Field, Func, Instance, Interface, Operator, Proc, Property, Structure, Union, VOStruct and many more
As a result the following is now valid code (but not recommended):
 
FUNCTION Start AS VOID
  LOCAL INTERFACE AS STRING
  LOCAL OPERATOR AS LONG
  ? INTERFACE, OPERATOR
  RETURN

You can see that the Visual Studio language support also recognizes that INTERFACE and OPERATOR are not used as keywords in this context

Bug fixes

•Fixed a problem with the REPEAT UNTIL statement

•Fixed a crash for code with a DO CASE without a matching END CASE

•Fixed several issues for the code generation for _DLL FUNCTIONs and _DLL PROCEDUREs

•Fixed a problem (in the Roslyn code) with embedding Native Resources in the Assembly.

•Fixed a problem with the _OR() and _AND() operators with more than 2 arguments.

•Added support for Pointer dereferencing using the VO/Vulcan Syntax : DWORD(p) => p[1]

•Fixed several problems with the @ operator

•When two partial classes had the same name and a different casing the compiler would not properly merge the class definitions.

•Fixed a crash when a #define in code was the same as a define passed on the commandline

•Indexed pointer access was not respecting the /AZ compiler option (and always assumed 0 based arrays). This has been fixed

•Fixed a problem with the caching of preprocessed files, especially files that contain #ifdef constructs.

•Fixed a problem which could occur when 2 partial classes had the same name but a different case

•Fixed a compiler crash when a referenced assembly had duplicate namespaces that were only different in Case

•Fixed problems with Functions that have a [DllImport] attribute.

•Error messages for ACCESS/ASSIGN methods would sometimes point to a strange location in the source file. This has been fixed.

•Fixed a problem with Init Procedures that had a STATIC modifier

•Fixed a problem in the preprocessor when detecting the codepage for a header file. This could cause problems reading header files with special characters (such as the copyright sign ©)

•And many more changes.

Visual Studio Integration

•Added support for all compiler options in the UI and the build system

•Fixed problems with dependent file items in subfolders

•The Optimize compiler option was not working

•The 'Clean' build option now also cleans the error list

•Under certain conditions the error list would remain empty even though there were messages in the output pane. This has been fixed.

•The <Documentationfile> property inside the xsproj file would cause a rebuild from the project even when the source was not changed

•Earlier versions of XPorter could create xsproj files that would not build properly. The project system now fixes this automatically

•Fixed a problem with the build system and certain kind of embedded managed resources

 

Documentation

•We have added many descriptions to the commandline options

•We have added a list of the most common compiler errors and warnings.

---

 

Changes in 0.2.8

Compiler

VO/Vulcan Compatibility

•Default Parameters are now handled like VO and Vulcan do. This means that you can also have date constants, symbolic constants etc as default parameter

•String Single Equals rules are now 100% identical with Visual Objects. We found one case where Vulcan does not return the same result as Visual Objects. We have chosen to be compatible with VO.

•When compiling in VO/Vulcan mode then the init procedures in the VO SDK libraries are automatically called. You do not have to call these in your code anymore
Also Init procedures in the main assembly are called at startup.

•The /vo7 compiler option (Implicit casts and conversions) has been implemented. This also includes support to use the @ sign for REF parameters

•You can now use the DOT operator to access members in VOSTRUCT variables

•We have fixed several USUAL - Other type conversion problems that required casts in previous builds

•The compiler now correctly parses VO code that contains DECLARE METHOD, DECLARE ACCESS and DECLARE ASSIGN statements and ignores these

•The compiler now parses "VO Style" compiler pragma's (~"keyword" as white-space and ignores these.

•Fixed a problem where arrays declared with the "LOCAL aSomething[10] AS ARRAY" syntax would not be initialized with the proper number of elements

•Fixed a problem when calling Clipper Calling Convention constructors with a single USUAL parameter

•Attributes on _DLL entities would not be properly compiled. These are recognized for now but ignored.

•Fixed several numeric conversion problems

New features

•We have added support for Collection Initializers and Object Initializers

•Anonymous type members no longer have to be named. If you select a property as an anonymous type member then the same property name will be used for the anonymous type as well.

•Missing closing keywords (such as NEXT, ENDIF, ENDCASE and ENDDO) now produce better error messages

•IIF() Expressions are now also allowed as Expression statement. The generated code will be the same as if an IF statement was used

FUNCTION IsEven(nValue as LONG) AS LOGIC
  LOCAL lEven as LOGIC
  IIF( nValue %2 == 0, lEven := TRUE, lEven := FALSE)
RETURN lEven

•AS VOID is now allowed as (the only) type specification for PROCEDUREs

•We have added a .config file to the exe for the shared compiler that should make it faster

•The XSharpStdDefs.xh file in the XSharp is now automatically included when compiling. This file declares the CRLF constant for now.

•Include files are now cached by the compiler. This should increase the compilation speed for projects that depend on large included files, such as the Win32APILibrary header file from Vulcan

•When a function is found in an external assembly and a function with the same name and arguments is found in the current assembly, then the function in the current assembly is used by the compiler

•Compiler error messages for missing closing symbols should have been improved

•Compiler error messages for unexpected tokens have been improved

Bug fixes

•Several command-line options with a minus sign were not properly handled by the compiler

•Fixed several crashes related to assigning NULL_OBJECT or NULL to late bound properties have been fixed

•Partial class no longer are required to specify the parent type on every source code location. When specified, the parent type must be the same of course. Parent interfaces implemented by a class can also be spread over multiple locations

•We have fixed a crash that could happen with errors/warnings in large include files

•Abstract methods no longer get a Virtual Modifier with /vo3

•Fixed a problem with virtual methods in child classes that would hide parent class methods

•Automatic return value generation was also generating return values for ASSIGN methods. This has been fixed.

•We fixed a problem with the Join Clauses for LINQ Expressions that would cause a compiler exception

•The /vo10 (compatible iif) compiler option no longer adds casts in the Core dialect. It only does that for the VO/Vulcan dialect

Visual Studio Integration

We have changed the way the error list and output window are updated. In previous version some lines could be missing on the output window, and the error code column was empty. This should work as expected now.

•We have merged some code from some other MPF based project systems, such as WIX (called Votive), NodeJS and Python (PTVS) to help extend our project system. As a result:

oOur project system now has support for Linked files

oOur project system now has support for 'Show All Files' and you can now Include and Exclude files. This setting is persisted in a .user file, so you can exclude this from SCC if you want.

oWe have made some changes to support better 'Drag and Drop'

•We have fixed several issues with regard to dependent items

•When you include a file that contains a form or user control, this is now recognized and the appropriate subtype is set in the project file, so you can open the windows forms editor

•We are now supporting source code generation for code behind files for .Settings and .Resx files

•The combobox in the Managed Resource editor and Managed Settings tool to choose between internal code and public code is now enabled. Selecting a different value in the combobox will change the tool in the files properties.

•The last response file for the compiler and native resource compiler are now saved in the users Temp folder to aid in debugging problems.

•The response file now has each compiler option to a new line to make it easier to read and debug when this is necessary.

•The code generation now preserves comments between entities (methods)

•We fixed several minor issues in the templates

•When the # of errors and warnings is larger than the built-in limit of 500, then a message will be shown that the error list was truncated

•At the end of the build process a line will be written to the output window with the total # of warnings and errors found

•The colors in the Source Code Editor are now shared with the source code editors for standard languages such as C# and VB

•When you have an inactive code section in your source code, embedded in an #ifdef that evaluates to FALSE then that section will be visibly colored gray and there will be no keyword highlighting. The source code parser for the editor picks up the include files and respects the path settings. Defines in the application properties dialog and the active configuration are not respected yet. That will follow in the next build.

 

 

Changes in 0.2.7.1

Compiler

•The compiler was not accepting wildcard strings for the AssemblyFileVersion Attribute and the AssemblyInformationVersion attribute. This has been fixed

•The #Pragma commands #Pragma Warnings(Push) and #Pragma Warnings(Pop) were not recognized. This has been fixed.

•The compiler was not recognizing expressions like global::System.String.Compare(..). This has been fixed

Visual Studio Integration

•Dependent items in subfolders of a project were not recognized properly and could produce an error when opening a project

•Fixed a problem in the VulcanApp Template

•The Windows Forms Editor would not open forms in a file without begin namespace .. end namespace. This has been fixed

•Source code comments between 'entities' in a source file is now properly saved and restored when the source is regenerated by the form editor

•Unnecessary blank lines in the generate source code are being suppressed

•The XPorter tool is now part of the Installation

•Comments after a line continuation character were not properly colored

•Changed the XSharp VS Editor Color scheme to make certain items easier to read

•New managed resource files would not be marked with the proper item type. As a result the resources would not be available at runtime. This has been fixed.

•Added 'Copy to Output Directory' property to the properties window

Setup

•The installer, exe files and documentation are now signed with a certificate

---

 

Changes in 0.2.7

Compiler

New features:

•Added support for the VOSTRUCT and UNION types

•Added support for Types as Numeric values, such as in the construct
       IF UsualType(uValue) == LONG

•Added a FIXED statement and FIXED modifier for variables

•Added support for Interpolated Strings

•Empty switch labels inside SWITCH statements are now allowed. They can share the implementation with the next label.
Error 9024 (EXIT inside SWITCH statement not allowed) has been added and will be thrown if you try to exit out of a loop around the switch statement.
This is not allowed.

•Added support for several /vo compiler options:
- vo8 (Compatible preprocessor behavior). This makes the preprocessor defines case insensitive. Also a define with the value FALSE or 0 is seen as 'undefined'
- vo9 (Allow missing return statements) compiler option. Missing return values are also allowed when /vo9 is used.  
Warnings 9025 (Missing RETURN statement) and 9026 (Missing RETURN value) have been added.
- vo12 (Clipper Integer divisions)

•The preprocessor now automatically defines the macros __VO1__ until __VO15__ with a value of TRUE or FALSE depending on the setting of the compiler option

•The FOX version of the compiler is now distributed in Release mode and much faster. A debug version of the compiler is also installed in case it is needed to aid in finding compiler problems.

Changed behavior

•The compiler generated Globals class for the Core dialect is now called Functions and no longer Xs$Globals.

•Overriding functions in VulcanRTFuncs can now be done without specifying the namespace:
When the compiler finds two candidate functions and one of them is inside VulcanRTFuncs then the function that is not in VulcanRTFuncs is chosen.

•Warning 9001 (unsafe modifier implied) is now suppressed for the VO/Vulcan dialect. You MUST pass the /unsafe compiler option if you are compiling unsafe code though!

•Improved the error messages for the Release mode of the compiler

Bug fixes

•RETURN and THROW statements inside a Switch statement would generate an 'unreachable code' warning. This has been fixed

•Fixed several problems with mixing signed and unsigned Array Indexes

•Fixed several problems with the FOR .. NEXT statement. The "To" expression will now be evaluated for every iteration of the loop, just like in VO and Vulcan.

•Fixed several compiler crashes

•Fixed a problem with implicit code generation for constructors

•Fixed a visibility problem with static variables inside static functions

Visual Studio Integration

•Fixed a problem that the wrong Language Service was selected when XSharp and Vulcan.NET were used in the same Visual Studio and when files were opened from the output window or the Find Results window

•Fixed some problems with 'abnormal' line endings in generated code

•Fixed a problem in the Class Library template

•Fixed a problem with non standard command lines to Start the debugger

 

Changes in 0.2.6

Compiler

•Added alternative syntax for event definition. See EVENT keyword in the documentation

•Added Code Block Support

•Implemented /vo13 (VO compatible string comparisons)

•Added support for /vo4 (VO compatible implicit numeric conversions)

•Aliased expressions are now fully supported

•Fixed a problem with the &= operator

•Fixed several crashes for incorrect source code.

•Fixed several problems related to implicit conversions from/to usual, float and date

•Indexed properties (such as String:Chars) can now be used by name

•Indexed properties can now have overloads with different parameter types

•Added support for indexed ACCESS and ASSIGN

•Fixed a problem when calling Clipper Calling Convention functions and/or methods with a single parameter

•Fixed a crash with defines in the preprocessor

•_CODEBLOCK is now an alias for the CODEBLOCK type

•Fixed a crash for properties defined with parentheses or square brackets, but without actual parameters

Visual Studio Integration

•Completed support for .designer.prg for Windows.Forms

•Fixed an issue in the CodeDom generator for generating wrappers for Services

•The XSharp Language service will no longer be used for Vulcan PRG files in a Side by Side installation

•Editor performance for large source files has been improved.

•All generated files are now stored in UTF, to make sure that special characters are stored correctly. If you are seeing warnings about code page conversions when generating code, then save files as UTF by choosing "File - Advanced Save Options", and select a Unicode file format, from the Visual Studio Menu.

 

Changes in 0.2.51

Visual Studio Integration & Build System

•The Native Resource compiler now "finds" header files, such as "VOWin32APILibrary.vh" in the Vulcan.NET include folder. Also the output of the resource compiler is now less verbose when running in "normal" message mode. When running in "detailed" or "diagnostics" mode the output now also includes the verbose output of the resource compiler.

Compiler

•Fixed a problem that would make PDB files unusable

•The error "Duplicate define with different value" (9012) has been changed to warning, because our preprocessor does a textual comparison and does not "see" that "10" and "(10)" are equal as well as "0xA" and "0xa". It is your responsibility of course to make sure that the values are indeed the same.

•Exponential REAL constants were only working with a lower case 'e'. This is now case insensitive

•Made several changes to the _DLL FUNCTION and _DLL PROCEDURE rules for the parser. Now we correctly recognize the "DLL Hints " (#123) and also allow extensions in these definitions. Ordinals are parsed correctly as well, but produce an error (9018) because the .Net runtime does not support these anymore. Also the Calling convention is now mandatory and the generated IL code includes SetLastError = true and ExactSpelling = true.

•Fixed a problem with the ~ operator. VO and Vulcan (and therefore X#) use this operator as unary operator and as binary operator.
The unary operator does a bitwise negation (Ones complement), and the binary operator does an XOR.
This is different than C# where the ~ operator is Bitwise Negation and the ^ operator is an XOR (and our Roslyn backend uses the C# syntax of course).

 

Changes in 0.2.5

Visual Studio Integration

•Fixed a problem where the output file name would contain a pipe symbol when building for WPF

•Fixed a problem with the Item type for WPF forms, pages and user controls

•The installer now has an option to not take away the association for PRG, VH and PPO items from an installed Vulcan project system.

•Added support for several new item types in the projects

•Added support for nested items

•Added several item templates for WPF, RC, ResX, Settings, Bitmap, Cursor etc.

Build System

•Added support for the new /vo15 command line switch.

•Added support for compiling native resources.

Compiler

•A reference to VulcanRT and VulcanRTFuncs is now mandatory when compiling in VO/Vulcan dialect

•Added support for indexed access for VO/Vulcan Arrays

•Added support for VO/Vulcan style Constructor chaining (where SUPER() or SELF() call is not the first call inside the constructor body)

•Added support for the &() macro operator in the VO/Vulcan dialect

•Added support for the FIELD statement in the VO/Vulcan dialect

oThe statement is recognized by the compiler

oFields listed in the FIELD statement now take precedence over local variables or instance variables with the same name

•Added support for the ALIAS operator (->) in the VO/Vulcan dialect, with the exception of the aliased expressions (AREA->(<Expression>))

•Added support for Late bound code (in the VO/Vulcan dialect)

oLate bound method calls

oLate bound property get

oLate bound property set

oLate bound delegate invocation

•Added a new /vo15 command line option (Allow untyped Locals and return types):
By default in the VO/Vulcan dialect missing types are allowed and replaced with the USUAL type.
When you specify /vo15- then untyped locals and return types are not allowed and you must specify them.
Of course you can also specify them as USUAL

•The ? and ?? statement are now directly mapped to the appropriate VO/Vulcan runtime function when compiling for the VO/Vulcan dialect

•We now also support the VulcanClassLibrary attribute and VulcanCompilerVersion attribute for the VO & Vulcan dialect.
With this support the Vulcan macro compiler and Vulcan Runtime should be able to find our functions and classes

•The generated static class name is now more in par with the class name that Vulcan generates in the VO & Vulcan dialect.

•Added several implicit conversion operations for the USUAL type.

•When accessing certain features in the VO & Vulcan dialect (such as the USUAL type) the compiler now checks to see if VulcanRTFuncs.DLL and/or VulcanRT.DLL are included.
When not then a meaningful error message is shown.

•Added support for the intrinsic function _GetInst()

•Fixed a problem with case sensitive namespace comparisons

•Fixed a problem with operator methods

•Added preprocessor macros __DIALECT__, __DIALECT_CORE__, __DIALECT_VO__ and __DIALECT_VULCAN__

•The _Chr() pseudo function will now be mapped to the Chr() function

•Added support for missing arguments in arguments lists (VO & Vulcan dialect only)

•Fixed a crash when calculating the position of tokens in header files

•The installer now offers to copy the Vulcan Header files to the XSharp Include folder

•Added support for skipping arguments in (VO) literal array constructors

Documentation

•Added the XSharp documentation to the Visual Studio Help collection

•Added reference documentation for the Vulcan Runtime

 

Changes in 0.2.4

Visual Studio Integration

•Double clicking errors in the error browser now correctly opens the source file and positions the cursor

•Fixed several problems in the project and item templates

•The installer now also detects Visual Studio 15 Preview and installs our project system in this environment.

Build System

•Fixed a problem with the /unsafe compiler option

•Fixed a problem with the /doc compiler option

•Treat warnings as error was always enabled. This has been fixed.

Compiler

•Added support for Lambda expressions with an expression list

LOCAL dfunc AS System.Func<Double,Double>

dfunc := {|x| x := x + 10, x^2}

? dfunc(2)

•Added support for Lambda expressions with a statement list

 LOCAL dfunc AS System.Func<Double,Double>

 dfunc :=        {|x|

                         ? 'square of', x

                         RETURN x^2

                 }

•Added support for the NAMEOF intrinsic function

FUNCTION Test(cFirstName AS STRING) AS VOID

 FUNCTION Test(cFirstName AS STRING) AS VOID

 IF String.IsNullOrEmpty(cFirstName)

         THROW ArgumentException{"Empty argument", nameof(cFirstName)}

 ENDIF

•Added support for creating methods and functions with Clipper calling convention (VO and Vulcan dialect only)

•Using Statement now can contain a Variable declaration:

Instead of:

    VAR ms := System.IO.MemoryStream{}

    BEGIN USING ms

         // do the work

 

END USING

You can now write

 BEGIN USING VAR ms := System.IO.MemoryStream{}

         // do the work

END USING

•Added support for /vo10 (Compatible IIF behavior). In the VO and Vulcan dialect the expressions are cast to USUAL. In the core dialect the expressions are cast to OBJECT.

New language features for the VO and Vulcan dialect

•Calling the SELF() or SUPER() constructor is now allowed anywhere inside a constructor (VO and Vulcan dialect only). The Core dialect still requires constructor chaining as the first expression inside the constructor body

•Added support for the PCOUNT, _GETFPARAM and _GETMPARAM intrinsic functions

•Added support for String2Psz() and Cast2Psz()

•Added support for BEGIN SEQUENCE … END

•Added support for BREAK

Fixed several problems:

•Nested array initializers

•Crash for BREAK statements

•Assertion error for generic arguments

•Assertion on const implicit reference

•Allow ClipperCallingConvention Attribute on Constructors, even when it is marked as ‘for methods only’

•Fixed a problem with Global Const declarations

•__ENTITY__ preprocessor macro inside indexed properties

 

Changes in 0.2.3

Visual Studio Integration

•We have changed to use the MPF style of Visual Studio Integration.

•We have added support for the Windows Forms Editor

•We have added support for the WPF Editor

•We have added support for the Codedom Provider, which means a parser and code generator that are used by the two editors above

•The project property pages have been elaborated. Many more features are available now.

•We have added several templates

Build System

•Added support for several new commandline options, such as /dialect

•The commandline options were not reset properly when running the shared compiler. This has been fixed.

•The build system will limit the # of errors passed to Visual Studio to max. 500 per project. The commandline compiler will still show all errors.

Compiler

•We have started work on the Bring Your Own Runtime support for Vulcan. See separate heading below.

•The __SIG__ and __ENTITY__ macros are now also supported, as well as the __WINDIR__, __SYSDIR__ and __WINDRIVE__ macros

•The debugger instructions have been improved. You should have a much better debugging experience with this build

•Several errors that indicated that there are visibility differences between types and method arguments, return types or property types have been changed into warnings. Of course you should consider to fix these problems in your code.

•The #Error and #warning preprocessor command no longer require the argument to be a string

•The SLen() function call is now inlined by the compiler (just like in Vulcan)

•The AltD() function will insert a call to "System.Diagnostics.Debugger.Break" within a IF System.Diagnostics.Debugger.IsAttached check

•Several compiler crashes have been fixed

•Added support for the PARAMS keyword for method and function parameters.

•Fixed a problem for the DYNAMIC type.

BYOR

•XBase type names are resolved properly (ARRAY, DATE, SYMBOL, USUAL etc)

•Literal values are now resolved properly (ARRAY, DATE, SYMBOL)

•NULL_ literals are resolved properly (NULL_STRING follows the /vo2 compiler option, NULL_DATE, NULL_SYMBOL)

•The /vo14 compiler option (Float literals) has been implemented

•The compiler automatically inserts a "Using Vulcan" and "using static VulcanRtFuncs.Functions" in each program

•You MUST add a reference to the VulcanRTFuncs and VulcanRT assembly to your project. This may be a Vulcan 3 and also a Vulcan 4 version of the Runtime. Maybe Vulcan 2 works as well, we have not tested it.

•Calling methods with Clipper calling convention works as expected.

•Methods/Functions without return type are seen as methods that return a USUAL

•If a method/function contains typed and typed parameters then the untyped parameters are seen as USUAL parameters

•Methods with only untyped parameters (Clipper calling convention) are not supported yet

•The ? command will call AsString() on the arguments

 

Changes in 0.2.2

Visual Studio Integration

•Added more project properties. One new property is the "Use Shared Compiler" option. This will improve compilation speed, but may have a side effect that some compiler (parser) errors are not shown in details.
If you experience this, then please disable this option.

•Added more properties to the Build System. All C# properties should now also be supported for X#, even though some of them are not visible in the property dialogs inside VS.

•Added a CreateManifest task to the Build System so you will not get an error anymore for projects that contain managed resources

•The performance of the editor should be better with this release.

•Marking and unmarking text blocks as comment would not always be reflected in the editor colors. This has been fixed.

Compiler

•We have added a first version of the preprocessor. This preprocessor supports the #define command, #ifdef, #ifndef, #else, #endif, #include, #error and #warning. #command and #translate (to add user defined commands) are not supported yet.

•Missing types (in parameter lists, field definitions etc) were sometimes producing unclear error messages. We have changed the compiler to produce a "Missing Type" error message.

•We rolled the underlying Roslyn code forward to VS 2015 Update 1. Not that you see much of this from the outside <g>, but several fixes and enhancements have made their way into the compiler.

•Added a YIELD EXIT statement (You can also use YIELD BREAK).

•Added an (optional) OVERRIDE keyword which can be used as modifier on virtual methods which are overridden in a subclass.

•Added a NOP keyword which you can use in code which is intentionally empty (for example the otherwise branch of a case statement. The compiler will no longer warn about an empty block when you insert a NOP keyword there.

•The On and Off keywords could cause problems, because they were not positional (these are part of the pragma statement). This has been fixed.

•_AND() and _OR() expressions with one argument now throw a compiler error.

•The compiler now recognizes the /VO14 (store literals as float) compiler switch (it has not been implemented yet).

•Added a ** operator as alias for the ^ (Exponent) operator.

•Added an "unsupported" error when using the Minus operator on strings.

•Fixed a "Stack overflow" error in the compiler that could occur for very long expressions.

•The right shift operator no longer conflicts with two Greater Than operators, which allows you to declare or create generics without having to put a space between them.
(var x := List<Tuple<int,int>>{}

 

Changes in 0.2.1

Visual Studio Integration

•Added and improved several project properties

•Fix a problem with the "Additional Compiler Options"

•Improved coloring in the editor for Keywords, Comments etc. You can set the colors from the Tools/Options dialog under General/Fonts & Colors. Look for the entries with the name "XSharp Keyword" etc.

•Added Windows Forms Template

Compiler

•Several errors have been demoted to warnings to be more compatible with VO/Vulcan

•Added support for Comment lines that start with an asterisk

•Added support for the DEFINE statement. For now the DEFINE statement MUST have a type
DEFINE WM_USER := 0x0400 AS DWORD

•Fixed problem with Single Line Properties with GET and SET reversed

•Several fixes for Virtual and Non virtual methods in combination with the /VO3 compatibility option

 

Changes in 0.1.7

•The "ns" (add default namespace to classes without namespace) has been implemented

•The "vo3" compiler option (to make all methods virtual ) has been implemented

•Fixed an issue where the send operator on an expression between parentheses was not compiling properly

•Relational operators for strings (>, >=, <, <=) are now supported. They are implemented using the String.Compare() method.

•Fixed a problem with local variables declared on the start line from FOR .. NEXT statements

•Added first version of the documentation in CHM & PDF format

•Added several properties to the Visual Studio Project properties dialog to allow setting the new compiler options

•Fixed a problem in the Targets files used by MsBuild because some standard macros such as $(TargetPath) were not working properly

•XIDE 0.1.7 is included. This version of XIDE is completely compiled with XSharp !

•The name of some of the MsBuild support files have changed. This may lead to problems loading a VS project if you have used the VS support from the previous build. If that is the case then please edit the xsproj file inside Visual Studio and replace all references of "XSharpProject" with "XSharp" . Then safe the xsproj file and try to reload the project again

•The WHILE.. ENDDO (a DO WHILE without the leading DO) is now recognized properly

 

Changes in 0.1.6

•This version now comes with an installer

•This version includes a first version of the Visual Studio Integration. You can edit, build, run and debug inside Visual Studio. There is no "intellisense" available.

•The compiler now uses 1-based arrays and the “az” compiler option has been implemented to switch the compiler to use 0-based arrays.

•The "vo2" compiler option (to initialize string variables with String.Empty) has been implemented

•Please note that there is no option in the VS project properties dialog yet for the az and vo2 compiler options. You can use the "additional compiler options" option to specify these compiler options.

•The text "this" and "base" in error messages has been changed to "SELF" and "SUPER"

•Error of type “visibility” (for example public properties that expose private or internal types) have been changed to warnings

•Fixed a problem with TRY … ENDTRY statements without CATCH clause

•The compiler now has a better resolution for functions that reside in other (X#) assemblies

•Fixed a problem which could lead to an "ambiguous operator" message when mixing different numeric types.

 

Changes in 0.1.5

•When an error occurs in the parsing stage, X# no longer enters the following stages of the compiler to prevent crashes. In addition to the errors from the parser also an error 9002 is displayed.

•Parser errors now also include the source file name in the error message and have the same format as other error messages. Please note that we are not finished yet with handling these error messages. There will be improvements in the format of these error messages in the upcoming builds.

•The compiler will display a “feature not available” (8022) error when a program uses one of the Xbase types (ARRAY, DATE, FLOAT, PSZ, SYMBOL, USUAL).

•Fixed an error with VOSTRUCT and UNION types

•Fixed a problem with the exclamation mark (!) NOT operator

 

Changes in 0.1.4

•Several changes to allow calculations with integers and enums

•Several changes to allow VO compatible _OR, _AND, _NOT an _XOR operations

•Fix interface/abstract VO properties

•Insert an implicit “USING System” only if not explicitly declared

•Error 542 turned to warning (members cannot have the same name as their enclosing type)

•Changes in the .XOR. expression definition

•Fix double quote in CHAR_CONST lexer rule

•Allow namespace declaration in class/struct/etc. name (CLASS Foo.Bar)

•Fix access/assign crash where identifier name was a (positional) keword: ACCESS Value

•Preprocessor keywords were not recognized after spaces, but only at the start of the line. This has been fixed.

•Prevent property GET SET from being parsed as expression body

•Fix default visibility for interface event

•Unsafe errors become warnings with /unsafe option, PTR is void*

•Fix dim array field declaration

•Initial support of VO cast and VO Conversion rules (TYPE(_CAST, Expression) and TYPE(Expression)). _CAST is always unchecked (LONG(_CAST, dwValue)) and convert follows the checked/unchecked rules (LONG(dwValue))

•Fixed problem with codeblock with empty parameter list

•Fixed problems with GlobalAttributes.

•An AUTO property without GET SET now automatically adds a GET and SET block

•Allow implicit constant double-to-single conversion

 

Changes in 0.1.3

•Change inconsistent field accessibility error to warning and other similar errors

•Added commandline support for Vulcan arguments. These arguments no longer result in an error message, but are not really implemented, unless an equivalent argument exists for the Roslyn (C#) compiler. For example: /ovf and /fovf are both mapped to /checked, /wx is mapped to /warnaserror. /w should not be used because that has a different meaning /warning level). /nowarn:nnnn should be used in stead

•Fixed problem where the PUBLIC modifier was assigned to Interface Members or Destructors

•Prevent expression statements from starting with CONSTRUCTOR() or DESTRUCTOR()

•Added support for ? statement without parameters

•The default return type for assigns is now VOID when not specified

•Added support for “old Style” delegate instantiation

•Added support for Enum addition

•Added an implicit empty catch block for TRY .. END TRY without catch and finally

•Added support for the DESCENDING keyword in LINQ statements

•Added support for VIRTUAL and OVERRIDE for Properties and Events

•Prevent implied override insertion for abstract interface members

•Fixed a problem where System.Void could not be resolved

•Fixed problem with Property Generation for ACCESS/ASSIGN

•Fixed problem with Abstract method handling

 

Changes in 0.1.2.1

•Added default expression

•Fixed problem with events

•Fixed some small lexer problems

•Fixed problem with _DLL FUNCTION and _DLL PROCEDURE

 

Changes in 0.1.2

•Fixed problem with handling escape sequences in extended strings

•Fixed issue in FOR.. NEXT statements

•Fixed a problem with SWITCH statements

•Fixed a problem with the sizeof() operator

•Fixed a problem in the REPEAT .. UNTIL statement

•Fixed a problem in TRY .. CATCH .. FINALLY .. END TRY statements.

•Fixed issue in Conditional Access Expression ( Expr ? Expr)

•Allow bound member access of name with type args

•Fixed problem in LOCAL statement with multiple locals

•Fixed a problem when compiling with debug info for methods without a body

•Optimized the Lexer. This should increase the compile speed a lot

•Fixed a problem in the code that reports that a feature is not supported yet

•Fixed a problem when defining Generic types with a STRUCTURE constraint

•Compiler macros (__ENTITY__, __LINE__ etc) were causing a crash. For now the compiler inserts a literal string with the name of the macro.

•Build 0.1.1 did not contain XSC.RSP

•Fixed a problem where identifiers were not recognized when they were matching a (new) keyword