1 #include "a.h"
2 
3 void*
4 emalloc(uint n)
5 {
6 	void *v;
7 
8 	v = mallocz(n, 1);
9 	if(v == nil)
10 		sysfatal("out of memory");
11 	return v;
12 }
13 
14 char*
15 estrdup(char *s)
16 {
17 	char *t;
18 
19 	t = strdup(s);
20 	if(t == nil)
21 		sysfatal("out of memory");
22 	return t;
23 }
24 
25 Rune*
26 erunestrdup(Rune *s)
27 {
28 	Rune *t;
29 
30 	t = emalloc(sizeof(Rune)*(runestrlen(s)+1));
31 	if(t == nil)
32 		sysfatal("out of memory");
33 	runestrcpy(t, s);
34 	return t;
35 }
36 
37 void*
38 erealloc(void *ov, uint n)
39 {
40 	void *v;
41 
42 	v = realloc(ov, n);
43 	if(v == nil)
44 		sysfatal("out of memory");
45 	return v;
46 }
47 
48 Rune*
49 erunesmprint(char *fmt, ...)
50 {
51 	Rune *s;
52 	va_list arg;
53 
54 	va_start(arg, fmt);
55 	s = runevsmprint(fmt, arg);
56 	va_end(arg);
57 	if(s == nil)
58 		sysfatal("out of memory");
59 	return s;
60 }
61 
62 char*
63 esmprint(char *fmt, ...)
64 {
65 	char *s;
66 	va_list arg;
67 
68 	va_start(arg, fmt);
69 	s = vsmprint(fmt, arg);
70 	va_end(arg);
71 	if(s == nil)
72 		sysfatal("out of memory");
73 	return s;
74 }
75 
76 void
77 warn(char *fmt, ...)
78 {
79 	va_list arg;
80 
81 	fprint(2, "htmlroff: %L: ");
82 	va_start(arg, fmt);
83 	vfprint(2, fmt, arg);
84 	va_end(arg);
85 	fprint(2, "\n");
86 }
87 
88 /*
89  * For non-Unicode compilers, so we can say
90  * L("asdf") and get a Rune string.  Assumes strings
91  * are identified by their pointers, so no mutable strings!
92  */
93 typedef struct Lhash Lhash;
94 struct Lhash
95 {
96 	char *s;
97 	Lhash *next;
98 	Rune r[1];
99 };
100 static Lhash *hash[1127];
101 
102 Rune*
103 L(char *s)
104 {
105 	Rune *p;
106 	Lhash *l;
107 	uint h;
108 
109 	h = (uintptr)s%nelem(hash);
110 	for(l=hash[h]; l; l=l->next)
111 		if(l->s == s)
112 			return l->r;
113 	l = emalloc(sizeof *l+(utflen(s)+1)*sizeof(Rune));
114 	p = l->r;
115 	l->s = s;
116 	while(*s)
117 		s += chartorune(p++, s);
118 	*p = 0;
119 	l->next = hash[h];
120 	hash[h] = l;
121 	return l->r;
122 }