---

misc.h

Go to the documentation of this file.

#ifndef GALE_MISC_H
#define GALE_MISC_H

#include <stdio.h>
#include <string.h>
#include <stddef.h>

#include "gale/types.h"
#include "gale/core.h"
#include "oop.h"


enum gale_print_flags {
        gale_print_bold = 1,
        gale_print_clobber_left = 2,
        gale_print_clobber_right = 4
};

void gale_print(FILE *fp,int attr,struct gale_text str);

void gale_print_line(FILE *fp,int attr,struct gale_text);

int gale_column(int start,wch);

int gale_text_width(struct gale_text str);

void gale_beep(FILE *fp);

int gale_columns(FILE *fp);

struct gale_text gale_read_line(FILE *fp);

void gale_exec(oop_source *,struct gale_text prog,
        int count,const struct gale_text *,
        int *in,int *out,
        int (*)(int count,const struct gale_text *,void *user),
        void *(*)(int status,void *user),
        void *user);

void gale_restart(void);

void gale_kill(struct gale_text class,int do_kill);

void gale_cleanup(void (*cleanup)(void *),void *);

void gale_do_cleanup();

void gale_watch_tty(oop_source *oop,int fd);

void gale_daemon(oop_source *);
void gale_detach(oop_source *);

extern const struct gale_data null_data;

void *gale_malloc(size_t size);
void *gale_malloc_atomic(size_t size);
void *gale_malloc_safe(size_t size);
void *gale_realloc(void *mem,size_t len);
void gale_free(void *);

void gale_finalizer(void *ptr,void (*fun)(void *ptr,void *user),void *user);

void gale_check_mem(void);

#define gale_create(x) ((x) = gale_malloc(sizeof(*(x))))

#define gale_create_array(x,count) ((x) = gale_malloc(sizeof(*(x)) * (count)))

#define gale_resize_array(x,count) ((x) = gale_realloc(x,sizeof(*(x)) * (count)))

struct gale_data gale_data_copy(struct gale_data data);

int gale_data_compare(struct gale_data a,struct gale_data b);

struct gale_ptr;

struct gale_ptr *gale_make_weak(void *ptr);

struct gale_ptr *gale_make_ptr(void *);

void *gale_get_ptr(struct gale_ptr *wp);

extern const struct gale_text null_text;
struct gale_encoding;

#define G_(x) (_gale_text_literal(L##x,sizeof(L##x) / sizeof(wch) - 1))

struct gale_text _gale_text_literal(const wchar_t *,size_t len); /* internal */

struct gale_text gale_text_concat(int count,...);
struct gale_text gale_text_concat_array(int count,struct gale_text *array);

struct gale_text_accumulator {
        int count;
        struct gale_text array[100];
};

extern const struct gale_text_accumulator null_accumulator;
void gale_text_accumulate(struct gale_text_accumulator *,struct gale_text);
int gale_text_accumulator_empty(const struct gale_text_accumulator *);
struct gale_text gale_text_collect(const struct gale_text_accumulator *);

struct gale_text gale_text_left(struct gale_text,int len);
struct gale_text gale_text_right(struct gale_text,int len);

int gale_text_token(struct gale_text string,wch sep,struct gale_text *token);
struct gale_text gale_text_replace(
        struct gale_text original,
        struct gale_text find,
        struct gale_text replace);

int gale_text_compare(struct gale_text a,struct gale_text b);

int gale_text_to_number(struct gale_text str);
struct gale_text gale_text_from_number(int n,int base,int pad);

struct gale_data gale_text_as_data(struct gale_text);
struct gale_text gale_text_from_data(struct gale_data);

struct gale_encoding *gale_make_encoding(struct gale_text enc);

struct gale_text gale_text_from(struct gale_encoding *enc,const char *str,int len);

char *gale_text_to(struct gale_encoding *enc,struct gale_text str);

struct gale_map;

struct gale_map *gale_make_map(int weak);

void gale_map_add(struct gale_map *map,struct gale_data key,void *data);

void *gale_map_find(const struct gale_map *map,struct gale_data key);

int gale_map_walk(const struct gale_map *map,const struct gale_data *after,
                  struct gale_data *key,void **data);
struct timeval; /* from Unix */

struct gale_time gale_time_zero(void);
struct gale_time gale_time_now(void);
struct gale_time gale_time_forever(void);
struct gale_time gale_time_seconds(int sec);

int gale_time_compare(struct gale_time a,struct gale_time b);

struct gale_time gale_time_diff(struct gale_time a,struct gale_time b);

struct gale_time gale_time_add(struct gale_time a,struct gale_time b);

void gale_time_to(struct timeval *tv,struct gale_time time);

void gale_time_from(struct gale_time *time,const struct timeval *tv);

struct gale_text gale_time_format(struct gale_time time); 

struct gale_group gale_group_empty(void);

void gale_group_add(struct gale_group *group,struct gale_fragment frag);

void gale_group_append(struct gale_group *a,struct gale_group b);

struct gale_group gale_group_find(struct gale_group,
        struct gale_text name,
        enum gale_fragment_type);

int gale_group_remove(struct gale_group *group,
        struct gale_text name,
        enum gale_fragment_type type);

void gale_group_replace(struct gale_group *group,struct gale_fragment frag);

int gale_group_null(struct gale_group);

struct gale_fragment gale_group_first(struct gale_group);

struct gale_group gale_group_rest(struct gale_group);

void gale_group_prefix(struct gale_group *,struct gale_group tail);

int gale_group_lookup(
        struct gale_group group,struct gale_text name,
        enum gale_fragment_type type,
        struct gale_fragment *frag);

struct gale_text gale_print_fragment(struct gale_fragment,int indent);

struct gale_text gale_print_group(struct gale_group,int indent);

int gale_fragment_compare(struct gale_fragment a,struct gale_fragment b);

int gale_group_compare(struct gale_group a,struct gale_group b);
int gale_unpack_copy(struct gale_data *,void *,size_t);
int gale_unpack_compare(struct gale_data *,const void *,size_t);
void gale_pack_copy(struct gale_data *,const void *,size_t);
#define gale_copy_size(s) (s)

int gale_unpack_skip(struct gale_data *);
void gale_pack_skip(struct gale_data *,size_t);
#define gale_skip_size(sz) ((sz) + gale_u32_size())

int gale_unpack_rle(struct gale_data *,void *,size_t);
void gale_pack_rle(struct gale_data *,const void *,size_t);
#define gale_rle_size(s) (((s)+127)/128+(s))

int gale_unpack_u32(struct gale_data *,u32 *);
void gale_pack_u32(struct gale_data *,u32);
#define gale_u32_size() (sizeof(u32))

int gale_unpack_wch(struct gale_data *,wch *);
void gale_pack_wch(struct gale_data *,wch);
#define gale_wch_size() (sizeof(u16))

/* ANSI; deprecated! */
int gale_unpack_str(struct gale_data *,const char **);
void gale_pack_str(struct gale_data *,const char *);
#define gale_str_size(t) (strlen(t) + 1)

int gale_unpack_text(struct gale_data *,struct gale_text *);
void gale_pack_text(struct gale_data *,struct gale_text);
#define gale_text_size(t) (gale_text_len_size(t) + gale_u32_size())

int gale_unpack_text_len(struct gale_data *,size_t len,
                         /*in,out*/ struct gale_text *);
void gale_pack_text_len(struct gale_data *,struct gale_text);
#define gale_text_len_size(t) ((t).l * gale_wch_size())

int gale_unpack_time(struct gale_data *,struct gale_time *);
void gale_pack_time(struct gale_data *,struct gale_time);
#define gale_time_size() (sizeof(u32) * 4)

int gale_unpack_fragment(struct gale_data *,struct gale_fragment *);
void gale_pack_fragment(struct gale_data *,struct gale_fragment);
size_t gale_fragment_size(struct gale_fragment);

int gale_unpack_group(struct gale_data *,struct gale_group *);
void gale_pack_group(struct gale_data *,struct gale_group);
size_t gale_group_size(struct gale_group);
/* global.h has these preinitialized pathnames, set by gale_init. 
   dot_gale  -> ~/.gale
   home_dir  -> ~
   sys_dir   -> etc/gale */

void make_dir(struct gale_text path,int mode);
struct gale_text sub_dir(struct gale_text path,struct gale_text sub);
struct gale_text submk_dir(struct gale_text path,struct gale_text sub,int mode);
struct gale_text up_dir(struct gale_text path);
struct gale_text dir_file(struct gale_text path,struct gale_text file);
struct gale_text dir_search(struct gale_text name,int cwd,struct gale_text,...);

struct gale_data gale_read_from(int fd,int size_limit);
int gale_write_to(int fd,struct gale_data data);

struct gale_file_state;
struct gale_data gale_read_file(
        struct gale_text name,
        int size_limit,int do_paranoia,
        struct gale_file_state **state);
int gale_write_file(
        struct gale_text name,
        struct gale_data data,
        int is_private,
        struct gale_file_state **state);

int gale_erase_file(const struct gale_file_state *state);
int gale_file_changed(const struct gale_file_state *since);
struct gale_time gale_get_file_time(const struct gale_file_state *state);
void gale_set_file_time(struct gale_file_state *state,struct gale_time);

enum gale_error { GALE_NOTICE, GALE_WARNING, GALE_ERROR };

typedef void *gale_call_error(int severity,struct gale_text msg,void *user);

void gale_alert(int severity,struct gale_text str,int err);
void gale_on_error(oop_source *oop,gale_call_error *func,void *user);
struct gale_report;

typedef struct gale_text gale_report_call(void *user);

struct gale_report *gale_make_report(struct gale_report *outer);

void gale_report_add(struct gale_report *outer,gale_report_call *func,void *user);

void gale_report_remove(struct gale_report *,gale_report_call *,void *);

struct gale_text gale_report_run(struct gale_report *);

void gale_dprintf(int level,const char *fmt,...);

void gale_diprintf(int level,int indent,const char *fmt,...);

typedef void *gale_connect_call(int fd,
        struct gale_text hostname,struct sockaddr_in addr,
        int found_local,void *user);

struct gale_text gale_connect_text(struct gale_text host,struct sockaddr_in);

struct gale_connect;
struct gale_connect *gale_make_connect(
        oop_source *source,struct gale_text host,int avoid_local_port,
        gale_connect_call *,void *);

void gale_abort_connect(struct gale_connect *);
#endif

---