Guten Morgen,
auf Wunsch einiger werde ich jetzt nochmal genauer in die Welt der Directives eintauchen, dieses Tutorial ist jetzt eher nichts mehr für Anfänger.
In dem anderen Thread wurde auch angesprochen, ich sollte was zu dem Compiler sagen, wie er das verarbeitet. Aber dazu gibt es meiner Meinung nach nicht so viel zu sagen er verarbeitet die Directives vor allem anderen, weil es der "Hard Code" ist und daher sind diese Directives auch sehr statisch.
#pragma
Dieses #pragma kann die .amx Datei verändern, wenn man mit #pragma oder #emit arbeitet nennt man dies auch meistens amx-scripting.
Ich mache mal eine kurze Erklärung für die wichtigsten Verwendungen für #pragma 
Fangen wir an:
#pragma deprecated
Aber was macht das und was soll das bringen ?!
Hier mal ein kleines Szenaro:
new var = 5;
#pragma deprecated var
main(){
printf("Wert: %d",var);
}
Dann erhalten wir einen Warning: 
Das passiert weil wir die Variable var nach dem #pragma deprecated unbrauchbar gemacht wird.
Was es bringt:
This is mostly useful for functions to preserve backwards compatability while updating the API.Nun zu der Nächsten Funktion:
#pragma dynamic
Dies sollte man nur nutzen, wenn der Memory Speicher voll ist, dann kommt meist so eine Warnung:
Header size: 112 bytesCode size: 88 bytesData size: 200 bytesStack/heap size: 16384 bytes; estimated max. usage=6456 cells (25824 bytes)Total requirements: 16784 bytes
Dies passiert bei den meisten GF's, weil dort zu viele Locale Variablen einen zu großen Array besitzen.
Dort könnte man dann ein #pragma dynamic reinsetzen, das würde dann so aussehen:
#pragma dynamic 25824
und diese Warning Tabelle da oben würde verschwinden 
Als nächstes hätten wir noch solche Sachen:
#pragma tabsize
Jeder kennt diese Fehlermeldung: 
Sie entstehen, wenn man einen Codeschnipsel falsch einrückt.
Man nutzt zum einrücken immer den Tabulator, doch meistens machen das viele Anfänger nicht und für die ist dieses #pragma eine Goldgrube, da dieses Directive in der .amx-Datei die tabsize = tablänge / größe automatisch einrückt.
Es ist am besten das zu verwenden:
#pragma tabsize 0
Dann wird die Länge von den Tabs auf 0 gesetzt und alles ist in der .amx Datei eingerückt und der Compiler zeigt keine Warnings mehr (hier erkennt man, dass die pre-processoren vor dem "Rest Code" compiliert werden und dann erst die Erros/Warnings angezeigt werden !).
Da gibt es noch eine weitere Funktion, mit der man Pawn ganz anders wird:
#pragma semicolon
Diese Funktion ermöglicht es in Pawn ohne ' ; ' zu arbeiten !
Hier mal ein Beispiel:
#pragma semicolon 0
new var
var = 5
printf("Var: %d",var)
return 1
Dies würde ohne Errors funktionieren (Nicht sehr zu empfehlen, da es schnell zur Unübersichtlichkeit führt !
Nun gehen wir mit #pragma langsam zum Ende:
Zunächst:
#pragma unused
Dieses Directive ist ähnlich wie stock. Nur man kann nicht immer stock nutzen und da wo man stock nicht nutzen kann, benutzt man #pragma unused.
Wir nehmen mal folgendes Szenario:
public OnGameModeInit() {
//Haha mir ist so langweilig ich mach eine variable die ich nicht nutze
new var;
return 1;
}
Da kommt folgender Warnig: 
Da können wir nämlich kein stock nutzen, da es eine lokale Variable ist und deshalb nutzen wir #pragma, das sähe dann so aus:
public OnGameModeInit() {
//Haha mir ist so langweilig ich mach eine variable die ich nicht nutze
new var;
#pragma unused var
return 1;
}
und der Warning ist weg.
PS: Es gibt noch viel viel mehr Funktionen mit #pragma aber die die am meisten verwendet werden sind diese.
#emit
So nun zu dem Nächsten und kompliziertesten Directive !
Fangen wir mal einfach an:
new var=5;
#emit LOAD.S.pri var
#emit ADD
".S" steht für "stack" "pri" steht für "primary register""ADD" schreibt das Ergebnis in den primary register
So würde #emit aber noch keinen Sinn machen 
Ich zeige mal ein Rechenbeispiel:
new a = 2,
b = 5,
c = 0;
#emit LOAD.S.pri a //Lädt a in den "primary register"
#emit LOAD.S.alt b //Lädt b in den "alternate register"
#emit ADD //addiert die zahlen und lädt das Ergebnis in den primary register
#emit STOR.S.pri c //Kopiert das Ergebnis aus dem primary register in c
c hätte also am Ende einen Wert von 7 !
PS: Dies funktioniert nur auf Lokaler Ebene nicht auf Globaler !
Wir können Variablen auch einen direkten Wert mit #emit geben, sähe dann so aus:
new var;
#emit CONST.pri 2
#emit STOR.S.pri var
var hätte jetzt den Wert 2.
Natürlich können wir auch negative Werte erstellen:
new var;
#emit CONST.pri 2
#emit NEG
#emit STOR.S.pri var
var hätte jetzt den Wert -2 !
So das war eine kleine Einführung mit Integern, ich zeige mal was zu Strings/Arrays:
new str[2][4] = {
{'W', 'a', 's', '?'},
{'\0', 'H', 'i', '\0'}
};
#emit CONST.pri str //gibt die addresse vom start des arrays
#emit ADD.C 4 //Hier der pointer in die 2. Zeile
#emit MOVE.alt //zwischen speicher im alternate register
#emit LOAD.I //Lädt die daten .I = indirect
#emit ADD.C 4//Hier pointer für das ende der 2. Zeile
#emit STOR.I //speichert es indirekt
printf("%s", str[0]); //printet: "Was?"
printf("%s", str[1]); //printet: "Hi"
So, das war eine ganz kurze Einführung in #emit, dieser Directive ist noch weit aus komplizierter wie ich ihn hier dargestellt habe, für eine 100% genaue Definition, bitte hier klicken: http://forum.sa-mp.com/showthread.php?t=315531 //von Y_LESS
Zu meinem 1. Tutorial über Makros: [ SCRIPTING ] Directives / Makros (pre-processor)
Ich hoffe die Mühe hat sich gelohnt euch so ein bisschen zu informieren, bitte ein Feedback
mfg. 
