maxkleiner / maxbox4 Goto Github PK

class function IsSymbol(C: Char): Boolean; overload; static;

Determines whether a UTF-16 character is defined as a symbol in the Unicode specifications.

Returns true if the UTF-16 character is defined as a symbol in the Unicode specifications.

put the function
FilesFromWildcard(Exepath, '10*.txt',mfilel, true, true, true)
in a recursive way to get
mfilel:= TStringlist.create;
FilesFromWildcard(Exepath, '10*.txt',mfilel, true, true, true)
writeln(mfilel.text)
mfilel.Free;

With the Release of 5.1.4.80 we fixed following:
5.1.4.70 XN Resource Editor & Game of Life
5.1.4.75 Unit Dependency Analyzer & TADOCommands & SQL Workbench for 64bit ODBC
5.1.4.80 Geocoding IV Unit & fix main bugfixing
5.1.4.80 IV ADODB OLE Object bugfixing
5.1.4.90 ADOQuery SQL property, UC Save
5.1.4.90 II Geocoding V & 0Auth HMAC_SHA1
5.1.4.90 III ClientDataSet fix, TDataset functions, CSVBase
5.1.4.98 VII Resource Explorer as XN and Delphi Regular Expressions as PCRE16
5.1.4.98 XII Char2() instead of inttoascii() - FormatJSON - findUtf8BOM

I wanna mention general bugs found since version 5.0.2.70 to 5.1.4.98 🐞

1. [var as word type] Having a var as word type you get a type mismatch unless you change word to dword (list below)
   Example: DecodeDate( Date : TDateTime; var Year, Month, Day : Word);
   change var ttyear, ttMonth, ttDay : dWord;
   DecodeDate(now, ttYear,ttMonth, ttDay);
   use floatIsNan instead of isNan()
   use floorj() instead of floor()

2. [inttoAscii instead of chr] some functions need IntToAscii( Value : Int64; Digits : Int) :Str; instead of chr() function
   2a // if (ex[2]) in strtochars(DIGISET) then writeln('in digiset'); wont work assign with c: char 👍
   c := ex[2];
   if c in strtochars(DIGISET) then writeln('in digiset');
   function IntToBinStr(AInt : LongWord) : string;
   begin
   Result := '';
   repeat
   Result := inttoAscii(Ord('0')+(AInt and 1),1)+Result;
   AInt := AInt div 2;
   until (AInt = 0);
   end;

3. [enums or set] a few properties cant load a set of like //Font.Style:= [fsBold];
   just uncomment helps - on progress
   use Font.Style2:= FSStrikeout2;
   3b. [turtle lib] replace position with setpos()
   mp.x:= round(60p+300); //position on canvas
   mp.y:= round(60(11-q));
   //position:= mp
   setpos(mp.x, mp.y)

4. [No mapping for the Unicode] debug: 341-No mapping for the Unicode character exists in the target multi-byte code page 863 err:20
   Then you have to save the file as UTF-8
   In menu ../Options/Saveas Unicode/ you can save code to UTF-8 with one click
   Attention it switches back to ANSI with another click! (no autocheck)
   if file load raise Exception: No mapping for the Unicode character exists
   in the target multi-byte code page at 0.146
   Then you must save the file as utf-8 with notepad or saveStringUC(path):
   procedure SaveString2(const AFile, AText: string);
   procedure SaveString3(const AFile, AText: string; Append: Boolean); //UTF8
   procedure SaveStringUC(const AFile, AText: string; Append: Boolean); //UTF8 - Unicode
   function LoadFile3(const FileName: TFileName): string;
   function LoadFileUC(const FileName: TFileName): string;
   combination test:
   writeln(loadfileUC(ExePath+’upsi_allfunctionslist2.txt’));
   sleep(700)
   savestringUC(ExePath+’upsi_allfunctionslist2save.txt’,
   loadfileUC(ExePath+’upsi_allfunctionslist2.txt’),true) //append
   Charset Function:
   function WideCharsInSet( wcstr:WideString; wcset:TBits):Boolean;
   function JSONUnescape(const Source: string; CRLF: string{ = #13#10}): string;
   function ParseJsonvalue(jsonutf8: string): string;
   procedure setdebugcheck(false);
   Here you can find a completer UTF-8 chars conversion list:
   http://bueltge.de/wp-content/download/wk/utf-8_kodierungen.pdf
   look at in built mX5 class at the bottom
   SIRegister_flcUnicodeCodecs

Example with CharsetConversion from call to google translator REST API:

1. trans atext:= 'bonjour mes amis da la ville of coding avec design';
2. json escaped utf8 ["Hola mis amigos en la ciudad de codificaci\u00c3\u00b3n con dise\u00c3\u00b1o","fr"]
3. trans back ParseJsonValue(): ["Hola mis amigos en la ciudad de codificación con diseño","fr"]
   writeln('mimecharset '+
   CharsetConversion(ParseJsonValue(Text_to_translate_API2(AURL,'dict-chrome-ex','auto','es',
   (atext))),UTF_8, ISO_8859_1));
4. mimecharset ["Hola mis amigos en la ciudad de codificación con diseño","fr"]
   Example Parse JSON Array:
   writeln('len node names: '+itoa(ajar.length))
   for it:= 0 to jo2.length-1 do begin
   //writeln(JSONUnescape(jo2.getstring(jo2.keys[it]), #13#10));
   writeln(CharsetConversion(parsejsonvalue(jo2.getstring(jo2.keys[it])),UTF_8,ISO_8859_1));
   //savstr:= savstr + jo2.getstring(jo2.keys[it]);
   savstr:= savstr +CharsetConversion(parsejsonvalue(jo2.getstring(jo2.keys[it])),UTF_8,ISO_8859_1);
   end;

StreamtoString new functions:
[Function TryMemoryStreamToString(const MS: TMemoryStream; var s: string): Boolean;
begin
Result:= False; if(MS=Nil) then Exit;
try
SetLength(s, MS.Size - MS.Position);
writeln('debug size: '+itoa(length(s)));
MS.Read(s, Length(s));
Result:= True;
except
Result:= False;
end;
end;

Function TryStringToMemoryStream(const s: string; var MS: TMemoryStream):Boolean;
begin
Result:= False; if(MS=Nil) then Exit;
try
//SetLength(s, MS.Size - MS.Position);
writeln('debug size2: '+itoa(length(s)));
MS.Write(s, Length(s));
Result:= True;
except
Result:= False;
end;
end;
](url)

Unicode Encoding Decoding Charset UTF-8 Detection

In menu ../Options/Saveas Unicode/ you can save code to UTF-8 with one click
Attention it switches back to ANSI with another click! (no autocheck)
if file load raise Exception: No mapping for the Unicode character exists
in the target multi-byte code page at 0.146
Then you must save the file as utf-8 with notepad or saveStringUC(path):
procedure SaveString2(const AFile, AText: string);
procedure SaveString3(const AFile, AText: string; Append: Boolean); //UTF8
procedure SaveStringUC(const AFile, AText: string; Append: Boolean); //UTF8 - Unicode
function LoadFile3(const FileName: TFileName): string;
function LoadFileUC(const FileName: TFileName): string;
combination test:
writeln(loadfileUC(ExePath+’upsi_allfunctionslist2.txt’));
sleep(700)
savestringUC(ExePath+’upsi_allfunctionslist2save.txt’,
loadfileUC(ExePath+’upsi_allfunctionslist2.txt’),true) //append
Charset Function:
function WideCharsInSet( wcstr:WideString; wcset:TBits):Boolean;
function JSONUnescape(const Source: string; CRLF: string{ = #13#10}): string;
function ParseJsonvalue(jsonutf8: string): string;
procedure setdebugcheck(false);
Here you can find a completer UTF-8 chars conversion list:
http://bueltge.de/wp-content/download/wk/utf-8_kodierungen.pdf
look at in built mX5 class at the bottom
SIRegister_flcUnicodeCodecs

Example with CharsetConversion from call to google translator REST API:

1. trans atext:= 'bonjour mes amis da la ville of coding avec design';
2. json escaped utf8 ["Hola mis amigos en la ciudad de codificaci\u00c3\u00b3n con dise\u00c3\u00b1o","fr"]
3. trans back ParseJsonValue(): ["Hola mis amigos en la ciudad de codificación con diseño","fr"]
   writeln('mimecharset '+
   CharsetConversion(ParseJsonValue(Text_to_translate_API2(AURL,'dict-chrome-ex','auto','es',
   (atext))),UTF_8, ISO_8859_1));
4. mimecharset ["Hola mis amigos en la ciudad de codificación con diseño","fr"]

Example Parse JSON Array:
writeln('len node names: '+itoa(ajar.length))
for it:= 0 to jo2.length-1 do begin
//writeln(JSONUnescape(jo2.getstring(jo2.keys[it]), #13#10));
writeln(CharsetConversion(parsejsonvalue(jo2.getstring(jo2.keys[it])),UTF_8,ISO_8859_1));
//savstr:= savstr + jo2.getstring(jo2.keys[it]);
savstr:= savstr +CharsetConversion(parsejsonvalue(jo2.getstring(jo2.keys[it])),UTF_8,ISO_8859_1);
end;

const tname= 'Subject: =?iso-8859-1?Q?Die_besten_W=FCnsche_zum_Neuen_Jahr_2021?=';

writeln('mimecharset '+CharsetConversion(tn,ISO_8859_1, UTF_8));
writeln('mimecharset '+CharsetConversion(tname,ISO_8859_1, win_1252));
writeln( MimeCharsetToCharsetString(ISO_8859_1) );

solution: writeln(DecodeHeader(tname)); or writeln(ForceDecodeHeader(tname));
-----> Subject: Die besten Wünsche zum Neuen Jahr 2021
writeln(UTF8toAnsi(ALUTF8HTMLdecode('Kaufbestätigung')))
-----> Kaufbestätigung

Inconsistent Case with Charset Detection:
//UTF-8 -> Windows-1251 -> UTF-8 -> Windows-1256 ?
sr:= 'Desinfektionslösungstücher für Flächen';
//sr:= CharsetConversion(sr,UTF_8, win_1251)
writeln('mimecharset2 '+CharsetConversion(sr,UTF_8, win_1256));

mimecharset2 DesinfektionslÃ_sungstÃ_cher fÃ_r FlÃ_chen

6. [SRE module mismatch] ebug: 59-AssertionError: SRE module mismatch 849 err:20 849 err:20
   Then its a python4delphi issue in multiinstaller of several 64-bit installation like
   C:\maxbox\maxbox5>py -0
   -V:3.12 * Python 3.12 (64-bit)
   -V:3.11 Python 3.11 (64-bit)
   -V:3.11-32 Python 3.11 (32-bit)
   -V:3.10-32 Python 3.10 (32-bit)
   -V:3.8 Python 3.8 (64-bit)
   The best you can get is to rename the last directory of Python install for exxample:
   C:\Users\User\AppData\Local\Programs\Python\Python312
   rename to C:\Users\User\AppData\Local\Programs\Python\Python312_
   then the remote interpreter shell uses V3.11 and so on

ordered list of [var as word type] in maxbox_functions
http://www.[softwareschule.ch/maxbox_functions.htm](http://www.softwareschule.ch/maxbox_functions.htm)
//line regex: Rex.Regex:= '(?i)(\bVar\b.*\bWord\b)'; not right

match all var of type :word but only of type word in a line
line regex: Rex.Regex:= '(?i)(\bVar\b([\w\s,]+(\s*:\s*))\bWord\b)';

0 648 Func DecLimit3( var B : Word; const Limit : Word; const Decr : Word) : Word;
1 655 Func DecLimitClamp3(var B:Word;const Limit: Word; const Decr : Word) : Word;
2 659 Func DecodeDateFully(DateTime: TDateTime; var Year,Month,Day,DOW:Word):Bool
3 1597 Func IncLimit3( var B : Word; const Limit : Word; const Incr : Word) : Word;
4 1604 Func IncLimitClamp3( var B : Word; const Limit : Word; const Incr : Word) : Word;
5 1689 Func InternalDecodeDate(DateTime:TDateTime;var Year,Month,Day,DOW:Word):Boolean
6 3073 Func WeekOfTheMonth1( const AValue : TDateTime; var AYear, AMonth : Word) : Word;
7 3075 Func WeekOfTheYear1( const AValue : TDateTime; var AYear : Word) : Word;
8 3424 Proc JDecodeDate( Date : TDateTime; var Year, Month, Day : Word);
9 3425 Proc DecodeDate1( Date : TDateTime; var Year : Int; var Month, Day : Word);
10 3475 Proc FileTimeToDosDateTime1( const FileTime : TFileTime; var Date, Time: Word);
11 3770 Proc DateDiff(Date1, Date2: TDateTime; var Days, Months, Years: Word);
12 4944 Proc DateDiff(Date1, Date2: TDateTime; var Days, Months, Years: Word);
13 5462 Proc IncLimW( var B : Word; const Limit : Word)
14 5467 Proc DecLimW( var B : Word; const Limit : Word)
15 5482 Proc SwapW( var B1, B2 : Word)
16 5887 Func Str2WordS(const S: ShortString; var I : Word) :Bool
17 5999 Proc SetFlag( var Flags : Word; FlagMask : Word)
18 6000 Proc ClearFlag( var Flags : Word; FlagMask : Word)
19 6009 Proc ExchangeWords( var I, J : Word)
20 6245 Proc ValWord( const S : ShortString; var Wd : word; var ErrorCode : Int)
21 6708 Func ExtractAssociatedIcon(hInst:HINST;lpIconPath:PChar;var lpiIcon:Word):HICON
22 8371 Proc ISOWeekNumber( const D : TDateTime; var WeekNumber, WeekYear : Word)
23 12860 Proc PtrInc( var P, Delta : Word)
24 12861 Proc PtrDec( var P, Delta : Word)
25 14514 //Proc VersionExtractFileInfo(const FixedInfo:TVSFixedFileInfo;var Major,Minor,Build,Revision:Word);
26 14515 //Proc VersionExtractProductInfo(const FixedInfo:TVSFixedFileInfo;var Major,Minor,Build,Revision:Word);
27 15207 Proc glDivMod( Dividend : Int; Divisor : Word; var Result, Remainder : Word)
28 16233 Proc cyAddMonths( var aMonth, aYear : Word; Months : Int);
29 18441 Func Str2WordL( const S : Ansistr; var I : Word) :Bool;
30 20444 Func GetAppVersion(const ALibName:str;var MajorVersion,MinorVersion,BuildNumber,RevisionNumber:Word):Bool;
31 21535 Proc SwapWord2( var x : word);
32 21607 Proc DecodeDatereal( Date : TDatetimeReal; var Year, Month, Day : Word);
33 21608 Proc DecodeDateTimereal(const AValue:TDatetimeReal;var Year,Month,Day,Hour,Minute,Second,MilliSecond:Word);
34 21609 Proc DecodeTimereal( Time : TDatetimeReal; var Hour, Min, Sec, MSec : Word);
35 21640 Func parsetimeISO(timestr:str;var hourval,minval,secval:word;var offsethourval,offsetminval:Int;var UTC:bool):bool;
36 21641 Func parsedateISO( datestr :Str; var yearval, monthval, dayval : word) :Bool;
37 21643 Proc jdtodate(jday:float; var year, month, day, hour, minute, second, msec : word);
38 21647 Proc getdatedos( var year, month, mday, wday : word);
39 21648 Proc gettimedos( var hour, minute, second, sec100 : word);
40 21664 Proc JulianToGregorian(JulianDN:big_Int_t;var Year,Month,Day:Word);;
41 21673 Func IsValidISODateStringExt(datestr:shortstring;strict:bool;var Year,Month,Day:word):bool;
42 21675 Func IsValidISOTimeStringExt(timestr:shortstring;strict:boolean;var hour,min,sec:word;var offhour,offmin: smallint):bool;
43 21680 Proc UNIXToDateTime2(epoch:big_Int_t; var year,month,day,hour,minute,second: Word);
44 22597 CRC16Init( var CRC16 : Word);
45 27738 Function GetHotkey( var pwHotkey : word) : HResult');
46 27786 Function azuJPEGDimensions( Filename : string; var X, Y : Word) : boolean');
47 30255 Procedure apiOsBuildInfo( var v1, v2, v3, v4 : word)');
48 31215 procedure(Sender: TObject; var Key: Word; Shift: TShiftState);
49 31328 Proc BooleansToBits1( var Dest : Word; const B : TBooleanArray);
50 31360 Proc cbPathKeyDown( Sender : TObject; var Key : Word; Shift : TShiftState)
51 31415 Proc ColorRGBToHLS( clrRGB : TColorRef; var Hue, Luminance, Saturation : Word)
52 31440 Proc CopyBytesToHostWord(const ASource:TIdBytes;const ASourceIndex:Int;var VDest: Word)
53 31480 Proc DecodeDate( DateTime : TDateTime; var Year, Month, Day : Word)
54 31481 Proc DecodeDate(const DateTime: TDateTime; var Year, Month, Day: Word);
55 31487 Proc DecodeTime( DateTime : TDateTime; var Hour, Min, Sec, MSec : Word)
56 31488 Proc DecodeTime(const DateTime: TDateTime; var Hour, Min, Sec, MSec: Word);
57 31525 Proc DivMod( Dividend : Int; Divisor : Word; var Result, Remainder : Word)
58 31769 Proc IncAMonth( var Year, Month, Day : Word; NumberOfMonths : Int)
59 31835 Proc ListViewKeyDown( Sender : TObject; var Key : Word; Shift : TShiftState)
60 32153 Proc SaveToClipboardFormat(var AFormat:Word; var AData: THandle; var APalette: HPALETTE)
61 32154 Proc SaveToClipboardFormat(var Format: Word; var Data : THandle; var APalette: HPALETTE)
62 32266 Proc SHORTCUTTOKEY( SHORTCUT : TSHORTCUT; var KEY : WORD; var SHIFT : TSHIFTSTATE)
63 32343 Proc SwapOrd3( var I, J : Word);
64 33099 Func WordIsOk(const AWord:Str; var VW: Word):Bool;
65 38410 Proc GetJPGSize(const sFile:Str; var wWidth, wHeight: Word);
66 38411 Proc GetPNGSize(const sFile:Str; var wWidth, wHeight: Word);
67 38413 Proc GetGIFSize(const sGIFFile:Str; var wWidth, wHeight: Word);
68 38667 Func ScanNumber(const S:Str; var Pos: Int; var Number: Word):Bool;
69 39130 Proc DecDay( var Year : Int; var Month, Day : Word);
70 39131 Proc DecDays( var Year : Int; var Month, Day : Word; const Days : Int);
71 39138 Proc FirstDayOfWeekYmd( var Year : Int; var Month, Day : Word);
72 39169 Proc diIncMonth( var Year : Int; var Month, Day : Word);
73 39170 Proc diIncMonths(var Year :Int; var Month, Day:Word; const NumberOfMonths:Int);
74 39171 Proc diIncDay( var Year : Int; var Month, Day : Word);
75 39172 Proc IncDays( var Year : Int; var Month, Day : Word; const Days : Int);
76 39199 Proc LastDayOfWeekYmd( var Year : Int; var Month, Day : Word);
77 43845 Example: DecodeDate( Date : TDateTime; var Year, Month, Day : Word);

after 3.6.0.2 to 3.6.1 to 3.6.2

add functions found in 241_RTL_SET.txt

add functions like colortoRGB found in delphi 2 S. 514 prozeduren etc. --> O.K.

by onclose() event with TAction the debugger stops

ado.sql.add wont work it's twidestring of sql member

clientdataset.FieldByName('Value').AsString := 'Paul Rigby'; is missing -->OK.

screen.cursors missing -->OK.

fillchar map the function with an array
from gethinstance to hinstance with a mapping function -->OK.

add unit clientdatasetutils from hp-rechner - cdutils.pas -->OK.
test component tanimate with an example -->OK.

MyForm.Icon.LoadFromResourceName bzw MyForm.Icon.LoadFromResourceID is missing
Application.Icon.LoadFromResourceName bzw Application.Icon.LoadFromResourceID is missing
//Screen.Cursors[crMaletUp] := LoadCursor(HInstance, 'Malet'); geht nicht loadcoursor is missing --->OK.

options function show all resource bitmap in a graphic list like memory game to choose from
include in V4 the res_maxplorer.exe ?

form.OnMinimize := @TSwatForm_Pause1Click; is missing -->OK.

Application.OnRestore := @TSwatForm_Pause1Click; -->OK.

FPC check the rtl manual on fpc

processpath dont work

check bcd with a packed record in unit source -->O.K.

make example of BCD from 241_RTL_SET.txt --> O.K.

add functions in functionlist of upsi_provider and upsi_dbclient and upsi_dbplatform --> OK.

function of tcomponent findcomponent -->OK.

add property Count: Integer read FCount write SetCount; in tobjectlist, tcomponentlist etc.

mini maXbox as less files

change mbversion of toolsapi in addconstant to var! -->OK.

FileSetDate( has two ways of parameters

correction of bestof runtime2 cmdline etc. in examples -->OK.
correction of examples with combination -->OK.

add functions in functionlist (fahrenheit , createmessagedlg ...----->OK.

original filename maxbox3_6.exe -->OK.

make example fastform with createmessagedialog outline & calendar -->OK. BCD

DlgType: TMsgDlgType; is missing -->OK.

opendialog can't execute maybe the constructor or the overload execute! -->OK.
tsavedialog has also an execute() but with pointers!-->OK.

types in strutils and dialogs dont match:$ -->OK.

CL.AddTypeSTMsgDlgButtons','set of TMsgDlgBtn); -->OK.
works with an empty set

functions of unit controls/classes is missing -->OK.

msecsperday is missing --OK.

copy file:
file:///C:/maxbook/maxbox3/maxbox33/maxbox3/docs/36test/DelphiVCL_RTLOverview.html --->OK.

check procedure Halt [ ( Exitcode: Integer) ];
with exitcode

use the function to check a set 👍

  ``` or it:= 0 to 9 do 
    if itoa(it)[1] in strtochars('BCE03C310FAEBA451DF2BDEE7B3A0DE2B5ECB8BD') then
      write('found: '+ itoa(it)+' ');
    writeln(CRLF)
  for it:= ord('A') to ord('F') do 
    if chr(it) in strtochars('BCE03C310FAEBA451DF2BDEE7B3A0DE2B5ECB8BD') then
      write('found: '+ chr(it)+'  ')`````

Add 20 Units + 8 Tutorials

1413 unit uPSI_PythonEngine.pas _P4D_Beta
1414 unit uPSI_VclPythonGUIInputOutput;
1415 unit uPSI_VarPyth;
1416 unit JclUsesUtils;
1417 unit uPSI_cParameters;
1418 unit uPSI_WDCCMisc; (uPSI_cFileTemplates);
1419 uPSI_WDCCOleVariantEnum.pas
1420 unit uPSI_WDCCWinInet.pas _WDCC
1421 uPSI_PythonVersions.pas
1422 unit uPSI_PythonAction.pas

SIRegister_TFastStringStream(CL);
procedure LoadJPEGResource(image1: TImage; aJpgImage: string);
function CreateDOSProcessRedirected3(const CommandLine, InputFile, OutputFile,
ErrMsg: string): Boolean;
function SysCharSetToStr(const C: TSysCharSet): AnsiString;
function StrToSysCharSet(const S: AnsiString): TSysCharSet;
Procedure MaskFPUExceptions( ExceptionsMasked : boolean; MatchPythonPrecision: Boolean);
Function GetOleVariantEnum( Collection : OLEVariant) : IGetOleVariantEnum);
Function GetOleVariantArrEnum( Collection : OLEVariant) : IGetOleVariantEnum);
Function GetRegisteredPythonVersions : TPythonVersions');

Total of Function Calls: 33848
SHA1: of 4.7.5.80 3E38A48072D4F828A4BE4A52320F092FE50AE9C3
CRC32: B6F69E19 29.8 MB (31,344,456 bytes)

best would be items of key and value
procedure stringHashtest;
var hash : TStringHash2;
//Here’s unit with those TIntegerHash2 and TStringHash2, TObjectHash2 described @
basehash: THash2;
begin
hash:= TStringHash2.Create;
try
hash['one']:= 'viens value';
hash['two']:= 'divi value';
//ShowMessage(hash['one']);
//ShowMessage(hash['two']);
if hash.exists('one') then
writeln(hash['one']);
writeln(hash['two']);
hash.Rename('one', 'onerename');
writeln(hash['onerename']);
finally
hash.Free;
end;
end;

by calling direct app.onmessage handler we get an app crash but indirect it works an we stop the loop with Q to quit:

while (GetMessage(Msg, 0, 0, 0)) And (Not msgstop) do begin
    inc(cnt)
    aUnicode:= (Msg.hwnd = 0);
     //or (IsWindowUnicode(Msg.hwnd));          
    TranslateMessage(Msg);
    if aUnicode then
      wDispatchMessage(Msg) else
        DispatchMessage(Msg);
        if msg.wparam = 81 then exit;    //Q sign
      //writeln(itoa(msg.wparam)+': '+itoa(msg.lparam)+' '+botostr(msgstop))
      PrintF('msg: %d of hwnd: %d, wpara: %d, lpara: %d, mess: %d',
             [cnt, msg.hwnd,msg.wparam,msg.lparam, msg.message]);  
    application.processmessages;         
    //else  

  //DispatchMessage(Msg);              

end;

A kernel for Pascal is essential.

python pascal console attach example

with GetDOSOutput und AttachConsole is just the first step.
The kernel and client live in different processes. They communicate via messaging protocols implemented on top of network sockets. Currently, these messages are encoded in JSON, a structured, text-based document format.

Our kernel receives code from the client (the notebook, for example). The do_execute() function is called whenever the user sends a cell's code.

The kernel can send messages back to the client with the self.send_response() method:

The first argument is the socket, here, the IOPub socket
The second argument is the message type, here, stream, to send back standard output or a standard error, or display_data to send back rich data
The third argument is the contents of the message, represented as a Python dictionary

The data can contain multiple MIME representations: text, HTML, SVG, images, and others. It is up to the client to handle these data types. In particular, the Notebook client knows how to represent all these types in the browser.

TApdComPort.create
Test comport 2 properties: LogName+TraceName not available'
CPort:
TComComboBox.create(frmmain)
//OnChange := @ccbComPortListChange is missing

add JclStackInfoList: TJclStackInfoList; to baselib:
function GetCallStack: String;
var
JclStackInfoList: TJclStackInfoList;
StringList: TStringList;
begin
JclStackInfoList := JclCreateStackList(True, 3, Caller(0, False));
try
StringList := TStringList.Create;
try
JclStackInfoList.AddToStrings(StringList, True, False, True, True);
Result := StringList.Text;
finally
StringList.Free;
end;
finally
JclStackInfoList.Free;
end;
end;

the work for the 64bit box has begun but libs, maps, transpiler and registering is full of traps

I did organize a third findfirst system (FindFirst3 and TFindRec) cause the compatibility with the standard was not given:

procedure LoadFilesByMask(lst: TStrings; const SpecDir, WildCard: string); var intFound: Integer; SearchRec: TFindRec; begin lst.Clear; if FindFirst3(SpecDir + WildCard, SearchRec) then repeat lst.Add(SpecDir + SearchRec.Name); until FindNext3(SearchRec) = false; FindClose3(SearchRec); end;

Standard system:

{procedure LoadFilesByMask(lst: TStrings; const SpecDir, WildCard: string); var intFound: Integer; SearchRec: TSearchRec; begin lst.Clear; intFound := FindFirst(SpecDir + WildCard, faAnyFile, SearchRec); while intFound = 0 do begin lst.Add(SpecDir + SearchRec.Name); intFound := FindNext(SearchRec); end; FindClose(SearchRec); end; }

Hi,
I would like to suggest adding to the readme:

• Prerequisites for compiling (compiler version, add-ons).
• A "getting started".
• What it does.

TidCGIRunner component allows to execute CGI scripts using
Indy TidHTTPServer component.

--- v3
+++ v4
@@ -21,6 +21,8 @@
1418 unit uPSIWDCCMisc; (uPSIcFileTemplates);
1419 uPSIWDCCOleVariantEnum.pas
1420 unit uPSIWDCCWinInet.pas WDCC
+1421 uPSI_PythonVersions.pas
+1422 unit uPSI_PythonAction.pas

SIRegister_TFastStringStream(CL);
procedure LoadJPEGResource(image1: TImage; aJpgImage: string);
@@ -31,9 +33,9 @@
Procedure MaskFPUExceptions( ExceptionsMasked : boolean; MatchPythonPrecision: Boolean);
Function GetOleVariantEnum( Collection : OLEVariant) : IGetOleVariantEnum);
Function GetOleVariantArrEnum( Collection : OLEVariant) : IGetOleVariantEnum);
+Function GetRegisteredPythonVersions : TPythonVersions');

-Total of Function Calls: 33840
-SHA1: of 4.7.5.80 C913C075CD890B03049047AB65499A562681BDF5
-CRC32: B6F69E19 29.8 MB (31,328,584 bytes)
+Total of Function Calls: 33848
+SHA1: of 4.7.5.80 3E38A48072D4F828A4BE4A52320F092FE50AE9C3
+CRC32: B6F69E19 29.8 MB (31,344,456 bytes)

Microsoft Windows HTTP Services (WinHTTP) provides developers with an HTTP client application programming interface (API) to send requests through the HTTP protocol to other HTTP servers.

 // Instantiate a WinHttpRequest object.
httpReq:= CreateOleObject('WinHttp.WinHttpRequest.5.1');

// Open an HTTP connection.                
hr:= httpReq.Open('GET', aURL, false);            
if hr= 0 then httpReq.setRequestheader('apikey','6b337c92c792174a54acd715ab1aae64'); 
 
HttpReq.Send()  /// Send HTTP Request & get Responses.
writeln(httpReq.responseText)
writeln(httpReq.GetAllResponseHeaders());         
httpReq:= NULL;

Such construct for it:= it < 40-zeile do as for each to items.
for it:= (it < 40-zeile and it > 20) do

One rule-of-thumb: ask yourself "Does it make sense to call this method, even if no object has been constructed yet?" If so, it should definitely be static.

So in a class Car you might have a method:

double convertMpgToKpl(double mpg)

...which would be static, because one might want to know what 35mpg converts to, even if nobody has ever built a Car. But this method (which sets the efficiency of one particular Car):

void setMileage(double mpg)

...can't be static since it's inconceivable to call the method before any Car has been constructed.

Or a bitmap instead of a car with a utility function:

FPicRed:= TBitMap.Create;
FPicled.LoadFromResourcename(Hinstance, 'yellow1');
FPicRed.LoadFromFile(Exepath+'\examples\images\red1.bmp');

Static method calls are made directly on the class and are not callable on instances of the class. Static methods are often used to create utility functions.

the stringadapter in class TStrings is missing, but the Class IStringsAdapter existst:
RegisterMethod('Function GetEnumerator : TStringsEnumerator');
RegisterProperty('StringsAdapter', 'IStringsAdapter', iptrw);
the same goes with TStringsEnumerator

a lot of types are alias like
CL.AddTypeS('TSocket', 'Integer'); //delphisocks as longint
CL.AddTypeS('TInAddr', 'record S_addr : Cardinal; end');
for the meantime theres no controller for those alias types.

theres no for each operator but we can map it:

//for c := 'a' to 'z' do
for c:= ord('a') to ord('z') do

//for ch in adata do begin
for chi:= low(adata) to high(adata) do begin
ch:= adata[chi]

new units: 01 RotImg.pas + uModel : TModel lib dmath
02 SimpleImageLoader.pas
03 systemsdiagram.pas + fpc switch
04 qsfoundation.pas NO FPC Vector operator
05 prediction.pas SimulationEngine missing
06 HSLUtils.pas - color model
07 cInternetUtils.pas - header information
08 cWindows.pas - cstrings routines as flcSysUtils
09 flcSysUtils.pas //2 functions with cwindows possible+ freqObj +TBytes utils
10 GraphicsMathLibrary.PAS gml-profix
11 flcBits32.pas //$IFDEF DEBUG} {$IFDEF TEST} procedure Test;
12 flcFloats.pas No Floats instead: uPSI_cBlaiseParserLexer.pas
13 flcDecimal.pas + TestClass
14 flcCharSet.pas //test include wrapper + -
15 flcComplex.pas -Class
16 flcMaths.pas //{$IFDEF MATHS_TEST} procedure Test
17 flcMatrix.pas - less TVectors
18 flcRational.pas -Class
19 flcStatistics.pas -Class
20 flcStringBuilder.pas - less Unicode
21 flcVectors.pas No Vectors cause compatibility
22 flcTimers.pas {$DEFINE TIMERS_TEST}

lines: 11990 V4.7.5.20 some Fundamentals 5.00, more jcl fixes, GraphMathLibrary - StringBuilder

Notes for V47520
OK-D _Help Tutorials 1-80
OK-D _Caption Ocean 105 Rheingold

OK-D UIntlist add TIntlistSortCompare = function
// C:\maxbox\EKON23\examples\DFFLibV15\UIntList.pas
OK-D TPrimes CanonicalFactors add array of TPoint64 -
TPoint64', 'record x : int64; y : int64; end;
:\maXbox\EKON23\examples\DFFLibV15\mathslib.pas
check iftheinint, ifthendouble, ifthenbool
OK IfThenInt( AValue : Boolean; const ATrue : Int; AFalse : Int): Int;;
OK IfThenDouble( AValue : Boolean; const ATrue : double; AFalse : double): double;;
OK IfThenBool( AValue : Boolean; const ATrue : boolean; AFalse : boolean): boolean;;
OK D setRoundMode
OK D ALStrings add -clear (-delete )
- uPSI_ALStringList.pas
//1: C:\maxbox\mXGit39988\maxbox3\source\REST\ALStringList.pas
getHTMLPost(headers, )?
OK D TForm @on mouse wheel
OK-D + TFrame ? see tform uPSI_Forms.pas
check randomInt
OK-D InttoBytes() -toBytes(int)
OK-D + PageControl multiline
Ok-D TPageControl = class(TCustomTabControl);
ComCtrls
property MultiLine: Boolean;
property MultiSelect: Boolean;

OK D missing InvMod() getfrom flc libs - see above
OK D -1011_flcStatistics_mX4.pas
OPK-D swapInt() fix not only one parameter
OK-D add CopyFrom - see above
OK-D TJCLStringlist - C:\maxbox\EKON17\uPSI_JclStringLists.pas
D uPSI_JclStringLists.pas second version
D IJclStringList
D |
OK-D TJclStringList

OK-D JclPeImages.pas TClPeBorImage filename violation

OK-D add all new tests SelfTestCFundamentUtils and so on;

Ref: new functions: utility and usability trying to fanthom

Now there are 2 libs available json4delphi and uJson:

           procedure jsonobjectTest_compare;
            // from 1243 unit uPSI_uJSON2;
           var
             json: TJSONObject;   Jobj:  TJSONObject2;
             Text: String;
             i: Integer;
           begin
             json := TJSONObject.create4(jsonnames);
             for i:=0 to json.getJSONArray('Names').Length -1 do begin
               Text := json.getJSONArray('Names').getJSONObject(i).optString('FirstName');
               //...
               writeln(text)
             end;
             
             Jobj:= TJSONObject2.create(nil); 
             jobj.parse(jsonnames);
             for i:= 0 to Jobj.count+1 do          
                writeln(jobj['Names'].asArray[i].asObject['FirstName'].asstring);    
             jObj.Free; 
             json.Free;
          end;

add attachconsole and freeconsole to base library

function AttachConsole(dwProcessID: Integer): Boolean;external'[email protected] stdcall';
function FreeConsole(): Boolean;external'[email protected] stdcall';
document:
NativeWriteln()

TADOConnection encapsulates the ADO connection object. Use TADOConnection for connecting to ADO data stores. The connection provided by a single TADOConnection component can be shared by multiple ADO command and dataset components through their Connection properties.

function CreateAccessDatabase(FileName: string): string;
var 
  cat: OLEVariant;
begin
  Result := '';
  try
    cat:= CreateOleObject('ADOX.Catalog');
    cat.Create('Provider=Microsoft.Jet.OLEDB.4.0;Data Source=' + FileName + ';');
    cat:= NULL;
  except
    writeln(ExceptionToString(ExceptionType, ExceptionParam));
    writeln('ADOX.Catalog create failed ');
    //on e: Exception do Result := e.message;
  end;
end;

This would be helpful:
{USES Classes,StrUtils;

TYPE
TStringListHelper = CLASS HELPER FOR TStrings
FUNCTION ToSQL : STRING;
END;

FUNCTION TStringListHelper.ToSQL : STRING;
VAR
S : STRING;

FUNCTION QuotedStr(CONST S : STRING) : STRING;
BEGIN
Result:=''''+ReplaceStr(S,'''','''''')+''''
END;

BEGIN
Result:='';
FOR S IN Self DO BEGIN
IF Result='' THEN Result:='(' ELSE Result:=Result+',';
Result:=Result+QuotedStr(S)
END;
IF Result<>'' THEN Result:=Result+')'
END;

SL:=TStringList.Create;
SL.Add('One');
SL.Add('Two');
SL.Add('Number Three');
SL.Add('It''s number 4');
WRITELN('SELECT * FROM TABLE WHERE FIELD IN '+SL.ToSQL);

SELECT * FROM TABLE WHERE FIELD IN ('One','Two','Number Three','It''s number 4'}

Hi Max,

I think your maXbox project is impressive. However, an issue with the files at sourceforge.net (SourceForge), is people can't download the latest files easily. For instance, the "all_maxbox_tutorials.zip" and "13_General_Examples_1_1020.zip" at your GitHub doesn't exist on SourceForge. It appears your users have to download updated files individually. Also, at your GitHub, it appears the files aren't being updated there, but at SourceForge.

I think a possible solution would be to have at least .zip files for your major folders on SourceForge (tutorials, arduino, examples) that is updated once a month or whenever convenient for you. If possible, also do this for GitHub. I know the configuration of settings at GitHub can be problematic, but the release dates do help, as gives people the impression the project is active. And you are, from the activity on SourceForge, but this might not be understood by those coming across only GitHub and seeing only 2016.

Lastly, I know you are probably busy, but anything for Android and/or iOS would be good too. A lot of people are using such platforms as their primary device.

Thanks in advance for your consideration

From [email protected] on 2021-09-22 01:09

news of 47620 VII zapatsza

crt-alt t for help task liste
4 gewinnt update
ocean 220 in title
psi extensions with type names and so on
tee chart fixes canvas etc.
examples all files now by 402 add 3 to 405 (also trend.pas)
internalexception function
check getwebscript call
checkversion alias to versioncheck
timesync letsynctime function //see up
make xraise as keyword black font
https://github.com/P33a/SimTwo/blob/master/Editor.pas
in menu debug ? or as a function
functioncount: strings
list_functions - writeln(list_modules(exepath+'maxbox4.exe'));
procedure TFEditor.BuildRegFuncList(Sender: TPSScript);
var i, j, typ: integer;
SaveFunclist: TStringList;
S: string;
-- add funclist procedure TFEditor.BuildRegFuncList(Sender: TPSScript);
BuildRegFuncList(Sender);
SynCompletionProposal.ItemList.AddStrings(FuncList);
//SynCompletionProposal.InsertList.AddStrings(InsertList);
SynCompletionProposal.ItemList.EndUpdate;
//SynCompletionProposal.InsertList.EndUpdate;
//sender.Comp.OnBeforeCleanup := @FillTypes;
BuildRegTypeList(Sender);

function FloatAsInteger(X: single): integer;
begin
result := PInteger(@x)^;
end;

function IntegerAsFloat(X: integer): single;
begin
result := PSingle(@x)^;
end;

TProcess.Create(nil); --> Unknown identifier 'EXECUTABLE'
Process.Executable := 'Calc.exe';
Process.Execute;

https://github.com/P33a/SimTwo/blob/master/AStar.pas
\maxbox3\1025_Deranged_anagrams2_mx47620.txt(160:14): Unknown identifier 'AXISLIST'

procedure LoadGridFromfile(SG: TStringGrid; fname: string);
procedure SaveGridTofile(SG: TStringGrid; fname: string);
procedure WriteVectorToGrid(SG: TStringGrid; vname: string; wval: TAffineVector);
procedure WriteStringToGrid(SG: TStringGrid; vname: string; icol: longword; wval: string);
procedure WriteFloatToGrid(SG: TStringGrid; vname: string; icol: longword; wval: double);

https://github.com/P33a/SimTwo/blob/master/Utils.pas

object SynCompletionProposal: TSynCompletion
ItemList.Strings = (
'Y1'
'Y2'
'R1'
'R2'
'Sek'
)
Position = 0
LinesInWindow = 6
OnSearchPosition = SynCompletionProposalSearchPosition
SelectedColor = clHighlight
CaseSensitive = False
Width = 400
ShowSizeDrag = True
AutoUseSingleIdent = True
ShortCut = 16416
EndOfTokenChr = '()[]. '
OnCodeCompletion = SynCompletionProposalCodeCompletion
ExecCommandID = ecSynCompletionExecute
Editor = SynEditST
ToggleReplaceWhole = False
Left = 192
Top = 64
end

procedure SetSynchroTime;
var mySTime: TIdSNTP;
begin
mySTime:= TIdSNTP.create(self);
try
//mySTime.host:='0.debian.pool.ntp.org'
mySTime.host:='pool.ntp.org'

writeln('the internettime '+
datetimetoStr(mystime.datetime));
if mySTime.Synctime then
  writeln('operating system sync now!');

finally
mySTime.free;
writeln('System time is now sync with the internet time '+TimeToStr(time))
end;
end;

to have the wait async in execute command

EOSerror SystemError code -2003283966

I am getting an EOSError code by starting an EXE with Wine: EOSerror SystemError code -2003283966 How can I find the reason why or the meaning of the code?

https://softwareschulecode.files.wordpress.com/2023/11/mintlinux2023-11-24.png?w=1800&h=

I tried the dbg debugger and fixed access violations in RAD Studio 11.3 Alexandria

LockBox3 is a Delphi library for cryptography.
It provides support for AES, DES, 3DES, Blowfish, Twofish, SHA, MD5, a variety of chaining modes, RSA digital signature and verification, now we updated this in maXbox5:

//intertnal test
procedure TSimpleTCPServerBroadcast(Buffer: PChar; BufLength: Integer);
var
I: Integer;
FConnections: TObjectlist;
begin
I := FConnections.Count;
if I <> 0 then
for I := 0 to I - 1 do
with TSimpleTCPClient(FConnections[I]) do
//SendBufferTo(FSocket, Buffer, BufLength);
end;

we have to change each var Dest : array of byte to a var Dest : TBytes type
for example RegisterMethod('Procedure ReadAsBits( var Dest : array of byte; Threshold : TNeuralFloat)');
to RegisterMethod('Procedure ReadAsBits( var Dest : TBytes; Threshold : TNeuralFloat)');
envlist:= Tstringlist.create;
InStr:= filetostring(Exepath+'\Examples\vararrayofFilename_savereport.txt');
StrtoList(InStr, envlist, CR)
writeln('envlist count: '+itoa(envlist.count));
cnt:= 0;
regEx:= TRegExpr.create; //HISUtils.RegExpr;
regEx.Expression:='var [\w+:\w:\w :,]+ array of byte';
// Execute search
for it:= 0 to envlist.count-1 do
if regEx.Exec(envlist[it]) then begin
writeln(itoa(cnt)+':'+envlist[it]);
inc(cnt)
end;
regex.Free;
envlist.Free;

0:
91: Procedure TIdUDPClientSendBufferAB(Self: TIdUDPClient; var AData: array of byte; const AByteCount: integer);
1:
//Procedure TIdUDPClientSendBufferAB(Self: TIdUDPBase; var AData: array of byte; const AByteCount: integer);
2:
Procedure TIdUDPClientSendBufferAB(Self: TIdUDPClient; var AData: array of byte; const AByteCount: integer);
3:
92: //Procedure TIdUDPClientSendBufferAB(Self: TIdUDPBase; var AData: array of byte; const AByteCount: integer);
4:
157: procedure BurnMemoryByteArray( var buff: array of byte; BuffLen: integer);
5:
1021: procedure ReadByteArray2(Self: TStream; var Buffer: array of byte; Count: Longint);
6:
1924: var mba: array of byte; //TBytearray; //array of byte;
7:
1681: var mba: array of byte; //TBytearray; //array of byte;
8:
46: procedure Include(var S: array of byte);
9:
49: function Test(var S: array of byte): boolean;
10:
56: function ABCmp(var X, Y: array of byte): boolean;
11:
59: function ABGetNext1(var AB: array of byte; ST: word): word;
12:
62: function ABCountDif(var X, Y: array of byte): longint;
13:
65: function ABCountDifZero(var X: array of byte): longint;
14:
68: procedure ABAnd(var A, B: array of byte);
15:
71: function ABGetEqual(var Equal, X, Y: array of byte): longint;
16:
74: procedure ABShiftLogicalLeft(var X: array of byte);
17:
77: procedure ABShiftLogicalRight(var X: array of byte);
18:
80: function ABGetDif(var Dif, X, Y: array of byte): longint;
19:
83: function ABToString(var AB: array of byte): string;
20:
86: function ABToStringR(var AB: array of byte): string;
21:
89: procedure ABClear(var AB: array of byte);
22:
92: procedure ABFull(var AB: array of byte);
23:
95: procedure ABBitOnPos(var AB: array of byte; POS: longint);
24:
98: procedure ABBitOnPosAtPos(var AB: array of byte; X, Start, Len: longint);
25:
104: procedure ABCopy(var A, B: array of byte);
26:
107: procedure ABTriPascal(var A, B: array of byte);
27:
115: procedure ABSet(var A: array of byte; B: array of byte);
28:
117: procedure ABSet2(var A: array of byte; B: array of byte);
29:
149: function ABCmp(var X, Y: array of byte): boolean;
30:
170: procedure ABSet(var A: array of byte; B: array of byte);
31:
179: procedure ABSet2(var A: array of byte; B: array of byte);
32:
187: procedure ABTriPascal(var A, B: array of byte);
33:
195: procedure ABCopy(var A, B: array of byte);
34:
207: function ABGetNext1(var AB: array of byte; ST: word): word;
35:
224: procedure ABClear(var AB: array of byte);
36:
232: procedure ABFull(var AB: array of byte);
37:
240: procedure ABAnd(var A, B: array of byte);
38:
248: function ABCountDif(var X, Y: array of byte): longint;
39:
260: function ABCountDifZero(var X: array of byte): longint;
40:
272: function ABGetEqual(var Equal, X, Y: array of byte): longint;
41:
289: procedure ABShiftLogicalLeft(var X: array of byte);
42:
299: procedure ABShiftLogicalRight(var X: array of byte);
43:
310: function ABGetDif(var Dif, X, Y: array of byte): longint;
44:
327: procedure ABBitOnPos(var AB: array of byte; POS: longint);
45:
333: procedure ABBitOnPosAtPos(var AB: array of byte; X, Start, Len: longint);
46:
366: function ABToString(var AB: array of byte): string;
47:
382: function ABToStringR(var AB: array of byte): string;
48:
413: procedure TABHash.Include(var S: array of byte);
49:
418: function TABHash.Test(var S: array of byte): boolean;
50:
335: procedure Create(Tests, FullEqual: boolean; var ERRORS: array of byte);
51:
628: function getNonZeroElementsPos(InputLen: integer; var InputData: array of byte; var OutputData: TPositionArray):integer;
52:
698: var ERRORS: array of byte);
53:
39: procedure BAClear(var VARS: array of byte);
54:
41: procedure BAMake1(var VARS: array of byte);
55:
43: function BARead(var A: array of byte; P: longint): byte;
56:
45: procedure BAFlip(var A: array of byte; P: longint);
57:
47: procedure BAWrite(var A: array of byte; P: longint; Data: byte);
58:
49: function BATest(var A: array of byte; P: longint): boolean;
59:
51: procedure BASum(var x, y: array of byte);
60:
53: procedure BASub(var x, y: array of byte);
61:
55: procedure BAIncPos(var x: array of byte; POS: longint);
62:
57: procedure BADecPos(var x: array of byte; POS: longint);
63:
59: procedure BAInc(var x: array of byte);
64:
61: procedure BADec(var x: array of byte);
65:
65: function BAToFloat(var VARS: array of byte): extended;
66:
67: procedure PFloatToBA(var VARS: array of byte; Valor: extended);
67:
69: procedure BANot(var VARS: array of byte);
68:
71: procedure BAAnd(var r, x, y: array of byte);
69:
73: procedure BAOr(var r, x, y: array of byte);
70:
75: procedure BAXOr(var r, x, y: array of byte);
71:
77: function BAGrater(var x, y: array of byte): boolean;
72:
79: function BALower(var x, y: array of byte): boolean;
73:
81: function BAEqual(var x, y: array of byte): boolean;
74:
83: procedure BAPMul(var r, x, y: array of byte);
75:
130: procedure BARAnd(var R, A, B: array of byte);
76:
procedure BAROr(var R, AUX, A, B: array of byte);
77:
procedure BARAnd(var R, A, B: array of byte);
78:
131: procedure BAROr(var R, AUX, A, B: array of byte);
79:
procedure BARNot(var R, A: array of byte);
80:
procedure BAROr(var R, AUX, A, B: array of byte);
81:
132: procedure BARNot(var R, A: array of byte);
82:
151: function BARead(var A: array of byte; P: longint): byte;
83:
163: procedure BAFlip(var A: array of byte; P: longint);
84:
174: function BATest(var A: array of byte; P: longint): boolean;
85:
204: procedure BAWrite(var A: array of byte; P: longint; Data: byte);
86:
216: procedure BAXOr(var r, x, y: array of byte);
87:
225: procedure BAOr(var r, x, y: array of byte);
88:
234: procedure BAAnd(var r, x, y: array of byte);
89:
243: procedure BANot(var VARS: array of byte);
90:
252: procedure BAClear(var VARS: array of byte);
91:
261: procedure BAMake1(var VARS: array of byte);
92:
279: procedure BASumWordPos(var X: array of byte; POS: longint; DADO: word);
93:
293: procedure BASum(var x, y: array of byte);
94:
306: procedure BASubBytePos(var X: array of byte; POS: longint; DADO: byte);
95:
325: procedure BASub(var x, y: array of byte);
96:
353: procedure BAIncPos(var x: array of byte; POS: longint);
97:
371: procedure BAInc(var x: array of byte);
98:
378: procedure BADecPos(var x: array of byte; POS: longint);
99:
396: procedure BADec(var x: array of byte);
100:
416: function BAGrater(var x, y: array of byte): boolean;
101:
432: function BALower(var x, y: array of byte): boolean;
102:
438: function BAEqual(var x, y: array of byte): boolean;
103:
452: procedure BANumFirstLast(var x: array of byte; var Num, First, Last: longint);
104:
544: procedure BAPMul(var r, x, y: array of byte);
105:
571: procedure BARAnd(var R, A, B: array of byte);
106:
577: procedure BAROr(var R, AUX, A, B: array of byte);
107:
589: procedure BARNot(var R, A: array of byte);
108:
731: function BAToFloat(var VARS: array of byte): extended;
109:
749: procedure PFloatToBA(var VARS: array of byte; Valor: extended);
110:
152: {input} var PActions: array of byte;
111:
{input} var pCurrentStates, pFoundStates: array of byte);
112:
{input} var PActions: array of byte;
113:
153: {input} var pCurrentStates, pFoundStates: array of byte);
114:
{output} var PNextStates: array of byte;
115:
167: {output} var PNextStates: array of byte;
116:
var PNextStates: array of byte; {states to be predicted}
117:
177: var PNextStates: array of byte; {states to be predicted}
118:
191: (var pFoundStates, pPredictedStates: array of byte;
119:
324: procedure Predict(var pActions, pCurrentState: array of byte;
120:
var pPredictedState: array of byte);
121:
procedure Predict(var pActions, pCurrentState: array of byte;
122:
325: var pPredictedState: array of byte);
123:
701: procedure TEasyLearnAndPredictClass.Predict(var pActions, pCurrentState: array of byte;
124:
var pPredictedState: array of byte);
125:
procedure TEasyLearnAndPredictClass.Predict(var pActions, pCurrentState: array of byte;
126:
702: var pPredictedState: array of byte);
127:
939: procedure TStatePredictionClass.UpdatePredictionStats(var PActions: array of byte;
128:
var pCurrentStates, pFoundStates: array of byte);
129:
procedure TStatePredictionClass.UpdatePredictionStats(var PActions: array of byte;
130:
940: var pCurrentStates, pFoundStates: array of byte);
131:
{output}var PNextStates: array of byte; var pRelationProbability: array of single;
132:
1225: {output}var PNextStates: array of byte; var pRelationProbability: array of single;
133:
1293: {input} PActions, PCurrentStates: array of byte; var PNextStates: array of byte;
134:
1396: var pFoundStates, pPredictedStates: array of byte;
135:
39: TProcPred = procedure(var ST: array of byte; Acao: byte) of object;
136:
133: procedure TCacheMem.Include(var ST, DTA: array of byte);
137:
166: function TCacheMem.ValidEntry(var ST: array of byte): boolean;
138:
176: function TCacheMem.Read(var ST, DTA: array of byte): longint;
139:
1626: procedure Compute(var pInput: array of byte);
140:
procedure Backpropagate(var pOutput: array of byte);
141:
procedure Compute(var pInput: array of byte);
142:
1627: procedure Backpropagate(var pOutput: array of byte);
143:
procedure GetOutput(var pOutput: array of byte);
144:
procedure Backpropagate(var pOutput: array of byte);
145:
1628: procedure GetOutput(var pOutput: array of byte);
146:
1655: procedure Predict(var pActions, pCurrentState: array of byte;
147:
var pPredictedState: array of byte);
148:
procedure Predict(var pActions, pCurrentState: array of byte;
149:
1656: var pPredictedState: array of byte);
150:
2460: procedure TNNetForByteProcessing.Compute(var pInput: array of byte);
151:
2466: procedure TNNetForByteProcessing.Backpropagate(var pOutput: array of byte);
152:
2472: procedure TNNetForByteProcessing.GetOutput(var pOutput: array of byte);
153:
13051: pCurrentState: array of byte; var pPredictedState: array of byte);
154:
43: TProcPred = function(var ST: array of byte; Action: byte): boolean of object;
155:
175: function ChooseBestPlanBasedOnNextStep(var CurrentState: array of byte): longint;
156:
178: function EvalPlanBasedOnNextStep(var CurrentState: array of byte;
157:
var FutureS: array of byte): boolean;
158:
207: var FutureS: array of byte): boolean;
159:
361: var FutureS: array of byte): boolean;
160:
409: var CurrentState: array of byte): longint;
161:
441: var CurrentState: array of byte; PlanIndex: longint): extended; // quanto maior, pior
162:
610: var TargetState: array of byte; currentState: array of byte;
163:
653: function ChooseRandomAction(var State: array of byte): integer;
164:
679: function ChooseActionIn1Step(var State: array of byte): integer;
165:
195: procedure Copy(var Original: array of byte); overload;
166:
267: procedure CopyAsBits(var Original: array of byte; pFlase: T = -0.5; pTrue: T = +0.5); overload;
167:
procedure ReadAsBits(var Dest: array of byte; Threshold: T = 0.0);
168:
procedure CopyAsBits(var Original: array of byte; pFlase: T = -0.5; pTrue: T = +0.5); overload;
169:
268: procedure ReadAsBits(var Dest: array of byte; Threshold: T = 0.0);
170:
3772: procedure TVolume.ReadAsBits(var Dest: array of byte; Threshold: T);
171:
3803: procedure TVolume.Copy(var Original: array of byte);
172:
3855: procedure TVolume.CopyAsBits(var Original: array of byte; pFlase: T = -0.5; pTrue: T = +0.5);
173:
73: RegisterMethod('Procedure Create( Tests, FullEqual : boolean; var ERRORS : array of byte)');
174:
83: RegisterMethod('Procedure Load( PCS : TCreateOperationSettings; var PActions, PCurrentStates, PNextStates : array of byte)');
175:
75: RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
176:
RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
177:
125: RegisterMethod('Procedure UpdatePredictionStats( var PActions : array of byte; var pCurrentStates, pFoundStates : array of byte)');
178:
RegisterMethod('Procedure UpdatePredictionStats( var PActions : array of byte; var pCurrentStates, pFoundStates : array of byte)');
179:
RegisterMethod('Procedure Prediction( PActions, PCurrentStates : array of byte; var PNextStates : array of byte; var pRelationProbability : array of single; var pVictoryIndex : array of longint)');
180:
127: RegisterMethod('Procedure Prediction( PActions, PCurrentStates : array of byte; var PNextStates : array of byte; var pRelationProbability : array of single; var pVictoryIndex : array of longint)');
181:
RegisterMethod('Procedure PredictionProbability( PActions, PCurrentStates : array of byte; var PNextStates : array of byte; var pRelationProbability : array of single; var pVictoryIndex : array of longint)');
182:
RegisterMethod('Procedure Prediction( PActions, PCurrentStates : array of byte; var PNextStates : array of byte; var pRelationProbability : array of single; var pVictoryIndex : array of longint)');
183:
128: RegisterMethod('Procedure PredictionProbability( PActions, PCurrentStates : array of byte; var PNextStates : array of byte; var pRelationProbability : array of single; var pVictoryIndex : array of longint)');
184:
131: RegisterMethod('Procedure UpdateNeuronVictories( var pFoundStates, pPredictedStates : array of byte; var pVictoryIndex : array of longint)');
185:
277: RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
186:
RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
187:
291: RegisterMethod('Procedure Compute( var pInput : array of byte)');
188:
RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
189:
RegisterMethod('Procedure Compute( var pInput : array of byte)');
190:
292: RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
191:
RegisterMethod('Procedure GetOutput( var pOutput : array of byte)');
192:
RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
193:
293: RegisterMethod('Procedure GetOutput( var pOutput : array of byte)');
194:
280: RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
195:
RegisterMethod('Procedure Predict( var pActions, pCurrentState : array of byte; var pPredictedState : array of byte)');
196:
294: RegisterMethod('Procedure Compute( var pInput : array of byte)');
197:
RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
198:
RegisterMethod('Procedure Compute( var pInput : array of byte)');
199:
295: RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
200:
RegisterMethod('Procedure GetOutput( var pOutput : array of byte)');
201:
RegisterMethod('Procedure Backpropagate( var pOutput : array of byte)');
202:
296: RegisterMethod('Procedure GetOutput( var pOutput : array of byte)');
203:
362: RegisterMethod('Procedure Copy42( var Original : array of byte);');
204:
424: RegisterMethod('Procedure CopyAsBits56( var Original : array of byte; pFlase : TNeuralFloat; pTrue : TNeuralFloat);');
205:
RegisterMethod('Procedure ReadAsBits( var Dest : array of byte; Threshold : TNeuralFloat)');
206:
RegisterMethod('Procedure CopyAsBits56( var Original : array of byte; pFlase : TNeuralFloat; pTrue : TNeuralFloat);');
207:
425: RegisterMethod('Procedure ReadAsBits( var Dest : array of byte; Threshold : TNeuralFloat)');
208:
820: Procedure TVolumeCopyAsBits56_P(Self: TVolume; var Original : array of byte; pFlase : T; pTrue : T);
209:
876: Procedure TVolumeCopy42_P(Self: TVolume; var Original : array of byte);
210:
154: procedure TForm2buffer_R(Self: THexForm2; var aT: array of byte);
211:
289: procedure TOscfrmMainframeSaveBuf_R(Self: TOscfrmMain; var T: array of byte);
��� mX4 executed: 28/10/2022 11:54:25 Runtime: 0:0:3.725 Memload: 38% use

Under certain condition the GetParentProcessName cant resolve the name.
Alternate solution is:
writeln('ParentProcessName: '+GetProcessName(GetParentProcessID(getprocessID)));
ex: ParentProcessName: explorer.exe

name conflict between Fillrect() and windows.Fillrect:

function wFillRect(HDC: hDC; RECT :TRect; hbr: HBRUSH):Longint;
external '[email protected] stdcall';

procedure FillRect(const Rect: TRect);

the short string like string[8] isnt enable, we can put setlength(sr, 8) but not in every case