]> git.proxmox.com Git - mirror_edk2.git/blame - Tools/CodeTools/Source/GenDepex/DepexParser.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
More renames for Tool Packages
[mirror_edk2.git] / Tools / CodeTools / Source / GenDepex / DepexParser.c
CommitLineData
878ddf1f 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 LeftTrim (Pbegin, length, Pindex);\r
428 if (strncmp (*Pindex, "{", 1) != 0) {\r
429 return FALSE;\r
430 }\r
431 (*Pindex)++;\r
432\r
433 for (Index = 0; Index < 7; Index++) {\r
434 LeftTrim (Pbegin, length, Pindex);\r
435 if (!ParseHex8 (Pbegin, length, Pindex)) {\r
436 *Pindex = Pin;\r
437 return FALSE;\r
438 }\r
439\r
440 LeftTrim (Pbegin, length, Pindex);\r
441 if (strncmp (*Pindex, ",", 1) != 0) {\r
442 return FALSE;\r
443 } else {\r
444 (*Pindex)++;\r
445 }\r
446 }\r
447\r
448 LeftTrim (Pbegin, length, Pindex);\r
449 if (!ParseHex8 (Pbegin, length, Pindex)) {\r
450 *Pindex = Pin;\r
451 return FALSE;\r
452 }\r
453\r
454 LeftTrim (Pbegin, length, Pindex);\r
455 if (strncmp (*Pindex, "}", 1) != 0) {\r
456 return FALSE;\r
457 } else {\r
458 (*Pindex)++;\r
459 }\r
460\r
461 LeftTrim (Pbegin, length, Pindex);\r
462 if (strncmp (*Pindex, "}", 1) != 0) {\r
463 return FALSE;\r
464 } else {\r
465 (*Pindex)++;\r
466 }\r
467\r
468 return TRUE;\r
469}\r
470\r
471BOOLEAN\r
472ParseRightFactor (\r
473 IN INT8 *Pbegin,\r
474 IN UINT32 length,\r
475 IN OUT INT8 **Pindex\r
476 )\r
477/*++\r
478\r
479Routine Description:\r
480\r
481 Parse rightfactor in bool expression.\r
482\r
483Arguments:\r
484\r
485 Pbegin The pointer to the string \r
486 length length of the string\r
487 Pindex The pointer of pointer to the next parse character in the string\r
488\r
489Returns:\r
490\r
491 BOOLEAN If string is a valid rightfactor expression, return TRUE, otherwise FALSE\r
492\r
493\r
494--*/\r
495{\r
496 INT8 *Pin;\r
497\r
498 Pin = *Pindex;\r
499 LeftTrim (Pbegin, length, Pindex);\r
500\r
501 //\r
502 // <rightfactor> ::=AND <term> <rightbool> <rightfactor>\r
503 //\r
504 if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) {\r
505 *Pindex += strlen (OPERATOR_AND);\r
506 LeftTrim (Pbegin, length, Pindex);\r
507\r
508 if (ParseTerm (Pbegin, length, Pindex)) {\r
509 LeftTrim (Pbegin, length, Pindex);\r
510\r
511 if (ParseRightBool (Pbegin, length, Pindex)) {\r
512 LeftTrim (Pbegin, length, Pindex);\r
513 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
514 return TRUE;\r
515 } else {\r
516 *Pindex = Pin;\r
517 }\r
518 } else {\r
519 *Pindex = Pin;\r
520 }\r
521 } else {\r
522 *Pindex = Pin;\r
523 }\r
524 }\r
525 //\r
526 // <rightfactor> ::=OR <term> <rightbool> <rightfactor>\r
527 //\r
528 if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) {\r
529 *Pindex += strlen (OPERATOR_OR);\r
530 LeftTrim (Pbegin, length, Pindex);\r
531\r
532 if (ParseTerm (Pbegin, length, Pindex)) {\r
533 LeftTrim (Pbegin, length, Pindex);\r
534\r
535 if (ParseRightBool (Pbegin, length, Pindex)) {\r
536 LeftTrim (Pbegin, length, Pindex);\r
537 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
538 return TRUE;\r
539 } else {\r
540 *Pindex = Pin;\r
541 }\r
542 } else {\r
543 *Pindex = Pin;\r
544 }\r
545 } else {\r
546 *Pindex = Pin;\r
547 }\r
548 }\r
549 //\r
550 // <rightfactor> ::= ''\r
551 //\r
552 *Pindex = Pin;\r
553 return TRUE;\r
554}\r
555\r
556BOOLEAN\r
557ParseRightBool (\r
558 IN INT8 *Pbegin,\r
559 IN UINT32 length,\r
560 IN OUT INT8 **Pindex\r
561 )\r
562/*++\r
563\r
564Routine Description:\r
565\r
566 Parse rightbool in bool expression.\r
567\r
568Arguments:\r
569\r
570 Pbegin The pointer to the string \r
571 length length of the string\r
572 Pindex The pointer of pointer to the next parse character in the string\r
573\r
574Returns:\r
575\r
576 BOOLEAN If string is a valid rightbool expression, return TRUE, otherwise FALSE\r
577\r
578\r
579--*/\r
580{\r
581 INT8 *Pin;\r
582\r
583 Pin = *Pindex;\r
584 LeftTrim (Pbegin, length, Pindex);\r
585\r
586 //\r
587 // <rightbool>::= AND <term><rightbool>\r
588 //\r
589 if (strncmp (*Pindex, OPERATOR_AND, strlen (OPERATOR_AND)) == 0) {\r
590 *Pindex += strlen (OPERATOR_AND);\r
591 LeftTrim (Pbegin, length, Pindex);\r
592\r
593 if (ParseTerm (Pbegin, length, Pindex)) {\r
594 LeftTrim (Pbegin, length, Pindex);\r
595\r
596 if (ParseRightBool (Pbegin, length, Pindex)) {\r
597 return TRUE;\r
598 } else {\r
599 *Pindex = Pin;\r
600 }\r
601 } else {\r
602 *Pindex = Pin;\r
603 }\r
604 }\r
605 //\r
606 // <rightbool>::= OR <term><rightbool>\r
607 //\r
608 if (strncmp (*Pindex, OPERATOR_OR, strlen (OPERATOR_OR)) == 0) {\r
609 *Pindex += strlen (OPERATOR_OR);\r
610 LeftTrim (Pbegin, length, Pindex);\r
611\r
612 if (ParseTerm (Pbegin, length, Pindex)) {\r
613 LeftTrim (Pbegin, length, Pindex);\r
614\r
615 if (ParseRightBool (Pbegin, length, Pindex)) {\r
616 return TRUE;\r
617 } else {\r
618 *Pindex = Pin;\r
619 }\r
620 } else {\r
621 *Pindex = Pin;\r
622 }\r
623 }\r
624 //\r
625 // <rightbool>::= ''\r
626 //\r
627 *Pindex = Pin;\r
628 return TRUE;\r
629}\r
630\r
631BOOLEAN\r
632ParseFactor (\r
633 IN INT8 *Pbegin,\r
634 IN UINT32 length,\r
635 IN OUT INT8 **Pindex\r
636 )\r
637/*++\r
638\r
639Routine Description:\r
640\r
641 Parse factor in bool expression.\r
642\r
643Arguments:\r
644\r
645 Pbegin The pointer to the string \r
646 length length of the string\r
647 Pindex The pointer of pointer to the next parse character in the string\r
648\r
649Returns:\r
650\r
651 BOOLEAN If string is a valid factor, return TRUE, otherwise FALSE\r
652\r
653\r
654--*/\r
655{\r
656 INT8 *Pin;\r
657\r
658 Pin = *Pindex;\r
659 LeftTrim (Pbegin, length, Pindex);\r
660\r
661 //\r
662 // <factor> ::= '('<bool>')'<rightfactor>\r
663 //\r
664 if (strncmp (*Pindex, OPERATOR_LEFT_PARENTHESIS, strlen (OPERATOR_LEFT_PARENTHESIS)) == 0) {\r
665 *Pindex += strlen (OPERATOR_LEFT_PARENTHESIS);\r
666 LeftTrim (Pbegin, length, Pindex);\r
667\r
668 if (!ParseBool (Pbegin, length, Pindex)) {\r
669 *Pindex = Pin;\r
670 } else {\r
671 LeftTrim (Pbegin, length, Pindex);\r
672\r
673 if (strncmp (*Pindex, OPERATOR_RIGHT_PARENTHESIS, strlen (OPERATOR_RIGHT_PARENTHESIS)) == 0) {\r
674 *Pindex += strlen (OPERATOR_RIGHT_PARENTHESIS);\r
675 LeftTrim (Pbegin, length, Pindex);\r
676\r
677 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
678 return TRUE;\r
679 } else {\r
680 *Pindex = Pin;\r
681 }\r
682 }\r
683 }\r
684 }\r
685 //\r
686 // <factor> ::= NOT <factor> <rightbool> <rightfactor>\r
687 //\r
688 if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) {\r
689 *Pindex += strlen (OPERATOR_NOT);\r
690 LeftTrim (Pbegin, length, Pindex);\r
691\r
692 if (ParseFactor (Pbegin, length, Pindex)) {\r
693 LeftTrim (Pbegin, length, Pindex);\r
694\r
695 if (ParseRightBool (Pbegin, length, Pindex)) {\r
696 LeftTrim (Pbegin, length, Pindex);\r
697\r
698 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
699 return TRUE;\r
700 } else {\r
701 *Pindex = Pin;\r
702 }\r
703 } else {\r
704 *Pindex = Pin;\r
705 }\r
706 } else {\r
707 *Pindex = Pin;\r
708 }\r
709 }\r
710 //\r
711 // <factor> ::= TRUE <rightfactor>\r
712 //\r
713 if (strncmp (*Pindex, OPERATOR_TRUE, strlen (OPERATOR_TRUE)) == 0) {\r
714 *Pindex += strlen (OPERATOR_TRUE);\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> ::= FALSE <rightfactor>\r
725 //\r
726 if (strncmp (*Pindex, OPERATOR_FALSE, strlen (OPERATOR_FALSE)) == 0) {\r
727 *Pindex += strlen (OPERATOR_FALSE);\r
728 LeftTrim (Pbegin, length, Pindex);\r
729\r
730 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
731 return TRUE;\r
732 } else {\r
733 *Pindex = Pin;\r
734 }\r
735 }\r
736 //\r
737 // <factor> ::= <guid> <rightfactor>\r
738 //\r
739 if (ParseGuid (Pbegin, length, Pindex)) {\r
740 LeftTrim (Pbegin, length, Pindex);\r
741\r
742 if (ParseRightFactor (Pbegin, length, Pindex)) {\r
743 return TRUE;\r
744 } else {\r
745 *Pindex = Pin;\r
746 return FALSE;\r
747 }\r
748 } else {\r
749 *Pindex = Pin;\r
750 return FALSE;\r
751 }\r
752}\r
753\r
754BOOLEAN\r
755ParseTerm (\r
756 IN INT8 *Pbegin,\r
757 IN UINT32 length,\r
758 IN OUT INT8 **Pindex\r
759 )\r
760/*++\r
761\r
762Routine Description:\r
763\r
764 Parse term in bool expression.\r
765\r
766Arguments:\r
767\r
768 Pbegin The pointer to the string \r
769 length length of the string\r
770 Pindex The pointer of pointer to the next parse character in the string\r
771\r
772Returns:\r
773\r
774 BOOLEAN If string is a valid term, return TRUE, otherwise FALSE\r
775\r
776\r
777--*/\r
778{\r
779 INT8 *Pin;\r
780\r
781 Pin = *Pindex;\r
782 LeftTrim (Pbegin, length, Pindex);\r
783\r
784 //\r
785 // <term> ::= NOT <factor>\r
786 //\r
787 if (strncmp (*Pindex, OPERATOR_NOT, strlen (OPERATOR_NOT)) == 0) {\r
788 *Pindex += strlen (OPERATOR_NOT);\r
789 LeftTrim (Pbegin, length, Pindex);\r
790\r
791 if (!ParseFactor (Pbegin, length, Pindex)) {\r
792 *Pindex = Pin;\r
793 } else {\r
794 return TRUE;\r
795 }\r
796 }\r
797 //\r
798 // <term> ::=<factor>\r
799 //\r
800 if (ParseFactor (Pbegin, length, Pindex)) {\r
801 return TRUE;\r
802 } else {\r
803 *Pindex = Pin;\r
804 return FALSE;\r
805 }\r
806}\r
807\r
808BOOLEAN\r
809ParseBool (\r
810 IN INT8 *Pbegin,\r
811 IN UINT32 length,\r
812 IN OUT INT8 **Pindex\r
813 )\r
814/*++\r
815\r
816Routine Description:\r
817\r
818 Parse bool expression.\r
819\r
820Arguments:\r
821\r
822 Pbegin The pointer to the string \r
823 length length of the string\r
824 Pindex The pointer of pointer to the next parse character in the string\r
825\r
826Returns:\r
827\r
828 BOOLEAN If string is a valid bool expression, return TRUE, otherwise FALSE\r
829\r
830\r
831--*/\r
832{\r
833 INT8 *Pin;\r
834 Pin = *Pindex;\r
835 LeftTrim (Pbegin, length, Pindex);\r
836\r
837 if (ParseTerm (Pbegin, length, Pindex)) {\r
838 LeftTrim (Pbegin, length, Pindex);\r
839\r
840 if (!ParseRightBool (Pbegin, length, Pindex)) {\r
841 *Pindex = Pin;\r
842 return FALSE;\r
843 } else {\r
844 return TRUE;\r
845 }\r
846 } else {\r
847 *Pindex = Pin;\r
848 return FALSE;\r
849 }\r
850}\r
851\r
852BOOLEAN\r
853ParseDepex (\r
854 IN INT8 *Pbegin,\r
855 IN UINT32 length\r
856 )\r
857/*++\r
858\r
859Routine Description:\r
860\r
861 Parse whole dependency expression.\r
862\r
863Arguments:\r
864\r
865 Pbegin The pointer to the string \r
866 length length of the string\r
867\r
868Returns:\r
869\r
870 BOOLEAN If string is a valid dependency expression, return TRUE, otherwise FALSE\r
871\r
872\r
873--*/\r
874{\r
875 BOOLEAN Result;\r
876 INT8 **Pindex;\r
877 INT8 *temp;\r
878\r
879 Result = FALSE;\r
880 temp = Pbegin;\r
881 Pindex = &temp;\r
882\r
883 LeftTrim (Pbegin, length, Pindex);\r
884 if (strncmp (*Pindex, OPERATOR_BEFORE, strlen (OPERATOR_BEFORE)) == 0) {\r
885 (*Pindex) += strlen (OPERATOR_BEFORE);\r
886 Result = ParseGuid (Pbegin, length, Pindex);\r
887\r
888 } else if (strncmp (*Pindex, OPERATOR_AFTER, strlen (OPERATOR_AFTER)) == 0) {\r
889 (*Pindex) += strlen (OPERATOR_AFTER);\r
890 Result = ParseGuid (Pbegin, length, Pindex);\r
891\r
892 } else if (strncmp (*Pindex, OPERATOR_SOR, strlen (OPERATOR_SOR)) == 0) {\r
893 (*Pindex) += strlen (OPERATOR_SOR);\r
894 Result = ParseBool (Pbegin, length, Pindex);\r
895\r
896 } else {\r
897 Result = ParseBool (Pbegin, length, Pindex);\r
898\r
899 }\r
900\r
901 LeftTrim (Pbegin, length, Pindex);\r
902 return (BOOLEAN) (Result && (*Pindex) >= (Pbegin + length));\r
903}\r
EFI Development Kit II mirror for PVE