By Aaron Severn
December 22, 1997
 
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Table of Contents
0 Disclaimer
1 Introduction
2 Using Debug to Generate Machine Code
3 Using Machine Code in QBasic
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 
0 Disclaimer
------------
I assume no responsibility for any harm that comes from using the material
contained in this document to you, your computer, or anything relating to
your existence. No warranty is provided or implied with this information.
This document is provided as is.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 
1 Introduction
--------------
It's always nice to throw in a little assembly in your QBasic programs, if
only to speed things up. Also, some things like BIOS calls are impossible
in QBasic without assembly (but not in QuickBasic, there's another way).
Now I'm not going to start teaching you assembly, if that's what you want
look into one of the hundreds of other tutorials available on that subject,
this is about taking assembly and making it usable to your QBasic programs.
I'm sure there are alot of people out there who know how to program in
assembly well enough but don't have a clue as to how you get all those hex
numbers that CALL ABSOLUTE uses. That's where this tutorial will help you.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 
2 Using Debug to Generate Machine Code
--------------------------------------
In your DOS directory (or your WINDOWS/COMMAND directory for Windows 95
users) you will find a nice little program called DEBUG.EXE. This is
probably the most user unfriendly piece of software ever created. If you've
tried running it you'll notice that you get the following prompt and nothing
else:
-
So what use is that? Well try typing in the letter 'a' and hitting enter.
Now you've got just as ugly a screen staring back at you that looks
something like this:
-a
199D:0100
 
But at least we're getting somewhere. You see, 'a' (which stands for
assemble, I think) turns DEBUG into a crude assembler. You can now start
typing in assembly code. As an example, let's try something simple like
turning the mouse on. Here's the assembly code:
push ax
xor ax,ax
int 33
mov ax,1
int 33
pop ax
retf
 
Enter this code in DEBUG, when you're done enter a blank line, you've just
written a simple assembly program. When you enter the blank line at the end
it should take you back to the dash prompt. Now enter a 'u' (for unassemble)
at the prompt. A whole bunch of weird lines pour out, but wait, there's
that program we just wrote, and beside it, machine code. There should be
four columns on your screen, the first one lists the memory address of each
bit of code, the second one lists the machine code, the third lists the
assembly command, and the fourth lists the arguments for that command. The
column we want is the second one, copy down those numbers that came out,
you should get this.
50
31C0
CD33
B80100
CD33
58
CB
 
All those numbers are in hex, so in QBasic you'll have to add the &H
prefix.
 
So now we've got our machine code and we just have to get out of DEBUG.
Type 'q' at the prompt and we'll move on to implementing this in QBasic.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
3 Using Machine Code in QBasic
------------------------------
Chances are you already know that CALL ABSOLUTE is the command we need to
use here. This is how you do it. First take the numbers that you copied
down that are the machine code for our little mouse program and put them
together in a string. You want to take the ASCII character associated with
each number, that way we'll have a string of bytes in memory accessible by
CALL ABSOLUTE. Your QBasic code should look something like this:
DIM ASM AS STRING
ASM = ASM + CHR$(&H50)
ASM = ASM + CHR$(&H31) + CHR$(&HC0)
ASM = ASM + CHR$(&HCD) + CHR$(&H33)
ASM = ASM + CHR$(&HB8) + CHR$(&H1) + CHR$(&H0)
ASM = ASM + CHR$(&HCD) + CHR$(&H33)
ASM = ASM + CHR$(&H58)
ASM = ASM + CHR$(&HCB)
 
Now all you have to do is run it. First set the default segment to the
segment address of ASM, then use CALL ABSOLUTE with the offset address of
ASM as the parameter. Add the following two lines to the bottom of the
above code and then run it.
DEF SEG = VARSEG(ASM)
CALL ABSOLUTE(SADD(ASM)
 
So that's the basics of using ASM in QBasic. But before I'm finished let
me write a little about passing variables to your assembly procedures. For
example, if you wrote a faster PSET routine done in assembly you'd want to
pass the (x, y) coordinates and the colour of the pixel. To do that you
have to understand where the variables are. When you put additional
parameters in a CALL ABSOLUTE statement QBasic puts them on the stack, so
all you need is to set up a pointer to the stack, which is done with the
following assembly code.
 
push bp
mov bp, sp
.
. [your code here]
.
pop bp
 
Now bp points to the first byte on the stack. Take the following sample
code. Let's assume that ASM contains code which puts a pixel on the screen.
DEF SEG = VARSEG(ASM)
CALL ABSOLUTE (x, y, colour, SADD(ASM))
 
In this example the stack would look something like this:
0A x
08 y
06 colour
04 QBasic return offset
02 QBasic return segment
00 bp (pushed on to the stack by the ASM code)
 
So in order to get at x you would just use [bp + 0A]. Remember that
everytime you push a byte on to the stack those numbers will be adjusted.
For example if you had pushed AX on to the stack then x would be located at
[bp + 0C] now. If you push on BX, x is now at [bp + 0E]. You get the
picture. So good luck!
 
 

Answer 12
~~~~~~~~~
[ Addition to Aaron Severn's ASM tutorial by Vic, downloaded from www.qbasicnews.com , 21.11.03)
 
-----------------------------------------------------------------------------
Vic's QBasic Programming Tutorial
Basic Tutorial XIII
USING BASIC ASM IN YOUR BASIC PROGRAM!!!
This actually is more complicated then ASM itself!!!
-----------------------------------------------------------------------------
Before I start On this tutorial, I want to admit something...
This tutorial was done before By a genius called Aaron Severn back in 1997...
That tutorial has everything you could want, but I think that it leaves
some things out... It also leeves out some details. At the time I learned
this, I did not know that that tutorial existed, (I wish I did!!), I picked
it up from some peoples source code, so I don't consider this plagerism...
 
---
Ok, where to start...
First, why use ASM at all...
1. Its fast...
2. It can do many many things that Qbasic can't do on its own...
3. well, I guess #2 covers everything doesn't it??
 
 
---
Ok, What must you do first?
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!NOTE: This tutorial expects that you read the last one on ASM... !!
!! This tutorial does not teach asm... !!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
Ok, lets start of by using the mouse ASM program we used in the last
tutorial...
remember?
 
mov ax,1
int 33
RETF
 
Ok, you might not remember the RETF, but we need it to shut down the program
withought crashing... just remember to put it at the end of your program...
now what?
 
well, Qbasic would not understand this program in this format, so, we have
to make it more Qbasic friendly...
How? (I ask more questions than you probly do!)
by converting it from ASM to MACHINE Code...
 
 
*** CONVERTING ASM TO MACHINE CODE
There are a few ways to convert ASM to Machine code...
the ways that I use are...
1. Memorizing
2. Using Debug's Desembler or Unasembler or whatever its called...
 
 

#1. Memorizing... 'If your no interested in the word memorizing skip this
 
The MOV command would be the machine code equivalent of "B8"
so, the first command "mov ax,1" would look like this in Machine code
"B80100"
 
The INT command would be the machine code equivalent of "CD"
so, the second command "int 33" would look like this...
"CD33"
 
Finally, the RETF command (which is equal to "CB" would look like this
"CB"
 
So, all together, the program would look like this...
B80100
CD33
CB
 
You would have to memorize each command... I don't recomend this!!!
This is the way I originally did it until I found Aaron Severn's tutor...
 

#2. Using Debug!! (easy... LISTEN!!!!!)
ok, this is going to sound a little familiar... I hope!
goto a dos prompt (command.com)
and type DEBUG
 
type
a
to go to assembler mode
Now, type in the program ps. don't write the {enter}s
mov ax,1 {enter}
int 33 {enter}
RETF {enter}
{enter}
 
that should bring you back to the
-
prompt (if not, hit enter again)
Now, type
u
and you should see this on your screen...
197A:0100 B80100 MOV AX,0001
197A:0103 CD33 INT 33
197A:0105 CB RETF
197A:0106 A7 CMPSW
197A:0107 D802 FADD DWORD PTR [BP+SI]
197A:0109 3C2A CMP AL,2A
197A:010B 7505 JNZ 0112
197A:010D 800EA7D802 OR BYTE PTR [D8A7],02
197A:0112 3A0694D2 CMP AL,[D294]
197A:0116 75C9 JNZ 00E1
197A:0118 4E DEC SI
197A:0119 32C0 XOR AL,AL
197A:011B 8634 XCHG DH,[SI]
197A:011D 006919 ADD [BX+DI+19],CH
 
'or something like this...
!!!!
whats all that crap for???
 
well, My best guess, would be that thats left over from another program...
The only part that you need to pay attention to is the stuff that contains
your program code...
EX.
197A:0100 B80100 MOV AX,0001
197A:0103 CD33 INT 33
197A:0105 CB RETF
 
Look over to the right of that ^ ^
Thats our complete program...
 
look over to the left... past the 197A:0100...
you see B80100...
 
That is those commands (to the right...) in machine code...
It did it for you!!! GREAT!!!
Do you get it???
 
 
*** Using MACHINE CODE in QBasic...
Each two digit number (in HEX.. (i'll explain later!)) is a command, or a
number... So, qbasic needs the program seperated into 2 digit #'s...
so the above program...
B80100
CD33
CB
 
needs to look like this...
B8 01 00 CD 33 CB
 
but, even now After it is machine code and seperated, QB will not understand
it... you have to tell QB that they are HEX and not Decimal numbers and then
put it all into an array... Then your finished...
Here we go!!
 
 
*** How to tell QB the numbers Are HEX...
Since this is a basic ASM in QB tutor I will cover the easy most
understandable explaination... In a more advanced tutorial, I plan to
cover a different way... for now just use this...
 
Lets take the first 2 digit HEX command B8...
in order for qb to understand it as hex we need to present it like this...
 
CHR$(&HB8)
 
Lets disect this...
CHR$( &H B8 )
^ ^ ^ ^
changes to Makes it The command Closing
character. HEX... ... ...
 
Ok... Lets look at the next one 01...
CHR$(&H01)
 
Disect again...
CHR$( &H 01 )
^ ^ ^ ^
changes to Makes it The command Closing
character. HEX... ... ...
 
do you get it yet? I hope so...
 
 
*** Putting the hex into an array...
This is simple...
do you remember how to add words together in qb?
like this
' First QB example in a long time (copy into QB...)
'
ONE$ = "School "
TWO$ = "Sucks!"
'
THREE$ = ONE$ + TWO$
'
Print THREE$
'
END
'
'---- end example...
 
In this example, the words are connected...
 
How do we do this with HEX?
The same way!
 
The mouse program would look like this...
this is the original (not ready for QB)
B8 01 00
CD 33
CB
 
This is what it would look like going into an array...
ASM$ = ASM$ + CHR$(&HB8) + CHR$(&H01) + CHR$(&H00)
ASM$ = ASM$ + CHR$(&HCD) + CHR$(&H33)
ASM$ = ASM$ + CHR$(&HCB)
 
can you see how its done???
 
 
*** OK Qbasic Can see the ASM program... Now what?
All we have to do now, is tell QB to execute the above code as an ASM file...
So, the program is stored as one array called ASM$...
That is what we have to tell QB to Run...
What command do we use to run it?
I am sure you have seen this before... It is called CALL ABSOLUTE...
 
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!NOTE: if you are using QB 4.0 or above, you have to start qbasic in a dos !
! Box (command.com) whith the line c:\qbdir\qb /l If you don't !
! then QB will not recognize the Call absolute command... !
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
This is how you would call the call absolute...
Memorize this...
DEF SEG = VARSEG(ASM$)
CALL ABSOLUTE (SADD(ASM$))
 
Thats IT!! Your finished!!!
Here is the total program... (copy and paste this into a qbasic dos window)
 
'---------- QB ASM MOUSE EXAMPLE
'
SCREEN 13
ASM$ = ASM$ + CHR$(&HB8) + CHR$(&H01) + CHR$(&H00)
ASM$ = ASM$ + CHR$(&HCD) + CHR$(&H33)
ASM$ = ASM$ + CHR$(&HCB)
'
DEF SEG = VARSEG(ASM$)
CALL ABSOLUTE (SADD(ASM$))
'
'------- END EXAMPLE
 
Wow, that was a lot of explaining to do for such a short example...
 
This method is to do something that does not require input or output into and
out from QBASIC...
 
In the next ASM tutorial I will show you how to interact with the ASM that is
running. Examples of this is how to get the mouse position into qbasic, and
how to set the mouse position... This gets really ASM advanced...
 
 
If you want to know when this or any other tutorial is out make sure to sign
up on the list (look at the bottom of this file...)
 
 
-----------------------------------------------------------------------------
Thats it for this tutorial, If I didn't get into enough detail in the
explanations then just look at the source code and try to figure it out
on your own. All else fails E-Mail Me... I want to make these tutorials
as easy to understand as posible!!!
My current E-Mail address is RADIOHANDS*AOL.com
If you are using this tutorial on your page, please leave the tutorial
exactly as it is... please don't change anything, unless its spelling
errors... Theres alot of them! I don't like using the backspace key...
The original website that these were on is
http://members.aol.com/radiohands/index.html
Thank you
Vic Luce
Finished
January 21
2000
 
If you want to be notified when a new tutorial is out..
Send An E-mail to RADIOHANDS*AOL.com
with the subject saying VQBLIST and then your E-mail address(check website)
 
 
 

Answer 13
~~~~~~~~~
[ by Milo Sedlacek and Drew Vogel ( mkv*internetwis.com ) ]
 

Assembly Language Tutorial v0.3

For Intel's 80286 Processor

by: Milo Sedlacek and Drew Vogel
 
Dear Reader,
The purpose of this tutorial is to familiarize you with
the 8086 processor registers, accessing modes and
architecture so you'll eventually be able to interface
QuickBasic 4.5 with Assembly Language.
 
Knowledge of Hexidecimal and Binary numbers is assumed.
 
Now let's go over the parts of the computer...
there's:
1. main memory
2. the processor
3. peripherals attached on the bus
 
Basically, the processor performs operations on memory
and reads and writes to the peripherals.
 
So let's take a look at what registers are in the 8086
 
General Purpose Registers:
AX
BX
CX
DX
 
OK first let's talk about what these do, and what they
are. First of all, they are 16 bits wide, and they
are split into 2 parts, the low and high byte. Actually,
you could pretend that there are this many general
purpose registers:
 
AX AH AL
BX BH BL
CX CH CL
DX DH DL
 
Now, AH is the high byte of AX, so if I set AL to 0 and
AH to 1 then AX will be 256
AX = AH * 256 + AL
 
That's the way the _X and hi / low registers are related.
 
So basically you can access a general purpose register
in its 16-bit entirety or in its 8 bit high and low
parts. Note that if you put a value in _L or _H it affects _X.
 
Basically, these registers just hold temporary values and
are used for calculations, loop counters and so on.
 
Let's move on to other registers now!
;-------------------------------------------------
;other regs will be here when we reg them wrote up
;-------------------------------------------------
 
OK, now it's time to learn some assembly instructions
In oder to understand instructions you need to know what an operand is.
Here's the shorest and easiest to understand definition:
 
operand(s): values after the instruction
 
First I'll teach you MOV (doesn't have to be in caps, I just do
that to seperate instructions from other stuff) since it's probably
the easiest to understand and definately the most commonly used
instruction. The syntax for MOV is:
MOV detsination, source
 
MOV just moves the value of 'source' to 'destination', so 'MOV AL, 0005h'
would place 0005h into AL. Both operands can be registers, 'destination'
can be a literal expression and either (but not both) operands can be a
variable, or memory, but we'll get into variables and memory later.
 
Well, Since MOV is pretty useless by itself you probably want to learn
some more instructions, so we'll move on to INC and DEC. Herte's the syntax:
INC value
DEC value
 
INC simply adds 1 to 'value' and DEC subtracts 1 from 'value' where value is
either a register, variable, or memory. Ok, here's a little quiz.
MOV AX, 0010h
INC AX
DEC BX
INC AX
 
What be the value of AX? If you said 0012h then your right. Good thing you
didn't fall for my little trick of sticking 'DEC BX' in there which has nothing
to do with the value of AX.
 
What's that you say? You don't want to have 2 zillion INC's and DEC's in your
code? Well me either, and obviously Intel didn't like that idea either since
they made us ADD and SUB. Syntax:
ADD destination, source
SUB destination, source
 
Ok, ADD just adds the value of 'source' to 'destination' and stores the result
in 'destination'. SUB subtracts the value of 'source' from 'destination' and
stores the result in 'destination'. ADD and SUB have the same operand rules as
MOV which you should remember (if you don't read it over and over until you do). ]
Your really gonna hate me now, time for another quiz:
MOV DX, 0012h
MOV BX, 0006h
SUB DX, AX
DEC DX
INC BS
ADD DX, BX
 
If you think the value of DX is 0012h then your right. Damn your good. Right
now you probably saying, whoppdy do da, this is really gonna help me. Well
I know this is going kinda slow, but you need to know all these little things
in order to do anything useful.
 
Alrighty, here's how to multiply!
 
there are 2 ways you can multiply:
 
8 bit * 8 bit to yield a 16 bit result, or 16 bit * 16 bit to yield a 32 bit
result.
 
Multiplying 8 bit by 8 bit.
 
To set up for a MUL instruction, one of the numbers to be multiplied must
be in the AL register and the other number can be in any other 8 bit general
purpose register.
 
Example:
MOV AL,10
MOV DL,20
MUL DL
 
And the result will be in AX.
 
Multiplying 16 bit by 16 bit.
 
To set up for a 16 bit multiply instruction, one of the numbers must be in
the AX register and the other number can be in any other 16 bit register:
 
Example:
MOV AX,320
MOV CX,10
MUL CX
 
And the result will be in AX:DX where AX is the low word of the result and
DX is the high word.
 
And now onto dividing!
 
When dividing, you either divide a 16 bit number by an 8 bit number or a
32 bit number by a 16 bit number.
 
Dividing a 16 bit number by an 8 bit number:
 
The number to divide is to be in AX. The number to divide by (the
denominator) can be in any 8 bit register. The qotient is returned in AL
and the remainder in AH.
 
Example:
MOV AX,100
MOV CL,2
DIV CL
 
In a 32 bit by 16 bit divide, place the number to be divided (the numerator
in the AX:DX pair where AX is the low word). Divide by any other 16 bit
register.
 
Example:
MOV AX,0
MOV DX,1 ;the ax:dx 32 bit pair now contains the value 65536
DIV CX
 
The quotient is returned in AX and the remainder in DX.
 
Ok, heres some juicy stuff! These next two instructions are the reason I
NEVER use MUL and DIV. SHL and SHR (our two new 'wonder' instructions) are
probably the best and hardest to understand instructions, put on your think
cap for these. This is where knowledge of binary and hexidecimal numbers
comes in handy (you might want to go out and get a TI-34 or better).
Syntax:
SHL destination, value
SHR destination, value
 
SHL shifts each bit in 'destination' left 2^'value' places (or digit) and
SHR shift each bit in 'destination' right 2^'value' place. In other words,
the breakdown of it is, they multiply and divide by powers of 2. Here, look
at a few examples:
MOV AX, 0010b ;'SHL destination, 1' multiplies destination by it's base
SHR AX, 1 ;so now AX holds 0001b (b = binary)
 
MOV CX, 2 ;ok, this example is like '2*(2^4)'
SHL CX, 4 ;I know it's hard, but it'll make sense eventually.
 
Next comes IN and OUT. These are very useful, if you have a port reference that
is. Yes, you guessed right boys and girls, IN and OUT recieve data from a port
and write data to a port respectively. Syntax:
OUT destination, source
IN destination, source
 
The thing I never understood about these (and a few other instructions) is that
even if you provide a 'destination' and a 'source' they still use the port in
DX and the value in AL. Maybe Milo can tell all of us why. Since you do need to
know the port indexes to use these, I suppose I should provide you with at least
a small list huh? Well I'll see what I can do.
 
Ok, It's been a while since we've worked on this, this being for many reasons,
and we're going to take off into the juicy stuff pretty rapidly so I'd suggest
you make sure you understand the above info before continueing and unless you
just started reading this tutorial then I'd also suggest at least skimming over
it again!
 
Before we begin I would suggest you go learn the internals of screen 13h and how
it works. There will eventually be an explanation in the same zip as this tutorial
but since this tutorial is aimed at teaching assembly programming, we'll stick to
the language for now.
 
Since we are teaching you howto use assembly with quickbasic, we should probably
teach you how to call it from quickbasic. There are many ways to do this, but
since you are just starting out we'll make it easy on you. We'll make a library
full of all of our assembly routines from throughout the tutorial.
 
We will be using TASM for our assembling. If you don't have TASM, MASM will probably
work for most of our routines. I would suggest going out and getting TASM though.
Here is a sample program to access screen 13h and then exit.
.MODEL SMALL ;you can read up on MODELs in the TASM help file
.STACK 256 ;allocate space on the stack for PUSHs and POPs
.CODE
PUBLIC SET_SCREEN_13 ;let quickbasic call it
SET_SCREEN_13 PROC ;start a procedure
MOV AX, 0013h ;move 13h into ax
INT 0010h ;call the video bios interrupt (read tutor on INTs)
RETF ;return from call
ENDP ;end the procedure
END ;tells the assembler to stop assembling
 
You can write this in any text editor. Save it as 'tutor.asm' if you choose not to,
you may have some problems down the line. Ok, you need to assemble this into a
.obj (object) file by doing:
TASM tutor.asm
 
Then (assuming the .obj file is already in your quickbasic directory) you need to
link it like this:
LINK /q tutor.obj
 
You will be confronted by a few questions, here is an example:
Run File [MODE-X.QLB]: [Just Hit Return]
List File [NUL.MAP]: [Just Hit Return]
Libraries [.LIB]: BQLB.LIB
 
Now to load your library just do:
QB /l tutor.qlb
 
To call your new procedure just do:
CALL SET_SCREEN_13
 
Ok, If it doesn't work then it's at your fault because we are double checking
the sample code and directions for errors. Since this code is, more or less,
impossible to see working, we'll quit write up another procedure.
 
Here is why you should know how screen 13h works. If you've ever done a POKE
routine for screen 13h in place of a PSET then you know ay least just enough
to get by. To keep you interested though, without having to know screen 13h just
yet, we'll make a simple routine to color in the pixel in the top left corner.
I'm going to just make a PROC...ENDP in this on since you can stick this code
into the library we've already started. Here's the code:
SETP PROC
MOV AX, 0A000h ;screen segment
MOV ES, AX ;you can't affect Segment Registers with imediate values
MOV DI, 0 ;clear DI
MOV AL, 2 ;color 2
MOV ES:[DI], AL ;write color in AL to the screen
RETF ;return from call
ENDP
 
Whoaa, what the hell is that ES:[DI] thing? Well, unless you know some assembly
already, you're probably thinking something of this sort. Well my friend, this is
how you point to memory. And we'll explain this in a few days. Please go learn how
memory is set up (ie: segments and offsets). We will explain this eventually but
once again, this tutorial is aimed at learning assembly, not much else.
 
Ok, now that you've read up on memory and segments and offsets and all that other
good stuff I suggested, we can move on. When you have something like ES:[DI], ES
hold the segment and DI holds the offset to write to. Take the PSET routine above.
ES held the segment of the screen (0A000h). And DI held 0 since we wanted to write
to the very first pixel on the screen.
 
Now that you understand how pointing to memory works, we can make a totally functional
PSET routine, with paramaters for X, Y, and COLOR. This next step will be a big one.
so maybe we should take it in two steps. How about this, you email me telling me
which of the following you want to learn first, ok?
 
1) Calculating Offsets & Complex/Fast Math
2) Parameters

 

Answer 14
~~~~~~~~~~~~
[ Unknown Author ]
 
Using assembler language from within QBasic
 
> Hi all,
> I am looking for a QBasic routine (not QuickBasic, please) that will
> let you use Assembly language code in QBasic programs.
> I have seen these all over the place. I even had a few, but I either
> misplaced or deleted them.
 
Well, there is no routine as such to convert ASM code to the assembly language hex code QBASIC and QB4.x requires for CALL ABSOLUTE. Mark K Kim'sassembly language in BASIC tutorial at the following FTP site, ftp://users.aol.com/markkkim/asm_tutorial/ gives good step by step instructions for using DEBUG to convert ASM code to hex code. This won't work on MASM or TASM code though (but you should be able to convert this to DEBUG acceptable code with only minor difficulties if you know what you are doing).
 
You can semi automate the system Mark mentions though. Here's a modification of one of his examples, the code to turn the mouse on.
 
Create a file called mouseon.dbg (or cut and paste the example below)
with the following DEBUG code (best read Marks examples first so this makes
sense
;==========Mouseon.dbg, cut here
a
mov ax,0000 ;Copy 0000h to AX
int 33h ;Interrupt 33h
cmp ax,0000 ;Compare, is AX=0000h
jz 010f ;If equal, Jump to last statement
mov ax,0001 ;Else move 0001h to AX
int 33 ;Interrupt 33h
retf ;Return
u 100 10f
q
;=============cut here.
now type
DEBUG < mouseon.dbg > mouseon.asm
 
This will send the contents of the debug session to a file called mouseon.asm which looks like this.
;========mouseon.asm
-a
1289:0100 mov ax,0000 ;Copy 0000h to AX
1289:0103 int 33h ;Interrupt 33h
1289:0105 cmp ax,0000 ;Compare, is AX=0000h
1289:0108 jz 010f ;If equal, Jump to last statement
1289:010A mov ax,0002 ;Else move 0001h to AX
1289:010D int 33 ;Interrupt 33h
1289:010F retf ;Return
1289:0110
-u 100 10f
1289:0100 B80000 MOV AX,0000
1289:0103 CD33 INT 33
1289:0105 3D0000 CMP AX,0000
1289:0108 7405 JZ 010F
1289:010A B80100 MOV AX,0001
1289:010D CD33 INT 33
1289:010F CB RETF
-q
;===========end
 
you want the lines between -u and -q, now you have to select the hex codes and split them up (eg, ignore the 1289:0103, you just want CD33, which has to be split up into CD and 33 and then converted into a string format CALL ABSOULTE can use. So CD33 becomes HR$(&HCD)+CHR$(&H33) (&H means hex)
Thus you get
'============================================================
asm$ = ""
asm$ = asm$ + CHR$(&HB8) + CHR$(&H0) + CHR$(&H0) 'MOV AX,0000
asm$ = asm$ + CHR$(&HCD) + CHR$(&H33) 'INT 33 Call the interupt
asm$ = asm$ + CHR$(&H3D) + CHR$(&H0) + CHR$(&H0) 'CMP AX,0000 If AX is 0 then no mouse
asm$ = asm$ + CHR$(&H74) + CHR$(&H5) 'JZ 010F so jump to the end
asm$ = asm$ + CHR$(&HB8) + CHR$(&H1) + CHR$(&H0) 'MOV AX,0001 otherwise load AX with 1
asm$ = asm$ + CHR$(&HCD) + CHR$(&H33) 'INT 33 and do the interrupt
asm$ = asm$ + CHR$(&HCB) 'RETF Return to the system

DEF SEG = VARSEG(asm$) 'calculate segment
offset% = SADD(asm$) 'calculate offset
CALL ABSOLUTE(offset%) 'execute
'============================================================
 
It should be easy to write a parser that will take the mouseon.asm file and convert it to BASIC code, I might even do it when I get some time.
 
 

Answer 15
~~~~~~~~~~
[ by lkt153 ( www.lkt153.cjb.net - ICQ: 27901426) ]
 
*** 1. The Assembler Basics
Assembly as the meaning of the word suggests is not what Quick Basic can execute. Assembly is what we want for Quick Basic to execute. Quickbasic can execute machine language only.
If you have an assembly routine, you have to have it translated. Dos' DEBUG can do the job.
Suppose we have this tiny routine:
MOV AX,0013
INT 10
RETF (Assembly routines always terminate with RETF)
 
We start DEBUG, type a0, press enter and type all the instructions. Press enter on a blank line to stop. Now type u0> and you will see like a dozen lines of which these are on top:
 
1E2C:0000 B81300 MOV AX,0013
1E2C:0003 CD10 INT 10
1E2C:0005 CB RETF
 
The machine language located is in the 2nd colum and you must extract them and keep them for later.
B8 13 00 CD 10 CB
 
To implement them in Quickbasic, read the implementing section in this category.
 
*** 2. Implementing ASM in QuickBASIC (a simple way)
There are several ways to implement asm into Quick Basic, of which most can easily cause crashes or a corrupt string space.
 
The way I'm gonna show now is the most simple one (if implemented right) and it requires some formatting of the machine code.
 
If you have this routine:
MOV CX,FFFF
;0003
PUSH CX
MOV CX,1000
;0007
LOOP 0007
POP CX
LOOP 0003
RETF
 
coded this way
B9FFFF
51
B90010
E2FE
59
E2F7
CB
 
then you can translate it and build this program to execute it. You read all the bytes as numerical format, convert them to character, add to a string and use the string as instruction space. To do that, you need to know the absolute location of the string. Get the segment by using VARSEG(). To get the beginning of the string, you normally use VARPTR(). You must first note that the beginning of a variable length string is in fact a length identifier. Only 2 bytes after the beginning is the first character in the string. To get the right beginning we use SADD() (string address) instead. This function returns the actual beginning of the string without the length identifier.
 
(tested)
DATA &hB9,&hFF,&hFF,&h51,&hB9,&h00,&h10,&hE2,&hFE,&h59,&hE2,&hF7,&hCB
asm$ = ""
FOR a = 1 TO 13
READ h%
asm$ = asm$ + CHR$(h%)
NEXT a
DEF SEG = VARSEG(asm$)
CALL absolute(SADD(asm$))
 
Now, you can rethink the situation and shorten the data line by adding some code. You just store the hex codes in one data string. You can let the program read the string and get every hex code out of it and have it translated to characters. This way you don't have to count how many machine codes you got.
 
(tested)
DATA B9FFFF51B90010E2FE59E2F7CB
asm$ = ""
READ h$
FOR a = 1 TO LEN(h$) STEP 2
asm$ = asm$ + CHR$(VAL("&h" + MID$(h$, a, 2)))
NEXT a
DEF SEG = VARSEG(asm$)
CALL absolute(SADD(asm$))
 
*** 3. Using numeric variables
Assembly routines (or should I say, machine language?) can read or write Quick Basic variables. First of all, you need to know the 2 types of variables:
 

Writing a routine for CALL ABSOLUTE..
 
CALL ABSOLUTE executes a machine-code string in memory, so you set the segment of the string with DEF SEG, then the rightmost parameter to the CALL ABSOLUTE routine is the offset at which the string begins.
 
Any previous parameters are like parameters you would pass to a regular sub (if you were making an assembly library or something). Parameters are pushed left to right, so your stack would look like this upon entering the assembly routine:
.
..
sp + 4 = rightmost parameter passed to routine (not the offset of the assembly routine
sp + 2 = return segment
sp = return offset
 
Parameters are passed to the routine by reference, by default, so the offsets of the variables are placed on the stack (DS contains the segment). You can pass variables by value by using BYVAL. Um.. here's a pointless routine.. it performs ShiftLeft on an integer:
 
DECLARE SUB addAsm (asmStr$, nextCmd$)
'
DIM number AS INTEGER
DIM count AS INTEGER
'
CLS
'
asm$ = ""
addAsm asm$, "55" 'push bp
addAsm asm$, "89E5" 'mov bp, sp
addAsm asm$, "8B5E08" 'mov bx, [bp+08]
addAsm asm$, "8B07" 'mov ax, [bx]
addAsm asm$, "8A4E06" 'mov cl, [bp+06]
addAsm asm$, "D3E0" 'shl ax, cl
addAsm asm$, "8907" 'mov [bx], ax
addAsm asm$, "5D" 'pop bp
addAsm asm$, "CA0400" 'retf 4
'
INPUT "Enter in a number: ", number
INPUT "Shift left how much?(1-15): ", count
DEF SEG = VARSEG(asm$) 'shouldn't be necessary, since data segment is default
CALL ABSOLUTE(number, BYVAL count, SADD(asm$))
DEF SEG
PRINT "Result:"; number
END
'
SUB addAsm (asmStr$, nextCmd$)
FOR i = 1 TO LEN(nextCmd$) STEP 2
asmStr$ = asmStr$ + CHR$(VAL("&H" + MID$(nextCmd$, i, 2)))
NEXT i
END SUB
 
BTW, remember to pay attention to the type of parameters you are passing (usually would just be integer, perhaps long integer). That would be a common thing to overlook.
 
*** Comment on this item
uhh... why not just use string concatenation from the beginning...
...instead of adding an unnecessary sub... If you're too lazy to type a few extra "&H"s, then perhaps you shouldn't be using call absolute (unless you want to use decimal... *shudder*).