This is a not so official version!!

This version is only for Windows at the moment, sorry.
To install this version, simply unzip it over your existing
installation, but make a backup of your installation first!
And please remember to replace the xb.dll in in your path, for example:
C:\WINDOWS\xb.dll

If you create a stand alone executables and want to send it to others,
please also send the new xb.dll, or the new functions will not work.

Changes for XBasic version 6.2.4 for windows:

In the PDE:

All options / settings (except breakpoints) will be saved on exit.
Most window sizes and positions are saved. 

The cursor is now flashing.

If the find / replace button is clicked and no find / replace text is
specified, the find / replace box is poped up.

Double clicking on the list in the variables window now has the same
function as the details button

In the variables window you can now disable / enable the display of
type, location or hex values.

In the array window double clicking on the list will go to the next
lower dimension or the detail window if already on the lowest
dimension (data).


New options under "option misc":

auto upper case:
        When checked all basic tokens will be automatically converted 
        to upper case when the program is compiled, or run in the    
     
        PDE.. Be carefull with this option, it can mess up program 
        text that has lines like len = len(a$).
        If the case is once converted, it can't be reverted!
        For editing of existing code it should be left unchecked.
        If you have accidentally loaded a program with auto uppercase
        on, you should set auto uppercase to off and leave the PDE 
        without saving the program.

auto indent:
        If the option "auto indent" in option misc is checked,
        pressing enter will indent the new line like the last one.

tab block indent:
        If the option "tab block indent" in option misc is checked,
        a block of selected text can be indented / unindented with
        tab / shift-tab

make backup file:
        If the option "make backup file" is checked, a copy with
        extension .bak of the version on disk will be created before
        the text/program is saved.

save before comp.:
        If the option "save before comp." is checked, the program
        will be saved, if it is altered, before compilation

save before run:
        If the option "save before run" is checked, the program will
        be saved, if it is altered, before running.

reload last file:
        If the option "reload last file" is checked, the last text /
        program that was in the PDE will be reloaded on next startup.


New menu entry under "status"
        "clear errors" will remove the error flags from the source.

Changes to the key functions:

Insert key:
        The insert key now works as expected, it will toggle insert
         / overwrite mode in the text area.
        Overwrite mode is indicated by a block cursor.

Changes to the console window:
        Changing of text with the delete- / backspace-key is now
        disabled when not in input mode with INLINE$().
        Typed in keys now only printed when in input mode, but they
        are still buffered, so you can read them in with READ [1],a$
        for example. The input buffer is deleted before the INLINE$()
        function reads the input. Backspace will now only delete the
        typed in chars.


Adopted from xblite are the following functions:
For more details, have a look at the xblite help.

It is reported, that the random functions from xblite are not
that random. So they may be only usefull for games.

XstRandom():
        Returns a ULONG random number.

XstRandomCreateSeed()
        Returns a ULONG seed number.

XstRandomSeed(ULONG):
        Sets the start seed for XstRandom().

XstRandomUniform():
        Returns a DOUBLE value in the rande 0 < uni < 1.

XstTally(source$, find$):
        Returns the count find$ in source$.

XstParse$(source$, delimiter$, n)
        Returns the n-th part of source$ that is delimited by
         delimiter$.

XstParseStringToStringArray(source$, delimiter$, @s$[])
        Will break the string source$ by the token delimiter$
        into parts and puts them into s$[].


New functions added by me:

Functions to easily handle preferences and settings of programs.
A preference file is a text file that contains "key=value" lines,
and is divided into sections, a section starts with "
[NameOfThisSection]"
Different sections can have same key names.
On first opening a preference file the section name is set to empty,
so all adding of keys to that section will be inserted at the start
of the file.


XstOpenPref(file$):
        Will read a preference file named file$ into memory, if that
        file doesn't exist, a empty preference will be created.
        On success it will return a preference number above 0.
        The returned preference number can be used in calls to other
        preference functions.
        The returned number is only valid for calls to preference
        functions and has nothing to do with file numbers.

XstGetPrefFile(prefNumber, @file$):
        Sets file$ to the filename of the opened prefNumber.

XstSavePref(prefNumber):
        Will save the settings from memory to the preference file and
        marks the data in memory as unchanged.

XstDiscardPref(prefNumber):
        Frees the memory used by the preference settings, all changes
        made so far are lost.
        The preference number is no longer valide after this function
        is called.

XstClosePref(prefNumber):
        If the data in memory is changed, it will be saved to disk,
        then the memory for this data will be freed.
        The preference number is no longer valide after this function
        is called.

XstDeletePrefKey(prefNumber, key$):
        The key and value of the key name in key$ will be deleted from
        the data in memory.

XstDeletePrefSection(prefNumber, section$):
        Deletes the complete section named in section$ from memory.

XstSetPrefSection(prefNumber, section$):
        Will set the actual section to section$, if the section 
        does not yet exist, it will be created.
        All functions after this call will only work on the new 
        section.
XstGetPrefSection(prefNumber, @section$):
        Returns the name of the actuall used section in section$.

XstSetPrefSTRING(prefNumber, key$, value$):
        Set the key with name in key$ to the string in value$.
        If the key already exist it will be replaced, otherwise it
        will be added at the end of the actual section.

XstSetPrefXLONG(prefNumber, key$, value):
        Set the key with name in key$ to the number in value.
        If the key already exists it will be replaced, otherwise it
        will be added at the end of the actuall section.

XstGetPrefSTRING(prefNumber, key$, value$, @result$):
        Will set result$ to the value of the key named in key$ and 
        the function returns 0. If the key doesn't exist in this 
        section, then it will be set to value$ and the function 
        returns a non-zero value

XstGetPrefXLONG(prefNumber, key$, value, @result):
        Will set result to the value of the key named in key$ and the
        function returns 0. If the key doesn't exist in this section, 
        then it will be set to value and the function returns a non-
        zero value

Saving and loading of a whole array.
These functions will save / load a whole array of any type and
dimensioning, even unregular forms. On loadin an array, be carefull
only to load it into the same type of array as you have saved it from.

XstLoadArray(file$, @array[]):
        Load the array data from the file named in file$ into array[].
        If the file can't be opened or is not a XBasic array file, 
        the function returns a non-zero value, otherwise it will 
        return 0.

XstSaveArray(file$, @array[]):
        Save the array[] to the file named in file$.
        If the file can't be opened, the function returns
        a non-zero value, otherwise it will return 0.

Comparing two arrays.

XstCompareArray(@array1[], @array2[], @result):
        Compares the two arrays and counts how many differences there
        are. Both arrays must be of same size and type. The number of
        differences are returned in result,which should be set to 0
        on entry.

        The function returns one of this constant values:
        $$CompareArrayEqual        =  0, both arrays are equal
        $$CompareArrayNotEqual     = -1, arrays have different values
                                         in some places
        $$CompareArrayNotSameSize  = -2, arrays are not of the same 
                                         size
        $$CompareArrayNotSameType  = -3, arrays are not of the same 
                                         type
        $$CompareArrayNotSameNode  = -4, some nodes are not the same 
                                         type

Changes from version V6.2.4(-jdl) to V6.2.5-jdl

The auto uppercase had a bug.
On each conversion the char behind a dollarsign was deleted.
But it's still only for very simple programms, where you dont
want to type any keyword in uppercase.
Don't use this on more complex or unknown source!!

The INSERT-key alone toggles insert / overwrite mode.

SHIFT-INSERT will paste the text from the clipboard.

The search and replace icons on the PDE and the F11- / F12-keys
are now working as follows:

Find icon / F12:            Repeat last find
Find icon / F12 + SHIFT:    Popup find / replace dialog
Find icon / F12 + CTRL:     Repeat last find in reverse direction

Replace icon / F12:         Repeat last replace
Replace icon / F12 + SHIFT: Popup find / replace dialog
Replace icon / F12 + CTRL:  Repeat last replace in reverse direction

Send questions or remarks to: jensdelling@alice-dsl.de aka technicorn

Happy coding,
jensdelling@alice-dsl.de