Mercurial > hg > toybox
view toys/pending/sh.c @ 912:f4f5132d5ac7
Stat cleanup.
From the mailing list:
Ok, first thing: clean up the help text. I realize what's there is copied verbatim from the man page, but that man page sucks. ("modification time" vs "change time"?) Took a bit of finagling to fit it in 80x24, but just made it.
GLOBALS() indent was still tab, change to two spaces. And I tend to put a blank line between options lib/args.c automatically fills out and normal globals.
We never do anything with date_stat_format() but immediately print it, might as well make the function do it.
The types[] array in do_stat() is a rough edge. Hmmm... there's no else case that sets the type in case it was unknown (such as 0). In theory, this never happens. In practice it means I can cheat slightly, given this observation:
$ find linux -name stat.h | xargs grep 'S_IF[A-Z]*[ \t]'
linux/include/uapi/linux/stat.h:#define S_IFMT 00170000
linux/include/uapi/linux/stat.h:#define S_IFSOCK 0140000
linux/include/uapi/linux/stat.h:#define S_IFLNK 0120000
linux/include/uapi/linux/stat.h:#define S_IFREG 0100000
linux/include/uapi/linux/stat.h:#define S_IFBLK 0060000
linux/include/uapi/linux/stat.h:#define S_IFDIR 0040000
linux/include/uapi/linux/stat.h:#define S_IFCHR 0020000
linux/include/uapi/linux/stat.h:#define S_IFIFO 0010000
I.E. the only place the I_IFBLAH constants occur a stat.h header in current linux code is in the generic stuff, it doesn't vary per target. (The access permission bits are actually subtly standardized in posix due to the command line arguments to chmod, although I'm sure cygwin finds a way to break. But the type fields, not so much. But linux has to be binary compatible with itself foreverish, and that's all I really care about.)
So, we have ALMOST have this going by twos, except there's no 8 and there is a 1. so let's make the 1 the default, feed a blank string into the 8... No, duh: octal. So it's actually 2, 4, 6, 8, 10, 12. So make the loop look like:
filetype = statf->st_mode & S_IFMT;
TT.ftname = types;
for (i = 1; filetype != (i*8192) && i < 7; i++)
TT.ftname += strlen(TT.ftname)+1;
Yes that's linux-specific, and I think I'm ok with that.
Printing all zeroes and pretending that's nanosecond resolution... either support it or don't. Let's see, supporting it is stat->st_atim.tv_nsec and similar... no mention of nanoseconds in strftime() (et tu, posix2008?) so pass it as a second argument and append it by hand... (Need to test that against musl...)
When we hit an unknown type in print_it() we print the literal character, which is right for %% but what about an unknown option?
$ stat -c %q /
?
Eh, I guess that's a "don't care". It didn't die with an error, that's the important thing.
I have a horrible idea for compressing the switch/case blocks, but should probably check this in and get some sleep for right now...
author | Rob Landley <rob@landley.net> |
---|---|
date | Tue, 28 May 2013 00:28:45 -0500 |
parents | 134d337ea880 |
children | 1fa185766188 |
line wrap: on
line source
/* sh.c - toybox shell * * Copyright 2006 Rob Landley <rob@landley.net> * * The POSIX-2008/SUSv4 spec for this is at: * http://opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html * and http://opengroup.org/onlinepubs/9699919799/utilities/sh.html * * The first link describes the following shell builtins: * * break colon continue dot eval exec exit export readonly return set shift * times trap unset * * The second link (the utilities directory) also contains specs for the * following shell builtins: * * alias bg cd command fc fg getopts hash jobs kill read type ulimit * umask unalias wait * * Things like the bash man page are good to read too. * * TODO: // Handle embedded NUL bytes in the command line. USE_SH(NEWTOY(cd, NULL, TOYFLAG_NOFORK)) USE_SH(NEWTOY(exit, NULL, TOYFLAG_NOFORK)) USE_SH(NEWTOY(sh, "c:i", TOYFLAG_BIN)) USE_SH(OLDTOY(toysh, sh, "c:i", TOYFLAG_BIN)) config SH bool "sh (toysh)" default n help usage: sh [-c command] [script] Command shell. Runs a shell script, or reads input interactively and responds to it. -c command line to execute config SH_TTY bool "Interactive shell (terminal control)" default n depends on SH help Add terminal control to toysh. This is necessary for interactive use, so the shell isn't killed by CTRL-C. config SH_PROFILE bool "Profile support" default n depends on SH_TTY help Read /etc/profile and ~/.profile when running interactively. Also enables the built-in command "source". config SH_JOBCTL bool "Job Control (fg, bg, jobs)" default n depends on SH_TTY help Add job control to toysh. This lets toysh handle CTRL-Z, and enables the built-in commands "fg", "bg", and "jobs". With pipe support, enable use of "&" to run background processes. config SH_FLOWCTL bool "Flow control (if, while, for, functions)" default n depends on SH help Add flow control to toysh. This enables the if/then/else/fi, while/do/done, and for/do/done constructs. With pipe support, this enables the ability to define functions using the "function name" or "name()" syntax, plus curly brackets "{ }" to group commands. config SH_QUOTES bool "Smarter argument parsing (quotes)" default n depends on SH help Add support for parsing "" and '' style quotes to the toysh command parser, with lets arguments have spaces in them. config SH_WILDCARDS bool "Wildcards ( ?*{,} )" default n depends on SH_QUOTES help Expand wildcards in argument names, ala "ls -l *.t?z" and "rm subdir/{one,two,three}.txt". config SH_PROCARGS bool "Executable arguments ( `` and $() )" default n depends on SH_QUOTES help Add support for executing arguments contianing $() and ``, using the output of the command as the new argument value(s). (Bash calls this "command substitution".) config SH_ENVVARS bool "Environment variable support" default n depends on SH_QUOTES help Substitute environment variable values for $VARNAME or ${VARNAME}, and enable the built-in command "export". config SH_LOCALS bool "Local variables" default n depends on SH_ENVVARS help Support for local variables, fancy prompts ($PS1), the "set" command, and $?. config SH_ARRAYS bool "Array variables" default n depends on SH_LOCALS help Support for ${blah[blah]} style array variables. config SH_PIPES bool "Pipes and redirects ( | > >> < << & && | || () ; )" default n depends on SH help Support multiple commands on the same command line. This includes | pipes, > >> < redirects, << here documents, || && conditional execution, () subshells, ; sequential execution, and (with job control) & background processes. config SH_BUILTINS bool "Builtin commands" default n depends on SH help Adds the commands exec, fg, bg, help, jobs, pwd, export, source, set, unset, read, alias. config EXIT bool default n depends on SH help usage: exit [status] Exit shell. If no return value supplied on command line, use value of most recent command, or 0 if none. config CD bool default n depends on SH help usage: cd [path] Change current directory. With no arguments, go to $HOME. config CD_P bool # "-P support for cd" default n depends on SH help usage: cd [-PL] -P Physical path: resolve symlinks in path. -L Cancel previous -P and restore default behavior. */ #define FOR_sh #include "toys.h" GLOBALS( char *command; ) // A single executable, its arguments, and other information we know about it. #define SH_FLAG_EXIT 1 #define SH_FLAG_SUSPEND 2 #define SH_FLAG_PIPE 4 #define SH_FLAG_AND 8 #define SH_FLAG_OR 16 #define SH_FLAG_AMP 32 #define SH_FLAG_SEMI 64 #define SH_FLAG_PAREN 128 // What we know about a single process. struct command { struct command *next; int flags; // exit, suspend, && || int pid; // pid (or exit code) int argc; char *argv[0]; }; // A collection of processes piped into/waiting on each other. struct pipeline { struct pipeline *next; int job_id; struct command *cmd; char *cmdline; // Unparsed line for display purposes int cmdlinelen; // How long is cmdline? }; // Parse one word from the command line, appending one or more argv[] entries // to struct command. Handles environment variable substitution and // substrings. Returns pointer to next used byte, or NULL if it // hit an ending token. static char *parse_word(char *start, struct command **cmd) { char *end; // Detect end of line (and truncate line at comment) if (CFG_SH_PIPES && strchr("><&|(;", *start)) return 0; // Grab next word. (Add dequote and envvar logic here) end = start; while (*end && !isspace(*end)) end++; (*cmd)->argv[(*cmd)->argc++] = xstrndup(start, end-start); // Allocate more space if there's no room for NULL terminator. if (!((*cmd)->argc & 7)) *cmd=xrealloc(*cmd, sizeof(struct command) + ((*cmd)->argc+8)*sizeof(char *)); (*cmd)->argv[(*cmd)->argc] = 0; return end; } // Parse a line of text into a pipeline. // Returns a pointer to the next line. static char *parse_pipeline(char *cmdline, struct pipeline *line) { struct command **cmd = &(line->cmd); char *start = line->cmdline = cmdline; if (!cmdline) return 0; if (CFG_SH_JOBCTL) line->cmdline = cmdline; // Parse command into argv[] for (;;) { char *end; // Skip leading whitespace and detect end of line. while (isspace(*start)) start++; if (!*start || *start=='#') { if (CFG_SH_JOBCTL) line->cmdlinelen = start-cmdline; return 0; } // Allocate next command structure if necessary if (!*cmd) *cmd = xzalloc(sizeof(struct command)+8*sizeof(char *)); // Parse next argument and add the results to argv[] end = parse_word(start, cmd); // If we hit the end of this command, how did it end? if (!end) { if (CFG_SH_PIPES && *start) { if (*start==';') { start++; break; } // handle | & < > >> << || && } break; } start = end; } if (CFG_SH_JOBCTL) line->cmdlinelen = start-cmdline; return start; } // Execute the commands in a pipeline static void run_pipeline(struct pipeline *line) { struct toy_list *tl; struct command *cmd = line->cmd; if (!cmd || !cmd->argc) return; tl = toy_find(cmd->argv[0]); // Is this command a builtin that should run in this process? if (tl && (tl->flags & TOYFLAG_NOFORK)) { struct toy_context temp; jmp_buf rebound; // This fakes lots of what toybox_main() does. memcpy(&temp, &toys, sizeof(struct toy_context)); memset(&toys, 0, sizeof(struct toy_context)); if (!setjmp(rebound)) { toys.rebound = rebound; toy_init(tl, cmd->argv); tl->toy_main(); } cmd->pid = toys.exitval; if (toys.optargs != toys.argv+1) free(toys.optargs); if (toys.old_umask) umask(toys.old_umask); memcpy(&toys, &temp, sizeof(struct toy_context)); } else { int status; cmd->pid = vfork(); if (!cmd->pid) xexec(cmd->argv); else waitpid(cmd->pid, &status, 0); if (CFG_SH_FLOWCTL || CFG_SH_PIPES) { if (WIFEXITED(status)) cmd->pid = WEXITSTATUS(status); if (WIFSIGNALED(status)) cmd->pid = WTERMSIG(status); } } return; } // Free the contents of a command structure static void free_cmd(void *data) { struct command *cmd=(struct command *)data; while(cmd->argc) free(cmd->argv[--cmd->argc]); } // Parse a command line and do what it says to do. static void handle(char *command) { struct pipeline line; char *start = command; // Loop through commands in this line for (;;) { // Parse a group of connected commands memset(&line,0,sizeof(struct pipeline)); start = parse_pipeline(start, &line); if (!line.cmd) break; // Run those commands run_pipeline(&line); llist_traverse(line.cmd, free_cmd); } } void cd_main(void) { char *dest = *toys.optargs ? *toys.optargs : getenv("HOME"); xchdir(dest); } void exit_main(void) { exit(*toys.optargs ? atoi(*toys.optargs) : 0); } void sh_main(void) { FILE *f; // Set up signal handlers and grab control of this tty. if (CFG_SH_TTY) { if (isatty(0)) toys.optflags |= 1; } f = *toys.optargs ? xfopen(*toys.optargs, "r") : NULL; if (TT.command) handle(TT.command); else { size_t cmdlen = 0; for (;;) { char *command = 0; if (!f) xputc('$'); if (1 > getline(&command, &cmdlen, f ? f : stdin)) break; handle(command); free(command); } } toys.exitval = 1; }