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

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

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

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!

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:

Code :

1 2 3 4

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

Zitat von 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

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

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

Zitat von master bratack

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

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

Zitat von master bratack

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.

Zitat von master bratack

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ß

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

Code cpp:

1 2 3 4 5

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

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

mit

Code :

1	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.

Code :

1

g++ m.cpp

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

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

.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