Re: The Case Against RosAsm (#2)

From: Beth (BethStone21_at_hotmail.NOSPICEDHAM.com)
Date: 01/21/04 

Date: Wed, 21 Jan 2004 11:29:27 -0000

Frank Kotler wrote:
> Beth wrote:
> > Betov wrote:
> >>May be _you_, as an expereinced programmer can make the
> >>difference, in some HLA Source about what is HLL and what
> >>is "assembly-Like". It is nevertheless evident that the
> >>original claimed targeted "user base" of HLA -Beginners-
> >>can in no case.
> ...
> > "it
> > could be a macro, it could be an instruction but I'm not telling
you!
>
> stdout.put
> stdout.puts
> rep.movsb
>
> I'm not an "expert" programmer, but I thought I was "advanced"
enough to
> know what's "assembly language" and what's not without having to
RTFM.

Why _aren't_ you reading the manual, anyway?

That was, by the way, a _criteria_ I explicitly put in the bit you've
trimmed...these things are _only_ a "mystery" if you insist on
_ignoring_ the documentation that makes it all perfectly clear...

Do you expect brand new NASM users to just "know" things -
"magically", it appears - like "BITS 32", the available output formats
and their corresponding "sections" (and the options that go along with
them) and so forth? Or, if someone asked, wouldn't you kind of suggest
"hey, there's a manual for this stuff, you know? If you read that, you
can work this stuff out yourself!"?

And, I'm suspicious of your examples below, anyway, because...well,
I'll get it below...

> I'm pretty sure "rep.movsb" is assembly language.

Only "pretty sure"? It's "MOVSB" with a "REP" prefix...you're telling
me that the syntactical addition of a "dot" between them - rather than
a colon in other syntaxii, just to stress that an "operator" here
isn't at all unusual for most assemblers - has suddenly blinded you
from recognising "MOVSB"?

And, of course, _why_ are you remaining confused of _your own
freewill_, anyway? Because you're _well aware_ of where the "mystical
solution" to your "great answered mysteries of our time" exists,
right? Yes, in the manuals (indeed, note: _plural_...HLA has _more
than one_ manual...clearly separating out "standard library" from "HLA
language itself"...which, again, makes me wonder if Rene's looked
because it would be pretty difficult to "get all confused" when not
only is all "clearly defined" in the manual but these things are in
_different manuals_...so, like, you'd almost have to be _trying_ to
get yourself totally confused to actually end up that way! Plus, I'm
leaving out AoA so far, which is _tutorial-like_ that it takes a
beginner through these things with actual examples and stuff like that
too...leading to most things actually being _DETAILED TWICE_ - so if
you've really got problems in knowing how to read a manual then the
documentation even kind of helps by increasing your odds of stumbling
into it accidentally by having a higher probability than most
"manuals" for that to happen - across these three pieces of
documentation ;)...

You know there's a manual (actually, _manuals_ plus _tutorial
material_) that explains these things...and that manual _is_ provided
for a reason, as we can see:

---------------------------------
rep.movsb( )

Copies ECX bytes from the memory location specified by [ESI] to the
location specified by [EDI]. Increments or decrements EDI & ESI by one
after each transfer.

Returns "".
---------------------------------

To be found in the list of "Zero Operand Instructions" section of the
"The 80x86 Instruction Set in HLA" chapter of the "HLA reference
manual" (hardly hidden away in some section that's hard to find now,
is it? ;)...and AoA probably goes into much more detail with some
example code using it...

Right, now, because you simply _read_ the manual, you are aware that
"rep.movsb" is clearly a machine instruction because it is listed and
explained as such...

There, confusion over...you'll also never need to ever look up the
entry again...so long as you don't get that "temporary amnesia" and
can remember what you read...but it should be pretty easy for an
"advanced" user like you to remember that "REP" and "MOVSB" are
machine instructions, just like they are on those other assemblers
where you incredibly have NO TROUBLE AT ALL remembering these
facts...hmmmm....

Aren't these manual things great?

Sorry...but that's kind of my whole point I was making to Rene..._WHY_
on Earth aren't we reading the manual, when we know it has the answers
we want?

(Foolish) pride? Not "macho" enough? Daddy isn't around to read to you
at bedtime?

RTFM!!! ;)

I mean, sure, if you _insist_ on not "RTFMing" then you can stare at
those statements all day long, wondering if they really are or aren't
machine instructions in HLA or not (although, as an "advanced" user,
you _KNOW_ there isn't a "puts" machine instruction so, sorry, what on
Earth are you talking about not being able to tell if it's a "machine
instruction" or not? HLA gives you "temporary amnesia" here?? :)...

And, of course, when a NASM beginner posts up "so, is 'bits 32' an
actual machine instruction?", all the same people making this
complaint, _immediately_ jump to say "RTFM!!!" and comment on how
"pathetic" these newbies are for not "RTFMing"...touch hypocritical,
isn't it, to kind of insist _they_ "RTFM" but, like, expect that you
can instantly understand a new syntax and stuff without looking?

> I'm pretty sure "stdout.put" isn't.

What's this "temporary amnesia"? Where did you _ever_ see "put" in the
x86 instruction set? HLA might be pretty clever in places but it
_can't_ just "invent" extra actual machine instructions that aren't on
the CPU!! Like, when you install HLA, the install program starts
burning on new instructions onto the CPU's silicon???

I don't want to push this "dumbo" angle too much, as I know you're no
such thing, Frank...

But isn't kind of interesting that, to insult HLA, people all seem to
resort to "duh, I'm soo shtoopid!" arguments and absurd arguments
like:

"Aaaah, but _IF_ I was unable to read English and was surrounded by
Spanish people who couldn't translate for me and my printed copy of
the manual was eaten by a large bull and I couldn't print another one
because a freak highly selective magnetic storm wiped the ZIP file off
my hard drive and, due to non-payment to my ISP, I couldn't access the
internet to download another free copy (and I couldn't work it out,
either, by recognising that "MOVSB" in an Intel reference looks
_identical_ to "MOVSB" in HLA, due to sharing exactly the same letters
and name and big "clues" like that ;)..._IF_..._IF_ that was all the
case, then how could I tell if it's a machine instruction or not?

See! I couldn't, could I? Aha! HLA must the very 'spawn of satan'
then, clearly...burn HLA! burn HLA! burn HLA!"...

Although, note, even though you're trying to make this sound "very
complicated" and "totally ambiguous", you've totally guessed 100% so
far...so it _can't_ really be that difficult, eh? And with the manual,
it's kind of looking slightly - dare I say? - _EASY_ to work this
stuff out...you've _guessed_ 100% thus far and even if you couldn't
guess then there's AoA _AND_ a reference manual with a chapter titled
"the 80x86 Instruction Set in HLA" (which, you have to admit sounds
like an obvious enough place to look, right? ;)...

And, were you truly "unsure" about whether "put" or "movsb" was or
wasn't a machine instruction, then simply look for it in the "The
80x86 Instruction Set in HLA" chapter which lists out - as the chapter
title kind of suggests - the 80x86 instruction sets in HLA...

If you don't find it there then look for it in the "HLA standard
library reference", which details all the macros and procedure calls:

-----------------------

stdout.puts( s:string );

This routine prints the specified string to the standard output
device. Keep in mind that HLA strings are pointer objects. Therefore
the parameter is a pointer to an HLA string.
See the section on the HLA string library for more details.

-----------------------

If the word "routine" isn't a big enough clue for you then this is in
the clearly titled: "Standard Output Routines (stdout.hhf) / General
Output Functions / Character, String, and Cset Output" among a list of
_subroutines_, clearly marked as such...

And then for "stdout.put" there's an _entire section_ devoted to it
called "the stdout.put _macro_"...does the word "macro" help and an
entire section explaining how it works act as big enough clues?

-----------------------

23.8 The stdout.put Macro

stdout.put( output_list );

stdout.put is a macro that provides a flexible syntax for outputting
data to the standard output device. This macro allows a variable
number of parameters. For each parameter present in the list,
stdout.put will call the appropriate routine to emit that data,
according to the type of the parameter. Parameters may be constants,
registers,
or memory locations.

Here is an example of a typical invocation of stdout.put:

[ snip rest of _entire section_ devoted to this _macro_ and its
use...and how the _macro_ calls the "routines" listed earlier - just
above - this section in the reference manual...and so on and so
forth...note, also, the final line there: "Here is an example of a
typical invocation of stdout.put"...cool! A tutorial kind of thing
too...Randy doesn't seem intent on "information hiding" to the extent
Rene claims, really, does he? But then, the sheer _size_ of his
_multiple volumes_ of documentation on _all_ different aspects of
HLA - plus the smaller "articles" on Webster and a new "Windows
Programming in Assembly" companion and...and...and...anyone want to
argue "black is white" that Randy never provides enough
documentation?? - kind of suggests this strongly before looking at
it...but once you read some of it, your suspicions are confirmed...it
explains things!! Wow!! Who'd have credited a "reference manual" with
documenting things like that? ;) ]

-----------------------

Sorry...I mean, having to tell you to "RTFM" and "how to read a
manual" really seems a bit cheeky...well, no, _very_ cheeky...

But, well, _YOU_ are the one telling me you are incapable of doing
this...and Randy didn't write all this tons of stuff, just so that he
could print it out and use the printed copy under a table leg to
balance his table out so it stopped rocking about(!)...it's there to
be _read_ and to _inform_ and _educate_ anyone who chooses to read it
with the answers to these supposed "great mysteries of our time"
questions you may have...

Again, sorry...I don't really want to be sarcastic here but you're
kind of _forcing_ me to be so...you know, just like a "dumb newbie
question" invites many people to similarly post "RTFM!!!" and nothing
else (ironically, I'm never that unkind to "newbies"...but, you're
different...you _do_ know better that the gloves can come off :)...

Plus, if all of this isn't good enough, ask Randy or other HLA users!

I've had the odd "advanced" question and I pop Randy an Email about it
and he usually writes back promptly...and the last time, I even got a
special "preview" copy of HLA from Randy because I needed something in
HLA _which he added on request_ (!!!!)...want to attempt to show me
anyone else that provides a new feature _on request_ from a simple
Email that turned up _the next day_ (well, you know Randy's
productivity! :)

Now, come on!...this whole "Randy isn't telling us anything!" nonsense
is really getting VERY, VERY SILLY!!...he's second _only_ to my good
self in just "core dumping" out information in all directions on
request...and, hey, Randy tends to write more understandably than me
by quite a ways...you know, proper sentences and words that make sense
and stuff like that...the kind of thing that's usually beyond me...

> Randy informs me that "stdout.puts" is not a "macro", but a
"proceedure call".
> Is that "assembly language" or not?

This "I'm really stupid!" thing doesn't quite wash, Frank...

You're seriously saying as an "advanced" NASM coder that you don't
know whether "macros" and "procedures" are machine instructions or
not?

Come on, Frank, what on Earth are you playing at? If it's a "macro"
then you _KNOW_ that it's not a "machine instruction"...and if it's a
"procedure" then you also _KNOW_ that it's not a "machine
instruction"...so, either way, it's clear as crystal that, no, it's
NOT a machine instruction...if the problem was "macro or procedure?"
then there was absolutely NO POSSIBILITY there for it to ever have
been a machine instruction...so, how are we getting confused?

Or, does HLA not only have the effect of making illiterate _and_
suffer from "temporary selective amnesia" _but also_ means all your
logical deductive skills completely vanish too?

And, as shown, there's _AN ENTIRE SECTION_ - called "the stdout.put
_macro_", so there's no confusion about it being a _MACRO_ from merely
reading the _title only_ in the "standard library manual" (kind of the
obvious place to look for this too, right?) about it - which details
it...

> Betov may have a point here!

No, he doesn't...to make this deeply unconvincing case, we've got to
believe you've suddenly become illiterate, suffer "temporary selective
amnesia" (which just happens to select away any memory of anything
that could, in some way, demonstrate that HLA isn't in any way
"confusing" about this at all for any right-thinking person) _and_ you
lack all logic completely...

And even then, it's not a particularly good point at that...

What is this point?

HLA's no good if you refuse to read or use your memory or brain in any
way at all?

Ummm, wouldn't that kind of apply to _anything_ in this life? Isn't
that, like, not in any way a HLA-specific criticism but a kind of
"general" point about the value of reading and learning to use your
brain for the benefits that has for anyone who attempts it?

Wow, HLA's "propoganda" must be working too well...people expect to
simply _look_ at some HLA source code and to immediately understand
every single aspect of the language and standard library in an
instant!

No...but what is actually happening is something _good_ and
_pro-HLA_...what's really happening here is that HLA actually _IS_
very, very easy to read that you've picked up plenty by _just
looking_...and have actually gotten yourself into a "false sense of
security" that you - the "advanced ASM expert" - doesn't ever need to
look at the reference manual...MACHO MAN!! *swoon* ;)

Well, not being a man and not caring about being "macho", I kind of
took the _logical_ approach...call me mad, if you like...but this idea
that when I didn't understand things or wasn't totally sure - even if
I'm an "advanced ASM user" normally - I'd kind of _look it up_ in the
manuals and tutorials and stuff...

Yeah, I know, it's a pretty radical idea...but I think, you never
know, it's a plan that just might work:

RTFM!!! :)

> In fairness, this "seamless transition" between "high level" and
"low
> level" could be construed as an "advantage", rather than a
"problem".
> Depends on how you look at it.

Indeed; Although, grab that pair of pants you have lying around the
floor, Frank (well, you're a man...that's bound to be where you keep
them ;)...now, pick it up and turn it inside out...look, there! You
can see all the seams and stitching and everything!

It's kind of, like, up to you whether it's "seamless" or not...just by
choosing whether to look inside or outside that pair of pants you
have...

I've patronised you enough in this post that I won't make the obvious
connection to HLA....I think you can at least manage that...

Again, I totally 100% apologise for the sarcasm and patronisation but
when the arguments are this "black is white" and "duh, I suddenly have
become shtoopid!" and "but if you couldn't read and didn't have a
brain and your eyes fell out and...and...then how could you use HLA at
all? See! HLA doesn't work because it makes demands on people to be
able to read and use their brain!" (and we'll just ignore that
_programming of any kind_ already makes that demand that HLA presuming
it is hardly "asking too much")...well, _YOU_ were asking for nothing
less...how _could_ I reply in any other way when an intelligent person
starts _pretending_ to have become "a bit thick" and has memory loss
and can't read anymore to suggest some "point" that wasn't valid in th
e first place because I'd already given the answer...the answer to so
much in programming:

RTFM!!!

Beth :)

Relevant Pages

  • Re: wanna do something nerdy and cool?
    ... | areas where efficiency and compactness are a priority. ... | inefficiently and someone responded with a more efficient HLA routine. ... | the WHILE loop. ... | already have the DEC instruction which is capable of setting the Zero ...
    (alt.lang.asm)
  • Re: A sample RosAsm macro (actually a whole set)
    ... inline AT&T syntax I think you're confusing HLA for..."eax" is called ... instruction at all...this is something people who oppose "data typing" ...
    (alt.lang.asm)
  • Re: Question about jumps
    ... when you see an IF statement in HLA, you're going to need very little ... like what a MOV instruction does ... mov cx,ax;cycle 16 bits [randomness] times ... jmp $+2;IO delay ...
    (alt.lang.asm)
  • Re: Opcode Parsing & Invalid Opcodes
    ... another byte to the instruction, adds a modr/m byte to the instruction ... can't find anything in the manuals to confirm or deny this. ... If you jump to any target, the prefetch mechanism ... processor issues an invalid opcode exception. ...
    (comp.lang.asm.x86)
  • Re: "Best" approach to create an INSTRUCTION manual? (Sheets? Pages ? Text Box?)
    ... I have a PDF on my web site for how to do it in Publisher. ... |> I examined a stack of manuals to find something close to what I ... I have "modeled" my instruction sheet after those from two different ...
    (microsoft.public.publisher)