![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtune.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / bin / src|
Return to mtune.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / bin / src |
1.1 root 1: /*
2: *-IMPORTS:
3: * <sys/compat.h>
4: * CONST
5: * LOCAL
6: * USE_PROTO
7: * ARGS ()
8: * <stdlib.h>
9: * NULL
10: * malloc ()
11: * free ()
12: */
13:
14: #include <sys/compat.h>
15: #include <stdlib.h>
16:
17: #include "ehand.h"
18: #include "symbol.h"
19: #include "read.h"
20: #include "input.h"
21:
22: #include "mtune.h"
23:
24: LOCAL mtune_t * _mtunes;
25:
26:
27: /*
28: * Locate a parameter definition by symbol.
29: */
30:
31: #if USE_PROTO
32: mtune_t * (find_mtune) (symbol_t * sym)
33: #else
34: mtune_t *
35: find_mtune ARGS ((sym))
36: symbol_t * sym;
37: #endif
38: {
39: mtune_t * scan;
40:
41: for (scan = _mtunes ; scan != NULL ; scan = scan->mt_next) {
42:
43: if (scan->mt_name == sym)
44: return scan;
45: }
46:
47: return NULL;
48: }
49:
50:
51: /*
52: * Regenerate an 'mtune' line from the stored record.
53: */
54:
55: #if USE_PROTO
56: void (write_mtune) (mtune_t * mtunep, input_t * input)
57: #else
58: void
59: write_mtune ARGS ((mtunep, input))
60: mtune_t * mtunep;
61: input_t * input;
62: #endif
63: {
64: if ((* input->in_filter) (input, "%s<2>%ld<3>%ld<4>%ld\n",
65: mtunep->mt_name->s_data, mtunep->mt_min,
66: mtunep->mt_default, mtunep->mt_max) < 0) {
67:
68: throw_error ("Output error");
69: }
70: }
71:
72:
73: /*
74: * Read lines from an "mtune" file.
75: */
76:
77: #if USE_PROTO
78: LOCAL mtune_t * (read_mtune) (input_t * input, lex_t * lexp, int * end_char)
79: #else
80: LOCAL mtune_t *
81: read_mtune ARGS ((input, lexp, end_char))
82: input_t * input;
83: lex_t * lexp;
84: int * end_char;
85: #endif
86: {
87: VOLATILE int ch = '\n';
88: mtune_t * VOLATILE mtunep;
89: ehand_t err;
90:
91: if ((mtunep = (mtune_t *) malloc (sizeof (* mtunep))) == NULL)
92: throw_error ("out of memory in read_mtune ()");
93:
94: if (PUSH_HANDLER (err) == 0) {
95: /*
96: * If the first thing on the line works out to be an EOF,
97: * then bail out without an error.
98: */
99:
100: ch = read_symbol (input, lexp, & mtunep->mt_name);
101:
102: if (mtunep->mt_name == NULL) {
103: /*
104: * We allow an EOF at the beginning of a line and we
105: * also allow a blank line.
106: */
107:
108: free (mtunep);
109: mtunep = NULL;
110: goto at_eof;
111: }
112: check_not_eol (ch);
113:
114: if (mtunep->mt_name->s_size > MAX_PARAMNAME)
115: throw_error ("parameter name must be <= %d characters",
116: MAX_PARAMNAME);
117:
118: /*
119: * Pull in the parameter values
120: */
121:
122: ch = read_longs (input, lexp, & mtunep->mt_min, NO_RANGE);
123: check_not_eol (ch);
124:
125: ch = read_longs (input, lexp, & mtunep->mt_default, NO_RANGE);
126: check_not_eol (ch);
127:
128: ch = read_longs (input, lexp, & mtunep->mt_max, NO_RANGE);
129: ch = expect_eol (input, lexp, ch);
130:
131: mtunep->mt_stune = NULL;
132: } else {
133:
134: free (mtunep);
135: CHAIN_ERROR (err);
136: }
137:
138: at_eof:
139: POP_HANDLER (err);
140:
141: * end_char = ch;
142: return mtunep;
143: }
144:
145:
146: /*
147: * This function is passed as a parameter to read_dev_string () to read an
148: * 'mtune' entry (usually a program argument) and hook it into a global list.
149: */
150:
151: #if USE_PROTO
152: LOCAL int _read_mtune_string (input_t * input, lex_t * lexp,
153: mtune_t ** mtlistp)
154: #else
155: LOCAL int
156: _read_mtune_string (input, lexp, mtlistp)
157: input_t * input;
158: lex_t * lexp;
159: mtune_t ** mtlistp;
160: #endif
161: {
162: mtune_t * mtunep;
163: int ch;
164:
165: if ((mtunep = read_mtune (input, lexp, & ch)) != NULL) {
166: mtunep->mt_next = * mtlistp;
167: * mtlistp = mtunep;
168: }
169:
170: return ch;
171: }
172:
173:
174: /*
175: * This function is used by _read_mtune_file () to link an mtune entry into
176: * the global lists and check it.
177: */
178:
179: #if USE_PROTO
180: LOCAL void (link_mtune) (mtune_t * mtunep, input_t * input)
181: #else
182: LOCAL void
183: link_mtune ARGS ((mtunep, input))
184: mtune_t * mtunep;
185: input_t * input;
186: #endif
187: {
188: if (find_mtune (mtunep->mt_name) != NULL)
189: throw_error ("tunable parameter name must be unique");
190:
191: mtunep->mt_next = _mtunes;
192: _mtunes = mtunep;
193:
194: write_mtune (mtunep, input);
195: }
196:
197:
198: /*
199: * This function is passed as a parameter to read_dev_file () to read an
200: * 'mtune' entry and link it in to the global list.
201: */
202:
203: #if USE_PROTO
204: LOCAL int _read_mtune_file (input_t * input, lex_t * lexp,
205: mtune_t ** changes)
206: #else
207: LOCAL int
208: _read_mtune_file (input, lexp, changes)
209: input_t * input;
210: lex_t * lexp;
211: mtune_t ** changes;
212: #endif
213: {
214: mtune_t * mtunep;
215: int ch;
216:
217: if ((mtunep = read_mtune (input, lexp, & ch)) == NULL) {
218: if (ch == READ_EOF) {
219: /*
220: * Blow remaining changes out as new entries
221: */
222:
223: while ((mtunep = * changes) != NULL) {
224: * changes = mtunep->mt_next;
225: link_mtune (mtunep, input);
226: }
227: }
228: return ch;
229: }
230:
231:
232: /*
233: * Link in the newly-read entry.
234: */
235:
236: if (changes) {
237: mtune_t ** scan;
238:
239: for (scan = changes ; * scan != NULL ;
240: scan = & (* scan)->mt_next) {
241:
242: if ((* scan)->mt_name == mtunep->mt_name) {
243: /*
244: * Our current entry is being replaced by a
245: * new one; unlink the new entry from the
246: * change list and discard the old entry.
247: */
248:
249: free (mtunep);
250:
251: if (report_mode ())
252: return ch;
253:
254: mtunep = * scan;
255: * scan = mtunep->mt_next;
256: break;
257: }
258: }
259: }
260:
261: link_mtune (mtunep, input);
262: return ch;
263: }
264:
265:
266: /*
267: * Return the head of the list of all tuneable parameters.
268: */
269:
270: #if USE_PROTO
271: mtune_t * (mtunes) (void)
272: #else
273: mtune_t *
274: mtunes ARGS (())
275: #endif
276: {
277: return _mtunes;
278: }
279:
280:
281: /*
282: * Read in an "mtune" entry from a string and add it to a list.
283: */
284:
285: #if USE_PROTO
286: void read_mtune_string (CONST char * string, VOID * extra)
287: #else
288: void
289: read_mtune_string (string, extra)
290: CONST char * string;
291: VOID * extra;
292: #endif
293: {
294: read_dev_string (string, (dev_func_p) _read_mtune_string, extra);
295: }
296:
297:
298: /*
299: * Suck in a complete 'mtune' file.
300: */
301:
302: #if USE_PROTO
303: void (read_mtune_file) (CONST char * inname, CONST char * outname,
304: VOID * extra)
305: #else
306: void
307: read_mtune_file ARGS ((inname, outname, extra))
308: CONST char * inname;
309: CONST char * outname;
310: VOID * extra;
311: #endif
312: {
313: read_dev_file (inname, outname, (dev_func_p) _read_mtune_file, extra);
314: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.