So erstellen Sie eine einfache Schale in C?
In diesem Tutorial führt Sie die Phasen der Erstellung einer unabhängigen einfachen Shell in C. Nach Abschluss dieses Tutorials sollten Sie ein besseres Verständnis für die verschiedenen Prozesse und Funktionen sowie eine klare, praktikable Möglichkeit haben, selbst zu codieren.
Was ist die grundlegende Lebensdauer der Schale??
Während ihrer Lebensdauer erledigt eine Hülle drei Hauptaufgaben.
- Initialisieren: In dieser Phase wird eine typische Shell gelesen und ihre Konfigurationsdateien ausgeführt. Diese verändern das Verhalten der Shell.
- Interpretieren: Die Shell liest dann Befehle von „Stdin“ und führt sie aus.
- Beenden: Nach der Ausführung ihrer Befehle führt die Shell einen der Herunterfahrenbefehle aus, befreit jeden Speicher und endet endet.
Diese Phasen sind allgemein und können für eine Vielzahl von Programmen anwendbar sein, aber wir werden sie als Grundlage für unsere Shell verwenden. Unsere Shell ist so grundlegend, dass es keine Konfigurationsdateien und keinen Heruntergangsbefehl gibt. Also werden wir einfach die Schleifenfunktion ausführen und dann beenden. Es ist jedoch wichtig zu beachten.
So erstellen Sie eine einfache Schale in C?
Wir werden eine grundlegende Shell in C erstellen, die die Grundlagen des Funktionierens demonstrieren wird. Da sein Ziel eher Demonstration als die Vollständigkeit oder sogar Fitness für den ungezwungenen Gebrauch ist, hat es eine Reihe von Einschränkungen, einschließlich
- Alle Befehle müssen in einer Zeile eingegeben werden.
- Die Whitespace muss zur Trennung von Argumenten verwendet werden.
- Es wird kein Whitespace zitieren oder entkommen.
- Es gibt keine Rohrleitungen oder Ausleger.
- Die einzigen integrierten Ins sind "CD", "Hilfe" und "Ausgang".
Schauen Sie sich nun ein C -Programm an, das eine einfache Hülle erstellt.
#enthalten#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int komal_cd (char ** args);
int komal_help (char ** args);
int komal_exit (char ** args);
char *bau_in_string [] =
"CD",
"Hilfe",
"Ausfahrt"
;
int (*bau_in_function []) (char **) =
& komal_cd,
& komal_help,
& komal_exit
;
int komal_builtins ()
return sizeof (bau_in_string) / sizeof (char *);
int komal_cd (char ** args)
if (args [1] == null)
fprintf (Stderr, "Komal: Erwartete Argument für" CD "\ n");
anders
if (chdir (args [1]) != 0)
Perror ("Komal");
Rückkehr 1;
int komal_help (char ** args)
int i;
printf ("Dies ist ein einfacher C -Shell -Build von Komal Batool \ n");
printf ("Geben Sie Programmnamen und Argumente ein und klicken Sie auf die Eingabetaste.\N");
printf ("Die folgenden sind in: \ n");
für (i = 0; i < komal_builtins(); i++)
printf (" %s \ n", basiert_in_string [i]);
printf ("Verwenden Sie den Befehl mAN, um Informationen zu anderen Programmen zu erhalten.\N");
Rückkehr 1;
int komal_exit (char ** args)
Rückkehr 0;
int komal_launch (char ** args)
PID_T PID;
int Status;
pid = fork ();
if (pid == 0)
if (execvp (args [0], args) == -1)
Perror ("Komal");
exit (exit_failure);
else if (pid < 0)
Perror ("Komal");
anders
Tun
WaitPID (PID & Status, Wuntrace);
während (!Wifexited (Status) && !Wifsignaled (Status));
Rückkehr 1;
int komal_execute (char ** args)
int i;
if (args [0] == null)
Rückkehr 1;
für (i = 0; i < komal_builtins(); i++)
if (strcmp (args [0], bau_in_string [i]) == 0)
return (*bau_in_function [i]) (args);
return komal_launch (args);
char *komal_read_line (void)
#ifdef komal_use_std_getline
char *line = null;
SSIZE_T BUFSIZE = 0;
if (getline (& line & bufsize, stdin) == -1)
if (feof (stdin))
exit (exit_success);
anders
Perror ("Komal: getline \ n");
exit (exit_failure);
Rückleitung;
#anders
#define komal_rl_bufsize 1024
int bufsize = komal_rl_bufsize;
int Position = 0;
char * buffer = malloc (sizeof (char) * bufsize);
int c;
Wenn (!Puffer)
fprintf (Stderr, "Komal: Zuweisungsfehler \ n");
exit (exit_failure);
während (1)
c = getChar ();
if (c == eof)
exit (exit_success);
sonst wenn (c == '\ n')
Puffer [Position] = '\ 0';
Rückpuffer;
anders
Puffer [Position] = C;
Position ++;
if (Position> = bufsize)
bufsize += komal_rl_bufsize;
buffer = realloc (buffer, bufsize);
Wenn (!Puffer)
fprintf (Stderr, "Komal: Zuweisungsfehler \ n");
exit (exit_failure);
#endif
#define komal_tok_bufsize 64
#define komal_tok_delim "\ t \ r \ n \ a"
char ** komal_split_line (char *line)
int bufsize = komal_tok_bufsize, Position = 0;
char ** tokens = malloc (bufsize *sizeof (char *));
char *token, ** tokens_backup;
Wenn (!Token)
fprintf (Stderr, "Komal: Zuweisungsfehler \ n");
exit (exit_failure);
token = strtok (Zeile, komal_tok_delim);
während (Token != Null)
Token [Position] = Token;
Position ++;
if (Position> = bufsize)
bufsize += komal_tok_bufsize;
tokens_backup = tokens;
tokens = realloc (tokens, bufsize * sizeof (char *));
Wenn (!Token)
kostenlos (tokens_backup);
fprintf (Stderr, "Komal: Zuweisungsfehler \ n");
exit (exit_failure);
token = strtok (null, komal_tok_delim);
Token [Position] = NULL;
Rückkehr -Token;
void Komal_loop (void)
char *line;
char ** args;
int Status;
Tun
printf (">");
line = komal_read_line ();
args = komal_split_line (Zeile);
status = komal_execute (args);
Freie Linie);
frei (args);
while (Status);
int main (int argc, char ** argv)
Komal_loop ();
return exit_success;
Code Beschreibung
Der obige Code ist eine einfache Implementierung einer in c geschriebenen Befehlszeilenschale. Die Hülle wird benannt "Komal", und es können integrierte Befehle wie "CD", "Hilfe" und "Beenden" sowie externe Befehle ausgeführt werden. Die Hauptfunktion des Programms ist die "Komal_loop" Funktion, die kontinuierlich abschließt und Eingaben vom Benutzer über die "Komal_read_line" Funktion, die Eingabe in individuelle Argumente mit dem aufteilt "Komal_split_line" Funktion und Ausführung des Befehls mit dem "Komal_execute" Funktion.
Der "Komal_execute" Funktion prüft, ob der Befehl ein integrierter Befehl ist. In diesem Fall wird die entsprechende integrierte Funktion ausgeführt. Wenn der Befehl kein integrierter Befehl ist, führt er einen externen Befehl aus, indem er einen untergeordneten Prozess aufgab und das angerufen wird "Execvp" Systemaufruf, um den Speicherplatz des Kinderprozesses durch das gewünschte Programm zu ersetzen.
Der "Komal_cd", "Komal_help", Und "Komal_exit" Funktionen sind die drei integrierten Funktionen, die vom Benutzer ausgeführt werden können. "Komal_cd" ändert das aktuelle Arbeitsverzeichnis, "Komal_help" Bietet Informationen über die Shell und ihre integrierten Befehle, und "Komal_exit" verlässt die Hülle.
Ausgang
Abschluss
Das Erstellen einer einfachen Shell in C beinhaltet das Verständnis, wie Sie Befehle analysieren und ausführen, Benutzereingaben und Ausgabe behandeln und Prozesse mithilfe von Systemaufrufen wie Fork und ExecVP verwalten können. Der Prozess des Erstellens einer Shell erfordert ein tiefes Verständnis der C -Programmiersprache C und des UNIX -Betriebssystems. Mit Hilfe der in der obigen Anleitung angegebenen Schritte und Beispiele kann jedoch eine einfache Shell erstellt werden, mit der Benutzereingaben verarbeitet und Befehle ausgeführt werden können.