Chameleon Applications

Chameleon Applications Svn Source Tree

Root/branches/iFabio/i386/libsaio/aml_generator.c

Source at commit 214 created 13 years 5 months ago.
By ifabio, update to chameleon trunk 630, and now the pakage folder is the same as blackosx branch, also add Icon "building" into buildpkg script, and add mint theme info into the English localizable.strings.
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 isn't supports child nodes!");␊
25␉␉␉␉return false;␊
26␉␉␉case AML_CHUNK_NAME:␊
27␉␉␉␉if (parent->First) ␊
28␉␉␉␉{␊
29␉␉␉␉␉verbose("aml_add_to_parent: Name node could have only one child node!");␊
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", 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.", 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}

Archive Download this file

Revision: 214