void printaliasnode(HashNode hn, int printflags) { Alias a = (Alias) hn; if (printflags & PRINT_NAMEONLY) { zputs(a->nam, stdout); putchar('\n'); return; } if (printflags & PRINT_WHENCE_SIMPLE) { zputs(a->text, stdout); putchar('\n'); return; } if (printflags & PRINT_WHENCE_CSH) { nicezputs(a->nam, stdout); if (a->flags & ALIAS_GLOBAL) printf(": globally aliased to "); else printf(": aliased to "); nicezputs(a->text, stdout); putchar('\n'); return; } if (printflags & PRINT_WHENCE_VERBOSE) { nicezputs(a->nam, stdout); if (a->flags & ALIAS_GLOBAL) printf(" is a global alias for "); else printf(" is an alias for "); nicezputs(a->text, stdout); putchar('\n'); return; } if (printflags & PRINT_LIST) { printf("alias "); if (a->flags & ALIAS_GLOBAL) printf("-g "); /* If an alias begins with `-', then we must output `-- ' * * first, so that it is not interpreted as an option. */ if(a->nam[0] == '-') printf("-- "); } quotedzputs(a->nam, stdout); putchar('='); quotedzputs(a->text, stdout); putchar('\n'); }
static void printshfuncnode(HashNode hn, int printflags) { Shfunc f = (Shfunc) hn; char *t = 0; if ((printflags & PRINT_NAMEONLY) || ((printflags & PRINT_WHENCE_SIMPLE) && !(printflags & PRINT_WHENCE_FUNCDEF))) { zputs(f->nam, stdout); putchar('\n'); return; } if ((printflags & (PRINT_WHENCE_VERBOSE|PRINT_WHENCE_WORD)) && !(printflags & PRINT_WHENCE_FUNCDEF)) { nicezputs(f->nam, stdout); printf((printflags & PRINT_WHENCE_WORD) ? ": function\n" : " is a shell function\n"); return; } quotedzputs(f->nam, stdout); if (f->funcdef || f->flags & PM_UNDEFINED) { printf(" () {\n\t"); if (f->flags & PM_UNDEFINED) printf("%c undefined\n\t", hashchar); else t = getpermtext(f->funcdef, NULL); if (f->flags & PM_TAGGED) printf("%c traced\n\t", hashchar); if (!t) { char *fopt = "Utkz"; int flgs[] = { PM_UNALIASED, PM_TAGGED, PM_KSHSTORED, PM_ZSHSTORED, 0 }; int fl;; zputs("builtin autoload -X", stdout); for (fl=0;fopt[fl];fl++) if (f->flags & flgs[fl]) putchar(fopt[fl]); } else { zputs(t, stdout); zsfree(t); if (f->funcdef->flags & EF_RUN) { printf("\n\t"); quotedzputs(f->nam, stdout); printf(" \"$@\""); } } printf("\n}\n"); } else { printf(" () { }\n"); } }
void printcmdnamnode(HashNode hn, int printflags) { Cmdnam cn = (Cmdnam) hn; if ((printflags & PRINT_WHENCE_CSH) || (printflags & PRINT_WHENCE_SIMPLE)) { if (cn->flags & HASHED) { zputs(cn->u.cmd, stdout); putchar('\n'); } else { zputs(*(cn->u.name), stdout); putchar('/'); zputs(cn->nam, stdout); putchar('\n'); } return; } if (printflags & PRINT_WHENCE_VERBOSE) { if (cn->flags & HASHED) { nicezputs(cn->nam, stdout); printf(" is hashed to "); nicezputs(cn->u.cmd, stdout); putchar('\n'); } else { nicezputs(cn->nam, stdout); printf(" is "); nicezputs(*(cn->u.name), stdout); putchar('/'); nicezputs(cn->nam, stdout); putchar('\n'); } return; } if (cn->flags & HASHED) { quotedzputs(cn->nam, stdout); putchar('='); quotedzputs(cn->u.cmd, stdout); putchar('\n'); } else { quotedzputs(cn->nam, stdout); putchar('='); quotedzputs(*(cn->u.name), stdout); putchar('/'); quotedzputs(cn->nam, stdout); putchar('\n'); } }
int main(void) { sysinit(); lcd_init(); for(;;) { zputs(PSTR("Hello, world!")); wait(); zputc_rep(10, 'x'); wait(); zputs_rev("9876543210", 10); wait(); zput_dec(1); zput_dec(200); zput_dec(30000); zput_dec(-30000); wait(); zput_udec(1); zput_udec(200); zput_udec(30000); zput_udec(65535); wait(); zput_hex(1); zput_hex(0xeeee); wait(); } return 0; }
int printbind(char *str, FILE *stream) { char *b = bindztrdup(str); int ret = zputs(b, stream); zsfree(b); return ret; }
void printshfuncnode(HashNode hn, int printflags) { Shfunc f = (Shfunc) hn; char *t; if ((printflags & PRINT_NAMEONLY) || ((printflags & PRINT_WHENCE_SIMPLE) && !(printflags & PRINT_WHENCE_FUNCDEF))) { zputs(f->nam, stdout); putchar('\n'); return; } if ((printflags & PRINT_WHENCE_VERBOSE) && !(printflags & PRINT_WHENCE_FUNCDEF)) { nicezputs(f->nam, stdout); printf(" is a shell function\n"); return; } if (f->flags & PM_UNDEFINED) printf("undefined "); if (f->flags & PM_TAGGED) printf("traced "); if (!f->funcdef) { nicezputs(f->nam, stdout); printf(" () { }\n"); return; } t = getpermtext((void *) dupstruct((void *) f->funcdef)); quotedzputs(f->nam, stdout); printf(" () {\n\t"); zputs(t, stdout); printf("\n}\n"); zsfree(t); }
void test_single_functions() { zputs("Hello, world!\n"); zputc_rep(10, 'x'); zputc('\n'); zputs_rev("9876543210", 10); zputc('\n'); zput_dec(1); zput_dec(200); zput_dec(30000); zput_dec(-30000); zputc('\n'); zput_udec(1); zput_udec(200); zput_udec(30000); zput_udec(65535); zputc('\n'); zput_hex(1); zput_hex(0xeeee); zputc('\n'); }
void printnameddirnode(HashNode hn, int printflags) { Nameddir nd = (Nameddir) hn; if (printflags & PRINT_NAMEONLY) { zputs(nd->nam, stdout); putchar('\n'); return; } quotedzputs(nd->nam, stdout); putchar('='); quotedzputs(nd->dir, stdout); putchar('\n'); }
static void printnameddirnode(HashNode hn, int printflags) { Nameddir nd = (Nameddir) hn; if (printflags & PRINT_NAMEONLY) { zputs(nd->nam, stdout); putchar('\n'); return; } if (printflags & PRINT_LIST) { printf("hash -d "); if(nd->nam[0] == '-') printf("-- "); } quotedzputs(nd->nam, stdout); putchar('='); quotedzputs(nd->dir, stdout); putchar('\n'); }
static int inputline(void) { char *ingetcline, **ingetcpmptl = NULL, **ingetcpmptr = NULL; int context = ZLCON_LINE_START; /* If reading code interactively, work out the prompts. */ if (interact && isset(SHINSTDIN)) { if (!isfirstln) { ingetcpmptl = &prompt2; if (rprompt2) ingetcpmptr = &rprompt2; context = ZLCON_LINE_CONT; } else { ingetcpmptl = &prompt; if (rprompt) ingetcpmptr = &rprompt; } } if (!(interact && isset(SHINSTDIN) && SHTTY != -1 && isset(USEZLE))) { /* * If not using zle, read the line straight from the input file. * Possibly we don't get the whole line at once: in that case, * we get another chunk with the next call to inputline(). */ if (interact && isset(SHINSTDIN)) { /* * We may still be interactive (e.g. running under emacs), * so output a prompt if necessary. We don't know enough * about the input device to be able to handle an rprompt, * though. */ char *pptbuf; int pptlen; pptbuf = unmetafy(promptexpand(ingetcpmptl ? *ingetcpmptl : NULL, 0, NULL, NULL, NULL), &pptlen); write_loop(2, pptbuf, pptlen); free(pptbuf); } ingetcline = shingetline(); } else { /* * Since we may have to read multiple lines before getting * a complete piece of input, we tell zle not to restore the * original tty settings after reading each chunk. Instead, * this is done when the history mechanism for the current input * terminates, which is not until we have the whole input. * This is supposed to minimise problems on systems that clobber * typeahead when the terminal settings are altered. * pws 1998/03/12 */ int flags = ZLRF_HISTORY|ZLRF_NOSETTY; if (isset(IGNOREEOF)) flags |= ZLRF_IGNOREEOF; ingetcline = zleentry(ZLE_CMD_READ, ingetcpmptl, ingetcpmptr, flags, context); histdone |= HISTFLAG_SETTY; } if (!ingetcline) { return lexstop = 1; } if (errflag) { free(ingetcline); errflag |= ERRFLAG_ERROR; return lexstop = 1; } if (isset(VERBOSE)) { /* Output the whole line read so far. */ zputs(ingetcline, stderr); fflush(stderr); } if (keyboardhackchar && *ingetcline && ingetcline[strlen(ingetcline) - 1] == '\n' && interact && isset(SHINSTDIN) && SHTTY != -1 && ingetcline[1]) { char *stripptr = ingetcline + strlen(ingetcline) - 2; if (*stripptr == keyboardhackchar) { /* Junk an unwanted character at the end of the line. (key too close to return key) */ int ct = 1; /* force odd */ char *ptr; if (keyboardhackchar == '\'' || keyboardhackchar == '"' || keyboardhackchar == '`') { /* * for the chars above, also require an odd count before * junking */ for (ct = 0, ptr = ingetcline; *ptr; ptr++) if (*ptr == keyboardhackchar) ct++; } if (ct & 1) { stripptr[0] = '\n'; stripptr[1] = '\0'; } } } isfirstch = 1; if ((inbufflags & INP_APPEND) && inbuf) { /* * We need new input but need to be able to back up * over the old input, so append this line. * Pushing the line onto the stack doesn't have the right * effect. * * This is quite a simple and inefficient fix, but currently * we only need it when backing up over a multi-line $((... * that turned out to be a command substitution rather than * a math substitution, which is a very special case. * So it's not worth rewriting. */ char *oinbuf = inbuf; int newlen = strlen(ingetcline); int oldlen = (int)(inbufptr - inbuf) + inbufleft; if (inbufflags & INP_FREE) { inbuf = realloc(inbuf, oldlen + newlen + 1); } else { inbuf = zalloc(oldlen + newlen + 1); memcpy(inbuf, oinbuf, oldlen); } inbufptr += inbuf - oinbuf; strcpy(inbuf + oldlen, ingetcline); free(ingetcline); inbufleft += newlen; inbufct += newlen; inbufflags |= INP_FREE; } else { /* Put this into the input channel. */ inputsetline(ingetcline, INP_FREE); } return 0; }
int execselect(Estate state, UNUSED(int do_exec)) { Wordcode end, loop; wordcode code = state->pc[-1]; char *str, *s, *name; LinkNode n; int i, usezle; FILE *inp; size_t more; LinkList args; int old_simple_pline = simple_pline; /* See comments in execwhile() */ simple_pline = 1; end = state->pc + WC_FOR_SKIP(code); name = ecgetstr(state, EC_NODUP, NULL); if (WC_SELECT_TYPE(code) == WC_SELECT_PPARAM) { char **x; args = newlinklist(); for (x = pparams; *x; x++) addlinknode(args, dupstring(*x)); } else { int htok = 0; if (!(args = ecgetlist(state, *state->pc++, EC_DUPTOK, &htok))) { state->pc = end; simple_pline = old_simple_pline; return 0; } if (htok) { execsubst(args); if (errflag) { state->pc = end; simple_pline = old_simple_pline; return 1; } } } if (!args || empty(args)) { state->pc = end; simple_pline = old_simple_pline; return 0; } loops++; pushheap(); cmdpush(CS_SELECT); usezle = interact && SHTTY != -1 && isset(USEZLE); inp = fdopen(dup(usezle ? SHTTY : 0), "r"); more = selectlist(args, 0); loop = state->pc; for (;;) { for (;;) { if (empty(bufstack)) { if (usezle) { int oef = errflag; isfirstln = 1; str = zleentry(ZLE_CMD_READ, &prompt3, NULL, 0, ZLCON_SELECT); if (errflag) str = NULL; /* Keep any user interrupt error status */ errflag = oef | (errflag & ERRFLAG_INT); } else { str = promptexpand(prompt3, 0, NULL, NULL, NULL); zputs(str, stderr); free(str); fflush(stderr); str = fgets(zhalloc(256), 256, inp); } } else str = (char *)getlinknode(bufstack); if (!str && !errflag) setsparam("REPLY", ztrdup("")); /* EOF (user pressed Ctrl+D) */ if (!str || errflag) { if (breaks) breaks--; fprintf(stderr, "\n"); fflush(stderr); goto done; } if ((s = strchr(str, '\n'))) *s = '\0'; if (*str) break; more = selectlist(args, more); } setsparam("REPLY", ztrdup(str)); i = atoi(str); if (!i) str = ""; else { for (i--, n = firstnode(args); n && i; incnode(n), i--); if (n) str = (char *) getdata(n); else str = ""; } setsparam(name, ztrdup(str)); state->pc = loop; execlist(state, 1, 0); freeheap(); if (breaks) { breaks--; if (breaks || !contflag) break; contflag = 0; } if (retflag || errflag) break; } done: cmdpop(); popheap(); fclose(inp); loops--; simple_pline = old_simple_pline; state->pc = end; return lastval; }
static int inputline(void) { char *ingetcline, **ingetcpmptl = NULL, **ingetcpmptr = NULL; int context = ZLCON_LINE_START; /* If reading code interactively, work out the prompts. */ if (interact && isset(SHINSTDIN)) { if (!isfirstln) { ingetcpmptl = &prompt2; if (rprompt2) ingetcpmptr = &rprompt2; context = ZLCON_LINE_CONT; } else { ingetcpmptl = &prompt; if (rprompt) ingetcpmptr = &rprompt; } } if (!(interact && isset(SHINSTDIN) && SHTTY != -1 && isset(USEZLE))) { /* * If not using zle, read the line straight from the input file. * Possibly we don't get the whole line at once: in that case, * we get another chunk with the next call to inputline(). */ if (interact && isset(SHINSTDIN)) { /* * We may still be interactive (e.g. running under emacs), * so output a prompt if necessary. We don't know enough * about the input device to be able to handle an rprompt, * though. */ char *pptbuf; int pptlen; pptbuf = unmetafy(promptexpand(ingetcpmptl ? *ingetcpmptl : NULL, 0, NULL, NULL, NULL), &pptlen); write_loop(2, pptbuf, pptlen); free(pptbuf); } ingetcline = shingetline(); } else { /* * Since we may have to read multiple lines before getting * a complete piece of input, we tell zle not to restore the * original tty settings after reading each chunk. Instead, * this is done when the history mechanism for the current input * terminates, which is not until we have the whole input. * This is supposed to minimise problems on systems that clobber * typeahead when the terminal settings are altered. * pws 1998/03/12 */ int flags = ZLRF_HISTORY|ZLRF_NOSETTY; if (isset(IGNOREEOF)) flags |= ZLRF_IGNOREEOF; ingetcline = zleentry(ZLE_CMD_READ, ingetcpmptl, ingetcpmptr, flags, context); histdone |= HISTFLAG_SETTY; } if (!ingetcline) { return lexstop = 1; } if (errflag) { free(ingetcline); return lexstop = errflag = 1; } if (isset(VERBOSE)) { /* Output the whole line read so far. */ zputs(ingetcline, stderr); fflush(stderr); } if (keyboardhackchar && *ingetcline && ingetcline[strlen(ingetcline) - 1] == '\n' && interact && isset(SHINSTDIN) && SHTTY != -1 && ingetcline[1]) { char *stripptr = ingetcline + strlen(ingetcline) - 2; if (*stripptr == keyboardhackchar) { /* Junk an unwanted character at the end of the line. (key too close to return key) */ int ct = 1; /* force odd */ char *ptr; if (keyboardhackchar == '\'' || keyboardhackchar == '"' || keyboardhackchar == '`') { /* * for the chars above, also require an odd count before * junking */ for (ct = 0, ptr = ingetcline; *ptr; ptr++) if (*ptr == keyboardhackchar) ct++; } if (ct & 1) { stripptr[0] = '\n'; stripptr[1] = '\0'; } } } isfirstch = 1; /* Put this into the input channel. */ inputsetline(ingetcline, INP_FREE); return 0; }
static void printcmdnamnode(HashNode hn, int printflags) { Cmdnam cn = (Cmdnam) hn; if (printflags & PRINT_WHENCE_WORD) { printf("%s: %s\n", cn->nam, (cn->flags & HASHED) ? "hashed" : "command"); return; } if ((printflags & PRINT_WHENCE_CSH) || (printflags & PRINT_WHENCE_SIMPLE)) { if (cn->flags & HASHED) { zputs(cn->u.cmd, stdout); putchar('\n'); } else { zputs(*(cn->u.name), stdout); putchar('/'); zputs(cn->nam, stdout); putchar('\n'); } return; } if (printflags & PRINT_WHENCE_VERBOSE) { if (cn->flags & HASHED) { nicezputs(cn->nam, stdout); printf(" is hashed to "); nicezputs(cn->u.cmd, stdout); putchar('\n'); } else { nicezputs(cn->nam, stdout); printf(" is "); nicezputs(*(cn->u.name), stdout); putchar('/'); nicezputs(cn->nam, stdout); putchar('\n'); } return; } if (printflags & PRINT_LIST) { printf("hash "); if(cn->nam[0] == '-') printf("-- "); } if (cn->flags & HASHED) { quotedzputs(cn->nam, stdout); putchar('='); quotedzputs(cn->u.cmd, stdout); putchar('\n'); } else { quotedzputs(cn->nam, stdout); putchar('='); quotedzputs(*(cn->u.name), stdout); putchar('/'); quotedzputs(cn->nam, stdout); putchar('\n'); } }
mod_export void showmsg(char const *msg) { char const *p; int up = 0, cc = 0; ZLE_CHAR_T c; #ifdef MULTIBYTE_SUPPORT char *umsg; int ulen, eol = 0; size_t width; mbstate_t mbs; #endif trashzle(); clearflag = isset(USEZLE) && !termflags && isset(ALWAYSLASTPROMPT); #ifdef MULTIBYTE_SUPPORT umsg = ztrdup(msg); p = unmetafy(umsg, &ulen); memset(&mbs, 0, sizeof mbs); mb_metacharinit(); while (ulen > 0) { char const *n; if (*p == '\n') { ulen--; p++; putc('\n', shout); up += 1 + cc / zterm_columns; cc = 0; } else { /* * Extract the next wide character from the multibyte string. */ size_t cnt = eol ? MB_INVALID : mbrtowc(&c, p, ulen, &mbs); switch (cnt) { case MB_INCOMPLETE: eol = 1; /* FALL THROUGH */ case MB_INVALID: /* * This really shouldn't be happening here, but... * Treat it as a single byte character; it may get * prettified. */ memset(&mbs, 0, sizeof mbs); n = nicechar(*p); cnt = 1; width = strlen(n); break; case 0: cnt = 1; /* FALL THROUGH */ default: /* * Paranoia: only needed if we start in the middle * of a multibyte string and only in some implementations. */ if (cnt > (size_t)ulen) cnt = ulen; n = wcs_nicechar(c, &width, NULL); break; } ulen -= cnt; p += cnt; zputs(n, shout); cc += width; } } free(umsg); #else for(p = msg; (c = *p); p++) { if(c == Meta) c = *++p ^ 32; if(c == '\n') { putc('\n', shout); up += 1 + cc / zterm_columns; cc = 0; } else { char const *n = nicechar(c); zputs(n, shout); cc += strlen(n); } } #endif up += cc / zterm_columns; if (clearflag) { putc('\r', shout); tcmultout(TCUP, TCMULTUP, up + nlnct); } else putc('\n', shout); showinglist = 0; }
static void printshfuncnode(HashNode hn, int printflags) { Shfunc f = (Shfunc) hn; char *t = 0; if ((printflags & PRINT_NAMEONLY) || ((printflags & PRINT_WHENCE_SIMPLE) && !(printflags & PRINT_WHENCE_FUNCDEF))) { zputs(f->node.nam, stdout); putchar('\n'); return; } if ((printflags & (PRINT_WHENCE_VERBOSE|PRINT_WHENCE_WORD)) && !(printflags & PRINT_WHENCE_FUNCDEF)) { nicezputs(f->node.nam, stdout); printf((printflags & PRINT_WHENCE_WORD) ? ": function" : (f->node.flags & PM_UNDEFINED) ? " is an autoload shell function" : " is a shell function"); if (f->filename && (printflags & PRINT_WHENCE_VERBOSE) && strcmp(f->filename, f->node.nam) != 0) { printf(" from "); quotedzputs(f->filename, stdout); } putchar('\n'); return; } quotedzputs(f->node.nam, stdout); if (f->funcdef || f->node.flags & PM_UNDEFINED) { printf(" () {\n"); zoutputtab(stdout); if (f->node.flags & PM_UNDEFINED) { printf("%c undefined\n", hashchar); zoutputtab(stdout); } else t = getpermtext(f->funcdef, NULL, 1); if (f->node.flags & (PM_TAGGED|PM_TAGGED_LOCAL)) { printf("%c traced\n", hashchar); zoutputtab(stdout); } if (!t) { char *fopt = "UtTkz"; int flgs[] = { PM_UNALIASED, PM_TAGGED, PM_TAGGED_LOCAL, PM_KSHSTORED, PM_ZSHSTORED, 0 }; int fl;; zputs("builtin autoload -X", stdout); for (fl=0;fopt[fl];fl++) if (f->node.flags & flgs[fl]) putchar(fopt[fl]); } else { zputs(t, stdout); zsfree(t); if (f->funcdef->flags & EF_RUN) { printf("\n"); zoutputtab(stdout); quotedzputs(f->node.nam, stdout); printf(" \"$@\""); } } printf("\n}"); } else { printf(" () { }"); } if (f->redir) { t = getpermtext(f->redir, NULL, 1); if (t) { zputs(t, stdout); zsfree(t); } } putchar('\n'); }
void printparamnode(HashNode hn, int printflags) { #ifdef ZSH_64_BIT_TYPE static char llbuf[DIGBUFSIZE]; #endif Param p = (Param) hn; char *t, **u; if (p->flags & PM_UNSET) return; /* Print the attributes of the parameter */ if (printflags & PRINT_TYPE) { if (p->flags & PM_INTEGER) printf("integer "); if (p->flags & PM_ARRAY) printf("array "); if (p->flags & PM_LEFT) printf("left justified %d ", p->ct); if (p->flags & PM_RIGHT_B) printf("right justified %d ", p->ct); if (p->flags & PM_RIGHT_Z) printf("zero filled %d ", p->ct); if (p->flags & PM_LOWER) printf("lowercase "); if (p->flags & PM_UPPER) printf("uppercase "); if (p->flags & PM_READONLY) printf("readonly "); if (p->flags & PM_TAGGED) printf("tagged "); if (p->flags & PM_EXPORTED) printf("exported "); } if (printflags & PRINT_NAMEONLY) { zputs(p->nam, stdout); putchar('\n'); return; } /* How the value is displayed depends * * on the type of the parameter */ quotedzputs(p->nam, stdout); putchar('='); switch (PM_TYPE(p->flags)) { case PM_SCALAR: /* string: simple output */ if (p->gets.cfn && (t = p->gets.cfn(p))) quotedzputs(t, stdout); putchar('\n'); break; case PM_INTEGER: /* integer */ #ifdef ZSH_64_BIT_TYPE convbase(llbuf, p->gets.ifn(p), 0); puts(llbuf); #else printf("%ld\n", p->gets.ifn(p)); #endif break; case PM_ARRAY: /* array */ putchar('('); u = p->gets.afn(p); if(*u) { quotedzputs(*u++, stdout); while (*u) { putchar(' '); quotedzputs(*u++, stdout); } } printf(")\n"); break; } }