Object *find(Binding *binding, char *key) {
Entry *entry = binding->first;
while (entry != NULL) {
if (key_matches(key, entry->key)) {
return entry->object;
}
entry = entry->next;
}
return (binding->parent == NULL ? NULL : find(binding->parent, key));
}
/* actual lookup. returns obj ptr or NULL of not found */
void *cbtree_lookup(struct CBTree *tree, const void *key, unsigned klen)
{
void *obj;
if (!tree->root)
return NULL;
/* find match based on bits we know about */
obj = raw_lookup(tree, key, klen);
/* need to check if the object actually matches */
if (key_matches(tree, obj, key, klen))
return obj;
return NULL;
}
static GdkFilterReturn
keyevent_filter(GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent = (XEvent *) gdk_xevent;
int i;
if (xevent->type != KeyPress) {
return GDK_FILTER_CONTINUE;
}
for (i = 0 ; keybinds[i].handler != NULL ; i++) {
if (key_matches(&keybinds[i], &xevent->xkey)) {
keybinds[i].handler();
return GDK_FILTER_REMOVE;
}
}
return GDK_FILTER_CONTINUE;
}
/* Does entry match? */
static tdb_bool_err match(struct tdb_context *tdb,
struct hash_info *h,
const struct tdb_data *key,
tdb_off_t val,
struct tdb_used_record *rec)
{
tdb_off_t off;
enum TDB_ERROR ecode;
tdb->stats.compares++;
/* Desired bucket must match. */
if (h->home_bucket != (val & TDB_OFF_HASH_GROUP_MASK)) {
tdb->stats.compare_wrong_bucket++;
return false;
}
/* Top bits of offset == next bits of hash. */
if (bits_from(val, TDB_OFF_HASH_EXTRA_BIT, TDB_OFF_UPPER_STEAL_EXTRA)
!= bits_from(h->h, 64 - h->hash_used - TDB_OFF_UPPER_STEAL_EXTRA,
TDB_OFF_UPPER_STEAL_EXTRA)) {
tdb->stats.compare_wrong_offsetbits++;
return false;
}
off = val & TDB_OFF_MASK;
ecode = tdb_read_convert(tdb, off, rec, sizeof(*rec));
if (ecode != TDB_SUCCESS) {
return ecode;
}
if ((h->h & ((1 << 11)-1)) != rec_hash(rec)) {
tdb->stats.compare_wrong_rechash++;
return false;
}
return key_matches(tdb, rec, off, key);
}
/* true -> object was found and removed, false -> not found */
bool cbtree_delete(struct CBTree *tree, const void *key, unsigned klen)
{
void *obj, *tmp;
unsigned bit = 0;
/* location of current node/obj pointer under examination */
struct Node **pos = &tree->root;
/* if 'pos' has user obj, prev_pos has internal node pointing to it */
struct Node **prev_pos = NULL;
if (!tree->root)
return false;
/* match bits we know about */
while (is_node(*pos)) {
bit = get_bit((*pos)->bitpos, key, klen);
prev_pos = pos;
pos = &(*pos)->child[bit];
}
/* does the key actually matches */
obj = get_external(*pos);
if (!key_matches(tree, obj, key, klen))
return false;
if (tree->obj_free_cb)
tree->obj_free_cb(tree->cb_ctx, obj);
/* drop the internal node pointing to our key */
if (prev_pos) {
tmp = *prev_pos;
*prev_pos = (*prev_pos)->child[bit ^ 1];
cx_free(tree->cx, tmp);
} else {
tree->root = NULL;
}
return true;
}
static tdb_off_t COLD find_in_chain(struct tdb_context *tdb,
struct tdb_data key,
tdb_off_t chain,
struct hash_info *h,
struct tdb_used_record *rec,
struct traverse_info *tinfo)
{
tdb_off_t off, next;
enum TDB_ERROR ecode;
/* In case nothing is free, we set these to zero. */
h->home_bucket = h->found_bucket = 0;
for (off = chain; off; off = next) {
unsigned int i;
h->group_start = off;
ecode = tdb_read_convert(tdb, off, h->group, sizeof(h->group));
if (ecode != TDB_SUCCESS) {
return ecode;
}
for (i = 0; i < (1 << TDB_HASH_GROUP_BITS); i++) {
tdb_off_t recoff;
if (!h->group[i]) {
/* Remember this empty bucket. */
h->home_bucket = h->found_bucket = i;
continue;
}
/* We can insert extra bits via add_to_hash
* empty bucket logic. */
recoff = h->group[i] & TDB_OFF_MASK;
ecode = tdb_read_convert(tdb, recoff, rec,
sizeof(*rec));
if (ecode != TDB_SUCCESS) {
return ecode;
}
ecode = key_matches(tdb, rec, recoff, &key);
if (ecode < 0) {
return ecode;
}
if (ecode == 1) {
h->home_bucket = h->found_bucket = i;
if (tinfo) {
tinfo->levels[tinfo->num_levels]
.hashtable = off;
tinfo->levels[tinfo->num_levels]
.total_buckets
= 1 << TDB_HASH_GROUP_BITS;
tinfo->levels[tinfo->num_levels].entry
= i;
tinfo->num_levels++;
}
return recoff;
}
}
next = tdb_read_off(tdb, off
+ offsetof(struct tdb_chain, next));
if (TDB_OFF_IS_ERR(next)) {
return next;
}
if (next)
next += sizeof(struct tdb_used_record);
}
return 0;
}
int new_wcs(const char* infn, int extension,
const char* wcsfn, const char* outfn,
anbool copydata) {
FILE* outfid = NULL;
int i, N;
int e;
regex_t re1[NE1];
regex_t re2[NE2];
qfits_header *inhdr=NULL, *outhdr=NULL, *wcshdr=NULL;
char key[FITS_LINESZ + 1];
char newkey[FITS_LINESZ + 1];
char val[FITS_LINESZ + 1];
char comment[FITS_LINESZ + 1];
int imatch = -1;
// how many REs have successfully been compiled.
int n1=0, n2=0;
outfid = fopen(outfn, "wb");
if (!outfid) {
SYSERROR("Failed to open output file \"%s\"", outfn);
goto bailout;
}
inhdr = anqfits_get_header2(infn, extension);
if (!inhdr) {
ERROR("Failed to read FITS header from input file \"%s\" ext %i",
infn, extension);
goto bailout;
}
wcshdr = anqfits_get_header2(wcsfn, 0);
if (!wcshdr) {
ERROR("Failed to read FITS header from WCS file \"%s\"", wcsfn);
goto bailout;
}
outhdr = qfits_header_new();
if (!outhdr) {
ERROR("Failed to allocate new output FITS header.");
goto bailout;
}
// Compile regular expressions...
for (e=0; e<NE1; e++) {
int errcode;
errcode = regcomp(re1 + e, exclude_input[e], REG_EXTENDED);
if (errcode) {
char err[256];
regerror(errcode, re1 + e, err, sizeof(err));
ERROR("Failed to compile regular expression \"%s\": %s", exclude_input[e], err);
goto bailout;
}
n1++;
}
for (e=0; e<NE2; e++) {
int errcode;
errcode = regcomp(re2 + e, exclude_wcs[e], REG_EXTENDED);
if (errcode) {
char err[256];
regerror(errcode, re2 + e, err, sizeof(err));
ERROR("Failed to compile regular expression \"%s\": %s", exclude_wcs[e], err);
goto bailout;
}
n2++;
}
logverb("Reading input file FITS headers...\n");
if (extension) {
// Copy the primary header unchanged
qfits_header* phdr = anqfits_get_header2(infn, 0);
if (!phdr) {
ERROR("Failed to read primary FITS header from input file \"%s\n",
infn);
goto bailout;
}
if (qfits_header_dump(phdr, outfid) ||
fits_pad_file(outfid)) {
SYSERROR("Failed to write primary header to file %s", outfn);
goto bailout;
}
qfits_header_destroy(phdr);
}
N = qfits_header_n(inhdr);
for (i=0; i<N; i++) {
anbool added_newkey = FALSE;
char line[FITS_LINESZ + 1];
if (qfits_header_getitem(inhdr, i, key, val, comment, line)) {
ERROR("Failed to read FITS header card %i from input file", i);
goto bailout;
}
logverb("Read input header line: \"%s\"\n", line);
if (key_matches(key, re1, exclude_input, NE1, &imatch)) {
logverb("Regular expression matched: \"%s\", key \"%s\".\n", exclude_input[imatch], key);
snprintf(newkey, FITS_LINESZ+1, "Original key: \"%s\"", key);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
// Completely skip the END card, since _ND is not a valid line.
if (streq(key, "END"))
continue;
snprintf(newkey, FITS_LINESZ+1, "_%.7s", key+1);
logverb("New key: \"%s\"\n", newkey);
strcpy(key, newkey);
line[0] = '_';
added_newkey = TRUE;
}
// If the header already contains this new (starting-with-"_")
// key, add three comment cards instead.
if (starts_with(key, "_") &&
(qfits_header_getstr(inhdr, key) ||
qfits_header_getstr(outhdr, key))) {
logverb("Key \"%s\" already exists; adding COMMENT cards for value and comment instead\n", key);
if (!added_newkey) {
snprintf(newkey, FITS_LINESZ+1, "Original key: \"%s\"", key);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
}
snprintf(newkey, FITS_LINESZ+1, " = %s", val);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
snprintf(newkey, FITS_LINESZ+1, " / %s", comment);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
continue;
}
qfits_header_append(outhdr, key, val, comment, line);
}
qfits_header_destroy(inhdr);
inhdr = NULL;
logverb("Reading WCS file FITS headers...\n");
qfits_header_append(outhdr, "COMMENT", "", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "--Start of Astrometry.net WCS solution--", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "--Put in by the new-wcs program--", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "", NULL, NULL);
N = qfits_header_n(wcshdr);
for (i=0; i<N; i++) {
char line[FITS_LINESZ + 1];
if (qfits_header_getitem(wcshdr, i, key, val, comment, line)) {
ERROR("Failed to read FITS header card %i from WCS file.", i);
goto bailout;
}
if (key_matches(key, re2, exclude_wcs, NE2, &imatch)) {
logverb("Regular expression matched: \"%s\", key \"%s\".\n", exclude_wcs[imatch], key);
// These don't really need to appear in the output file...
/*
snprintf(newkey, FITS_LINESZ+1, "Original WCS key: \"%s\"", key);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
snprintf(newkey, FITS_LINESZ+1, "_%.7s", key);
strcpy(key, newkey);
*/
continue;
}
if (streq(key, "DATE") && qfits_header_getstr(outhdr, key)) {
// If the input header already had a DATE card,
snprintf(newkey, FITS_LINESZ+1, "Original WCS key: \"%s\"", key);
qfits_header_append(outhdr, "COMMENT", newkey, NULL, NULL);
snprintf(newkey, FITS_LINESZ+1, "_%.7s", key);
strcpy(key, newkey);
line[0] = '_';
}
qfits_header_append(outhdr, key, val, comment, line);
}
qfits_header_destroy(wcshdr);
wcshdr = NULL;
qfits_header_append(outhdr, "COMMENT", "", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "--End of Astrometry.net WCS--", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "--(Put in by the new-wcs program)--", NULL, NULL);
qfits_header_append(outhdr, "COMMENT", "", NULL, NULL);
qfits_header_append(outhdr, "END", NULL, NULL, NULL);
if (qfits_header_dump(outhdr, outfid) ||
fits_pad_file(outfid)) {
SYSERROR("Failed to write output header to file %s", outfn);
goto bailout;
}
qfits_header_destroy(outhdr);
outhdr = NULL;
if (copydata) {
int datsize, datstart;
FILE* infid = NULL;
anqfits_t* anq = NULL;
anq = anqfits_open(infn);
if (!anq) {
ERROR("Failed to open file \"%s\"", infn);
goto bailout;
}
datstart = anqfits_data_start(anq, extension);
datsize = anqfits_data_size (anq, extension);
infid = fopen(infn, "rb");
if (!infid) {
SYSERROR("Failed to open input file \"%s\"", infn);
anqfits_close(anq);
goto bailout;
}
logverb("Copying from offset %i to offset %i (length %i) of the input file to the output.\n",
datstart, datstart + datsize, datsize);
if (pipe_file_offset(infid, datstart, datsize, outfid)) {
ERROR("Failed to copy the data block");
fclose(infid);
anqfits_close(anq);
goto bailout;
}
fclose(infid);
if (fits_pad_file(outfid)) {
ERROR("Failed to pad FITS file \"%s\"", outfn);
anqfits_close(anq);
goto bailout;
}
anqfits_close(anq);
anq = NULL;
}
if (fclose(outfid)) {
SYSERROR("Failed to close output file \"%s\"", outfn);
goto bailout;
}
// Free regular expressions...
for (e=0; e<NE1; e++)
regfree(re1 + e);
for (e=0; e<NE2; e++)
regfree(re2 + e);
return 0;
bailout:
if (outfid)
fclose(outfid);
if (inhdr)
qfits_header_destroy(inhdr);
if (outhdr)
qfits_header_destroy(outhdr);
if (wcshdr)
qfits_header_destroy(wcshdr);
for (i=0; i<n1; i++)
regfree(re1 + i);
for (i=0; i<n2; i++)
regfree(re2 + i);
return -1;
}
