Re: What is an assembly language?

>Reply to article by: "randyhyde@xxxxxxxxxxxxx" <randyhyde@xxxxxxxxxxxxx>
>Date written: 22 Nov 2005 22:04:36 -0800
>MsgID:<1132725876.151597.230950@xxxxxxxxxxxxxxxxxxxxxxxxxxxx>

>>>>>Prove that HLA is a "high level language".

>>>>You are dodging and evading the issue, you little coward. All he really has to
>>>>do is prove it isn't an assembler.

>>>An assembler is a compiler for an assembly language.

>>No it isn't. Try another guess but before you do, read this:
>>http://www.davidsalomon.name/assem.advertis/AssemAd.html

>As I said, I have. I even quote his definitions for high level
>assemblers right here:
>http://webster.cs.ucr.edu/AsmTools/HLA/HLADoc/HLARef/HLARef3.html#1035157

I'm not interested in what you do elsewhere, I'm only interested in what you do
here and you aren't doing any such thing here. But I guess it is better that you
didn't because the tired ol' argument you give in the link above starts with an
admittance that you know what David Salomon says about HLAs, but since it
doesn't fit into your agenda or opinion, "Therefore, this document will define a
high level assembler as follows..." whereupon you proceed to make up your own
definition of an HLA. You are not an expert on this matter; David Salomon is,
therefore if David Salomon says that HLA is one thing and you say it is
something else, I will side with David Salomon. This is especially so when you
resort to dishonest things like making up your own definition for what an HLA is
and not telling other people that you are making it up.

>>>Then again, that same definition excludes just about every other
>>>assembler available for the x86, including his own.

>>No it doesn't. Just because you say it is so doesn't make it so.

>Perhaps not.

That too is only say so. Are you have difficulty understanding what say so is?
Instead of immature insults and name calling, why don't you try proving the
definition in question exlcuse just about every other assembler available for
the x86, instead of just saying it is so?

>>Try another guess.

>>>>There is no RosAsm crowd for you to attack here.

>>>I count three active today. Where have you been?

>>I count one in this thread at this time. Where have you been?

>Try using your second and third fingers. I'm sure you can count to at
>least three by using them :-)

Can't admit you are wrong again? It was only you and Rene and you can't prove
otherwise.

>>I'm curious...why can't you love your enemies and do good for your enemies like
>>Jesus commanded you to?

>Keep trolling... Someone might bite. It just won't be me.

Don't worry your pretty little head over whether this is a troll or not. It
isn't because, by definition, a troll won't hang around to participate in the
discussion afterwards. But believe me, I will definitely be around to hear and
discuss your reply for why you are such a hateful, insulting, immature person,
when the person you profess to emulate, Jesus told you not to be that way. If
you are a religious phony, I want the whole world to see and know it without a
doubt. Thank you for proving me right on for this one so far.

>>>And now, the guy who thinks that semicolons are optional at the end of
>>>C statements :-).

>>Nope. Try another fairytale.

>Ah, so you are not claiming that you are not the amazing "The_Sage" who
>graced this very forum (and comp.lang.c) with that nonsense about
>semicolons being optional at the end of C statements (specifically
>before a closing brace)? You sure sound like the same guy. Your
>arguments are just as lame. You have the same trolling manner. Forgive
>me for assuming that you're the same person.

You are forgiven. Did you forget your memory pill yet again? You might have the
right guy but, as usual, you don't have the right argument. Why don't you stop
resorting to logical fallacies like attacking me instead of attacking the
argument? Stick to the subject instead. Is that too unreasonable of a request to
ask of of a mature Christian like you are?

>>>>All one has to do is just compare HLA to the assembly language mnemonics listed
>>>>in the Intel Programmer's Manual to see you are talking out your arse.

>>>Well, let's see here.

>>>Intel HLA
>>>------ ------
>>>MOV MOV
>>>ADD ADD
>>>SUB SUB
>>>AND AND
>>>OR OR
>>>XOR XOR
>>>BT BT
>>> . .
>>> . .
>>> . .
>>>etc. etc.

>>More dishonesty. *ALL* of your keywords have to be ASM keywords, not just a few
>>of them.

>Sure. And by doing that we pretty much disqualify *all* assemblers.
>Good job.

It does no such thing. You claim it does, so prove it does instead of asserting
it does. And don't resort to the logicall fallacy of shifting the burden of
proof. All of your keywords have to be ASM keywords in order for HLA to be
considered an assembler but most of the HLA keywords are HLL keywords. Explain.

>>By your "logic", you just proved the Visual C++ is also an HLA, since
>>Visual C++ also supports ASM keywords. But you would be wrong. Again.

>The language that VC++ processes is not an assembly language.

Just like HLA.

>That's the crucial difference; HLA *does* process an assembly language.

VC++ will "process" MOV, ADD, SUB, AND, OR, XOR, BT, and so on, just like your
HLA example does. All that is needed to process those (and other MASM compatible
syntax) is the use of the _ASM keyword. Therefore, by your not-so-honest
"logic", VC++ is an HLA. But of course you would still be wrong.

>>>Wow, that even eclipses your "semicolons are optional in C" claim.
>>>You *do* realize that GCC emits assembly language source code as
>>>output, don't you?

>>So does VC++ but you weren't talking about assembly output, but directly
>>outputting object code.

>I wasn't? Let's read my exact quote again:
>"Yes, there exist compilers that translate their input source file to
>object code directly, just as there are compilers that employ an
>intermediate form (e.g., assembly source file)."

>Pay particular close attention to the last phrase in the quote.

Pay particular close attention to the fact that object code is not even close to
being an object file. They are vastly different to be so easily confused by
someone who supposedly should know better.

>And as for VC++ emitting assembly, it has an *option* to do this, but
>by default it emits binary object code to an OBJ file (or, if you
>consider the whole VC++ system, including the linker, it creates an EXE
>file).

Assembly code is not the same thing as an object file or object code. They are
vastly different to be so easily confused by someone who supposedly should know
better.

>>Maybe you still don't know what the difference between
>>object code and assembly code is yet?

>Where do you get this nonsense from? Oh, I forgot who you are, you are
>incapable of anything else.

I know of many compilers that emit object files and assembly code, but none the
emit that object code minus all the other stuff included in an object file.

>>This even eclipses your "HLA is an assembler claim".

>I'm still trying to figure out how you went from my statement "You *do*
>realize that GCC emits assembly language source code as output, don't
>you?" to making comments about VC++'s output and suggesting that I
>don't know the difference between assembly and object code output on
>the basis of that statement.

Your quote included the term "object code", not "object files" nor "object
source". You can't seem to get your elementary computer terminology correct.
Code, files, and source are three different things yet you used all three
interchangeably.

>A complete non-sequitor.

Only to you. But that only tells us more about you than it does about the topic
under discussion.

>>>You do realize that VC++ emits object code as output, don't you?

>>It can emit object code but only INDIRECTLY.

>I run VC++ all the time. It produces object files. Not assembly files.

VC++ will directly output object files but will not directly output object code,
and your claim was that many compilers directly emit object code. Object code is
by definition, directly executable. Try directly running an object file and it
will crash. That's because object files not only contain object code but object
data and symbol tables for linking purposes only.

PS -- Not all compilers output object files. Many BASIC programs do not output
any object files.

>>The main function of VC++ is to
>>perform the compile and link all in one operation,

>Perhaps for you.
>Some of us actually run cl.exe to produce object files (via make or
>nmake) and then separately link the result.

You can do the same thing visually.

>But what all this has to do
>with the fact that GCC produces assembly files is beyond me.

If you can't explain your own comments, who can then?

>Let's go back to my original quote you're commenting on:

I never left it...

>>>>Yes, there exist compilers that translate their input source file to
>>>>object code directly,

>For example, VC++. And there is nothing indirect about it. cl -c
>myfile.c produces an object file directly. In fact, it's really the
>*EXE* file that gets produced indirectly, by having CL automatically
>run the linker after it's produced an OBJ file.

Technically speaking, VC++ produces object files and EXE *directly* -- how could
it be any any other way when they are both produced in *exactly* the same
manner? You press a button or type a command to produce it and it directly
produces it. Now if there were no command or button to produce it and it still
produced them anyway, then you could say it was produced indirectly. Or is this
another example of a Randall Hyde redefinition of common words to mean something
else?

Please, lay off the nonsense. You are just being argumentive just to be
argumentative.

>>>>just as there are compilers that employ an
>>>>intermediate form (e.g., assembly source file).

>E.g., Gas.

>Now how VC++'s behavior somehow "proves" that no C compiler produces
>assembly output is beyond me. Particularly when there is such an
>obvious example such as GCC. Indeed, even VC++ has the option of
>producing an assembly language output file that can be compiled with
>MASM (then you'd get an OBJ file indirectly, this this path is by no
>means mandatory).

I did not claim that VC++ or GCC would not emit assembly code, I only disagreed
with the first part of your two-part claim that most compilers emit object code
directly. And if you read the context of *all* my replies, you will see that I
never take issue with the assembly code part.

>>so emitting object code
>>directly would generally be counter-productive and useless, since most VC++
>>people don't need or want to deal with object code. All they want is the
>>executable.

>You really don't have a clue what you're talking about, do you?
>The really funny thing is that the compilation process is generally
>discussed during the first week of a student's first programming
>course. Were you sleeping during that lecture?
>Did you even take any programming courses? It sure doesn't sound like
>it.

>BTW, within a couple of weeks in a C++ programming class, most students
>have figured out that semicolons go at the end of each statement in the
>program.

BTW, I'm glad I never claimed anything to the contrary. As now, you didn't pay
attention back then. My claim was that not every line needed a semi-colon in
every C++ compiler. That is not the same thing as "no line needs a semi-colon in
C++". I even gave an example that you were unable to disprove, ie -- lines could
be terminated with a "}" at the end of a function.

But this isn't open for discussion. You are just trying to divert the topic
because you feel threatened. That is the only reason people resort to tactics
like that, as well as the immature insulting. But I'm not going to let you get
away with that. Anytime you resort to the stupidity in the future, I will do the
proper thing by snipping it, just like I snipped any of your logically and
factually irrevent name calling "arguments" in this post.

>>>>Ah, but I am merciful, even to idiots like yourself. I will
>>>>show you a real expert who wrote a real book on this topic, titled ASSEMBLERS
>>>>AND LOADERS. You can download it for free at:
>>>> http://www.davidsalomon.name/assem.advertis/AssemAd.html

>>>I don't need to download a copy. I actually own the hardback edition.

>>But you do need to learn to read it, not just let it sit on your shelf
>>collecting dust.

>Hmmm..
>Not only have I read it, I even quoted it in the HLA manual, check it
>out yourself here:
>http://webster.cs.ucr.edu/AsmTools/HLA/HLADoc/HLARef/HLARef3.html#1035157

That only proves you know how to quote it, not the you learned to read it, ie --
I see no evidence of reading comprehension.

>>>>Please do us all a favor and don't forget to read the INTRODUCTION where the
>>>>author gives two definitions for an assembler. It's on page one...you can't miss
>>>>it. But in case you want to revert to your usual denial of anything not
>>>>conforming to your opinion, read the stats on the author here...
>>>> http://www.davidsalomon.name/
>>>> ...and then let's compare them to your stats.

>>>And you might want to read his discussion of high-level assemblers.
>>>Note that he still calls them assemblers.

>>He points out that some people consider the term a misnomer. He is also very
>>clear in pointing that, "Such a language should not have features like the if,
>>for, and case control structures, complex arithmetic, logical expressions, and
>>multi-dimensional arrays...and [should ony have] a few simple data types". Last
>>time I looked, HLA violated all of those rules. Clearly you have no proper
>>concept of what an HLA is.

>How *sneaky* you are. But you forget that I own the book. So I know how
>you've taken this statement out of context. In the next paragraph, or
>so, for example, Salomon says the following:

>"A high-level assembler language (HLA) is a language that combines most
>of the features of higher-level languages (easy to use control
>structures, variables, scope, data types, block structure) with one
>important feature of assembler languages namely, machine dependence. "

>Nice try, though. You might have convinced those who've not bothered to
>read the book. But as I *have* read it, and used the definitions from
>the book, that's one "swindling" (as Rene would put it) that you're not
>going to get away with.

How *sneaky* you are. I also own the book but you forgot that fact. Context
refers to what is before and after a particular quote. Here is an actual example
of quoting in-context instead of giving an out-of-context quote like you gave...

"As the name implies, these are assemblers for high-level assembler
languages. Such languages are rare, there is no general agreement on how to
define them, on what their main features should be, and on whether they are
useful and should be developed at all. Existing high-level assemblers differ
in many respects and, on looking at several of them, two possible definitions
emerge:

A high-level assembler language (HLA) is a programming language where each
instruction is translated into a few machine instructions. The translator
is somewhat more complex than an assembler, but much simpler than a
compiler. Such a language should not have features like the if, for, and
case control structures, complex arithmetic, logical expressions, and
multi-dimensional arrays. It should consist of simple instructions,
closely resembling traditional assembler instructions, and of a few simple
data types.

A high-level assembler language (HLA) is a language that combines most of
the features of higher-level languages (easy to use control structures,
variables, scope, data types, blockstructure) with one important feature
of assembler languages namely, machine dependence.

One may argue that the second definition defines a machine dependent
higher-level language rather than a high-level assembler language, the main
reason being the definition of assembler language, given in the introduction.
The basis of this definition is the one-to-one correspondence between
assembler- and machine instructions. The languages discussed here do not have
such a one-to-one correspondence and, in this respect, resemble more a
higher-level language than an assembler language.

What that says is that the existence of HLA is in dispute, not that they
actually exist. David gives examples of what are considerd by some to be HLAs,
but offers no proof, as he remains neutral in the matter. That is fine for
historical purposes, but not for for technical matters. The second definition is
contradictory, since by that definition, any assemble or compiler that will only
work with an Intel processor can be considered an HLA, and therefore, since
MSBasic is an HLA.

And because the definition is in dispute, no valid arguement can be given for
it, ie -- if there is an adequate degree of agreement among the other experts in
the subject in question, it would be a logical fallacy to claim any HLA exists.
See item number three in
http://www.nizkor.org/features/fallacies/appeal-to-authority.html

>>Yes it is. He asked for proof

>That HLA is an assembler.

>>and you said, "No, you give me proof first", and

>Okay. Here's the proof. Read Salomon's definition above. As you're the
>one pushing Salomon as the aribiter of what is and what is not an
>assembler, we'll just use his definition. And HLA certainly fits that
>second definition above.

The one in dispute you mean? The one that is contradictory? Nice try but no
cigar.

PS -- How do you justify ignoring the first definition? You can't. You just pick
and choose what appeals to your opinion, not what is factual or real.

>> Sorry, I can discuss religion wherever I want to. I don't need your permission
>>or approval. And I am also free to point out to whomever I like, all the facts
>>that prove you are a religious fake. If you don't like it, tough.

>Nice try at a troll, it still won't work.

>>When I observe
>>your childish, hateful, and unprofessional behavior in these newsgroups, and
>>then I look at the religion you espouse on your commericial website, it makes
>>for very interesting discussion. Phony people always make for interesting
>>discussion. Just look at your brothers in Christ like Jim Bakker, Jimmy
>>Swaggart, or Oral Roberts. They are unforgettable characters, just like you.

>Nice try for a troll, it still won't work.

It isn't a troll. Clearly you have no clue what a troll is.

>>>>Prove HLA is an assembler.

>>>HLA is a compiler.

>>Duh, so why name it an assembler when it is really only a compiler?

>An assembler is a compiler for an assembly language.

No it isn't. Quit making up terms out of thin air, just to suit your personal
agendas.

>>>It accepts HLA source code as input.
>>>It produces executable code as output.

>>No object code? No MASM code? Your story changes every two minutes.

>Try again.

Okay...No object code? No MASM code? Your story changes every two minutes.

>>>If we work under the assertion that HLA is an assembly language, then
>>>HLA is an assembler. Period.

>>But it isn't. Period.

>Again, if you say something isn't, that's a pretty good sign that it
>is.

So you say without a shred of proof.

>>>I will be more than willing to have an intelligent debate with those
>>>who would like to argue that HLA is *not* an assembly language.

>>That's because you are an intellectual coward and choose to dodge and evade the
>>reasonable request to prove HLA is an assembler.

>An assembler is a compiler for an assembly language.

No it isn't. Please look up your terms before spewing forth uneducated nonsense
like that.

>>Don't be afraid, you are only just wrong as usual.

>>>But I'll make the same challenge to you

>>No thank you.

>IOW, you are incapable of such a proof.

Can you prove I'm incapable or are we just going to have to take you at your
word, because right now your word is shit.

>>I would rather see you cower and duck everytime someone tries to
>>engage you in an intelligent debate over what an assembler is, what a compiler
>>is, and what a high-level assembler is.

>Well, as HLA matches the description of the book *you* provided as a
>reference for what is and what isn't a high-level *assembler*, I guess
>the debate is over.

You have interesting delusions, but that is all they are -- delusions.

>Nice attempt, though. As I said, the more you argue against HLA, the
>more people will take HLA's side because *everyone* around here knows
>what a total troll you are and the last thing they want to do is be
>associated with you. I'd bet even Rene cringes when you start arguing
>for him.

Yeah, that sounds like a real life fact that was gathered using scientific
methodology...not! You are not being a very good witness for Jesus. Everyone
around here knows what a back stabbing, lying, egotistical, hate-filled person
you are and the last thing real believers would want you to do is claim to be
one yourself. I'd bet even God cringes every time you tell someone you follow
Jesus.

The Sage

=============================================================
My Home Page : http://members.cox.net/the.sage

"Careful when you cast your devil out of you lest you cast
out the best thing in you." -Nietzsche
=============================================================
.