home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / PCGPEV10.ZIP / ASM0.TXT < prev    next >
Text File  |  1994-05-10  |  7KB  |  194 lines
  1. Text for ASM #0
  2.     
  3.     Hello there, this is Draeden typing this wonderful document.  This is 
  4. an explanation of the basic assembler frame.  This document assumes that you
  5. know what hexdecimal is and somewhat how it works, that you have a copy of  
  6. TASM and TLINK, that you know what AX is, and how it relates to AL and AH, 
  7. and you know the commands: 
  8.  
  9.     MOV xx,xx 
  10.     JMP xxxx
  11. and INT xx
  12.  
  13.     I'm also making the rash assumption that you want to learn ASSEMBLER. :)
  14. To assemble ASM0.ASM into an executable do the following:
  15.  
  16.         TASM ASM0
  17.         TLINK ASM0
  18.  
  19.     Now you can exececute this wonderful program.  Go ahead.  Try it.  In
  20. case you are having problems figuring out how to execute this, just type:
  21.  
  22.         ASM0  (followed by the enter key)
  23.  
  24.     No, you did nothing wrong. This code (ASM0.ASM) does nothing.  All it 
  25. does is return control to DOS.  It is the basic frame for an assembler 
  26. program.  All of the programs that I write use this frame.  If you want to 
  27. know what each part does, read on.  If you already know, just go read 
  28. ASM1.TXT.
  29.  
  30.     The number followed by the colon means that this is from ASM0.ASM and 
  31. tells which line it is from.
  32.     
  33. 1:    DOSSEG        
  34.  
  35.   DOSSEG Sorts the segment using DOS standard, which is:
  36.  
  37.      1) 'code' segments (in alphabetical order)
  38.      2) 'data' segments (in alphabetical order)
  39.      3) 'stack' segments (again, in alphabetical order)
  40.  
  41.   Although it may not seem clear what this does, don't worry about it.  Just
  42. have it as the first line in your assembler programs, until you understand it.
  43.  
  44. 2:    .MODEL SMALL  
  45.  
  46. MODEL ONLY needs to be used if you use the simplified segments, which I 
  47. strongly recommend.
  48.  
  49. In a nutshell, .MODEL Selects the MODEL to use.  This is used so that this 
  50. code can be linked with C, PASCAL, ADA, BASIC, other ASSEMBLER program, and 
  51. other languages with ease.  It also tells the compiler how to treat your
  52. code and data segments.
  53.  
  54. NEAR means that the data/code can be reached using a 16bit pointer (offset)
  55. FAR  means that a SEGMENT:OFFSET pair must be used to access all the data/code
  56.  
  57. Possible MODELS are:
  58.  
  59.      TINY: Code and Data must fit in same 64k segment.  
  60.            Both Code and Data are NEAR.
  61.  
  62.     SMALL: Code & Data have seperate segment, but must be each less than 64k
  63.            Both Code and Data are NEAR.
  64.            For most applications, this will suffice.
  65.  
  66.    MEDIUM: Code may be larger than 64k, but Data has to be less than 64k
  67.            Code is FAR, Data is NEAR.
  68.  
  69.   COMPACT: Code is less than 64k, but Data may be greater than 64k
  70.            Code is NEAR, Data is FAR.
  71.  
  72.     LARGE: Both Code & Data can be greather than 64k.  Both are FAR, but a 
  73.            single array cannot be greater than 64k.  Note that max array size
  74.            means nothing if you are just writing in assembler.  This only
  75.            matters when you link to C or another high level language.
  76.  
  77.      HUGE: Same as LARGE, but arrays can be greater than 64k.
  78.            What that means is that the array index is a far pointer, instead
  79.            of a NEAR one.
  80.            LARGE and HUGE are identicle to the assembler programmer.
  81.  
  82. 3:    .STACK 200h   
  83.  
  84.     Tells the compiler to set up a 200h byte stack upon execution of the
  85. program.  NOTE: the size you choose for the stack does not change the size 
  86. of the file on disk.  You can see what I mean by changing the 200h to, say,
  87. 400h and then recompiling.  The file sizes are identicle.
  88.  
  89.     This could be replaced with:
  90.  
  91. : MyStack SEGMENT PARA PUBLIC STACK 'STACK'
  92. :       db  200h dup (0)
  93. : MyStack ENDS
  94.  
  95.     BUT, doing it this way makes your executable 512 bytes bigger.  If you
  96. were to double to 400h, the executable would be another 512 bytes bigger.
  97. I think it's pretty obvious why the simplified version is preferred.
  98.  
  99. 4:    .DATA           
  100.  
  101.     Simplified, unnamed 'data' segment.  This is where those simplified 
  102. segments become very handy.  If you were to write out the segment declaration
  103. the regular way, you'd have to write something like this:
  104.  
  105. : MyData SEGMENT PARA PUBLIC 'DATA'
  106. :
  107. :  ...                  ;your data goes here...
  108. :
  109. : MyData ENDS
  110.  
  111. Where 'MyData' is the name of the segment, public means that its, well, 
  112. public, and PARA is the alignment of the start of the segment.  'DATA' 
  113. specifies the type of the segment.  Instead of PARA, WORD or BYTE could 
  114. have been used.  (PARA = segment will start on an adress that is a multiple 
  115. of 16, WORD = even addresses, BYTE = where ever it lands.)
  116.  
  117. 5:    .CODE
  118.  
  119.     Pretty much the same story as above, but this is for the code segment.
  120. Could be replaced with:
  121.  
  122.  - IN MASM MODE -
  123. : MyCode SEGMENT PARA PUBLIC 'CODE'
  124. :  ...
  125. : MyCode ENDS
  126.  
  127.  - IN IDEAL MODE -
  128. : SEGMENT MyCode PARA PUBLIC 'CODE'
  129. :  ...
  130. : ENDS MyCode  ;the 'MyCode' is optional in IDEAL mode
  131.     
  132. 6: START:
  133.  
  134.     This is just a label.  Labels just provide a way of refencing memory 
  135. easily.  Like I could say "JMP START" which would jump to the label START and 
  136. execute the code immediatly after it.  Or I could say MOV AX,[Start], which
  137. would grab the WORD that was immediatly after the label START.
  138.  
  139. 7: mov     ax,4c00h
  140. 8: int     21h         
  141.  
  142.     This bit of code calls DOS function # 4ch, which returns control to DOS
  143. and sends back the error level code that is in AL (which is zero).
  144. Note that for all int 21h DOS functions, AH contains the function number.
  145.  
  146. THIS MUST BE AT THE END OF THE CODE! If it isn't, the code will continue to
  147. run...  right out of the end of your program and will execute whatever code
  148. is there!  The program will crash with out it!
  149.  
  150. 9: END START
  151.  
  152. This tells the compiler that we are all done with our program and that it can
  153. stop compiling, now.  And it tells the compiler to put the entry point at
  154. the label START.  This means that DOS is effectivly starting your program by
  155. executing this:
  156.  
  157. : JMP START
  158.  
  159.     As you would probably guess, if you just put `END' instead of `END START'
  160. and you compiled and linked the program, when you went to execute the code,
  161. the computer will probably freeze because it does not know where to start
  162. execution.
  163.  
  164.     Ok, now that you know what the frame is/does, lets actually make the 
  165. program do something.  Lets be wild and crazy, and PRINT A MESSAGE! 
  166.  
  167.  
  168.                             CONTINUED IN ASM1.TXT
  169.  
  170.  
  171. ┌──────────┬───────────────────────────────────────────────────────────────
  172. │ ASM0.ASM │
  173. └──────────┘
  174.  
  175.     DOSSEG
  176.     .MODEL SMALL
  177.     .STACK 200h
  178.     .DATA
  179.     .CODE
  180.  
  181. START:
  182.  
  183. ;
  184. ;   Your code goes here...
  185. ;
  186.  
  187.     mov     ax,4c00h
  188.     int     21h
  189. END START
  190.  
  191. ;   THIS CODE DOES ABSOLUTLY NOTHING EXCEPT RETURN CONTROL TO DOS!
  192.  
  193.  
  194.