jmp | js module for creating , parsing and replying to messages

You need to restrict the ranges for the uppercase and lowercase characters by specifying a lower limit and a higher limit, not just the one value (96) that your current code uses.

Uppercase characters [A,Z] are in [65,90]
Lowercase characters [a,z] are in [97,122]

The nice thing of course is that you don't actually need to write these numbers in your code. You can just write the relevant characters and the assembler will substitute them for you:

There's a couple of issues. First of all ja is used for unsigned comparisons so it won't work for detecting values <0. Use jg (jump if greater) instead.

When you use Invoke MASM, does prepare a frame for you and passes parameters via stack, those are available inside the method, but if you see those ptrmessage in a debugger outside VS, those will be pointers to the addresses on the stack and not to the content of the message.

When an .EXE program starts in the DOS environment, the DS segment register points at the ProgramSegmentPrefix PSP. That's what we see in the included screenshot.

ASSUME DS:DATA is merily an indication for the assembler so it can verify the addressability of data items. To actually make DS point to your DATA SEGMENT, you need code like mov ax, @DATA mov ds, ax. Put it where your code begins its execution.

I'm sorry I don't know much about fasm, I tried to reproduce the problem through C++:

The BIOS will always start execution at the first byte of the boot sector, and in your case that appears to be the string, so you're executing data. (The fact that you put in a label called main doesn't affect this; nothing looks at it.) It could be that your "Hello world" string just happens to correspond to instructions that don't totally break everything.

Try moving the string to be after all the code, or else insert a jmp main before it.

Also, you have an inconsistency between your ORG directive and your ds segment. Your boot sector gets loaded at linear address 0x7c00. You can think of this in segment:offset form as 0000:7c00 or 07c0:0000 (or other ways in between if you really want). So to access data in the boot sector, you either need to load ds with zero and use [ORG 0x7c00], or else load ds with 0x07c0 and use [ORG 0]. However, your code mixes the two.

Various processors have different ways of handling this. On some, the call pushes the address of the instruction after the call. On others, the ret adds the length of the call instruction to the return address before jumping.

The first method is more flexible because it makes it possible to use various addressing modes with different instruction lengths in the call. It's also likely that the instruction decoder already knows the location of the next instruction as the call is being processed.

The transcription of the checksum algorithm is wrong.
Here's how I'd do it:

You are leaving loop1 when ah is not less than 0xff anymore.
The term less/greater is used in x86 assembly when signed numbers are compared. Number 0xff treated as signed 8bit integer has the value -1 and ah as signed byte (-128..+127), starts at 0x0f + 0x10 = 0x1f. And 31 < -1 is false on the first iteration, so loop1 is abandoned after the first call procedure1.

When comparing unsigned numbers we use term below/above. Instead of jl loop1 use jb loop1. Similary in procedure1: replace jl procedure1 with jb procedure1. (https://www.felixcloutier.com/x86/jcc)

The instruction JG is for comparision of signed integers. A 8-bit value 255 means -1 in two's complement and the jump is taken because 2 is larger than -1.

You should use JA to compare unsigned integers and jump in greater case.

Reference: Intel x86 JUMP quick reference