Make these strings 'const', then clean up all the fall-out.
Signed-off-by: NeilBrown <neil@brown.name>
/* attr_cmp just deals with bytes and ASCII digits, so it is
* not aware for wchars
*/
-static int getcmptok(char **ap safe)
+static int getcmptok(const char **ap safe)
{
- char *a safe;
+ const char *a safe;
char c;
int i;
/* Compare 'a' and 'b' treating strings of digits as numbers.
* If bnum >= 0, it is used as a leading number on 'b'.
*/
-static int attr_cmp(char *a safe, char *b safe, int bnum)
+static int attr_cmp(const char *a safe, const char *b safe, int bnum)
{
while (*a && (*b || bnum >= 0)) {
int ai, bi;
#ifdef TEST_ATTR_CMP
#include <stdlib.h>
#include <stdio.h>
-struct {char *a, *b; int result;} test[] = {
+struct {const char *a, *b; int result;} test[] = {
{ "hello", "there", -1},
{ "6hello", "10world", -1},
{ "0005six", "5six", 0},
#endif
-static int __attr_find(struct attrset ***setpp safe, char *key safe,
+static int __attr_find(struct attrset ***setpp safe, const char *key safe,
int *offsetp safe, int keynum)
{
struct attrset **setp safe;
return 1;
}
-int attr_del(struct attrset * *setp safe, char *key safe)
+int attr_del(struct attrset * *setp safe, const char *key safe)
{
int offset = 0;
int cmp;
return 1;
}
-char *attr_get_str(struct attrset *set, char *key safe, int keynum)
+char *attr_get_str(struct attrset *set, const char *key safe, int keynum)
{
struct attrset **setp = &set;
int offset = 0;
return set->attrs + offset;
}
-char *attr_find(struct attrset *set, char *key safe)
+char *attr_find(struct attrset *set, const char *key safe)
{
return attr_get_str(set, key, -1);
}
-char *attr_get_next_key(struct attrset *set, char *key safe, int keynum,
- char **valp safe)
+const char *attr_get_next_key(struct attrset *set, const char *key safe,
+ int keynum, const char **valp safe)
{
struct attrset **setp = &set;
int offset = 0;
int cmp = __attr_find(&setp, key, &offset, keynum);
- char *val;
+ const char *val;
if (cmp < 0)
return NULL;
return key;
}
-int attr_set_str_key(struct attrset **setp safe, char *key safe, char *val,
+int attr_set_str_key(struct attrset **setp safe,
+ const char *key safe, const char *val,
int keynum)
{
int offset = 0;
return cmp;
}
-int attr_set_str(struct attrset **setp safe, char *key safe, char *val)
+int attr_set_str(struct attrset **setp safe,
+ const char *key safe, const char *val)
{
return attr_set_str_key(setp, key, val, -1);
}
#endif
/* Have versions that take and return numbers, '-1' for 'not found' */
-int attr_find_int(struct attrset *set, char *key safe)
+int attr_find_int(struct attrset *set, const char *key safe)
{
- char *val = attr_find(set, key);
+ const char *val = attr_find(set, key);
unsigned long rv;
char *end;
return rv;
}
-int attr_set_int(struct attrset **setp safe, char *key safe, int val)
+int attr_set_int(struct attrset **setp safe, const char *key safe, int val)
{
/* 3 digits per bytes, +1 for sign and +1 for trailing nul */
char sval[sizeof(int)*3+2];
int dir;
char *open;
char *close;
- char *wordchars = ci->str ?: "";
+ const char *wordchars = ci->str ?: "";
const char *special safe = "[](){}'\"";
if (!m)
DEF_CMD(doc_set)
{
struct doc *d = ci->home->data;
- char *val = ci->key + 8;
+ const char *val = ci->key + 8;
if (strcmp(val, "autoclose") == 0) {
d->autoclose = ci->num;
struct pane *doc = ci->home;
struct pane *p, *p2;
char *s;
- char *type = ci->str ?: "default";
+ const char *type = ci->str ?: "default";
p = doc_attach(focus);
if (!p)
{
struct pane *ed = ci->home;
int fd = ci->num;
- char *name = ci->str;
+ const char *name = ci->str;
struct stat stb;
struct pane *p;
int autoclose = ci->num2 & 1;
stb.st_mode = 0;
if (fd >= -1) {
/* Try to canonicalize directory part of path */
- char *sl;
+ const char *sl;
sl = strrchr(name, '/');
if (!sl) {
rp = realpath(".", pathbuf);
DEF_CMD(doc_from_text)
{
- char *name = ci->str;
- char *text = ci->str2;
+ const char *name = ci->str;
+ const char *text = ci->str2;
struct pane *p;
p = call_ret(pane, "attach-doc-text", ci->focus);
{
struct ed_info *ei = ci->home->data;
struct map *map = ei->map;
- char *name = ci->str;
+ const char *name = ci->str;
char buf[PATH_MAX];
#ifndef edlib_init
void *h;
int ret;
struct ed_info *ei = ci->home->data;
struct map *map = ei->map;
- char *mod = ci->key + 7;
+ const char *mod = ci->key + 7;
+ char *mod2 = NULL;
/* Check the key really doesn't exist, rather than
* it fails
char *m = strrchr(ci->key+6, '-');
if (m) {
m += 1;
- mod = malloc(4+strlen(m)+1);
- strcpy(mod, "lib-");
- strcpy(mod+4, m);
+ mod2 = malloc(4+strlen(m)+1);
+ strcpy(mod2, "lib-");
+ strcpy(mod2+4, m);
+ mod = mod2;
}
}
ret = call("global-load-module", ci->home, 0, NULL,
mod, 0);
- if (mod != ci->key + 7)
- free(mod);
+ free(mod2);
if (ret > 0)
/* auto-load succeeded */
return 1;
}
-void * safe memsave(struct pane *p safe, char *buf, int len)
+void * safe memsave(struct pane *p safe, const char *buf, int len)
{
struct ed_info *ei;
return ei->store->space+ei->store->size;
}
-char *strsave(struct pane *p safe, char *buf)
+char *strsave(struct pane *p safe, const char *buf)
{
if (!buf)
return NULL;
return memsave(p, buf, strlen(buf)+1);
}
-char *strnsave(struct pane *p safe, char *buf, int len)
+char *strnsave(struct pane *p safe, const char *buf, int len)
{
char *s;
if (!buf)
return s;
}
-char * safe __strconcat(struct pane *p safe, char *s1 safe, ...)
+char * safe __strconcat(struct pane *p safe, const char *s1 safe, ...)
{
va_list ap;
char *s;
}
-static int key_present(struct map *map safe, char *key, int klen,
+static int key_present(struct map *map safe, const char *key, int klen,
unsigned int *hashp safe)
{
int hash;
}
/* Find first entry >= k */
-static int key_find_len(struct map *map safe, char *k safe, int len)
+static int key_find_len(struct map *map safe, const char *k safe, int len)
{
int lo = 0;
int hi = map->size;
return hi;
}
-static int key_find(struct map *map safe, char *k safe)
+static int key_find(struct map *map safe, const char *k safe)
{
return key_find_len(map, k, strlen(k));
}
-void key_add(struct map *map safe, char *k safe, struct command *comm)
+void key_add(struct map *map safe, const char *k safe, struct command *comm)
{
int size;
int pos;
map->changed = 1;
}
-void key_add_range(struct map *map safe, char *first safe, char *last safe,
+void key_add_range(struct map *map safe,
+ const char *first safe, const char *last safe,
struct command *comm)
{
int size, move_size;
return 1;
}
-struct command *key_lookup_cmd(struct map *m safe, char *c safe,
- char **cret, int *lenret)
+struct command *key_lookup_cmd(struct map *m safe, const char *c safe,
+ const char **cret, unsigned int *lenret)
{
/* If 'k' contains an ASCII US (Unit Separator, 0o37 0x1f 31),
* it represents multiple keys.
* Call key_find() on each of them until success.
*/
while (*c) {
- char *end = strchr(c, '\037');
+ const char *end = strchr(c, '\037');
int pos;
if (!end)
int key_lookup(struct map *m safe, const struct cmd_info *ci safe)
{
struct command *comm;
- char *key;
- int len;
+ const char *key;
+ unsigned
+ int len;
if (ci->hash && !key_present(m, ci->key, strlen(ci->key), ci->hash)) {
stat_count("bloom-miss");
* keys, we need to pass down the one that was matched.
*/
int ret;
- char *oldkey = ci->key;
- char tail = key[len];
+ const char *oldkey = ci->key;
+ char ktmp[40], *k2 = NULL;
stat_count("bloom-hit-good");
- if (key[len])
- key[len] = 0;
+ if (key[len] == 0) {
+ ((struct cmd_info*)ci)->key = key;
+ } else if (len >= sizeof(ktmp)) {
+ k2 = strndup(key, len);
+ ((struct cmd_info*)ci)->key = k2;
+ } else {
+ strncpy(ktmp, key, len);
+ ktmp[len] = 0;
+ ((struct cmd_info*)ci)->key = ktmp;
+ }
((struct cmd_info*)ci)->comm = comm;
- ((struct cmd_info*)ci)->key = key;
ret = comm->func(ci);
((struct cmd_info*)ci)->key = oldkey;
- if (tail)
- key[len] = tail;
+ free(k2);
return ret;
}
}
int pos = key_find(m, ci->key);
struct command *comm, *prev = NULL;
int len = strlen(ci->key);
- char *k = ci->key;
+ const char *k = ci->key;
while (pos < m->size && strncmp(m->keys[pos], k, len) == 0) {
comm = GETCOMM(m->comms[pos]);
b->size = 0;
}
-void buf_concat_len(struct buf *b safe, char *s safe, int l)
+void buf_concat_len(struct buf *b safe, const char *s safe, int l)
{
if (b->len + l >= b->size) {
b->b[b->len] = 0;
}
-void buf_concat(struct buf *b safe, char *s safe)
+void buf_concat(struct buf *b safe, const char *s safe)
{
int l = strlen(s);
buf_concat_len(b, s, l);
return (start ^ key) * 0x61C88647U;
}
-static int hash_str(char *key safe, int len)
+static int hash_str(const char *key safe, int len)
{
int i;
int h = 0;
static struct kstack {
long long tstart;
- char *name;
+ const char *name;
} kstack[20];
static int ktos = 0;
-void time_start_key(char *key safe)
+void time_start_key(const char *key safe)
{
struct timespec start;
kstack[ktos-1].name = key;
}
-static struct khash *hash_find(struct khash **table, char *key safe)
+static struct khash *hash_find(struct khash **table, const char *key safe)
{
struct khash *h, **hp;
int hash;
return h;
}
-void time_stop_key(char *key safe)
+void time_stop_key(const char *key safe)
{
struct timespec stop;
struct khash *h;
}
void pane_add_notify(struct pane *target safe, struct pane *source safe,
- char *msg safe)
+ const char *msg safe)
{
struct notifier *n;
}
}
-int do_pane_notify(struct pane *home, char *notification safe,
+int do_pane_notify(struct pane *home, const char *notification safe,
struct pane *p safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
struct command *comm2)
{
/* Return the largest absolute return value. If no notifiees are found.
call("pane:refocus", focus);
}
-char *pane_attr_get(struct pane *p, char *key safe)
+char *pane_attr_get(struct pane *p, const char *key safe)
{
while (p) {
char *a = attr_find(p->attrs, key);
}
char *pane_mark_attr(struct pane *p safe, struct mark *m safe,
- char *key safe)
+ const char *key safe)
{
return call_ret(strsave, "doc:get-attr", p, 0, m, key);
}
struct pane *do_call_pane(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
struct mark *do_call_mark(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
struct mark *do_call_mark2(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
struct command *do_call_comm(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
char *do_call_strsave(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
struct call_return do_call_all(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
char *do_call_str(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
int noted;
};
void pane_add_notify(struct pane *target safe, struct pane *source safe,
- char *msg safe);
-int do_pane_notify(struct pane *home, char *notification safe,
+ const char *msg safe);
+int do_pane_notify(struct pane *home, const char *notification safe,
struct pane *p safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
struct command *comm2);
void pane_drop_notifiers(struct pane *p safe, char *notification);
void editor_delayed_free(struct pane *ed safe, struct pane *p safe);
void editor_delayed_mark_free(struct mark *m safe);
struct pane *editor_new(void);
-void * safe memsave(struct pane *p safe, char *buf, int len);
-char *strsave(struct pane *p safe, char *buf);
-char *strnsave(struct pane *p safe, char *buf, int len);
-char * safe __strconcat(struct pane *p safe, char *s1 safe, ...);
+void * safe memsave(struct pane *p safe, const char *buf, int len);
+char *strsave(struct pane *p safe, const char *buf);
+char *strnsave(struct pane *p safe, const char *buf, int len);
+char * safe __strconcat(struct pane *p safe, const char *s1 safe, ...);
#define strconcat(p, ...) __strconcat(p, __VA_ARGS__, NULL)
/* This is declared here so sparse knows it is global */
}
/* Attributes */
-char *attr_find(struct attrset *set, char *key safe);
-int attr_del(struct attrset **setp safe, char *key safe);
-int attr_set_str(struct attrset **setp safe, char *key safe, char *val);
-int attr_set_str_key(struct attrset **setp safe, char *key safe,
- char *val, int keynum);
-char *attr_get_str(struct attrset *setp, char *key safe, int keynum);
-char *attr_get_next_key(struct attrset *set, char *key safe, int keynum,
- char **valp safe);
-int attr_find_int(struct attrset *set, char *key safe);
-int attr_set_int(struct attrset **setp safe, char *key safe, int val);
+char *attr_find(struct attrset *set, const char *key safe);
+int attr_del(struct attrset **setp safe, const char *key safe);
+int attr_set_str(struct attrset **setp safe,
+ const char *key safe, const char *val);
+int attr_set_str_key(struct attrset **setp safe, const char *key safe,
+ const char *val, int keynum);
+char *attr_get_str(struct attrset *setp, const char *key safe, int keynum);
+const char *attr_get_next_key(struct attrset *set, const char *key safe,
+ int keynum,
+ const char **valp safe);
+int attr_find_int(struct attrset *set, const char *key safe);
+int attr_set_int(struct attrset **setp safe, const char *key safe, int val);
void attr_trim(struct attrset **setp safe, int nkey);
struct attrset *attr_copy_tail(struct attrset *set, int nkey);
struct attrset *attr_collect(struct attrset *set, unsigned int pos, int prefix);
* 'mark' is moved by 'move' and 'replace' deletes between point and mark.
*/
struct cmd_info {
- char *key safe;
+ const char *key safe;
struct pane *home safe, *focus safe;
int num, num2;
int x,y; /* relative to focus */
- char *str, *str2;
+ const char *str, *str2;
struct mark *mark, *mark2;
struct command *comm safe;
struct command *comm2;
int key_handle(const struct cmd_info *ci safe);
int key_lookup(struct map *m safe, const struct cmd_info *ci safe);
int key_lookup_prefix(struct map *m safe, const struct cmd_info *ci safe);
-struct command *key_lookup_cmd(struct map *m safe, char *c safe,
- char **cret, int *lenret);
-void key_add(struct map *map safe, char *k safe, struct command *comm);
-void key_add_range(struct map *map safe, char *first safe, char *last safe,
+struct command *key_lookup_cmd(struct map *m safe, const char *c safe,
+ const char **cret, unsigned int *lenret);
+void key_add(struct map *map safe, const char *k safe, struct command *comm);
+void key_add_range(struct map *map safe,
+ const char *first safe, const char *last safe,
struct command *comm);
#define key_add_prefix(map, prefix, comm) \
key_add_range(map, prefix, prefix "\xFF\xFF\xFF\xFF", comm)
int pane_masked(struct pane *p safe, short x, short y, short abs_z,
short *w, short *h);
-char *pane_attr_get(struct pane *p, char *key safe);
-char *pane_mark_attr(struct pane *p safe, struct mark *m safe, char *key safe);
+char *pane_attr_get(struct pane *p, const char *key safe);
+char *pane_mark_attr(struct pane *p safe, struct mark *m safe,
+ const char *key safe);
void pane_absxy(struct pane *p, short *x safe, short *y safe,
short *w safe, short *h safe);
void pane_relxy(struct pane *p, short *x safe, short *y safe);
struct xy pane_scale(struct pane *p safe);
-static inline int pane_attr_get_int(struct pane *p safe, char *key safe)
+static inline int pane_attr_get_int(struct pane *p safe, const char *key safe)
{
char *c = pane_attr_get(p, key);
int rv;
struct pane *do_call_pane(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
struct mark *do_call_mark(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
struct mark *do_call_mark2(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
struct command *do_call_comm(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
struct call_return do_call_all(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
char *do_call_str(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
char *do_call_strsave(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *cache);
static inline int do_call_val(enum target_type type, struct pane *home,
struct command *comm2a,
- char *key safe, struct pane *focus safe,
- int num, struct mark *m, char *str,
- int num2, struct mark *m2, char *str2,
+ const char *key safe, struct pane *focus safe,
+ int num, struct mark *m, const char *str,
+ int num2, struct mark *m2, const char *str2,
int x, int y, struct command *comm2b,
struct commcache *ccache)
{
}
-static int cvt_attrs(struct pane *home safe, char *attrs)
+static int cvt_attrs(struct pane *home safe, const char *attrs)
{
struct display_data *dd = home->data;
int attr = 0;
char tmp[40];
- char *a;
+ const char *a;
int fg = COLOR_BLACK;
int bg = COLOR_WHITE+8;
set_screen(home);
a = attrs;
while (a && *a) {
- char *c;
+ const char *c;
if (*a == ',') {
a++;
continue;
int size = 0;
int offset = 0;
mbstate_t mbs = {};
- char *str = ci->str;
+ const char *str = ci->str;
int len;
if (!str)
short offset = 0;
short x = ci->x, y = ci->y;
mbstate_t mbs = {};
- char *str = ci->str;
+ const char *str = ci->str;
int len;
if (!str)
return 1;
}
-static struct pane *ncurses_init(struct pane *ed, char *tty, char *term)
+static struct pane *ncurses_init(struct pane *ed,
+ const char *tty, const char *term)
{
SCREEN *scr;
struct pane *p;
{
struct doc *d = ci->home->data;
int fd = ci->num2;
- char *name = ci->str;
+ const char *name = ci->str;
struct directory *dr = container_of(d, struct directory, doc);
struct list_head new;
struct dir_ent *de1, *de2;
}
if (name) {
- char *dname;
+ const char *dname;
int l = strlen(name);
fstat(fd, &dr->stat);
return de->nbuf;
}
-static char *__dir_get_attr(struct doc *d safe, struct mark *m safe,
- char *attr safe)
+static const char *__dir_get_attr(struct doc *d safe, struct mark *m safe,
+ const char *attr safe)
{
struct dir_ent *de;
{
struct doc *d = ci->home->data;
struct mark *m = ci->mark;
- char *attr = ci->str;
- char *val;
+ const char *attr = ci->str;
+ const char *val;
if (!m || !attr)
return Enoarg;
{
struct doc *d = ci->home->data;
struct directory *dr = container_of(d, struct directory, doc);
- char *attr = ci->str;
- char *val;
+ const char *attr = ci->str;
+ const char *val;
if (!attr)
return Enoarg;
{
struct doc *d = ci->home->data;
struct directory *dr = container_of(d, struct directory, doc);
- char *type = ci->str ?: "default";
+ const char *type = ci->str ?: "default";
struct pane *p;
if (strcmp(type, "invisible") == 0 ||
}
static char *__docs_get_attr(struct doc *doc safe, struct mark *m safe,
- char *attr safe)
+ const char *attr safe)
{
struct pane *p;
{
struct doc *d = ci->home->data;
struct mark *m = ci->mark;
- char *attr = ci->str;
+ const char *attr = ci->str;
char *val;
if (!m || !attr)
DEF_CMD(docs_get_attr)
{
- char *attr = ci->str;
+ const char *attr = ci->str;
char *val;
struct doc *d = ci->home->data;
{
struct doc *d = ci->home->data;
struct docs *docs = container_of(d, struct docs, doc);
- char *type = ci->str ?: "default";
+ const char *type = ci->str ?: "default";
struct pane *p;
if (strcmp(type, "invisible") == 0 ||
struct mark *m1 = NULL;
int ret;
int d;
- char *attr = ci->str;
+ const char *attr = ci->str;
if (!ci->mark || !attr)
return Enoarg;
struct mark *m = ci->mark;
struct mark *m1;
int dn;
- char *attr = ci->str;
+ const char *attr = ci->str;
if (!attr)
return Enoarg;
*/
struct mp_info *mpi = ci->home->data;
struct mark *m1, *m2;
- char *key;
+ const char *key = ci->key;
int d;
if (!ci->mark2)
/* at the wrong end of a part */
d += 1;
- key = ci->key;
if (strncmp(key, "multipart-next:", 15) == 0) {
d += 1;
key += 15;
DEF_CMD(dr_get_attr)
{
- char *attr = ci->str;
+ const char *attr = ci->str;
char *val;
struct doc *d = ci->home->data;
struct dr_info *dri = container_of(d, struct dr_info, doc);
* the last 4 bytes. (longest UTF-8 encoding of 21bit unicode is 4 bytes).
* A start of codepoint starts with 0b0 or 0b11, not 0b10.
*/
-static int text_round_len(char *text safe, int len)
+static int text_round_len(const char *text safe, int len)
{
/* The string at 'text' is *longer* than 'len', or
* at least text[len] is defined - it can be nul. If
{
struct doc *d = ci->home->data;
int fd = ci->num2;
- char *name = ci->str;
+ const char *name = ci->str;
off_t size;
struct text_alloc *a;
struct text_chunk *c = NULL;
}
}
if (name) {
- char *dname;
+ const char *dname;
if (fstat(fd, &t->stat) < 0) {
t->newfile = 1;
static int do_text_write_file(struct text *t safe, struct doc_ref *start,
struct doc_ref *end,
- char *fname safe)
+ const char *fname safe)
{
/* Don't worry about links for now
* Create a temp file with #basename#~, write to that,
* copy mode across, fsync and then rename
*/
char *tempname = malloc(strlen(fname) + 3 + 10);
- char *base, *tbase;
+ const char *base;
+ char *tbase;
int cnt = 0;
int fd = -1;
struct stat stb;
}
static void text_add_str(struct text *t safe, struct doc_ref *pos safe,
- char *str safe,
+ const char *str safe,
struct doc_ref *start, bool *first_edit safe)
{
/* Text is added to the end of the referenced chunk, or
doc_check_consistent(d);
}
-static void text_add_attrs(struct attrset **attrs safe, char *new safe, int o)
+static void text_add_attrs(struct attrset **attrs safe,
+ const char *new safe, int o)
{
char sep = *new++;
char *cpy = strdup(new);
struct text *t = container_of(d, struct text, doc);
struct mark *pm = ci->mark2;
struct mark *end = ci->mark;
- char *str = ci->str;
- char *newattrs = ci->str2;
+ const char *str = ci->str;
+ const char *newattrs = ci->str2;
bool first = !ci->num2;
struct mark *early = NULL;
int status_change = 0;
{
struct doc *d = ci->home->data;
struct mark *m = ci->mark;
- char *attr = ci->str;
- char *val;
+ const char *attr = ci->str;
+ const char *val;
struct attrset *a;
int o = 0;
val = attr_get_str(a, attr, o);
comm_call(ci->comm2, "callback:get_attr", ci->focus, 0, NULL, val);
if (ci->num2 == 1) {
- char *key = attr;
+ const char *key = attr;
int len = strlen(attr);
while ((key = attr_get_next_key(a, key, o, &val)) != NULL &&
strncmp(key, attr, len) == 0)
{
struct doc *d = ci->home->data;
struct text *t = container_of(d, struct text, doc);
- char *attr = ci->str;
- char *val;
+ const char *attr = ci->str;
+ const char *val;
if (!attr)
return Enoarg;
DEF_CMD(text_set_attr)
{
- char *attr = ci->str;
- char *val = ci->str2;
+ const char *attr = ci->str;
+ const char *val = ci->str2;
struct text_chunk *c;
struct doc *d = ci->home->data;
struct text *t = container_of(d, struct text, doc);
DEF_CMD(do_replace)
{
struct es_info *esi = ci->home->data;
- char *new = ci->str;
+ const char *new = ci->str;
struct mark *m;
int len = esi->matched - 1;
DEF_CMD(python_load)
{
- char *fname = ci->str;
+ const char *fname = ci->str;
FILE *fp;
PyObject *globals, *main_mod;
PyObject *Ed;
DEF_CMD(python_load_module)
{
- char *name = ci->str;
+ const char *name = ci->str;
FILE *fp;
PyObject *globals, *main_mod;
PyObject *Ed;
return 1;
}
-static PyObject *safe python_string(char *s safe)
+static PyObject *safe python_string(const char *s safe)
{
- char *c = s;
+ const char *c = s;
while (*c && !(*c & 0x80))
c++;
if (*c)
DEF_CMD(history_save)
{
struct history_info *hi = ci->home->data;
- char *eol;
- char *line = ci->str;
- char *prev;
+ const char *eol;
+ const char *line = ci->str;
+ const char *prev;
if (!hi->history || !ci->str)
/* history document was destroyed */
#include "core.h"
struct input_mode {
- char *mode safe;
+ const char *mode safe;
int num, num2;
struct pane *focus, *source;
struct mark *point;
DEF_CMD(keystroke)
{
- char *key;
+ const char *key;
+ char *vkey = NULL;
struct input_mode *im = ci->home->data;
struct pane *p;
int l;
if (im->mode[0]) {
int cnt = 1;
- char *k = ci->str;
+ const char *k = ci->str;
char *end;
while ((end = strchr(k, '\037')) != NULL) {
cnt += 1;
}
l = strlen(im->mode) * cnt + strlen(ci->str) + 1;
- key = malloc(l);
- memset(key, 0, l);
+ vkey = malloc(l);
+ memset(vkey, 0, l);
k = ci->str;
while ((end = strchr(k, '\037')) != NULL) {
end += 1;
- strcat(key, im->mode);
- strncat(key, k, end-k);
+ strcat(vkey, im->mode);
+ strncat(vkey, k, end-k);
k = end;
while (*k == '\037')
k++;
}
- strcat(key, im->mode);
- strcat(key, k);
+ strcat(vkey, im->mode);
+ strcat(vkey, k);
+ key = vkey;
} else
key = ci->str;
m = im->point;
ret = call(key, p, num, m, NULL, num2);
- if (key != ci->str)
- free(key);
+ free(vkey);
if (ret < 0)
call("Message:default", ci->focus, 0, NULL,
"** Command Failed **");
struct timespec now;
unsigned int b;
int press;
- char *mode;
+ const char *mode;
struct mouse_state *ms = NULL;
clock_gettime(CLOCK_MONOTONIC, &now);
static struct pane *safe do_keymap_attach(struct pane *p, int global);
-static struct command *get_command(struct pane *p safe, char *cmd)
+static struct command *get_command(struct pane *p safe, const char *cmd)
{
return call_ret(comm, "global-get-command", p, 0, NULL, cmd);
}
return cr.y;
}
-static void popup_resize(struct pane *p safe, char *style safe)
+static void popup_resize(struct pane *p safe, const char *style safe)
{
struct popup_info *ppi = p->data;
int x,y,w,h;
DEF_CMD(popup_do_close)
{
struct popup_info *ppi = ci->home->data;
- char *key, *str;
+ const char *key, *str;
struct pane *target = ppi->target;
struct command *done;
*/
struct pane *root, *p;
struct popup_info *ppi;
- char *style = ci->str;
+ const char *style = ci->str;
char *in_popup;
int z;
}
static void as_add(struct attr_return *ar safe,
- int end, int prio, char *attr safe)
+ int end, int prio, const char *attr safe)
{
struct attr_stack *new, **here;
}
static void as_clear(struct attr_return *ar safe,
- int prio, char *attr safe)
+ int prio, const char *attr safe)
{
struct attr_stack *st;
static void call_map_mark(struct pane *f safe, struct mark *m safe,
struct attr_return *ar safe)
{
- char *key = "render:";
- char *val;
+ const char *key = "render:";
+ const char *val;
while ((key = attr_get_next_key(m->attrs, key, -1, &val)) != NULL &&
strncmp(key, "render:", 7) == 0)
return last;
}
-static void copy_header(struct pane *doc safe, char *hdr safe, char *type,
+static void copy_header(struct pane *doc safe,
+ const char *hdr safe, const char *type,
struct mark *start safe, struct mark *end safe,
struct pane *p safe, struct mark *point safe)
{
mark_free(m);
}
-static void copy_headers(struct pane *p safe, char *hdr safe, char *type,
+static void copy_headers(struct pane *p safe, const char *hdr safe,
+ const char *type,
struct pane *doc safe, struct mark *pt safe)
{
struct header_info *hi = p->data;
return buf_final(&buf);
}
-static char *load_header(struct pane *home safe, char *hdr safe)
+static char *load_header(struct pane *home safe, const char *hdr safe)
{
struct header_info *hi = home->data;
struct mark *m, *n;
DEF_CMD(header_get)
{
- char *hdr = ci->str;
- char *type = ci->str2;
+ const char *hdr = ci->str;
+ const char *type = ci->str2;
char *attr = NULL;
char *c, *t;
return comm_call(ci->comm2, "callback:attach", p);
}
-static struct pane *tile_split(struct pane **pp safe, int horiz, int after, char *name)
+static struct pane *tile_split(struct pane **pp safe, int horiz, int after,
+ const char *name)
{
/* Create a new pane near the given one, reducing its size,
* and possibly the size of other siblings.
return next_child(ti->p, NULL, 1);
}
-static struct tileinfo *safe tile_next_named(struct tileinfo *ti safe, char *name)
+static struct tileinfo *safe tile_next_named(struct tileinfo *ti safe,
+ const char *name)
{
struct tileinfo *t = ti;
while ((t = list_next_entry(t, tiles)) != ti) {
};
void buf_init(struct buf *b safe);
-void buf_concat(struct buf *b safe, char *s safe);
-void buf_concat_len(struct buf *b safe, char *s safe, int l);
+void buf_concat(struct buf *b safe, const char *s safe);
+void buf_concat_len(struct buf *b safe, const char *s safe, int l);
void buf_append(struct buf *b safe, wchar_t wch);
void buf_append_byte(struct buf *b safe, char c);
static inline char *safe buf_final(struct buf *b safe)
};
void time_start(enum timetype);
void time_stop(enum timetype);
-void time_start_key(char *key safe);
-void time_stop_key(char *key safe);
+void time_start_key(const char *key safe);
+void time_stop_key(const char *key safe);
void stat_count(char *name safe);
#include "core.h"
static struct map *emacs_map;
-static char * safe file_normalize(struct pane *p safe, char *path,
- char *initial_path);
+static const char * safe file_normalize(struct pane *p safe, const char *path,
+ const char *initial_path);
/* num2 is used to track if successive commands are related.
* Only low 16 bits identify command, other bits are free.
DEF_CMD(emacs_insert)
{
int ret;
- char *str;
+ const char *str;
if (!ci->mark)
return Enoarg;
{
int ret;
char buf[2] = ".";
- char *str = buf;
+ const char *str = buf;
if (!ci->mark)
return Enoarg;
key_add(fh_map, "M-Chr-n", &find_prevnext);
}
-static char * safe file_normalize(struct pane *p safe, char *path, char *initial_path)
+static const char * safe file_normalize(struct pane *p safe,
+ const char *path,
+ const char *initial_path)
{
int len = strlen(initial_path?:"");
char *dir;
{
int fd;
struct pane *p, *par;
- char *path;
+ const char *path;
char buf[PATH_MAX];
char *e;
* Find a document for the directory and attach as a completing
* popup menu
*/
- char *str;
- char *d, *b;
+ const char *str;
+ const char *d, *b;
int fd;
struct pane *pop, *docp, *p;
struct call_return cr;
DEF_CMD(emacs_num)
{
int rpt = ci->num;
- char *last = ci->key + strlen(ci->key)-1;
+ const char *last = ci->key + strlen(ci->key)-1;
int neg = 0;
if (rpt < 0) {
DEF_CMD(attach_file_entry)
{
- pane_register(ci->focus, 0, &find_handle.c, ci->str ?: "shellcmd");
+ pane_register(ci->focus, 0, &find_handle.c,
+ (void*) ci->str ?: "shellcmd");
return 1;
}
struct command c;
int keep, plen, cmp;
int prefix_only;
- char *prefix safe, *str;
+ const char *prefix safe, *str;
};
-static char *add_highlight_prefix(char *orig, int start, int plen, char *attr safe)
+static const char *add_highlight_prefix(const char *orig, int start, int plen,
+ const char *attr safe)
{
struct buf ret;
- char *c safe;
+ const char *c safe;
if (orig == NULL)
return orig;
DEF_CMD(save_highlighted)
{
struct rlcb *cb = container_of(ci->comm, struct rlcb, c);
- char *start;
+ const char *start;
if (!ci->str)
return 1;
return 0;
ret = comm_call(ci->comm2, "callback:render", ci->focus, 0, NULL, cb.str);
- free(cb.str);
+ free((void*)cb.str);
if (ci->num != NO_NUMERIC)
/* Was rendering to find a cursor, don't need to skip */
return ret;
return 1;
}
-static int do_render_complete_prev(struct complete_data *cd safe, struct mark *m safe,
- struct pane *focus safe, int n, char **savestr)
+static int do_render_complete_prev(struct complete_data *cd safe,
+ struct mark *m safe,
+ struct pane *focus safe, int n,
+ const char **savestr)
{
/* If 'n' is 0 we just need 'start of line' so use
* underlying function.
return 1;
}
-static int common_len(char *a safe, char *b safe)
+static int common_len(const char *a safe, const char *b safe)
{
int len = 0;
while (*a && *a == *b) {
return len;
}
-static void adjust_pre(char *common safe, char *new safe, int len)
+static void adjust_pre(char *common safe, const char *new safe, int len)
{
int l = strlen(common);
int newlen = 0;
struct complete_data *cd = p->data;
struct mark *m;
struct mark *m2 = NULL;
- char *c;
+ const char *c;
int cnt = 0;
char *common = NULL;
char *common_pre = NULL;
while (do_render_complete_prev(cd, m, p->parent, 1, &c) > 0 && c) {
int l;
- char *match = c;
+ const char *match = c;
if (!cd->prefix_only)
match = strstr(match, cd->prefix);
if (!match)
}
struct parse_state {
- char *patn safe;
+ const char *patn safe;
unsigned short *rxl;
int next;
unsigned short *sets;
return;
}
-static int is_set_element(char *p safe)
+static int is_set_element(const char *p safe)
{
int i;
if (*p != '[')
static int do_parse_set(struct parse_state *st safe, int plane)
{
mbstate_t ps = {};
- char *p safe = st->patn;
+ const char *p safe = st->patn;
wchar_t ch;
int newplane = 0xFFFFFF;
int planes = 0;
return -1;
case ':': /* character class */
{
- char *e, *cls;
+ const char *e;
+ char *cls;
wctype_t wct;
p += 2;
e = strchr(p, ':');
static int parse_set(struct parse_state *st safe)
{
int plane;
- char *patn;
+ const char *patn;
int set;
if (*st->patn++ != '[')
return 1;
}
-static int cvt_hex(char *s safe, int len)
+static int cvt_hex(const char *s safe, int len)
{
long rv = 0;
while (len) {
return 1;
}
-unsigned short *rxl_parse(char *patn safe, int *lenp, int nocase)
+unsigned short *rxl_parse(const char *patn safe, int *lenp, int nocase)
{
struct parse_state st;
st.patn = patn;
return st.rxl;
}
-unsigned short *safe rxl_parse_verbatim(char *patn safe, int nocase)
+unsigned short *safe rxl_parse_verbatim(const char *patn safe, int nocase)
{
struct parse_state st;
int i, l;
* May be distributed under terms of GPLv2 - see file:COPYING
*/
struct match_state;
-unsigned short *rxl_parse(char *patn safe, int *lenp, int nocase);
-unsigned short *safe rxl_parse_verbatim(char *patn safe, int nocase);
+unsigned short *rxl_parse(const char *patn safe, int *lenp, int nocase);
+unsigned short *safe rxl_parse_verbatim(const char *patn safe, int nocase);
struct match_state *safe rxl_prepare(unsigned short *rxl safe,
int anchored, int *lenp);
void rxl_free_state(struct match_state *s safe);
git / edlib.git / commitdiff