A popup for user to enter a PIN for return to your app. The number of digits is specified in the call, and checked by the function in the DLL.

Longer description
at https://www.yarker-dsyc.info/Programs/Mi...N_DLL.html

Source, compiled, icons and Help file in ZIP
at https://www.yarker-dsyc.info/Programs/Mi...er_PIN.zip

DLL source: 

There is an improved version of the experimental code converter for JKB (JKB_Convert.exe), please download the update package (update.zip) and unpack over your existing installation.

From: What´s different

Quote:The syntax is (with some minor restrictions) compatible to PowerBASIC. These restrictions are:

Quote:- Variables must not be declared with "DIM" anymore! ...  Dim is exclusively used for dimensioning arrays.

Quote:THREADED is not supported ATM.

Quote:- You may still declare multiple variables of the same data type in one single line. "LOCAL a, b, c AS LONG" is accepted. "LOCAL a$, b AS DWORD, c AS LONG" throws an error, because a$, b and c represent different data types.

What´s different

The syntax is (with some minor restrictions) compatible to PowerBASIC. These restrictions are:


- Variables must not be declared with "DIM" anymore! 
    LOCAL, GLOBAL, STATIC, INSTANCE or COMMON is required (= #DIM ALL in PB)!. Dim is exclusively used for dimensioning arrays. THREADED is not supported ATM.

- You may still declare multiple variables of the same data type in one single line. "LOCAL a, b, c AS LONG" is accepted. "LOCAL a$, b AS DWORD, c AS LONG" throws an error, because a$, b and c represent different data types.


- You may assign an intial value, e.g. "LOCAL x AS LONG = -1"


- With variables you cannot have type specifiers anymore except for "$" (dynamic ANSI string) or "$$" (dynamic wide string)


- There are new data types: QWORD (unsigned 64 bit integer), SBYTE (signed 8 bit integer), XWORD (DWORD in 32 bit and QWORD in 64), XLONG (LONG in 32 bit and QUAD in 64)


- Assembler code:   
    ! cmp byte [esi], 0  -> byte ptr (the key word "ptr" is mandatory, assembler error otherwise)
    ! ret must become,  ! retn, (ret ends a stackframe)

    !.if (eax == 0)
    ! ... "
    !.endif                     (MASM Hi-level syntax is possible)

    XAX = EAX in 32 bit and RAX in 64 bit


- Reserved words: there is a list of words, which are forbidden as variable or procedure names, eg. pos, count, enter, comment et. al


- String expressions: no logical string expressions, but automatic build$
    e.g.        if a$ < b$ and c$ < d$ then
                 ...
           
    must be    if a$ < b$ then
                      if c$ < d$ then
                      ...
             
    but a$ + b$ + c$, is always compiled as BUILD$(a$, b$, c$), BUILD$ is valid syntax, but it is not necessary anymore             



- Conditional compiling: code inside conditional compiling blocks (even if condition is not met) must be compilable
    you cannot code anymore:
    #IF 0
    <your comments here> -> you must pepend an apostrophe to make it a comment
    #ENDIF


#TRACE, #PROFILE and #CALLSTACK make use of the OutputDebugString Viewer, this is still experimental


- Syntax:
PARSE        (no special treatment for default separator "," and quotes)

ISTRUE      (parenthesis are required, it´s a function not an operator)
ISFALSE      (parenthesis are required, it´s a function not an operator)

FORMAT$      (only one formatting mask allowed)
JOIN$        (without BINARY option and special quote handling)
PARSE$      (without BINARY option and special quote handling)

PRINT        (requires sparator (, ; spc() tab()) between expressions)



What´s new:

#SEH - in case of a GPF, the offending line is shown in the IDE

TIMING [END]  -  return elapsed time in µs, syntax: TIMING [END] qword/quadvar
ISVALID(<ptr>) -  returns -1, if pointer points to valid memory, 0 otherwise

SIN            -  y = SIN([deg/rad], x) default is deg, applies to all trigonometric functions

ZIP:                                                                                  'zip into ziparchive
' ZIP string s$, filename (in ziparchive), ziparchive [, password] [, call callback]
' ZIP filename(s), ziparchive [, password] [, call callback]
' ZIP memory ptr, len, filename (in ziparchive), ziparchive [, password] [, call callback]
ZIP$:                                                                                  'zip into string
' z$ = ZIP$(string s$, filename (in archive) [, password] [size = x] [, call callback])
' z$ = ZIP$(filename(s) [, password] [size = x] [, call callback])
' z$ = ZIP$(memory ptr, len, filename (in archive) [, password] [size = x] [, call callback])
UNZIP:                                                                                'unzip ziparchive
' UNZIP filename(s) (in string), string s$ [, password] [to folder] [, call callback]
' UNZIP filename(s) (in ziparchive), ziparchive [, password] [to folder] [, call callback]
' UNZIP filename(s) (in memory), memory ptr, len [, password] [to folder] [, call callback]
UNZIP$                                                                                'unzip into string
' s$($) = UNZIP$(filename (in string), string z$|ziparchive] [, password])
' s$($) = UNZIP$(filename (in ziparchive), ziparchive] [, password])
' s$($) = UNZIP$(filename (in memory), memory ptr, len|ziparchive] [, password])
ZIPINFO:                                                                              'return # of files in zip + array of zipinfo
' x = ZIPINFO(array, string z$|ziparchive [, password])           
' x = ZIPINFO(array, memory ptr, len|ziparchive [, password])
ZIPCALC:                                                                              'return # of bytes for zipped data
' x = ZIPCALC(string s$|filename(s))
' x = ZIPCALC memory ptr, len|filename(s)
UNZIPCALC:                                                                            'return # of bytes for unzipped data
' x = UNZIPCALC( filename(s), string z$|ziparchive [, password])
' x = UNZIPCALC( filename(s), memory pointer, len|ziparchive [, password])



Run 32 bit code:
As a first step try to run 32 bit code. Please adapt your code according to the above restrictions. If there are many places to adapt, the Replace Dialog (Ctrl + R) is your friend. The first line must be "#COMPILER JKB [32]", "F9" compiles and executes. The IDE will complain about errors.


Run 64 bit code:
64 bit code definitely needs adaptions: all pointers and handles (which are pointers in fact) must become 64 bit data types (DWORD -> XWORD and LONG -> XLONG). The first line must be "#COMPILER JKB 64".



There is a (still experimental) code converter (Credits to Norbert Spoerl for supplying ideas and major parts of code) for adapting existing code to the new requirements. You may use the menu (last item in "File" menu: "Prepare Source for JKB" ) or the top toolbar (a new button, next to the "command prompt" button on the right side). This feature is applied to current file in the IDE. A copy (<name>.original) is made before. Yet you may still have to adapt some things manually.



Please don´t post in this thread, feel free to ask questions in "Discussions" thread

Please use this thread for asking all kinds of questions!

My IDE makes extensive use of hot keys, type CTRL + H for a list of key combinations

In the IDE´s folder there is a file (list of available features.txt) listing all currently supported statements. Most statements are compatible to PB syntax

I´m not absolutely sure, if my implementation of macros works correct under all circumstances, the same applies to math functions and all kinds of expressions, especially with new data types like QWORD and SBYTE. I am sure there will be bugs, issues and problems i didn´t find yet!


Compiling the same code for 32 and 64 bit requires a special data type, which represents 32 bit in 32 bit and 64 bit in 64 bit: XWORD (unsigned) and XLONG (signed). Therefore all include files (i used José´s) must be prepared for this. Currently not all but about 2/3 have been translated and can be found in \Basic\Include_new.

64 bit code is much more picky about alignment, 64 bit code refuses to work, if structure alignment is not correct. This produces hard to find errors, and i´m not sure if all structures have been translated properly for 64 bit.

Inline assembler works as usual, i build ebp/rbp based stackframes and you can use PUSH and POP as usual, but in 64 bit code the stack pointer (rsp) must be 16 byte aligned before calls, otherwise you will experience all kinds of crashes. You may replace e/r by x for registers in order to write code, which compiles in 32 and 64 bit. Internally xax becomes eax in 32 bit and rax in 64 bit, this applies to all standard 32 bit registers (eax, ebx, ecx, edx, esi, edi, ebp, esp), obviously you cannot use r8 - r15 in 32 bit code.


In 32 bit code the constant %x32_code and in 64 bit code %x64_code are predefined, so you can build conditional compiling blocks like:

#ifdef %x64_code

... 64 bit code goes here (must be compilable)

#else

... 32 bit code goes here (must be compilable)

#endif


While PowerBASIC allows for (variable)names like "cx" or "si", which are valid register names, my implementation currently doesn´t. So you must use different names. ATM there are some more words (in addition to language keywords), which are forbidden. You will get an error message in such cases.


My object and COM implementation may need improvement, the focus was on being able to use COM services, which seems to work.Writing COM servers is possible but with some restrictions. Inheritance and multiple interfaces are not handled absolutely correct, i fear. There is nothing like #TLIB and "ME." (an object calling itself) doesn´t work yet.
I want better error reporting, in many places you will get a simple "syntax error". It is possible to have more specific messages and i plan to do that, but it is not on top of my priority list.


There are many ways of improving and optimizing my code, but for the moment the most important thing is making the "core" things stable.

Then will be the time to add more features, currently it supports, what i would call the "core" features of a BASIC language. Feel free to ask for "core" features i might have missed. But i won´t add more or less "special" things, before the core can be considered actually stable. At the current point of development i must thoroughly test, what i have in order to avoid changes in the core functionality later on. Code generation must cover different scenarios, the currently supported feature set covers all these scenarios in (hopefully) all it´s aspects. So it should be suited for testing and finding bugs i missed. Further development will then be a variation or implementation of the existing core of code.

E.g when passing arguments, such an argument can be: a literal, a constant, a variable, an array (as a whole, or as one single element), a structure (as a whole, or as one member of it), nested structures, a pointer, a resolved pointer, procedure returns, intrinsic functions (results from key words) and combinations and expressions of all of this. An argument can be passed "byref", "byval" and "bycopy". So there is a variety of possibilities, which must be taken care of.

The most simple code for own tests would be:

Code Select
Code:
#COMPILER JKB 32
#COMPILE EXE

FUNCTION MAIN

...

END FUNCTION


Now you can fill in the body of MAIN (for convenience PBMAIN is also possible) with declarations of variables and code using the syntax known form PB. You can add subs and functions as usual. You may add "#INCLUDE "Win32Api.inc" for access to predefined constants and the Windows API.

About 2/3 of José´s include files are already adapted to work in 64 bit Windows. There might still be issues though


"F9" will start the code generation and if this was successful, start the compiled executable. AV will often not be you friend here! You may add resources by "#RESOURCE "<resourcefilename>.res", but even adding a version control block and a manifest does not ensure smooth testing.

When there are syntax errors inside the BASIC code, these errors are shown in the IDE. In case of no error so far, the generated assembler code is passed to an assembler and linker, errors are shown in the IDE. Finally the created executable is run.

For debuging you can inspect final or intermediate results with "MSGBOX", use "STR$" or "HEX$" for numeric results, or you can make use of "ODS" or "ODX", which show debug output in a special viewer, which doesn´t block code flow like a message box.


Basically everything listed in features is allowed as syntax element. Expressions and block constructs have a maximum nesting level of 64.

The generated assembler code still has potential for optimizing, but (as already mentioned) first i want to get it working and then i want to make it smaller, faster, whatever...

The IDE will create a bunch of extra files mostly for debugging purposes, these will not be visible anymore in a final state.



Please don´t post in this thread, use the "Discussions" thread. More explanations will follow as needed.

Hi all,

Below are a link and instructions for a setup - have fun


whole package:  https://www.dropbox.com/scl/fi/tc6syg81r...pbwwe&dl=1
update package:  https://www.dropbox.com/scl/fi/cl6294npc...bwzsq&dl=1



The .zip file is about 40 MB and contains an updated version of my IDE and the complete tool chain necessary for the new "compiler". In fact working together with my IDE this is a complete compiler toolchain creating Windows executables (internally it is a code converter creating assembler code, which in turn is assembled to standard COFF .obj files and then linked to an execuatable). There is a linker (PoLink64.exe) included. A better choice would be Mircosoft´s linker (link.exe + a bunch of dlls), but this linker is not redistributable. It is included in a (free) community version of Visual C. You may download and install VC to have it installed on your machine. For using it you must specify this executable in Path Options Dialog in my IDE. A typical location for VC22 would be: C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\bin\Hostx86\x86\link.exe.

There might be problems with AV scanners, even Windows Defender sees some versions of JK-Basic.exe (the "compiler") as a potential threat, while virustotal sees no problem. In Windows 11 .exe files might not run, because there is no digital signature. The IDE itself (jk-ide.exe) and the "compiler" (jk-basic.exe) are not digitally signed, and newly created executables will have no digital signature, except you can digitally sign them yourself (the IDE can do that, if you have a certificate).

As usual you can expand the package to a directory of your choice, it is path independent. I recommend a new location, if you already use my IDE. This version is still experimental, so in order not to destroy your work with an existing install, don´t just unpack this over it. Please don´t select a path way down in your folder tree, because there still is a limit in length for paths, which could come into play, if your install path is too long.


When expanding Windows defender (or other AV) might block or quarantine some of the files, so be sure you got them all. In Windows 10 and below it is sufficient to add the "root" directory of this package to the AV´s exception list. I recommend doing this, because to my experience every now and then AV will "butt in" and produce all kinds of strange errors. Sometimes it can be really hard to get such false positives out of quaratine and get it to work again. The package doesn´t contain any dangerous or malicious things. Fell free to re-check with virustotal.

Currently the tool chain only works with my IDE (jk-ide.exe), so you must be or make yourself familiar with it. There is a quite comprehensive help file (menu -> help\JK-IDE Help)


For a start i would like you to do the following things:

- download (full package, the "update package" is for updates, which requires only a subset of files to be replaced)

- unzip

- run jk-ide.exe (you maybe will be asked to specify a path for the PB compiler and for an include file set, please fill in the necessary paths and press "Apply". This happens only, if the IDE cannot find these paths itself)

- the IDE will do some internal setup work, don´t worry, this is expected. It will tell you, when it is finished.

- open "File" menu, select "New As" and "JKB", name and save this source file wherever you want, press "F9". Congratulations, you should have compiled your first 64 bit executable with JKB



Please tell me, if this doesn´t work as described in "Discussions" thread. Don´t post in this thread!

Welcome to the new sub-forum for Juergen Kuehlwein's JKB. Juergen is going public with his new JKB (32/64 bit Compiler). Please follow the usual PUMP rules for posting in this area.

Cheers,
Albert (PUMP admin)

Chinese Hackers Remote Executed Code Via Notepad++ for 6 Months
_______________________________________________________

Please do not post any Youtube links (and others) without comment.

Thank you
Albert (PUMP admin)