/branches/dd/uspace/app/ash/bltin/echo.c |
---|
0,0 → 1,127 |
/* $NetBSD: echo.c,v 1.8 1996/11/02 18:26:06 christos Exp $ */ |
/*- |
* Copyright (c) 1991, 1993 |
* The Regents of the University of California. All rights reserved. |
* |
* This code is derived from software contributed to Berkeley by |
* Kenneth Almquist. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* 1. Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* 2. Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* 3. All advertising materials mentioning features or use of this software |
* must display the following acknowledgement: |
* This product includes software developed by the University of |
* California, Berkeley and its contributors. |
* 4. Neither the name of the University nor the names of its contributors |
* may be used to endorse or promote products derived from this software |
* without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
* SUCH DAMAGE. |
* |
* @(#)echo.c 8.1 (Berkeley) 5/31/93 |
*/ |
/* |
* Echo command. |
*/ |
#define main echocmd |
#ifdef _GNU_SOURCE |
#include <stdio.h> |
#include "../mystring.h" |
#else |
#include "bltin.h" |
#endif |
/* #define eflag 1 */ |
int |
main(argc, argv) char **argv; { |
register char **ap; |
register char *p; |
register char c; |
int nflag = 0; |
#ifndef eflag |
int eflag = 0; |
#endif |
ap = argv; |
if (argc) |
ap++; |
while ((p = *ap) != NULL && *p == '-') { |
if (equal(p, "-n")) { |
nflag = 1; |
} else if (equal(p, "-e")) { |
#ifndef eflag |
eflag = 1; |
#endif |
} else if (equal(p, "-E")) { |
#ifndef eflag |
eflag = 0; |
#endif |
} |
else break; |
ap++; |
} |
while ((p = *ap++) != NULL) { |
while ((c = *p++) != '\0') { |
if (c == '\\' && eflag) { |
switch (c = *p++) { |
case 'a': c = '\007'; break; |
case 'b': c = '\b'; break; |
case 'c': return 0; /* exit */ |
case 'e': c = '\033'; break; |
case 'f': c = '\f'; break; |
case 'n': c = '\n'; break; |
case 'r': c = '\r'; break; |
case 't': c = '\t'; break; |
case 'v': c = '\v'; break; |
case '\\': break; /* c = '\\' */ |
case '0': case '1': case '2': case '3': |
case '4': case '5': case '6': case '7': |
c -= '0'; |
if (*p >= '0' && *p <= '7') |
c = c * 8 + (*p++ - '0'); |
if (*p >= '0' && *p <= '7') |
c = c * 8 + (*p++ - '0'); |
break; |
default: |
p--; |
break; |
} |
} |
putchar(c); |
} |
if (*ap) |
putchar(' '); |
} |
if (! nflag) |
putchar('\n'); |
#ifdef _GNU_SOURCE |
fflush(stdout); |
if (ferror(stdout)) { |
clearerr(stdout); |
return 1; |
} |
#endif |
return 0; |
} |
/branches/dd/uspace/app/ash/bltin/test.c |
---|
0,0 → 1,583 |
/* $NetBSD: test.c,v 1.22 2000/04/09 23:24:59 christos Exp $ */ |
/* |
* test(1); version 7-like -- author Erik Baalbergen |
* modified by Eric Gisin to be used as built-in. |
* modified by Arnold Robbins to add SVR3 compatibility |
* (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket). |
* modified by J.T. Conklin for NetBSD. |
* |
* This program is in the Public Domain. |
*/ |
#include <sys/cdefs.h> |
#ifndef lint |
__RCSID("$NetBSD: test.c,v 1.22 2000/04/09 23:24:59 christos Exp $"); |
#endif |
#include <sys/types.h> |
#include <sys/stat.h> |
#include <unistd.h> |
#include <ctype.h> |
#include <errno.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <err.h> |
#ifdef __STDC__ |
#include <stdarg.h> |
#else |
#include <varargs.h> |
#endif |
/* test(1) accepts the following grammar: |
oexpr ::= aexpr | aexpr "-o" oexpr ; |
aexpr ::= nexpr | nexpr "-a" aexpr ; |
nexpr ::= primary | "!" primary |
primary ::= unary-operator operand |
| operand binary-operator operand |
| operand |
| "(" oexpr ")" |
; |
unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"| |
"-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S"; |
binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"| |
"-nt"|"-ot"|"-ef"; |
operand ::= <any legal UNIX file name> |
*/ |
enum token { |
EOI, |
FILRD, |
FILWR, |
FILEX, |
FILEXIST, |
FILREG, |
FILDIR, |
FILCDEV, |
FILBDEV, |
FILFIFO, |
FILSOCK, |
FILSYM, |
FILGZ, |
FILTT, |
FILSUID, |
FILSGID, |
FILSTCK, |
FILNT, |
FILOT, |
FILEQ, |
FILUID, |
FILGID, |
STREZ, |
STRNZ, |
STREQ, |
STRNE, |
STRLT, |
STRGT, |
INTEQ, |
INTNE, |
INTGE, |
INTGT, |
INTLE, |
INTLT, |
UNOT, |
BAND, |
BOR, |
LPAREN, |
RPAREN, |
OPERAND |
}; |
enum token_types { |
UNOP, |
BINOP, |
BUNOP, |
BBINOP, |
PAREN |
}; |
static struct t_op { |
const char *op_text; |
short op_num, op_type; |
} const ops [] = { |
{"-r", FILRD, UNOP}, |
{"-w", FILWR, UNOP}, |
{"-x", FILEX, UNOP}, |
{"-e", FILEXIST,UNOP}, |
{"-f", FILREG, UNOP}, |
{"-d", FILDIR, UNOP}, |
{"-c", FILCDEV,UNOP}, |
{"-b", FILBDEV,UNOP}, |
{"-p", FILFIFO,UNOP}, |
{"-u", FILSUID,UNOP}, |
{"-g", FILSGID,UNOP}, |
{"-k", FILSTCK,UNOP}, |
{"-s", FILGZ, UNOP}, |
{"-t", FILTT, UNOP}, |
{"-z", STREZ, UNOP}, |
{"-n", STRNZ, UNOP}, |
{"-h", FILSYM, UNOP}, /* for backwards compat */ |
{"-O", FILUID, UNOP}, |
{"-G", FILGID, UNOP}, |
{"-L", FILSYM, UNOP}, |
{"-S", FILSOCK,UNOP}, |
{"=", STREQ, BINOP}, |
{"!=", STRNE, BINOP}, |
{"<", STRLT, BINOP}, |
{">", STRGT, BINOP}, |
{"-eq", INTEQ, BINOP}, |
{"-ne", INTNE, BINOP}, |
{"-ge", INTGE, BINOP}, |
{"-gt", INTGT, BINOP}, |
{"-le", INTLE, BINOP}, |
{"-lt", INTLT, BINOP}, |
{"-nt", FILNT, BINOP}, |
{"-ot", FILOT, BINOP}, |
{"-ef", FILEQ, BINOP}, |
{"!", UNOT, BUNOP}, |
{"-a", BAND, BBINOP}, |
{"-o", BOR, BBINOP}, |
{"(", LPAREN, PAREN}, |
{")", RPAREN, PAREN}, |
{0, 0, 0} |
}; |
static char **t_wp; |
static struct t_op const *t_wp_op; |
static gid_t *group_array = NULL; |
static int ngroups; |
static void syntax __P((const char *, const char *)); |
static int oexpr __P((enum token)); |
static int aexpr __P((enum token)); |
static int nexpr __P((enum token)); |
static int primary __P((enum token)); |
static int binop __P((void)); |
static int filstat __P((char *, enum token)); |
static enum token t_lex __P((char *)); |
static int isoperand __P((void)); |
static int getn __P((const char *)); |
static int newerf __P((const char *, const char *)); |
static int olderf __P((const char *, const char *)); |
static int equalf __P((const char *, const char *)); |
static int test_eaccess(); |
static int bash_group_member(); |
static void initialize_group_array(); |
#if defined(SHELL) |
extern void error __P((const char *, ...)) __attribute__((__noreturn__)); |
#else |
static void error __P((const char *, ...)) __attribute__((__noreturn__)); |
static void |
#ifdef __STDC__ |
error(const char *msg, ...) |
#else |
error(va_alist) |
va_dcl |
#endif |
{ |
va_list ap; |
#ifndef __STDC__ |
const char *msg; |
va_start(ap); |
msg = va_arg(ap, const char *); |
#else |
va_start(ap, msg); |
#endif |
verrx(2, msg, ap); |
/*NOTREACHED*/ |
va_end(ap); |
} |
#endif |
#ifdef SHELL |
int testcmd __P((int, char **)); |
int |
testcmd(argc, argv) |
int argc; |
char **argv; |
#else |
int main __P((int, char **)); |
int |
main(argc, argv) |
int argc; |
char **argv; |
#endif |
{ |
int res; |
if (strcmp(argv[0], "[") == 0) { |
if (strcmp(argv[--argc], "]")) |
error("missing ]"); |
argv[argc] = NULL; |
} |
if (argc < 2) |
return 1; |
t_wp = &argv[1]; |
res = !oexpr(t_lex(*t_wp)); |
if (*t_wp != NULL && *++t_wp != NULL) |
syntax(*t_wp, "unexpected operator"); |
return res; |
} |
static void |
syntax(op, msg) |
const char *op; |
const char *msg; |
{ |
if (op && *op) |
error("%s: %s", op, msg); |
else |
error("%s", msg); |
} |
static int |
oexpr(n) |
enum token n; |
{ |
int res; |
res = aexpr(n); |
if (t_lex(*++t_wp) == BOR) |
return oexpr(t_lex(*++t_wp)) || res; |
t_wp--; |
return res; |
} |
static int |
aexpr(n) |
enum token n; |
{ |
int res; |
res = nexpr(n); |
if (t_lex(*++t_wp) == BAND) |
return aexpr(t_lex(*++t_wp)) && res; |
t_wp--; |
return res; |
} |
static int |
nexpr(n) |
enum token n; /* token */ |
{ |
if (n == UNOT) |
return !nexpr(t_lex(*++t_wp)); |
return primary(n); |
} |
static int |
primary(n) |
enum token n; |
{ |
enum token nn; |
int res; |
if (n == EOI) |
return 0; /* missing expression */ |
if (n == LPAREN) { |
if ((nn = t_lex(*++t_wp)) == RPAREN) |
return 0; /* missing expression */ |
res = oexpr(nn); |
if (t_lex(*++t_wp) != RPAREN) |
syntax(NULL, "closing paren expected"); |
return res; |
} |
if (t_wp_op && t_wp_op->op_type == UNOP) { |
/* unary expression */ |
if (*++t_wp == NULL) |
syntax(t_wp_op->op_text, "argument expected"); |
switch (n) { |
case STREZ: |
return strlen(*t_wp) == 0; |
case STRNZ: |
return strlen(*t_wp) != 0; |
case FILTT: |
return isatty(getn(*t_wp)); |
default: |
return filstat(*t_wp, n); |
} |
} |
if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { |
return binop(); |
} |
return strlen(*t_wp) > 0; |
} |
static int |
binop() |
{ |
const char *opnd1, *opnd2; |
struct t_op const *op; |
opnd1 = *t_wp; |
(void) t_lex(*++t_wp); |
op = t_wp_op; |
if ((opnd2 = *++t_wp) == (char *)0) |
syntax(op->op_text, "argument expected"); |
switch (op->op_num) { |
case STREQ: |
return strcmp(opnd1, opnd2) == 0; |
case STRNE: |
return strcmp(opnd1, opnd2) != 0; |
case STRLT: |
return strcmp(opnd1, opnd2) < 0; |
case STRGT: |
return strcmp(opnd1, opnd2) > 0; |
case INTEQ: |
return getn(opnd1) == getn(opnd2); |
case INTNE: |
return getn(opnd1) != getn(opnd2); |
case INTGE: |
return getn(opnd1) >= getn(opnd2); |
case INTGT: |
return getn(opnd1) > getn(opnd2); |
case INTLE: |
return getn(opnd1) <= getn(opnd2); |
case INTLT: |
return getn(opnd1) < getn(opnd2); |
case FILNT: |
return newerf (opnd1, opnd2); |
case FILOT: |
return olderf (opnd1, opnd2); |
case FILEQ: |
return equalf (opnd1, opnd2); |
default: |
abort(); |
/* NOTREACHED */ |
} |
} |
static int |
filstat(nm, mode) |
char *nm; |
enum token mode; |
{ |
struct stat s; |
if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s)) |
return 0; |
switch (mode) { |
case FILRD: |
return test_eaccess(nm, R_OK) == 0; |
case FILWR: |
return test_eaccess(nm, W_OK) == 0; |
case FILEX: |
return test_eaccess(nm, X_OK) == 0; |
case FILEXIST: |
return 1; |
case FILREG: |
return S_ISREG(s.st_mode); |
case FILDIR: |
return S_ISDIR(s.st_mode); |
case FILCDEV: |
return S_ISCHR(s.st_mode); |
case FILBDEV: |
return S_ISBLK(s.st_mode); |
case FILFIFO: |
return S_ISFIFO(s.st_mode); |
case FILSOCK: |
return S_ISSOCK(s.st_mode); |
case FILSYM: |
return S_ISLNK(s.st_mode); |
case FILSUID: |
return (s.st_mode & S_ISUID) != 0; |
case FILSGID: |
return (s.st_mode & S_ISGID) != 0; |
case FILSTCK: |
return (s.st_mode & S_ISVTX) != 0; |
case FILGZ: |
return s.st_size > (off_t)0; |
case FILUID: |
return s.st_uid == geteuid(); |
case FILGID: |
return s.st_gid == getegid(); |
default: |
return 1; |
} |
} |
static enum token |
t_lex(s) |
char *s; |
{ |
struct t_op const *op = ops; |
if (s == 0) { |
t_wp_op = (struct t_op *)0; |
return EOI; |
} |
while (op->op_text) { |
if (strcmp(s, op->op_text) == 0) { |
if ((op->op_type == UNOP && isoperand()) || |
(op->op_num == LPAREN && *(t_wp+1) == 0)) |
break; |
t_wp_op = op; |
return op->op_num; |
} |
op++; |
} |
t_wp_op = (struct t_op *)0; |
return OPERAND; |
} |
static int |
isoperand() |
{ |
struct t_op const *op = ops; |
char *s; |
char *t; |
if ((s = *(t_wp+1)) == 0) |
return 1; |
if ((t = *(t_wp+2)) == 0) |
return 0; |
while (op->op_text) { |
if (strcmp(s, op->op_text) == 0) |
return op->op_type == BINOP && |
(t[0] != ')' || t[1] != '\0'); |
op++; |
} |
return 0; |
} |
/* atoi with error detection */ |
static int |
getn(s) |
const char *s; |
{ |
char *p; |
long r; |
errno = 0; |
r = strtol(s, &p, 10); |
if (errno != 0) |
error("%s: out of range", s); |
while (isspace((unsigned char)*p)) |
p++; |
if (*p) |
error("%s: bad number", s); |
return (int) r; |
} |
static int |
newerf (f1, f2) |
const char *f1, *f2; |
{ |
struct stat b1, b2; |
return (stat (f1, &b1) == 0 && |
stat (f2, &b2) == 0 && |
b1.st_mtime > b2.st_mtime); |
} |
static int |
olderf (f1, f2) |
const char *f1, *f2; |
{ |
struct stat b1, b2; |
return (stat (f1, &b1) == 0 && |
stat (f2, &b2) == 0 && |
b1.st_mtime < b2.st_mtime); |
} |
static int |
equalf (f1, f2) |
const char *f1, *f2; |
{ |
struct stat b1, b2; |
return (stat (f1, &b1) == 0 && |
stat (f2, &b2) == 0 && |
b1.st_dev == b2.st_dev && |
b1.st_ino == b2.st_ino); |
} |
/* Do the same thing access(2) does, but use the effective uid and gid, |
and don't make the mistake of telling root that any file is |
executable. */ |
static int |
test_eaccess (path, mode) |
char *path; |
int mode; |
{ |
struct stat st; |
int euid = geteuid(); |
if (stat (path, &st) < 0) |
return (-1); |
if (euid == 0) { |
/* Root can read or write any file. */ |
if (mode != X_OK) |
return (0); |
/* Root can execute any file that has any one of the execute |
bits set. */ |
if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) |
return (0); |
} |
if (st.st_uid == euid) /* owner */ |
mode <<= 6; |
else if (bash_group_member (st.st_gid)) |
mode <<= 3; |
if (st.st_mode & mode) |
return (0); |
return (-1); |
} |
static void |
initialize_group_array () |
{ |
ngroups = getgroups(0, NULL); |
group_array = malloc(ngroups * sizeof(gid_t)); |
if (!group_array) |
error(strerror(ENOMEM)); |
getgroups(ngroups, group_array); |
} |
/* Return non-zero if GID is one that we have in our groups list. */ |
static int |
bash_group_member (gid) |
gid_t gid; |
{ |
register int i; |
/* Short-circuit if possible, maybe saving a call to getgroups(). */ |
if (gid == getgid() || gid == getegid()) |
return (1); |
if (ngroups == 0) |
initialize_group_array (); |
/* Search through the list looking for GID. */ |
for (i = 0; i < ngroups; i++) |
if (gid == group_array[i]) |
return (1); |
return (0); |
} |
/branches/dd/uspace/app/ash/bltin/times.c |
---|
0,0 → 1,30 |
#ifdef _GNU_SOURCE |
/* |
* Copyright (c) 1999 Herbert Xu <herbert@debian.org> |
* This file contains code for the times builtin. |
* $Id: ash-0.4.0-cumulative_fixes-1.patch,v 1.1 2004/06/04 10:32:01 jim Exp $ |
*/ |
#include <stdio.h> |
#include <sys/times.h> |
#include <unistd.h> |
#define main timescmd |
int main() { |
struct tms buf; |
long int clk_tck = sysconf(_SC_CLK_TCK); |
times(&buf); |
printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n", |
(int) (buf.tms_utime / clk_tck / 60), |
((double) buf.tms_utime) / clk_tck, |
(int) (buf.tms_stime / clk_tck / 60), |
((double) buf.tms_stime) / clk_tck, |
(int) (buf.tms_cutime / clk_tck / 60), |
((double) buf.tms_cutime) / clk_tck, |
(int) (buf.tms_cstime / clk_tck / 60), |
((double) buf.tms_cstime) / clk_tck); |
return 0; |
} |
#endif /* _GNU_SOURCE */ |
/branches/dd/uspace/app/ash/bltin/echo.1 |
---|
0,0 → 1,113 |
.\" $NetBSD: echo.1,v 1.9 1999/03/22 18:30:47 garbled Exp $ |
.\" |
.\" Copyright (c) 1991, 1993 |
.\" The Regents of the University of California. All rights reserved. |
.\" |
.\" This code is derived from software contributed to Berkeley by |
.\" Kenneth Almquist. |
.\" Copyright 1989 by Kenneth Almquist |
.\" |
.\" Redistribution and use in source and binary forms, with or without |
.\" modification, are permitted provided that the following conditions |
.\" are met: |
.\" 1. Redistributions of source code must retain the above copyright |
.\" notice, this list of conditions and the following disclaimer. |
.\" 2. Redistributions in binary form must reproduce the above copyright |
.\" notice, this list of conditions and the following disclaimer in the |
.\" documentation and/or other materials provided with the distribution. |
.\" 3. All advertising materials mentioning features or use of this software |
.\" must display the following acknowledgement: |
.\" This product includes software developed by the University of |
.\" California, Berkeley and its contributors. |
.\" 4. Neither the name of the University nor the names of its contributors |
.\" may be used to endorse or promote products derived from this software |
.\" without specific prior written permission. |
.\" |
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
.\" SUCH DAMAGE. |
.\" |
.\" @(#)echo.1 8.1 (Berkeley) 5/31/93 |
.\" |
.Dd May 31, 1993 |
.Dt ECHO 1 |
.Os |
.Sh NAME |
.Nm echo |
.Nd produce message in a shell script |
.Sh SYNOPSIS |
.Nm |
.Op Fl n | Fl e |
.Ar args... |
.Sh DESCRIPTION |
.Nm |
prints its arguments on the standard output, separated by spaces. |
Unless the |
.Fl n |
option is present, a newline is output following the arguments. |
The |
.Fl e |
option causes |
.Nm |
to treat the escape sequences specially, as described in the following |
paragraph. |
The |
.Fl e |
option is the default, and is provided solely for compatibility with |
other systems. |
Only one of the options |
.Fl n |
and |
.Fl e |
may be given. |
.Pp |
If any of the following sequences of characters is encountered during |
output, the sequence is not output. Instead, the specified action is |
performed: |
.Bl -tag -width indent |
.It Li \eb |
A backspace character is output. |
.It Li \ec |
Subsequent output is suppressed. This is normally used at the end of the |
last argument to suppress the trailing newline that |
.Nm |
would otherwise output. |
.It Li \ef |
Output a form feed. |
.It Li \en |
Output a newline character. |
.It Li \er |
Output a carriage return. |
.It Li \et |
Output a (horizontal) tab character. |
.It Li \ev |
Output a vertical tab. |
.It Li \e0 Ns Ar digits |
Output the character whose value is given by zero to three digits. |
If there are zero digits, a nul character is output. |
.It Li \e\e |
Output a backslash. |
.El |
.Sh HINTS |
Remember that backslash is special to the shell and needs to be escaped. |
To output a message to standard error, say |
.Pp |
.D1 echo message >&2 |
.Sh BUGS |
The octal character escape mechanism |
.Pq Li \e0 Ns Ar digits |
differs from the |
C language mechanism. |
.Pp |
There is no way to force |
.Nm |
to treat its arguments literally, rather than interpreting them as |
options and escape sequences. |
/branches/dd/uspace/app/ash/bltin/bltin.h |
---|
0,0 → 1,81 |
/* $NetBSD: bltin.h,v 1.9 1997/07/04 21:02:29 christos Exp $ */ |
/*- |
* Copyright (c) 1991, 1993 |
* The Regents of the University of California. All rights reserved. |
* |
* This code is derived from software contributed to Berkeley by |
* Kenneth Almquist. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* 1. Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* 2. Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* 3. All advertising materials mentioning features or use of this software |
* must display the following acknowledgement: |
* This product includes software developed by the University of |
* California, Berkeley and its contributors. |
* 4. Neither the name of the University nor the names of its contributors |
* may be used to endorse or promote products derived from this software |
* without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
* SUCH DAMAGE. |
* |
* @(#)bltin.h 8.1 (Berkeley) 5/31/93 |
*/ |
/* |
* This file is included by programs which are optionally built into the |
* shell. If SHELL is defined, we try to map the standard UNIX library |
* routines to ash routines using defines. |
*/ |
#include "../shell.h" |
#include "../mystring.h" |
#include "../memalloc.h" |
#ifdef SHELL |
#include "../output.h" |
#ifndef _GNU_SOURCE |
#define stdout out1 |
#define stderr out2 |
#define printf out1fmt |
#define putc(c, file) outc(c, file) |
#define putchar(c) out1c(c) |
#define fprintf outfmt |
#define fputs outstr |
#define fflush flushout |
#define warnx(a, b, c) { \ |
char buf[64]; \ |
(void)snprintf(buf, sizeof(buf), a, b, c); \ |
error("%s", buf); \ |
} |
#endif |
#define INITARGS(argv) |
#else |
#undef NULL |
#include <stdio.h> |
#undef main |
#define INITARGS(argv) if ((commandname = argv[0]) == NULL) {fputs("Argc is zero\n", stderr); exit(2);} else |
#endif |
pointer stalloc __P((int)); |
void error __P((char *, ...)); |
int echocmd __P((int, char **)); |
extern char *commandname; |