CHAR
CHAR(pvec, i) = (char) (rand()/RAND_DIV);
CHAR(msgbuf, n) ^= CHAR(ivec, n);
CHAR(msgbuf, 7) = n;
CHAR(msgbuf, n) ^= CHAR(ivec, n);
n = CHAR(msgbuf, 7);
while (p[0] == CHAR && !ISDIRSEP(p[1])
r = (p[0] == EOS || p[0] == CHAR || p[0] == CSUBST) ? tilde(Xstring(ts, tp)) : (char *) 0;
case CHAR:
c = word[slen = 0] == CHAR ? word[1] : 0;
c = word[slen + 0] == CHAR ? word[slen + 1] : 0;
if (word[slen + 0] == CHAR && c == word[slen + 1]) {
for (p = *te->pos.wp; *p == CHAR; p += 2)
for (p = *te->pos.wp; *p == CHAR
*wp++ = CHAR;
*wp++ = CHAR;
*wp++ = CHAR;
*wp++ = CHAR, *wp++ = '\\';
*wp++ = CHAR, *wp++ = c;
*wp++ = CHAR, *wp++ = c;
*wp++ = CHAR, *wp++ = '$';
*wp++ = CHAR, *wp++ = c;
*wp++ = CHAR;
*wp++ = CHAR;
*wp++ = CHAR;
|| (c2 == 2 && dp[0] == CHAR && digit(dp[1]))))
for (sp = yylval.cp, dp = ident; dp < ident+IDENT && (c = *sp++) == CHAR; )
static const char let_cmd[] = { CHAR, 'l', CHAR, 'e',
CHAR, 't', EOS };
t->left->args[0][0] = CHAR;
static const char dbtest_or[] = { CHAR, '|', CHAR, '|', EOS };
static const char dbtest_and[] = { CHAR, '&', CHAR, '&', EOS };
static const char dbtest_not[] = { CHAR, '!', EOS };
static const char dbtest_oparen[] = { CHAR, '(', EOS };
static const char dbtest_cparen[] = { CHAR, ')', EOS };
const char db_close[] = { CHAR, ']', CHAR, ']', EOS };
const char db_lthan[] = { CHAR, '<', EOS };
const char db_gthan[] = { CHAR, '>', EOS };
case CHAR:
case CHAR:
case CHAR:
if (s[0] == CHAR && letter(s[1])) {
while (s[0] == CHAR && letnum(s[1]));
if (aok && s[0] == CHAR && s[1] == '[') {
if (p[0] != CHAR)
return p != s && p[0] == CHAR && p[1] == '=';
case CHAR:
case CHAR:
case CHAR:
setbit(location[deposit].objects, CHAR);
(void)printf("%c", CHAR(*p));
*bufnext++ = CHAR(c);
*bufnext++ = CHAR(c);
*bufnext++ = CHAR(c);
(void)putchar(CHAR(msgbuf, n));
CHAR(msgbuf, 0) = 0x00;
CHAR(msgbuf, 0) |= (CHAR(msgbuf, n)&bits[j]);
(void)putchar(CHAR(msgbuf, 0));
*to++ = (CHAR(from, i)>>(7-j))&01;
CHAR(to, i) = 0;
CHAR(to, i) = ((*from++)<<(7-j))|CHAR(to, i);
MEMZERO(&CHAR(msgbuf, n), 8 - n);
CHAR(msgbuf, 7) = n;
n = CHAR(msgbuf, 7);
CHAR(msgbuf, n) ^= CHAR(ivec, n);
MEMZERO(&CHAR(msgbuf, n), 8 - n);
CHAR(msgbuf, 7) = n;
CHAR(msgbuf, n) ^= CHAR(ivec, n);
n = CHAR(msgbuf, 7);
CHAR(encbuf, n) = CHAR(msgbuf, n) ^ CHAR(ivec, n);
MEMZERO(&CHAR(msgbuf, n), 8 - n);
CHAR(encbuf, n) = CHAR(msgbuf, n) ^ CHAR(ivec, n);
(void)putchar(CHAR(encbuf, n));
CHAR(msgbuf, 0) = 0x00;
CHAR(msgbuf, 0) |= (CHAR(encbuf, n)&bits[j]);
(void)putchar(CHAR(msgbuf, 0));
WRITE(&CHAR(ivec, 8-nbytes), nbytes);
CHAR(ivec, c) = CHAR(ivec, c+nbytes);
CHAR(ivec, 8-nbytes+c) = ibuf[c];
obuf[n] = CHAR(ivec, 8-nbytes+n)&0177;
CHAR(ivec, c) = CHAR(ivec, c+nbytes);
CHAR(ivec, 8-nbytes+c) = ibuf[c]|0200;
CHAR(ivec, c) = CHAR(ivec, c+nbytes);
CHAR(ivec, 8-nbytes+c) = UCHAR(msgbuf, c);
CHAR *c;
(unsigned)need * sizeof(CHAR))) == NULL)
CHAR *c, *endc;
static CHAR *sorted;
sizeof(CHAR) * (size_t)sorted_size)) == NULL)
CHAR *l_line; /* characters on the line */
%token CHAR COLONEQ COMPILE_WITH CONFIG
| CHAR int32 { $$ = $2; }
case CHAR:
case CHAR:
{ "escape", CHAR, (READ|WRITE)<<PUBLIC,
{ "force", CHAR, (READ|WRITE)<<PUBLIC,
{ "prompt", CHAR, (READ|WRITE)<<PUBLIC,
{ "raisechar", CHAR, (READ|WRITE)<<PUBLIC,
struct CHAR *obuf = NULL;
flushln(struct CHAR *obuf, size_t obuf_size)
overstrike(struct CHAR *obuf)
iattr(struct CHAR *obuf)
initbuf(struct CHAR *obuf, size_t obuf_size)
fwd(struct CHAR *obuf, size_t obuf_size)
reverse(struct CHAR *obuf, size_t obuf_size)
alloc_buf(struct CHAR **buf, size_t *size)
static void flushln(struct CHAR *, size_t);
static void fwd(struct CHAR *, size_t);
static void iattr(struct CHAR *);
static void initbuf(struct CHAR *, size_t);
static void overstrike(struct CHAR *);
static void reverse(struct CHAR *, size_t);
static void alloc_buf(struct CHAR **, size_t *);
tp->t_subt = gettyp(CHAR);
t == CHAR || t == SCHAR || t == UCHAR ||
return t == CHAR ? SCHAR : t;
else if (t == CHAR || t == SCHAR)
return t == CHAR ? UCHAR
st == CHAR || st == SCHAR || st == UCHAR);
(t2 == CHAR || t2 == SHORT || t2 == INT ||
if (l != NO_TSPEC && t == CHAR) {
if (t != INT && t != CHAR && (s != NO_TSPEC || l != NO_TSPEC)) {
if (t == CHAR || t == UCHAR || t == SCHAR ||
return rst == CHAR
? lst == CHAR || lst == UCHAR || lst == SCHAR
kwdef_type( "char", CHAR, 78),
? convert_integer((int64_t)val, CHAR, CHAR_SIZE)
if (lt == CHAR && is_out_of_char_range(rn)) {
if (rt == CHAR && is_out_of_char_range(ln)) {
if (lt == CHAR && rn->tn_op == CON &&
if (rt == CHAR && ln->tn_op == CON &&
tp->t_subt->t_tspec == CHAR &&
if (lstp->t_tspec == CHAR && !lstp->t_const &&
if (t == CHAR || t == SCHAR || t == SHORT)
if (t == CHAR || t == SCHAR)
return size_in_bits(CHAR) < size_in_bits(INT) ? INT : UINT;
if (nt == CHAR || nt == SCHAR || nt == UCHAR ||
(tp->t_subt->t_tspec == CHAR || tp->t_subt->t_tspec == UCHAR);
if (nst == CHAR || nst == UCHAR)
if (ost == CHAR || ost == UCHAR)
case CHAR:
if (tn->tn_type->t_subt->t_tspec != CHAR)
sym->s_type = block_derive_type(gettyp(CHAR), ARRAY);
tp->t_subt = gettyp(lit->data != NULL ? CHAR : WCHAR_TSPEC);
} else if (t == CHAR || t == SCHAR) {
if (t == CHAR || t == SCHAR || t == UCHAR)
} else if (t1 == CHAR || t1 == SCHAR) {
(t2 != CHAR && t2 != UCHAR && t2 != SCHAR)) {
} else if (t2 != CHAR && t2 != UCHAR &&
return s == 's' ? SCHAR : (s == 'u' ? UCHAR : CHAR);
t = CHAR;