static void stest_usage(const char *argv0, const char **test_usage,
int exitstatus)
{
fprintf(stderr, "%s: a Redfish system test\n", argv0);
{
static const char *usage_lines[] = {
"See http://www.club.cc.cmu.edu/~cmccabe/redfish.html for the most up-to-date",
"information about Redfish.",
"",
"System test options:",
"-d <directory>",
" Set the directory to use for test metadata. Defaults to a temporary ",
" directory",
"-f",
" Run in the foreground (do not daemonize)",
"-h",
" Show this help message",
NULL
};
print_lines(stderr, usage_lines);
}
fprintf(stderr, "\nTest information:\n");
print_lines(stderr, test_usage);
exit(exitstatus);
}
~Statistics() {
long total = 0;
for (int i = 0; i < max_small;i ++) {
if (alloc_count[i] > 0) {
printf("size %d left is %d for size %d\n",
i * sizeof(size_t),
alloc_count[i],
i * sizeof(size_t)*alloc_count[i]);
print_lines(headers[i]);
total += i * sizeof(size_t)*alloc_count[i];
}
}
size_rec *next = big;
while (next) {
if (next->count > 0) {
printf("size %d left is %d for size %d\n",
next->size * sizeof(size_t),
next->count,
next->size * sizeof(size_t)*next->count);
print_lines(next->headers);
total += next->size * sizeof(size_t)*next->count;
}
next = next->next;
}
printf("total allocation remaining %d\n",total);
}
gboolean insert_in_tree(GNode *directory, File *file)
{
GNode *new_file, *file_ptr, *dir_ptr;
int position;
if (file->name[0] == '.' && FILE(directory)->show_dotfiles == FALSE) {
insert_sorted_in_dotfiles(directory, file);
return FALSE;
}
new_file = insert_sorted_in_tree(directory, file);
for (dir_ptr = directory; !G_NODE_IS_ROOT(dir_ptr); dir_ptr = dir_ptr->parent) {
if (FILE(dir_ptr)->open == FALSE)
return FALSE;
}
if (FILE(dir_ptr)->open == FALSE)
return FALSE;
file_ptr = get_previous_file(new_file);
position = g_list_position(lines, FILE(file_ptr)->line);
lines = g_list_insert(lines, new_file, position + 1);
file->line = g_list_nth(lines, position + 1);
if (g_list_length(first_line) - g_list_length(last_line) + 1) {
if (g_list_previous(first_line) == file->line)
first_line = file->line;
else if (g_list_next(last_line) == file->line)
last_line = file->line;
}
if (g_list_position(lines, first_line) <= position + 1 &&
position + 1 <= g_list_position(lines, last_line)) {
if (position + 1 < g_list_position(lines, selected_line)) {
if (g_list_length(first_line) <= getmaxy(tree_window))
print_lines(first_line, last_line, FALSE);
else {
first_line = g_list_next(first_line);
print_lines(first_line, file->line, FALSE);
}
} else {
if (g_list_length(first_line) > getmaxy(tree_window))
last_line = g_list_previous(last_line);
if (g_node_last_sibling(new_file) == new_file)
print_lines(g_list_previous(file->line), last_line, FALSE);
else
print_lines(file->line, last_line, FALSE);
}
return TRUE;
}
return FALSE;
}
/* Print out all stored ID3v2 fields with their 4-character IDs. */
void print_raw_v2(mpg123_id3v2 *v2)
{
size_t i;
for(i=0; i<v2->texts; ++i)
{
char id[5];
char lang[4];
memcpy(id, v2->text[i].id, 4);
id[4] = 0;
memcpy(lang, v2->text[i].lang, 3);
lang[3] = 0;
if(v2->text[i].description.fill)
printf("%s language(%s) description(%s)\n", id, lang, v2->text[i].description.p);
else printf("%s language(%s)\n", id, lang);
print_lines(" ", &v2->text[i].text);
}
for(i=0; i<v2->extras; ++i)
{
char id[5];
memcpy(id, v2->extra[i].id, 4);
id[4] = 0;
printf( "%s description(%s)\n",
id,
v2->extra[i].description.fill ? v2->extra[i].description.p : "" );
print_lines(" ", &v2->extra[i].text);
}
for(i=0; i<v2->comments; ++i)
{
char id[5];
char lang[4];
memcpy(id, v2->comment_list[i].id, 4);
id[4] = 0;
memcpy(lang, v2->comment_list[i].lang, 3);
lang[3] = 0;
printf( "%s description(%s) language(%s):\n",
id,
v2->comment_list[i].description.fill ? v2->comment_list[i].description.p : "",
lang );
print_lines(" ", &v2->comment_list[i].text);
}
for(i=0; i<v2->pictures; ++i)
{
mpg123_picture* pic;
pic = &v2->picture[i];
fprintf(stderr, "APIC type(%i, %s) mime(%s) size(%"SIZE_P")\n",
pic->type, pic_type(pic->type), pic->mime_type.p, (size_p)pic->size);
print_lines(" ", &pic->description);
}
}
static void fortran_prescanner_process(prescanner_t* prescanner)
{
file_lines = NULL;
last_line = file_lines;
// Load all the file into memory
read_lines(prescanner);
// Cut lines to be of width 'prescanner.width'
cut_lines(prescanner);
// We used to remove comments here but it is better to convert them
convert_whole_line_comments();
// Join continuated lines
join_continuated_lines(prescanner);
#if 0
// Lines that were not appended any continuation line have not been trimmed
// their inline comments
remove_inlined_comments();
#endif
convert_lines(prescanner);
if (!prescanner->append)
{
continuate_lines(prescanner);
}
print_lines(prescanner);
close_files(prescanner);
}
int process_copy_output(process_info_t* p, FILE* stream) {
char buf[1024];
int fd, r;
FILE* f;
fd = _open_osfhandle((intptr_t)p->stdio_out, _O_RDONLY | _O_TEXT);
if (fd == -1)
return -1;
f = _fdopen(fd, "rt");
if (f == NULL) {
_close(fd);
return -1;
}
r = fseek(f, 0, SEEK_SET);
if (r < 0)
return -1;
while (fgets(buf, sizeof(buf), f) != NULL)
print_lines(buf, strlen(buf), stream);
if (ferror(f))
return -1;
fclose(f);
return 0;
}
int main(int argc, const char * argv[]) {
FILE *file;
if (argc < 2 || !(file = fopen(argv[1], "r"))) {
puts("No argument provided / File not found.");
return 1;
}
file = fopen(argv[1], "r");
char line[LINE_BUFFER];
fgets(line, LINE_BUFFER, file);
int number_of_lines = atoi(line);
char lines_to_print[number_of_lines][LINE_BUFFER];
initialize(lines_to_print, number_of_lines, file);
sort_lines(lines_to_print, number_of_lines);
int end = number_of_lines - 1;
int shortest_long_line_length = strlen(lines_to_print[end]);
int line_length;
while (fgets(line, LINE_BUFFER, file)) {
if ((line_length = strlen(line)) > shortest_long_line_length) {
strcpy(lines_to_print[end], line);
sort_lines(lines_to_print, number_of_lines);
shortest_long_line_length = strlen(lines_to_print[end]);
}
}
print_lines(lines_to_print, number_of_lines);
}
int print_args(t_param *debut)
{
int col;
t_param *buf;
int nb_col;
int nb_row;
buf = debut;
col = 0;
nb_col = get_nb_col(debut);
nb_row = get_nb_row(debut, nb_col);
if (nb_row >= get_height())
return (-2);
if (print_lines(nb_row) == -1)
return (-1);
while (col < nb_col)
{
if ((buf = print_col(buf, nb_row, col, get_nb_tab(debut))) == NULL)
return (-2);
if (buf->nb == 0)
break ;
if (move_cursor_up(nb_row, get_nb_tab(debut)) < 0)
return (-1);
col++;
}
return (0);
}
/**
* USE: Provide sample points and how many to setup_hough() transformation and plot those points
* using plot_point() with each index of points you want to convert. The use print_classifier()
* or get_lines() to see the lines extracted.
*/
int main(int argc, char **argv) {
// Get points from image
SIZE_TYPE size;
POINT_TYPE *points = NULL;
sizep_t count = get_points("sample_small.bmp", &points, &size);
/*
* points : Array of points
* num_points : Number of points in the array
* threshold : Threshold to consider line intersection
* tolerance_t : Tolerance (in grades) to consider two lines are the same
* tolerance_r : Distance (in pixels) to consider two lines are the same
* precision : Precision for degrees (10 = decimals, 100 = cents...)
* size : Size of the image
* max_lines : Lines to look for (value -1 falls back to 500)
*/
clock_t cp = clock();
setup_hough(points, count, 12, 15.0, 5.0, 1, size, 10000);
// Plot every point and measure clock ticks
int n;
for (n=0; n<_num_points; n++) {
plot_point(n);
}
printf("_plot_point() ticks: %.4f\n", ((double)(clock()-cp))/1000000l);
print_accumulator("accumulator.bmp");
print_classifier();//*/
// Get lines from classifier
LINE_TYPE *lines;
sizep_t clines = get_lines(&lines);
// Print lines
print_lines("output.bmp", "sample.bmp", lines, clines, 10);
print_lines("output_small.bmp", "sample_small.bmp", lines, clines, 1);
// Free memory
finish_hough();
free(lines);
free(points);
printf("All clear!");
return EXIT_SUCCESS;
}
int main()
{
struct indicator *indicators;
struct strategy *strategies;
struct coll_ctrl_blk *coll_ctrl_blks;
indicators = load_indicators("indicators.xml");
print_indicators(indicators);
//destroy_indicators(indicators);
strategies = load_strategies("strategies.xml");
print_strategies(strategies);
//destroy_strategies(strategies);
//printf("name offset in Indicator is: %u\n", offsetof(struct indicator, name));
//printf("size of int: %u\n", sizeof(int));
struct data data;
init_data(&data);
put_value(&data, "hello", "wold");
struct pair *pair_ptr = get_pair(&data, "hello");
printf("%s, %s\n", pair_ptr->name, pair_ptr->value);
coll_ctrl_blks = generate_coll_ctrl_blks(indicators, strategies);
print_coll_ctrl_blks(coll_ctrl_blks);
struct coll_ctrl_blk *coll_ctrl_blk_ptr = find_coll_ctrl_blk(coll_ctrl_blks, 1);
printf("Indicator NAME: %s\n", coll_ctrl_blk_ptr->indicator_ptr->name);
generate_coll_commands(coll_ctrl_blk_ptr);
destroy_indicators(indicators);
destroy_strategies(strategies);
ssh_init();
struct ssh_client client;
struct line *lines;
init_client(&client);
login(&client, "127.0.0.1", 22, "tshi", "123456");
lines = exec_command(&client, "date");
print_lines(lines);
destroy_lines(lines);
lines = exec_command(&client, "top -b -n 1");
print_lines(lines);
destroy_lines(lines);
close_client(&client);
ssh_exit();
return (0);
}
void open_directory(GNode *directory)
{
if (FILE(directory)->read == FALSE && read_directory(directory) == FALSE)
return;
FILE(directory)->open = TRUE;
add_directory_content(directory);
update_last_line();
print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}
bool esp_run_command(serial_handle_t handle, std::string const &command, bool printresult)
{
std::vector<std::string> lines;
if (esp_run_command(handle, command, &lines, 3)) {
if (printresult) {
print_lines(&lines);
}
return true;
}
return false;
}
void shn_error(shn_config config, char *msg, ...)
{
va_list args;
char msgbuf[BUF_SIZE];
va_start(args,msg);
shn_vsnprintf(msgbuf,BUF_SIZE,msg,args);
switch (config.error_output_method) {
case ERROR_OUTPUT_STDERR:
print_lines(PACKAGE ": ",msgbuf);
break;
default:
if (0 != config.verbose)
print_lines(PACKAGE " [error]: ",msgbuf);
}
va_end(args);
}
void print_tree(GtkWidget *widget, rbtree_node node) {
if (node != NULL) {
char *s = (char*) malloc(3 * sizeof(char));
sprintf(s, "%d", node->key);
print_lines(widget, node->left != NULL, node->right != NULL, node->x, node->y, node->r);
print_tree(widget, node->left);
print_circle(widget, s, node_color(node), node->x, node->y, 15, 16);
print_tree(widget, node->right);
}
}
void scroll_tree(int n_lines)
{
int min_n_lines, max_n_lines;
if ((min_n_lines = -g_list_position(lines, first_line)) > n_lines)
n_lines = min_n_lines;
else if ((max_n_lines = g_list_length(last_line) - 1) < n_lines)
n_lines = max_n_lines;
wscrl(tree_window, n_lines);
if (n_lines < 0) {
first_line = g_list_nth(lines, g_list_position(lines, first_line) + n_lines);
update_last_line();
print_lines(first_line, g_list_nth(first_line, -n_lines), FALSE);
} else if (n_lines > 0) {
first_line = g_list_nth(first_line, n_lines);
update_last_line();
print_lines(g_list_nth(lines, g_list_position(lines, last_line) - n_lines),
last_line, TRUE);
}
}
void st_debug_internal(int level,char *msg,va_list args)
{
char debugprefix[16];
if (level > st_priv.debug_level)
return;
st_vsnprintf(msgbuf,BUF_SIZE,msg,args);
st_snprintf(debugprefix,16,"debug%d: ",level);
print_lines(debugprefix,msgbuf);
}
void print_edit(char** file_a, char** file_b, int idx_a, int idx_b, int nb_diff_a, int nb_diff_b, int edit_type) {
char edit_code[] = {'a', 'd', 'c'};
print_range(idx_a, nb_diff_a);
putchar(edit_code[edit_type]);
print_range(idx_b, nb_diff_b);
putchar('\n');
if (edit_type == ADDITION)
print_lines(file_b, idx_b, nb_diff_b, '>');
else if (edit_type == DELETION)
print_lines(file_a, idx_a, nb_diff_a, '<');
else if (edit_type == MODIFICATION)
{
print_lines(file_a, idx_a, nb_diff_a, '<');
puts("---");
print_lines(file_b, idx_b, nb_diff_b, '>');
}
}
void shn_debug(shn_config config, char *msg, ...)
{
va_list args;
char msgbuf[BUF_SIZE];
va_start(args,msg);
shn_vsnprintf(msgbuf,BUF_SIZE,msg,args);
if (0 != config.verbose)
print_lines(PACKAGE " [debug]: ",msgbuf);
va_end(args);
}
void st_error(char *msg, ...)
{
va_list args;
va_start(args,msg);
st_vsnprintf(msgbuf,BUF_SIZE,msg,args);
print_lines("error: ",msgbuf);
va_end(args);
exit(ST_EXIT_ERROR);
}
/* Print out the named ID3v2 fields. */
void print_v2(mpg123_id3v2 *v2)
{
print_lines("Title: ", v2->title);
print_lines("Artist: ", v2->artist);
print_lines("Album: ", v2->album);
print_lines("Year: ", v2->year);
print_lines("Comment: ", v2->comment);
print_lines("Genre: ", v2->genre);
}
void st_warning(char *msg, ...)
{
va_list args;
if (st_priv.suppress_warnings || st_priv.suppress_stderr)
return;
va_start(args,msg);
st_vsnprintf(msgbuf,BUF_SIZE,msg,args);
print_lines("warning: ",msgbuf);
va_end(args);
}
void close_directory(GNode *directory)
{
GNode *directory_sibling;
GList *line_ptr;
directory_sibling = get_next_file_not_deepper(directory);
for (line_ptr = g_list_next(FILE(directory)->line); line_ptr != NULL &&
NODE(line_ptr) != directory_sibling; line_ptr = g_list_next(FILE(directory)->line))
lines = g_list_delete_link(lines, line_ptr);
FILE(directory)->open = FALSE;
update_last_line();
print_lines(g_list_next(FILE(directory)->line), last_line, TRUE);
}
void player(t_line *lines)
{
int nb;
nb = al_count(lines);
if (nb == 0)
ft_putstr("You win the game. But we know you know the trick..\n");
else
{
print_lines(&lines);
ft_putstr("Player's turn : ");
remove_al(&lines, ask_nb(lines));
playia(lines);
}
}
int main(int argc, char *argv[]) {
int argument = 10;
if (argc == 2)
argument = abs(atoi(argv[1]));
if (argument == 0)
argument = 10;
char currentline[500];
init_lineholder(argument);
while (getline1(currentline) > 0) {
insert_line(currentline);
}
print_lines();
}
void st_help(char *msg, ...)
{
va_list args;
va_start(args,msg);
st_vsnprintf(msgbuf,BUF_SIZE,msg,args);
print_lines("error: ",msgbuf);
va_end(args);
print_prefix();
fprintf(stderr,"\n");
print_prefix();
fprintf(stderr,"type '%s -h' for help\n",st_priv.fullprogname);
exit(ST_EXIT_ERROR);
}
int process_copy_output(process_info_t* p, FILE* stream) {
DWORD read;
char buf[1024];
if (SetFilePointer(p->stdio_out,
0,
0,
FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
return -1;
}
while (ReadFile(p->stdio_out, &buf, sizeof(buf), &read, NULL) && read > 0)
print_lines(buf, read, stream);
if (GetLastError() != ERROR_HANDLE_EOF)
return -1;
return 0;
}
static void usage(int exitstatus)
{
static const char *usage_lines[] = {
"fishosd: the Redfish object storage daemon",
"See http://www.club.cc.cmu.edu/~cmccabe/redfish.html for the most up-to-date",
"information about Redfish.",
"",
"fishosd usage:",
"-c <osd-configuration-file>",
" Set the osd configuration file.",
"-k <osd ID>",
" The ID number of this OSD. This is an index into the array of ",
" OSDs in the configuration file.",
"-f",
" Run in the foreground (do not daemonize)",
"-h",
" Show this help message",
NULL
};
print_lines(stderr, usage_lines);
exit(exitstatus);
}
static bool esp_get_mac_address_(serial_handle_t handle, std::string const &cmd, std::string const &key, mac_address_t *out)
{
*out = mac_address_t();
std::vector<std::string> lines;
if (esp_run_command(handle, cmd, &lines)) {
print_lines(&lines);
std::string t;
if (lookup(&lines, key, &t)) {
t = trim_quot(t);
int a, b, c, d, e, f;
if (sscanf(t.c_str(), "%02x:%02x:%02x:%02x:%02x:%02x", &a, &b, &c, &d, &e, &f) == 6) {
out->a = a;
out->b = b;
out->c = c;
out->d = d;
out->e = e;
out->f = f;
}
return true;
}
}
return false;
}
int print_header(FILE *fp, char *hname)
{
int c;
struct file_info *fi;
FILE *header_file;
if (hname)
{
if ((fi = open_file(hname, "r")) == NULL)
{
fprintf(stderr, "umat: can't read PS header file %s\n", hname);
return 1;
}
header_file = fi2fp(fi);
while ((c = fgetc(header_file)) != EOF)
fputc(c, fp);
close_file(fi);
}
else
print_lines(fp, psheader);
return 0;
}
gboolean remove_from_tree(GNode *file, gboolean unmount)
{
int position = g_list_position(lines, FILE(file)->line);
gboolean refresh_needed = FALSE;
GList *line_ptr, *line_ptr2;
GNode *dir_ptr;
if (G_NODE_IS_ROOT(file)) {
endwin();
clean_up();
printf("The tree root was removed\n");
exit(EXIT_SUCCESS);
}
if (g_node_is_ancestor(file, NODE(selected_line)))
select_file(file);
if (FILE(file)->type == directory_type) {
close_directory(file);
destroy_directory_content_real(file, FALSE);
if (unmount)
return TRUE;
} else if (FILE(file)->type == file_type) {
for (dir_ptr = file->parent; !G_NODE_IS_ROOT(dir_ptr);
dir_ptr = dir_ptr->parent) {
if (FILE(dir_ptr)->open == FALSE) {
g_node_unlink(file);
return FALSE;
}
}
if (FILE(dir_ptr)->open == FALSE) {
g_node_unlink(file);
return FALSE;
}
}
g_node_unlink(file);
if (g_list_position(lines, first_line) <= position &&
position <= g_list_position(lines, last_line)) {
if (first_line == FILE(file)->line && selected_line == FILE(file)->line) {
selected_line = first_line = g_list_previous(first_line);
lines = g_list_delete_link(lines, FILE(file)->line);
print_lines(first_line, first_line, FALSE);
} else if (position < g_list_position(lines, selected_line)) {
if (first_line == FILE(file)->line)
first_line = g_list_next(first_line);
line_ptr = g_list_previous(FILE(file)->line);
lines = g_list_delete_link(lines, FILE(file)->line);
if ((line_ptr2 = g_list_previous(first_line)) != NULL) {
first_line = line_ptr2;
print_lines(first_line, line_ptr, FALSE);
} else if ((line_ptr2 = g_list_next(last_line)) != NULL) {
last_line = line_ptr2;
print_lines(line_ptr, last_line, FALSE);
} else
print_lines(line_ptr, last_line, TRUE);
} else {
if (FILE(file)->line == selected_line)
selected_line = g_list_previous(selected_line);
if (last_line == FILE(file)->line)
last_line = g_list_previous(last_line);
line_ptr = g_list_previous(FILE(file)->line);
lines = g_list_delete_link(lines, FILE(file)->line);
if ((line_ptr2 = g_list_next(last_line)) != NULL) {
last_line = line_ptr2;
print_lines(line_ptr, last_line, FALSE);
} else
print_lines(line_ptr, last_line, TRUE);
}
refresh_needed = TRUE;
} else {
if (last_line == g_list_previous(FILE(file)->line)) {
lines = g_list_delete_link(lines, FILE(file)->line);
print_lines(last_line, last_line, FALSE);
refresh_needed = TRUE;
} else
lines = g_list_delete_link(lines, FILE(file)->line);
}
free_node_data(file, NULL);
g_node_destroy(file);
return refresh_needed;
}
