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)

If possible, it would be nice to have "Board Statistics" box in the bottom of the forum like in official MyBB forum

Ciao,

I've attached a project I was working some time ago where I experimented AI (OpenAI ChatGPT and Google Gemini together) to code with some help ... well ... a lot of help.

It's a classic visual HEX viewer control able to show some memory buffer.
Clicking on the left hidden panel there are some options to change viewer

Attached 100% 10.4 PowerBasic source code and executable.
Do whatever with the sources.

Hope it can help someone.

Ciao
Eros

Attached Files

Thumbnail(s)
       

  HexControl_v0.4.1.bas (Size: 102 KB / Downloads: 21)
  HexControl_v0.4.1.EXE.zip (Size: 28.48 KB / Downloads: 8)

Found three code samples in the internet to make text unreadable.
First one can read text and encrypt it and decrypt .
The second and third seems to encrypt it but decrypt does not work.

First sample code:

I just recently ordered a new 386SX mini laptop system. Running DOS 6.22 and Windows 3.11. Lovely little beast. 40Mhz, 8MB RAM, and an IPS screen. It is capable of running Windows 95, but I do not want to at this time.

I am going to be working on some DOS & 16 bit Windows software.

PB DOS is still getting use from me.

I posted this on the new community run PB Users Forum: https://pbusers.org/forum/viewtopic.php?t=239
Sharing here as well as I think it is useful for those that might not have joined there yet.

============================


It always bothered me that PowerBASIC never implemented a #RESOURCE AVI metastatement. If you want to include an AVI for the animation control via #RESOURCE metastatements it's impossible as you cannot animate directly from RCDATA (or other resource sections available via the #RESOURCE metastatement). It can only be done from an AVI resource section (or from a supplied file path). Yes, you can compile the AVI into an AVI resource section using an RC file compiler and add it as a PBR (which still works but was technically deprecated) or RES, but "you cannot add any other #RESOURCE metastatements in your program" as per the PowerBASIC documentation.

What this code does is allow you to embed AVIs into your code using #RESOURCE RCDATA. After you compile your code to DLL or EXE you run this patcher by supplying the DLL/EXE file path on the command line (or via drag-and-drop). It proceeds to enumerate the AVIs and moves them to an AVI resource section using UpdateResource.

Be aware that you will need to repatch the DLL/EXE each time you re-compile your code.
As such, this could be included in a tool chain to always run after a compile.

Processing is written to a log (AVIRscPtch_Log.csv) in the directory the targeted module is located. To facilitate running in a toolchain it runs silently if no errors occur, but uses MESSAGEBOX to report any errors (in addition to the log).