]> git.proxmox.com Git - mirror_edk2.git/blame - EdkCompatibilityPkg/Sample/Tools/Source/GenDepex/DepexParser.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add in the 1st version of ECP.
[mirror_edk2.git] / EdkCompatibilityPkg / Sample / Tools / Source / GenDepex / DepexParser.c
CommitLineData
3eb9473e 1/*++\r
2\r
3Copyright (c) 2004, Intel Corporation \r
4All rights reserved. This program and the accompanying materials \r
5are licensed and made available under the terms and conditions of the BSD License \r
6which accompanies this distribution. The full text of the license may be found at \r
7http://opensource.org/licenses/bsd-license.php \r
8 \r
9THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
10WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
11\r
12Module Name:\r
13\r
14 DepexParser.c\r
15\r
16Abstract:\r
17\r
18 Validate Dependency Expression syntax\r
19 recursive descent Algorithm\r
20\r
21 The original BNF grammar(taken from "Pre EFI Initialization Core Interface Specification \r
22 draft review 0.9") is thus:\r
23 <depex> ::= BEFORE <guid> END\r
24 | AFTER <guid> END\r
25 | SOR <bool> END\r
26 | <bool> END \r
27 <bool> ::= <bool> AND <term> \r
28 | <bool> OR <term> \r
29 | <term> \r
30 <term> ::= NOT <factor> \r
31 | <factor> \r
32 <factor> ::= <bool> \r
33 | TRUE \r
34 | FALSE \r
35 | GUID\r
36\r
37 <guid> ::= '{' <hex32> ',' <hex16> ',' <hex16> ','\r
38 <hex8> ',' <hex8> ',' <hex8> ',' <hex8> ',' \r
39 <hex8> ',' <hex8> ',' <hex8> ',' <hex8> '}'\r
40 <hex32> ::= <hexprefix> <hexvalue>\r
41 <hex16> ::= <hexprefix> <hexvalue>\r
42 <hex8> ::= <hexprefix> <hexvalue>\r
43 <hexprefix>::= '0' 'x'\r
44 | '0' 'X'\r
45 <hexvalue> ::= <hexdigit> <hexvalue>\r
46 | <hexdigit>\r
47 <hexdigit> ::= [0-9]\r
48 | [a-f]\r
49 | [A-F]\r
50\r
51 After cleaning left recursive and parentheses supported, the BNF grammar used in this module is thus:\r
52 <depex> ::= BEFORE <guid>\r
53 | AFTER <guid>\r
54 | SOR <bool>\r
55 | <bool>\r
56 <bool> ::= <term><rightbool>\r
57 <rightbool>::= AND <term><rightbool>\r
58 | OR <term><rightbool>\r
59 | ''\r
60 <term> ::= NOT <factor>\r
61 | <factor>\r
62 <factor> ::= '('<bool>')'<rightfactor>\r
63 | NOT <factor> <rightbool> <rightfactor>\r
64 | TRUE <rightfactor>\r
65 | FALSE <rightfactor>\r
66 | END <rightfactor>\r
67 | <guid> <rightfactor> \r
68 <rightfactor> ::=AND <term><rightbool> <rightfactor> \r
69 | OR <term><rightbool> <rightfactor> \r
70 | ''\r
71 <guid> ::= '{' <hex32> ',' <hex16> ',' <hex16> ','\r
72 <hex8> ',' <hex8> ',' <hex8> ',' <hex8> ',' \r
73 <hex8> ',' <hex8> ',' <hex8> ',' <hex8> '}'\r
74 <hex32> ::= <hexprefix> <hexvalue>\r
75 <hex16> ::= <hexprefix> <hexvalue>\r
76 <hex8> ::= <hexprefix> <hexvalue>\r
77 <hexprefix>::= '0' 'x'\r
78 | '0' 'X'\r
79 <hexvalue> ::= <hexdigit> <hexvalue>\r
80 | <hexdigit>\r
81 <hexdigit> ::= [0-9]\r
82 | [a-f]\r
83 | [A-F]\r
84 \r
85 Note: 1. There's no precedence in operators except parentheses;\r
86 2. For hex32, less and equal than 8 bits is valid, more than 8 bits is invalid.\r
87 Same constraint for hex16 is 4, hex8 is 2. All hex should contains at least 1 bit.\r
88 3. "<factor> ::= '('<bool>')'<rightfactor>" is added to support parentheses;\r
89 4. "<factor> ::= GUID" is changed to "<factor> ::= <guid>";\r
90 5. "DEPENDENCY_END" is the terminal of the expression. But it has been filtered by caller. \r
91 During parsing, "DEPENDENCY_END" will be treated as illegal factor;\r
92 \r
93 This code should build in any environment that supports a standard C-library w/ string\r
94 operations and File I/O services.\r
95\r
96 As an example of usage, consider the following:\r
97\r
98 The input string could be something like: \r
99 \r
100 NOT ({ 0xce345171, 0xba0b, 0x11d2, 0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72,\r
101 0x3b } AND { 0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69,\r
102 0x72, 0x3b }) OR { 0x03c4e603, 0xac28, 0x11d3, 0x9a, 0x2d, 0x00, 0x90, 0x27,\r
103 0x3f, 0xc1, 0x4d } AND\r
104\r
105 It's invalid for an extra "AND" in the end.\r
106\r
107 Complies with Tiano C Coding Standards Document, version 0.33, 16 Aug 2001.\r
108\r
109--*/\r
110\r
111#include "DepexParser.h"\r
112\r
113BOOLEAN\r
114ParseBool (\r
115 IN INT8 *Pbegin,\r
116 IN UINT32 length,\r
117 IN OUT INT8 **Pindex\r
118 );\r
119\r
120BOOLEAN\r
121ParseTerm (\r
122 IN INT8 *Pbegin,\r
123 IN UINT32 length,\r
124 IN OUT INT8 **Pindex\r
125 );\r
126\r
127BOOLEAN\r
128ParseRightBool (\r
129 IN INT8 *Pbegin,\r
130 IN UINT32 length,\r
131 IN OUT INT8 **Pindex\r
132 );\r
133\r
134BOOLEAN\r
135ParseFactor (\r
136 IN INT8 *Pbegin,\r
137 IN UINT32 length,\r
138 IN OUT INT8 **Pindex\r
139 );\r
140\r
141VOID\r
142LeftTrim (\r
143 IN INT8 *Pbegin,\r
144 IN UINT32 length,\r
145 IN OUT INT8 **Pindex\r
146 )\r
147/*++\r
148\r
149Routine Description:\r
150\r
151 Left trim the space, '\n' and '\r' character in string.\r
152 The space at the end does not need trim.\r
153\r
154\r
155Arguments:\r
156\r
157 Pbegin The pointer to the string \r
158 length length of the string\r
159 Pindex The pointer of pointer to the next parse character in the string\r
160\r
161Returns:\r
162\r
163 None\r
164\r
165\r
166--*/\r
167{\r
168 while\r
169 (\r
170 ((*Pindex) < (Pbegin + length)) &&\r
171 ((strncmp (*Pindex, " ", 1) == 0) || (strncmp (*Pindex, "\n", 1) == 0) || (strncmp (*Pindex, "\r", 1) == 0))\r
172 ) {\r
173 (*Pindex)++;\r
174 }\r
175}\r
176\r
177BOOLEAN\r
178ParseHexdigit (\r
179 IN INT8 *Pbegin,\r
180 IN UINT32 length,\r
181 IN OUT INT8 **Pindex\r
182 )\r
183/*++\r
184\r
185Routine Description:\r
186\r
187 Parse Hex bit in dependency expression. \r
188\r
189Arguments:\r
190\r
191 Pbegin The pointer to the string \r
192 length Length of the string\r
193 Pindex The pointer of pointer to the next parse character in the string\r
194\r
195Returns:\r
196\r
197 BOOLEAN If parses a valid hex bit, return TRUE, otherwise FALSE\r
198\r
199\r
200--*/\r
201{\r
202 //\r
203 // <hexdigit> ::= [0-9] | [a-f] | [A-F]\r
204 //\r
205 if (((**Pindex) >= '0' && (**Pindex) <= '9') ||\r
206 ((**Pindex) >= 'a' && (**Pindex) <= 'f') ||\r
207 ((**Pindex) >= 'A' && (**Pindex) <= 'F')\r
208 ) {\r
209 (*Pindex)++;\r
210 return TRUE;\r
211 } else {\r
212 return FALSE;\r
213 }\r
214}\r
215\r
216BOOLEAN\r
217ParseHex32 (\r
218 IN INT8 *Pbegin,\r
219 IN UINT32 length,\r
220 IN OUT INT8 **Pindex\r
221 )\r
222/*++\r
223\r
224Routine Description:\r
225\r
226 Parse Hex32 in dependency expression. \r
227\r
228Arguments:\r
229\r
230 Pbegin The pointer to the string \r
231 length Length of the string\r
232 Pindex The pointer of point to the next parse character in the string\r
233\r
234Returns:\r
235\r
236 BOOLEAN If parses a valid hex32, return TRUE, otherwise FALSE\r
237\r
238\r
239--*/\r
240{\r
241 INT32 Index;\r
242 INT8 *Pin;\r
243\r
244 Index = 0;\r
245 Pin = *Pindex;\r
246 LeftTrim (Pbegin, length, Pindex);\r
247\r
248 if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) {\r
249 return FALSE;\r
250 }\r
251 (*Pindex) += 2;\r
252\r
253 while (ParseHexdigit (Pbegin, length, Pindex)) {\r
254 Index++;\r
255 }\r
256\r
257 if (Index > 0 && Index <= 8) {\r
258 return TRUE;\r
259 } else {\r
260 *Pindex = Pin;\r
261 return FALSE;\r
262 }\r
263}\r
264\r
265BOOLEAN\r
266ParseHex16 (\r
267 IN INT8 *Pbegin,\r
268 IN UINT32 length,\r
269 IN OUT INT8 **Pindex\r
270 )\r
271/*++\r
272\r
273Routine Description:\r
274\r
275 Parse Hex16 in dependency expression. \r
276\r
277Arguments:\r
278\r
279 Pbegin The pointer to the string \r
280 length Length of the string\r
281 Pindex The pointer of pointer to the next parse character in the string\r
282\r
283Returns:\r
284\r
285 BOOLEAN If parses a valid hex16, return TRUE, otherwise FALSE\r
286\r
287\r
288--*/\r
289{\r
290 int Index;\r
291 INT8 *Pin;\r
292\r
293 Index = 0;\r
294 Pin = *Pindex;\r
295 LeftTrim (Pbegin, length, Pindex);\r
296\r
297 if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) {\r
298 return FALSE;\r
299 }\r
300 (*Pindex) += 2;\r
301\r
302 while (ParseHexdigit (Pbegin, length, Pindex)) {\r
303 Index++;\r
304 }\r
305\r
306 if (Index > 0 && Index <= 4) {\r
307 return TRUE;\r
308 } else {\r
309 *Pindex = Pin;\r
310 return FALSE;\r
311 }\r
312}\r
313\r
314BOOLEAN\r
315ParseHex8 (\r
316 IN INT8 *Pbegin,\r
317 IN UINT32 length,\r
318 IN OUT INT8 **Pindex\r
319 )\r
320/*++\r
321\r
322Routine Description:\r
323\r
324 Parse Hex8 in dependency expression. \r
325\r
326Arguments:\r
327\r
328 Pbegin The pointer to the string \r
329 length Length of the string\r
330 Pindex The pointer of pointer to the next parse character in the string\r
331\r
332Returns:\r
333\r
334 BOOLEAN If parses a valid hex8, return TRUE, otherwise FALSE\r
335\r
336\r
337--*/\r
338{\r
339 int Index;\r
340 INT8 *Pin;\r
341\r
342 Index = 0;\r
343 Pin = *Pindex;\r
344 LeftTrim (Pbegin, length, Pindex);\r
345\r
346 if ((strncmp (*Pindex, "0x", 2) != 0) && (strncmp (*Pindex, "0X", 2) != 0)) {\r
347 return FALSE;\r
348 }\r
349 (*Pindex) += 2;\r
350\r
351 while (ParseHexdigit (Pbegin, length, Pindex)) {\r
352 Index++;\r
353 }\r
354\r
355 if (Index > 0 && Index <= 2) {\r
356 return TRUE;\r
357 } else {\r
358 *Pindex = Pin;\r
359 return FALSE;\r
360 }\r
361}\r
362\r
363BOOLEAN\r
364ParseGuid (\r
365 IN INT8 *Pbegin,\r
366 IN UINT32 length,\r
367 IN OUT INT8 **Pindex\r
368 )\r
369/*++\r
370\r
371Routine Description:\r
372\r
373 Parse guid in dependency expression.\r
374 There can be any number of spaces between '{' and hexword, ',' and hexword, \r
375 hexword and ',', hexword and '}'. The hexword include hex32, hex16 and hex8.\r
376\r
377Arguments:\r
378\r
379 Pbegin The pointer to the string \r
380 length length of the string\r
381 Pindex The pointer of pointer to the next parse character in the string\r
382\r
383Returns:\r
384\r
385 BOOLEAN If parses a valid guid, return TRUE, otherwise FALSE\r
386\r
387\r
388--*/\r
389{\r
390 INT32 Index;\r
391 INT8 *Pin;\r
392 Pin = *Pindex;\r
393 LeftTrim (Pbegin, length, Pindex);\r
394 if (strncmp (*Pindex, "{", 1) != 0) {\r
395 return FALSE;\r
396 }\r
397 (*Pindex)++;\r
398\r
399 LeftTrim (Pbegin, length, Pindex);\r
400 if (!ParseHex32 (Pbegin, length, Pindex)) {\r
401 *Pindex = Pin;\r
402 return FALSE;\r
403 }\r
404\r
405 LeftTrim (Pbegin, length, Pindex);\r
406 if (strncmp (*Pindex, ",", 1) != 0) {\r
407 return FALSE;\r
408 } else {\r
409 (*Pindex)++;\r
410 }\r
411\r
412 for (Index = 0; Index < 2; Index++) {\r
413 LeftTrim (Pbegin, length, Pindex);\r
414 if (!ParseHex16 (Pbegin, length, Pindex)) {\r
415 *Pindex = Pin;\r
416 return FALSE;\r
417 }\r
418\r
419 LeftTrim (Pbegin, length, Pindex);\r
420 if (strncmp (*Pindex, ",", 1) != 0) {\r
421 return FALSE;\r
422 } else {\r
423 (*Pindex)++;\r
424 }\r
425 }\r
426\r
427 for (Index = 0; Index < 7; Index++) {\r
428 LeftTrim (Pbegin, length, Pindex);\r
429 if (!ParseHex8 (Pbegin, length, Pindex)) {\r
430 *Pindex = Pin;\r
431 return FALSE;\r
432 }\r
433\r
434 LeftTrim (Pbegin, length, Pindex);\r
435 if (strncmp (*Pindex, ",", 1) != 0) {\r
436 return FALSE;\r
437 } else {\r
438 (*Pindex)++;\r
439 }\r
440 }\r
441\r
442 LeftTrim (Pbegin, length, Pindex);\r
443 if (!ParseHex8 (Pbegin, length, Pindex)) {\r
444 *Pindex = Pin;\r
445 return FALSE;\r
446 }\r
447\r
448 LeftTrim (Pbegin, length, Pindex);\r
449 if (strncmp (*Pindex, "}", 1) != 0) {\r
450 return FALSE;\r
451 } else {\r
452 (*Pindex)++;\r
453 }\r
454\r
455 return TRUE;\r
456}\r
457\r
458BOOLEAN\r
459ParseRightFactor (\r
460 IN INT8 *Pbegin,\r
461 IN UINT32 length,\r
462 IN OUT INT8 **Pindex\r
463 )\r
464/*++\r
465\r
466Routine Description:\r
467\r
468 Parse rightfactor in bool expression.\r
469\r
470Arguments:\r
471\r
472 Pbegin The pointer to the string \r
473 length length of the string\r
474 Pindex The pointer of pointer to the next parse character in the string\r
475\r
476Returns:\r
477\r
478 BOOLEAN If string is a valid rightfactor expression, return TRUE, otherwise FALSE\r
479\r
480\r
481--*/\r
482{\r
483 INT8 *Pin;\r
484\r
485 Pin = *Pindex;\r
486 LeftTrim (Pbegin, length, Pindex);\r
487\r
488 //\r
489 // <rightfactor> ::=AND <term> <rightbool> <rightfactor>\r
490 //\r
491 if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) {\r
492 *Pindex += strlen (OPERATOR_AND);\r
493 LeftTrim (Pbegin, length, Pindex);\r
494\r
495 if (ParseTerm (Pbegin, length, Pindex)) {\r
496 LeftTrim (Pbegin, length, Pindex);\r
497\r
498 if (ParseRightBool (Pbegin, length, Pindex)) {\r
499 LeftTrim (Pbegin, length, Pindex);\r
500 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
501 return TRUE;\r
502 } else {\r
503 *Pindex = Pin;\r
504 }\r
505 } else {\r
506 *Pindex = Pin;\r
507 }\r
508 } else {\r
509 *Pindex = Pin;\r
510 }\r
511 }\r
512 //\r
513 // <rightfactor> ::=OR <term> <rightbool> <rightfactor>\r
514 //\r
515 if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) {\r
516 *Pindex += strlen (OPERATOR_OR);\r
517 LeftTrim (Pbegin, length, Pindex);\r
518\r
519 if (ParseTerm (Pbegin, length, Pindex)) {\r
520 LeftTrim (Pbegin, length, Pindex);\r
521\r
522 if (ParseRightBool (Pbegin, length, Pindex)) {\r
523 LeftTrim (Pbegin, length, Pindex);\r
524 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
525 return TRUE;\r
526 } else {\r
527 *Pindex = Pin;\r
528 }\r
529 } else {\r
530 *Pindex = Pin;\r
531 }\r
532 } else {\r
533 *Pindex = Pin;\r
534 }\r
535 }\r
536 //\r
537 // <rightfactor> ::= ''\r
538 //\r
539 *Pindex = Pin;\r
540 return TRUE;\r
541}\r
542\r
543BOOLEAN\r
544ParseRightBool (\r
545 IN INT8 *Pbegin,\r
546 IN UINT32 length,\r
547 IN OUT INT8 **Pindex\r
548 )\r
549/*++\r
550\r
551Routine Description:\r
552\r
553 Parse rightbool in bool expression.\r
554\r
555Arguments:\r
556\r
557 Pbegin The pointer to the string \r
558 length length of the string\r
559 Pindex The pointer of pointer to the next parse character in the string\r
560\r
561Returns:\r
562\r
563 BOOLEAN If string is a valid rightbool expression, return TRUE, otherwise FALSE\r
564\r
565\r
566--*/\r
567{\r
568 INT8 *Pin;\r
569\r
570 Pin = *Pindex;\r
571 LeftTrim (Pbegin, length, Pindex);\r
572\r
573 //\r
574 // <rightbool>::= AND <term><rightbool>\r
575 //\r
576 if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) {\r
577 *Pindex += strlen (OPERATOR_AND);\r
578 LeftTrim (Pbegin, length, Pindex);\r
579\r
580 if (ParseTerm (Pbegin, length, Pindex)) {\r
581 LeftTrim (Pbegin, length, Pindex);\r
582\r
583 if (ParseRightBool (Pbegin, length, Pindex)) {\r
584 return TRUE;\r
585 } else {\r
586 *Pindex = Pin;\r
587 }\r
588 } else {\r
589 *Pindex = Pin;\r
590 }\r
591 }\r
592 //\r
593 // <rightbool>::= OR <term><rightbool>\r
594 //\r
595 if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) {\r
596 *Pindex += strlen (OPERATOR_OR);\r
597 LeftTrim (Pbegin, length, Pindex);\r
598\r
599 if (ParseTerm (Pbegin, length, Pindex)) {\r
600 LeftTrim (Pbegin, length, Pindex);\r
601\r
602 if (ParseRightBool (Pbegin, length, Pindex)) {\r
603 return TRUE;\r
604 } else {\r
605 *Pindex = Pin;\r
606 }\r
607 } else {\r
608 *Pindex = Pin;\r
609 }\r
610 }\r
611 //\r
612 // <rightbool>::= ''\r
613 //\r
614 *Pindex = Pin;\r
615 return TRUE;\r
616}\r
617\r
618BOOLEAN\r
619ParseFactor (\r
620 IN INT8 *Pbegin,\r
621 IN UINT32 length,\r
622 IN OUT INT8 **Pindex\r
623 )\r
624/*++\r
625\r
626Routine Description:\r
627\r
628 Parse factor in bool expression.\r
629\r
630Arguments:\r
631\r
632 Pbegin The pointer to the string \r
633 length length of the string\r
634 Pindex The pointer of pointer to the next parse character in the string\r
635\r
636Returns:\r
637\r
638 BOOLEAN If string is a valid factor, return TRUE, otherwise FALSE\r
639\r
640\r
641--*/\r
642{\r
643 INT8 *Pin;\r
644\r
645 Pin = *Pindex;\r
646 LeftTrim (Pbegin, length, Pindex);\r
647\r
648 //\r
649 // <factor> ::= '('<bool>')'<rightfactor>\r
650 //\r
651 if (strncmp (*Pindex, OPERATOR_LEFT_PARENTHESIS, strlen (OPERATOR_LEFT_PARENTHESIS)) == 0) {\r
652 *Pindex += strlen (OPERATOR_LEFT_PARENTHESIS);\r
653 LeftTrim (Pbegin, length, Pindex);\r
654\r
655 if (!ParseBool (Pbegin, length, Pindex)) {\r
656 *Pindex = Pin;\r
657 } else {\r
658 LeftTrim (Pbegin, length, Pindex);\r
659\r
660 if (strncmp (*Pindex, OPERATOR_RIGHT_PARENTHESIS, strlen (OPERATOR_RIGHT_PARENTHESIS)) == 0) {\r
661 *Pindex += strlen (OPERATOR_RIGHT_PARENTHESIS);\r
662 LeftTrim (Pbegin, length, Pindex);\r
663\r
664 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
665 return TRUE;\r
666 } else {\r
667 *Pindex = Pin;\r
668 }\r
669 }\r
670 }\r
671 }\r
672 //\r
673 // <factor> ::= NOT <factor> <rightbool> <rightfactor>\r
674 //\r
675 if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) {\r
676 *Pindex += strlen (OPERATOR_NOT);\r
677 LeftTrim (Pbegin, length, Pindex);\r
678\r
679 if (ParseFactor (Pbegin, length, Pindex)) {\r
680 LeftTrim (Pbegin, length, Pindex);\r
681\r
682 if (ParseRightBool (Pbegin, length, Pindex)) {\r
683 LeftTrim (Pbegin, length, Pindex);\r
684\r
685 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
686 return TRUE;\r
687 } else {\r
688 *Pindex = Pin;\r
689 }\r
690 } else {\r
691 *Pindex = Pin;\r
692 }\r
693 } else {\r
694 *Pindex = Pin;\r
695 }\r
696 }\r
697 //\r
698 // <factor> ::= TRUE <rightfactor>\r
699 //\r
700 if (strncmp (*Pindex, OPERATOR_TRUE, strlen (OPERATOR_TRUE)) == 0) {\r
701 *Pindex += strlen (OPERATOR_TRUE);\r
702 LeftTrim (Pbegin, length, Pindex);\r
703\r
704 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
705 return TRUE;\r
706 } else {\r
707 *Pindex = Pin;\r
708 }\r
709 }\r
710 //\r
711 // <factor> ::= FALSE <rightfactor>\r
712 //\r
713 if (strncmp (*Pindex, OPERATOR_FALSE, strlen (OPERATOR_FALSE)) == 0) {\r
714 *Pindex += strlen (OPERATOR_FALSE);\r
715 LeftTrim (Pbegin, length, Pindex);\r
716\r
717 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
718 return TRUE;\r
719 } else {\r
720 *Pindex = Pin;\r
721 }\r
722 }\r
723 //\r
724 // <factor> ::= <guid> <rightfactor>\r
725 //\r
726 if (ParseGuid (Pbegin, length, Pindex)) {\r
727 LeftTrim (Pbegin, length, Pindex);\r
728\r
729 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
730 return TRUE;\r
731 } else {\r
732 *Pindex = Pin;\r
733 return FALSE;\r
734 }\r
735 } else {\r
736 *Pindex = Pin;\r
737 return FALSE;\r
738 }\r
739}\r
740\r
741BOOLEAN\r
742ParseTerm (\r
743 IN INT8 *Pbegin,\r
744 IN UINT32 length,\r
745 IN OUT INT8 **Pindex\r
746 )\r
747/*++\r
748\r
749Routine Description:\r
750\r
751 Parse term in bool expression.\r
752\r
753Arguments:\r
754\r
755 Pbegin The pointer to the string \r
756 length length of the string\r
757 Pindex The pointer of pointer to the next parse character in the string\r
758\r
759Returns:\r
760\r
761 BOOLEAN If string is a valid term, return TRUE, otherwise FALSE\r
762\r
763\r
764--*/\r
765{\r
766 INT8 *Pin;\r
767\r
768 Pin = *Pindex;\r
769 LeftTrim (Pbegin, length, Pindex);\r
770\r
771 //\r
772 // <term> ::= NOT <factor>\r
773 //\r
774 if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) {\r
775 *Pindex += strlen (OPERATOR_NOT);\r
776 LeftTrim (Pbegin, length, Pindex);\r
777\r
778 if (!ParseFactor (Pbegin, length, Pindex)) {\r
779 *Pindex = Pin;\r
780 } else {\r
781 return TRUE;\r
782 }\r
783 }\r
784 //\r
785 // <term> ::=<factor>\r
786 //\r
787 if (ParseFactor (Pbegin, length, Pindex)) {\r
788 return TRUE;\r
789 } else {\r
790 *Pindex = Pin;\r
791 return FALSE;\r
792 }\r
793}\r
794\r
795BOOLEAN\r
796ParseBool (\r
797 IN INT8 *Pbegin,\r
798 IN UINT32 length,\r
799 IN OUT INT8 **Pindex\r
800 )\r
801/*++\r
802\r
803Routine Description:\r
804\r
805 Parse bool expression.\r
806\r
807Arguments:\r
808\r
809 Pbegin The pointer to the string \r
810 length length of the string\r
811 Pindex The pointer of pointer to the next parse character in the string\r
812\r
813Returns:\r
814\r
815 BOOLEAN If string is a valid bool expression, return TRUE, otherwise FALSE\r
816\r
817\r
818--*/\r
819{\r
820 INT8 *Pin;\r
821 Pin = *Pindex;\r
822 LeftTrim (Pbegin, length, Pindex);\r
823\r
824 if (ParseTerm (Pbegin, length, Pindex)) {\r
825 LeftTrim (Pbegin, length, Pindex);\r
826\r
827 if (!ParseRightBool (Pbegin, length, Pindex)) {\r
828 *Pindex = Pin;\r
829 return FALSE;\r
830 } else {\r
831 return TRUE;\r
832 }\r
833 } else {\r
834 *Pindex = Pin;\r
835 return FALSE;\r
836 }\r
837}\r
838\r
839BOOLEAN\r
840ParseDepex (\r
841 IN INT8 *Pbegin,\r
842 IN UINT32 length\r
843 )\r
844/*++\r
845\r
846Routine Description:\r
847\r
848 Parse whole dependency expression.\r
849\r
850Arguments:\r
851\r
852 Pbegin The pointer to the string \r
853 length length of the string\r
854\r
855Returns:\r
856\r
857 BOOLEAN If string is a valid dependency expression, return TRUE, otherwise FALSE\r
858\r
859\r
860--*/\r
861{\r
862 BOOLEAN Result;\r
863 INT8 **Pindex;\r
864 INT8 *temp;\r
865\r
866 Result = FALSE;\r
867 temp = Pbegin;\r
868 Pindex = &temp;\r
869\r
870 LeftTrim (Pbegin, length, Pindex);\r
871 if (strncmp (*Pindex, OPERATOR_BEFORE, strlen (OPERATOR_BEFORE)) == 0) {\r
872 (*Pindex) += strlen (OPERATOR_BEFORE);\r
873 Result = ParseGuid (Pbegin, length, Pindex);\r
874\r
875 } else if (strncmp (*Pindex, OPERATOR_AFTER, strlen (OPERATOR_AFTER)) == 0) {\r
876 (*Pindex) += strlen (OPERATOR_AFTER);\r
877 Result = ParseGuid (Pbegin, length, Pindex);\r
878\r
879 } else if (strncmp (*Pindex, OPERATOR_SOR, strlen (OPERATOR_SOR)) == 0) {\r
880 (*Pindex) += strlen (OPERATOR_SOR);\r
881 Result = ParseBool (Pbegin, length, Pindex);\r
882\r
883 } else {\r
884 Result = ParseBool (Pbegin, length, Pindex);\r
885\r
886 }\r
887\r
888 LeftTrim (Pbegin, length, Pindex);\r
889 return (BOOLEAN) (Result && (*Pindex) >= (Pbegin + length));\r
890}\r
EFI Development Kit II mirror for PVE