Re: Help...

On Jul 31, 12:05 am, Betov <be...@xxxxxxx> wrote:
"rh...@xxxxxxxxxx" <rh...@xxxxxxxxxx> écrivaitnews:1185831521.008293.158070@xxxxxxxxxxxxxxxxxxxxxxxxxxx:

The "100% of Asmers around" tends to be you and Wolfgang, by your own
claims.

Where did i say this, clown?

Again, your senility is getting the best of you.
Search back in this very group. At various times you've said that no
one in this group are real Asmer's excluding yourself and a few others
such as Wolfgang.


Fact is that Wolfgang is an occasional RosAsm user, when it
comes to develop for Win32. And then? Mind you, what i call,
usually, an "Asmer", is a programmer who wrote, at least,
one small Application, in Assembly.

In particular, your definition of an "application" and your definition
of an "assembler". And that pretty much means writing Win32 GUI apps
with RosAsm. Therefore, you've excluding pretty much everyone who
posts here except yourself and Wolfgang.


Which, evidently, does
not limit to the couple of Regular RosAsm users, like Half,
Guga, and such, who write daily with RosAsm, as a production
environment.

Forgive me. You can added "outtabee" to the list, too.



Do not simulate forgetting that, when a FASM user comes here,
- which is quite exceptional, as long as they have poor
interrest with fronting a nerd like you -, this is always,
to show that you are a nerd. So was it for the talentuous
JohnFound and/or for VID, who never missed to push your head
into your own barril of ***.

Really?
I've gone back and read their posts.
You've really got a strange mind to interpret those posts the way you
have.

Indeed, your interactions with these individuals seems to be the ones
in question,
e.g.

http://groups.google.com/group/alt.lang.asm/browse_frm/thread/de3659a8719038e/ee3baddc1f22df0f?lnk=gst&q=JohnFound&rnum=1&hl=en#ee3baddc1f22df0f



Now let's take a look at what John Found has to say about the major
subject of this thread (as long as you've brought John into this
dicussion). This thread, of course, is just a rehash of many identical
ones that have come before it. I'm currently looking at this one
started by NoDot three years ago:

http://groups.google.com/group/alt.lang.asm/browse_frm/thread/81ec3bc3930ef9d0/8acab3e4b7e1b9a0?lnk=gst&q=JohnFound&rnum=151&hl=en#8acab3e4b7e1b9a0

As the very second post, John had this to say about what is and what
is not an assembler:



NoDot <no_...@xxxxxxxxxxxxxxxxxxx> wrote:

This thread is about the catagories of assembly languages.
It is *NOT* about their implimentations, whatever they may be.



The main problem in these type of classifications is that they
are not based on the internal nature of the assemblers but on
personal feelings of the author thus producing absolutely
subjective opinion and causing simply the next flame war.

In this little article I will use following terminology
about compilers:
- Translator - program that provides translation of human
readable code (source text) to the machine executable form.
There are two types of translators:
1. Interpreters - they executes the program in the moment of
translation.
2. Compilers - they translate the program without execution
and (usually) stores the machine executable form for later
translation.


What will be the result if we try more scientific approach?
We can see even on first sight, that every so called assembler,
actually contains at least three _independent_ modules:


1. compile time language interpreter (CTL)
2. native assembly language compiler (ALC)
3. data definition language compiler (DDL)


These modules process the source file separately or simultaneously,
but independenly from each other. In some cases you even can use one
of the modules instead of other to generate the same code.


Let examine every of these modules in details:


1. Compile time language interpreter (CTL) - aka "macro language" -
this is (in known cases)interpreted language usually aimed to modify
the source code before actual assembling. This language is
independent
from the assembler and can have any syntax the assembly author
prefer.
In most cases, CTL is created to be as simple as possible and in the
same time as powerfull as possible. Also very important is the speed
of executing of this language.


2. native assembly language compiler (ALC) processes only the part of
the code that contains native processor instructions. We have to
consider
assembly instructions are those defined in the processor manuals.


Of course the syntax may differs in different assembler, but
important
thing is correspondence with the machine language instructions.


For example, assembler may use "op1 = op2" instead of "mov op1, op2".


If we have instruction: "eax = ebx" and assembler translates it to
"8bh, 0c3h" machine instruction, defined for x86 processors as "mov
eax,ebx"
everything is ok and this process can be considering as "assembling".


But if assembler allows using "es = ds" and translates it as "1eh,
07h" -
this process is not true assembling, because there is no such
instruction
in x86 processors that moves ds to es. There are TWO instructions
"push ds"
and "pop es".
So, to make this translation assembler have to make some other than
"assembling" processing on the source code. Usually this processing
can
be considering as "preprocessing" - modification of the source text
before
actuall translation.
Note that it isn't improtant how actually assembler provides this
translation -
with internal macroses, CTL, special ALC, etc.


3. Data definition language (DDL) - this language is aimed to produce
the
binary part of the code that contains data and thus can't be created
by the
ALC.


Usually the syntax of the data definition language is consistent to
the
syntax of the assembler - statements as "db, dw, dd" etc. actually
are
pseudo instructions that have binary opcodes depending of the data
they
defines.


Actually, data definition language is processor independent language
and
assembler authors have to treat it as such. We can't classify
assemblers
by their DDL at all, because DDL have nothing to do with assembly
language.


Well, at the end, my definition of the assembler. It is based only on
second
part of assembler - "assembly language compiler" because the CTL and
DDL
are processor independent languages and have nothing to do with
assembler.


Definition:
If the ALC of the compiler provides true translation of the source
code
to the machine instructions without internal interpretation other
than
provided by the processor manufacturer, it can be considered as
"assembler".
<<<<<<<<<<

Though I don't particularly agree with everything John Found has to
say, I would hardly characterize his response (and follow ons) as you
have.

In any case, those interested in reading this thread would do well to
read the reference I've provided and many others just like it that
have littered ALA for several years now. It's fun to see that the
arguments haven't changed one bit in all this time. There are still
the people who fail to see that you cannot define a language by its
implementation and trying to define an assembler based on what it does
*not* do rather than based on what it *does* just doesn't work.
hLater,
Randy Hyde




.