bool
fill_cmnd(const char *src, size_t len)
{
char *dst;
size_t i;
debug_decl(fill_cmnd, SUDOERS_DEBUG_PARSER)
arg_len = arg_size = 0;
dst = sudoerslval.command.cmnd = malloc(len + 1);
if (dst == NULL) {
sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
sudoerserror(NULL);
debug_return_bool(false);
}
sudoerslval.command.args = NULL;
/* Copy the string and collapse any escaped sudo-specific characters. */
for (i = 0; i < len; i++) {
if (src[i] == '\\' && i != len - 1 && SPECIAL(src[i + 1]))
*dst++ = src[++i];
else
*dst++ = src[i];
}
*dst = '\0';
debug_return_bool(true);
}
/* Accessor for sym->st_shndx, hides ugliness of "64k sections" */
static inline unsigned int get_secindex(unsigned int shndx,
unsigned int sym_offs,
const Elf32_Word *symtab_shndx_start)
{
if (is_shndx_special(shndx))
return SPECIAL(shndx);
if (shndx != SHN_XINDEX)
return shndx;
return r(&symtab_shndx_start[sym_offs]);
}
static PyObject *
CP_getattro(PyObject *self, PyObject *name)
{
char *cname;
cname = PyString_AsString(name);
if (cname == NULL)
return NULL;
if (SPECIAL(cname))
/* delegate to persistent */
return cPersistenceCAPI->pertype->tp_getattro(self, name);
/* Use the wrapper version to delegate */
return wrap_getattro(self, name);
}
int delete_quest(qst_rnum rnum)
{
qst_rnum i;
zone_rnum rznum;
mob_vnum qm = QST_MASTER(rnum);
SPECIAL (*tempfunc);
int quests_remaining = 0;
if (rnum >= total_quests)
return FALSE;
rznum = real_zone_by_thing(QST_NUM(rnum));
log("GenOLC: delete_quest: Deleting quest #%d (%s).",
QST_NUM(rnum), QST_NAME(rnum));
/* make a note of the quest master's secondary spec proc */
tempfunc = QST_FUNC(rnum);
free_quest_strings(&aquest_table[rnum]);
for (i = rnum; i < total_quests - 1; i++) {
aquest_table[i] = aquest_table[i + 1];
}
total_quests--;
if (total_quests > 0)
RECREATE(aquest_table, struct aq_data, total_quests);
else {
free(aquest_table);
aquest_table = NULL;
}
if (rznum != NOWHERE)
add_to_save_list(zone_table[rznum].number, SL_QST);
else
mudlog(BRF, ADMLVL_BUILDER, TRUE,
"SYSERR: GenOLC: Cannot determine quest zone.");
/* does the questmaster mob have any quests left? */
if (qm != NOBODY) {
for (i = 0; i < total_quests; i++) {
if (QST_MASTER(i) == qm)
quests_remaining++;
}
if (quests_remaining == 0)
mob_index[qm].func = tempfunc; // point back to original spec proc
}
return TRUE;
}
void
play(Play *play)
{
/* put the pieces on the board,
* adjust the board data structures.
*/
int j;
Pos p;
char c;
firstmove = false;
/* describe the play */
if(1) {
print("(%d,%d,%c) %d ",
play->pos.x, play->pos.y, play->o ? 'V' : 'H', play->score);
wordprint(&play->word);
print("\n");
if(DBG)
score(&play->word, play->pos, play->o);
}
assert(isword(root, &play->word));
/* place the letters */
p = play->pos;
for (j= play->word.n -1; j>= 0; j--) {
if(!HASLETTER(p)){
/* place the letter on the board */
LETTER(p) = play->word.c[j];
HASLETTER(p)=true;
SPECIAL(p) = Not; /* not needed */
ISANCHOR(p) = false;
SCORE(p) = play->word.blank[j] ? 0 : points[play->word.c[j]];
adjust(p,ORTHO(play->o));
}
p = PREV(p,play->o);
}
p = NEXT(p,play->o);
adjust(p, play->o); /* squares to the sides */
}
#define SPECIALP(f, P) FTYPE_SPECIAL, 0, P, f
#define SPECIAL(f) SPECIALP(f, NULL)
} tokens[] = {
#ifdef _WIN32
#define CSIDLP(C,P) FTYPE_CSIDL, C, P, _expand_csidl
#define CSIDL(C) CSIDLP(C, NULL)
{"APPDATA", CSIDL(CSIDL_APPDATA)}, /* Roaming application data (for current user) */
{"COMMON_APPDATA", CSIDL(CSIDL_COMMON_APPDATA)}, /* Application data (all users) */
{"LOCAL_APPDATA", CSIDL(CSIDL_LOCAL_APPDATA)}, /* Local application data (for current user) */
{"SYSTEM", CSIDL(CSIDL_SYSTEM)}, /* Windows System folder (e.g. %WINDIR%\System32) */
{"WINDOWS", CSIDL(CSIDL_WINDOWS)}, /* Windows folder */
{"USERCONFIG", CSIDLP(CSIDL_APPDATA, "\\" PACKAGE)}, /* Per user Heimdal configuration file path */
{"COMMONCONFIG", CSIDLP(CSIDL_COMMON_APPDATA, "\\" PACKAGE)}, /* Common Heimdal configuration file path */
{"LIBDIR", SPECIAL(_expand_bin_dir)},
{"BINDIR", SPECIAL(_expand_bin_dir)},
{"LIBEXEC", SPECIAL(_expand_bin_dir)},
{"SBINDIR", SPECIAL(_expand_bin_dir)},
#else
{"LIBDIR", FTYPE_SPECIAL, 0, LIBDIR, _expand_path},
{"BINDIR", FTYPE_SPECIAL, 0, BINDIR, _expand_path},
{"LIBEXEC", FTYPE_SPECIAL, 0, LIBEXECDIR, _expand_path},
{"SBINDIR", FTYPE_SPECIAL, 0, SBINDIR, _expand_path},
#endif
{"TEMP", SPECIAL(_expand_temp_folder)},
{"USERID", SPECIAL(_expand_userid)},
{"uid", SPECIAL(_expand_userid)},
{"null", SPECIAL(_expand_null)}
};
void
tds_check_column_extra(const TDSCOLUMN * column)
{
int size;
TDSCONNECTION conn;
int varint_ok;
int column_varint_size;
assert(column);
column_varint_size = column->column_varint_size;
/* 8 is for varchar(max) or similar */
assert(column_varint_size == 8 || (column_varint_size <= 5 && column_varint_size != 3));
assert(column->column_scale <= column->column_prec);
assert(column->column_prec <= MAXPRECISION);
/* I don't like this that much... freddy77 */
if (column->column_type == 0)
return;
assert(column->funcs);
assert(column->column_type > 0);
/* check type and server type same or SQLNCHAR -> SQLCHAR */
#define SPECIAL(ttype, server_type, varint) \
if (column->column_type == ttype && column->on_server.column_type == server_type && column_varint_size == varint) {} else
SPECIAL(SYBTEXT, XSYBVARCHAR, 8)
SPECIAL(SYBTEXT, XSYBNVARCHAR, 8)
SPECIAL(SYBIMAGE, XSYBVARBINARY, 8)
assert(tds_get_cardinal_type(column->on_server.column_type, column->column_usertype) == column->column_type
|| (tds_get_conversion_type(column->on_server.column_type, column->column_size) == column->column_type
&& column_varint_size == 1 && is_fixed_type(column->column_type)));
varint_ok = 0;
if (column_varint_size == 8) {
assert(column->on_server.column_type == XSYBVARCHAR || column->on_server.column_type == XSYBVARBINARY || column->on_server.column_type == XSYBNVARCHAR || column->on_server.column_type == SYBMSXML || column->on_server.column_type == SYBMSUDT);
varint_ok = 1;
} else if (is_blob_type(column->column_type)) {
assert(column_varint_size >= 4);
} else if (column->column_type == SYBVARIANT) {
assert(column_varint_size == 4);
}
conn.tds_version = 0x500;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
conn.tds_version = 0x700;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
assert(varint_ok);
/* check current size <= size */
if (is_numeric_type(column->column_type)) {
/* I don't like that much this difference between numeric and not numeric - freddy77 */
/* TODO what should be the size ?? */
assert(column->column_prec >= 1 && column->column_prec <= MAXPRECISION);
assert(column->column_scale <= column->column_prec);
/* assert(column->column_cur_size == tds_numeric_bytes_per_prec[column->column_prec] + 2 || column->column_cur_size == -1); */
} else {
assert(column->column_cur_size <= column->column_size);
}
/* check size of fixed type correct */
size = tds_get_size_by_type(column->column_type);
assert(size != 0 || column->column_type == SYBVOID);
if (size >= 0 && column->column_type != SYBBITN) {
/* check macro */
assert(is_fixed_type(column->column_type));
/* check current size */
if (column->column_type != SYBMSDATE)
assert(size == column->column_size);
/* check cases where server need nullable types */
if (column->column_type != column->on_server.column_type && (column->column_type != SYBINT8 || column->on_server.column_type != SYB5INT8)) {
assert(!is_fixed_type(column->on_server.column_type));
assert(column_varint_size == 1);
assert(column->column_size == column->column_cur_size || column->column_cur_size == -1);
} else {
assert(column_varint_size == 0
|| (column->column_type == SYBUNIQUE && column_varint_size == 1)
|| (column->column_type == SYBMSDATE && column_varint_size == 1));
assert(column->column_size == column->column_cur_size
|| (column->column_type == SYBUNIQUE && column->column_cur_size == -1)
|| (column->column_type == SYBMSDATE && column->column_cur_size == -1));
}
assert(column->column_size == column->on_server.column_size);
} else {
assert(!is_fixed_type(column->column_type));
assert(is_char_type(column->column_type) || (column->on_server.column_size == column->column_size || column->on_server.column_size == 0));
assert(column_varint_size != 0);
}
/* check size of nullable types (ie intN) it's supported */
if (tds_get_conversion_type(column->column_type, 4) != column->column_type) {
/* check macro */
assert(is_nullable_type(column->column_type));
/* check that size it's correct for this type of nullable */
assert(tds_get_conversion_type(column->column_type, column->column_size) != column->column_type);
/* check current size */
assert(column->column_size >= column->column_cur_size || column->column_cur_size == -1);
/* check same type and size on server */
assert(column->column_type == column->on_server.column_type);
assert(column->column_size == column->on_server.column_size);
}
}
const struct mips_operand *
decode_mips16_operand (char type, bfd_boolean extended_p)
{
switch (type)
{
case '0': MAPPED_REG (0, 0, GP, reg_0_map);
case 'L': SPECIAL (6, 5, ENTRY_EXIT_LIST);
case 'M': SPECIAL (7, 0, SAVE_RESTORE_LIST);
case 'P': SPECIAL (0, 0, PC);
case 'R': MAPPED_REG (0, 0, GP, reg_31_map);
case 'S': MAPPED_REG (0, 0, GP, reg_29_map);
case 'X': REG (5, 0, GP);
case 'Y': MAPPED_REG (5, 3, GP, reg32r_map);
case 'Z': MAPPED_REG (3, 0, GP, reg_m16_map);
case 'a': JUMP (26, 0, 2);
case 'e': UINT (11, 0);
case 'i': JALX (26, 0, 2);
case 'l': SPECIAL (6, 5, ENTRY_EXIT_LIST);
case 'm': SPECIAL (7, 0, SAVE_RESTORE_LIST);
case 'v': MAPPED_REG (3, 8, GP, reg_m16_map);
case 'w': MAPPED_REG (3, 5, GP, reg_m16_map);
case 'x': MAPPED_REG (3, 8, GP, reg_m16_map);
case 'y': MAPPED_REG (3, 5, GP, reg_m16_map);
case 'z': MAPPED_REG (3, 2, GP, reg_m16_map);
}
if (extended_p)
switch (type)
{
case '<': UINT (5, 0);
case '>': UINT (5, 0);
case '[': UINT (6, 0);
case ']': UINT (6, 0);
case '4': SINT (15, 0);
case '5': SINT (16, 0);
case '6': SINT (16, 0);
case '8': SINT (16, 0);
case 'A': PCREL (16, 0, TRUE, 0, 2, FALSE, FALSE);
case 'B': PCREL (16, 0, TRUE, 0, 3, FALSE, FALSE);
case 'C': SINT (16, 0);
case 'D': SINT (16, 0);
case 'E': PCREL (16, 0, TRUE, 0, 2, FALSE, FALSE);
case 'H': SINT (16, 0);
case 'K': SINT (16, 0);
case 'U': UINT (16, 0);
case 'V': SINT (16, 0);
case 'W': SINT (16, 0);
case 'j': SINT (16, 0);
case 'k': SINT (16, 0);
case 'p': BRANCH (16, 0, 1);
case 'q': BRANCH (16, 0, 1);
}
else
switch (type)
{
case '<': INT_ADJ (3, 2, 8, 0, FALSE);
case '>': INT_ADJ (3, 8, 8, 0, FALSE);
case '[': INT_ADJ (3, 2, 8, 0, FALSE);
case ']': INT_ADJ (3, 8, 8, 0, FALSE);
case '4': SINT (4, 0);
case '5': UINT (5, 0);
case '6': UINT (6, 5);
case '8': UINT (8, 0);
case 'A': PCREL (8, 0, FALSE, 2, 2, FALSE, FALSE);
case 'B': PCREL (5, 0, FALSE, 3, 3, FALSE, FALSE);
case 'C': INT_ADJ (8, 0, 255, 3, FALSE); /* (0 .. 255) << 3 */
case 'D': INT_ADJ (5, 0, 31, 3, FALSE); /* (0 .. 31) << 3 */
case 'E': PCREL (5, 0, FALSE, 2, 2, FALSE, FALSE);
case 'H': INT_ADJ (5, 0, 31, 1, FALSE); /* (0 .. 31) << 1 */
case 'K': INT_ADJ (8, 0, 127, 3, FALSE); /* (-128 .. 127) << 3 */
case 'U': UINT (8, 0);
case 'V': INT_ADJ (8, 0, 255, 2, FALSE); /* (0 .. 255) << 2 */
case 'W': INT_ADJ (5, 0, 31, 2, FALSE); /* (0 .. 31) << 2 */
case 'j': SINT (5, 0);
case 'k': SINT (8, 0);
case 'p': BRANCH (8, 0, 1);
case 'q': BRANCH (11, 0, 1);
}
return 0;
}
#define SPECIAL(x) offsetof(struct reg, r_special) \
+ offsetof(struct _special, x)
#define HIGH_FP(x) offsetof(struct fpreg, fpr_high) \
+ offsetof(struct _high_fp, x)
#define PRESERVED_FP(x) offsetof(struct fpreg, fpr_preserved) \
+ offsetof(struct _callee_saved_fp, x)
#define SCRATCH_FP(x) offsetof(struct fpreg, fpr_scratch) \
+ offsetof(struct _caller_saved_fp, x)
static int regofs[] = {
/*
* General registers (0-127)
*/
-1, /* gr0 */
SPECIAL(gp),
SCRATCH(gr2), SCRATCH(gr3),
PRESERVED(gr4), PRESERVED(gr5), PRESERVED(gr6), PRESERVED(gr7),
SCRATCH(gr8), SCRATCH(gr9), SCRATCH(gr10), SCRATCH(gr11),
SPECIAL(sp), SPECIAL(tp),
SCRATCH(gr14), SCRATCH(gr15), SCRATCH(gr16), SCRATCH(gr17),
SCRATCH(gr18), SCRATCH(gr19), SCRATCH(gr20), SCRATCH(gr21),
SCRATCH(gr22), SCRATCH(gr23), SCRATCH(gr24), SCRATCH(gr25),
SCRATCH(gr26), SCRATCH(gr27), SCRATCH(gr28), SCRATCH(gr29),
SCRATCH(gr30), SCRATCH(gr31),
/*
* gr32 through gr127 are not directly available as they are
* stacked registers.
*/
-1, -1, -1, -1, -1, -1, -1, -1, /* gr32-gr39 */
-1, -1, -1, -1, -1, -1, -1, -1, /* gr40-gr47 */
pass1()
{
register int c, i, j;
register DINODE *dp;
struct zlncnt *zlnp;
int ndb, partial, cgd;
struct inodesc idesc;
ino_t inumber;
/*
* Set file system reserved blocks in used block map.
*/
for (c = 0; c < sblock.fs_ncg; c++) {
cgd = cgdmin(&sblock, c);
if (c == 0) {
i = cgbase(&sblock, c);
cgd += howmany(sblock.fs_cssize, sblock.fs_fsize);
} else
i = cgsblock(&sblock, c);
for (; i < cgd; i++)
setbmap(i);
}
/*
* Find all allocated blocks.
*/
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1check;
inumber = 0;
n_files = n_blks = 0;
for (c = 0; c < sblock.fs_ncg; c++) {
for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
if (inumber < ROOTINO)
continue;
dp = ginode(inumber);
if (!ALLOC(dp)) {
if (bcmp((char *)dp->di_db, (char *)zino.di_db,
NDADDR * sizeof(daddr_t)) ||
bcmp((char *)dp->di_ib, (char *)zino.di_ib,
NIADDR * sizeof(daddr_t)) ||
dp->di_mode || dp->di_size) {
pfatal("PARTIALLY ALLOCATED INODE I=%u",
inumber);
if (reply("CLEAR") == 1) {
zapino(dp);
inodirty();
}
}
statemap[inumber] = USTATE;
continue;
}
lastino = inumber;
if (dp->di_size < 0 ||
dp->di_size + sblock.fs_bsize - 1 < 0) {
if (debug)
printf("bad size %d:", dp->di_size);
goto unknown;
}
if (!preen && (dp->di_mode & IFMT) == IFMT &&
reply("HOLD BAD BLOCK") == 1) {
dp->di_size = sblock.fs_fsize;
dp->di_mode = IFREG|0600;
inodirty();
}
ndb = howmany(dp->di_size, sblock.fs_bsize);
if (SPECIAL(dp))
ndb++;
for (j = ndb; j < NDADDR; j++)
if (dp->di_db[j] != 0) {
if (debug)
printf("bad direct addr: %d\n",
dp->di_db[j]);
goto unknown;
}
for (j = 0, ndb -= NDADDR; ndb > 0; j++)
ndb /= NINDIR(&sblock);
for (; j < NIADDR; j++)
if (dp->di_ib[j] != 0) {
if (debug)
printf("bad indirect addr: %d\n",
dp->di_ib[j]);
goto unknown;
}
if (ftypeok(dp) == 0)
goto unknown;
n_files++;
lncntp[inumber] = dp->di_nlink;
if (dp->di_nlink <= 0) {
zlnp = (struct zlncnt *)malloc(sizeof *zlnp);
if (zlnp == NULL) {
pfatal("LINK COUNT TABLE OVERFLOW");
if (reply("CONTINUE") == 0)
errexit("");
} else {
zlnp->zlncnt = inumber;
zlnp->next = zlnhead;
zlnhead = zlnp;
}
}
statemap[inumber] = DIRCT(dp) ? DSTATE : FSTATE;
badblk = dupblk = 0; maxblk = 0;
idesc.id_number = inumber;
(void)ckinode(dp, &idesc);
idesc.id_entryno *= btodb(sblock.fs_fsize);
if (dp->di_blocks != idesc.id_entryno) {
pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %ld)",
inumber, dp->di_blocks, idesc.id_entryno);
if (preen)
printf(" (CORRECTED)\n");
else if (reply("CORRECT") == 0)
continue;
dp->di_blocks = idesc.id_entryno;
inodirty();
}
continue;
unknown:
pfatal("UNKNOWN FILE TYPE I=%u", inumber);
statemap[inumber] = FCLEAR;
if (reply("CLEAR") == 1) {
statemap[inumber] = USTATE;
zapino(dp);
inodirty();
}
}
}
}
const struct mips_operand *
decode_mips16_operand (char type, bfd_boolean extended_p)
{
switch (type)
{
case '.': MAPPED_REG (0, 0, GP, reg_0_map);
case '>': HINT (5, 22);
case '0': HINT (5, 0);
case '1': HINT (3, 5);
case '2': HINT (3, 8);
case '3': HINT (5, 16);
case '4': HINT (3, 21);
case '6': HINT (6, 5);
case '9': SINT (9, 0);
case 'G': SPECIAL (0, 0, REG28);
case 'L': SPECIAL (6, 5, ENTRY_EXIT_LIST);
case 'N': REG (5, 0, COPRO);
case 'O': UINT (3, 21);
case 'Q': REG (5, 16, HW);
case 'P': SPECIAL (0, 0, PC);
case 'R': MAPPED_REG (0, 0, GP, reg_31_map);
case 'S': MAPPED_REG (0, 0, GP, reg_29_map);
case 'T': HINT (5, 16);
case 'X': REG (5, 0, GP);
case 'Y': MAPPED_REG (5, 3, GP, reg32r_map);
case 'Z': MAPPED_REG (3, 0, GP, reg_m16_map);
case 'a': JUMP (26, 0, 2);
case 'b': BIT (5, 22, 0); /* (0 .. 31) */
case 'c': MSB (5, 16, 1, TRUE, 32); /* (1 .. 32) */
case 'd': MSB (5, 16, 1, FALSE, 32); /* (1 .. 32) */
case 'e': HINT (11, 0);
case 'i': JALX (26, 0, 2);
case 'l': SPECIAL (6, 5, ENTRY_EXIT_LIST);
case 'm': SPECIAL (7, 0, SAVE_RESTORE_LIST);
case 'n': INT_BIAS (2, 0, 3, 1, 0, FALSE); /* (1 .. 4) */
case 'o': INT_ADJ (5, 16, 31, 4, FALSE); /* (0 .. 31) << 4 */
case 'r': MAPPED_REG (3, 16, GP, reg_m16_map);
case 's': HINT (3, 24);
case 'u': HINT (16, 0);
case 'v': OPTIONAL_MAPPED_REG (3, 8, GP, reg_m16_map);
case 'w': OPTIONAL_MAPPED_REG (3, 5, GP, reg_m16_map);
case 'x': MAPPED_REG (3, 8, GP, reg_m16_map);
case 'y': MAPPED_REG (3, 5, GP, reg_m16_map);
case 'z': MAPPED_REG (3, 2, GP, reg_m16_map);
}
if (extended_p)
switch (type)
{
case '<': UINT (5, 22);
case '[': UINT (6, 0);
case ']': UINT (6, 0);
case '5': SINT (16, 0);
case '8': SINT (16, 0);
case 'A': PCREL (16, 0, TRUE, 0, 2, FALSE, FALSE);
case 'B': PCREL (16, 0, TRUE, 0, 3, FALSE, FALSE);
case 'C': SINT (16, 0);
case 'D': SINT (16, 0);
case 'E': PCREL (16, 0, TRUE, 0, 2, FALSE, FALSE);
case 'F': SINT (15, 0);
case 'H': SINT (16, 0);
case 'K': SINT (16, 0);
case 'U': UINT (16, 0);
case 'V': SINT (16, 0);
case 'W': SINT (16, 0);
case 'j': SINT (16, 0);
case 'k': SINT (16, 0);
case 'p': BRANCH (16, 0, 1);
case 'q': BRANCH (16, 0, 1);
}
else
switch (type)
{
case '<': INT_ADJ (3, 2, 8, 0, FALSE);
case '[': INT_ADJ (3, 2, 8, 0, FALSE);
case ']': INT_ADJ (3, 8, 8, 0, FALSE);
case '5': UINT (5, 0);
case '8': UINT (8, 0);
case 'A': PCREL (8, 0, FALSE, 2, 2, FALSE, FALSE);
case 'B': PCREL (5, 0, FALSE, 3, 3, FALSE, FALSE);
case 'C': INT_ADJ (8, 0, 255, 3, FALSE); /* (0 .. 255) << 3 */
case 'D': INT_ADJ (5, 0, 31, 3, FALSE); /* (0 .. 31) << 3 */
case 'E': PCREL (5, 0, FALSE, 2, 2, FALSE, FALSE);
case 'F': SINT (4, 0);
case 'H': INT_ADJ (5, 0, 31, 1, FALSE); /* (0 .. 31) << 1 */
case 'K': INT_ADJ (8, 0, 127, 3, FALSE); /* (-128 .. 127) << 3 */
case 'U': UINT (8, 0);
case 'V': INT_ADJ (8, 0, 255, 2, FALSE); /* (0 .. 255) << 2 */
case 'W': INT_ADJ (5, 0, 31, 2, FALSE); /* (0 .. 31) << 2 */
case 'j': SINT (5, 0);
case 'k': SINT (8, 0);
case 'p': BRANCH (8, 0, 1);
case 'q': BRANCH (11, 0, 1);
}
return 0;
}
#include "keys.h"
#include "vterm_input.h"
#include "stdlib.h"
kbstate_t keyboard;
#define NOKEY { .type = KEY_NONE }
#define ASCII(l,u) { .type = KEY_ASCII, .v = { .ascii = { .lower = l, .upper = u } } }
#define SPECIAL(s) { .type = KEY_SPECIAL, .v = { .value = s } }
#define MODIFIER(m) { .type = KEY_MOD, .v = { .modifier = m } }
/* See also http://www.quadibloc.com/comp/scan.htm */
static key_t keys[] = {
NOKEY,
/* First row: 0x01 - 0x0e */
SPECIAL(VTERM_KEY_ESCAPE),
ASCII('1','!'),
ASCII('2','@'),
ASCII('3','#'),
ASCII('4','$'),
ASCII('5','%'),
ASCII('6','^'),
ASCII('7','&'),
ASCII('8','*'),
ASCII('9','('),
ASCII('0',')'),
ASCII('-','_'),
ASCII('=','+'),
SPECIAL(VTERM_KEY_BACKSPACE),
/* Second row: 0x0f - 0x1c */
SPECIAL(VTERM_KEY_TAB),
ASCII('q','Q'),
ASCII('w','W'),
ASCII('e','E'),
void
tds_check_column_extra(const TDSCOLUMN * column)
{
int size;
TDSCONNECTION conn;
int varint_ok;
int column_varint_size;
assert(column);
column_varint_size = column->column_varint_size;
/* 8 is for varchar(max) or similar */
assert(column_varint_size == 8 || (column_varint_size <= 5 && column_varint_size != 3));
assert(column->column_scale <= column->column_prec);
assert(column->column_prec <= MAXPRECISION);
/* I don't like this that much... freddy77 */
if (column->column_type == 0)
return;
assert(column->funcs);
assert(column->column_type > 0);
/* specific checks, if true fully checked */
if (column->funcs->check(column))
return;
/* check type and server type same or SQLNCHAR -> SQLCHAR */
#define SPECIAL(ttype, server_type, varint) \
if (column->column_type == ttype && column->on_server.column_type == server_type && column_varint_size == varint) {} else
SPECIAL(SYBTEXT, XSYBVARCHAR, 8)
SPECIAL(SYBTEXT, XSYBNVARCHAR, 8)
SPECIAL(SYBIMAGE, XSYBVARBINARY, 8)
assert(tds_get_cardinal_type(column->on_server.column_type, column->column_usertype) == column->column_type
|| (tds_get_conversion_type(column->on_server.column_type, column->column_size) == column->column_type
&& column_varint_size == 1 && is_fixed_type(column->column_type)));
varint_ok = 0;
if (column_varint_size == 8) {
if (column->on_server.column_type == XSYBVARCHAR
|| column->on_server.column_type == XSYBVARBINARY
|| column->on_server.column_type == XSYBNVARCHAR)
varint_ok = 1;
} else if (is_blob_type(column->column_type)) {
assert(column_varint_size >= 4);
} else if (column->column_type == SYBVARIANT) {
assert(column_varint_size == 4);
}
conn.tds_version = 0x500;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
conn.tds_version = 0x700;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
assert(varint_ok);
assert(!is_numeric_type(column->column_type));
assert(column->column_cur_size <= column->column_size);
/* check size of fixed type correct */
size = tds_get_size_by_type(column->column_type);
assert(size != 0 || column->column_type == SYBVOID);
/* these peculiar types are variable but have only a possible size */
if (size >= 0 && (column->column_type != SYBBITN
&& column->column_type != SYBDATEN && column->column_type != SYBTIMEN)) {
/* check macro */
assert(is_fixed_type(column->column_type));
/* check current size */
assert(size == column->column_size);
/* check cases where server need nullable types */
if (column->column_type != column->on_server.column_type && (column->column_type != SYBINT8 || column->on_server.column_type != SYB5INT8)) {
assert(!is_fixed_type(column->on_server.column_type));
assert(column_varint_size == 1);
assert(column->column_size == column->column_cur_size || column->column_cur_size == -1);
} else {
assert(column_varint_size == 0
|| (column->column_type == SYBUNIQUE && column_varint_size == 1));
assert(column->column_size == column->column_cur_size
|| (column->column_type == SYBUNIQUE && column->column_cur_size == -1));
}
assert(column->column_size == column->on_server.column_size);
} else {
assert(!is_fixed_type(column->column_type));
assert(is_char_type(column->column_type) || (column->on_server.column_size == column->column_size || column->on_server.column_size == 0));
assert(column_varint_size != 0);
}
/* check size of nullable types (ie intN) it's supported */
if (tds_get_conversion_type(column->column_type, 4) != column->column_type) {
/* check macro */
assert(is_nullable_type(column->column_type));
/* check that size it's correct for this type of nullable */
assert(tds_get_conversion_type(column->column_type, column->column_size) != column->column_type);
/* check current size */
assert(column->column_size >= column->column_cur_size || column->column_cur_size == -1);
/* check same type and size on server */
assert(column->column_type == column->on_server.column_type);
assert(column->column_size == column->on_server.column_size);
}
}
const char * tok;
int ftype;
#define FTYPE_CSIDL 0
#define FTYPE_SPECIAL 1
PTYPE param;
const char * postfix;
int (*exp_func)(krb5_context, PTYPE, const char *, char **);
#define SPECIALP(f, P) FTYPE_SPECIAL, 0, P, f
#define SPECIAL(f) SPECIALP(f, NULL)
} tokens[] = {
#ifdef __APPLE__
{"ApplicationResources", SPECIAL(_expand_resources) },
{"IPHONE_SIMULATOR_ROOT", SPECIALP(_expand_env, "IPHONE_SIMULATOR_ROOT") },
#endif
#ifdef _WIN32
#define CSIDLP(C,P) FTYPE_CSIDL, C, P, _expand_csidl
#define CSIDL(C) CSIDLP(C, NULL)
{"APPDATA", CSIDL(CSIDL_APPDATA)}, /* Roaming application data (for current user) */
{"COMMON_APPDATA", CSIDL(CSIDL_COMMON_APPDATA)}, /* Application data (all users) */
{"LOCAL_APPDATA", CSIDL(CSIDL_LOCAL_APPDATA)}, /* Local application data (for current user) */
{"SYSTEM", CSIDL(CSIDL_SYSTEM)}, /* Windows System folder (e.g. %WINDIR%\System32) */
{"WINDOWS", CSIDL(CSIDL_WINDOWS)}, /* Windows folder */
{"USERCONFIG", CSIDLP(CSIDL_APPDATA, "\\" PACKAGE)}, /* Per user Heimdal configuration file path */
{"COMMONCONFIG", CSIDLP(CSIDL_COMMON_APPDATA, "\\" PACKAGE)}, /* Common Heimdal configuration file path */
{"LIBDIR", SPECIAL(_expand_bin_dir)},
{"BINDIR", SPECIAL(_expand_bin_dir)},
bool checkcheck_b (TFastNode* node, int move)
{ //check if black move checked white king
char offset,
offset_ssq_tsq;
unsigned char piece,
csq,
sq;
if (!SPECIAL (move)) {
piece = PIECE (move);
sq = TARGETSQ (move);
if (!t.pieceattacks [piece] [node->wkpos] [sq]) {
goto AFTREKSCHAAK;
}
if (piece < BISHOP) {
return true;
}
// check if no piece in between
offset = t.direction [sq] [node->wkpos];
sq += offset;
while (sq != node -> wkpos) {
if (node->matrix [sq]) {
goto AFTREKSCHAAK;
}
sq += offset;
}
return true;
} else {
switch (SPECIALCASE (move)) {
case _EN_PASSANT:
sq = TARGETSQ (move);
if (t.pieceattacks [PAWN] [node->wkpos] [sq]) {
return true;
}
csq = sq + 8;
offset = t.direction [node -> wkpos] [csq];
if (offset) {
sq = node -> wkpos + offset;
if (node -> matrix [sq]) {
break;
}
sq = t.sqonline [node->wkpos] [sq];
while (sq != node -> wkpos) {
BOOST_ASSERT (sq >= 0 && sq <= 63);
piece = node -> matrix [sq];
if (piece) {
if (piece > BKNIGHT && t.pieceattacks [piece - KING] [sq] [node->wkpos]) {
return true;
}
goto AFTREKSCHAAK;
}
sq = t.sqonline [node -> wkpos] [sq];
}
}
break;
case _QUEEN_PROMOTION:
sq = TARGETSQ (move);
if (!t.pieceattacks [QUEEN] [sq] [node->wkpos]) {
goto AFTREKSCHAAK;
}
offset = t.direction [sq] [node->wkpos];
sq += offset;
while (sq != node->wkpos) {
piece = node -> matrix [sq];
if (piece) {
goto AFTREKSCHAAK;
}
sq += offset;
}
return true;
case _SHORT_CASTLE:
if (!t.pieceattacks [ROOK] [f8] [node->wkpos]) {
return false;
}
offset = t.direction [f8] [node->wkpos];
sq = f8 + offset;
do {
if (node->matrix [sq]) {
return false;
}
sq += offset;
} while (sq != node->wkpos);
return true;
case _LONG_CASTLE:
if (!t.pieceattacks [ROOK] [d8] [node->wkpos]) {
return false;
}
offset = t.direction [d8] [node->wkpos];
sq = d8 + offset;
do {
if (node->matrix [sq]) {
return false;
}
sq += offset;
} while (sq != node->wkpos);
return true;
case _ROOK_PROMOTION:
sq = TARGETSQ (move);
if (!t.pieceattacks [ROOK] [sq] [node->wkpos]) {
goto AFTREKSCHAAK;
}
offset = t.direction [sq] [node->wkpos];
sq += offset;
while (sq != node->wkpos) {
piece = node -> matrix [sq];
if (piece) {
goto AFTREKSCHAAK;
}
sq += offset;
}
return true;
case _BISHOP_PROMOTION:
sq = TARGETSQ (move);
if (!t.pieceattacks [BISHOP] [sq] [node->wkpos]) {
goto AFTREKSCHAAK;
}
offset = t.direction [sq] [node->wkpos];
sq += offset;
while (sq != node->wkpos) {
piece = node -> matrix [sq];
if (piece) {
goto AFTREKSCHAAK;
}
sq += offset;
}
return true;
case _KNIGHT_PROMOTION:
sq = TARGETSQ (move);
if (!t.pieceattacks [KNIGHT] [sq] [node->wkpos]) {
goto AFTREKSCHAAK;
}
return true;
case _PLUNKMOVE:
piece = PIECE (move);
sq = TARGETSQ (move);
if (!t.pieceattacks [piece] [node->wkpos] [sq]) {
return false;
}
if (piece < BISHOP) {
return true;
}
// check if no piece in between
offset = t.direction [sq] [node->wkpos];
sq += offset;
while (sq != node -> wkpos) {
if (node->matrix [sq]) {
return false;
}
sq += offset;
}
return true;
}
}
AFTREKSCHAAK:
sq = SOURCESQ (move);
offset = t.direction [node->wkpos] [sq];
if (!offset) {
return false;
}
offset_ssq_tsq = t.direction [sq] [TARGETSQ (move)];
if ((offset_ssq_tsq == offset) || (offset_ssq_tsq == (- offset))) {
return false;
}
sq = node -> wkpos + offset;
if (node -> matrix [sq]) {
return false;
}
sq = t.sqonline [node -> wkpos] [sq];
while (sq != node -> wkpos) {
piece = node->matrix [sq];
if (piece) {
return piece > BKNIGHT && t.pieceattacks [piece - KING] [sq] [node->wkpos];
}
sq = t.sqonline [node -> wkpos] [sq];
}
return false;
}
