1 #include "BuildLangClientParser.hpp"
2 #include <soulng/util/Unicode.hpp>
3 #include <cmajor/build/BuildLangLexer.hpp>
4 #include <cmajor/build/BuildLangTokens.hpp>
5 #include <cmajor/build/BuildLangOptionParser.hpp>
6
7
8
9 using namespace soulng::unicode;
10 using namespace BuildLangTokens;
11
12 std::std::unique_ptr<cmajor::build::ClientCommand>BuildLangClientParser::Parse(BuildLangLexer&lexer, cmajor::build::BuildOptionSetter*optionSetter)
13 {
14 std::unique_ptr<cmajor::build::ClientCommand> value;
15 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
16
17
18
19
20
21 #endif // SOULNG_PARSER_DEBUG_SUPPORT
22 ++lexer;
23 soulng::lexer::Span span = lexer.GetSpan();
24 soulng::parser::Match match = BuildLangClientParser::ClientSentence(lexer, optionSetter);
25 value.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
26 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
27
28
29
30
31
32 #endif // SOULNG_PARSER_DEBUG_SUPPORT
33 if (match.hit)
34 {
35 if (*lexer == soulng::lexer::END_TOKEN)
36 {
37 return value;
38 }
39 else
40 {
41 lexer.ThrowExpectationFailure(lexer.GetSpan(), ToUtf32(soulng::lexer::GetEndTokenInfo()));
42 }
43 }
44 else
45 {
46 lexer.ThrowExpectationFailure(span, U"cmclient [options] (add | remove | show | push | build | debug | install) ...");
47 }
48 return value;
49 }
50
51 soulng::parser::Match BuildLangClientParser::ClientSentence(BuildLangLexer& lexer, cmajor::build::BuildOptionSetter* optionSetter)
52 {
53 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
54
55
56
57
58
59
60
61 #endif // SOULNG_PARSER_DEBUG_SUPPORT
62 std::unique_ptr<cmajor::build::ClientCommand> sentence;
63 soulng::parser::Match match(false);
64 soulng::parser::Match* parentMatch0 = &match;
65 {
66 soulng::parser::Match match(true);
67 int64_t save = lexer.GetPos();
68 soulng::parser::Match* parentMatch1 = &match;
69 {
70 soulng::parser::Match match = BuildLangOptionParser::Options(lexer, optionSetter);
71 if (match.hit)
72 {
73 *parentMatch1 = match;
74 }
75 else
76 {
77 lexer.SetPos(save);
78 }
79 }
80 *parentMatch0 = match;
81 }
82 if (match.hit)
83 {
84 soulng::parser::Match match(false);
85 soulng::parser::Match* parentMatch2 = &match;
86 {
87 soulng::parser::Match match(false);
88 soulng::parser::Match* parentMatch3 = &match;
89 {
90 int64_t pos = lexer.GetPos();
91 soulng::parser::Match match(true);
92 soulng::parser::Match* parentMatch4 = &match;
93 {
94 soulng::lexer::Span span = lexer.GetSpan();
95 soulng::parser::Match match = BuildLangClientParser::ClientCommandSentence(lexer);
96 sentence.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
97 if (match.hit)
98 {
99 *parentMatch4 = match;
100 }
101 else
102 {
103 lexer.ThrowExpectationFailure(span, U"cmclient [options] (add | remove | show | push | build | debug | install) ...");
104 }
105 }
106 if (match.hit)
107 {
108 {
109 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
110
111 #endif // SOULNG_PARSER_DEBUG_SUPPORT
112 return soulng::parser::Match(true, sentence.release());
113 }
114 }
115 *parentMatch3 = match;
116 }
117 *parentMatch2 = match;
118 }
119 *parentMatch0 = match;
120 }
121 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
122
123
124
125
126
127 #endif // SOULNG_PARSER_DEBUG_SUPPORT
128 if (!match.hit)
129 {
130 match.value = nullptr;
131 }
132 return match;
133 }
134
135 soulng::parser::Match BuildLangClientParser::ClientCommandSentence(BuildLangLexer& lexer)
136 {
137 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
138
139
140
141
142
143
144
145 #endif // SOULNG_PARSER_DEBUG_SUPPORT
146 std::unique_ptr<cmajor::build::ClientCommand> pushCommand;
147 std::unique_ptr<cmajor::build::ClientCommand> removeProjectCommand;
148 std::unique_ptr<cmajor::build::ClientCommand> addServerCommand;
149 std::unique_ptr<cmajor::build::ClientCommand> removeServerCommand;
150 std::unique_ptr<cmajor::build::ClientCommand> buildCommand;
151 std::unique_ptr<cmajor::build::ClientCommand> debugCommand;
152 std::unique_ptr<cmajor::build::ClientCommand> installCommand;
153 std::unique_ptr<cmajor::build::ClientCommand> showConfigurationCommand;
154 soulng::parser::Match match(false);
155 soulng::parser::Match* parentMatch0 = &match;
156 {
157 soulng::parser::Match match(false);
158 soulng::parser::Match* parentMatch1 = &match;
159 {
160 int64_t save = lexer.GetPos();
161 soulng::parser::Match match(false);
162 soulng::parser::Match* parentMatch2 = &match;
163 {
164 int64_t save = lexer.GetPos();
165 soulng::parser::Match match(false);
166 soulng::parser::Match* parentMatch3 = &match;
167 {
168 int64_t save = lexer.GetPos();
169 soulng::parser::Match match(false);
170 soulng::parser::Match* parentMatch4 = &match;
171 {
172 int64_t save = lexer.GetPos();
173 soulng::parser::Match match(false);
174 soulng::parser::Match* parentMatch5 = &match;
175 {
176 int64_t save = lexer.GetPos();
177 soulng::parser::Match match(false);
178 soulng::parser::Match* parentMatch6 = &match;
179 {
180 int64_t save = lexer.GetPos();
181 soulng::parser::Match match(false);
182 soulng::parser::Match* parentMatch7 = &match;
183 {
184 int64_t save = lexer.GetPos();
185 soulng::parser::Match match(false);
186 soulng::parser::Match* parentMatch8 = &match;
187 {
188 int64_t pos = lexer.GetPos();
189 soulng::parser::Match match = BuildLangClientParser::PushProjectSentence(lexer);
190 pushCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
191 if (match.hit)
192 {
193 {
194 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
195
196 #endif // SOULNG_PARSER_DEBUG_SUPPORT
197 return soulng::parser::Match(true, pushCommand.release());
198 }
199 }
200 *parentMatch8 = match;
201 }
202 *parentMatch7 = match;
203 if (!match.hit)
204 {
205 soulng::parser::Match match(false);
206 soulng::parser::Match* parentMatch9 = &match;
207 lexer.SetPos(save);
208 {
209 soulng::parser::Match match(false);
210 soulng::parser::Match* parentMatch10 = &match;
211 {
212 int64_t pos = lexer.GetPos();
213 soulng::parser::Match match = BuildLangClientParser::RemoveProjectSentence(lexer);
214 removeProjectCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
215 if (match.hit)
216 {
217 {
218 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
219
220 #endif // SOULNG_PARSER_DEBUG_SUPPORT
221 return soulng::parser::Match(true, removeProjectCommand.release());
222 }
223 }
224 *parentMatch10 = match;
225 }
226 *parentMatch9 = match;
227 }
228 *parentMatch7 = match;
229 }
230 }
231 *parentMatch6 = match;
232 if (!match.hit)
233 {
234 soulng::parser::Match match(false);
235 soulng::parser::Match* parentMatch11 = &match;
236 lexer.SetPos(save);
237 {
238 soulng::parser::Match match(false);
239 soulng::parser::Match* parentMatch12 = &match;
240 {
241 int64_t pos = lexer.GetPos();
242 soulng::parser::Match match = BuildLangClientParser::AddServerSentence(lexer);
243 addServerCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
244 if (match.hit)
245 {
246 {
247 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
248
249 #endif // SOULNG_PARSER_DEBUG_SUPPORT
250 return soulng::parser::Match(true, addServerCommand.release());
251 }
252 }
253 *parentMatch12 = match;
254 }
255 *parentMatch11 = match;
256 }
257 *parentMatch6 = match;
258 }
259 }
260 *parentMatch5 = match;
261 if (!match.hit)
262 {
263 soulng::parser::Match match(false);
264 soulng::parser::Match* parentMatch13 = &match;
265 lexer.SetPos(save);
266 {
267 soulng::parser::Match match(false);
268 soulng::parser::Match* parentMatch14 = &match;
269 {
270 int64_t pos = lexer.GetPos();
271 soulng::parser::Match match = BuildLangClientParser::RemoveServerSentence(lexer);
272 removeServerCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
273 if (match.hit)
274 {
275 {
276 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
277
278 #endif // SOULNG_PARSER_DEBUG_SUPPORT
279 return soulng::parser::Match(true, removeServerCommand.release());
280 }
281 }
282 *parentMatch14 = match;
283 }
284 *parentMatch13 = match;
285 }
286 *parentMatch5 = match;
287 }
288 }
289 *parentMatch4 = match;
290 if (!match.hit)
291 {
292 soulng::parser::Match match(false);
293 soulng::parser::Match* parentMatch15 = &match;
294 lexer.SetPos(save);
295 {
296 soulng::parser::Match match(false);
297 soulng::parser::Match* parentMatch16 = &match;
298 {
299 int64_t pos = lexer.GetPos();
300 soulng::parser::Match match = BuildLangClientParser::BuildProjectSentence(lexer);
301 buildCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
302 if (match.hit)
303 {
304 {
305 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
306
307 #endif // SOULNG_PARSER_DEBUG_SUPPORT
308 return soulng::parser::Match(true, buildCommand.release());
309 }
310 }
311 *parentMatch16 = match;
312 }
313 *parentMatch15 = match;
314 }
315 *parentMatch4 = match;
316 }
317 }
318 *parentMatch3 = match;
319 if (!match.hit)
320 {
321 soulng::parser::Match match(false);
322 soulng::parser::Match* parentMatch17 = &match;
323 lexer.SetPos(save);
324 {
325 soulng::parser::Match match(false);
326 soulng::parser::Match* parentMatch18 = &match;
327 {
328 int64_t pos = lexer.GetPos();
329 soulng::parser::Match match = BuildLangClientParser::DebugProjectSentence(lexer);
330 debugCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
331 if (match.hit)
332 {
333 {
334 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
335
336 #endif // SOULNG_PARSER_DEBUG_SUPPORT
337 return soulng::parser::Match(true, debugCommand.release());
338 }
339 }
340 *parentMatch18 = match;
341 }
342 *parentMatch17 = match;
343 }
344 *parentMatch3 = match;
345 }
346 }
347 *parentMatch2 = match;
348 if (!match.hit)
349 {
350 soulng::parser::Match match(false);
351 soulng::parser::Match* parentMatch19 = &match;
352 lexer.SetPos(save);
353 {
354 soulng::parser::Match match(false);
355 soulng::parser::Match* parentMatch20 = &match;
356 {
357 int64_t pos = lexer.GetPos();
358 soulng::parser::Match match = BuildLangClientParser::InstallProjectSentence(lexer);
359 installCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
360 if (match.hit)
361 {
362 {
363 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
364
365 #endif // SOULNG_PARSER_DEBUG_SUPPORT
366 return soulng::parser::Match(true, installCommand.release());
367 }
368 }
369 *parentMatch20 = match;
370 }
371 *parentMatch19 = match;
372 }
373 *parentMatch2 = match;
374 }
375 }
376 *parentMatch1 = match;
377 if (!match.hit)
378 {
379 soulng::parser::Match match(false);
380 soulng::parser::Match* parentMatch21 = &match;
381 lexer.SetPos(save);
382 {
383 soulng::parser::Match match(false);
384 soulng::parser::Match* parentMatch22 = &match;
385 {
386 int64_t pos = lexer.GetPos();
387 soulng::parser::Match match = BuildLangClientParser::ShowConfigurationSentence(lexer);
388 showConfigurationCommand.reset(static_cast<cmajor::build::ClientCommand*>(match.value));
389 if (match.hit)
390 {
391 {
392 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
393
394 #endif // SOULNG_PARSER_DEBUG_SUPPORT
395 return soulng::parser::Match(true, showConfigurationCommand.release());
396 }
397 }
398 *parentMatch22 = match;
399 }
400 *parentMatch21 = match;
401 }
402 *parentMatch1 = match;
403 }
404 }
405 *parentMatch0 = match;
406 }
407 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
408
409
410
411
412
413 #endif // SOULNG_PARSER_DEBUG_SUPPORT
414 if (!match.hit)
415 {
416 match.value = nullptr;
417 }
418 return match;
419 }
420
421 soulng::parser::Match BuildLangClientParser::PushProjectSentence(BuildLangLexer& lexer)
422 {
423 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
424
425
426
427
428
429
430
431 #endif // SOULNG_PARSER_DEBUG_SUPPORT
432 std::string serverName = std::string();
433 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>project;
434 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
435 soulng::parser::Match match(false);
436 soulng::parser::Match* parentMatch0 = &match;
437 {
438 int64_t pos = lexer.GetPos();
439 soulng::parser::Match match(false);
440 soulng::parser::Match* parentMatch1 = &match;
441 {
442 soulng::parser::Match match(false);
443 soulng::parser::Match* parentMatch2 = &match;
444 {
445 soulng::parser::Match match(false);
446 soulng::parser::Match* parentMatch3 = &match;
447 {
448 soulng::parser::Match match(false);
449 if (*lexer == PUSH)
450 {
451 ++lexer;
452 match.hit = true;
453 }
454 *parentMatch3 = match;
455 }
456 if (match.hit)
457 {
458 soulng::parser::Match match(false);
459 soulng::parser::Match* parentMatch4 = &match;
460 {
461 soulng::parser::Match match(true);
462 soulng::parser::Match* parentMatch5 = &match;
463 {
464 soulng::lexer::Span span = lexer.GetSpan();
465 soulng::parser::Match match = BuildLangClientParser::ProjectFilePath(lexer);
466 project.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
467 if (match.hit)
468 {
469 *parentMatch5 = match;
470 }
471 else
472 {
473 lexer.ThrowExpectationFailure(span, U"PROJECT.cmp");
474 }
475 }
476 *parentMatch4 = match;
477 }
478 *parentMatch3 = match;
479 }
480 *parentMatch2 = match;
481 }
482 if (match.hit)
483 {
484 soulng::parser::Match match(false);
485 soulng::parser::Match* parentMatch6 = &match;
486 {
487 soulng::parser::Match match(true);
488 int64_t save = lexer.GetPos();
489 soulng::parser::Match* parentMatch7 = &match;
490 {
491 soulng::parser::Match match(false);
492 soulng::parser::Match* parentMatch8 = &match;
493 {
494 soulng::parser::Match match(false);
495 soulng::parser::Match* parentMatch9 = &match;
496 {
497 soulng::parser::Match match(false);
498 soulng::parser::Match* parentMatch10 = &match;
499 {
500 soulng::parser::Match match(false);
501 if (*lexer == TO)
502 {
503 ++lexer;
504 match.hit = true;
505 }
506 *parentMatch10 = match;
507 }
508 if (match.hit)
509 {
510 soulng::parser::Match match(false);
511 soulng::parser::Match* parentMatch11 = &match;
512 {
513 soulng::parser::Match match(true);
514 soulng::parser::Match* parentMatch12 = &match;
515 {
516 soulng::lexer::Span span = lexer.GetSpan();
517 soulng::parser::Match match(false);
518 if (*lexer == SERVER)
519 {
520 ++lexer;
521 match.hit = true;
522 }
523 if (match.hit)
524 {
525 *parentMatch12 = match;
526 }
527 else
528 {
529 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(SERVER)));
530 }
531 }
532 *parentMatch11 = match;
533 }
534 *parentMatch10 = match;
535 }
536 *parentMatch9 = match;
537 }
538 if (match.hit)
539 {
540 soulng::parser::Match match(false);
541 soulng::parser::Match* parentMatch13 = &match;
542 {
543 soulng::parser::Match match(false);
544 soulng::parser::Match* parentMatch14 = &match;
545 {
546 int64_t pos = lexer.GetPos();
547 soulng::parser::Match match(true);
548 soulng::parser::Match* parentMatch15 = &match;
549 {
550 soulng::lexer::Span span = lexer.GetSpan();
551 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
552 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
553 if (match.hit)
554 {
555 *parentMatch15 = match;
556 }
557 else
558 {
559 lexer.ThrowExpectationFailure(span, U"server name");
560 }
561 }
562 if (match.hit)
563 {
564 serverName = server->value;
565 }
566 *parentMatch14 = match;
567 }
568 *parentMatch13 = match;
569 }
570 *parentMatch9 = match;
571 }
572 *parentMatch8 = match;
573 }
574 if (match.hit)
575 {
576 *parentMatch7 = match;
577 }
578 else
579 {
580 lexer.SetPos(save);
581 }
582 }
583 *parentMatch6 = match;
584 }
585 *parentMatch2 = match;
586 }
587 *parentMatch1 = match;
588 }
589 if (match.hit)
590 {
591 {
592 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
593
594 #endif // SOULNG_PARSER_DEBUG_SUPPORT
595 return soulng::parser::Match(true, new cmajor::build::PushProjectClientCommand(project->value, serverName));
596 }
597 }
598 *parentMatch0 = match;
599 }
600 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
601
602
603
604
605
606 #endif // SOULNG_PARSER_DEBUG_SUPPORT
607 if (!match.hit)
608 {
609 match.value = nullptr;
610 }
611 return match;
612 }
613
614 soulng::parser::Match BuildLangClientParser::RemoveProjectSentence(BuildLangLexer& lexer)
615 {
616 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
617
618
619
620
621
622
623
624 #endif // SOULNG_PARSER_DEBUG_SUPPORT
625 std::string serverName = std::string();
626 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>project;
627 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
628 soulng::parser::Match match(false);
629 soulng::parser::Match* parentMatch0 = &match;
630 {
631 int64_t pos = lexer.GetPos();
632 soulng::parser::Match match(false);
633 soulng::parser::Match* parentMatch1 = &match;
634 {
635 soulng::parser::Match match(false);
636 soulng::parser::Match* parentMatch2 = &match;
637 {
638 soulng::parser::Match match(false);
639 soulng::parser::Match* parentMatch3 = &match;
640 {
641 soulng::parser::Match match(false);
642 if (*lexer == REMOVE)
643 {
644 ++lexer;
645 match.hit = true;
646 }
647 *parentMatch3 = match;
648 }
649 if (match.hit)
650 {
651 soulng::parser::Match match(false);
652 soulng::parser::Match* parentMatch4 = &match;
653 {
654 soulng::parser::Match match = BuildLangClientParser::ProjectFilePath(lexer);
655 project.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
656 *parentMatch4 = match;
657 }
658 *parentMatch3 = match;
659 }
660 *parentMatch2 = match;
661 }
662 if (match.hit)
663 {
664 soulng::parser::Match match(false);
665 soulng::parser::Match* parentMatch5 = &match;
666 {
667 soulng::parser::Match match(true);
668 int64_t save = lexer.GetPos();
669 soulng::parser::Match* parentMatch6 = &match;
670 {
671 soulng::parser::Match match(false);
672 soulng::parser::Match* parentMatch7 = &match;
673 {
674 soulng::parser::Match match(false);
675 soulng::parser::Match* parentMatch8 = &match;
676 {
677 soulng::parser::Match match(false);
678 soulng::parser::Match* parentMatch9 = &match;
679 {
680 soulng::parser::Match match(false);
681 if (*lexer == FROM)
682 {
683 ++lexer;
684 match.hit = true;
685 }
686 *parentMatch9 = match;
687 }
688 if (match.hit)
689 {
690 soulng::parser::Match match(false);
691 soulng::parser::Match* parentMatch10 = &match;
692 {
693 soulng::parser::Match match(true);
694 soulng::parser::Match* parentMatch11 = &match;
695 {
696 soulng::lexer::Span span = lexer.GetSpan();
697 soulng::parser::Match match(false);
698 if (*lexer == SERVER)
699 {
700 ++lexer;
701 match.hit = true;
702 }
703 if (match.hit)
704 {
705 *parentMatch11 = match;
706 }
707 else
708 {
709 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(SERVER)));
710 }
711 }
712 *parentMatch10 = match;
713 }
714 *parentMatch9 = match;
715 }
716 *parentMatch8 = match;
717 }
718 if (match.hit)
719 {
720 soulng::parser::Match match(false);
721 soulng::parser::Match* parentMatch12 = &match;
722 {
723 soulng::parser::Match match(false);
724 soulng::parser::Match* parentMatch13 = &match;
725 {
726 int64_t pos = lexer.GetPos();
727 soulng::parser::Match match(true);
728 soulng::parser::Match* parentMatch14 = &match;
729 {
730 soulng::lexer::Span span = lexer.GetSpan();
731 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
732 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
733 if (match.hit)
734 {
735 *parentMatch14 = match;
736 }
737 else
738 {
739 lexer.ThrowExpectationFailure(span, U"server name");
740 }
741 }
742 if (match.hit)
743 {
744 serverName = server->value;
745 }
746 *parentMatch13 = match;
747 }
748 *parentMatch12 = match;
749 }
750 *parentMatch8 = match;
751 }
752 *parentMatch7 = match;
753 }
754 if (match.hit)
755 {
756 *parentMatch6 = match;
757 }
758 else
759 {
760 lexer.SetPos(save);
761 }
762 }
763 *parentMatch5 = match;
764 }
765 *parentMatch2 = match;
766 }
767 *parentMatch1 = match;
768 }
769 if (match.hit)
770 {
771 {
772 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
773
774 #endif // SOULNG_PARSER_DEBUG_SUPPORT
775 return soulng::parser::Match(true, new cmajor::build::RemoveProjectClientCommand(project->value, serverName));
776 }
777 }
778 *parentMatch0 = match;
779 }
780 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
781
782
783
784
785
786 #endif // SOULNG_PARSER_DEBUG_SUPPORT
787 if (!match.hit)
788 {
789 match.value = nullptr;
790 }
791 return match;
792 }
793
794 soulng::parser::Match BuildLangClientParser::AddServerSentence(BuildLangLexer& lexer)
795 {
796 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
797
798
799
800
801
802
803
804 #endif // SOULNG_PARSER_DEBUG_SUPPORT
805 std::string host = std::string();
806 std::string toolChain = std::string();
807 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
808 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>h;
809 std::unique_ptr<soulng::parser::soulng::parser::Value<int>>port;
810 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>defaultToolChain;
811 soulng::parser::Match match(false);
812 soulng::parser::Match* parentMatch0 = &match;
813 {
814 int64_t pos = lexer.GetPos();
815 soulng::parser::Match match(false);
816 soulng::parser::Match* parentMatch1 = &match;
817 {
818 soulng::parser::Match match(false);
819 soulng::parser::Match* parentMatch2 = &match;
820 {
821 soulng::parser::Match match(false);
822 soulng::parser::Match* parentMatch3 = &match;
823 {
824 soulng::parser::Match match(false);
825 soulng::parser::Match* parentMatch4 = &match;
826 {
827 soulng::parser::Match match(false);
828 soulng::parser::Match* parentMatch5 = &match;
829 {
830 soulng::parser::Match match(false);
831 soulng::parser::Match* parentMatch6 = &match;
832 {
833 soulng::parser::Match match(false);
834 soulng::parser::Match* parentMatch7 = &match;
835 {
836 soulng::parser::Match match(false);
837 if (*lexer == ADD)
838 {
839 ++lexer;
840 match.hit = true;
841 }
842 *parentMatch7 = match;
843 }
844 if (match.hit)
845 {
846 soulng::parser::Match match(false);
847 soulng::parser::Match* parentMatch8 = &match;
848 {
849 soulng::parser::Match match(false);
850 if (*lexer == SERVER)
851 {
852 ++lexer;
853 match.hit = true;
854 }
855 *parentMatch8 = match;
856 }
857 *parentMatch7 = match;
858 }
859 *parentMatch6 = match;
860 }
861 if (match.hit)
862 {
863 soulng::parser::Match match(false);
864 soulng::parser::Match* parentMatch9 = &match;
865 {
866 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
867 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
868 *parentMatch9 = match;
869 }
870 *parentMatch6 = match;
871 }
872 *parentMatch5 = match;
873 }
874 if (match.hit)
875 {
876 soulng::parser::Match match(false);
877 soulng::parser::Match* parentMatch10 = &match;
878 {
879 soulng::parser::Match match(true);
880 int64_t save = lexer.GetPos();
881 soulng::parser::Match* parentMatch11 = &match;
882 {
883 soulng::parser::Match match(false);
884 soulng::parser::Match* parentMatch12 = &match;
885 {
886 soulng::parser::Match match(false);
887 soulng::parser::Match* parentMatch13 = &match;
888 {
889 soulng::parser::Match match(false);
890 if (*lexer == HOST)
891 {
892 ++lexer;
893 match.hit = true;
894 }
895 *parentMatch13 = match;
896 }
897 if (match.hit)
898 {
899 soulng::parser::Match match(false);
900 soulng::parser::Match* parentMatch14 = &match;
901 {
902 soulng::parser::Match match(false);
903 soulng::parser::Match* parentMatch15 = &match;
904 {
905 int64_t pos = lexer.GetPos();
906 soulng::parser::Match match(true);
907 soulng::parser::Match* parentMatch16 = &match;
908 {
909 soulng::lexer::Span span = lexer.GetSpan();
910 soulng::parser::Match match = BuildLangClientParser::Host(lexer);
911 h.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
912 if (match.hit)
913 {
914 *parentMatch16 = match;
915 }
916 else
917 {
918 lexer.ThrowExpectationFailure(span, U"host name or IP-address");
919 }
920 }
921 if (match.hit)
922 {
923 host = h->value;
924 }
925 *parentMatch15 = match;
926 }
927 *parentMatch14 = match;
928 }
929 *parentMatch13 = match;
930 }
931 *parentMatch12 = match;
932 }
933 if (match.hit)
934 {
935 *parentMatch11 = match;
936 }
937 else
938 {
939 lexer.SetPos(save);
940 }
941 }
942 *parentMatch10 = match;
943 }
944 *parentMatch5 = match;
945 }
946 *parentMatch4 = match;
947 }
948 if (match.hit)
949 {
950 soulng::parser::Match match(false);
951 soulng::parser::Match* parentMatch17 = &match;
952 {
953 soulng::parser::Match match(false);
954 if (*lexer == PORT)
955 {
956 ++lexer;
957 match.hit = true;
958 }
959 *parentMatch17 = match;
960 }
961 *parentMatch4 = match;
962 }
963 *parentMatch3 = match;
964 }
965 if (match.hit)
966 {
967 soulng::parser::Match match(false);
968 soulng::parser::Match* parentMatch18 = &match;
969 {
970 soulng::parser::Match match(true);
971 soulng::parser::Match* parentMatch19 = &match;
972 {
973 soulng::lexer::Span span = lexer.GetSpan();
974 soulng::parser::Match match = BuildLangClientParser::Port(lexer);
975 port.reset(static_cast<soulng::parser::soulng::parser::Value<int>*>(match.value));
976 if (match.hit)
977 {
978 *parentMatch19 = match;
979 }
980 else
981 {
982 lexer.ThrowExpectationFailure(span, U"port number");
983 }
984 }
985 *parentMatch18 = match;
986 }
987 *parentMatch3 = match;
988 }
989 *parentMatch2 = match;
990 }
991 if (match.hit)
992 {
993 soulng::parser::Match match(false);
994 soulng::parser::Match* parentMatch20 = &match;
995 {
996 soulng::parser::Match match(true);
997 int64_t save = lexer.GetPos();
998 soulng::parser::Match* parentMatch21 = &match;
999 {
1000 soulng::parser::Match match(false);
1001 soulng::parser::Match* parentMatch22 = &match;
1002 {
1003 soulng::parser::Match match(false);
1004 soulng::parser::Match* parentMatch23 = &match;
1005 {
1006 soulng::parser::Match match(false);
1007 soulng::parser::Match* parentMatch24 = &match;
1008 {
1009 soulng::parser::Match match(false);
1010 if (*lexer == DEFAULT)
1011 {
1012 ++lexer;
1013 match.hit = true;
1014 }
1015 *parentMatch24 = match;
1016 }
1017 if (match.hit)
1018 {
1019 soulng::parser::Match match(false);
1020 soulng::parser::Match* parentMatch25 = &match;
1021 {
1022 soulng::parser::Match match(true);
1023 soulng::parser::Match* parentMatch26 = &match;
1024 {
1025 soulng::lexer::Span span = lexer.GetSpan();
1026 soulng::parser::Match match(false);
1027 if (*lexer == TOOLCHAIN)
1028 {
1029 ++lexer;
1030 match.hit = true;
1031 }
1032 if (match.hit)
1033 {
1034 *parentMatch26 = match;
1035 }
1036 else
1037 {
1038 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(TOOLCHAIN)));
1039 }
1040 }
1041 *parentMatch25 = match;
1042 }
1043 *parentMatch24 = match;
1044 }
1045 *parentMatch23 = match;
1046 }
1047 if (match.hit)
1048 {
1049 soulng::parser::Match match(false);
1050 soulng::parser::Match* parentMatch27 = &match;
1051 {
1052 soulng::parser::Match match(false);
1053 soulng::parser::Match* parentMatch28 = &match;
1054 {
1055 int64_t pos = lexer.GetPos();
1056 soulng::parser::Match match(true);
1057 soulng::parser::Match* parentMatch29 = &match;
1058 {
1059 soulng::lexer::Span span = lexer.GetSpan();
1060 soulng::parser::Match match = BuildLangClientParser::ToolChain(lexer);
1061 defaultToolChain.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1062 if (match.hit)
1063 {
1064 *parentMatch29 = match;
1065 }
1066 else
1067 {
1068 lexer.ThrowExpectationFailure(span, U"tool chain (clang | gcc | vs)");
1069 }
1070 }
1071 if (match.hit)
1072 {
1073 toolChain = defaultToolChain->value;
1074 }
1075 *parentMatch28 = match;
1076 }
1077 *parentMatch27 = match;
1078 }
1079 *parentMatch23 = match;
1080 }
1081 *parentMatch22 = match;
1082 }
1083 if (match.hit)
1084 {
1085 *parentMatch21 = match;
1086 }
1087 else
1088 {
1089 lexer.SetPos(save);
1090 }
1091 }
1092 *parentMatch20 = match;
1093 }
1094 *parentMatch2 = match;
1095 }
1096 *parentMatch1 = match;
1097 }
1098 if (match.hit)
1099 {
1100 {
1101 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1102
1103 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1104 return soulng::parser::Match(true, new cmajor::build::AddServerClientCommand(server->value, host, port->value, toolChain));
1105 }
1106 }
1107 *parentMatch0 = match;
1108 }
1109 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1110
1111
1112
1113
1114
1115 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1116 if (!match.hit)
1117 {
1118 match.value = nullptr;
1119 }
1120 return match;
1121 }
1122
1123 soulng::parser::Match BuildLangClientParser::RemoveServerSentence(BuildLangLexer& lexer)
1124 {
1125 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1126
1127
1128
1129
1130
1131
1132
1133 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1134 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
1135 soulng::parser::Match match(false);
1136 soulng::parser::Match* parentMatch0 = &match;
1137 {
1138 soulng::parser::Match match(false);
1139 soulng::parser::Match* parentMatch1 = &match;
1140 {
1141 soulng::parser::Match match(false);
1142 if (*lexer == REMOVE)
1143 {
1144 ++lexer;
1145 match.hit = true;
1146 }
1147 *parentMatch1 = match;
1148 }
1149 if (match.hit)
1150 {
1151 soulng::parser::Match match(false);
1152 soulng::parser::Match* parentMatch2 = &match;
1153 {
1154 soulng::parser::Match match(false);
1155 if (*lexer == SERVER)
1156 {
1157 ++lexer;
1158 match.hit = true;
1159 }
1160 *parentMatch2 = match;
1161 }
1162 *parentMatch1 = match;
1163 }
1164 *parentMatch0 = match;
1165 }
1166 if (match.hit)
1167 {
1168 soulng::parser::Match match(false);
1169 soulng::parser::Match* parentMatch3 = &match;
1170 {
1171 soulng::parser::Match match(false);
1172 soulng::parser::Match* parentMatch4 = &match;
1173 {
1174 int64_t pos = lexer.GetPos();
1175 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
1176 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1177 if (match.hit)
1178 {
1179 {
1180 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1181
1182 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1183 return soulng::parser::Match(true, new cmajor::build::RemoveServerClientCommand(server->value));
1184 }
1185 }
1186 *parentMatch4 = match;
1187 }
1188 *parentMatch3 = match;
1189 }
1190 *parentMatch0 = match;
1191 }
1192 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1193
1194
1195
1196
1197
1198 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1199 if (!match.hit)
1200 {
1201 match.value = nullptr;
1202 }
1203 return match;
1204 }
1205
1206 soulng::parser::Match BuildLangClientParser::BuildProjectSentence(BuildLangLexer& lexer)
1207 {
1208 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1209
1210
1211
1212
1213
1214
1215
1216 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1217 std::string serverName = std::string();
1218 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>project;
1219 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
1220 soulng::parser::Match match(false);
1221 soulng::parser::Match* parentMatch0 = &match;
1222 {
1223 int64_t pos = lexer.GetPos();
1224 soulng::parser::Match match(false);
1225 soulng::parser::Match* parentMatch1 = &match;
1226 {
1227 soulng::parser::Match match(false);
1228 soulng::parser::Match* parentMatch2 = &match;
1229 {
1230 soulng::parser::Match match(false);
1231 soulng::parser::Match* parentMatch3 = &match;
1232 {
1233 soulng::parser::Match match(false);
1234 if (*lexer == BUILD)
1235 {
1236 ++lexer;
1237 match.hit = true;
1238 }
1239 *parentMatch3 = match;
1240 }
1241 if (match.hit)
1242 {
1243 soulng::parser::Match match(false);
1244 soulng::parser::Match* parentMatch4 = &match;
1245 {
1246 soulng::parser::Match match(true);
1247 soulng::parser::Match* parentMatch5 = &match;
1248 {
1249 soulng::lexer::Span span = lexer.GetSpan();
1250 soulng::parser::Match match = BuildLangClientParser::ProjectFilePath(lexer);
1251 project.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1252 if (match.hit)
1253 {
1254 *parentMatch5 = match;
1255 }
1256 else
1257 {
1258 lexer.ThrowExpectationFailure(span, U"PROJECT.cmp");
1259 }
1260 }
1261 *parentMatch4 = match;
1262 }
1263 *parentMatch3 = match;
1264 }
1265 *parentMatch2 = match;
1266 }
1267 if (match.hit)
1268 {
1269 soulng::parser::Match match(false);
1270 soulng::parser::Match* parentMatch6 = &match;
1271 {
1272 soulng::parser::Match match(true);
1273 int64_t save = lexer.GetPos();
1274 soulng::parser::Match* parentMatch7 = &match;
1275 {
1276 soulng::parser::Match match(false);
1277 soulng::parser::Match* parentMatch8 = &match;
1278 {
1279 soulng::parser::Match match(false);
1280 soulng::parser::Match* parentMatch9 = &match;
1281 {
1282 soulng::parser::Match match(false);
1283 soulng::parser::Match* parentMatch10 = &match;
1284 {
1285 soulng::parser::Match match(false);
1286 if (*lexer == USING)
1287 {
1288 ++lexer;
1289 match.hit = true;
1290 }
1291 *parentMatch10 = match;
1292 }
1293 if (match.hit)
1294 {
1295 soulng::parser::Match match(false);
1296 soulng::parser::Match* parentMatch11 = &match;
1297 {
1298 soulng::parser::Match match(true);
1299 soulng::parser::Match* parentMatch12 = &match;
1300 {
1301 soulng::lexer::Span span = lexer.GetSpan();
1302 soulng::parser::Match match(false);
1303 if (*lexer == SERVER)
1304 {
1305 ++lexer;
1306 match.hit = true;
1307 }
1308 if (match.hit)
1309 {
1310 *parentMatch12 = match;
1311 }
1312 else
1313 {
1314 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(SERVER)));
1315 }
1316 }
1317 *parentMatch11 = match;
1318 }
1319 *parentMatch10 = match;
1320 }
1321 *parentMatch9 = match;
1322 }
1323 if (match.hit)
1324 {
1325 soulng::parser::Match match(false);
1326 soulng::parser::Match* parentMatch13 = &match;
1327 {
1328 soulng::parser::Match match(false);
1329 soulng::parser::Match* parentMatch14 = &match;
1330 {
1331 int64_t pos = lexer.GetPos();
1332 soulng::parser::Match match(true);
1333 soulng::parser::Match* parentMatch15 = &match;
1334 {
1335 soulng::lexer::Span span = lexer.GetSpan();
1336 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
1337 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1338 if (match.hit)
1339 {
1340 *parentMatch15 = match;
1341 }
1342 else
1343 {
1344 lexer.ThrowExpectationFailure(span, U"server name");
1345 }
1346 }
1347 if (match.hit)
1348 {
1349 serverName = server->value;
1350 }
1351 *parentMatch14 = match;
1352 }
1353 *parentMatch13 = match;
1354 }
1355 *parentMatch9 = match;
1356 }
1357 *parentMatch8 = match;
1358 }
1359 if (match.hit)
1360 {
1361 *parentMatch7 = match;
1362 }
1363 else
1364 {
1365 lexer.SetPos(save);
1366 }
1367 }
1368 *parentMatch6 = match;
1369 }
1370 *parentMatch2 = match;
1371 }
1372 *parentMatch1 = match;
1373 }
1374 if (match.hit)
1375 {
1376 {
1377 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1378
1379 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1380 return soulng::parser::Match(true, new cmajor::build::BuildProjectClientCommand(project->value, serverName));
1381 }
1382 }
1383 *parentMatch0 = match;
1384 }
1385 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1386
1387
1388
1389
1390
1391 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1392 if (!match.hit)
1393 {
1394 match.value = nullptr;
1395 }
1396 return match;
1397 }
1398
1399 soulng::parser::Match BuildLangClientParser::DebugProjectSentence(BuildLangLexer& lexer)
1400 {
1401 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1402
1403
1404
1405
1406
1407
1408
1409 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1410 std::string serverName = std::string();
1411 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>project;
1412 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
1413 soulng::parser::Match match(false);
1414 soulng::parser::Match* parentMatch0 = &match;
1415 {
1416 int64_t pos = lexer.GetPos();
1417 soulng::parser::Match match(false);
1418 soulng::parser::Match* parentMatch1 = &match;
1419 {
1420 soulng::parser::Match match(false);
1421 soulng::parser::Match* parentMatch2 = &match;
1422 {
1423 soulng::parser::Match match(false);
1424 soulng::parser::Match* parentMatch3 = &match;
1425 {
1426 soulng::parser::Match match(false);
1427 if (*lexer == DEBUG)
1428 {
1429 ++lexer;
1430 match.hit = true;
1431 }
1432 *parentMatch3 = match;
1433 }
1434 if (match.hit)
1435 {
1436 soulng::parser::Match match(false);
1437 soulng::parser::Match* parentMatch4 = &match;
1438 {
1439 soulng::parser::Match match(true);
1440 soulng::parser::Match* parentMatch5 = &match;
1441 {
1442 soulng::lexer::Span span = lexer.GetSpan();
1443 soulng::parser::Match match = BuildLangClientParser::ProjectFilePath(lexer);
1444 project.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1445 if (match.hit)
1446 {
1447 *parentMatch5 = match;
1448 }
1449 else
1450 {
1451 lexer.ThrowExpectationFailure(span, U"PROJECT.cmp");
1452 }
1453 }
1454 *parentMatch4 = match;
1455 }
1456 *parentMatch3 = match;
1457 }
1458 *parentMatch2 = match;
1459 }
1460 if (match.hit)
1461 {
1462 soulng::parser::Match match(false);
1463 soulng::parser::Match* parentMatch6 = &match;
1464 {
1465 soulng::parser::Match match(true);
1466 int64_t save = lexer.GetPos();
1467 soulng::parser::Match* parentMatch7 = &match;
1468 {
1469 soulng::parser::Match match(false);
1470 soulng::parser::Match* parentMatch8 = &match;
1471 {
1472 soulng::parser::Match match(false);
1473 soulng::parser::Match* parentMatch9 = &match;
1474 {
1475 soulng::parser::Match match(false);
1476 soulng::parser::Match* parentMatch10 = &match;
1477 {
1478 soulng::parser::Match match(false);
1479 if (*lexer == USING)
1480 {
1481 ++lexer;
1482 match.hit = true;
1483 }
1484 *parentMatch10 = match;
1485 }
1486 if (match.hit)
1487 {
1488 soulng::parser::Match match(false);
1489 soulng::parser::Match* parentMatch11 = &match;
1490 {
1491 soulng::parser::Match match(true);
1492 soulng::parser::Match* parentMatch12 = &match;
1493 {
1494 soulng::lexer::Span span = lexer.GetSpan();
1495 soulng::parser::Match match(false);
1496 if (*lexer == SERVER)
1497 {
1498 ++lexer;
1499 match.hit = true;
1500 }
1501 if (match.hit)
1502 {
1503 *parentMatch12 = match;
1504 }
1505 else
1506 {
1507 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(SERVER)));
1508 }
1509 }
1510 *parentMatch11 = match;
1511 }
1512 *parentMatch10 = match;
1513 }
1514 *parentMatch9 = match;
1515 }
1516 if (match.hit)
1517 {
1518 soulng::parser::Match match(false);
1519 soulng::parser::Match* parentMatch13 = &match;
1520 {
1521 soulng::parser::Match match(false);
1522 soulng::parser::Match* parentMatch14 = &match;
1523 {
1524 int64_t pos = lexer.GetPos();
1525 soulng::parser::Match match(true);
1526 soulng::parser::Match* parentMatch15 = &match;
1527 {
1528 soulng::lexer::Span span = lexer.GetSpan();
1529 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
1530 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1531 if (match.hit)
1532 {
1533 *parentMatch15 = match;
1534 }
1535 else
1536 {
1537 lexer.ThrowExpectationFailure(span, U"server name");
1538 }
1539 }
1540 if (match.hit)
1541 {
1542 serverName = server->value;
1543 }
1544 *parentMatch14 = match;
1545 }
1546 *parentMatch13 = match;
1547 }
1548 *parentMatch9 = match;
1549 }
1550 *parentMatch8 = match;
1551 }
1552 if (match.hit)
1553 {
1554 *parentMatch7 = match;
1555 }
1556 else
1557 {
1558 lexer.SetPos(save);
1559 }
1560 }
1561 *parentMatch6 = match;
1562 }
1563 *parentMatch2 = match;
1564 }
1565 *parentMatch1 = match;
1566 }
1567 if (match.hit)
1568 {
1569 {
1570 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1571
1572 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1573 return soulng::parser::Match(true, new cmajor::build::DebugProjectClientCommand(project->value, serverName));
1574 }
1575 }
1576 *parentMatch0 = match;
1577 }
1578 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1579
1580
1581
1582
1583
1584 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1585 if (!match.hit)
1586 {
1587 match.value = nullptr;
1588 }
1589 return match;
1590 }
1591
1592 soulng::parser::Match BuildLangClientParser::InstallProjectSentence(BuildLangLexer& lexer)
1593 {
1594 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1595
1596
1597
1598
1599
1600
1601
1602 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1603 std::string serverName = std::string();
1604 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>project;
1605 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>directory;
1606 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>server;
1607 soulng::parser::Match match(false);
1608 soulng::parser::Match* parentMatch0 = &match;
1609 {
1610 int64_t pos = lexer.GetPos();
1611 soulng::parser::Match match(false);
1612 soulng::parser::Match* parentMatch1 = &match;
1613 {
1614 soulng::parser::Match match(false);
1615 soulng::parser::Match* parentMatch2 = &match;
1616 {
1617 soulng::parser::Match match(false);
1618 soulng::parser::Match* parentMatch3 = &match;
1619 {
1620 soulng::parser::Match match(false);
1621 soulng::parser::Match* parentMatch4 = &match;
1622 {
1623 soulng::parser::Match match(false);
1624 soulng::parser::Match* parentMatch5 = &match;
1625 {
1626 soulng::parser::Match match(false);
1627 if (*lexer == INSTALL)
1628 {
1629 ++lexer;
1630 match.hit = true;
1631 }
1632 *parentMatch5 = match;
1633 }
1634 if (match.hit)
1635 {
1636 soulng::parser::Match match(false);
1637 soulng::parser::Match* parentMatch6 = &match;
1638 {
1639 soulng::parser::Match match(true);
1640 soulng::parser::Match* parentMatch7 = &match;
1641 {
1642 soulng::lexer::Span span = lexer.GetSpan();
1643 soulng::parser::Match match = BuildLangClientParser::ProjectFilePath(lexer);
1644 project.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1645 if (match.hit)
1646 {
1647 *parentMatch7 = match;
1648 }
1649 else
1650 {
1651 lexer.ThrowExpectationFailure(span, U"PROJECT.cmp");
1652 }
1653 }
1654 *parentMatch6 = match;
1655 }
1656 *parentMatch5 = match;
1657 }
1658 *parentMatch4 = match;
1659 }
1660 if (match.hit)
1661 {
1662 soulng::parser::Match match(false);
1663 soulng::parser::Match* parentMatch8 = &match;
1664 {
1665 soulng::parser::Match match(true);
1666 soulng::parser::Match* parentMatch9 = &match;
1667 {
1668 soulng::lexer::Span span = lexer.GetSpan();
1669 soulng::parser::Match match(false);
1670 if (*lexer == TO)
1671 {
1672 ++lexer;
1673 match.hit = true;
1674 }
1675 if (match.hit)
1676 {
1677 *parentMatch9 = match;
1678 }
1679 else
1680 {
1681 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(TO)));
1682 }
1683 }
1684 *parentMatch8 = match;
1685 }
1686 *parentMatch4 = match;
1687 }
1688 *parentMatch3 = match;
1689 }
1690 if (match.hit)
1691 {
1692 soulng::parser::Match match(false);
1693 soulng::parser::Match* parentMatch10 = &match;
1694 {
1695 soulng::parser::Match match(true);
1696 soulng::parser::Match* parentMatch11 = &match;
1697 {
1698 soulng::lexer::Span span = lexer.GetSpan();
1699 soulng::parser::Match match = BuildLangClientParser::DirectoryPath(lexer);
1700 directory.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1701 if (match.hit)
1702 {
1703 *parentMatch11 = match;
1704 }
1705 else
1706 {
1707 lexer.ThrowExpectationFailure(span, U"directory name");
1708 }
1709 }
1710 *parentMatch10 = match;
1711 }
1712 *parentMatch3 = match;
1713 }
1714 *parentMatch2 = match;
1715 }
1716 if (match.hit)
1717 {
1718 soulng::parser::Match match(false);
1719 soulng::parser::Match* parentMatch12 = &match;
1720 {
1721 soulng::parser::Match match(true);
1722 int64_t save = lexer.GetPos();
1723 soulng::parser::Match* parentMatch13 = &match;
1724 {
1725 soulng::parser::Match match(false);
1726 soulng::parser::Match* parentMatch14 = &match;
1727 {
1728 soulng::parser::Match match(false);
1729 soulng::parser::Match* parentMatch15 = &match;
1730 {
1731 soulng::parser::Match match(false);
1732 soulng::parser::Match* parentMatch16 = &match;
1733 {
1734 soulng::parser::Match match(false);
1735 if (*lexer == FROM)
1736 {
1737 ++lexer;
1738 match.hit = true;
1739 }
1740 *parentMatch16 = match;
1741 }
1742 if (match.hit)
1743 {
1744 soulng::parser::Match match(false);
1745 soulng::parser::Match* parentMatch17 = &match;
1746 {
1747 soulng::parser::Match match(true);
1748 soulng::parser::Match* parentMatch18 = &match;
1749 {
1750 soulng::lexer::Span span = lexer.GetSpan();
1751 soulng::parser::Match match(false);
1752 if (*lexer == SERVER)
1753 {
1754 ++lexer;
1755 match.hit = true;
1756 }
1757 if (match.hit)
1758 {
1759 *parentMatch18 = match;
1760 }
1761 else
1762 {
1763 lexer.ThrowExpectationFailure(span, ToUtf32(GetTokenInfo(SERVER)));
1764 }
1765 }
1766 *parentMatch17 = match;
1767 }
1768 *parentMatch16 = match;
1769 }
1770 *parentMatch15 = match;
1771 }
1772 if (match.hit)
1773 {
1774 soulng::parser::Match match(false);
1775 soulng::parser::Match* parentMatch19 = &match;
1776 {
1777 soulng::parser::Match match(false);
1778 soulng::parser::Match* parentMatch20 = &match;
1779 {
1780 int64_t pos = lexer.GetPos();
1781 soulng::parser::Match match(true);
1782 soulng::parser::Match* parentMatch21 = &match;
1783 {
1784 soulng::lexer::Span span = lexer.GetSpan();
1785 soulng::parser::Match match = BuildLangClientParser::ServerName(lexer);
1786 server.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
1787 if (match.hit)
1788 {
1789 *parentMatch21 = match;
1790 }
1791 else
1792 {
1793 lexer.ThrowExpectationFailure(span, U"server name");
1794 }
1795 }
1796 if (match.hit)
1797 {
1798 serverName = server->value;
1799 }
1800 *parentMatch20 = match;
1801 }
1802 *parentMatch19 = match;
1803 }
1804 *parentMatch15 = match;
1805 }
1806 *parentMatch14 = match;
1807 }
1808 if (match.hit)
1809 {
1810 *parentMatch13 = match;
1811 }
1812 else
1813 {
1814 lexer.SetPos(save);
1815 }
1816 }
1817 *parentMatch12 = match;
1818 }
1819 *parentMatch2 = match;
1820 }
1821 *parentMatch1 = match;
1822 }
1823 if (match.hit)
1824 {
1825 {
1826 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1827
1828 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1829 return soulng::parser::Match(true, new cmajor::build::InstallProjectClientCommand(project->value, directory->value, serverName));
1830 }
1831 }
1832 *parentMatch0 = match;
1833 }
1834 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1835
1836
1837
1838
1839
1840 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1841 if (!match.hit)
1842 {
1843 match.value = nullptr;
1844 }
1845 return match;
1846 }
1847
1848 soulng::parser::Match BuildLangClientParser::ShowConfigurationSentence(BuildLangLexer& lexer)
1849 {
1850 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1851
1852
1853
1854
1855
1856
1857
1858 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1859 soulng::parser::Match match(false);
1860 soulng::parser::Match* parentMatch0 = &match;
1861 {
1862 int64_t pos = lexer.GetPos();
1863 soulng::parser::Match match(false);
1864 soulng::parser::Match* parentMatch1 = &match;
1865 {
1866 soulng::parser::Match match(false);
1867 soulng::parser::Match* parentMatch2 = &match;
1868 {
1869 soulng::parser::Match match(false);
1870 if (*lexer == SHOW)
1871 {
1872 ++lexer;
1873 match.hit = true;
1874 }
1875 *parentMatch2 = match;
1876 }
1877 if (match.hit)
1878 {
1879 soulng::parser::Match match(false);
1880 soulng::parser::Match* parentMatch3 = &match;
1881 {
1882 soulng::parser::Match match(false);
1883 if (*lexer == CONFIGURATION)
1884 {
1885 ++lexer;
1886 match.hit = true;
1887 }
1888 *parentMatch3 = match;
1889 }
1890 *parentMatch2 = match;
1891 }
1892 *parentMatch1 = match;
1893 }
1894 if (match.hit)
1895 {
1896 {
1897 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1898
1899 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1900 return soulng::parser::Match(true, new cmajor::build::ShowConfigurationClientCommand());
1901 }
1902 }
1903 *parentMatch0 = match;
1904 }
1905 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1906
1907
1908
1909
1910
1911 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1912 if (!match.hit)
1913 {
1914 match.value = nullptr;
1915 }
1916 return match;
1917 }
1918
1919 soulng::parser::Match BuildLangClientParser::ProjectFilePath(BuildLangLexer& lexer)
1920 {
1921 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1922
1923
1924
1925
1926
1927
1928
1929 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1930 soulng::parser::Match match(false);
1931 soulng::parser::Match* parentMatch0 = &match;
1932 {
1933 int64_t pos = lexer.GetPos();
1934 soulng::parser::Match match(false);
1935 if (*lexer == FILEPATH)
1936 {
1937 ++lexer;
1938 match.hit = true;
1939 }
1940 if (match.hit)
1941 {
1942 {
1943 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1944
1945 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1946 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
1947 }
1948 }
1949 *parentMatch0 = match;
1950 }
1951 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1952
1953
1954
1955
1956
1957 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1958 if (!match.hit)
1959 {
1960 match.value = nullptr;
1961 }
1962 return match;
1963 }
1964
1965 soulng::parser::Match BuildLangClientParser::DirectoryPath(BuildLangLexer& lexer)
1966 {
1967 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1968
1969
1970
1971
1972
1973
1974
1975 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1976 soulng::parser::Match match(false);
1977 soulng::parser::Match* parentMatch0 = &match;
1978 {
1979 int64_t pos = lexer.GetPos();
1980 soulng::parser::Match match(false);
1981 if (*lexer == FILEPATH)
1982 {
1983 ++lexer;
1984 match.hit = true;
1985 }
1986 if (match.hit)
1987 {
1988 {
1989 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1990
1991 #endif // SOULNG_PARSER_DEBUG_SUPPORT
1992 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
1993 }
1994 }
1995 *parentMatch0 = match;
1996 }
1997 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
1998
1999
2000
2001
2002
2003 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2004 if (!match.hit)
2005 {
2006 match.value = nullptr;
2007 }
2008 return match;
2009 }
2010
2011 soulng::parser::Match BuildLangClientParser::ServerName(BuildLangLexer& lexer)
2012 {
2013 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2014
2015
2016
2017
2018
2019
2020
2021 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2022 soulng::parser::Match match(false);
2023 soulng::parser::Match* parentMatch0 = &match;
2024 {
2025 int64_t pos = lexer.GetPos();
2026 soulng::parser::Match match(false);
2027 if (*lexer == ID)
2028 {
2029 ++lexer;
2030 match.hit = true;
2031 }
2032 if (match.hit)
2033 {
2034 {
2035 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2036
2037 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2038 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
2039 }
2040 }
2041 *parentMatch0 = match;
2042 }
2043 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2044
2045
2046
2047
2048
2049 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2050 if (!match.hit)
2051 {
2052 match.value = nullptr;
2053 }
2054 return match;
2055 }
2056
2057 soulng::parser::Match BuildLangClientParser::Host(BuildLangLexer& lexer)
2058 {
2059 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2060
2061
2062
2063
2064
2065
2066
2067 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2068 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>hostName;
2069 std::unique_ptr<soulng::parser::soulng::parser::Value<std::string>>ipAddress;
2070 soulng::parser::Match match(false);
2071 soulng::parser::Match* parentMatch0 = &match;
2072 {
2073 int64_t save = lexer.GetPos();
2074 soulng::parser::Match match(false);
2075 soulng::parser::Match* parentMatch1 = &match;
2076 {
2077 int64_t pos = lexer.GetPos();
2078 soulng::parser::Match match = BuildLangClientParser::HostName(lexer);
2079 hostName.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
2080 if (match.hit)
2081 {
2082 {
2083 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2084
2085 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2086 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(hostName->value));
2087 }
2088 }
2089 *parentMatch1 = match;
2090 }
2091 *parentMatch0 = match;
2092 if (!match.hit)
2093 {
2094 soulng::parser::Match match(false);
2095 soulng::parser::Match* parentMatch2 = &match;
2096 lexer.SetPos(save);
2097 {
2098 soulng::parser::Match match(false);
2099 soulng::parser::Match* parentMatch3 = &match;
2100 {
2101 int64_t pos = lexer.GetPos();
2102 soulng::parser::Match match = BuildLangClientParser::IpAddress(lexer);
2103 ipAddress.reset(static_cast<soulng::parser::soulng::parser::Value<std::string>*>(match.value));
2104 if (match.hit)
2105 {
2106 {
2107 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2108
2109 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2110 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ipAddress->value));
2111 }
2112 }
2113 *parentMatch3 = match;
2114 }
2115 *parentMatch2 = match;
2116 }
2117 *parentMatch0 = match;
2118 }
2119 }
2120 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2121
2122
2123
2124
2125
2126 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2127 if (!match.hit)
2128 {
2129 match.value = nullptr;
2130 }
2131 return match;
2132 }
2133
2134 soulng::parser::Match BuildLangClientParser::HostName(BuildLangLexer& lexer)
2135 {
2136 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2137
2138
2139
2140
2141
2142
2143
2144 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2145 std::string hostName = std::string();
2146 soulng::parser::Match match(false);
2147 soulng::parser::Match* parentMatch0 = &match;
2148 {
2149 int64_t pos = lexer.GetPos();
2150 soulng::parser::Match match(false);
2151 soulng::parser::Match* parentMatch1 = &match;
2152 {
2153 soulng::parser::Match match(false);
2154 soulng::parser::Match* parentMatch2 = &match;
2155 {
2156 soulng::parser::Match match(false);
2157 soulng::parser::Match* parentMatch3 = &match;
2158 {
2159 int64_t pos = lexer.GetPos();
2160 soulng::parser::Match match(false);
2161 if (*lexer == ID)
2162 {
2163 ++lexer;
2164 match.hit = true;
2165 }
2166 if (match.hit)
2167 {
2168 hostName.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2169 }
2170 *parentMatch3 = match;
2171 }
2172 *parentMatch2 = match;
2173 }
2174 if (match.hit)
2175 {
2176 soulng::parser::Match match(false);
2177 soulng::parser::Match* parentMatch4 = &match;
2178 {
2179 soulng::parser::Match match(true);
2180 soulng::parser::Match* parentMatch5 = &match;
2181 {
2182 while (true)
2183 {
2184 int64_t save = lexer.GetPos();
2185 {
2186 soulng::parser::Match match(false);
2187 soulng::parser::Match* parentMatch6 = &match;
2188 {
2189 soulng::parser::Match match(false);
2190 soulng::parser::Match* parentMatch7 = &match;
2191 {
2192 soulng::parser::Match match(false);
2193 soulng::parser::Match* parentMatch8 = &match;
2194 {
2195 int64_t pos = lexer.GetPos();
2196 soulng::parser::Match match(false);
2197 if (*lexer == DOT)
2198 {
2199 ++lexer;
2200 match.hit = true;
2201 }
2202 if (match.hit)
2203 {
2204 hostName.append(1, '.');
2205 }
2206 *parentMatch8 = match;
2207 }
2208 *parentMatch7 = match;
2209 }
2210 if (match.hit)
2211 {
2212 soulng::parser::Match match(false);
2213 soulng::parser::Match* parentMatch9 = &match;
2214 {
2215 soulng::parser::Match match(false);
2216 soulng::parser::Match* parentMatch10 = &match;
2217 {
2218 int64_t pos = lexer.GetPos();
2219 soulng::parser::Match match(false);
2220 if (*lexer == ID)
2221 {
2222 ++lexer;
2223 match.hit = true;
2224 }
2225 if (match.hit)
2226 {
2227 hostName.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2228 }
2229 *parentMatch10 = match;
2230 }
2231 *parentMatch9 = match;
2232 }
2233 *parentMatch7 = match;
2234 }
2235 *parentMatch6 = match;
2236 }
2237 if (match.hit)
2238 {
2239 *parentMatch5 = match;
2240 }
2241 else
2242 {
2243 lexer.SetPos(save);
2244 break;
2245 }
2246 }
2247 }
2248 }
2249 *parentMatch4 = match;
2250 }
2251 *parentMatch2 = match;
2252 }
2253 *parentMatch1 = match;
2254 }
2255 if (match.hit)
2256 {
2257 {
2258 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2259
2260 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2261 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(hostName));
2262 }
2263 }
2264 *parentMatch0 = match;
2265 }
2266 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2267
2268
2269
2270
2271
2272 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2273 if (!match.hit)
2274 {
2275 match.value = nullptr;
2276 }
2277 return match;
2278 }
2279
2280 soulng::parser::Match BuildLangClientParser::IpAddress(BuildLangLexer& lexer)
2281 {
2282 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2283
2284
2285
2286
2287
2288
2289
2290 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2291 std::string ip = std::string();
2292 soulng::parser::Match match(false);
2293 soulng::parser::Match* parentMatch0 = &match;
2294 {
2295 int64_t pos = lexer.GetPos();
2296 soulng::parser::Match match(false);
2297 soulng::parser::Match* parentMatch1 = &match;
2298 {
2299 soulng::parser::Match match(false);
2300 soulng::parser::Match* parentMatch2 = &match;
2301 {
2302 soulng::parser::Match match(false);
2303 soulng::parser::Match* parentMatch3 = &match;
2304 {
2305 soulng::parser::Match match(false);
2306 soulng::parser::Match* parentMatch4 = &match;
2307 {
2308 soulng::parser::Match match(false);
2309 soulng::parser::Match* parentMatch5 = &match;
2310 {
2311 soulng::parser::Match match(false);
2312 soulng::parser::Match* parentMatch6 = &match;
2313 {
2314 soulng::parser::Match match(false);
2315 soulng::parser::Match* parentMatch7 = &match;
2316 {
2317 soulng::parser::Match match(false);
2318 soulng::parser::Match* parentMatch8 = &match;
2319 {
2320 int64_t pos = lexer.GetPos();
2321 soulng::parser::Match match(false);
2322 if (*lexer == INTEGER)
2323 {
2324 ++lexer;
2325 match.hit = true;
2326 }
2327 if (match.hit)
2328 {
2329 ip.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2330 }
2331 *parentMatch8 = match;
2332 }
2333 *parentMatch7 = match;
2334 }
2335 if (match.hit)
2336 {
2337 soulng::parser::Match match(false);
2338 soulng::parser::Match* parentMatch9 = &match;
2339 {
2340 soulng::parser::Match match(false);
2341 soulng::parser::Match* parentMatch10 = &match;
2342 {
2343 int64_t pos = lexer.GetPos();
2344 soulng::parser::Match match(false);
2345 if (*lexer == DOT)
2346 {
2347 ++lexer;
2348 match.hit = true;
2349 }
2350 if (match.hit)
2351 {
2352 ip.append(1, '.');
2353 }
2354 *parentMatch10 = match;
2355 }
2356 *parentMatch9 = match;
2357 }
2358 *parentMatch7 = match;
2359 }
2360 *parentMatch6 = match;
2361 }
2362 if (match.hit)
2363 {
2364 soulng::parser::Match match(false);
2365 soulng::parser::Match* parentMatch11 = &match;
2366 {
2367 soulng::parser::Match match(false);
2368 soulng::parser::Match* parentMatch12 = &match;
2369 {
2370 int64_t pos = lexer.GetPos();
2371 soulng::parser::Match match(false);
2372 if (*lexer == INTEGER)
2373 {
2374 ++lexer;
2375 match.hit = true;
2376 }
2377 if (match.hit)
2378 {
2379 ip.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2380 }
2381 *parentMatch12 = match;
2382 }
2383 *parentMatch11 = match;
2384 }
2385 *parentMatch6 = match;
2386 }
2387 *parentMatch5 = match;
2388 }
2389 if (match.hit)
2390 {
2391 soulng::parser::Match match(false);
2392 soulng::parser::Match* parentMatch13 = &match;
2393 {
2394 soulng::parser::Match match(false);
2395 soulng::parser::Match* parentMatch14 = &match;
2396 {
2397 int64_t pos = lexer.GetPos();
2398 soulng::parser::Match match(false);
2399 if (*lexer == DOT)
2400 {
2401 ++lexer;
2402 match.hit = true;
2403 }
2404 if (match.hit)
2405 {
2406 ip.append(1, '.');
2407 }
2408 *parentMatch14 = match;
2409 }
2410 *parentMatch13 = match;
2411 }
2412 *parentMatch5 = match;
2413 }
2414 *parentMatch4 = match;
2415 }
2416 if (match.hit)
2417 {
2418 soulng::parser::Match match(false);
2419 soulng::parser::Match* parentMatch15 = &match;
2420 {
2421 soulng::parser::Match match(false);
2422 soulng::parser::Match* parentMatch16 = &match;
2423 {
2424 int64_t pos = lexer.GetPos();
2425 soulng::parser::Match match(false);
2426 if (*lexer == INTEGER)
2427 {
2428 ++lexer;
2429 match.hit = true;
2430 }
2431 if (match.hit)
2432 {
2433 ip.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2434 }
2435 *parentMatch16 = match;
2436 }
2437 *parentMatch15 = match;
2438 }
2439 *parentMatch4 = match;
2440 }
2441 *parentMatch3 = match;
2442 }
2443 if (match.hit)
2444 {
2445 soulng::parser::Match match(false);
2446 soulng::parser::Match* parentMatch17 = &match;
2447 {
2448 soulng::parser::Match match(false);
2449 soulng::parser::Match* parentMatch18 = &match;
2450 {
2451 int64_t pos = lexer.GetPos();
2452 soulng::parser::Match match(false);
2453 if (*lexer == DOT)
2454 {
2455 ++lexer;
2456 match.hit = true;
2457 }
2458 if (match.hit)
2459 {
2460 ip.append(1, '.');
2461 }
2462 *parentMatch18 = match;
2463 }
2464 *parentMatch17 = match;
2465 }
2466 *parentMatch3 = match;
2467 }
2468 *parentMatch2 = match;
2469 }
2470 if (match.hit)
2471 {
2472 soulng::parser::Match match(false);
2473 soulng::parser::Match* parentMatch19 = &match;
2474 {
2475 soulng::parser::Match match(false);
2476 soulng::parser::Match* parentMatch20 = &match;
2477 {
2478 int64_t pos = lexer.GetPos();
2479 soulng::parser::Match match(false);
2480 if (*lexer == INTEGER)
2481 {
2482 ++lexer;
2483 match.hit = true;
2484 }
2485 if (match.hit)
2486 {
2487 ip.append(ToUtf8(lexer.GetToken(pos).match.ToString()));
2488 }
2489 *parentMatch20 = match;
2490 }
2491 *parentMatch19 = match;
2492 }
2493 *parentMatch2 = match;
2494 }
2495 *parentMatch1 = match;
2496 }
2497 if (match.hit)
2498 {
2499 {
2500 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2501
2502 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2503 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ip));
2504 }
2505 }
2506 *parentMatch0 = match;
2507 }
2508 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2509
2510
2511
2512
2513
2514 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2515 if (!match.hit)
2516 {
2517 match.value = nullptr;
2518 }
2519 return match;
2520 }
2521
2522 soulng::parser::Match BuildLangClientParser::Port(BuildLangLexer& lexer)
2523 {
2524 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2525
2526
2527
2528
2529
2530
2531
2532 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2533 std::string portStr = std::string();
2534 soulng::parser::Match match(false);
2535 soulng::parser::Match* parentMatch0 = &match;
2536 {
2537 int64_t pos = lexer.GetPos();
2538 soulng::parser::Match match(false);
2539 if (*lexer == INTEGER)
2540 {
2541 ++lexer;
2542 match.hit = true;
2543 }
2544 if (match.hit)
2545 {
2546 portStr = ToUtf8(lexer.GetToken(pos).match.ToString());
2547 {
2548 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2549
2550 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2551 return soulng::parser::Match(true, new soulng::parser::Value<int>(std::stoi(portStr)));
2552 }
2553 }
2554 *parentMatch0 = match;
2555 }
2556 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2557
2558
2559
2560
2561
2562 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2563 if (!match.hit)
2564 {
2565 match.value = nullptr;
2566 }
2567 return match;
2568 }
2569
2570 soulng::parser::Match BuildLangClientParser::ToolChain(BuildLangLexer& lexer)
2571 {
2572 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2573
2574
2575
2576
2577
2578
2579
2580 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2581 soulng::parser::Match match(false);
2582 int64_t pos = lexer.GetPos();
2583 soulng::lexer::Span span = lexer.GetSpan();
2584 switch (*lexer)
2585 {
2586 case CLANG:
2587 {
2588 ++lexer;
2589 {
2590 {
2591 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2592
2593 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2594 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
2595 }
2596 }
2597 break;
2598 }
2599 case GCC:
2600 {
2601 ++lexer;
2602 {
2603 {
2604 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2605
2606 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2607 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
2608 }
2609 }
2610 break;
2611 }
2612 case VS:
2613 {
2614 ++lexer;
2615 {
2616 {
2617 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2618
2619 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2620 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
2621 }
2622 }
2623 break;
2624 }
2625 case ID:
2626 {
2627 ++lexer;
2628 {
2629 {
2630 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2631
2632 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2633 return soulng::parser::Match(true, new soulng::parser::Value<std::string>(ToUtf8(lexer.GetToken(pos).match.ToString())));
2634 }
2635 }
2636 break;
2637 }
2638 }
2639 #ifdef SOULNG_PARSER_DEBUG_SUPPORT
2640
2641
2642
2643
2644
2645 #endif // SOULNG_PARSER_DEBUG_SUPPORT
2646 if (!match.hit)
2647 {
2648 match.value = nullptr;
2649 }
2650 return match;
2651 }