![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / f2c|
Return to mem.c CVS log | Up to [Research Unix] / researchv10no / cmd / f2c |
1.1 root 1: /****************************************************************
2: Copyright 1990, 1991 by AT&T Bell Laboratories and Bellcore.
3:
4: Permission to use, copy, modify, and distribute this software
5: and its documentation for any purpose and without fee is hereby
6: granted, provided that the above copyright notice appear in all
7: copies and that both that the copyright notice and this
8: permission notice and warranty disclaimer appear in supporting
9: documentation, and that the names of AT&T Bell Laboratories or
10: Bellcore or any of their entities not be used in advertising or
11: publicity pertaining to distribution of the software without
12: specific, written prior permission.
13:
14: AT&T and Bellcore disclaim all warranties with regard to this
15: software, including all implied warranties of merchantability
16: and fitness. In no event shall AT&T or Bellcore be liable for
17: any special, indirect or consequential damages or any damages
18: whatsoever resulting from loss of use, data or profits, whether
19: in an action of contract, negligence or other tortious action,
20: arising out of or in connection with the use or performance of
21: this software.
22: ****************************************************************/
23:
24: #include "defs.h"
25: #include "iob.h"
26:
27: #define MEMBSIZE 32000
28: #define GMEMBSIZE 16000
29:
30: extern void exit();
31:
32: char *
33: gmem(n, round)
34: int n, round;
35: {
36: static char *last, *next;
37: char *rv;
38: if (round)
39: #ifdef CRAY
40: if ((long)next & 0xe000000000000000)
41: next = (char *)(((long)next & 0x1fffffffffffffff) + 1);
42: #else
43: #ifdef MSDOS
44: if ((int)next & 1)
45: next++;
46: #else
47: next = (char *)(((long)next + sizeof(char *)-1)
48: & ~((long)sizeof(char *)-1));
49: #endif
50: #endif
51: rv = next;
52: if ((next += n) > last) {
53: rv = Alloc(n + GMEMBSIZE);
54:
55: next = rv + n;
56: last = next + GMEMBSIZE;
57: }
58: return rv;
59: }
60:
61: struct memblock {
62: struct memblock *next;
63: char buf[MEMBSIZE];
64: };
65: typedef struct memblock memblock;
66:
67: static memblock *mem0;
68: memblock *curmemblock, *firstmemblock;
69:
70: char *mem_first, *mem_next, *mem_last, *mem0_last;
71:
72: void
73: mem_init()
74: {
75: curmemblock = firstmemblock = mem0
76: = (memblock *)Alloc(sizeof(memblock));
77: mem_first = mem0->buf;
78: mem_next = mem0->buf;
79: mem_last = mem0->buf + MEMBSIZE;
80: mem0_last = mem0->buf + MEMBSIZE;
81: mem0->next = 0;
82: }
83:
84: char *
85: mem(n, round)
86: int n, round;
87: {
88: memblock *b;
89: register char *rv, *s;
90:
91: if (round)
92: #ifdef CRAY
93: if ((long)mem_next & 0xe000000000000000)
94: mem_next = (char *)(((long)mem_next & 0x1fffffffffffffff) + 1);
95: #else
96: #ifdef MSDOS
97: if ((int)mem_next & 1)
98: mem_next++;
99: #else
100: mem_next = (char *)(((long)mem_next + sizeof(char *)-1)
101: & ~((long)sizeof(char *)-1));
102: #endif
103: #endif
104: rv = mem_next;
105: s = rv + n;
106: if (s >= mem_last) {
107: if (n > MEMBSIZE) {
108: fprintf(stderr, "mem(%d) failure!\n", n);
109: exit(1);
110: }
111: if (!(b = curmemblock->next)) {
112: b = (memblock *)Alloc(sizeof(memblock));
113: curmemblock->next = b;
114: b->next = 0;
115: }
116: curmemblock = b;
117: rv = b->buf;
118: mem_last = rv + sizeof(b->buf);
119: s = rv + n;
120: }
121: mem_next = s;
122: return rv;
123: }
124:
125: char *
126: tostring(s,n)
127: register char *s;
128: int n;
129: {
130: register char *s1, *se, **sf;
131: char *rv, *s0;
132: register int k = n + 2, t;
133:
134: sf = str_fmt;
135: sf['%'] = "%";
136: s0 = s;
137: se = s + n;
138: for(; s < se; s++) {
139: t = *(unsigned char *)s;
140: s1 = sf[t];
141: while(*++s1)
142: k++;
143: }
144: sf['%'] = "%%";
145: rv = s1 = mem(k,0);
146: *s1++ = '"';
147: for(s = s0; s < se; s++) {
148: t = *(unsigned char *)s;
149: sprintf(s1, sf[t], t);
150: s1 += strlen(s1);
151: }
152: *s1 = 0;
153: return rv;
154: }
155:
156: char *
157: cpstring(s)
158: register char *s;
159: {
160: return strcpy(mem(strlen(s)+1,0), s);
161: }
162:
163: void
164: new_iob_data(ios, name)
165: register io_setup *ios;
166: char *name;
167: {
168: register iob_data *iod;
169: register char **s, **se;
170:
171: iod = (iob_data *)
172: mem(sizeof(iob_data) + ios->nelt*sizeof(char *), 1);
173: iod->next = iob_list;
174: iob_list = iod;
175: iod->type = ios->fields[0];
176: iod->name = cpstring(name);
177: s = iod->fields;
178: se = s + ios->nelt;
179: while(s < se)
180: *s++ = "0";
181: *s = 0;
182: }
183:
184: char *
185: string_num(pfx, n)
186: char *pfx;
187: long n;
188: {
189: char buf[32];
190: sprintf(buf, "%s%ld", pfx, n);
191: /* can't trust return type of sprintf -- BSD gets it wrong */
192: return strcpy(mem(strlen(buf)+1,0), buf);
193: }
194:
195: static defines *define_list;
196:
197: void
198: def_start(outfile, s1, s2, post)
199: FILE *outfile;
200: char *s1, *s2, *post;
201: {
202: defines *d;
203: int n, n1;
204: extern int in_define;
205:
206: n = n1 = strlen(s1);
207: if (s2)
208: n += strlen(s2);
209: d = (defines *)mem(sizeof(defines)+n, 1);
210: d->next = define_list;
211: define_list = d;
212: strcpy(d->defname, s1);
213: if (s2)
214: strcpy(d->defname + n1, s2);
215: in_define = 1;
216: nice_printf(outfile, "#define %s", d->defname);
217: if (post)
218: nice_printf(outfile, " %s", post);
219: }
220:
221: void
222: other_undefs(outfile)
223: FILE *outfile;
224: {
225: defines *d;
226: if (d = define_list) {
227: define_list = 0;
228: nice_printf(outfile, "\n");
229: do
230: nice_printf(outfile, "#undef %s\n", d->defname);
231: while(d = d->next);
232: nice_printf(outfile, "\n");
233: }
234: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.