![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dict.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / kernel|
Return to dict.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / kernel |
1.1 root 1: /*
2: * tag: dict management
3: *
4: * Copyright (C) 2003-2005 Stefan Reinauer, Patrick Mauritz
5: *
6: * See the file "COPYING" for further information about
7: * the copyright and warranty status of this work.
8: */
9:
10: #include "config.h"
11: #include "kernel/kernel.h"
12: #include "dict.h"
13: #ifdef BOOTSTRAP
14: #include <string.h>
15: #else
16: #include "libc/string.h"
17: #endif
18: #include "cross.h"
19:
20:
21: unsigned char *dict = NULL;
22: ucell *last;
23: cell dicthead = 0;
24: cell dictlimit = 0;
25:
26: /* lfa2nfa
27: * converts a link field address to a name field address,
28: * i.e find pointer to a given words name
29: */
30:
31: ucell lfa2nfa(ucell ilfa)
32: {
33: /* get offset from dictionary start */
34: ilfa = ilfa - (ucell)pointer2cell(dict);
35: ilfa--; /* skip status */
36: while (dict[--ilfa] == 0); /* skip all pad bytes */
37: ilfa -= (dict[ilfa] - 128);
38: return ilfa + (ucell)pointer2cell(dict);
39: }
40:
41: /* lfa2cfa
42: * converts a link field address to a code field address.
43: * in this forth implementation this is just a fixed offset
44: */
45:
46: static xt_t lfa2cfa(ucell ilfa)
47: {
48: return (xt_t)(ilfa + sizeof(cell));
49: }
50:
51:
52: /* fstrlen - returns length of a forth string. */
53:
54: ucell fstrlen(ucell fstr)
55: {
56: fstr -= pointer2cell(dict)+1;
57: //fstr -= pointer2cell(dict); FIXME
58: while (dict[++fstr] < 128)
59: ;
60: return dict[fstr] - 128;
61: }
62:
63: /* to_lower - convert a character to lowecase */
64:
65: static int to_lower(int c)
66: {
67: return ((c >= 'A') && (c <= 'Z')) ? (c - 'A' + 'a') : c;
68: }
69:
70: /* fstrcmp - compare null terminated string with forth string. */
71:
72: static int fstrcmp(const char *s1, ucell fstr)
73: {
74: char *s2 = (char*)cell2pointer(fstr);
75: while (*s1) {
76: if ( to_lower(*(s1++)) != to_lower(*(s2++)) )
77: return -1;
78: }
79: return 0;
80: }
81:
82: /* fstrncpy - copy a forth string to a destination (with NULL termination) */
83:
84: void fstrncpy(char *dest, ucell src, unsigned int maxlen)
85: {
86: int len = fstrlen(src);
87:
88: if (fstrlen(src) >= maxlen) len = maxlen - 1;
89: memcpy(dest, cell2pointer(src), len);
90: *(dest + len) = '\0';
91: }
92:
93:
94: /* findword
95: * looks up a given word in the dictionary. This function
96: * is used by the c based interpreter and to find the "initialize"
97: * word.
98: */
99:
100: xt_t findword(const char *s1)
101: {
102: ucell tmplfa, len;
103:
104: if (!last)
105: return 0;
106:
107: tmplfa = read_ucell(last);
108:
109: len = strlen(s1);
110:
111: while (tmplfa) {
112: ucell nfa = lfa2nfa(tmplfa);
113:
114: if (len == fstrlen(nfa) && !fstrcmp(s1, nfa)) {
115: return lfa2cfa(tmplfa);
116: }
117:
118: tmplfa = read_ucell(cell2pointer(tmplfa));
119: }
120:
121: return 0;
122: }
123:
124:
125: /* findsemis_wordlist
126: * Given a DOCOL xt and a wordlist, find the address of the semis
127: * word at the end of the word definition. We do this by finding
128: * the word before this in the dictionary, then counting back one
129: * from the NFA.
130: */
131:
132: static ucell findsemis_wordlist(ucell xt, ucell wordlist)
133: {
134: ucell tmplfa, nextlfa, nextcfa;
135:
136: if (!wordlist)
137: return 0;
138:
139: tmplfa = read_ucell(cell2pointer(wordlist));
140: nextcfa = lfa2cfa(tmplfa);
141:
142: /* Catch the special case where the lfa of the word we
143: * want is the last word in the dictionary; in that case
144: * the end of the word is given by "here" - 1 */
145: if (nextcfa == xt)
146: return pointer2cell(dict) + dicthead - sizeof(cell);
147:
148: while (tmplfa) {
149:
150: /* Peek ahead and see if the next CFA in the list is the
151: * one we are searching for */
152: nextlfa = read_ucell(cell2pointer(tmplfa));
153: nextcfa = lfa2cfa(nextlfa);
154:
155: /* If so, count back 1 cell from the current NFA */
156: if (nextcfa == xt)
157: return lfa2nfa(tmplfa) - sizeof(cell);
158:
159: tmplfa = nextlfa;
160: }
161:
162: return 0;
163: }
164:
165:
166: /* findsemis
167: * Given a DOCOL xt, find the address of the semis word at the end
168: * of the word definition by searching all vocabularies */
169:
170: ucell findsemis(ucell xt)
171: {
172: ucell usesvocab = findword("vocabularies?") + sizeof(cell);
173: unsigned int i;
174:
175: if (read_ucell(cell2pointer(usesvocab))) {
176: /* Vocabularies are in use, so search each one in turn */
177: ucell numvocabs = findword("#order") + sizeof(cell);
178:
179: for (i = 0; i < read_ucell(cell2pointer(numvocabs)); i++) {
180: ucell vocabs = findword("vocabularies") + 2 * sizeof(cell);
181: ucell semis = findsemis_wordlist(xt, read_cell(cell2pointer(vocabs + (i * sizeof(cell)))));
182:
183: /* If we get a non-zero result, we found the xt in this vocab */
184: if (semis)
185: return semis;
186: }
187: } else {
188: /* Vocabularies not in use */
189: return findsemis_wordlist(xt, read_ucell(last));
190: }
191:
192: return 0;
193: }
194:
195:
196: /* findxtfromcell_wordlist
197: * Given a cell and a wordlist, determine the CFA of the word containing
198: * the cell or 0 if we are unable to return a suitable CFA
199: */
200:
201: ucell findxtfromcell_wordlist(ucell incell, ucell wordlist)
202: {
203: ucell tmplfa;
204:
205: if (!wordlist)
206: return 0;
207:
208: tmplfa = read_ucell(cell2pointer(wordlist));
209: while (tmplfa) {
210: if (tmplfa < incell)
211: return lfa2cfa(tmplfa);
212:
213: tmplfa = read_ucell(cell2pointer(tmplfa));
214: }
215:
216: return 0;
217: }
218:
219:
220: /* findxtfromcell
221: * Given a cell, determine the CFA of the word containing
222: * the cell by searching all vocabularies
223: */
224:
225: ucell findxtfromcell(ucell incell)
226: {
227: ucell usesvocab = findword("vocabularies?") + sizeof(cell);
228: unsigned int i;
229:
230: if (read_ucell(cell2pointer(usesvocab))) {
231: /* Vocabularies are in use, so search each one in turn */
232: ucell numvocabs = findword("#order") + sizeof(cell);
233:
234: for (i = 0; i < read_ucell(cell2pointer(numvocabs)); i++) {
235: ucell vocabs = findword("vocabularies") + 2 * sizeof(cell);
236: ucell semis = findxtfromcell_wordlist(incell, read_cell(cell2pointer(vocabs + (i * sizeof(cell)))));
237:
238: /* If we get a non-zero result, we found the xt in this vocab */
239: if (semis)
240: return semis;
241: }
242: } else {
243: /* Vocabularies not in use */
244: return findxtfromcell_wordlist(incell, read_ucell(last));
245: }
246:
247: return 0;
248: }
249:
250: void dump_header(dictionary_header_t *header)
251: {
252: printk("OpenBIOS dictionary:\n");
253: printk(" version: %d\n", header->version);
254: printk(" cellsize: %d\n", header->cellsize);
255: printk(" endianess: %s\n", header->endianess?"big":"little");
256: printk(" compression: %s\n", header->compression?"yes":"no");
257: printk(" relocation: %s\n", header->relocation?"yes":"no");
258: printk(" checksum: %08x\n", target_long(header->checksum));
259: printk(" length: %08x\n", target_long(header->length));
260: printk(" last: %0" FMT_CELL_x "\n", target_cell(header->last));
261: }
262:
263: ucell load_dictionary(const char *data, ucell len)
264: {
265: u32 checksum=0;
266: const char *checksum_walk;
267: ucell *walk, *reloc_table;
268: dictionary_header_t *header=(dictionary_header_t *)data;
269:
270: /* assertions */
271: if (len <= (sizeof(dictionary_header_t)) || strncmp(DICTID, data, 8))
272: return 0;
273: #ifdef CONFIG_DEBUG_DICTIONARY
274: dump_header(header);
275: #endif
276:
277: checksum_walk=data;
278: while (checksum_walk<data+len) {
279: checksum+=read_long(checksum_walk);
280: checksum_walk+=sizeof(u32);
281: }
282:
283: if(checksum) {
284: printk("Checksum invalid (%08x)!\n", checksum);
285: return 0;
286: }
287:
288: data += sizeof(dictionary_header_t);
289:
290: dicthead = target_long(header->length);
291:
292: memcpy(dict, data, dicthead);
293: reloc_table=(ucell *)(data+dicthead);
294:
295: #ifdef CONFIG_DEBUG_DICTIONARY
296: printk("\nmoving dictionary (%x bytes) to %x\n",
297: (ucell)dicthead, (ucell)dict);
298: printk("\ndynamic relocation...");
299: #endif
300:
301: for (walk = (ucell *) dict; walk < (ucell *) (dict + dicthead);
302: walk++) {
303: int pos, bit, l;
304: l=(walk-(ucell *)dict);
305: pos=l/BITS;
306: bit=l&~(-BITS);
307: if (reloc_table[pos] & target_ucell((ucell)1ULL << bit)) {
308: // printk("%lx, pos %x, bit %d\n",*walk, pos, bit);
309: write_ucell(walk, read_ucell(walk)+pointer2cell(dict));
310: }
311: }
312:
313: #ifdef CONFIG_DEBUG_DICTIONARY
314: printk(" done.\n");
315: #endif
316:
317: last = (ucell *)(dict + target_ucell(header->last));
318:
319: return -1;
320: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.