Eigner Compiler

[simon1997]

Hallo, weiß wer, wie ich einen eigenen compiler für meine eigene Programiersprache mache?

 

[Nico Graichen]

Hi

ERstmal hab ich das Thema verschoben, in der Tutorials-Inbox hat das nix zu suchen!

Zum Thema:
Ein Kompiler ist eine Anwendung, die für eine bestimmte Sprache Quellcode parst und interpretiert und diesen dann in maschinennahe Sprache übersetzt. Kurz, ohne Assembler-Kenntnisse kommst du nicht weiter.

Ich finde es jedoch höchst interessant, eine eigene Programmiersprache zu entwickeln, ohne sich mit dem Thema Compilerbau auseinanderzusetzen

 

[master bratack]

Son quatsch! Wer dafür Assembler nimmt kann Photoshop in 0 und 1en programmieren. Nim C/C++, aber vorher, lies dich ein zum thema Compilerbau

 

[m0dpad]

Natürlich braucht man auch Assembler oder ähnliches für einen Compiler, das macht ja genau ein Compiler! Ein C Compiler übersetzt C in Assembler bzw. Maschinensprache.

@Topic : Deine Frage ist schwachsinnig eigentlich, das Ganze ist hoch kompliziert. Mal eben schnell eine eigene Programmiersprache entwickeln lol!

 

[Muepe32]

Die Frage ist natürlich was für dich ein Compiler ist. Muss direkt eine ausführbare Datei dabei entstehen? Wäre es nicht auch möglich C-Code zu generieren aus deiner Sprache?

Falls dem so ist, dann könntest du zum Beispiel mal anfangen gewisse Konzepte deiner Sprache zu überlegen. Daraus kannst du dann Regeln ableiten. Diese kannst du beispielsweise in einem Syntaxbaum dann umsetzen. Die entsprechenden Blätter kannst du dann in weiteren Code umwandeln.

Ich habe mal eine einfache Sprache "entwickelt" welche auf sehr simplen Regeln basiert. Ein Beispiel ist folgendes:

Register(1) << Input
Register(2) << Input
Register(3) << Register(1) + Register(2)
Output << Register(3)

Dabei wurde dann diese Code in kompilierbaren C-Code umgewandelt und man konnte direkt einen standalone Compiler auswählen (wie cl.exe oder gcc) somit ist dann auch gleich eine Exe-Datei daraus entstanden.

Das ist sicher ein guter Anfang um mit dem entwickeln von Sprachen anzufangen. Macht ausserdem auch sehr viel Spass

 

[Nico Graichen]

Son quatsch! Wer dafür Assembler nimmt kann Photoshop in 0 und 1en programmieren. Nim C/C++, aber vorher, lies dich ein zum thema Compilerbau

Vorsicht mit deinem Ton! Der Output eines Compilers ist Maschinencode. Der schreibt sich mit C/C++ aber weniger gut! ;-) Also wäre Assembler-Kenntnisse hier angebracht.
Große Teile des Compilers können sicherlich in C geschrieben werden, an Kenntnissen einer Maschinesprache kommt man trotzdem nicht vor bei

 

[master bratack]

Lexikalische Analyse etc. kann man doch in C machen, naja ich würde sagen alles.
Als Output kann man doch jede Sprache kann man eigentlich nehmen welche man will, wobei traditionele Compiler nach ASM übersetzten. Man kann theoretisch doch gleich in Ausführbare dateien übersetzten, nicht? sonst müßte ja der erste ASM Compiler in 0 & 1 programmiert worden sein

 

[sheel]

Lexikalische Analyse etc. kann man doch in C machen, naja ich würde sagen alles.

Natürlich, da hat doch auch keiner was dagegen.

wobei traditionele Compiler nach ASM übersetzten. Man kann theoretisch doch gleich in Ausführbare dateien übersetzten, nicht?

Also, bei meinem Visual Studio machen mir Compiler und Linker eine exe, und keine .asm-Datei.

sonst müßte ja der erste ASM Compiler in 0 & 1 programmiert worden sein

Wer sagt denn, dass das nicht so war?
Ich war ja nicht dabei, aber wenn man eine Assembler machen will, ohne irgend ein derartiges Hilfsmittel zu haben...denk ich mal.

Gruß

 

[master bratack]

Okay, das da ne exe raus kommt ist normal. Du musst dem Compiler sagen das er nur Compilieren soll, niicht assemblieren & linken.
Als C++ programmierer geb ich folgendes BSP:
DIe Datei m.cpp

#include <iostream>
using namespace std;
int main(void){
	cout << "Hallo Welt" << endl;
}

als compiler nehmen wir g++, also den C++ Compiler der GCC

mit

g++ m.cpp -o MainBSP

Wird das Proramm erzeugt (bei mir keine Exe, weil ich Linux nutze). So gucken wir mal bei g++ --help.
Da fnden wir

[...]
-S Compile only; do not assemble or link

[..]

Also nemen wir diese Option.

g++ m.cpp

Es müßte eine datei namens "m.s" erzeugt werden. Die öffnen wir & finden den Asm code.

	.file	"m.cpp"
	.local	_ZStL8__ioinit
	.comm	_ZStL8__ioinit,1,1
	.section	.rodata
.LC0:
	.string	"Hallo Welt"
	.text
.globl main
	.type	main, @function
main:
.LFB963:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	andl	$-16, %esp
	subl	$16, %esp
	movl	$.LC0, 4(%esp)
	movl	$_ZSt4cout, (%esp)
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
	movl	$_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, 4(%esp)
	movl	%eax, (%esp)
	call	_ZNSolsEPFRSoS_E
	movl	$0, %eax
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE963:
	.size	main, .-main
	.type	_Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
.LFB972:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	cmpl	$1, 8(%ebp)
	jne	.L2
	cmpl	$65535, 12(%ebp)
	jne	.L2
	movl	$_ZStL8__ioinit, (%esp)
	call	_ZNSt8ios_base4InitC1Ev
	movl	$_ZNSt8ios_base4InitD1Ev, %eax
	movl	$__dso_handle, 8(%esp)
	movl	$_ZStL8__ioinit, 4(%esp)
	movl	%eax, (%esp)
	call	__cxa_atexit
.L2:
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE972:
	.size	_Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
	.type	_GLOBAL__I_main, @function
_GLOBAL__I_main:
.LFB973:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	movl	%esp, %ebp
	.cfi_offset 5, -8
	.cfi_def_cfa_register 5
	subl	$24, %esp
	movl	$65535, 4(%esp)
	movl	$1, (%esp)
	call	_Z41__static_initialization_and_destruction_0ii
	leave
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE973:
	.size	_GLOBAL__I_main, .-_GLOBAL__I_main
	.section	.ctors,"aw",@progbits
	.align 4
	.long	_GLOBAL__I_main
	.weakref	_ZL20__gthrw_pthread_oncePiPFvvE,pthread_once
	.weakref	_ZL27__gthrw_pthread_getspecificj,pthread_getspecific
	.weakref	_ZL27__gthrw_pthread_setspecificjPKv,pthread_setspecific
	.weakref	_ZL22__gthrw_pthread_createPmPK14pthread_attr_tPFPvS3_ES3_,pthread_create
	.weakref	_ZL20__gthrw_pthread_joinmPPv,pthread_join
	.weakref	_ZL21__gthrw_pthread_equalmm,pthread_equal
	.weakref	_ZL20__gthrw_pthread_selfv,pthread_self
	.weakref	_ZL22__gthrw_pthread_detachm,pthread_detach
	.weakref	_ZL22__gthrw_pthread_cancelm,pthread_cancel
	.weakref	_ZL19__gthrw_sched_yieldv,sched_yield
	.weakref	_ZL26__gthrw_pthread_mutex_lockP15pthread_mutex_t,pthread_mutex_lock
	.weakref	_ZL29__gthrw_pthread_mutex_trylockP15pthread_mutex_t,pthread_mutex_trylock
	.weakref	_ZL31__gthrw_pthread_mutex_timedlockP15pthread_mutex_tPK8timespec,pthread_mutex_timedlock
	.weakref	_ZL28__gthrw_pthread_mutex_unlockP15pthread_mutex_t,pthread_mutex_unlock
	.weakref	_ZL26__gthrw_pthread_mutex_initP15pthread_mutex_tPK19pthread_mutexattr_t,pthread_mutex_init
	.weakref	_ZL29__gthrw_pthread_mutex_destroyP15pthread_mutex_t,pthread_mutex_destroy
	.weakref	_ZL30__gthrw_pthread_cond_broadcastP14pthread_cond_t,pthread_cond_broadcast
	.weakref	_ZL27__gthrw_pthread_cond_signalP14pthread_cond_t,pthread_cond_signal
	.weakref	_ZL25__gthrw_pthread_cond_waitP14pthread_cond_tP15pthread_mutex_t,pthread_cond_wait
	.weakref	_ZL30__gthrw_pthread_cond_timedwaitP14pthread_cond_tP15pthread_mutex_tPK8timespec,pthread_cond_timedwait
	.weakref	_ZL28__gthrw_pthread_cond_destroyP14pthread_cond_t,pthread_cond_destroy
	.weakref	_ZL26__gthrw_pthread_key_createPjPFvPvE,pthread_key_create
	.weakref	_ZL26__gthrw_pthread_key_deletej,pthread_key_delete
	.weakref	_ZL30__gthrw_pthread_mutexattr_initP19pthread_mutexattr_t,pthread_mutexattr_init
	.weakref	_ZL33__gthrw_pthread_mutexattr_settypeP19pthread_mutexattr_ti,pthread_mutexattr_settype
	.weakref	_ZL33__gthrw_pthread_mutexattr_destroyP19pthread_mutexattr_t,pthread_mutexattr_destroy
	.ident	"GCC: (SUSE Linux) 4.5.0 20100604 [gcc-4_5-branch revision 160292]"
	.section	.comment.SUSE.OPTs,"MS",@progbits,1
	.string	"ospwg"
	.section	.note.GNU-stack,"",@progbits

Das macht der Compiler. Das Linken & assemblieren gehören nicht zu seinem Job