char *have_file(t_struct *st)
{
if (st->world_sel == 1)
return (get_file_content(LEVEL1));
else
if (st->world_sel == 2)
return (get_file_content(LEVEL2));
else
return (get_file_content(LEVEL3));
}
int error_boss(char *map)
{
char *file;
char **tab;
int width;
int height;
if (check_existence(map) == -1
|| (file = get_file_content(map)) == NULL
|| check_integer(file, "ibwsm.lg\n") == -1
|| (file = put_return(file)) == NULL
|| (tab = my_str_to_wordtab(file, '\n')) == NULL
|| check_largest(tab) == -1
|| is_present("i", file) != 1
|| is_present("b", file) != 1
|| check_tab(tab) == -1)
return (puterror("One of Boss map isn't correct.\n"));
width = my_strlen(tab[0]) * 29;
height = tablen(tab) * 26;
if (width > 1300 || height > 750)
return (puterror("Error: Dimension are too big in Boss Map.\n"));
free(file);
free_tab(tab);
return (0);
}
static int process_individual_events(const char *path, struct event_iter *iter)
{
struct stat st;
const char *system = iter->system_dent->d_name;
char *file;
char *enable = NULL;
char *str;
int ret = 0;
file = append_file(path, system);
stat(file, &st);
if (!S_ISDIR(st.st_mode))
goto out;
enable = append_file(file, "enable");
str = get_file_content(enable);
if (!str)
goto out;
if (*str != '1' && *str != '0')
ret = 1;
free(str);
out:
free(enable);
free(file);
return ret;
}
struct _list* load_file_to_list(const char *dir_name, const char *file_name)
{
char *file_path_name = get_file_path_name(dir_name, file_name);
char *content = get_file_content(file_path_name);
free(file_path_name);
if (content == NULL)
return NULL;
struct _list *data = list_init();
int len = strlen(content);
int sym, last_sym = 0;
for (sym = 0; sym < len; sym++)
{
if (content[sym] != '\n')
continue;
if (last_sym == sym)
{
last_sym++;
continue;
}
content[sym] = '\0';
data->add(data, content + last_sym);
last_sym = sym + 1;
}
free(content);
return data;
}
t_map *get_map(char *path)
{
t_map *map;
char *buffer;
int i;
int j;
map = xmalloc(sizeof(*map));
buffer = get_file_content(path);
get_map_dim(buffer, &map->width, &map->height);
map->map = xmalloc((map->height + 1) * sizeof(*map->map));
i = 0;
while (i < map->height)
{
map->map[i] = xmalloc((map->width) * sizeof(**map->map));
j = 0;
while (j < map->width)
{
map->map[i][j] = buffer[j + i * map->width];
j++;
}
i++;
}
map->width--;
free(buffer);
return (map);
}
/* walks @directory, calling @callback on each template to check */
static void
traverse_dir (const gchar *directory,
void (*callback) (const gchar *filename,
const gchar *data,
const gchar *data_output,
gpointer user_data),
gpointer user_data)
{
GDir *dir;
GError *err = NULL;
dir = g_dir_open (directory, 0, &err);
if (! dir) {
fprintf (stderr, " ** Failed to open directory \"%s\": %s\n", directory,
err->message);
g_error_free (err);
exit (1);
} else {
const gchar *name;
printf (" Entering test directory \"%s\"...\n", directory);
while ((name = g_dir_read_name (dir))) {
gchar *path;
gchar *path_output;
gchar *data;
gchar *data_output;
/* ignore hidden files and -output */
if (g_str_has_prefix (name, ".") || g_str_has_suffix (name, "-output")) {
continue;
}
path = g_build_filename (directory, name, NULL);
path_output = g_strconcat (path, "-output", NULL);
get_file_content (path, &data, FALSE);
get_file_content (path_output, &data_output, TRUE);
printf (" Test \"%s\"...\n", path);
callback (path, data, data_output, user_data);
g_free (path);
g_free (path_output);
g_free (data);
g_free (data_output);
}
printf (" Leaving test directory \"%s\".\n", directory);
g_dir_close (dir);
}
}
char* get_file_content_path(const char *dir_name, const char *file_name)
{
char *file_path_name = get_file_path_name(dir_name, file_name);
char *content = get_file_content(file_path_name);
free(file_path_name);
return content;
}
static void list_functions(const char *path, char *string)
{
enum func_states state;
struct stat st;
char *str;
int ret = 0;
int len;
int i;
int first = 0;
/* Ignore if it does not exist. */
ret = stat(path, &st);
if (ret < 0)
return;
str = get_file_content(path);
if (!str)
return;
len = strlen(str);
state = FUNC_STATE_START;
/* Skip all lines that start with '#' */
for (i = 0; i < len; i++) {
if (state == FUNC_STATE_PRINT)
putchar(str[i]);
if (str[i] == '\n') {
state = FUNC_STATE_START;
continue;
}
if (state == FUNC_STATE_SKIP)
continue;
if (state == FUNC_STATE_START && str[i] == '#') {
state = FUNC_STATE_SKIP;
continue;
}
if (!first) {
printf("\n%s:\n", string);
first = 1;
}
if (state != FUNC_STATE_PRINT) {
state = FUNC_STATE_PRINT;
printf(" ");
putchar(str[i]);
}
}
free(str);
}
void http_handler(struct evhttp_request *req, void *arg)
{
if (strcmp(req->uri, JSON_RPC_ENDPOINT) == 0 || strcmp(req->uri, WS_ENDPOINT) == 0)
return;
char *path = (strcmp(req->uri, "/") == 0) ? get_path(ROOT_URI) : get_path(req->uri);
if (path == NULL)
goto error;
int len = get_file_size(path);
if (len == -1) {
evhttp_send_error(req, HTTP_NOT_FOUND_CODE, HTTP_NOT_FOUND_REASON);
free(path);
return;
}
void *buf = get_file_content(path);
if (buf == NULL)
goto error;
struct evbuffer *evbuf = evbuffer_new();
if (evbuf == NULL)
goto error;
if (evbuffer_add(evbuf, buf, len) == -1) {
evbuffer_free(evbuf);
goto error;
}
if (string_ends_by(path, CSS_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "text/css");
}
if (string_ends_by(path, JS_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "text/javascript");
}
if (string_ends_by(path, PNG_POSTFIX)) {
evhttp_add_header(req->output_headers, "Content-Type", "image/png");
}
evhttp_send_reply(req, HTTP_OK_CODE, HTTP_OK_REASON, evbuf);
free(path);
free(buf);
free(evbuf);
return;
error:
free(path);
free(buf);
evhttp_send_error(req, HTTP_INTERNAL_ERROR_CODE, HTTP_INTERNAL_ERROR_REASON);
}
int main(int argc, char *argv[])
{
// 打开文档文件
// 读取文件内容
// 循环 {
// 读取一行文本
// 如果是楼主的发言标题，类似“百由-服务员(1521136075) 22:39:34”，那就在行尾加一个 \\
// 如果是同学插话，那就设置个标志，表示插话的开始
// 有同学插话标志的时候，把每一行结尾都加 \\
// 如果遇到空行，那就表示同学插话结束，清除插话标志
// }
// 打开文档文件
// 读取文件内容
char *file_name;
unsigned long file_len;
void *buf;
char *pos;
unsigned long remain_len;
char *line;
unsigned long line_len;
if ((argc < 2) || (argc > 2)) {
printf("用法：\n");
printf("tf 文件名\n\n");
}
file_name = argv[1];
buf = get_file_content(file_name, &file_len);
if (!buf)
return 0;
return 0;
pos = buf;
remain_len = file_len;
// 循环 {
while (1) {
// 读取一行文本
//pos = read_a_line(pos, &remain_len, line, &line_len);
if (!pos)
break;
// 如果是楼主的发言标题，类似“百由-服务员(1521136075) 22:39:34”，那就在行尾加一个 \ \
// 如果是同学插话，那就设置个标志，表示插话的开始
// 有同学插话标志的时候，把每一行结尾都加 \ \
// 如果遇到空行，那就表示同学插话结束，清除插话标志
}
}
char* gl_prepare_source(gl_args* args, LPCWSTR shader_file, int* length, bool transpose_shader)
{
std::string str = get_file_content(shader_file);
if (transpose_shader) {
manip_content(&str, L"WIDTH", (args->groups.y * args->threads.x) << 1);
manip_content(&str, L"TILE_DIM", args->tile_dim);
} else {
manip_content(&str, L"LOCAL_DIM_X", args->threads.x);
manip_content(&str, L"SHARED_MEM_SIZE", (args->threads.x << 1));
}
return get_kernel_src_from_string(str, length);
}
static void
process_event_enable(char *path, const char *system, const char *name,
enum event_process *processed)
{
struct stat st;
char *enable = NULL;
char *file;
char *str;
if (system)
path = append_file(path, system);
file = append_file(path, name);
if (system)
free(path);
stat(file, &st);
if (!S_ISDIR(st.st_mode))
goto out;
enable = append_file(file, "enable");
str = get_file_content(enable);
if (!str)
goto out;
if (*str == '1') {
if (!system) {
if (!*processed)
printf(" Individual systems:\n");
printf( " %s\n", name);
*processed = PROCESSED_SYSTEM;
} else {
if (!*processed) {
printf(" Individual events:\n");
*processed = PROCESSED_SYSTEM;
}
if (*processed == PROCESSED_SYSTEM) {
printf(" %s\n", system);
*processed = PROCESSED_EVENT;
}
printf( " %s\n", name);
}
}
free(str);
out:
free(enable);
free(file);
}
void write2_conf(t_struct *st, char *str)
{
char *file;
char *tmp;
int nb;
file = str_nb(st->map_sel);
tmp = get_file_content(str);
nb = my_getnbr(tmp);
free(tmp);
if (st->map_sel > nb)
write_in(str, file);
free(file);
}
int copy_file_to_HOME (const char *dir_name, const char *file_name)
{
int max_path_len = get_max_path_len();
char *path_file = (char *) xnmalloc((max_path_len + 1) * sizeof(char));
// Search conf in /{prefix}/etc/xneur
if (dir_name == NULL)
snprintf(path_file, max_path_len, PACKAGE_SYSCONFDIR_DIR "/%s", file_name);
else
snprintf(path_file, max_path_len, PACKAGE_SYSCONFDIR_DIR "/%s/%s", dir_name, file_name);
FILE *stream = stream = fopen(path_file, "r");
if (stream == NULL)
{
// Search conf in /etc/xneur
if (dir_name == NULL)
snprintf(path_file, max_path_len, "/etc/xneur/%s", file_name);
else
snprintf(path_file, max_path_len, "/etc/xneur/%s/%s", dir_name, file_name);
stream = fopen(path_file, "r");
if (stream == NULL)
return 0;
}
char * file_content = get_file_content(path_file);
// Copy file to Home
// create directory
if (dir_name == NULL)
snprintf(path_file, max_path_len, "%s/%s", getenv("HOME"), HOME_CONF_DIR);
else
snprintf(path_file, max_path_len, "%s/%s/%s", getenv("HOME"), HOME_CONF_DIR, dir_name);
mkdir(path_file, -1);
// create file
if (dir_name == NULL)
snprintf(path_file, max_path_len, "%s/%s/%s", getenv("HOME"), HOME_CONF_DIR, file_name);
else
snprintf(path_file, max_path_len, "%s/%s/%s/%s", getenv("HOME"), HOME_CONF_DIR, dir_name, file_name);
stream = fopen(path_file, "w");
if (stream != NULL)
{
fputs(file_content, stream);
fclose(stream);
return 1;
}
log_message(DEBUG, "%s", path_file);
return 0;
}
/****************************
检查程序文件的MD5有没改变
*****************************/
void build_packet( )
{
char *in_file_content=NULL;
long in_file_len=0;
char new_filename[1024]= {0};
char new_filename2[1024]= {0};
char for_str[]= {'%','s','_','n','e','w','.','c','\0'};
snprintf(new_filename2,strlen(filepath)-1,"%s",filepath);
sprintf(new_filename,for_str,new_filename2);
//printf("%s\n",new_filename);
get_file_content(filepath,&in_file_len,&in_file_content);
format_filename(in_file_content,in_file_len);
free(in_file_content);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
a.setStyleSheet(get_file_content(":/qss/style.qss"));
a.setOrganizationName("rekols");
a.setApplicationName("redict");
#ifdef Q_OS_UNIX
qputenv("QT_QPA_PLATFORMTHEME", "gtk2");
QSettings lock_file(QDir::homePath() + "/.redict/redict.pid", QSettings::IniFormat);
QString last_pid = lock_file.value("LastStart/pid").toString();
if (last_pid.length() && QDir("/proc/" + last_pid).exists() &&
lock_file.value("LastStart/time").toDateTime() == QFileInfo("/proc/" + last_pid).created())
{
qWarning() << "redict already running";
return 0;
}
lock_file.setValue("LastStart/pid", getpid());
lock_file.setValue("LastStart/time", QFileInfo("/proc/" + QString::number(getpid())).created());
lock_file.sync();
#elif defined(Q_OS_WIN)
HANDLE hMutex = CreateMutex(NULL, true, (LPCTSTR)"redict");
if (GetLastError() == ERROR_ALREADY_EXISTS) {
return 0;
}
QFont font = a.font();
font.setFamily("Microsoft Yahei");
a.setFont(font);
#endif
QTranslator translator;
if (translator.load(QString(":/translations/redict_%1.qm")
.arg(QLocale::system().name()))) {
qApp->installTranslator(&translator);
}
MainWindow w;
w.show();
move_to_center(&w);
return a.exec();
}
void generate_files(FILE* file, char* file_name) {
/* Get file content */
char* buff = get_file_content(file);
/* Create new file to save */
FILE* out_f = fopen(file_name, "w");
if(file) {
/* Prints Beamer file to output file on disj */
fprintf(out_f, "%s", buff);
fclose(file);
fclose(out_f);
char* pdflatex = malloc(strlen(file_name) + 9);
sprintf(pdflatex, "pdflatex %s", file_name);
system(pdflatex);
system("rm *.aux && rm *.log && rm *.nav && rm *.out && rm *.snm && rm *.toc");
}
else {
printf("An error occurred saving file '%s'\n", file_name);
}
}
int open_file(char *file) {
if ((strstr(file,".ovd")!=NULL) || (strstr(file,".odt")!=NULL) ) /* check whether it's a ovd or odt*/
{
if (strstr(file,".ovd")!=NULL) /* ovd*/
{
ovd_file = fopen(file,"r");
if (ovd_file != NULL)
{
buffer = (struct fileinfo *)malloc(sizeof(struct fileinfo));
main_win = subwin(stdscr,LINES-2,COLS,1,0);
get_file_content(ovd_file, file, buffer);
fclose(ovd_file);
cur_char = buffer->content;
print_site(buffer->cur_line, buffer->lines);
print_file(buffer,cur_char);
file_printed = true;
file_type = 2;
}
else
{
print_status_bar("File does not exist!");
}
}
else /* else if odt */
{
buffer = (struct fileinfo *)malloc(sizeof(struct fileinfo));
main_win= subwin(stdscr,LINES-2,COLS,1,0);
open_odt(file, buffer);
/* get_file_meta("/tmp/ooview/meta.xml",buffer);*/
cur_char = buffer->content;
print_site(buffer->cur_line, buffer->lines);
print_file(buffer,cur_char);
file_printed = true;
file_type = 1;
}
}
else
{
print_status_bar("Must be a OOView-file (ovd) or OpenDocument-file (odt)!");
}
}
void open_odt (char *filename, struct fileinfo *buffer)
{
FILE *tmp;
char unzip_cmd[255] = "unzip -qq -u -d /tmp/ooview ";
char syscall[255] = "cat /tmp/ooview/content.xml | o3totxt > /tmp/ooview/content.tmp";
system("rm -rf /tmp/ooview");
strcat(unzip_cmd,filename);
/*strcat(unzip_cmd," -qq");*/
printf("%s",unzip_cmd);
system(unzip_cmd);
system(syscall);
tmp = fopen ("/tmp/ooview/content.tmp","r");
get_file_content(tmp, filename, buffer);
fclose(tmp);
}
static t_player *new_player(char *filename)
{
t_player *player;
size_t file_len;
int fd;
header_t *h;
if ((fd = open(filename, O_RDONLY)) < 0)
return (NULL);
if (!(player = my_memalloc(sizeof(*player))))
return (NULL);
if (!(player->file = get_file_content(fd, &file_len)))
return (NULL);
player->file_len = file_len;
player->alive = -1;
h = player->file;
my_strncpy(player->name, h->prog_name, PROG_NAME_LENGTH + 1);
close(fd);
return (player);
}
int
main (int argc,
char **argv)
{
const gchar *srcdir;
gchar *env_str;
gchar *path = NULL;
GError *err = NULL;
/* for autotools integration */
if (! (srcdir = g_getenv ("srcdir"))) {
srcdir = ".";
}
/* possible arg to override */
if (argc == 2) {
srcdir = argv[1];
} else if (argc > 2) {
fprintf (stderr, "USAGE: %s SRCDIR", argv[0]);
return 1;
}
g_type_init ();
#define setptr(ptr, val) (ptr = (g_free (ptr), val))
setptr (path, g_build_filename (srcdir, "environ", NULL));
get_file_content (path, &env_str, FALSE);
setptr (path, g_build_filename (srcdir, "success", NULL));
traverse_dir (path, success_tests_item, env_str);
setptr (path, g_build_filename (srcdir, "fail", NULL));
traverse_dir (path, fail_tests_item, env_str);
setptr (path, NULL);
#undef setptr
g_free (env_str);
return 0;
}
static void
process_event_trigger(char *path, struct event_iter *iter, enum event_process *processed)
{
const char *system = iter->system_dent->d_name;
const char *event = iter->event_dent->d_name;
struct stat st;
char *trigger = NULL;
char *file;
char *str;
char *cont;
path = append_file(path, system);
file = append_file(path, event);
free(path);
stat(file, &st);
if (!S_ISDIR(st.st_mode))
goto out;
trigger = append_file(file, "trigger");
str = get_file_content(trigger);
if (!str)
goto out;
cont = strstrip(str);
if (cont[0] == '#') {
free(str);
goto out;
}
if (!*processed)
printf("\nTriggers:\n");
printf( " %s:%s \"%s\"\n", system, event, cont);
*processed = PROCESSED_SYSTEM;
free(str);
out:
free(trigger);
free(file);
}
void write_in_conf_file(t_struct *st)
{
char *str;
int nb;
char *file;
str = get_file_content(WORLD);
nb = my_getnbr(str);
file = my_strcat("conf/map/world", str);
free(str);
str = my_strcat(file, "/level");
free(file);
if (nb < st->world_sel)
{
file = str_nb(st->world_sel);
write_in(WORLD, file);
free(file);
}
else
write2_conf(st, str);
free(str);
}
/** Example 1 entry point. */
int example_1_entry(int argc, char **argv) {
unsigned long buffer_size = 2048;
char *json_data = malloc(buffer_size * sizeof(char));
if (!get_file_content("json/example_1.json", json_data, &buffer_size)) {
return -1;
}
jfes_parser_t parser;
jfes_token_t tokens[1024];
jfes_size_t tokens_count = 1024;
jfes_config_t config;
config.jfes_malloc = malloc;
config.jfes_free = free;
jfes_init_parser(&parser, &config);
jfes_status_t status = jfes_parse_tokens(&parser, json_data, buffer_size, tokens, &tokens_count);
free(json_data);
return 0;
}
cl_int ocl_setup_program(std::string kernel_filename, char *kernel_name, ocl_args *args, int tile_dim, int block_dim)
{
cl_int err = CL_SUCCESS;
cl_program program;
cl_kernel kernel;
// Read kernel file as a char *
//char *src = get_kernel_src(std::string("Platforms/OpenCL/" + kernel_filename + ".cl"), NULL);
std::string str = get_file_content(std::string("Platforms/OpenCL/" + kernel_filename + ".cl"));
//free(src);
manip_content(&str, L"OCL_TILE_DIM", tile_dim);
manip_content(&str, L"OCL_BLOCK_DIM", block_dim);
char *src = get_kernel_src_from_string(str, NULL);
// Create the compute program from the source buffer
program = clCreateProgramWithSource(args->context, 1, (const char **)&src, NULL, &err);
if (err != CL_SUCCESS) return err;
// Build the program executable
if (err = clBuildProgram(program, 0, NULL, "-cl-single-precision-constant -cl-mad-enable -cl-fast-relaxed-math", NULL, NULL) != CL_SUCCESS) {
size_t len;
clGetProgramBuildInfo(program, args->device_id, CL_PROGRAM_BUILD_LOG, NULL, NULL, &len);
char *buffer = (char *)malloc(sizeof(char) * len);
clGetProgramBuildInfo(program, args->device_id, CL_PROGRAM_BUILD_LOG, len, buffer, NULL);
printf("\n%s\n", buffer);
free(buffer);
return err;
}
// Create the compute kernel in the program we wish to run
kernel = clCreateKernel(program, kernel_name, &err);
if (err != CL_SUCCESS) return err;
args->program = program;
args->kernel = kernel;
free(src);
return err;
}
G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *info)
{
TrackerSparqlBuilder *metadata;
TrackerConfig *config;
gchar *content;
config = tracker_main_get_config ();
metadata = tracker_extract_info_get_metadata_builder (info);
content = get_file_content (tracker_extract_info_get_file (info),
tracker_config_get_max_bytes (config));
tracker_sparql_builder_predicate (metadata, "a");
tracker_sparql_builder_object (metadata, "nfo:PlainTextDocument");
if (content) {
tracker_sparql_builder_predicate (metadata, "nie:plainTextContent");
tracker_sparql_builder_object_unvalidated (metadata, content);
g_free (content);
}
return TRUE;
}
/*****************************************************************************\
* read_shader *
\*****************************************************************************/
GLuint read_shader(const std::string &vertex_filename,
const std::string &fragment_filename)
{
GLint status;
std::string source;
const char *cstring;
GLuint program;
if(access(vertex_filename.data(),F_OK) == -1)
{
std::cerr<<"Cannot load shader file "<<vertex_filename<<std::endl;
std::cerr<<"Wrong path ?"<<std::endl;
abort();
}
if(access(fragment_filename.data(),F_OK) == -1)
{
std::cerr<<"Cannot load shader file "<<vertex_filename<<std::endl;
std::cerr<<"Wrong path ?"<<std::endl;
abort();
}
program = glCreateProgram(); PRINT_OPENGL_ERROR();
// Create the vertex shader.
if (vertex_filename != "")
{
GLuint handle = glCreateShader(GL_VERTEX_SHADER); PRINT_OPENGL_ERROR();
source = get_file_content(vertex_filename);
cstring = source.c_str();
glShaderSource(handle, 1, &cstring, NULL); PRINT_OPENGL_ERROR();
// Compile the vertex shader, and print out the compiler log file.
glCompileShader(handle); PRINT_OPENGL_ERROR();
glGetShaderiv(handle, GL_COMPILE_STATUS, &status); PRINT_OPENGL_ERROR();
print_shader_info_log(handle);
glAttachShader(program, handle); PRINT_OPENGL_ERROR();
if (!status) return 0;
}
// Create the fragment shader
if (fragment_filename != "")
{
GLuint handle = glCreateShader(GL_FRAGMENT_SHADER); PRINT_OPENGL_ERROR();
source = get_file_content(fragment_filename);
cstring = source.c_str();
glShaderSource(handle, 1, &cstring, NULL); PRINT_OPENGL_ERROR();
// Compile the fragment shader, and print out the compiler log file.
glCompileShader(handle); PRINT_OPENGL_ERROR();
glGetShaderiv(handle, GL_COMPILE_STATUS, &status); PRINT_OPENGL_ERROR();
print_shader_info_log(handle);
glAttachShader(program, handle); PRINT_OPENGL_ERROR();
if (!status) return 0;
}
// Link the program object and print out the info log.
glLinkProgram(program); PRINT_OPENGL_ERROR();
glGetProgramiv(program, GL_LINK_STATUS, &status); PRINT_OPENGL_ERROR();
print_program_info_log(program);
if (!status) return 0;
// Install program object as part of current state.
glUseProgram(program); PRINT_OPENGL_ERROR();
return program;
}
int
print_tldrpage(char const* input)
{
int islinux;
int isdarwin;
char* output;
char* platform;
char url[1024];
struct utsname sys;
int homelen;
char* homedir;
int tldrlen;
char* tldrdir = "/.tldr/tldr-master/pages/";
char directory[1024];
struct stat sb;
uname(&sys);
islinux = strcmp(sys.sysname, "Linux") == 0;
isdarwin = strcmp(sys.sysname, "Darwin") == 0;
if (islinux) { platform = "linux"; }
else if (isdarwin) { platform = "osx"; }
else { platform = "common"; }
if ((homedir = getenv("HOME")) == NULL)
{
homedir = getpwuid(getuid())->pw_dir;
}
homelen = strlen(homedir);
tldrlen = strlen(tldrdir);
memcpy(directory, homedir, homelen);
memcpy(directory + homelen, tldrdir, tldrlen);
directory[homelen + tldrlen] = '\0';
if (stat(directory, &sb) == 0 && S_ISDIR(sb.st_mode))
{
construct_path(url, 1024, homedir, input, platform);
if (stat(url, &sb) == 0 && S_ISREG(sb.st_mode))
{
if (!get_file_content(url, &output, 0))
{
parse_tldrpage(output);
free(output);
return 0;
}
}
else
{
construct_path(url, 1024, homedir, input, "common");
if (stat(url, &sb) == 0 && S_ISREG(sb.st_mode))
{
if (!get_file_content(url, &output, 0))
{
parse_tldrpage(output);
free(output);
return 0;
}
}
}
}
construct_url(url, 1024, input, platform);
download_content(url, &output, 0);
if (output == NULL)
{
construct_url(url, 1024, input, "common");
download_content(url, &output, 0);
if (output == NULL) { return 1; }
}
parse_tldrpage(output);
free(output);
return 0;
}
int RFG_Filter_readDefFile( RFG_Filter* filter, int rank, uint8_t* r_isRankOff )
{
char* line;
uint32_t lineno = 0;
size_t pos = 0;
uint8_t parse_err = 0;
uint8_t l_is_rank_off = 0;
uint8_t includes_current_rank = 1;
if( !filter || !filter->file_name )
return 0;
/* reset filter rules */
if( !RFG_Filter_reset( filter ) )
return 0;
/* get filter file content, if necessary */
if( !filter->file_content )
{
if( !get_file_content( filter ) )
{
fprintf( stderr,
"RFG_Filter_readDefFile(): Error: Could not read file '%s'\n",
filter->file_name );
return 0;
}
}
/* allocate memory for line */
line = ( char* )malloc( MAX_LINE_LEN * sizeof( char ) );
if( !line ) return 0;
/* read lines */
while( !l_is_rank_off && !parse_err &&
get_file_content_line( filter, line, MAX_LINE_LEN, &pos ) )
{
char* p;
char* q;
/* increment line number */
lineno++;
/* remove newline */
if( strlen(line) > 0 && line[strlen(line)-1] == '\n' )
line[strlen(line)-1] = '\0';
/* remove leading and trailing spaces from line */
vt_strtrim( line );
/* cut possible comment from line */
p = strchr( line, '#' );
if( p ) *p = '\0';
/* continue if line is empty */
if( strlen( line ) == 0 )
continue;
if( line[0] == '@' )
{
int a = -1;
int b = -1;
uint8_t is_rank_off_rule = 0;
/* check whether selected ranks shall be disabled */
if( ( p = strstr( line, "--" ) ) )
{
/* cut "-- OFF" from line */
*p = '\0';
p += 2;
while( *p == ' ' || *p == '\t' ) p++;
q = p;
while( *q != '\0' ) { *q = tolower( *q ); q++; }
if( strcmp( p, "off" ) == 0 )
{
is_rank_off_rule = 1;
}
else
{
parse_err = 1;
break;
}
}
/* no specific rank given? */
if( rank == -1 )
{
/* continue reading, if selected ranks shall be disabled
(non-rank-specific filter rules can follow) */
if( is_rank_off_rule )
continue;
/* otherwise, stop reading
(all the following filter rules are rank-specific which will be
read later) */
else
break;
}
/* parse rank selection
If current rank is included, then read the following filter rules.
Otherwise, jump to next @ clause. */
p = line + 1;
includes_current_rank = 0;
while( 1 )
{
while( *p == ' ' || *p == '\t' ) p++;
if( *p >= '0' && *p <= '9' )
{
errno = 0;
a = strtol( p, &q, 10 );
p = q;
if( errno != 0 )
{
parse_err = 1;
break;
}
}
else if( *p == '-' && *(p+1) != '\0' && a != -1 )
{
p++;
errno = 0;
b = strtol( p, &q, 10 );
p = q;
if( errno != 0 )
{
parse_err = 1;
break;
}
}
else if( (*p == ';' || *p == ',') && a != -1 )
{
p++;
if( a == rank || (a < rank && rank <= b ) )
{
includes_current_rank = 1;
if( is_rank_off_rule )
{
l_is_rank_off = 1; /* deactivate this rank completely */
break;
}
}
else if( is_rank_off_rule )
{
includes_current_rank = 1;
}
a = b = -1;
}
else if( *p == '\0' && a != -1 )
{
if( a == rank || (a < rank && rank <= b ) )
{
includes_current_rank = 1;
if( is_rank_off_rule )
l_is_rank_off = 1; /* deactivate this rank completely */
}
else if( is_rank_off_rule )
{
includes_current_rank = 1;
}
break;
}
else
{
parse_err = 1;
break;
}
}
}
else
{
int32_t climit;
uint32_t sbounds[2] = { 1, (uint32_t)-1 };
uint8_t flags = 0;
uint8_t is_cpath_rule = 0;
uint32_t num_cpath_regions = 0;
char* cpath_regions[RFG_FILTER_MAX_CPATH_SIZE];
/* search for '--'
e.g. "func1;func2;func3 -- 1000 S:5-10 R"
p
*/
if( !( p = strstr( line, "--" ) ) )
{
parse_err = 1;
break;
}
/* cut call limit, stack level bounds, and flags from line
e.g. "func1;func2;func3 -- 1000 S:5-10 R"
=> "func1;func2;func3"
*/
*p = '\0';
/* split remaining line at ' ' to get call limit, stack level bounds,
and flags */
if( !( p = strtok( p+2, " " ) ) )
{
parse_err = 1;
break;
}
/* parse call limit */
{
long l_climit;
l_climit = strtol( p, &q, 10 );
if( p == q || l_climit == LONG_MIN || l_climit == LONG_MAX ||
l_climit < -1 )
{
parse_err = 1;
break;
}
climit = (int32_t)l_climit;
}
/* parse stack level bounds and flags */
while( !parse_err && ( p = strtok( NULL, " " ) ) )
{
/* stack level bounds */
if( strlen( p ) > 2 && tolower( *p ) == 's' && *(p+1) == ':' )
{
long l_bounds[2] = { 1 };
p = p+2;
/* parse maximum (or minimum) stack level bound */
l_bounds[1] = strtol( p, &q, 10 );
if( p == q || l_bounds[1] == LONG_MIN || l_bounds[1] == LONG_MAX ||
l_bounds[1] < 1 )
{
parse_err = 1;
break;
}
p = q;
/* minimum stack level bound specified? */
if( *p == '-' )
{
p++;
l_bounds[0] = l_bounds[1];
/* parse maximum stack level bound */
l_bounds[1] = strtol( p, &q, 10 );
if( p == q || l_bounds[1] == LONG_MIN || l_bounds[1] == LONG_MAX ||
l_bounds[1] < l_bounds[0] )
{
parse_err = 1;
break;
}
p = q;
}
if( strlen( p ) > 1 || ( *p != '\0' && *p != '\t' ) )
{
parse_err = 1;
break;
}
sbounds[0] = (uint32_t)l_bounds[0];
sbounds[1] = (uint32_t)l_bounds[1];
}
/* group flag */
else if( strlen( p ) == 1 && tolower( *p ) == 'g' )
{
flags |= RFG_FILTER_FLAG_GROUP;
}
/* recursiveness flag */
else if( strlen( p ) == 1 && tolower( *p ) == 'r' )
{
flags |= RFG_FILTER_FLAG_RECURSIVE;
}
/* call-path flag */
else if( strlen( p ) == 1 && tolower( *p ) == 'c' )
{
is_cpath_rule = 1;
}
else
{
parse_err = 1;
break;
}
}
/* call-path flag must not be mixed with other flags
(except recursiveness) or stack level bounds */
parse_err = ( parse_err || ( is_cpath_rule &&
( ( flags != 0 && flags != RFG_FILTER_FLAG_RECURSIVE ) ||
sbounds[0] != 1 || sbounds[1] != (uint32_t)-1 ) ) );
if( parse_err )
break;
/* split line at ';' to get pattern/region names */
p = strtok( line, ";" );
do
{
char* pattern_or_rname;
if( !p )
{
parse_err = 1;
break;
}
pattern_or_rname = strdup( p );
vt_strtrim( pattern_or_rname );
if( *pattern_or_rname != '\0' && includes_current_rank )
{
if( is_cpath_rule )
{
/* max. number of regions in a call path exceeded? */
if( num_cpath_regions + 1 > RFG_FILTER_MAX_CPATH_SIZE )
{
free( pattern_or_rname );
parse_err = 1;
break;
}
/* add region to array of call-path region names */
cpath_regions[num_cpath_regions++] = pattern_or_rname;
}
else
{
/* add region filter rules */
RFG_Filter_addRegionRules( filter, pattern_or_rname, climit,
sbounds, flags );
free( pattern_or_rname );
}
}
else
{
free( pattern_or_rname );
}
} while( ( p = strtok( 0, ";" ) ) );
if( is_cpath_rule )
{
if( !parse_err )
{
/* add call-path filter rules */
RFG_Filter_addCallPathRules( filter, num_cpath_regions,
(const char**)cpath_regions, climit,
NULL, NULL );
}
/* free array of call-path region names */
do free( cpath_regions[--num_cpath_regions] );
while( num_cpath_regions > 0 );
}
}
}
free( line );
if( parse_err )
{
fprintf( stderr, "%s:%u: Could not be parsed\n",
filter->file_name, lineno );
return 0;
}
if( r_isRankOff )
*r_isRankOff = l_is_rank_off;
return 1;
}
int main (int argc, char **argv)
{
logfilepath = getenv ("HOME");
logfilepath = strcat (logfilepath, "/.ooview.log");
load_config();
initscr();
raw();
noecho();
start_color();
keypad(stdscr,TRUE);
init_pair(1, COLOR_WHITE, COLOR_BLACK);
init_pair(2, COLOR_RED, COLOR_WHITE);
init_pair(3, COLOR_BLUE, COLOR_WHITE);
init_pair(4, COLOR_BLACK, COLOR_WHITE);
bkgd(COLOR_PAIR(1));
curs_set(0);
menu_bar = subwin(stdscr,1,COLS,0,0);
wbkgd(menu_bar,COLOR_PAIR(2));
waddstr(menu_bar,"File");
wattron(menu_bar, COLOR_PAIR(3));
waddstr(menu_bar,"<F1>");
wattroff(menu_bar, COLOR_PAIR(3));
wmove(menu_bar, 0, 19);
waddstr(menu_bar,"View");
wattron(menu_bar, COLOR_PAIR(3));
waddstr(menu_bar,"<F2>");
wattroff(menu_bar, COLOR_PAIR(3));
wmove(menu_bar, 0, 34);
waddstr(menu_bar,"Options");
wattron(menu_bar, COLOR_PAIR(3));
waddstr(menu_bar,"<F3>");
wattroff(menu_bar, COLOR_PAIR(3));
wmove(menu_bar, 0, 53);
waddstr(menu_bar,"Help");
wattron(menu_bar, COLOR_PAIR(3));
waddstr(menu_bar,"<F4>");
wattroff(menu_bar, COLOR_PAIR(3));
status_bar = subwin(stdscr,1,COLS,LINES-1,0);
wbkgd(status_bar,COLOR_PAIR(4));
n_choices[0] = ARRAY_SIZE(file_choices);
n_choices[1] = ARRAY_SIZE(view_choices);
n_choices[2] = ARRAY_SIZE(opts_choices);
n_choices[3] = ARRAY_SIZE(help_choices);
file_items = (ITEM **)calloc(n_choices[0] + 1, sizeof(ITEM *));
view_items = (ITEM **)calloc(n_choices[1] + 1, sizeof(ITEM *));
opts_items = (ITEM **)calloc(n_choices[2] + 1, sizeof(ITEM *));
help_items = (ITEM **)calloc(n_choices[3] + 1, sizeof(ITEM *));
for (i=0; i<n_choices[0]; ++i)
file_items[i] = new_item(file_choices[i], NULL);
for (i=0; i<n_choices[1]; ++i)
view_items[i] = new_item(view_choices[i], NULL);
for (i=0; i<n_choices[2]; ++i)
opts_items[i] = new_item(opts_choices[i], NULL);
for (i=0; i<n_choices[3]; ++i)
help_items[i] = new_item(help_choices[i], NULL);
file_items[n_choices[0]] = (ITEM *)NULL;
view_items[n_choices[1]] = (ITEM *)NULL;
opts_items[n_choices[2]] = (ITEM *)NULL;
help_items[n_choices[3]] = (ITEM *)NULL;
file_menu = new_menu((ITEM **)file_items);
view_menu = new_menu((ITEM **)view_items);
opts_menu = new_menu((ITEM **)opts_items);
help_menu = new_menu((ITEM **)help_items);
set_menu_mark(file_menu, "");
set_menu_mark(view_menu, "");
set_menu_mark(opts_menu, "");
set_menu_mark(help_menu, "");
init_screen();
if (argc == 2)
open_file(argv[1]);
while ((c = getch()) != EXIT_KEY)
{
action_performed = false;
switch (c)
{
case KEY_F(1):
cur_menu=1;
break;
case KEY_F(2):
cur_menu=2;
break;
case KEY_F(3):
cur_menu=3;
break;
case KEY_F(4):
cur_menu=4;
break;
case KEY_UP:
if ((file_printed) && (buffer->cur_line > 1))
{
int backsteps = 0;
int steps;
char *tmp;
if ((*--cur_char)==NEWLINE)
backsteps++;
tmp = cur_char - 1;
if ((*--cur_char) == NEWLINE)
{
cur_char = tmp;
print_status_bar("yeah");
}
else
{
do {
cur_char--;
backsteps++;
} while (((*cur_char)!=NEWLINE) && (cur_char != buffer->content));
if (backsteps > COLS)
{
int test;
test = backsteps/COLS;
steps = (backsteps%COLS);
if (test>1)
steps += COLS;
mvwprintw(status_bar,0,0,"%d",steps);
touchwin(status_bar);
wrefresh(status_bar);
cur_char += backsteps;
cur_char -= steps;
}
}
buffer->cur_line--;
print_site(buffer->cur_line, buffer->lines);
if (cur_char!=buffer->content)
print_file(buffer,++cur_char);
else
print_file(buffer,cur_char);
}
break;
case KEY_DOWN:
if ((file_printed) && (buffer->cur_line < buffer->lines))
{
int cols=0;
while (((*cur_char)!=NEWLINE) && (cols < COLS-1))
{
cols++;
cur_char++;
}
buffer->cur_line++;
print_site(buffer->cur_line, buffer->lines);
print_file(buffer,++cur_char);
}
break;
default:
if (meta_win!=NULL)
{
delwin(meta_win);
touchwin(stdscr);
refresh();
}
}
if (cur_menu == 1)
{
file_win = newwin(8,19,1,0);
keypad(file_win,TRUE);
box(file_win,0,0);
set_menu_win(file_menu, file_win);
set_menu_sub(file_menu, derwin(file_win,6,17,1,1));
post_menu(file_menu);
while (c = wgetch(file_win))
{
if (c == KEY_DOWN)
menu_driver(file_menu, REQ_DOWN_ITEM);
else if (c == KEY_UP)
menu_driver(file_menu, REQ_UP_ITEM);
else if (c == KEY_RIGHT)
{
cur_menu = 2;
break;
}
else if (c == KEY_LEFT)
{
cur_menu = 4;
break;
}
else if (c == RETURN)
{
cur_menu = 0;
cmd = (char *)item_name(current_item(file_menu));
action_performed = true;
break;
}
else
{
cur_menu = 0;
break;
}
}
unpost_menu(file_menu);
touchwin(stdscr);
wrefresh(stdscr);
}
if (cur_menu == 2)
{
view_win = newwin(6,15,1,19);
keypad(view_win,TRUE);
box(view_win,0,0);
set_menu_win(view_menu, view_win);
set_menu_sub(view_menu, derwin(view_win,4,13,1,1));
post_menu(view_menu);
while (c = wgetch(view_win))
{
if (c == KEY_DOWN)
menu_driver(view_menu, REQ_DOWN_ITEM);
else if (c == KEY_UP)
menu_driver(view_menu, REQ_UP_ITEM);
else if (c == KEY_RIGHT)
{
cur_menu = 3;
break;
}
else if (c == KEY_LEFT)
{
cur_menu = 1;
break;
}
else if (c == RETURN)
{
cur_menu = 0;
cmd = (char *)item_name(current_item(view_menu));
action_performed = true;
break;
}
else
{
cur_menu = 0;
break;
}
}
unpost_menu(view_menu);
touchwin(stdscr);
refresh();
}
if (cur_menu == 3)
{
opts_win = newwin(5,19,1,34);
keypad(opts_win,TRUE);
box(opts_win,0,0);
set_menu_win(opts_menu, opts_win);
set_menu_sub(opts_menu, derwin(opts_win,3,17,1,1));
post_menu(opts_menu);
while (c = wgetch(opts_win))
{
if (c == KEY_DOWN)
menu_driver(opts_menu, REQ_DOWN_ITEM);
else if (c == KEY_UP)
menu_driver(opts_menu, REQ_UP_ITEM);
else if (c == KEY_RIGHT)
{
cur_menu = 4;
break;
}
else if (c == KEY_LEFT)
{
cur_menu = 2;
break;
}
else if (c == RETURN)
{
cur_menu = 0;
cmd = (char *)item_name(current_item(opts_menu));
action_performed = true;
break;
}
else
{
cur_menu = 0;
break;
}
}
unpost_menu(opts_menu);
touchwin(stdscr);
refresh();
}
if (cur_menu == 4)
{
help_win = newwin(6,17,1,53);
keypad(help_win,TRUE);
box(help_win,0,0);
set_menu_win(help_menu, help_win);
set_menu_sub(help_menu, derwin(help_win,4,15,1,1));
post_menu(help_menu);
while (c = wgetch(help_win))
{
if (c == KEY_DOWN)
menu_driver(help_menu, REQ_DOWN_ITEM);
else if (c == KEY_UP)
menu_driver(help_menu, REQ_UP_ITEM);
else if (c == KEY_RIGHT)
{
cur_menu = 1;
break;
}
else if (c == KEY_LEFT)
{
cur_menu = 3;
break;
}
else if (c == RETURN)
{
cur_menu = 0;
cmd = (char *)item_name(current_item(help_menu));
action_performed = true;
break;
}
else
{
cur_menu = 0;
break;
}
}
unpost_menu(help_menu);
touchwin(stdscr);
refresh();
}
if (action_performed)
{
char file[80];
clear_status_bar();
if (!strcmp(cmd,"Open"))
{
if (file_printed==false)
{
print_status_bar("Enter a file: ");
curs_set(1);
echo();
wscanw(status_bar,"%s",file); /* get filename from user */
curs_set(0);
noecho();
open_file(file);
}
else
{
print_status_bar("Please close current file.");
}
}
if (!strcmp(cmd,"Close"))
{
if (file_printed)
{
free(buffer);
werase(main_win);
init_screen();
wrefresh(main_win);
file_printed = false;
system("rm -rf /tmp/ooview");
}
else
{
print_status_bar("No open file!");
}
}
if (!strcmp(cmd,"Reload"))
{
if (file_printed)
{
if (strstr(file,".ovd")!=NULL) /* ovd*/
{
ovd_file = fopen(file,"r");
if (ovd_file != NULL)
{
free(buffer);
buffer = (struct fileinfo *)malloc(sizeof(struct fileinfo));
main_win = subwin(stdscr,LINES-2,COLS,1,0);
get_file_content(ovd_file, file, buffer);
fclose(ovd_file);
cur_char = buffer->content;
print_site(buffer->cur_line, buffer->lines);
print_file(buffer,cur_char);
file_printed = true;
}
else
{
print_status_bar("File does not exist!");
}
}
else /* else if odt */
{
free(buffer);
buffer = (struct fileinfo *)malloc(sizeof(struct fileinfo));
main_win= subwin(stdscr,LINES-2,COLS,1,0);
open_odt(file,buffer);
get_file_meta("/tmp/ooview/meta.xml",buffer);
cur_char = buffer->content;
print_site(buffer->cur_line, buffer->lines);
print_file(buffer,cur_char);
file_printed = true;
}
}
else
{
print_status_bar("No open file!");
}
}
if (!strcmp(cmd,"Document info"))
{
if (file_printed)
{
if (file_type==1)
{
meta_win = newwin(9,COLS-2,(LINES/2)-5,1);
wbkgd(meta_win,COLOR_PAIR(4));
mvwprintw(meta_win,1,1,"Genarator: %s", buffer->generator);
mvwprintw(meta_win,2,1,"Initial creator:\t%s", buffer->initial_creator);
mvwprintw(meta_win,3,1,"Creation date:\t\t%s", buffer->creation_date);
mvwprintw(meta_win,4,1,"Creator:\t\t%s", buffer->creator);
mvwprintw(meta_win,5,1,"Date:\t\t\t%s", buffer->date);
mvwprintw(meta_win,6,1,"Editing cycles:\t%s", buffer->editing_cycles);
mvwprintw(meta_win,7,1,"Editing duration:\t%s", buffer->editing_duration);
box(meta_win,0,0);
wrefresh(meta_win);
touchwin(meta_win);
}
}
else
{
print_status_bar("No open file!");
}
}
if (!strcmp(cmd,"OOView homepage"))
{
char *syscall;
syscall=(char *)malloc(strlen(BROWSER)+strlen(HOMEPAGE_URL)+1);
sprintf(syscall, "%s %s", BROWSER, HOMEPAGE_URL);
system(syscall);
free(syscall);
if (file_printed)
free(buffer);
end_curses();
return(0);
}
if (!strcmp(cmd,"Documentation"))
{
char *syscall;
syscall=(char *)malloc(strlen(BROWSER)+strlen(HOMEPAGE_URL)+1);
sprintf(syscall, "%s %s", BROWSER, HOMEPAGE_URL);
system(syscall);
free(syscall);
if (file_printed)
free(buffer);
end_curses();
return(0);
}
if (!strcmp(cmd, "About OOView"))
print_status_bar("OOView. Visit Homepage for details");
if (!strcmp(cmd, "Copying"))
print_status_bar("OOView is under GPL/2 Visit Homepage for details");
if (!strcmp(cmd, "Find")) {
if (file_printed) {
print_status_bar("Enter string to find: ");
char *findit;
curs_set(1);
echo();
wscanw(status_bar,"%s",findit);
/*
how to find a string in a string?
find it -> set cursor to position
*/
print_status_bar("Not implemented yet :(");
curs_set(0);
noecho();
} else {
print_status_bar("No open file!");
}
}
if (!strcmp(cmd, "External Programs")) {
char *prompt;
/*getting printer command*/
prompt = (char *)malloc((strlen("Enter Printing Command []: ")+strlen(PRINTER)));
sprintf(prompt,"Enter Printing Command [%s]: ",PRINTER);
print_status_bar(prompt);
free(prompt);
curs_set(1);
echo();
char *newcmd;
wscanw(status_bar,"%s",newcmd);
curs_set(0);
noecho();
print_status_bar(newcmd);
/* / getting printer command*/
}
if (!strcmp(cmd,"Exit"))
{
if (file_printed)
free(buffer);
end_curses();
return 0;
}
}
}
if (file_printed)
free(buffer);
end_curses();
return 0;
}
