From: address@nospicedham.not.available   
      
   Alex,   
      
   > How so? The literals are assembled out of line of the code.   
      
   Again, you have zero knowledge about how the OP implemented it (or is   
   thinking about doing it).  You should therefore not be throwing absolutes   
   like that around.   
      
   But you're still stuck on that IBM of yours aren't you ?   Even though this   
   newsgroup is about x86 processors, which, if I may take your "a single   
   register can only address 4K at a time", isn't what what IBM uses(s|d) for   
   its mainframes.   
      
   > In other words, use an assembler or compiler with good programmer   
   > facilities.   
      
   Without any kind of explanation to what "good programmer facilities" are   
   that statement is rather meaningless I'm afraid.   
      
   > Preprocessors are a nuisance, especially macro driven beasts like m4.   
      
   Everything can be done overdone, or even done badly.  Thats not a reason to   
   exclude all usage of it.   If it where than all kinds of activities would be   
   forbidden.  Ranging from driving vehicles, kicking a leather air-filled sack   
   around, eating and even drinking of pretty-much everything (including   
   water), as well as politics and religion (of any kind).   
      
   And now I think of it, especially programming.   Both overdone as well as   
   done badly.  :-)   
      
   > The idea is to simplify, the outcome is complexity.   
      
   Quite so.  And sometimes that includes having done something "complex" done   
   by a preprocessor,a macro language and/or something build into the assembler   
   itself so the programmers task becomes easier (and less repetetive).   
      
   For example, my assembler allows me to set up a procedure which allows for   
   the definition of arguments (automatically converted to [bp+...] when   
   assembling), local labels - for stack and data segment alike - , used   
   register and memory locations (automaticaly POPed on when a RET is   
   encountered - which also automatically gets told how many argument bytes to   
   skip).  It also allows me a call the function with all of the needed   
   arguments on the same line.   
      
   It also allows me to call such a procedure, with the arguments for it on the   
   same line as the call.   Very handly, as I do not even need to think about   
   how many arguments, or even in which order they need to be pushed.   
      
   You see, a "procdesc" allows me to strictly define the calling type   
   (influencing the order in which the arguments are pushed), the ammount   
   ammount and type of arguments for the specified procedure, which the   
   assembler than checks against any call I make to it.   
      
   *None* of that is in *any* way related to a puristic view of what an   
   assembler is there for (the conversion from mnemonics to machinecode).   
      
   Regards,   
   Rudy Wieser   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)