Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Modules/i386/libsaio/aml_generator.c

1/*␊
2 * aml_generator.c␊
3 * Chameleon␊
4 *␊
5 * Created by Mozodojo on 20/07/10.␊
6 * Copyright 2010 mozo. All rights reserved.␊
7 *␊
8 */␊
9␊
10#include "aml_generator.h"␊
11␊
12bool aml_add_to_parent(struct aml_chunk* parent, struct aml_chunk* node)␊
13{␊
14␉if (parent && node)␊
15␉{␊
16␉␉switch (parent->Type) ␊
17␉␉{␊
18␉␉␉case AML_CHUNK_NONE:␊
19␉␉␉case AML_CHUNK_BYTE:␊
20␉␉␉case AML_CHUNK_WORD:␊
21␉␉␉case AML_CHUNK_DWORD:␊
22␉␉␉case AML_CHUNK_QWORD:␊
23␉␉␉case AML_CHUNK_ALIAS:␊
24␉␉␉␉verbose("aml_add_to_parent: Node doesn't support child nodes!\n");␊
25␉␉␉␉return false;␊
26␉␉␉case AML_CHUNK_NAME:␊
27␉␉␉␉if (parent->First) ␊
28␉␉␉␉{␊
29␉␉␉␉␉verbose("aml_add_to_parent: Name node supports only one child node!\n");␊
30␉␉␉␉␉return false;␊
31␉␉␉␉}␊
32␉␉␉␉break;␊
33␊
34␉␉␉default:␊
35␉␉␉␉break;␊
36␉␉}␊
37␉␉␊
38␉␉if (!parent->First)␊
39␉␉␉parent->First = node;␊
40␉␉␊
41␉␉if (parent->Last)␊
42␉␉␉parent->Last->Next = node;␊
43␉␉␊
44␉␉parent->Last = node;␊
45␉␉␊
46␉␉return true;␊
47␉}␊
48␉␊
49␉return false;␊
50}␊
51␊
52struct aml_chunk* aml_create_node(struct aml_chunk* parent)␊
53{␊
54␉struct aml_chunk* node = (struct aml_chunk*)malloc(sizeof(struct aml_chunk));␊
55␉␊
56␉aml_add_to_parent(parent, node);␊
57␉␊
58␉return node;␊
59}␊
60␊
61void aml_destroy_node(struct aml_chunk* node)␊
62{␊
63␉// Delete child nodes␊
64␉struct aml_chunk* child = node->First;␊
65␉␊
66␉while (child) ␊
67␉{␊
68␉␉struct aml_chunk* next = child->Next;␊
69␉␉␊
70␉␉if (child->Buffer)␊
71␉␉␉free(child->Buffer);␊
72␉␉␊
73␉␉free(child);␊
74␉␉␊
75␉␉child = next;␊
76␉}␊
77␉␊
78␉// Free node␊
79␉if (node->Buffer)␊
80␉␉free(node->Buffer);␊
81␉␊
82␉free(node);␊
83}␊
84␊
85struct aml_chunk* aml_add_buffer(struct aml_chunk* parent, const char* buffer, unsigned int size)␊
86{␊
87␉struct aml_chunk* node = aml_create_node(parent);␊
88␉␊
89␉if (node) ␊
90␉{␊
91␉␉node->Type = AML_CHUNK_NONE;␊
92␉␉node->Length = size;␊
93␉␉node->Buffer = malloc(node->Length);␊
94␉␉memcpy(node->Buffer, buffer, node->Length);␊
95␉}␊
96␉␊
97␉return node;␊
98}␊
99␊
100struct aml_chunk* aml_add_byte(struct aml_chunk* parent, unsigned char value)␊
101{␊
102␉struct aml_chunk* node = aml_create_node(parent);␊
103␉␊
104␉if (node) ␊
105␉{␊
106␉␉node->Type = AML_CHUNK_BYTE;␊
107␉␉␊
108␉␉node->Length = 1;␊
109␉␉node->Buffer = malloc(node->Length);␊
110␉␉node->Buffer[0] = value;␊
111␉}␊
112␉␊
113␉return node;␊
114}␊
115␊
116struct aml_chunk* aml_add_word(struct aml_chunk* parent, unsigned int value)␊
117{␊
118␉struct aml_chunk* node = aml_create_node(parent);␊
119␉␊
120␉if (node) ␊
121␉{␊
122␉␉node->Type = AML_CHUNK_WORD;␊
123␉␉node->Length = 2;␊
124␉␉node->Buffer = malloc(node->Length);␊
125␉␉node->Buffer[0] = value & 0xff;␊
126␉␉node->Buffer[1] = value >> 8;␊
127␉}␊
128␉␊
129␉return node;␊
130}␊
131␊
132struct aml_chunk* aml_add_dword(struct aml_chunk* parent, unsigned long value)␊
133{␊
134␉struct aml_chunk* node = aml_create_node(parent);␊
135␉␊
136␉if (node) ␊
137␉{␊
138␉␉node->Type = AML_CHUNK_DWORD;␊
139␉␉node->Length = 4;␊
140␉␉node->Buffer = malloc(node->Length);␊
141␉␉node->Buffer[0] = value & 0xff;␊
142␉␉node->Buffer[1] = (value >> 8) & 0xff;␊
143␉␉node->Buffer[2] = (value >> 16) & 0xff;␊
144␉␉node->Buffer[3] = (value >> 24) & 0xff;␊
145␉}␊
146␉␊
147␉return node;␊
148}␊
149␊
150struct aml_chunk* aml_add_qword(struct aml_chunk* parent, unsigned long long value)␊
151{␊
152␉struct aml_chunk* node = aml_create_node(parent);␊
153␉␊
154␉if (node) ␊
155␉{␊
156␉␉node->Type = AML_CHUNK_QWORD;␊
157␉␉node->Length = 8;␊
158␉␉node->Buffer = malloc(node->Length);␊
159␉␉node->Buffer[0] = value & 0xff;␊
160␉␉node->Buffer[1] = (value >> 8) & 0xff;␊
161␉␉node->Buffer[2] = (value >> 16) & 0xff;␊
162␉␉node->Buffer[3] = (value >> 24) & 0xff;␊
163␉␉node->Buffer[4] = (value >> 32) & 0xff;␊
164␉␉node->Buffer[5] = (value >> 40) & 0xff;␊
165␉␉node->Buffer[6] = (value >> 48) & 0xff;␊
166␉␉node->Buffer[7] = (value >> 56) & 0xff;␊
167␉}␊
168␉␊
169␉return node;␊
170}␊
171␊
172unsigned int aml_fill_simple_name(char* buffer, const char* name)␊
173{␊
174␉if (strlen(name) < 4) ␊
175␉{␊
176␉␉verbose("aml_fill_simple_name: simple name %s has incorrect lengh! Must be 4.\n", name);␊
177␉␉return 0;␊
178␉}␊
179␉␊
180␉memcpy(buffer, name, 4);␊
181␉return 4;␊
182}␊
183␊
184unsigned int aml_fill_name(struct aml_chunk* node, const char* name)␊
185{␊
186␉if (!node) ␊
187␉␉return 0;␊
188␉␊
189␉int len = strlen(name), offset = 0, count = len / 4;␊
190␉␊
191␉if ((len % 4) > 1 || count == 0) ␊
192␉{␊
193␉␉verbose("aml_fill_name: pathname %s has incorrect length! Must be 4, 8, 12, 16, etc...\n", name);␊
194␉␉return 0;␊
195␉}␊
196␉␊
197␉unsigned int root = 0;␊
198␉␊
199␉if ((len % 4) == 1 && name[0] == '\\')␊
200␉␉root++;␊
201␉␉␉␊
202␉if (count == 1) ␊
203␉{␊
204␉␉node->Length = 4 + root;␊
205␉␉node->Buffer = malloc(node->Length);␊
206␉␉memcpy(node->Buffer, name, 4 + root);␊
207␉␉return node->Length;␊
208␉}␊
209␉␊
210␉if (count == 2) ␊
211␉{␊
212␉␉node->Length = 2 + 8;␊
213␉␉node->Buffer = malloc(node->Length);␊
214␉␉node->Buffer[offset++] = 0x5c; // Root Char␊
215␉␉node->Buffer[offset++] = 0x2e; // Double name␊
216␉␉memcpy(node->Buffer+offset, name + root, 8);␊
217␉␉return node->Length;␊
218␉}␊
219␉␊
220␉node->Length = 3 + count*4;␊
221␉node->Buffer = malloc(node->Length);␊
222␉node->Buffer[offset++] = 0x5c; // Root Char␊
223␉node->Buffer[offset++] = 0x2f; // Multi name␊
224␉node->Buffer[offset++] = count; // Names count␊
225␉memcpy(node->Buffer+offset, name + root, count*4);␊
226␉␊
227␉return node->Length;␊
228}␊
229␊
230struct aml_chunk* aml_add_scope(struct aml_chunk* parent, const char* name)␊
231{␊
232␉struct aml_chunk* node = aml_create_node(parent);␊
233␉␊
234␉if (node)␊
235␉{␊
236␉␉node->Type = AML_CHUNK_SCOPE;␊
237␉␉␊
238␉␉aml_fill_name(node, name);␊
239␉}␊
240␉␊
241␉return node;␊
242}␊
243␊
244struct aml_chunk* aml_add_name(struct aml_chunk* parent, const char* name)␊
245{␊
246␉struct aml_chunk* node = aml_create_node(parent);␊
247␉␊
248␉if (node)␊
249␉{␊
250␉␉node->Type = AML_CHUNK_NAME;␊
251␉␉␊
252␉␉aml_fill_name(node, name);␊
253␉}␊
254␉␊
255␉return node;␊
256}␊
257␊
258struct aml_chunk* aml_add_package(struct aml_chunk* parent)␊
259{␊
260␉struct aml_chunk* node = aml_create_node(parent);␊
261␉␊
262␉if (node)␊
263␉{␊
264␉␉node->Type = AML_CHUNK_PACKAGE;␊
265␉␉␊
266␉␉node->Length = 1;␊
267␉␉node->Buffer = malloc(node->Length);␊
268␉}␊
269␉␊
270␉return node;␊
271}␊
272␊
273struct aml_chunk* aml_add_alias(struct aml_chunk* parent, const char* name1, const char* name2)␊
274{␊
275␉struct aml_chunk* node = aml_create_node(parent);␊
276␉␊
277␉if (node)␊
278␉{␊
279␉␉node->Type = AML_CHUNK_ALIAS;␊
280␉␉␊
281␉␉node->Length = 8;␊
282␉␉node->Buffer = malloc(node->Length);␊
283␉␉aml_fill_simple_name(node->Buffer, name1);␊
284␉␉aml_fill_simple_name(node->Buffer+4, name2);␊
285␉}␊
286␉␊
287␉return node;␊
288}␊
289␊
290unsigned char aml_get_size_length(unsigned int size)␊
291{␊
292␉if (size + 1 <= 0x3f)␊
293␉␉return 1;␊
294␉else if (size + 2 <= 0x3fff)␊
295␉␉return 2;␊
296␉else if (size + 3 <= 0x3fffff)␊
297␉␉return 3;␊
298␉␊
299␉return 4;␊
300}␊
301␊
302unsigned int aml_calculate_size(struct aml_chunk* node)␊
303{␊
304␉if (node)␊
305␉{␊
306␉␉node->Size = 0;␊
307␉␉␊
308␉␉// Calculate child nodes size␊
309␉␉struct aml_chunk* child = node->First;␊
310␉␉unsigned char child_count = 0;␊
311␉␉␊
312␉␉while (child) ␊
313␉␉{␊
314␉␉␉child_count++;␊
315␉␉␉␊
316␉␉␉node->Size += aml_calculate_size(child);␊
317␉␉␉␊
318␉␉␉child = child->Next;␊
319␉␉}␊
320␉␉␊
321␉␉switch (node->Type) ␊
322␉␉{␊
323␉␉␉case AML_CHUNK_NONE:␊
324␉␉␉␉node->Size += node->Length;␊
325␉␉␉␉break;␊
326␉␉␉case AML_CHUNK_SCOPE:␊
327␉␉␉␉node->Size += 1 + node->Length;␊
328␉␉␉␉node->Size += aml_get_size_length(node->Size);␊
329␉␉␉␉break;␊
330␉␉␉case AML_CHUNK_PACKAGE:␊
331␉␉␉␉node->Buffer[0] = child_count;␊
332␉␉␉␉node->Size += 1 + node->Length;␊
333␉␉␉␉node->Size += aml_get_size_length(node->Size);␊
334␉␉␉␉break;␊
335␉␉␉␉␊
336␉␉␉case AML_CHUNK_BYTE:␊
337␉␉␉␉if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) ␊
338␉␉␉␉{␊
339␉␉␉␉␉node->Size += node->Length;␊
340␉␉␉␉}␊
341␉␉␉␉else ␊
342␉␉␉␉{␊
343␉␉␉␉␉node->Size += 1 + node->Length;␊
344␉␉␉␉}␊
345␉␉␉␉␊
346␉␉␉␉break;␊
347␉␉␉␉␊
348␉␉␉case AML_CHUNK_WORD:␊
349␉␉␉case AML_CHUNK_DWORD:␊
350␉␉␉case AML_CHUNK_QWORD:␊
351␉␉␉case AML_CHUNK_ALIAS:␊
352␉␉␉case AML_CHUNK_NAME:␊
353␉␉␉␉node->Size += 1 + node->Length;␊
354␉␉␉␉break;␊
355␉␉}␊
356␉␉␊
357␉␉return node->Size;␊
358␉}␊
359␉␊
360␉return 0;␊
361}␊
362␊
363unsigned int aml_write_byte(unsigned char value, char* buffer, unsigned int offset)␊
364{␊
365␉buffer[offset++] = value;␊
366␉␊
367␉return offset;␊
368}␊
369␊
370unsigned int aml_write_word(unsigned int value, char* buffer, unsigned int offset)␊
371{␊
372␉buffer[offset++] = value & 0xff;␊
373␉buffer[offset++] = value >> 8;␊
374␉␊
375␉return offset;␊
376}␊
377␊
378unsigned int aml_write_dword(unsigned long value, char* buffer, unsigned int offset)␊
379{␊
380␉buffer[offset++] = value & 0xff;␊
381␉buffer[offset++] = (value >> 8) & 0xff;␊
382␉buffer[offset++] = (value >> 16) & 0xff;␊
383␉buffer[offset++] = (value >> 24) & 0xff;␊
384␉␊
385␉return offset;␊
386}␊
387␊
388unsigned int aml_write_qword(unsigned long long value, char* buffer, unsigned int offset)␊
389{␊
390␉buffer[offset++] = value & 0xff;␊
391␉buffer[offset++] = (value >> 8) & 0xff;␊
392␉buffer[offset++] = (value >> 16) & 0xff;␊
393␉buffer[offset++] = (value >> 24) & 0xff;␊
394␉buffer[offset++] = (value >> 32) & 0xff;␊
395␉buffer[offset++] = (value >> 40) & 0xff;␊
396␉buffer[offset++] = (value >> 48) & 0xff;␊
397␉buffer[offset++] = (value >> 56) & 0xff;␊
398␉␊
399␉return offset;␊
400}␊
401␊
402unsigned int aml_write_buffer(const char* value, unsigned int size, char* buffer, unsigned int offset)␊
403{␊
404␉if (size > 0)␊
405␉{␊
406␉␉memcpy(buffer + offset, value, size);␊
407␉}␊
408␉␊
409␉return offset + size;␊
410}␊
411␊
412unsigned int aml_write_size(unsigned int size, char* buffer, unsigned int offset)␊
413{␊
414␉if (size <= 0x3f)␊
415␉{␊
416␉␉buffer[offset++] = size;␊
417␉}␊
418␉else if (size <= 0x3fff) ␊
419␉{␊
420␉␉buffer[offset++] = 0x40 | (size & 0xf);␊
421␉␉buffer[offset++] = (size >> 4) & 0xff;␊
422␉}␊
423␉else if (size <= 0x3fffff) ␊
424␉{␊
425␉␉buffer[offset++] = 0x80 | (size & 0xf);␊
426␉␉buffer[offset++] = (size >> 4) & 0xff;␊
427␉␉buffer[offset++] = (size >> 12) & 0xff;␊
428␉}␊
429 else ␊
430␉{␊
431␉␉buffer[offset++] = 0xc0 | (size & 0xf);␊
432␉␉buffer[offset++] = (size >> 4) & 0xff;␊
433␉␉buffer[offset++] = (size >> 12) & 0xff;␊
434␉␉buffer[offset++] = (size >> 20) & 0xff;␊
435␉}␊
436␉␊
437␉return offset;␊
438}␊
439␊
440unsigned int aml_write_node(struct aml_chunk* node, char* buffer, unsigned int offset)␊
441{␊
442␉if (node && buffer) ␊
443␉{␊
444␉␉unsigned int old = offset;␊
445␉␉␊
446␉␉switch (node->Type) ␊
447␉␉{␊
448␉␉␉case AML_CHUNK_NONE:␊
449␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
450␉␉␉␉break;␊
451␊
452␉␉␉case AML_CHUNK_SCOPE:␊
453␉␉␉case AML_CHUNK_PACKAGE:␊
454␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
455␉␉␉␉offset = aml_write_size(node->Size-1, buffer, offset);␊
456␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
457␉␉␉␉break;␊
458␉␉␉␉␊
459␉␉␉case AML_CHUNK_BYTE:␊
460␉␉␉␉if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) ␊
461␉␉␉␉{␊
462␉␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
463␉␉␉␉}␊
464␉␉␉␉else ␊
465␉␉␉␉{␊
466␉␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
467␉␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
468␉␉␉␉}␊
469␉␉␉␉break;␊
470␉␉␉␉␊
471␉␉␉case AML_CHUNK_WORD:␊
472␉␉␉case AML_CHUNK_DWORD:␊
473␉␉␉case AML_CHUNK_QWORD:␊
474␉␉␉case AML_CHUNK_ALIAS:␊
475␉␉␉case AML_CHUNK_NAME:␊
476␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
477␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
478␉␉␉␉break;␊
479␉␉␉␉␊
480␉␉␉default:␊
481␉␉␉␉break;␊
482␉␉}␊
483␊
484␉␉struct aml_chunk* child = node->First;␊
485␉␉␊
486␉␉while (child) ␊
487␉␉{␊
488␉␉␉offset = aml_write_node(child, buffer, offset);␊
489␉␉␉␊
490␉␉␉child = child->Next;␊
491␉␉}␊
492␉␉␊
493␉␉if (offset - old != node->Size) ␊
494␉␉␉verbose("Node size incorrect: 0x%x\n", node->Type);␊
495␉}␊
496␉␊
497␉return offset;␊
498}␊
499

Archive Download this file

Revision: 1621