void
printf(char* s, ...)
{
va_list va;
char lng;
va_start(va, s);
for(; *s != 0; s++)
if(*s == '%'){
s++;
lng = 0;
if(*s == 'l'){
lng = 1;
s++;
}
switch(*s){
case '%':
putc('%');
break;
case 'd':
putn(lng ? va_arg(va, u32int) : va_arg(va, u16int), 10);
break;
case 'o':
putn(lng ? va_arg(va, u32int) : va_arg(va, u16int), 8);
break;
case 'x':
putn(lng ? va_arg(va, u32int) : va_arg(va, u16int), 16);
break;
}
}
else
putc(*s);
va_end(va);
}
int
facpr(int n)
{
putstr("factorial ");
putn(n);
putstr(" = ");
putn(fac(n));
putstr("\n");
}
Char *
randsuf(void) {
#ifndef WINNT_NATIVE
struct timeval tv;
(void) gettimeofday(&tv, NULL);
return putn((((tcsh_number_t)tv.tv_sec) ^
((tcsh_number_t)tv.tv_usec) ^
((tcsh_number_t)getpid())) & 0x00ffffff);
#else
return putn(getpid());
#endif
}
/*
* *_procstates(total, brkdn, names) - print the process summary line
*
* Assumptions: cursor is at the beginning of the line on entry
*/
void
i_procstates(int total, int *brkdn)
{
if (screen_length > 2 || !smart_terminal) {
int i;
char procstates_buffer[MAX_COLS];
move(1, 0);
clrtoeol();
/* write current number of processes and remember the value */
printwp("%d processes:", total);
if (smart_terminal)
move(1, 15);
else {
/* put out enough spaces to get to column 15 */
i = digits(total);
while (i++ < 4) {
if (putchar(' ') == EOF)
exit(1);
}
}
/* format and print the process state summary */
summary_format(procstates_buffer, sizeof(procstates_buffer), brkdn,
procstate_names);
addstrp(procstates_buffer);
putn();
}
}
void
i_timeofday(time_t * tod)
{
static char buf[30];
if (buf[0] == '\0')
gethostname(buf, sizeof(buf));
if (screen_length > 1 || !smart_terminal) {
if (smart_terminal) {
move(0, screen_width - 8 - strlen(buf) - 1);
} else {
if (fputs(" ", stdout) == EOF)
exit(1);
}
#ifdef DEBUG
{
char *foo;
foo = ctime(tod);
addstrp(foo);
}
#endif
printwp("%s %-8.8s", buf, &(ctime(tod)[11]));
putn();
}
}
void
main(int argc, char **argv)
{
DSApriv *k;
char *comment;
uchar buf[8192], *p;
fmtinstall('B', mpfmt);
fmtinstall('[', encodefmt);
comment = "";
ARGBEGIN{
case 'c':
comment = EARGF(usage());
break;
default:
usage();
}ARGEND
if(argc > 1)
usage();
if((k = getdsakey(argc, argv, 0, nil)) == nil)
sysfatal("%r");
p = buf;
p = put4(p, 7);
p = putn(p, "ssh-dss", 7);
p = putmp2(p, k->pub.p);
p = putmp2(p, k->pub.q);
p = putmp2(p, k->pub.alpha);
p = putmp2(p, k->pub.key);
print("ssh-dss %.*[ %s\n", (int)(p - buf), buf, comment);
exits(nil);
}
int
putn(int n)
{
if (n >= 10)
putn(n / 10);
putchar((n%10) + '0');
}
static Char *
operate(int op, Char *vp, Char *p)
{
Char opr[2];
Char *vec[5];
Char **v = vec;
Char **vecp = v;
tcsh_number_t i;
if (op != '=') {
if (*vp)
*v++ = vp;
opr[0] = op;
opr[1] = 0;
*v++ = opr;
if (op == '<' || op == '>')
*v++ = opr;
}
*v++ = p;
*v++ = 0;
i = expr(&vecp);
if (*vecp)
stderror(ERR_NAME | ERR_EXPRESSION);
return (putn(i));
}
void
i_header(char *text)
{
if (header_status == Yes && (screen_length > y_header
|| !smart_terminal)) {
if (!smart_terminal) {
putn();
if (fputs(text, stdout) == EOF)
exit(1);
putn();
} else {
move(y_header, 0);
clrtoeol();
addstrp(text);
}
}
}
utility::string_t calculate_hmac_sha256_hash(const utility::string_t& string_to_hash, const storage_credentials& credentials)
{
auto utf8_string_to_hash = utility::conversions::to_utf8string(string_to_hash);
auto hash_streambuf = core::hash_hmac_sha256_streambuf(credentials.account_key());
hash_streambuf.putn(reinterpret_cast<const uint8_t*>(utf8_string_to_hash.data()), utf8_string_to_hash.size()).wait();
hash_streambuf.close().wait();
return utility::conversions::to_base64(hash_streambuf.hash());
}
static Char *
xset(Char *cp, Char ***vp)
{
Char *dp;
if (*cp) {
dp = Strsave(cp);
--(*vp);
xfree(** vp);
**vp = dp;
}
return (putn(expr(vp)));
}
int main(){
int N, a,f;
scanf("%d",&N);
while(N--){
scanf("%d %d", &a, &f);
while(f--){
int i = 0;
while(i++ < a){
putn(i);
}
i--;
while(--i ){
putn(i);
}
if(f)printf("\n");
}
if(N) printf("\n");
}
return 0;
}
static void
putn(u32int n, int b)
{
u32int d;
d = udivmod(&n, n, b);
if(d != 0)
putn(d, b);
if(n >= 10)
putc(n + 'a' - 10);
else
putc(n + '0');
}
void
main(int argc, char **argv)
{
RSApriv *k;
int ssh2;
char *comment;
fmtinstall('B', mpfmt);
fmtinstall('[', encodefmt);
ssh2 = 0;
comment = "";
ARGBEGIN{
case 'c':
comment = EARGF(usage());
break;
case '2':
ssh2 = 1;
break;
default:
usage();
}ARGEND
if(argc > 1)
usage();
if((k = getkey(argc, argv, 0, nil)) == nil)
sysfatal("%r");
if(ssh2) {
uchar buf[8192], *p;
p = buf;
p = put4(p, 7);
p = putn(p, "ssh-rsa", 7);
p = putmp2(p, k->pub.ek);
p = putmp2(p, k->pub.n);
print("ssh-rsa %.*[ %s\n", (int)(p-buf), buf, comment);
} else {
print("%d %.10B %.10B %s\n", mpsignif(k->pub.n), k->pub.ek, k->pub.n, comment);
}
exits(nil);
}
/*
* *_memory(stats) - print "Memory: " followed by the memory summary string
*/
void
i_memory(int *stats)
{
if (screen_length > y_mem || !smart_terminal) {
char memory_buffer[MAX_COLS];
move(y_mem, 0);
clrtoeol();
addstrp("Memory: ");
/* format and print the memory summary */
summary_format(memory_buffer, sizeof(memory_buffer), stats,
memory_names);
addstrp(memory_buffer);
putn();
}
}
void
i_process(int line, char *thisline, int hl)
{
/* make sure we are on the correct line */
move(y_procs + line, 0);
/* truncate the line to conform to our current screen width */
thisline[display_width] = '\0';
/* write the line out */
if (hl && smart_terminal)
standoutp();
addstrp(thisline);
if (hl && smart_terminal)
standendp();
putn();
clrtoeol();
}
int main(){
int N,M, i,j, b[10][2]={0};
N = getn(), M = getn();
scanf("%s",a);
a[0] -= '0', r[i] = 0;
for(i = 1; i < N; i++){
a[i] -= '0';
for(j = 0; j < 10; j++){
if(j - a[i-1] < 0)
b[j][0] += j - a[i-1];
else if(j - a[i-1] > 0)
b[j][1] += j - a[i-1];
r[i] = b[a[i]][1] - b[a[i]][0];
}
}
for(i = 0; i < M; i++){
putn(r[getn()-1]);
pc('\n');
}
return 0;
}
int
main(int argc, char *argv[])
{
struct sigaction oact;
Char *cp;
char *tcp, **tempv;
const char *ecp;
sigset_t nsigset;
int f;
cshin = stdin;
cshout = stdout;
csherr = stderr;
setprogname(argv[0]);
settimes(); /* Immed. estab. timing base */
/*
* Initialize non constant strings
*/
#ifdef _PATH_BSHELL
STR_BSHELL = SAVE(_PATH_BSHELL);
#endif
#ifdef _PATH_CSHELL
STR_SHELLPATH = SAVE(_PATH_CSHELL);
#endif
STR_environ = blk2short(environ);
environ = short2blk(STR_environ); /* So that we can free it */
STR_WORD_CHARS = SAVE(WORD_CHARS);
HIST = '!';
HISTSUB = '^';
word_chars = STR_WORD_CHARS;
tempv = argv;
if (eq(str2short(tempv[0]), STRaout)) /* A.out's are quittable */
quitit = 1;
uid = getuid();
gid = getgid();
euid = geteuid();
egid = getegid();
/*
* We are a login shell if: 1. we were invoked as -<something> and we had
* no arguments 2. or we were invoked only with the -l flag
*/
loginsh = (**tempv == '-' && argc == 1) ||
(argc == 2 && tempv[1][0] == '-' && tempv[1][1] == 'l' &&
tempv[1][2] == '\0');
if (loginsh && **tempv != '-') {
/*
* Mangle the argv space
*/
tempv[1][0] = '\0';
tempv[1][1] = '\0';
tempv[1] = NULL;
for (tcp = *tempv; *tcp++;)
continue;
for (tcp--; tcp >= *tempv; tcp--)
tcp[1] = tcp[0];
*++tcp = '-';
argc--;
}
if (loginsh)
(void)time(&chktim);
AsciiOnly = 1;
#ifdef NLS
(void)setlocale(LC_ALL, "");
{
int k;
for (k = 0200; k <= 0377 && !Isprint(k); k++)
continue;
AsciiOnly = k > 0377;
}
#else
AsciiOnly = getenv("LANG") == NULL && getenv("LC_CTYPE") == NULL;
#endif /* NLS */
/*
* Move the descriptors to safe places. The variable didfds is 0 while we
* have only FSH* to work with. When didfds is true, we have 0,1,2 and
* prefer to use these.
*/
initdesc();
/*
* XXX: This is to keep programs that use stdio happy.
* what we really want is freunopen() ....
* Closing cshin cshout and csherr (which are really stdin stdout
* and stderr at this point and then reopening them in the same order
* gives us again stdin == cshin stdout == cshout and stderr == csherr.
* If that was not the case builtins like printf that use stdio
* would break. But in any case we could fix that with memcpy and
* a bit of pointer manipulation...
* Fortunately this is not needed under the current implementation
* of stdio.
*/
(void)fclose(cshin);
(void)fclose(cshout);
(void)fclose(csherr);
if (!(cshin = funopen2((void *) &SHIN, readf, writef, seekf, NULL,
closef)))
exit(1);
if (!(cshout = funopen2((void *) &SHOUT, readf, writef, seekf, NULL,
closef)))
exit(1);
if (!(csherr = funopen2((void *) &SHERR, readf, writef, seekf, NULL,
closef)))
exit(1);
(void)setvbuf(cshin, NULL, _IOLBF, 0);
(void)setvbuf(cshout, NULL, _IOLBF, 0);
(void)setvbuf(csherr, NULL, _IOLBF, 0);
/*
* Initialize the shell variables. ARGV and PROMPT are initialized later.
* STATUS is also munged in several places. CHILD is munged when
* forking/waiting
*/
set(STRstatus, Strsave(STR0));
if ((ecp = getenv("HOME")) != NULL)
cp = quote(SAVE(ecp));
else
cp = NULL;
if (cp == NULL)
fast = 1; /* No home -> can't read scripts */
else
set(STRhome, cp);
dinit(cp); /* dinit thinks that HOME == cwd in a login
* shell */
/*
* Grab other useful things from the environment. Should we grab
* everything??
*/
if ((ecp = getenv("LOGNAME")) != NULL ||
(ecp = getenv("USER")) != NULL)
set(STRuser, quote(SAVE(ecp)));
if ((ecp = getenv("TERM")) != NULL)
set(STRterm, quote(SAVE(ecp)));
/*
* Re-initialize path if set in environment
*/
if ((ecp = getenv("PATH")) == NULL) {
#ifdef _PATH_DEFPATH
importpath(str2short(_PATH_DEFPATH));
#else
setq(STRpath, defaultpath(), &shvhed);
#endif
} else {
importpath(str2short(ecp));
}
set(STRshell, Strsave(STR_SHELLPATH));
doldol = putn((int) getpid()); /* For $$ */
shtemp = Strspl(STRtmpsh, doldol); /* For << */
/*
* Record the interrupt states from the parent process. If the parent is
* non-interruptible our hand must be forced or we (and our children) won't
* be either. Our children inherit termination from our parent. We catch it
* only if we are the login shell.
*/
/* parents interruptibility */
(void)sigaction(SIGINT, NULL, &oact);
parintr = oact.sa_handler;
(void)sigaction(SIGTERM, NULL, &oact);
parterm = oact.sa_handler;
/* catch these all, login shell or not */
(void)signal(SIGHUP, phup); /* exit processing on HUP */
(void)signal(SIGXCPU, phup); /* ...and on XCPU */
(void)signal(SIGXFSZ, phup); /* ...and on XFSZ */
/*
* Process the arguments.
*
* Note that processing of -v/-x is actually delayed till after script
* processing.
*
* We set the first character of our name to be '-' if we are a shell
* running interruptible commands. Many programs which examine ps'es
* use this to filter such shells out.
*/
argc--, tempv++;
while (argc > 0 && (tcp = tempv[0])[0] == '-' && *++tcp != '\0' && !batch) {
do
switch (*tcp++) {
case 0: /* - Interruptible, no prompt */
prompt = 0;
setintr = 1;
nofile = 1;
break;
case 'b': /* -b Next arg is input file */
batch = 1;
break;
case 'c': /* -c Command input from arg */
if (argc == 1)
xexit(0);
argc--, tempv++;
arginp = SAVE(tempv[0]);
prompt = 0;
nofile = 1;
break;
case 'e': /* -e Exit on any error */
exiterr = 1;
break;
case 'f': /* -f Fast start */
fast = 1;
break;
case 'i': /* -i Interactive, even if !intty */
intact = 1;
nofile = 1;
break;
case 'm': /* -m read .cshrc (from su) */
mflag = 1;
break;
case 'n': /* -n Don't execute */
noexec = 1;
break;
case 'q': /* -q (Undoc'd) ... die on quit */
quitit = 1;
break;
case 's': /* -s Read from std input */
nofile = 1;
break;
case 't': /* -t Read one line from input */
onelflg = 2;
prompt = 0;
nofile = 1;
break;
case 'v': /* -v Echo hist expanded input */
nverbose = 1; /* ... later */
break;
case 'x': /* -x Echo just before execution */
nexececho = 1; /* ... later */
break;
case 'V': /* -V Echo hist expanded input */
setNS(STRverbose); /* NOW! */
break;
case 'X': /* -X Echo just before execution */
setNS(STRecho); /* NOW! */
break;
} while (*tcp);
tempv++, argc--;
}
if (quitit) /* With all due haste, for debugging */
(void)signal(SIGQUIT, SIG_DFL);
/*
* Unless prevented by -, -c, -i, -s, or -t, if there are remaining
* arguments the first of them is the name of a shell file from which to
* read commands.
*/
if (nofile == 0 && argc > 0) {
nofile = open(tempv[0], O_RDONLY);
if (nofile < 0) {
child = 1; /* So this doesn't return */
stderror(ERR_SYSTEM, tempv[0], strerror(errno));
}
ffile = SAVE(tempv[0]);
/*
* Replace FSHIN. Handle /dev/std{in,out,err} specially
* since once they are closed we cannot open them again.
* In that case we use our own saved descriptors
*/
if ((SHIN = dmove(nofile, FSHIN)) < 0)
switch(nofile) {
case 0:
SHIN = FSHIN;
break;
case 1:
SHIN = FSHOUT;
break;
case 2:
SHIN = FSHERR;
break;
default:
stderror(ERR_SYSTEM, tempv[0], strerror(errno));
/* NOTREACHED */
}
(void)ioctl(SHIN, FIOCLEX, NULL);
prompt = 0;
/* argc not used any more */ tempv++;
}
intty = isatty(SHIN);
intty |= intact;
if (intty || (intact && isatty(SHOUT))) {
if (!batch && (uid != euid || gid != egid)) {
errno = EACCES;
child = 1; /* So this doesn't return */
stderror(ERR_SYSTEM, "csh", strerror(errno));
}
}
/*
* Decide whether we should play with signals or not. If we are explicitly
* told (via -i, or -) or we are a login shell (arg0 starts with -) or the
* input and output are both the ttys("csh", or "csh</dev/ttyx>/dev/ttyx")
* Note that in only the login shell is it likely that parent may have set
* signals to be ignored
*/
if (loginsh || intact || (intty && isatty(SHOUT)))
setintr = 1;
settell();
/*
* Save the remaining arguments in argv.
*/
setq(STRargv, blk2short(tempv), &shvhed);
/*
* Set up the prompt.
*/
if (prompt) {
set(STRprompt, Strsave(uid == 0 ? STRsymhash : STRsymcent));
/* that's a meta-questionmark */
set(STRprompt2, Strsave(STRmquestion));
}
/*
* If we are an interactive shell, then start fiddling with the signals;
* this is a tricky game.
*/
shpgrp = getpgrp();
opgrp = tpgrp = -1;
if (setintr) {
**argv = '-';
if (!quitit) /* Wary! */
(void)signal(SIGQUIT, SIG_IGN);
(void)signal(SIGINT, pintr);
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, NULL);
(void)signal(SIGTERM, SIG_IGN);
if (quitit == 0 && arginp == 0) {
(void)signal(SIGTSTP, SIG_IGN);
(void)signal(SIGTTIN, SIG_IGN);
(void)signal(SIGTTOU, SIG_IGN);
/*
* Wait till in foreground, in case someone stupidly runs csh &
* dont want to try to grab away the tty.
*/
if (isatty(FSHERR))
f = FSHERR;
else if (isatty(FSHOUT))
f = FSHOUT;
else if (isatty(OLDSTD))
f = OLDSTD;
else
f = -1;
retry:
if ((tpgrp = tcgetpgrp(f)) != -1) {
if (tpgrp != shpgrp) {
sig_t old = signal(SIGTTIN, SIG_DFL);
(void)kill(0, SIGTTIN);
(void)signal(SIGTTIN, old);
goto retry;
}
opgrp = shpgrp;
shpgrp = getpid();
tpgrp = shpgrp;
/*
* Setpgid will fail if we are a session leader and
* mypid == mypgrp (POSIX 4.3.3)
*/
if (opgrp != shpgrp)
if (setpgid(0, shpgrp) == -1)
goto notty;
/*
* We do that after we set our process group, to make sure
* that the process group belongs to a process in the same
* session as the tty (our process and our group) (POSIX 7.2.4)
*/
if (tcsetpgrp(f, shpgrp) == -1)
goto notty;
(void)ioctl(dcopy(f, FSHTTY), FIOCLEX, NULL);
}
if (tpgrp == -1) {
notty:
(void)fprintf(csherr, "Warning: no access to tty (%s).\n",
strerror(errno));
(void)fprintf(csherr, "Thus no job control in this shell.\n");
}
}
}
if ((setintr == 0) && (parintr == SIG_DFL))
setintr = 1;
(void)signal(SIGCHLD, pchild); /* while signals not ready */
/*
* Set an exit here in case of an interrupt or error reading the shell
* start-up scripts.
*/
reenter = setexit(); /* PWP */
haderr = 0; /* In case second time through */
if (!fast && reenter == 0) {
/* Will have value(STRhome) here because set fast if don't */
{
sig_t oparintr;
sigset_t osigset;
int osetintr;
oparintr = parintr;
osetintr = setintr;
sigemptyset(&nsigset);
(void)sigaddset(&nsigset, SIGINT);
(void)sigprocmask(SIG_BLOCK, &nsigset, &osigset);
setintr = 0;
parintr = SIG_IGN; /* Disable onintr */
#ifdef _PATH_DOTCSHRC
(void)srcfile(_PATH_DOTCSHRC, 0, 0);
#endif
if (!fast && !arginp && !onelflg)
dohash(NULL, NULL);
#ifdef _PATH_DOTLOGIN
if (loginsh)
(void)srcfile(_PATH_DOTLOGIN, 0, 0);
#endif
(void)sigprocmask(SIG_SETMASK, &osigset, NULL);
setintr = osetintr;
parintr = oparintr;
}
(void)srccat(value(STRhome), STRsldotcshrc);
if (!fast && !arginp && !onelflg && !havhash)
dohash(NULL, NULL);
/*
* Source history before .login so that it is available in .login
*/
if ((cp = value(STRhistfile)) != STRNULL)
tildehist[2] = cp;
dosource(tildehist, NULL);
if (loginsh)
(void)srccat(value(STRhome), STRsldotlogin);
}
/*
* Now are ready for the -v and -x flags
*/
if (nverbose)
setNS(STRverbose);
if (nexececho)
setNS(STRecho);
/*
* All the rest of the world is inside this call. The argument to process
* indicates whether it should catch "error unwinds". Thus if we are a
* interactive shell our call here will never return by being blown past on
* an error.
*/
process(setintr);
/*
* Mop-up.
*/
if (intty) {
if (loginsh) {
(void)fprintf(cshout, "logout\n");
(void)close(SHIN);
child = 1;
goodbye();
}
else {
(void)fprintf(cshout, "exit\n");
}
}
rechist();
exitstat();
/* NOTREACHED */
}
/*
* Karl Kleinpaste, 21oct1983.
* Set up a one-word alias command, for use for special things.
* This code is based on the mainline of process().
*/
void
aliasrun(int cnt, Char *s1, Char *s2)
{
struct wordent w, *new1, *new2; /* for holding alias name */
struct command *t = NULL;
jmp_buf_t osetexit;
int status;
size_t omark;
getexit(osetexit);
if (seterr) {
xfree(seterr);
seterr = NULL; /* don't repeatedly print err msg. */
}
w.word = STRNULL;
new1 = xcalloc(1, sizeof w);
new1->word = Strsave(s1);
if (cnt == 1) {
/* build a lex list with one word. */
w.next = w.prev = new1;
new1->next = new1->prev = &w;
}
else {
/* build a lex list with two words. */
new2 = xcalloc(1, sizeof w);
new2->word = Strsave(s2);
w.next = new2->prev = new1;
new1->next = w.prev = new2;
new1->prev = new2->next = &w;
}
cleanup_push(&w, lex_cleanup);
/* Save the old status */
status = getn(varval(STRstatus));
/* expand aliases like process() does. */
alias(&w);
/* build a syntax tree for the command. */
t = syntax(w.next, &w, 0);
cleanup_push(t, syntax_cleanup);
if (seterr)
stderror(ERR_OLD);
psavejob();
cleanup_push(&cnt, psavejob_cleanup); /* cnt is used only as a marker */
/* catch any errors here */
omark = cleanup_push_mark();
if (setexit() == 0)
/* execute the parse tree. */
/*
* From: Michael Schroeder <*****@*****.**>
* was execute(t, tpgrp);
*/
execute(t, tpgrp > 0 ? tpgrp : -1, NULL, NULL, TRUE);
/* reset the error catcher to the old place */
cleanup_pop_mark(omark);
resexit(osetexit);
if (haderr) {
haderr = 0;
/*
* Either precmd, or cwdcmd, or periodic had an error. Call it again so
* that it is removed
*/
if (precmd_active)
precmd();
if (postcmd_active)
postcmd();
#ifdef notdef
/*
* XXX: On the other hand, just interrupting them causes an error too.
* So if we hit ^C in the middle of cwdcmd or periodic the alias gets
* removed. We don't want that. Note that we want to remove precmd
* though, cause that could lead into an infinite loop. This should be
* fixed correctly, but then haderr should give us the whole exit
* status not just true or false.
*/
else if (cwdcmd_active)
cwd_cmd();
else if (beepcmd_active)
beep_cmd();
else if (periodic_active)
period_cmd();
#endif /* notdef */
}
cleanup_until(&w);
pendjob();
/* Restore status */
setv(STRstatus, putn((tcsh_number_t)status), VAR_READWRITE);
}
/*
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
void
Dgetdol(void)
{
tchar *np;
struct varent *vp;
tchar name[MAX_VREF_LEN];
int c, sc;
int subscr = 0, lwb = 1, upb = 0;
bool dimen = 0, bitset = 0;
tchar wbuf[BUFSIZ + MB_LEN_MAX]; /* read_ may return extra bytes */
#ifdef TRACE
tprintf("TRACE- Dgetdol()\n");
#endif
dolmod = dolmcnt = 0;
c = sc = DgetC(0);
if (c == '{')
c = DgetC(0); /* sc is { to take } later */
if ((c & TRIM) == '#')
dimen++, c = DgetC(0); /* $# takes dimension */
else if (c == '?')
bitset++, c = DgetC(0); /* $? tests existence */
switch (c) {
case '$':
if (dimen || bitset)
syntax:
error("Variable syntax"); /* No $?$, $#$ */
setDolp(doldol);
goto eatbrac;
case '<'|QUOTE:
if (dimen || bitset)
goto syntax; /* No $?<, $#< */
for (np = wbuf; read_(OLDSTD, np, 1) == 1; np++) {
if (np >= &wbuf[BUFSIZ-1])
error("$< line too long");
if (*np <= 0 || *np == '\n')
break;
}
*np = 0;
/*
* KLUDGE: dolmod is set here because it will
* cause setDolp to call domod and thus to copy wbuf.
* Otherwise setDolp would use it directly. If we saved
* it ourselves, no one would know when to free it.
* The actual function of the 'q' causes filename
* expansion not to be done on the interpolated value.
*/
dolmod = 'q';
dolmcnt = 10000;
setDolp(wbuf);
goto eatbrac;
case DEOF:
case '\n':
goto syntax;
case '*':
(void) strcpy_(name, S_argv);
vp = adrof(S_argv);
subscr = -1; /* Prevent eating [...] */
break;
default:
np = name;
if (digit(c)) {
if (dimen)
goto syntax; /* No $#1, e.g. */
subscr = 0;
do {
subscr = subscr * 10 + c - '0';
c = DgetC(0);
} while (digit(c));
unDredc(c);
if (subscr < 0)
error("Subscript out of range");
if (subscr == 0) {
if (bitset) {
dolp = file ? S_1 /* "1" */ : S_0 /* "0" */;
goto eatbrac;
}
if (file == 0)
error("No file for $0");
setDolp(file);
goto eatbrac;
}
if (bitset)
goto syntax;
vp = adrof(S_argv);
if (vp == 0) {
vp = &nulargv;
goto eatmod;
}
break;
}
if (!alnum(c))
goto syntax;
for (;;) {
*np++ = c;
c = DgetC(0);
if (!alnum(c))
break;
/* if variable name is > 20, complain */
if (np >= &name[MAX_VAR_LEN])
error("Variable name too long");
}
*np++ = 0;
unDredc(c);
vp = adrof(name);
}
if (bitset) {
/*
* getenv() to getenv_(), because 'name''s type is now tchar *
* no need to xalloc
*/
dolp = (vp || getenv_(name)) ? S_1 /* "1" */ : S_0 /* "0" */;
goto eatbrac;
}
if (vp == 0) {
/*
* getenv() to getenv_(), because 'name''s type is now tchar *
* no need to xalloc
*/
np = getenv_(name);
if (np) {
addla(np);
goto eatbrac;
}
udvar(name);
/*NOTREACHED*/
}
c = DgetC(0);
upb = blklen(vp->vec);
if (dimen == 0 && subscr == 0 && c == '[') {
np = name;
for (;;) {
c = DgetC(DODOL); /* Allow $ expand within [ ] */
if (c == ']')
break;
if (c == '\n' || c == DEOF)
goto syntax;
if (np >= &name[MAX_VREF_LEN])
error("Variable reference too long");
*np++ = c;
}
*np = 0, np = name;
if (dolp || dolcnt) /* $ exp must end before ] */
goto syntax;
if (!*np)
goto syntax;
if (digit(*np)) {
int i = 0;
while (digit(*np))
i = i * 10 + *np++ - '0';
/* if ((i < 0 || i > upb) && !any(*np, "-*")) { */
if ((i < 0 || i > upb) && (*np != '-') && (*np != '*')) {
oob:
setname(vp->v_name);
error("Subscript out of range");
}
lwb = i;
if (!*np)
upb = lwb, np = S_AST /* "*" */;
}
if (*np == '*')
np++;
else if (*np != '-')
goto syntax;
else {
int i = upb;
np++;
if (digit(*np)) {
i = 0;
while (digit(*np))
i = i * 10 + *np++ - '0';
if (i < 0 || i > upb)
goto oob;
}
if (i < lwb)
upb = lwb - 1;
else
upb = i;
}
if (lwb == 0) {
if (upb != 0)
goto oob;
upb = -1;
}
if (*np)
goto syntax;
} else {
if (subscr > 0)
if (subscr > upb)
lwb = 1, upb = 0;
else
lwb = upb = subscr;
unDredc(c);
}
if (dimen) {
tchar *cp = putn(upb - lwb + 1);
addla(cp);
xfree(cp);
} else {
eatmod:
c = DgetC(0);
if (c == ':') {
c = DgetC(0), dolmcnt = 1;
if (c == 'g')
c = DgetC(0), dolmcnt = 10000;
if (!any(c, S_htrqxe))
error("Bad : mod in $");
dolmod = c;
if (c == 'q')
dolmcnt = 10000;
} else
unDredc(c);
dolnxt = &vp->vec[lwb - 1];
dolcnt = upb - lwb + 1;
}
eatbrac:
if (sc == '{') {
c = Dredc();
if (c != '}')
goto syntax;
}
}
/*
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
static void
Dgetdol(void)
{
Char *np;
struct varent *vp = NULL;
struct Strbuf *name = Strbuf_alloc();
eChar c, sc;
int subscr = 0, lwb = 1, upb = 0;
int dimen = 0, bitset = 0, length = 0;
static Char *dolbang = NULL;
cleanup_push(name, Strbuf_free);
dolmod.len = dolmcnt = dol_flag_a = 0;
c = sc = DgetC(0);
if (c == DEOF) {
stderror(ERR_SYNTAX);
return;
}
if (c == '{')
c = DgetC(0); /* sc is { to take } later */
if ((c & TRIM) == '#')
dimen++, c = DgetC(0); /* $# takes dimension */
else if (c == '?')
bitset++, c = DgetC(0); /* $? tests existence */
else if (c == '%')
length++, c = DgetC(0); /* $% returns length in chars */
switch (c) {
case '!':
if (dimen || bitset || length)
stderror(ERR_SYNTAX);
if (backpid != 0) {
xfree(dolbang);
setDolp(dolbang = putn((tcsh_number_t)backpid));
}
cleanup_until(name);
goto eatbrac;
case '$':
if (dimen || bitset || length)
stderror(ERR_SYNTAX);
setDolp(doldol);
cleanup_until(name);
goto eatbrac;
case '<'|QUOTE: {
static struct Strbuf wbuf; /* = Strbuf_INIT; */
if (bitset)
stderror(ERR_NOTALLOWED, "$?<");
if (dimen)
stderror(ERR_NOTALLOWED, "$#<");
if (length)
stderror(ERR_NOTALLOWED, "$%<");
wbuf.len = 0;
{
char cbuf[MB_LEN_MAX];
size_t cbp = 0;
int old_pintr_disabled;
for (;;) {
int len;
ssize_t res;
Char wc;
pintr_push_enable(&old_pintr_disabled);
res = force_read(OLDSTD, cbuf + cbp, 1);
cleanup_until(&old_pintr_disabled);
if (res != 1)
break;
cbp++;
len = normal_mbtowc(&wc, cbuf, cbp);
if (len == -1) {
reset_mbtowc();
if (cbp < MB_LEN_MAX)
continue; /* Maybe a partial character */
wc = (unsigned char)*cbuf | INVALID_BYTE;
}
if (len <= 0)
len = 1;
if (cbp != (size_t)len)
memmove(cbuf, cbuf + len, cbp - len);
cbp -= len;
if (wc == '\n')
break;
Strbuf_append1(&wbuf, wc);
}
while (cbp != 0) {
int len;
Char wc;
len = normal_mbtowc(&wc, cbuf, cbp);
if (len == -1) {
reset_mbtowc();
wc = (unsigned char)*cbuf | INVALID_BYTE;
}
if (len <= 0)
len = 1;
if (cbp != (size_t)len)
memmove(cbuf, cbuf + len, cbp - len);
cbp -= len;
if (wc == '\n')
break;
Strbuf_append1(&wbuf, wc);
}
Strbuf_terminate(&wbuf);
}
fixDolMod();
setDolp(wbuf.s); /* Kept allocated until next $< expansion */
cleanup_until(name);
goto eatbrac;
}
case '*':
Strbuf_append(name, STRargv);
Strbuf_terminate(name);
vp = adrof(STRargv);
subscr = -1; /* Prevent eating [...] */
break;
case DEOF:
case '\n':
np = dimen ? STRargv : (bitset ? STRstatus : NULL);
if (np) {
bitset = 0;
Strbuf_append(name, np);
Strbuf_terminate(name);
vp = adrof(np);
subscr = -1; /* Prevent eating [...] */
unDredc(c);
break;
}
else
stderror(ERR_SYNTAX);
/*NOTREACHED*/
default:
if (Isdigit(c)) {
if (dimen)
stderror(ERR_NOTALLOWED, "$#<num>");
subscr = 0;
do {
subscr = subscr * 10 + c - '0';
c = DgetC(0);
} while (c != DEOF && Isdigit(c));
unDredc(c);
if (subscr < 0)
stderror(ERR_RANGE);
if (subscr == 0) {
if (bitset) {
dolp = dolzero ? STR1 : STR0;
cleanup_until(name);
goto eatbrac;
}
if (ffile == 0)
stderror(ERR_DOLZERO);
if (length) {
length = Strlen(ffile);
addla(putn((tcsh_number_t)length));
}
else {
fixDolMod();
setDolp(ffile);
}
cleanup_until(name);
goto eatbrac;
}
#if 0
if (bitset)
stderror(ERR_NOTALLOWED, "$?<num>");
if (length)
stderror(ERR_NOTALLOWED, "$%<num>");
#endif
vp = adrof(STRargv);
if (vp == 0) {
vp = &nulargv;
cleanup_until(name);
goto eatmod;
}
break;
}
if (c == DEOF || !alnum(c)) {
np = dimen ? STRargv : (bitset ? STRstatus : NULL);
if (np) {
bitset = 0;
Strbuf_append(name, np);
Strbuf_terminate(name);
vp = adrof(np);
subscr = -1; /* Prevent eating [...] */
unDredc(c);
break;
}
else
stderror(ERR_VARALNUM);
}
for (;;) {
Strbuf_append1(name, (Char) c);
c = DgetC(0);
if (c == DEOF || !alnum(c))
break;
}
Strbuf_terminate(name);
unDredc(c);
vp = adrof(name->s);
}
if (bitset) {
dolp = (vp || getenv(short2str(name->s))) ? STR1 : STR0;
cleanup_until(name);
goto eatbrac;
}
if (vp == NULL || vp->vec == NULL) {
np = str2short(getenv(short2str(name->s)));
if (np) {
static Char *env_val; /* = NULL; */
cleanup_until(name);
fixDolMod();
if (length) {
addla(putn((tcsh_number_t)Strlen(np)));
} else {
xfree(env_val);
env_val = Strsave(np);
setDolp(env_val);
}
goto eatbrac;
}
udvar(name->s);
/* NOTREACHED */
}
cleanup_until(name);
c = DgetC(0);
upb = blklen(vp->vec);
if (dimen == 0 && subscr == 0 && c == '[') {
name = Strbuf_alloc();
cleanup_push(name, Strbuf_free);
np = name->s;
for (;;) {
c = DgetC(DODOL); /* Allow $ expand within [ ] */
if (c == ']')
break;
if (c == '\n' || c == DEOF)
stderror(ERR_INCBR);
Strbuf_append1(name, (Char) c);
}
Strbuf_terminate(name);
np = name->s;
if (dolp || dolcnt) /* $ exp must end before ] */
stderror(ERR_EXPORD);
if (!*np)
stderror(ERR_SYNTAX);
if (Isdigit(*np)) {
int i;
for (i = 0; Isdigit(*np); i = i * 10 + *np++ - '0')
continue;
if (i < 0 || (i > upb && !any("-*", *np))) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
lwb = i;
if (!*np)
upb = lwb, np = STRstar;
}
if (*np == '*')
np++;
else if (*np != '-')
stderror(ERR_MISSING, '-');
else {
int i = upb;
np++;
if (Isdigit(*np)) {
i = 0;
while (Isdigit(*np))
i = i * 10 + *np++ - '0';
if (i < 0 || i > upb) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
}
if (i < lwb)
upb = lwb - 1;
else
upb = i;
}
if (lwb == 0) {
if (upb != 0) {
cleanup_until(name);
dolerror(vp->v_name);
return;
}
upb = -1;
}
if (*np)
stderror(ERR_SYNTAX);
cleanup_until(name);
}
else {
if (subscr > 0) {
if (subscr > upb)
lwb = 1, upb = 0;
else
lwb = upb = subscr;
}
unDredc(c);
}
if (dimen) {
/* this is a kludge. It prevents Dgetdol() from */
/* pushing erroneous ${#<error> values into the labuf. */
if (sc == '{') {
c = Dredc();
if (c != '}')
stderror(ERR_MISSING, '}');
unDredc(c);
}
addla(putn((tcsh_number_t)(upb - lwb + 1)));
}
else if (length) {
int i;
for (i = lwb - 1, length = 0; i < upb; i++)
length += Strlen(vp->vec[i]);
#ifdef notdef
/* We don't want that, since we can always compute it by adding $#xxx */
length += i - 1; /* Add the number of spaces in */
#endif
addla(putn((tcsh_number_t)length));
}
else {
eatmod:
fixDolMod();
dolnxt = &vp->vec[lwb - 1];
dolcnt = upb - lwb + 1;
}
eatbrac:
if (sc == '{') {
c = Dredc();
if (c != '}')
stderror(ERR_MISSING, '}');
}
}
/*
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
static void
Dgetdol(void)
{
Char *np;
struct varent *vp = NULL;
Char name[4 * MAXVARLEN + 1];
int c, sc;
int subscr = 0, lwb = 1, upb = 0;
bool dimen = 0, bitset = 0;
char tnp;
Char wbuf[BUFSIZ];
static Char *dolbang = NULL;
dolnmod = dolmcnt = dolwcnt = 0;
c = sc = DgetC(0);
if (c == '{')
c = DgetC(0); /* sc is { to take } later */
if ((c & TRIM) == '#')
dimen++, c = DgetC(0); /* $# takes dimension */
else if (c == '?')
bitset++, c = DgetC(0); /* $? tests existence */
switch (c) {
case '!':
if (dimen || bitset)
stderror(ERR_SYNTAX);
if (backpid != 0) {
if (dolbang)
xfree(dolbang);
setDolp(dolbang = putn(backpid));
}
goto eatbrac;
case '$':
if (dimen || bitset)
stderror(ERR_SYNTAX);
setDolp(doldol);
goto eatbrac;
case '<' | QUOTE:
if (bitset)
stderror(ERR_NOTALLOWED, "$?<");
if (dimen)
stderror(ERR_NOTALLOWED, "$?#");
for (np = wbuf; read(OLDSTD, &tnp, 1) == 1; np++) {
*np = (unsigned char) tnp;
if (np >= &wbuf[BUFSIZ - 1])
stderror(ERR_LTOOLONG);
if (tnp == '\n')
break;
}
*np = 0;
/*
* KLUDGE: dolmod is set here because it will cause setDolp to call
* domod and thus to copy wbuf. Otherwise setDolp would use it
* directly. If we saved it ourselves, no one would know when to free
* it. The actual function of the 'q' causes filename expansion not to
* be done on the interpolated value.
*/
dolmod[dolnmod++] = 'q';
dolmcnt = 10000;
setDolp(wbuf);
goto eatbrac;
case DEOF:
case '\n':
stderror(ERR_SYNTAX);
/* NOTREACHED */
break;
case '*':
(void) Strlcpy(name, STRargv, sizeof name/sizeof(Char));
vp = adrof(STRargv);
subscr = -1; /* Prevent eating [...] */
break;
default:
np = name;
if (Isdigit(c)) {
if (dimen)
stderror(ERR_NOTALLOWED, "$#<num>");
subscr = 0;
do {
subscr = subscr * 10 + c - '0';
c = DgetC(0);
} while (Isdigit(c));
unDredc(c);
if (subscr < 0)
stderror(ERR_RANGE);
if (subscr == 0) {
if (bitset) {
dolp = ffile ? STR1 : STR0;
goto eatbrac;
}
if (ffile == 0)
stderror(ERR_DOLZERO);
fixDolMod();
setDolp(ffile);
goto eatbrac;
}
if (bitset)
stderror(ERR_DOLQUEST);
vp = adrof(STRargv);
if (vp == 0) {
vp = &nulargv;
goto eatmod;
}
break;
}
if (!alnum(c))
stderror(ERR_VARALNUM);
for (;;) {
*np++ = c;
c = DgetC(0);
if (!alnum(c))
break;
if (np >= &name[MAXVARLEN])
stderror(ERR_VARTOOLONG);
}
*np++ = 0;
unDredc(c);
vp = adrof(name);
}
if (bitset) {
dolp = (vp || getenv(short2str(name))) ? STR1 : STR0;
goto eatbrac;
}
if (vp == 0) {
np = str2short(getenv(short2str(name)));
if (np) {
fixDolMod();
setDolp(np);
goto eatbrac;
}
udvar(name);
/* NOTREACHED */
}
c = DgetC(0);
upb = blklen(vp->vec);
if (dimen == 0 && subscr == 0 && c == '[') {
np = name;
for (;;) {
c = DgetC(DODOL); /* Allow $ expand within [ ] */
if (c == ']')
break;
if (c == '\n' || c == DEOF)
stderror(ERR_INCBR);
if (np >= &name[sizeof(name) / sizeof(Char) - 2])
stderror(ERR_VARTOOLONG);
*np++ = c;
}
*np = 0, np = name;
if (dolp || dolcnt) /* $ exp must end before ] */
stderror(ERR_EXPORD);
if (!*np)
stderror(ERR_SYNTAX);
if (Isdigit(*np)) {
int i;
for (i = 0; Isdigit(*np); i = i * 10 + *np++ - '0')
continue;
if ((i < 0 || i > upb) && !any("-*", *np)) {
dolerror(vp->v_name);
return;
}
lwb = i;
if (!*np)
upb = lwb, np = STRstar;
}
if (*np == '*')
np++;
else if (*np != '-')
stderror(ERR_MISSING, '-');
else {
int i = upb;
np++;
if (Isdigit(*np)) {
i = 0;
while (Isdigit(*np))
i = i * 10 + *np++ - '0';
if (i < 0 || i > upb) {
dolerror(vp->v_name);
return;
}
}
if (i < lwb)
upb = lwb - 1;
else
upb = i;
}
if (lwb == 0) {
if (upb != 0) {
dolerror(vp->v_name);
return;
}
upb = -1;
}
if (*np)
stderror(ERR_SYNTAX);
}
else {
if (subscr > 0) {
if (subscr > upb)
lwb = 1, upb = 0;
else
lwb = upb = subscr;
}
unDredc(c);
}
if (dimen) {
Char *cp = putn(upb - lwb + 1);
addla(cp);
xfree(cp);
}
else {
eatmod:
fixDolMod();
dolnxt = &vp->vec[lwb - 1];
dolcnt = upb - lwb + 1;
}
eatbrac:
if (sc == '{') {
c = Dredc();
if (c != '}')
stderror(ERR_MISSING, '}');
}
}
void main (void)
{
int i;
unsigned char k;
ringinfo ri;
puts ("G7 hardware diagnostics\n\r");
puts ("\n\rInitialising board...");
boardinit ();
puts (" done\n\r");
puts ("\n\r ** Timer test\n\r");
puts ("Waiting for 3 seconds...");
starttimer (1010000);
while (gettimer () > 10000);
puts (" done\n\r");
puts ("\n\r ** iButton reader test\n\r");
puts ("Place an iButton in the reader...\n\r");
i = 0;
do
{
while (!checkring ());
ri = getringinfo ();
i++;
}
while (ri.crc == 0xFF);
puts ("iButton read (");
putn (i, 10, 2);
puts (" times); product family ");
putn (ri.product, 16, 2);
puts ("; user ID ");
for (i = 0; i < 6; i++)
putn (ri.id [i], 16, 2);
puts ("; CRC ");
putn (ri.crc, 16, 2);
puts ("\n\r");
puts ("\n\r ** Keypad test\n\r");
puts ("Press all the keys and the doorbell...\n\r");
for (i = 0; i < 13; i++)
{
k = getkeypad ();
starttimer (40000);
buzzerled (BUZZER);
while (gettimer () > 10000);
buzzerled (ALLOFF);
stoptimer ();
puts ("Key pressed: ");
if (k < 10)
putn (k, 10, 1);
else
switch (k)
{
case KP_STAR:
puts ("*");
break;
case KP_HASH:
puts ("#");
break;
case KP_DOORBELL:
puts ("doorbell");
break;
case KP_UNDEF:
puts ("undefined (");
putn (k, 16, 2);
puts (")");
break;
}
puts ("\n\r");
}
puts ("\n\r ** Beeper test\n\r");
starttimer (10000000);
buzzerled (BUZZER);
while (gettimer () > 10000000 - 30000);
buzzerled (ALLOFF);
while (gettimer () > 10000000 - 40000);
buzzerled (BUZZER);
while (gettimer () > 10000000 - 70000);
buzzerled (ALLOFF);
stoptimer ();
puts ("\n\r ** Door open test\n\r");
for (i = 0; i < 5; i++)
{
starttimer (210000);
buzzerled (LEDGREEN);
while (gettimer () > 110000);
buzzerled (ALLOFF);
while (gettimer () > 10000);
stoptimer ();
}
puts ("\n\r ** Entry denied test\n\r");
for (i = 0; i < 5; i++)
{
starttimer (210000);
buzzerled (LEDRED);
while (gettimer () > 110000);
buzzerled (ALLOFF);
while (gettimer () > 10000);
stoptimer ();
}
puts ("\n\r ** Door status test\n\r");
puts ("Close the door, then press a key\n\r");
mon_getc ();
puts ("Door status is ");
putn (getdoorstatus (), 10, 1);
puts ("\n\r");
puts ("Open the door, then press a key\n\r");
mon_getc ();
puts ("Door status is ");
putn (getdoorstatus (), 10, 1);
puts ("\n\r");
puts ("\n\r ** Testing done\n\r");
}
void
i_cpustates(int64_t *ostates)
{
int i, first, cpu;
double value;
int64_t *states;
char **names, *thisname;
if (combine_cpus) {
static double *values;
if (!values) {
values = calloc(num_cpustates, sizeof(*values));
if (!values)
err(1, NULL);
}
memset(values, 0, num_cpustates * sizeof(*values));
for (cpu = 0; cpu < ncpu; cpu++) {
names = cpustate_names;
states = ostates + (CPUSTATES * cpu);
i = 0;
while ((thisname = *names++) != NULL) {
if (*thisname != '\0') {
/* retrieve the value and remember it */
values[i++] += *states++;
}
}
}
if (screen_length > 2 || !smart_terminal) {
names = cpustate_names;
i = 0;
first = 0;
move(2, 0);
clrtoeol();
addstrp("All CPUs: ");
while ((thisname = *names++) != NULL) {
if (*thisname != '\0') {
value = values[i++] / ncpu;
/* if percentage is >= 1000, print it as 100% */
printwp((value >= 1000 ? "%s%4.0f%% %s" :
"%s%4.1f%% %s"), first++ == 0 ? "" : ", ",
value / 10., thisname);
}
}
putn();
}
return;
}
for (cpu = 0; cpu < ncpu; cpu++) {
/* now walk thru the names and print the line */
names = cpustate_names;
first = 0;
states = ostates + (CPUSTATES * cpu);
if (screen_length > 2 + cpu || !smart_terminal) {
move(2 + cpu, 0);
clrtoeol();
addstrp(cpustates_tag(cpu));
while ((thisname = *names++) != NULL) {
if (*thisname != '\0') {
/* retrieve the value and remember it */
value = *states++;
/* if percentage is >= 1000, print it as 100% */
printwp((value >= 1000 ? "%s%4.0f%% %s" :
"%s%4.1f%% %s"), first++ == 0 ? "" : ", ",
value / 10., thisname);
}
}
putn();
}
}
}
int nt_texec(char *prog, char**args ) {
STARTUPINFO si;
PROCESS_INFORMATION pi;
HANDLE htemp;
DWORD type=0;
DWORD dwCreationflags;
unsigned int priority;
char *argv0 = NULL, *savepath = NULL;
char *cmdstr,*cmdend ;
char *originalPtr = NULL;
unsigned int cmdsize,cmdlen;
char *p2;
char **savedargs;
int retries=0;
int hasdot =0;
int is_winnt=0;
int retval = 1;
memset(&si,0,sizeof(si));
savedargs = args;
/* MUST FREE !! */
originalPtr = cmdstr= heap_alloc(MAX_PATH<<2);
cmdsize = MAX_PATH<<2;
is_winnt = (gdwPlatform != VER_PLATFORM_WIN32_WINDOWS);
p2 = cmdstr;
cmdlen = 0;
cmdlen += copy_quote_and_fix_slashes(prog,cmdstr,&hasdot);
p2 += cmdlen;
if (*cmdstr != '"') {
// If not quoted, skip initial character we left for quote
*cmdstr = 'A';
cmdstr++;
cmdsize--;
}
*p2 = 0;
cmdend = p2;
if (!is_winnt) {
argv0 = NULL;
}
else {
argv0= heap_alloc(MAX_PATH);
(void)StringCbPrintf(argv0,MAX_PATH,"%s",prog);
}
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES;
htemp= (HANDLE)_get_osfhandle(SHIN);
DuplicateHandle(GetCurrentProcess(),htemp,GetCurrentProcess(),
&si.hStdInput,0,TRUE,DUPLICATE_SAME_ACCESS);
htemp= (HANDLE)_get_osfhandle(SHOUT);
DuplicateHandle(GetCurrentProcess(),htemp,GetCurrentProcess(),
&si.hStdOutput,0,TRUE,DUPLICATE_SAME_ACCESS);
htemp= (HANDLE)_get_osfhandle(SHDIAG);
DuplicateHandle(GetCurrentProcess(),htemp,GetCurrentProcess(),
&si.hStdError,0,TRUE,DUPLICATE_SAME_ACCESS);
/*
quotespace hack needed since execv() would have separated args, but
createproces doesnt
-amol 9/14/96
*/
args++; // the first arg is the command
dprintf("nt_texec calling c_a_a_q");
if(concat_args_and_quote(args,&originalPtr,&cmdstr,&cmdlen,&cmdend,&cmdsize) == NULL)
{
retval = 1;
errno = ENOMEM;
heap_free(originalPtr);
goto free_mem;
}
*cmdend = 0;
dwCreationflags = GetPriorityClass(GetCurrentProcess());
priority = GetThreadPriority(GetCurrentThread());
if (is_winnt) {
retries = 0;
// For NT, try ShellExecuteEx first
do {
if (GetBinaryType(argv0,&type))
break;
if (GetLastError() == ERROR_BAD_EXE_FORMAT){
errno = ENOEXEC;
if (!__nt_only_start_exes)
try_shell_ex(savedargs,0,FALSE);
if (errno) {
retval = 1;
goto free_mem;
}
else {
retval = 0;
goto free_mem;
}
}
// only try shellex again after appending ".exe fails
else if ( retries > 1 ){
if (
( (argv0[0] == '\\') ||(argv0[0] == '/') ) &&
( (argv0[1] == '\\') ||(argv0[1] == '/') ) &&
(!args[1])
)
if (!__nt_only_start_exes)
try_shell_ex(savedargs,0,FALSE);
errno = ENOENT;
}
if (retries == 0)
(void)StringCbPrintf(argv0,MAX_PATH,"%s.exe",prog);
else if (retries == 1) {
(void)StringCbPrintf(argv0,MAX_PATH,"%s.EXE",prog);
}
retries++;
}while(retries < 3);
}
savepath = fix_path_for_child();
re_cp:
dprintf("nt_texec cmdstr %s\n",cmdstr);
if (!CreateProcess(argv0,
cmdstr,
NULL,
NULL,
TRUE, // need this for redirecting std handles
dwCreationflags,
NULL,//envcrap,
NULL,
&si,
&pi) ){
if (GetLastError() == ERROR_BAD_EXE_FORMAT) {
errno = ENOEXEC;
}
else if (GetLastError() == ERROR_INVALID_PARAMETER) {
errno = ENAMETOOLONG;
}else {
errno = ENOENT;
}
if (!is_winnt && !hasdot) { //append '.' to the end if needed
StringCbCat(cmdstr,cmdsize,".");
hasdot=1;
goto re_cp;
}
retval = 1;
}
else{
int gui_app ;
DWORD exitcode;
char guivar[50];
if (GetEnvironmentVariable("TCSH_NOASYNCGUI",guivar,50))
gui_app=0;
else
gui_app= is_gui(argv0);
if(!gui_app) {
WaitForSingleObject(pi.hProcess,INFINITE);
(void)GetExitCodeProcess(pi.hProcess,&exitcode);
setv(STRstatus, putn(exitcode), VAR_READWRITE);/*FIXRESET*/
}
retval = 0;
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
free_mem:
CloseHandle(si.hStdInput);
CloseHandle(si.hStdOutput);
CloseHandle(si.hStdError);
if(savepath)
restore_path(savepath);
heap_free(originalPtr);
if (argv0)
heap_free(argv0);
return retval;
}
/*
* Form a shell temporary file (in unit 0) from the words
* of the shell input up to EOF or a line the same as "term".
* Unit 0 should have been closed before this call.
*/
void
heredoc(Char *term)
{
eChar c;
Char *Dv[2];
struct Strbuf lbuf = Strbuf_INIT, mbuf = Strbuf_INIT;
Char obuf[BUFSIZE + 1];
#define OBUF_END (obuf + sizeof(obuf) / sizeof (*obuf) - 1)
Char *lbp, *obp, *mbp;
Char **vp;
int quoted;
char *tmp;
#ifndef WINNT_NATIVE
struct timeval tv;
again:
#endif /* WINNT_NATIVE */
tmp = short2str(shtemp);
#ifndef O_CREAT
# define O_CREAT 0
if (xcreat(tmp, 0600) < 0)
stderror(ERR_SYSTEM, tmp, strerror(errno));
#endif
xclose(0);
#ifndef O_TEMPORARY
# define O_TEMPORARY 0
#endif
#ifndef O_EXCL
# define O_EXCL 0
#endif
if (xopen(tmp, O_RDWR|O_CREAT|O_EXCL|O_TEMPORARY|O_LARGEFILE, 0600) ==
-1) {
int oerrno = errno;
#ifndef WINNT_NATIVE
if (errno == EEXIST) {
if (unlink(tmp) == -1) {
(void) gettimeofday(&tv, NULL);
xfree(shtemp);
mbp = putn((((int)tv.tv_sec) ^
((int)tv.tv_usec) ^ ((int)getpid())) & 0x00ffffff);
shtemp = Strspl(STRtmpsh, mbp);
xfree(mbp);
}
goto again;
}
#endif /* WINNT_NATIVE */
(void) unlink(tmp);
errno = oerrno;
stderror(ERR_SYSTEM, tmp, strerror(errno));
}
(void) unlink(tmp); /* 0 0 inode! */
Dv[0] = term;
Dv[1] = NULL;
gflag = 0;
trim(Dv);
rscan(Dv, Dtestq);
quoted = gflag;
obp = obuf;
obuf[BUFSIZE] = 0;
inheredoc = 1;
cleanup_push(&inheredoc, inheredoc_cleanup);
#ifdef WINNT_NATIVE
__dup_stdin = 1;
#endif /* WINNT_NATIVE */
cleanup_push(&lbuf, Strbuf_cleanup);
cleanup_push(&mbuf, Strbuf_cleanup);
for (;;) {
Char **words;
/*
* Read up a line
*/
lbuf.len = 0;
for (;;) {
c = readc(1); /* 1 -> Want EOF returns */
if (c == CHAR_ERR || c == '\n')
break;
if ((c &= TRIM) != 0)
Strbuf_append1(&lbuf, (Char) c);
}
Strbuf_terminate(&lbuf);
/*
* Check for EOF or compare to terminator -- before expansion
*/
if (c == CHAR_ERR || eq(lbuf.s, term))
break;
/*
* If term was quoted or -n just pass it on
*/
if (quoted || noexec) {
Strbuf_append1(&lbuf, '\n');
Strbuf_terminate(&lbuf);
for (lbp = lbuf.s; (c = *lbp++) != 0;) {
*obp++ = (Char) c;
if (obp == OBUF_END) {
tmp = short2str(obuf);
(void) xwrite(0, tmp, strlen (tmp));
obp = obuf;
}
}
continue;
}
/*
* Term wasn't quoted so variable and then command expand the input
* line
*/
Dcp = lbuf.s;
Dvp = Dv + 1;
mbuf.len = 0;
for (;;) {
c = DgetC(DODOL);
if (c == DEOF)
break;
if ((c &= TRIM) == 0)
continue;
/* \ quotes \ $ ` here */
if (c == '\\') {
c = DgetC(0);
if (!any("$\\`", c))
unDgetC(c | QUOTE), c = '\\';
else
c |= QUOTE;
}
Strbuf_append1(&mbuf, (Char) c);
}
Strbuf_terminate(&mbuf);
/*
* If any ` in line do command substitution
*/
mbp = mbuf.s;
if (Strchr(mbp, '`') != NULL) {
/*
* 1 arg to dobackp causes substitution to be literal. Words are
* broken only at newlines so that all blanks and tabs are
* preserved. Blank lines (null words) are not discarded.
*/
words = dobackp(mbp, 1);
}
else
/* Setup trivial vector similar to return of dobackp */
Dv[0] = mbp, Dv[1] = NULL, words = Dv;
/*
* Resurrect the words from the command substitution each separated by
* a newline. Note that the last newline of a command substitution
* will have been discarded, but we put a newline after the last word
* because this represents the newline after the last input line!
*/
for (vp= words; *vp; vp++) {
for (mbp = *vp; *mbp; mbp++) {
*obp++ = *mbp & TRIM;
if (obp == OBUF_END) {
tmp = short2str(obuf);
(void) xwrite(0, tmp, strlen (tmp));
obp = obuf;
}
}
*obp++ = '\n';
if (obp == OBUF_END) {
tmp = short2str(obuf);
(void) xwrite(0, tmp, strlen (tmp));
obp = obuf;
}
}
if (words != Dv)
blkfree(words);
}
*obp = 0;
tmp = short2str(obuf);
(void) xwrite(0, tmp, strlen (tmp));
(void) lseek(0, (off_t) 0, L_SET);
cleanup_until(&inheredoc);
}
