Groovy (52)

44 Name: #!/usr/bin/anonymous : 2008-10-27 20:52 ID:QE2i++lf

>If .NET compilers first wrote CIL assembly mnemonics into a text file and passed them to an assembler, then it would make languages like LISP difficult to implement.

No.

First there is no "If .Net compilers...", what you described is how .Net high level language compilers work.

>Since .NET has the APIs that make LISP easy to implement, this must not be true.

What you just said is compiling a high level language like lisp to a machine (virtual in this case) assembly language would make the language difficult to implement.

That's makes no sense. By your argument we can conclude every high level computer programming language is difficult to implement.

But you say that is not true because lisp is easy to implement. You then go on to say that it is easy to implement because of magic.

>Since .NET has the APIs that make LISP easy to implement, this must not be true.

APIs that must be written with the compilers own API implementation according to the specs. This just happens to make one feature you point out easy to implement.

>There is a plain-text assembly format for .NET. Few people actually use it when making compilers because there are better APIs.

What magic is this? .Net understands all languages through API calls?

System.Runtime.CompilerServices don't have a "magic" method that compiles any given string of arbitrary characters to bytecode.

You keep saying there is some magic translation from high level languge to bytecode through some existing API that understands everything.

>There is a plain-text assembly format for JVM.

Format implies some sort of formal specification defining the format. You have already forgotten the link to the page on Sun's own website that tells you exactly that there is no standard formal assembly language for the JVM. So not only is that statement false, it was already sourced and covered.

>Your PC will execute anything you put under its instruction pointer- whether it comes in a text file or not.

You just said that the text file of assembly instructions is directly executable by your machines processor. That is just stupid. The binary of the ASCII codes that make up a text file are not the same binary used for instructions.

Also, and again, those assembly language files contain symbols that are not instructions for the processor.

>You haven't demonstrated that x86 asm files are any different than IL asm files in any way that they aren't also different from ppc asm files.

You are having huge problems following along. I didn't make a distinction there. I brought up x86 asm because it uses a well known macro assembler language that contains symbols that are not machine instructions. If the asm contains symbols that are not executable, then the asm is not executable. Once assembled and those symbols are interpreted by the assembler, it is executable by the machine.

CIL contains symbols that are not instructions for the .Net runtime. CIL files are not executable binaries.

Java assembler may or may not include symbols, who the fuck knows. It's up to you I guess. Either way, the binary for a file that has created an arbitrary asm like language for bytcode is not executable by the JVM.

I can't believe I just had to explain that by repeating concepts already discussed and spoon feeding them together.

Name: Link:
Leave these fields empty (spam trap):
More options...
Verification: