Esempio n. 1
0
/* Convert a path represented by a list of indices to a mask. */
mask_t path_to_mask(path_t path, int start, int end) {
    mask_t mask = EMPTY_MASK;
    while (start < end) {
        mask = ADD_TO_MASK(mask, path[start++]);
    }
    return mask;
}
Esempio n. 2
0
/* Split a mask into a mask with just the cycles, and another mask with the remaining dots. */
void separate_cycles(mask_t mask, mask_t *cycles, mask_t *no_cycles) {
    int i, j;

    *cycles = mask;
    *no_cycles = 0;

    for (i = j = 0; i < NUM_DOTS; j = ++i) {
        if (MASK_CONTAINS(*cycles, j)) {
            /* Repeatedly remove dots that only have less than two neighbors and add
             * them to the mask that has no cycles.
             */
            int num_neighbors;
            neighbors_t neighbors;
            get_neighbors(*cycles, j, &num_neighbors, neighbors);
            while (num_neighbors <= 1) {
                *cycles = REMOVE_FROM_MASK(*cycles, j);
                *no_cycles = ADD_TO_MASK(*no_cycles, j);
                if (num_neighbors == 0) {
                    break;
                }
                j = neighbors[0];
                get_neighbors(*cycles, j, &num_neighbors, neighbors);
            }
        }
    }
}
Esempio n. 3
0
/*
 * Convert the character representation of audit values into the au_mask_t
 * field.
 */
int
getauditflagsbin(char *auditstr, au_mask_t *masks)
{
	char class_ent_name[AU_CLASS_NAME_MAX];
	char class_ent_desc[AU_CLASS_DESC_MAX];
	struct au_class_ent c;
	char *tok;
	char sel, sub;
	char *last;

	bzero(&c, sizeof(c));
	bzero(class_ent_name, sizeof(class_ent_name));
	bzero(class_ent_desc, sizeof(class_ent_desc));
	c.ac_name = class_ent_name;
	c.ac_desc = class_ent_desc;

	masks->am_success = 0;
	masks->am_failure = 0;

	tok = strtok_r(auditstr, flagdelim, &last);
	while (tok != NULL) {
		/* Check for the events that should not be audited. */
		if (tok[0] == '^') {
			sub = 1;
			tok++;
		} else
			sub = 0;

		/* Check for the events to be audited for success. */
		if (tok[0] == '+') {
			sel = AU_PRS_SUCCESS;
			tok++;
		} else if (tok[0] == '-') {
			sel = AU_PRS_FAILURE;
			tok++;
		} else
			sel = AU_PRS_BOTH;

		if ((getauclassnam_r(&c, tok)) != NULL) {
			if (sub)
				SUB_FROM_MASK(masks, c.ac_class, sel);
			else
				ADD_TO_MASK(masks, c.ac_class, sel);
		} else {
			errno = EINVAL;
			return (-1);
		}

		/* Get the next class. */
		tok = strtok_r(NULL, flagdelim, &last);
	}
	return (0);
}
Esempio n. 4
0
mask_t random_mask() {
    mask_t mask = EMPTY_MASK;
    int col, row;
    for (col = 0; col < NUM_COLS; col++) {
        for (row = 0; row < NUM_ROWS; row++) {
            if (RAND_COLOR == RED) {
                mask = ADD_TO_MASK(mask, MASK_INDEX(row, col));
            }
        }
    }
    return mask;
}
Esempio n. 5
0
/* Create a mask of all of the dots in a grid of a given color. */
mask_t get_color_mask(grid_t grid, color_t color) {
    mask_t mask = EMPTY_MASK;
    int col, row;
    column_t column;
    for (col = 0; col < NUM_COLS; col++) {
        column = grid[col];
        for (row = 0; row < NUM_ROWS; row++) {
            if (GET_COLUMN_COLOR(column, row) == color) {
                mask = ADD_TO_MASK(mask, MASK_INDEX(row, col));
            }
        }
    }
    return mask;
}
Esempio n. 6
0
/* Find a path through a mask. Returns the length of the path stored in `path`. The length is 0 if no path was found. */
int _mask_to_path(mask_t mask, mask_t visited, int index, int edges[NUM_DOTS][NUM_DOTS], int path_length, path_t path) {
    int j, num_neighbors, nowhere_to_go;
    neighbors_t neighbors;

    /* All of the branches of this DFS share the same buffer for path, but that's okay because it
     * quits as soon as it finds a path that uses all of the dots.
     */
    path[path_length++] = index;
    visited = ADD_TO_MASK(visited, index);

    nowhere_to_go = 1;
    get_neighbors(mask, index, &num_neighbors, neighbors);
    for (j = 0; j < num_neighbors; j++) {
        int new_index = neighbors[j];

        /* Don't follow the same edge twice. */
        if (!edges[index][new_index]) {
            int final_path_length, new_edges[NUM_DOTS][NUM_DOTS];

            nowhere_to_go = 0;

            /* Make a copy of the edges and mark the edge about to be traversed. */
            memcpy(new_edges, edges, sizeof(new_edges));
            new_edges[index][new_index] = 1;
            new_edges[new_index][index] = 1;

            final_path_length= _mask_to_path(mask, visited, new_index, new_edges, path_length, path);
            if (final_path_length > 0) {
                return final_path_length;
            }
        }
    }

    /* End condition: all dots have been visited and there is nowhere left to go.
     * This works even for cycles where it might visit the same dot twice. */
    if (mask == visited && nowhere_to_go) {
        return path_length;
    }

    /* No path was found. */
    return 0;
}