Slice states.
Prototype scanner states comment parsing states C++20 concepts Object-C Deprecated C++20 modules
515 {
516 if (!yyextra->insideObjC) REJECT;
517 }
518<*>"DEPRECATED_MSG_ATTRIBUTE(\"" { // Object-C attribute
519 if (!yyextra->insideObjC) REJECT;
520 yyextra->lastDeprecatedContext=YY_START;
521 yyextra->lastStringContext=Deprecated_round;
522 BEGIN(SkipString);
523 }
524<Deprecated_round>")" {
525 BEGIN(yyextra->lastDeprecatedContext);
526 }
527<Deprecated_round>{BNopt} {
529 }
530<Deprecated_round>. { }
531<NextSemi>"{" {
532 yyextra->curlyCount=0;
533 yyextra->needsSemi =
TRUE;
534 BEGIN(SkipCurlyBlock);
535 }
536<NextSemi>"(" {
537 yyextra->roundCount=0;
538 BEGIN(SkipRoundBlock);
539 }
540<SkipRoundBlock>"(" {
541 ++yyextra->roundCount;
542 }
543<SkipRoundBlock>")" {
544 if (yyextra->roundCount )
545 --yyextra->roundCount ;
546 else
547 BEGIN( NextSemi ) ;
548 }
549<SkipCurlyBlock>"{" {
550 ++yyextra->curlyCount ;
551 }
552<SkipCurlyBlock>"}" {
553 if( yyextra->curlyCount )
554 {
555 --yyextra->curlyCount ;
556 }
557 else if (yyextra->needsSemi)
558 {
559 BEGIN( NextSemi );
560 }
561 else
562 {
563 BEGIN( FindMembers );
564 }
565 }
566<NextSemi>\' {
567 if (yyextra->insidePHP)
568 {
569 yyextra->lastStringContext=NextSemi;
570 BEGIN(SkipPHPString);
571 }
572 }
573<NextSemi>{CHARLIT} { if (yyextra->insidePHP) REJECT; }
574<NextSemi>\" {
575 yyextra->lastStringContext=NextSemi;
576 BEGIN(SkipString);
577 }
578<NextSemi>[;,] {
579 unput(*yytext);
580 BEGIN( FindMembers );
581 }
582<BitFields>[;,] {
583 unput(*yytext);
584 BEGIN( FindMembers );
585 }
586<EnumBaseType>[{;,] {
587 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
588 unput(*yytext);
589 BEGIN( ClassVar );
590 }
591<FindMembers>"<?php" { // PHP code with unsupported extension?
592 yyextra->insidePHP =
TRUE;
593 }
594<FindMembersPHP>"<?"("php"?) { // PHP code start
595 BEGIN( FindMembers );
596 }
597<FindMembersPHP>"<script"{BN}+"language"{BN}*"="{BN}*['"]?"php"['"]?{BN}*">" { // PHP code start
599 BEGIN( FindMembers );
600 }
601<FindMembers>"?>"|"</script>" { // PHP code end
602 if (yyextra->insidePHP)
603 BEGIN( FindMembersPHP );
604 else
605 REJECT;
606 }
607<FindMembersPHP>[^\n<]+ { // Non-PHP code text, ignore
608 }
609<FindMembersPHP>\n { // Non-PHP code text, ignore
611 }
612<FindMembersPHP>. { // Non-PHP code text, ignore
613 }
614<FindMembers>{PHPKW} { if (yyextra->insidePHP)
615 BEGIN( NextSemi );
616 else
617 REJECT;
618 }
619<FindMembers>"%{"[^\n]* { // Mozilla XPIDL lang-specific block
620 if (!yyextra->insideIDL)
621 REJECT;
622 }
623<FindMembers>"%}" { // Mozilla XPIDL lang-specific block end
624 if (!yyextra->insideIDL)
625 REJECT;
626 }
627<FindMembers>{B}*("properties"){BN}*":"{BN}* { // IDL or Borland C++ builder property
629 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
630 }
static void initMethodProtection(yyscan_t yyscanner, Protection prot)
631
632<FindMembers>{B}*"k_dcop"{BN}*":"{BN}* {
634 yyextra->current->mtype = yyextra->mtype = MethodTypes::DCOP;
635 }
636
637<FindMembers>{B}*("signals"|"Q_SIGNALS"){BN}*":"{BN}* {
639 yyextra->current->mtype = yyextra->mtype = MethodTypes::Signal;
640 }
641
642<FindMembers>{B}*"public"{BN}*("slots"|"Q_SLOTS"){BN}*":"{BN}* {
644 yyextra->current->mtype = yyextra->mtype = MethodTypes::Slot;
645 }
646
647<FindMembers>{B}*"protected"{BN}*("slots"|"Q_SLOTS"){BN}*":"{BN}* {
649 yyextra->current->mtype = yyextra->mtype = MethodTypes::Slot;
650 }
651
652<FindMembers>{B}*"private"{BN}*("slots"|"Q_SLOTS"){BN}*":"{BN}* {
654 yyextra->current->mtype = yyextra->mtype = MethodTypes::Slot;
655 }
656<FindMembers>{B}*("public"|"methods"|"__published"){BN}*":"{BN}* {
658 }
659<FindMembers>{B}*"internal"{BN}*":"{BN}* { // for now treat C++/CLI's internal as package...
660 if (yyextra->insideCli)
661 {
663 }
664 else
665 {
666 REJECT;
667 }
668 }
669<FindMembers>{B}*"protected"{BN}*":"{BN}* {
671 }
672<FindMembers>{B}*"private"{BN}*":"{BN}* {
674 }
675<FindMembers>{B}*"public"/({BN}|{CCS}|{CPPC}) {
676 if (!yyextra->insideCpp) REJECT;
678 BEGIN(CppProt);
679 }
680<FindMembers>{B}*"protected"/({BN}|{CCS}|{CPPC}) {
681 if (!yyextra->insideCpp) REJECT;
683 BEGIN(CppProt);
684 }
685<FindMembers>{B}*"private"/({BN}|{CCS}|{CPPC}) {
686 if (!yyextra->insideCpp) REJECT;
688 BEGIN(CppProt);
689 }
690<CppProt>":" {
691 BEGIN(FindMembers);
692 }
693<CppProt>. {
694 unput(*yytext);
695 BEGIN(FindMembers);
696 }
697<CppProt>{BN}+ { lineCount(yyscanner); }
698<CppProt>{CPPC}.*\n { lineCount(yyscanner); }
699<CppProt>{CCS} { yyextra->lastCContext = YY_START ;
700 BEGIN( SkipComment ) ;
701 }
702<CppProt>("slots"|"Q_SLOTS") {
703 yyextra->current->mtype = yyextra->mtype = MethodTypes::Slot;
704 }
705<FindMembers>{B}*"event"{BN}+ {
706 if (yyextra->insideCli)
707 {
708
710 yyextra->current->mtype = yyextra->mtype = MethodTypes::Event;
711 yyextra->current->bodyLine = yyextra->yyLineNr;
712 yyextra->current->bodyColumn = yyextra->yyColNr;
713 yyextra->curlyCount=0;
714 BEGIN( CliPropertyType );
715 }
716 else if (yyextra->insideCS)
717 {
719 yyextra->current->mtype = MethodTypes::Event;
720 yyextra->current->bodyLine = yyextra->yyLineNr;
721 yyextra->current->bodyColumn = yyextra->yyColNr;
722 }
723 else
724 {
725 REJECT;
726 }
727 }
728<FindMembers>{B}*"property"{BN}+ {
729 if (yyextra->insideCli)
730 {
731
733 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
734 yyextra->current->bodyLine = yyextra->yyLineNr;
735 yyextra->current->bodyColumn = yyextra->yyColNr;
736 yyextra->curlyCount=0;
737 BEGIN( CliPropertyType );
738 }
739 else
740 {
741 REJECT;
742 }
743 }
744<CliPropertyType>{ID} {
746 yyextra->current->name = yytext;
747 }
static void addType(yyscan_t yyscanner)
748<CliPropertyType>"[" { // C++/CLI indexed property
749 yyextra->current->args = "[";
750 BEGIN( CliPropertyIndex );
751 }
752<CliPropertyType>"{" {
753 yyextra->curlyCount=0;
754
755 BEGIN( CSAccessorDecl );
756 }
757<CliPropertyType>";" {
758 unput(*yytext);
759 BEGIN( FindMembers );
760 }
761<CliPropertyType>\n {
763 }
764<CliPropertyType>{B}* {
765 }
766<CliPropertyType>. {
768 yyextra->current->type += yytext;
769 }
770<CliPropertyIndex>"]" {
771 BEGIN( CliPropertyType );
772 yyextra->current->args+=yytext;
773 }
774<CliPropertyIndex>. {
775 yyextra->current->args+=yytext;
776 }
777
778<FindMembers>{B}*"property"{BN}+ {
779 if (!yyextra->current->type.isEmpty())
780 {
781 REJECT;
782 }
783 else
784 {
785 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
787 }
788 }
789 */
790<FindMembers>{B}*"@private"{BN}+ {
792 }
793<FindMembers>{B}*"@protected"{BN}+ {
795 }
796<FindMembers>{B}*"@public"{BN}+ {
798 }
799<FindMembers>[\-+]{BN}* {
800 if (!yyextra->insideObjC)
801 {
802 REJECT;
803 }
804 else
805 {
806 yyextra->current->fileName = yyextra->fileName;
807 yyextra->current->startLine = yyextra->yyLineNr;
808 yyextra->current->startColumn = yyextra->yyColNr;
809 yyextra->current->bodyLine = yyextra->yyLineNr;
810 yyextra->current->bodyColumn = yyextra->yyColNr;
811 yyextra->current->section = EntryType::makeFunction();
812 yyextra->language = yyextra->current->lang = SrcLangExt::ObjC;
813 yyextra->insideObjC =
TRUE;
814 yyextra->yyBegColNr = yyextra->yyColNr;
815 yyextra->yyBegLineNr = yyextra->yyLineNr;
816 yyextra->current->virt = Specifier::Virtual;
817
818 yyextra->current->isStatic=yytext[0]=='+';
820 BEGIN( ObjCMethod );
821 }
822 }
823<ObjCMethod>"(" { // start of method's return type
824 BEGIN( ObjCReturnType );
825 yyextra->current->type.clear();
826 yyextra->roundCount=0;
827 }
828<ObjCMethod>{ID} { // found method name
829 if (yyextra->current->type.isEmpty())
830 {
831 yyextra->current->type += "id";
832 }
833 yyextra->current->name = yytext;
835 }
static void storeClangId(yyscan_t yyscanner, const char *id)
836<ObjCMethod>":"{B}* { // start of parameter list
837 yyextra->current->name += ':';
839 yyextra->current->argList.push_back(a);
840 BEGIN( ObjCParams );
841 }
842<ObjCReturnType>[^()]* {
843 yyextra->current->type += yytext;
844 }
845<ObjCReturnType>"(^)(" { // Block return type
846 yyextra->current->type += yytext;
847 yyextra->roundCount++;
848 }
849<ObjCReturnType>"(" {
850 yyextra->current->type += yytext;
851 yyextra->roundCount++;
852 }
853<ObjCReturnType>")" {
854 if (yyextra->roundCount<=0)
855 {
856 BEGIN( ObjCMethod );
857 }
858 else
859 {
860 yyextra->current->type += yytext;
861 yyextra->roundCount--;
862 }
863 }
864<ObjCParams>({ID})?{BN}*":" { // Keyword of parameter
868 {
869 yyextra->current->name += " :";
870 }
871 else
872 {
873 yyextra->current->name += keyw+":";
874 }
875 if (yyextra->current->argList.back().type.isEmpty())
876 {
877 yyextra->current->argList.back().type="id";
878 }
881 yyextra->current->argList.push_back(a);
882 }
883<ObjCParams>{ID}{BN}* { // name of parameter
886 }
887<ObjCParams>","{BN}*"..." { // name of parameter
889
890
894 yyextra->current->argList.push_back(a);
895 }
896
897<ObjCParams>":" {
898 yyextra->current->name += ':';
899 }
900 */
901<ObjCParams>"(" {
902 yyextra->roundCount=0;
903 yyextra->current->argList.back().type.clear();
904 BEGIN( ObjCParamType );
905 }
906<ObjCParamType>"(" {
907 yyextra->roundCount++;
908 yyextra->current->argList.back().type+=yytext;
909 }
910<ObjCParamType>")"/{B}* {
911 if (yyextra->roundCount<=0)
912 {
913 BEGIN( ObjCParams );
914 }
915 else
916 {
917 yyextra->current->argList.back().type+=yytext;
918 yyextra->roundCount--;
919 }
920 }
921<ObjCParamType>[^()]* {
923 }
924<ObjCMethod,ObjCParams>";" { // end of method declaration
925 if (!yyextra->current->argList.empty() && yyextra->current->argList.back().type.isEmpty())
926 {
927 yyextra->current->argList.back().type="id";
928 }
929 if (yyextra->current->argList.empty())
930 {
931 yyextra->current->argList.setNoParameters(
TRUE);
932 }
934
935 unput(';');
936 BEGIN( SFunction );
937 }
QCString argListToString(const ArgumentList &al, bool useCanonicalType, bool showDefVals)
938<ObjCMethod,ObjCParams>(";"{BN}+)?"{" { // start of a method body
940
941
942
943 if (!yyextra->current->argList.empty() && yyextra->current->argList.back().type.isEmpty())
944 {
945 yyextra->current->argList.back().type="id";
946 }
947 if (yyextra->current->argList.empty())
948 {
949 yyextra->current->argList.setNoParameters(
TRUE);
950 }
952 unput('{');
953 BEGIN( SFunction );
954 }
955<FindMembers>{B}*"sequence"{BN}*"<"{BN}* {
956 if (yyextra->insideSlice)
957 {
959 yyextra->current->bodyLine = yyextra->yyLineNr;
960 yyextra->current->bodyColumn = yyextra->yyColNr;
961 yyextra->current->fileName = yyextra->fileName ;
962 yyextra->current->startLine = yyextra->yyLineNr ;
963 yyextra->current->startColumn = yyextra->yyColNr;
964 yyextra->current->args.clear();
965 yyextra->current->section = EntryType::makeTypedef();
966 yyextra->isTypedef =
TRUE;
967 BEGIN( SliceSequence );
968 }
969 else
970 REJECT;
971 }
972<FindMembers>{B}*"dictionary"{BN}*"<"{BN}* {
973 if (yyextra->insideSlice)
974 {
976 yyextra->current->bodyLine = yyextra->yyLineNr;
977 yyextra->current->bodyColumn = yyextra->yyColNr;
978 yyextra->current->fileName = yyextra->fileName ;
979 yyextra->current->startLine = yyextra->yyLineNr ;
980 yyextra->current->startColumn = yyextra->yyColNr;
981 yyextra->current->args.clear();
982 yyextra->current->section = EntryType::makeTypedef() ;
983 yyextra->isTypedef =
TRUE;
984 BEGIN( SliceDictionary );
985 }
986 else
987 REJECT;
988 }
989<FindMembers>{BN}{1,80} {
991 }
992<FindMembers>"@"({ID}".")*{ID}{BN}*"(" {
993 if (yyextra->insideJava)
994 {
996 yyextra->lastSkipRoundContext = YY_START;
997 yyextra->roundCount=0;
998 BEGIN( SkipRound );
999 }
1001 {
1002 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
1003 yyextra->current->spec.setReadable(true).setWritable(true).setAssign(true);
1004 yyextra->current->protection = Protection::Public ;
1005 unput('(');
1006 BEGIN( ObjCPropAttr );
1007 }
1008 else
1009 {
1010 REJECT;
1011 }
1012 }
bool literal_at(const char *data, const char(&str)[N])
returns TRUE iff data points to a substring that matches string literal str
1013<ObjCPropAttr>"getter="{ID} {
1014 yyextra->current->read = yytext+7;
1015 }
1016<ObjCPropAttr>"setter="{ID} {
1017 yyextra->current->write = yytext+7;
1018 }
1019<ObjCPropAttr>"readonly" {
1020 yyextra->current->spec.setWritable(false);
1021 }
1022<ObjCPropAttr>"readwrite" { // default
1023 }
1024<ObjCPropAttr>"assign" { // default
1025 }
1026<ObjCPropAttr>"unsafe_unretained" {
1027 yyextra->current->spec.setAssign(false);
1028 yyextra->current->spec.setUnretained(true);
1029 }
1030<ObjCPropAttr>"retain" {
1031 yyextra->current->spec.setAssign(false);
1032 yyextra->current->spec.setRetain(true);
1033 }
1034<ObjCPropAttr>"copy" {
1035 yyextra->current->spec.setAssign(false);
1036 yyextra->current->spec.setCopy(true);
1037 }
1038<ObjCPropAttr>"weak" {
1039 yyextra->current->spec.setAssign(false);
1040 yyextra->current->spec.setWeak(true);
1041 }
1042<ObjCPropAttr>"strong" {
1043 yyextra->current->spec.setAssign(false);
1044 yyextra->current->spec.setStrong(true);
1045 }
1046<ObjCPropAttr>"nonatomic" {
1047 yyextra->current->spec.setNonAtomic(true);
1048 }
1049<ObjCPropAttr>")" {
1050 BEGIN(FindMembers);
1051 }
1052<FindMembers>"@"{ID}("."{ID})+ {
1053 if (yyextra->insideJava)
1054 {
1055
1056 }
1057 else
1058 {
1059 REJECT;
1060 }
1061 }
1062<FindMembers>"@"{ID} {
1063 if (yyextra->insideJava)
1064 {
1065
1066 }
1067 else if (
qstrcmp(yytext,
"@property")==0)
1068 {
1069 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
1070 yyextra->current->spec.setWritable(true).setReadable(true);
1071 yyextra->current->protection = Protection::Public ;
1072 }
1073 else if (
qstrcmp(yytext,
"@synthesize")==0)
1074 {
1075 BEGIN( ObjCSkipStatement );
1076 }
1077 else if (
qstrcmp(yytext,
"@dynamic")==0)
1078 {
1079 BEGIN( ObjCSkipStatement );
1080 }
1081 else
1082 {
1083 REJECT;
1084 }
1085 }
int qstrcmp(const char *str1, const char *str2)
1086<ObjCSkipStatement>";" {
1087 BEGIN(FindMembers);
1088 }
1089<PackageName>{ID}(("."|"\\"){ID})* {
1090 yyextra->isTypedef=
FALSE;
1091
1092 yyextra->current->name = yytext;
1093 yyextra->current->name =
substitute(yyextra->current->name,
".",
"::");
1094 yyextra->current->name =
substitute(yyextra->current->name,
"\\",
"::");
1095 yyextra->current->section = EntryType::makeNamespace();
1096 yyextra->current->type = "namespace" ;
1097 yyextra->current->fileName = yyextra->fileName;
1098 yyextra->current->startLine = yyextra->yyLineNr;
1099 yyextra->current->startColumn = yyextra->yyColNr;
1100 yyextra->current->bodyLine = yyextra->yyLineNr;
1101 yyextra->current->bodyColumn = yyextra->yyColNr;
1103 }
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
1105 std::shared_ptr<Entry> tmp = yyextra->current;
1106 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
1107 yyextra->current_root = std::move(tmp);
1109 BEGIN(FindMembers);
1110 }
1112 yyextra->curlyCount=0;
1113 BEGIN( ReadNSBody );
1114 }
1115<FindMembers>{B}*"export"{BN}+"module"{BN}+ { // primary module interface unit
1116 if (!yyextra->insideCpp) REJECT;
1117
1118 yyextra->current->exported = true;
1120 BEGIN( ModuleName );
1121 }
1122<FindMembers>{B}*"module"{BN}*";" { // global module section
1123 if (!yyextra->insideCpp) REJECT;
1124 if (!yyextra->current->type.isEmpty() || !yyextra->current->name.isEmpty()) REJECT;
1125
1127 BEGIN( FindMembers );
1128 }
1129<FindMembers>{B}*"module"{BN}+ { // module implementation unit
1130 if (!yyextra->insideCpp) REJECT;
1131
1132 yyextra->current->exported = false;
1134 BEGIN( ModuleName );
1135 }
1136<FindMembers>{B}*"export"{BN}+"import"{BN}+ { // export an imported module
1137 if (!yyextra->insideCpp) REJECT;
1138 yyextra->current->exported = true;
1140 BEGIN( ModuleImport );
1141 }
1142<FindMembers>{B}*"import"{BN}+ { // start of a module import
1143 if (!yyextra->insideCpp) REJECT;
1145 BEGIN( ModuleImport );
1146 }
1147<ModuleName>{MODULE_ID}{BN}*":"{BN}*{MODULE_ID} { // module partition name, e.g. A.B:C.D'
1149 int i = name.
find(
':');
1153 yyextra->yyLineNr,
1154 yyextra->yyColNr,
1155 yyextra->current->exported,
1156 name,
1157 partition);
1158 yyextra->current->section = EntryType::makeModuleDoc();
1159 yyextra->isTypedef=
FALSE;
1161 yyextra->current->type += " module";
1162 yyextra->current->fileName = yyextra->fileName;
1163 yyextra->current->startLine = yyextra->yyLineNr;
1164 yyextra->current->startColumn = yyextra->yyColNr;
1165 yyextra->current->bodyLine = yyextra->yyLineNr;
1166 yyextra->current->bodyColumn = yyextra->yyColNr;
1167 yyextra->current->name = name+":"+partition;
1169 }
static ModuleManager & instance()
void createModuleDef(const QCString &fileName, int line, int column, bool exported, const QCString &moduleName, const QCString &partitionName=QCString())
1170<ModuleName>{MODULE_ID} { // primary module name, e.g. A.B
1172 yyextra->yyLineNr,
1173 yyextra->yyColNr,
1174 yyextra->current->exported,
1175 yytext);
1176 yyextra->current->section = EntryType::makeModuleDoc();
1177 yyextra->isTypedef=
FALSE;
1179 yyextra->current->type += " module";
1180 yyextra->current->fileName = yyextra->fileName;
1181 yyextra->current->startLine = yyextra->yyLineNr;
1182 yyextra->current->startColumn = yyextra->yyColNr;
1183 yyextra->current->bodyLine = yyextra->yyLineNr;
1184 yyextra->current->bodyColumn = yyextra->yyColNr;
1185 yyextra->current->name = yytext;
1187 }
1188<ModuleName>":"{BN}+"private" { // start of private section of the module interface
1189 yyextra->current->exported = yyextra->exported = false;
1191 }
1192<ModuleName>";" { unput(';');
1193 BEGIN(FindMembers);
1194 }
1195<ModuleName>\n { lineCount(yyscanner); }
1196<ModuleName>. {}
1197<ModuleImport>"\""[^"\n]*"\"" { // local header import
1199 yyextra->yyLineNr,
1201 false);
1202 }
void addHeader(const QCString &moduleFile, int line, const QCString &headerName, bool isSystem)
1203<ModuleImport>"<"[^>\n]*">" { // system header import
1205 yyextra->yyLineNr,
1207 true);
1208 }
1209<ModuleImport>{MODULE_ID}?{BN}*":"{BN}*{MODULE_ID} { // module partition import
1211 int i = name.
find(
':');
1215 yyextra->yyLineNr,
1216 name,
1217 yyextra->current->exported,
1218 partition);
1220 }
void addImport(const QCString &moduleFile, int line, const QCString &importName, bool isExported, const QCString &partitionName=QCString())
1221<ModuleImport>{MODULE_ID} { // module import
1223 yyextra->yyLineNr,
1224 yytext,
1225 yyextra->current->exported);
1227 }
1228<ModuleImport>";" { BEGIN(FindMembers); }
1229<ModuleImport>\n { lineCount(yyscanner); }
1230<ModuleImport>. {}
1231<FindMembers>{B}*"export"{BN}+"{" {
1232 yyextra->current->exported = yyextra->exported = true;
1233 }
1234<FindMembers>{B}*"export"{BN}+ {
1235 if (!yyextra->insideCpp) REJECT;
1236 yyextra->current->exported=true;
1237 }
1238<FindMembers>{B}*"initonly"{BN}+ { if (yyextra->insideJava || yyextra->insideCpp) REJECT;
1239 yyextra->current->type += " initonly ";
1240 if (yyextra->insideCli) yyextra->current->spec.setInitonly(true);
1242 }
1243<FindMembers>{B}*"static"{BN}*/"{" { yyextra->current->type += " static ";
1244 yyextra->current->isStatic =
TRUE;
1246 }
1247<FindMembers>{B}*"static"{BN}+ { yyextra->current->type += " static ";
1248 yyextra->current->isStatic =
TRUE;
1250 }
1251<FindMembers>{B}*"extern"{BN}+ { if (yyextra->insideJava) REJECT;
1252 yyextra->current->isStatic =
FALSE;
1253 yyextra->current->explicitExternal =
TRUE;
1255 }
1256<FindMembers>{B}*"const"{BN}+ { if (yyextra->insideCS)
1257 {
1258 yyextra->current->type += " const ";
1259 if (yyextra->insideCS) yyextra->current->isStatic =
TRUE;
1261 }
1262 else
1263 {
1264 REJECT;
1265 }
1266 }
1267<FindMembers>{B}*"virtual"{BN}+ { if (yyextra->insideJava) REJECT;
1268 yyextra->current->type += " virtual ";
1269 yyextra->current->virt = Specifier::Virtual;
1271 }
1272<FindMembers>{B}*"constexpr"{BN}+ {
1273 if (yyextra->insideCpp)
1274 {
1275 yyextra->current->spec.setConstExpr(true);
1276 }
1277 REJECT;
1278 }
1279<FindMembers>{B}*"consteval"{BN}+ {
1280 if (yyextra->insideCpp)
1281 {
1282 yyextra->current->spec.setConstEval(true);
1283 }
1284 REJECT;
1285 }
1286<FindMembers>{B}*"constinit"{BN}+ {
1287 if (yyextra->insideCpp)
1288 {
1289 yyextra->current->spec.setConstInit(true);
1290 }
1291 REJECT;
1292 }
1293<FindMembers>{B}*"published"{BN}+ { // UNO IDL published keyword
1294 if (yyextra->insideIDL)
1295 {
1297 yyextra->current->spec.setPublished(true);
1298 }
1299 else
1300 {
1301 REJECT;
1302 }
1303 }
1304<FindMembers>{B}*"sealed"{BN}+ {
1305 if (yyextra->insideCS)
1306 {
1307 yyextra->current->spec.setSealed(true);
1308 }
1309 else
1310 {
1311 REJECT;
1312 }
1313 }
1314<FindMembers>{B}*"abstract"{BN}+ {
1315 if (yyextra->insidePHP || yyextra->insideCS)
1316 {
1317 yyextra->current->spec.setAbstract(true);
1318 }
1319 else
1320 {
1321 if (yyextra->insideCpp) REJECT;
1322 yyextra->current->type += " abstract ";
1323 if (!yyextra->insideJava)
1324 {
1325 yyextra->current->virt = Specifier::Pure;
1326 }
1327 else
1328 {
1329 yyextra->current->spec.setAbstract(true);
1330 }
1331 }
1333 }
1334<FindMembers>{B}*"inline"{BN}+ { if (yyextra->insideJava) REJECT;
1335 yyextra->current->spec.setInline(true);
1337 }
1338<FindMembers>{B}*"mutable"{BN}+ { if (yyextra->insideJava) REJECT;
1339 yyextra->current->spec.setMutable(true);
1341 }
1342<FindMembers>{B}*"thread_local"{BN}+ { if (yyextra->insideJava) REJECT;
1343 yyextra->current->spec.setThreadLocal(true);
1345 }
1346<FindMembers>{B}*"explicit"{BN}+ { if (yyextra->insideJava) REJECT;
1347 yyextra->current->spec.setExplicit(true);
1349 }
1350<FindMembers>{B}*"local"{BN}+ { if (yyextra->insideJava || yyextra->insideCpp) REJECT;
1351 yyextra->current->spec.setLocal(true);
1353 }
1354<FindMembers>{B}*"@required"{BN}+ { // Objective C 2.0 protocol required section
1355 yyextra->current->spec.setOptional(false).setRequired(true);
1357 }
1358<FindMembers>{B}*"@optional"{BN}+ { // Objective C 2.0 protocol optional section
1359 yyextra->current->spec.setRequired(false).setOptional(true);
1361 }
1362
1363<FindMembers>{B}*"import"{BN}+ { // IDL import keyword
1364 BEGIN( NextSemi );
1365 }
1366 */
1367<FindMembers>{B}*"typename"{BN}+ { lineCount(yyscanner); }
1368<FindMembers>{B}*"namespace"{BNopt}/[^a-z_A-Z0-9] { if (yyextra->insideJava) REJECT;
1369 yyextra->isTypedef=
FALSE;
1370 yyextra->current->section = EntryType::makeNamespace();
1371 yyextra->current->type = "namespace" ;
1372 yyextra->current->fileName = yyextra->fileName;
1373 yyextra->current->startLine = yyextra->yyLineNr;
1374 yyextra->current->startColumn = yyextra->yyColNr;
1375 yyextra->current->bodyLine = yyextra->yyLineNr;
1376 yyextra->current->bodyColumn = yyextra->yyColNr;
1378 if (yyextra->insidePHP)
1379 {
1380 BEGIN( PackageName );
1381 }
1382 else
1383 {
1384 BEGIN( CompoundName );
1385 }
1386 }
1387<FindMembers>{B}*"module"{BN}+ {
1389 if (yyextra->insideIDL || yyextra->insideSlice)
1390 {
1391 yyextra->isTypedef=
FALSE;
1392 yyextra->current->section = EntryType::makeNamespace();
1393 yyextra->current->type = "module" ;
1394 yyextra->current->fileName = yyextra->fileName;
1395 yyextra->current->startLine = yyextra->yyLineNr;
1396 yyextra->current->startColumn = yyextra->yyColNr;
1397 yyextra->current->bodyLine = yyextra->yyLineNr;
1398 yyextra->current->bodyColumn = yyextra->yyColNr;
1399 BEGIN( CompoundName );
1400 }
1401 else if (yyextra->insideD)
1402 {
1404 BEGIN(PackageName);
1405 }
1406 else
1407 {
1410 }
1411 }
1412<FindMembers>{B}*"library"{BN}+ {
1414 if (yyextra->insideIDL)
1415 {
1416 yyextra->isTypedef=
FALSE;
1417 yyextra->current->section = EntryType::makeNamespace();
1418 yyextra->current->type = "library" ;
1419 yyextra->current->fileName = yyextra->fileName;
1420 yyextra->current->startLine = yyextra->yyLineNr;
1421 yyextra->current->startColumn = yyextra->yyColNr;
1422 yyextra->current->bodyLine = yyextra->yyLineNr;
1423 yyextra->current->bodyColumn = yyextra->yyColNr;
1424 BEGIN( CompoundName );
1425 }
1426 else
1427 {
1430 }
1431 }
1432<FindMembers>{B}*"constants"{BN}+ { // UNO IDL constant group
1434 if (yyextra->insideIDL)
1435 {
1436 yyextra->isTypedef=
FALSE;
1437 yyextra->current->section = EntryType::makeNamespace();
1438 yyextra->current->type = "constants";
1439 yyextra->current->fileName = yyextra->fileName;
1440 yyextra->current->startLine = yyextra->yyLineNr;
1441 yyextra->current->startColumn = yyextra->yyColNr;
1442 yyextra->current->bodyLine = yyextra->yyLineNr;
1443 yyextra->current->bodyColumn = yyextra->yyColNr;
1444 BEGIN( CompoundName );
1445 }
1446 else
1447 {
1450 }
1451 }
1452<FindMembers>{BN}*("service"){BN}+ { // UNO IDL service
1454 if (yyextra->insideIDL)
1455 {
1456 yyextra->isTypedef=
FALSE;
1457 yyextra->current->section = EntryType::makeClass();
1460
1461 setOptional(spec.isOptional()).setPublished(spec.isPublished());
1463 yyextra->current->type += " service " ;
1464 yyextra->current->fileName = yyextra->fileName;
1465 yyextra->current->startLine = yyextra->yyLineNr;
1466 yyextra->current->bodyLine = yyextra->yyLineNr;
1467 yyextra->current->bodyColumn = yyextra->yyColNr;
1468 BEGIN( CompoundName );
1469 }
1470 else
1471 {
1474 }
1475 }
Wrapper class for a number of boolean properties.
1476<FindMembers>{BN}*("singleton"){BN}+ { // UNO IDL singleton
1478 if (yyextra->insideIDL)
1479 {
1480 yyextra->isTypedef=
FALSE;
1481 yyextra->current->section = EntryType::makeClass();
1483 yyextra->current->spec =
TypeSpecifier().setSingleton(
true).
1484 setPublished(spec.isPublished());
1486 yyextra->current->type += " singleton " ;
1487 yyextra->current->fileName = yyextra->fileName;
1488 yyextra->current->startLine = yyextra->yyLineNr;
1489 yyextra->current->bodyLine = yyextra->yyLineNr;
1490 yyextra->current->bodyColumn = yyextra->yyColNr;
1491 BEGIN( CompoundName );
1492 }
1493 else
1494 {
1497 }
1498 }
1499<FindMembers>{BN}*((("disp")?"interface")|"valuetype"){BN}+ { // M$/Corba/UNO IDL/Java/Slice interface
1501 if (yyextra->insideIDL || yyextra->insideJava || yyextra->insideCS || yyextra->insideD || yyextra->insidePHP || yyextra->insideSlice)
1502 {
1503 yyextra->isTypedef=
FALSE;
1504 yyextra->current->section = EntryType::makeClass();
1506 yyextra->current->spec =
TypeSpecifier().setInterface(
true).
1507
1508 setOptional(spec.isOptional()).
1509 setPublished(spec.isPublished()).
1510 setLocal(spec.isLocal());
1512 yyextra->current->type += " interface" ;
1513 yyextra->current->fileName = yyextra->fileName;
1514 yyextra->current->startLine = yyextra->yyLineNr;
1515 yyextra->current->startColumn = yyextra->yyColNr;
1516 yyextra->current->bodyLine = yyextra->yyLineNr;
1517 yyextra->current->bodyColumn = yyextra->yyColNr;
1519 BEGIN( CompoundName );
1520 }
1521 else
1522 {
1525 }
1526 }
static void setJavaProtection(yyscan_t yyscanner)
1527<FindMembers>{B}*"@implementation"{BN}+ { // Objective-C class implementation
1529 yyextra->isTypedef=
FALSE;
1530 yyextra->current->section = EntryType::makeObjcImpl();
1531 yyextra->language = yyextra->current->lang = SrcLangExt::ObjC;
1532 yyextra->insideObjC =
TRUE;
1533 yyextra->current->protection = yyextra->protection = Protection::Public ;
1535 yyextra->current->type += " implementation" ;
1536 yyextra->current->fileName = yyextra->fileName;
1537 yyextra->current->startLine = yyextra->yyLineNr;
1538 yyextra->current->bodyLine = yyextra->yyLineNr;
1539 yyextra->current->bodyColumn = yyextra->yyColNr;
1540 BEGIN( CompoundName );
1541 }
1542<FindMembers>{B}*"@interface"{BN}+ { // Objective-C class interface, or Java attribute
1544 yyextra->isTypedef=
FALSE;
1545 yyextra->current->section = EntryType::makeClass();
1546 yyextra->current->spec =
TypeSpecifier().setInterface(
true);
1547 if (!yyextra->insideJava)
1548 {
1549 yyextra->language = yyextra->current->lang = SrcLangExt::ObjC;
1550 yyextra->insideObjC =
TRUE;
1551 }
1552 yyextra->current->protection = yyextra->protection = Protection::Public ;
1554 yyextra->current->type += " interface" ;
1555 yyextra->current->fileName = yyextra->fileName;
1556 yyextra->current->startLine = yyextra->yyLineNr;
1557 yyextra->current->startColumn = yyextra->yyColNr;
1558 yyextra->current->bodyLine = yyextra->yyLineNr;
1559 yyextra->current->bodyColumn = yyextra->yyColNr;
1560 BEGIN( CompoundName );
1561 }
1562<FindMembers>{B}*"@protocol"{BN}+ { // Objective-C protocol definition
1564 yyextra->isTypedef=
FALSE;
1565 yyextra->current->section = EntryType::makeClass();
1567 yyextra->language = yyextra->current->lang = SrcLangExt::ObjC;
1568 yyextra->insideObjC =
TRUE;
1569 yyextra->current->protection = yyextra->protection = Protection::Public ;
1571 yyextra->current->type += " protocol" ;
1572 yyextra->current->fileName = yyextra->fileName;
1573 yyextra->current->startLine = yyextra->yyLineNr;
1574 yyextra->current->startColumn = yyextra->yyColNr;
1575 yyextra->current->bodyLine = yyextra->yyLineNr;
1576 yyextra->current->bodyColumn = yyextra->yyColNr;
1577 BEGIN( CompoundName );
1578 }
1579<FindMembers>{B}*"exception"{BN}+ { // Corba IDL/Slice exception
1580 if (yyextra->insideJava || yyextra->insideCpp) REJECT;
1581 yyextra->isTypedef=
FALSE;
1582 yyextra->current->section = EntryType::makeClass();
1584
1585 yyextra->current->spec =
TypeSpecifier().setException(
true).
1586 setPublished(spec.isPublished()).setLocal(spec.isLocal());
1588 yyextra->current->type += " exception" ;
1589 yyextra->current->fileName = yyextra->fileName;
1590 yyextra->current->startLine = yyextra->yyLineNr;
1591 yyextra->current->startColumn = yyextra->yyColNr;
1592 yyextra->current->bodyLine = yyextra->yyLineNr;
1593 yyextra->current->bodyColumn = yyextra->yyColNr;
1595 BEGIN( CompoundName );
1596 }
1597<FindMembers>"@class" | // for Objective C class declarations
1598<FindMembers>{B}*{TYPEDEFPREFIX}"class{" |
1599<FindMembers>{B}*{TYPEDEFPREFIX}"class"{BN}+ {
1601 yyextra->isTypedef=decl.
find(
"typedef")!=-1;
1602 bool isConst=decl.
find(
"const")!=-1;
1603 bool isVolatile=decl.
find(
"volatile")!=-1;
1604 yyextra->current->section = EntryType::makeClass();
1606 if (yyextra->insidePHP && yyextra->current->spec.isAbstract())
1607 {
1608
1609 yyextra->current->spec.setAbstract(false).setAbstractClass(true);
1610 }
1611 if (yyextra->insideSlice && yyextra->current->spec.isLocal())
1612 {
1613 yyextra->current->spec.setLocal(true);
1614 }
1615 if (isConst)
1616 {
1617 yyextra->current->type += " const";
1618 }
1619 else if (isVolatile)
1620 {
1621 yyextra->current->type += " volatile";
1622 }
1623 yyextra->current->type += " class" ;
1624 yyextra->current->fileName = yyextra->fileName;
1625 yyextra->current->startLine = yyextra->yyLineNr;
1626 yyextra->current->startColumn = yyextra->yyColNr;
1627 yyextra->current->bodyLine = yyextra->yyLineNr;
1628 yyextra->current->bodyColumn = yyextra->yyColNr;
1629 if (yytext[0]=='@')
1630 {
1631 yyextra->language = yyextra->current->lang = SrcLangExt::ObjC;
1632 yyextra->insideObjC =
TRUE;
1633 }
1635 if (yytext[yyleng-1]=='{') unput('{');
1636 BEGIN( CompoundName ) ;
1637 }
1638<FindMembers>{B}*"value class{" | // C++/CLI extension
1639<FindMembers>{B}*"value class"{BN}+ {
1640 yyextra->isTypedef=
FALSE;
1641 yyextra->current->section = EntryType::makeClass();
1644 yyextra->current->type += " value class" ;
1645 yyextra->current->fileName = yyextra->fileName;
1646 yyextra->current->startLine = yyextra->yyLineNr;
1647 yyextra->current->startColumn = yyextra->yyColNr;
1648 yyextra->current->bodyLine = yyextra->yyLineNr;
1649 yyextra->current->bodyColumn = yyextra->yyColNr;
1651 if (yytext[yyleng-1]=='{') unput('{');
1652 BEGIN( CompoundName ) ;
1653 }
1654<FindMembers>{B}*"ref class{" | // C++/CLI extension
1655<FindMembers>{B}*"ref class"{BN}+ {
1656 yyextra->isTypedef=
FALSE;
1657 yyextra->current->section = EntryType::makeClass();
1660 yyextra->current->type += " ref class" ;
1661 yyextra->current->fileName = yyextra->fileName;
1662 yyextra->current->startLine = yyextra->yyLineNr;
1663 yyextra->current->startColumn = yyextra->yyColNr;
1664 yyextra->current->bodyLine = yyextra->yyLineNr;
1665 yyextra->current->bodyColumn = yyextra->yyColNr;
1667 if (yytext[yyleng-1]=='{') unput('{');
1668 BEGIN( CompoundName ) ;
1669 }
1670<FindMembers>{B}*"interface class{" | // C++/CLI extension
1671<FindMembers>{B}*"interface class"{BN}+ {
1672 yyextra->isTypedef=
FALSE;
1673 yyextra->current->section = EntryType::makeClass();
1674 yyextra->current->spec =
TypeSpecifier().setInterface(
true);
1676 yyextra->current->type += " interface class" ;
1677 yyextra->current->fileName = yyextra->fileName;
1678 yyextra->current->startLine = yyextra->yyLineNr;
1679 yyextra->current->startColumn = yyextra->yyColNr;
1680 yyextra->current->bodyLine = yyextra->yyLineNr;
1681 yyextra->current->bodyColumn = yyextra->yyColNr;
1683 if (yytext[yyleng-1]=='{') unput('{');
1684 BEGIN( CompoundName ) ;
1685 }
1686<FindMembers>{B}*"coclass"{BN}+ {
1687 if (yyextra->insideIDL)
1688 {
1689 yyextra->isTypedef=
FALSE;
1690 yyextra->current->section = EntryType::makeClass();
1692 yyextra->current->type += " coclass" ;
1693 yyextra->current->fileName = yyextra->fileName;
1694 yyextra->current->startLine = yyextra->yyLineNr;
1695 yyextra->current->startColumn = yyextra->yyColNr;
1696 yyextra->current->bodyLine = yyextra->yyLineNr;
1697 yyextra->current->bodyColumn = yyextra->yyColNr;
1699 BEGIN( CompoundName ) ;
1700 }
1701 else
1702 {
1704 yyextra->current->name = yytext;
1705 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
1707 }
1708 }
1709<FindMembers>{B}*{TYPEDEFPREFIX}"struct{" |
1710<FindMembers>{B}*{TYPEDEFPREFIX}"struct"/{BN}+ {
1711 if (yyextra->insideJava) REJECT;
1713 yyextra->isTypedef=decl.
find(
"typedef")!=-1;
1714 bool isConst=decl.
find(
"const")!=-1;
1715 bool isVolatile=decl.
find(
"volatile")!=-1;
1716 yyextra->current->section = EntryType::makeClass() ;
1719
1720 setPublished(spec.isPublished()).
1721 setInline(spec.isInline()).
1722 setLocal(spec.isLocal());
1723
1724
1726 if (isConst)
1727 {
1728 yyextra->current->type += " const";
1729 }
1730 else if (isVolatile)
1731 {
1732 yyextra->current->type += " volatile";
1733 }
1734 yyextra->current->type += " struct" ;
1735 yyextra->current->fileName = yyextra->fileName;
1736 yyextra->current->startLine = yyextra->yyLineNr;
1737 yyextra->current->startColumn = yyextra->yyColNr;
1738 yyextra->current->bodyLine = yyextra->yyLineNr;
1739 yyextra->current->bodyColumn = yyextra->yyColNr;
1741 if (yytext[yyleng-1]=='{') unput('{');
1742 BEGIN( CompoundName ) ;
1743 }
1744<FindMembers>{B}*"value struct{" | // C++/CLI extension
1745<FindMembers>{B}*"value struct"{BN}+ {
1746 yyextra->isTypedef=
FALSE;
1747 yyextra->current->section = EntryType::makeClass();
1748 yyextra->current->spec =
TypeSpecifier().setStruct(
true).setValue(
true);
1750 yyextra->current->type += " value struct" ;
1751 yyextra->current->fileName = yyextra->fileName;
1752 yyextra->current->startLine = yyextra->yyLineNr;
1753 yyextra->current->startColumn = yyextra->yyColNr;
1754 yyextra->current->bodyLine = yyextra->yyLineNr;
1755 yyextra->current->bodyColumn = yyextra->yyColNr;
1757 if (yytext[yyleng-1]=='{') unput('{');
1758 BEGIN( CompoundName ) ;
1759 }
1760<FindMembers>{B}*"ref struct{" | // C++/CLI extension
1761<FindMembers>{B}*"ref struct"{BN}+ {
1762 yyextra->isTypedef=
FALSE;
1763 yyextra->current->section = EntryType::makeClass();
1764 yyextra->current->spec =
TypeSpecifier().setStruct(
true).setRef(
true);
1766 yyextra->current->type += " ref struct" ;
1767 yyextra->current->fileName = yyextra->fileName;
1768 yyextra->current->startLine = yyextra->yyLineNr;
1769 yyextra->current->startColumn = yyextra->yyColNr;
1770 yyextra->current->bodyLine = yyextra->yyLineNr;
1771 yyextra->current->bodyColumn = yyextra->yyColNr;
1773 if (yytext[yyleng-1]=='{') unput('{');
1774 BEGIN( CompoundName ) ;
1775 }
1776<FindMembers>{B}*"interface struct{" | // C++/CLI extension
1777<FindMembers>{B}*"interface struct"{BN}+ {
1778 yyextra->isTypedef=
FALSE;
1779 yyextra->current->section = EntryType::makeClass();
1780 yyextra->current->spec =
TypeSpecifier().setStruct(
true).setInterface(
true);
1782 yyextra->current->type += " interface struct";
1783 yyextra->current->fileName = yyextra->fileName;
1784 yyextra->current->startLine = yyextra->yyLineNr;
1785 yyextra->current->startColumn = yyextra->yyColNr;
1786 yyextra->current->bodyLine = yyextra->yyLineNr;
1787 yyextra->current->bodyColumn = yyextra->yyColNr;
1789 if (yytext[yyleng-1]=='{') unput('{');
1790 BEGIN( CompoundName ) ;
1791 }
1792<FindMembers>{B}*{TYPEDEFPREFIX}"union{" |
1793<FindMembers>{B}*{TYPEDEFPREFIX}"union"{BN}+ {
1794 if (yyextra->insideJava) REJECT;
1796 yyextra->isTypedef=decl.
find(
"typedef")!=-1;
1797 bool isConst=decl.
find(
"const")!=-1;
1798 bool isVolatile=decl.
find(
"volatile")!=-1;
1799 yyextra->current->section = EntryType::makeClass();
1801
1802
1804 if (isConst)
1805 {
1806 yyextra->current->type += " const";
1807 }
1808 else if (isVolatile)
1809 {
1810 yyextra->current->type += " volatile";
1811 }
1812 yyextra->current->type += " union" ;
1813 yyextra->current->fileName = yyextra->fileName;
1814 yyextra->current->startLine = yyextra->yyLineNr;
1815 yyextra->current->startColumn = yyextra->yyColNr;
1816 yyextra->current->bodyLine = yyextra->yyLineNr;
1817 yyextra->current->bodyColumn = yyextra->yyColNr;
1819 if (yytext[yyleng-1]=='{') unput('{');
1820 BEGIN( CompoundName ) ;
1821 }
1822<FindMembers>{B}*{TYPEDEFPREFIX}{IDLATTR}?"enum"({BN}+("class"|"struct"))?"{" |
1823<FindMembers>{B}*{TYPEDEFPREFIX}{IDLATTR}?"enum"({BN}+("class"|"struct"))?{BN}+ { // for IDL: typedef [something] enum
1825 yyextra->isTypedef = text.
find(
"typedef")!=-1;
1826 bool isStrongEnum = text.
find(
"class")!=-1 || yyextra->insideCS;
1827 bool isEnumSytruct = text.
find(
"struct")!=-1;
1828 if (yyextra->insideJava)
1829 {
1830 yyextra->current->section = EntryType::makeClass();
1833 }
1834 else
1835 {
1836 yyextra->current->section = EntryType::makeEnum() ;
1837 }
1839 yyextra->current->type += " enum";
1840 if (isStrongEnum)
1841 {
1842 yyextra->current->spec.setStrong(true);
1843 }
1844 if (isEnumSytruct)
1845 {
1846 yyextra->current->spec.setStrong(true).setEnumStruct(true);
1847 }
1848 yyextra->current->fileName = yyextra->fileName;
1849 yyextra->current->startLine = yyextra->yyLineNr;
1850 yyextra->current->startColumn = yyextra->yyColNr;
1851 yyextra->current->bodyLine = yyextra->yyLineNr;
1852 yyextra->current->bodyColumn = yyextra->yyColNr;
1854 if (yytext[yyleng-1]=='{') unput('{');
1855 BEGIN( CompoundName ) ;
1856 }
1857<FindMembers>{B}*"concept"{BN}+ { // C++20 concept
1858 if (yyextra->insideJava) REJECT;
1859 yyextra->isTypedef=
FALSE;
1860 yyextra->current->section = EntryType::makeConcept();
1862 yyextra->current->type += " concept";
1863 yyextra->current->fileName = yyextra->fileName;
1864 yyextra->current->startLine = yyextra->yyLineNr;
1865 yyextra->current->startColumn = yyextra->yyColNr;
1866 yyextra->current->bodyLine = yyextra->yyLineNr;
1867 yyextra->current->bodyColumn = yyextra->yyColNr;
1868 yyextra->current->args = yyextra->fullArgString;
1869 yyextra->keepComment = true;
1871 BEGIN( ConceptName ) ;
1872 }
1873<Operator>"("{BN}*")"({BN}*"<"[^>]*">"){BNopt}/"(" { // A::operator()<int>(int arg)
1875 yyextra->current->name += "()";
1876 BEGIN( FindMembers );
1877 }
1878<Operator>"("{BN}*")"{BNopt}/("[["[^\]]*"]]"){BNopt}"(" {
1880 yyextra->current->name += yytext ;
1881 yyextra->current->name = yyextra->current->name.simplifyWhiteSpace();
1882 BEGIN( FindMembers ) ;
1883 }
1884<Operator>"("{BN}*")"{BNopt}/"(" {
1886 yyextra->current->name += yytext ;
1887 yyextra->current->name = yyextra->current->name.simplifyWhiteSpace();
1888 BEGIN( FindMembers ) ;
1889 }
1890<Operator>";" { // can occur when importing members
1891 unput(';');
1892 BEGIN( FindMembers ) ;
1893 }
1894<Operator>[^(] {
1896 yyextra->current->name += *yytext ;
1897 }
1898<Operator>"<"({B}*{ID}{B}*(","{B}*{BN})*{B}*)?">" { /* skip guided templ specifiers */
1899 if (!yyextra->current->type.startsWith("friend "))
1900 {
1901 yyextra->current->name += yytext;
1902 }
1903 }
1904<Operator>"(" {
1905 yyextra->current->name = yyextra->current->name.simplifyWhiteSpace();
1906 unput(*yytext);
1907 BEGIN( FindMembers ) ;
1908 }
1909<FindMembers>("template"|"generic")({BN}*)"<"/[>]? { // generic is a C++/CLI extension
1912 yyextra->current->tArgLists.
push_back(al);
1913 yyextra->currentArgumentList = &yyextra->current->tArgLists.back();
1914 yyextra->templateStr="<";
1915 yyextra->fullArgString = yyextra->templateStr;
1916 yyextra->copyArgString = &yyextra->templateStr;
1917 yyextra->currentArgumentContext = FindMembers;
1918 BEGIN( ReadTempArgs );
1919 }
void push_back(const Argument &a)
1920<FindMembers>"namespace"{BN}+/{ID}{BN}*"=" { // namespace alias
1921 if (yyextra->insideJava) REJECT;
1923 BEGIN( NSAliasName );
1924 }
1925<NSAliasName>{ID} {
1926 yyextra->aliasName = yytext;
1927 BEGIN( NSAliasArg );
1928 }
1929<NSAliasArg>({ID}"::")*{ID} {
1930
1931 std::string ctx = yyextra->current_root->name.str();
1932 if (ctx.empty())
1933 {
1935 }
1936 else
1937 {
1939 }
1940 }
static NamespaceAliasInfoMap namespaceAliasMap
1941<NSAliasArg>";" {
1942 BEGIN( FindMembers );
1943 }
1944<PHPUse>({ID}{BN}*"\\"{BN}*)*{ID}/{BN}+"as" {
1946 yyextra->aliasName=yytext;
1947 BEGIN(PHPUseAs);
1948 }
1949<PHPUse>({ID}{BN}*"\\"{BN}*)*{ID} {
1952
1953 yyextra->current->fileName = yyextra->fileName;
1954
1955 yyextra->current->section = EntryType::makeUsingDecl();
1956 yyextra->current_root->copyToSubEntry(yyextra->current);
1957
1958 yyextra->current->section = EntryType::makeUsingDir();
1959 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
1961 yyextra->aliasName.clear();
1962 }
QCString removeRedundantWhiteSpace(const QCString &s)
1963<PHPUseAs>{BN}+"as"{BN}+ {
1965 }
1966<PHPUseAs>{PHPUSEKW} {
1967 }
1969
1970 if (!yyextra->aliasName.isEmpty())
1971 {
1974 }
1975 yyextra->aliasName.clear();
1976 }
1977<PHPUse,PHPUseAs>[,;] {
1978 if (*yytext==',')
1979 {
1980 BEGIN(PHPUse);
1981 }
1982 else
1983 {
1984 BEGIN(FindMembers);
1985 }
1986 }
1987<JavaImport>({ID}{BN}*"."{BN}*)+"*" { // package import => add as a using directive
1991 yyextra->current->fileName = yyextra->fileName;
1992 bool ambig = false;
1994 if (incFd)
1995 {
1997 }
1998 yyextra->current->section = EntryType::makeUsingDir();
1999 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2001 BEGIN(Using);
2002 }
static FileNameLinkedMap * inputNameLinkedMap
A model of a file symbol.
virtual void addIncludeDependency(const FileDef *fd, const QCString &incName, IncludeKind kind)=0
FileDef * findFileDef(const FileNameLinkedMap *fnMap, const QCString &n, bool &ambig)
2003<JavaImport>({ID}{BN}*"."{BN}*)+{ID} { // class import => add as a using declaration
2007 yyextra->current->fileName = yyextra->fileName;
2008 bool ambig = false;
2011 if (fromFd)
2012 {
2014 }
2015 if (toFd && fromFd)
2016 {
2018 }
2019 if (yyextra->insideD)
2020 {
2021 yyextra->current->section = EntryType::makeUsingDir();
2022 }
2023 else
2024 {
2025
2026 yyextra->current->section = EntryType::makeUsingDecl();
2027 }
2028 yyextra->previous = yyextra->current;
2029 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2031 BEGIN(Using);
2032 }
virtual void addIncludedByDependency(const FileDef *fd, const QCString &incName, IncludeKind kind)=0
virtual const QCString & docName() const =0
2033<IDLImport>"\""[^"]*"\"" {
2034 QCString fileName(&yytext[1],yyleng-2);
2035 bool ambig = false;
2038 if (fromFd)
2039 {
2041 }
2042 if (toFd && fromFd)
2043 {
2045 }
2046 }
2047<IDLImport>";" {
2048 BEGIN(FindMembers);
2049 }
2050<FindMembers>"using"{BN}+/("::"{ID}("::"{ID})*)? {
2051 if (yyextra->insideJava) REJECT;
2052 yyextra->current->startLine=yyextra->yyLineNr;
2053 yyextra->current->startColumn = yyextra->yyColNr;
2055 BEGIN(Using);
2056 }
2057<Using>"namespace"{BN}+ { lineCount(yyscanner); BEGIN(UsingDirective); }
2058<Using>("::")?({ID}{BN}*("::"|"."){BN}*)*({ID}|{OPERATOR}|{FUNCOP}) {
2060 yyextra->current->name=yytext;
2061 yyextra->current->fileName = yyextra->fileName;
2062 yyextra->current->section = EntryType::makeUsingDecl();
2063 yyextra->current->startLine = yyextra->yyLineNr;
2064 yyextra->usingNewVarNeeded = true;
2065 if (yyextra->insideCS)
2066
2067
2068
2069 {
2070 yyextra->current->name=yytext;
2071 yyextra->current->fileName = yyextra->fileName;
2072 yyextra->current->startLine = yyextra->yyLineNr;
2073 yyextra->current->startColumn = yyextra->yyColNr;
2074 yyextra->current->section = EntryType::makeUsingDir();
2075 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2077 }
2078 BEGIN(Using);
2079 }
2080<Using>({ID}{BN}*("::"|"."){BN}*)*({ID}|{OPERATOR}){BN}*"=" { // C++11 style using alias
2082 yyextra->current->fileName = yyextra->fileName;
2083 yyextra->current->section = EntryType::makeUsingDecl();
2084 yyextra->current->startLine = yyextra->yyLineNr;
2085 yyextra->current->bodyLine = yyextra->yyLineNr;
2086 yyextra->current->bodyColumn = yyextra->yyColNr;
2087 yyextra->lastInitializerContext = UsingAlias;
2088 yyextra->sharpCount=0;
2089 yyextra->initBracketCount=0;
2091 BEGIN(ReadInitializer);
2092 }
2093<Using>";" {
2094 if (yyextra->usingNewVarNeeded)
2095 {
2096 yyextra->previous = yyextra->current;
2097 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2099 yyextra->usingNewVarNeeded = false;
2100 }
2101 BEGIN(FindMembers);
2102 }
2103<Using>{BN}*"=" {
2104 yyextra->lastInitializerContext = UsingAlias;
2105 yyextra->sharpCount=0;
2106 yyextra->initBracketCount=0;
2108 yyextra->usingNewVarNeeded = false;
2109 BEGIN(ReadInitializer);
2110 }
2111<Using>{B}*{CCS} {
2112 yyextra->lastCContext = YY_START ;
2113 BEGIN( SkipComment ) ;
2114 }
2115<Using>{B}*{CPPC} {
2116 yyextra->lastCContext = YY_START ;
2117 BEGIN( SkipCxxComment ) ;
2118 }
2119<Using>{B}*
2120<Using>. {
2121 if (yyextra->usingNewVarNeeded)
2122 {
2123 yyextra->previous = yyextra->current;
2124 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2126 yyextra->usingNewVarNeeded = false;
2127 }
2128 }
2129<UsingAlias>";" {
2130 yyextra->current->section = EntryType::makeVariable();
2132 init.stripPrefix(
"class ");
2133 init.stripPrefix(
"struct ");
2135 yyextra->current->type =
"typedef "+
init;
2136 yyextra->current->args.clear();
2137 yyextra->current->spec.setAlias(true);
2138 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2140 BEGIN(FindMembers);
2141 }
2142<UsingAlias>. {
2143 yyextra->current->initializer << yytext;
2144 }
2145<UsingAlias>\n {
2146 yyextra->current->initializer << yytext;
2148 }
2149<UsingDirective>{SCOPENAME} { yyextra->current->name=removeRedundantWhiteSpace(yytext);
2150 yyextra->current->fileName = yyextra->fileName;
2151 yyextra->current->section = EntryType::makeUsingDir();
2152 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2154 yyextra->usingNewVarNeeded = false;
2155 BEGIN(Using);
2156 }
2157<FindMembers>{SCOPENAME}{BN}*"<>" { // guided template decl
2161 }
2162<FindMembers>{SCOPENAME}{BNopt}/"<" { // Note: this could be a return type!
2164 if (yyextra->insideCpp && name=="import") REJECT;
2165 yyextra->roundCount=0;
2166 yyextra->sharpCount=0;
2169 yyextra->current->name=name;
2170
2171
2173 BEGIN( Operator );
2174 else
2175 BEGIN( EndTemplate );
2176 }
static bool nameIsOperator(QCString &name)
2177<FindMemberName>{SCOPENAME}{BNopt}/"<" {
2178 yyextra->sharpCount=0;
2179 yyextra->roundCount=0;
2182
2183
2185 BEGIN( Operator );
2186 else
2187 BEGIN( EndTemplate );
2188 }
std::string_view stripWhiteSpace(std::string_view s)
Given a string view s, returns a new, narrower view on that string, skipping over any leading or trai...
2189<EndTemplate>"<<<" {
2190 if (!yyextra->insidePHP)
2191 {
2192 REJECT;
2193 }
2194 else
2195 {
2196 yyextra->lastHereDocContext = YY_START;
2197 BEGIN(HereDoc);
2198 }
2199 }
2200<ClassTemplSpec,EndTemplate>("<<"|"<=") {
2201 yyextra->current->name+=yytext;
2202
2203 }
2204<EndTemplate>"<" {
2205 if (yyextra->roundCount==0)
2206 {
2207
2208 yyextra->sharpCount++;
2209 }
2210 yyextra->current->name+=yytext;
2211 }
2212<ClassTemplSpec,EndTemplate>">=" {
2213 yyextra->current->name+=yytext;
2214 }
2215<ClassTemplSpec,EndTemplate>(">>") {
2216 if (yyextra->insideJava || yyextra->insideCS || yyextra->insideCli || yyextra->roundCount==0)
2217 {
2218 unput('>');
2219 unput(' ');
2220 unput('>');
2221 }
2222 else
2223 {
2224 yyextra->current->name+=yytext;
2225 }
2226
2227 }
2228<EndTemplate>">" {
2229 yyextra->current->name+='>';
2230
2231 if (yyextra->roundCount==0 && --yyextra->sharpCount<=0)
2232 {
2233 yyextra->current->name = yyextra->current->name.simplifyWhiteSpace();
2234
2235 BEGIN(FindMembers);
2236 }
2237 }
2238<EndTemplate>">"{BN}*"(" {
2240 yyextra->current->name+='>';
2241
2242 if (yyextra->roundCount==0)
2243 {
2244 --yyextra->sharpCount;
2245 }
2246 if (yyextra->roundCount==0 && yyextra->sharpCount<=0)
2247 {
2248 yyextra->current->bodyLine = yyextra->yyLineNr;
2249 yyextra->current->bodyColumn = yyextra->yyColNr;
2250 yyextra->current->args = "(";
2251 yyextra->currentArgumentContext = FuncQual;
2252 yyextra->fullArgString = yyextra->current->args;
2253 yyextra->copyArgString = &yyextra->current->args;
2254
2255 BEGIN( ReadFuncArgType ) ;
2256 }
2257 else
2258 {
2259 yyextra->current->name+="(";
2260 yyextra->roundCount++;
2261 }
2262 }
2263<EndTemplate>">"{BNopt}/"("({BN}*{TSCOPE}{BN}*"::")*({BN}*"*"{BN}*)+ { // function pointer returning a template instance
2265 yyextra->current->name+='>';
2266 if (yyextra->roundCount==0 && --yyextra->sharpCount<=0)
2267 {
2268 BEGIN(FindMembers);
2269 }
2270 }
2271<EndTemplate>">"{BNopt}/"::" {
2273 yyextra->current->name+='>';
2274
2275 if (yyextra->roundCount==0 && --yyextra->sharpCount<=0)
2276 {
2277 BEGIN(FindMemberName);
2278 }
2279 }
2280<ClassTemplSpec,EndTemplate>"(" { yyextra->current->name+=*yytext;
2281 yyextra->roundCount++;
2282 }
2283<ClassTemplSpec,EndTemplate>")" { yyextra->current->name+=*yytext;
2284 if (yyextra->roundCount>0) yyextra->roundCount--;
2285 }
2286<EndTemplate>. {
2287 yyextra->current->name+=*yytext;
2288
2289 }
2290<FindMembers>"define"{BN}*"("{BN}*["'] {
2291 if (yyextra->insidePHP)
2292 {
2293 yyextra->current->bodyLine = yyextra->yyLineNr;
2294 yyextra->current->bodyColumn = yyextra->yyColNr;
2295 BEGIN( DefinePHP );
2296 }
2297 else
2298 REJECT;
2299 }
2300<CopyHereDoc>{ID} { // PHP heredoc
2301 yyextra->delimiter = yytext;
2302 *yyextra->pCopyHereDocGString << yytext;
2303 BEGIN(CopyHereDocEnd);
2304 }
2305<CopyHereDoc>"\""{ID}/"\"" { // PHP quoted heredoc
2306 yyextra->delimiter = &yytext[1];
2307 *yyextra->pCopyHereDocGString << yytext;
2308 BEGIN(CopyHereDocEnd);
2309 }
2310<CopyHereDoc>"'"{ID}/"'" { // PHP nowdoc
2311 yyextra->delimiter = &yytext[1];
2312 *yyextra->pCopyHereDocGString << yytext;
2313 BEGIN(CopyHereDocEnd);
2314 }
2315<HereDoc>{ID} { // PHP heredoc
2316 yyextra->delimiter = yytext;
2317 BEGIN(HereDocEnd);
2318 }
2319<HereDoc>"\""{ID}/"\"" { // PHP quoted heredoc
2320 yyextra->delimiter = &yytext[1];
2321 BEGIN(HereDocEnd);
2322 }
2323<HereDoc>"'"{ID}/"'" { // PHP nowdoc
2324 yyextra->delimiter = &yytext[1];
2325 BEGIN(HereDocEnd);
2326 }
2327<HereDocEnd>^{Bopt}{ID} { // id at start of the line could mark the end of the block
2329 {
2330 BEGIN(yyextra->lastHereDocContext);
2331 }
2332 }
2333<HereDocEnd>. { }
2334<CopyHereDocEnd>^{Bopt}{ID} { // id at start of the line could mark the end of the block
2335 *yyextra->pCopyHereDocGString << yytext;
2337 {
2338 BEGIN(yyextra->lastHereDocContext);
2339 }
2340 }
2341<CopyHereDocEnd>\n {
2343 *yyextra->pCopyHereDocGString << yytext;
2344 }
2345<CopyHereDocEnd>{ID} {
2346 *yyextra->pCopyHereDocGString << yytext;
2347 }
2348<CopyHereDocEnd>. {
2349 *yyextra->pCopyHereDocGString << yytext;
2350 }
2351<FindMembers>"Q_OBJECT"|"Q_GADGET" { // Qt object / gadget macro
2352 }
2353<FindMembers>"Q_PROPERTY" { // Qt property declaration
2354 yyextra->yyBegLineNr = yyextra->yyLineNr;
2355 yyextra->yyBegColNr = yyextra->yyColNr;
2356 yyextra->current->protection = Protection::Public ;
2357 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
2358 yyextra->current->type.clear();
2359 BEGIN(QtPropType);
2360 }
2361<QtPropType>"(" { // start of property arguments
2362 }
2363<QtPropAttr>")" { // end of property arguments
2364 unput(';');
2365 BEGIN(FindMembers);
2366 }
2367<QtPropType>{BN}+ {
2368 yyextra->current->name+=yytext;
2369 }
2370<QtPropType>"*" {
2371 yyextra->current->type+= yyextra->current->name;
2372 yyextra->current->type+= yytext;
2373 yyextra->current->name="";
2374 }
2375<QtPropType>({TSCOPE}"::")*{TSCOPE} {
2376 yyextra->current->type+= yyextra->current->name;
2377 yyextra->current->name=yytext;
2378 }
2379<QtPropType,QtPropAttr>{BN}+"READ"{BN}+ {
2380 yyextra->current->spec.setReadable(true);
2381 BEGIN(QtPropRead);
2382 }
2383<QtPropType,QtPropAttr>{BN}+"WRITE"{BN}+ {
2384 yyextra->current->spec.setWritable(true);
2385 BEGIN(QtPropWrite);
2386 }
2387<QtPropType,QtPropAttr>{BN}+"MEMBER"{BN}+{ID} | // member property => not supported yet
2388<QtPropType,QtPropAttr>{BN}+"RESET"{BN}+{ID} | // reset method => not supported yet
2389<QtPropType,QtPropAttr>{BN}+"SCRIPTABLE"{BN}+{ID} | // scriptable property => not supported yet
2390<QtPropType,QtPropAttr>{BN}+"DESIGNABLE"{BN}+{ID} | // designable property => not supported yet
2391<QtPropType,QtPropAttr>{BN}+"NOTIFY"{BN}+{ID} | // notify property => not supported yet
2392<QtPropType,QtPropAttr>{BN}+"REVISION"{BN}+{ID} | // revision property => not supported yet
2393<QtPropType,QtPropAttr>{BN}+"STORED"{BN}+{ID} | // stored property => not supported yet
2394<QtPropType,QtPropAttr>{BN}+"USER"{BN}+{ID} | // user property => not supported yet
2395<QtPropType,QtPropAttr>{BN}+"CONSTANT"{BN} | // constant property => not supported yet
2396<QtPropType,QtPropAttr>{BN}+"FINAL"{BN} { // final property => not supported yet
2397 BEGIN(QtPropAttr);
2398 }
2399<QtPropRead>{ID} {
2400 yyextra->current->read = yytext;
2401 BEGIN(QtPropAttr);
2402 }
2403<QtPropWrite>{ID} {
2404 yyextra->current->write = yytext;
2405 BEGIN(QtPropAttr);
2406 }
2407<FindMembers>"friend"{BN}+("class"|"union"|"struct"){BN}+ {
2408 yyextra->current->name=yytext;
2410 BEGIN(FindMembers);
2411 }
2412<FindMembers>"requires" { // C++20 requires clause
2413 if (yyextra->insideJava) REJECT;
2414 yyextra->current->req.clear();
2415 yyextra->requiresContext = YY_START;
2416 BEGIN(RequiresClause);
2417 }
2418<RequiresClause>"requires"{BN}*/"{" { // requires requires { ... }
2419 if (yyextra->insideJava) REJECT;
2421 yyextra->current->req+=yytext;
2422 BEGIN( RequiresExpression ) ;
2423 }
2424<RequiresClause>"requires"{BN}*"(" { // requires requires(T x) { ... }
2425 if (yyextra->insideJava) REJECT;
2427 yyextra->current->req+=yytext;
2428 yyextra->lastRoundContext=RequiresExpression;
2429 yyextra->pCopyRoundString=&yyextra->current->req;
2430 yyextra->roundCount=0;
2431 BEGIN( CopyRound ) ;
2432 }
2433<RequiresExpression>"{" {
2434 yyextra->current->req+=yytext;
2435 yyextra->lastCurlyContext=RequiresClause;
2436 yyextra->pCopyCurlyString=&yyextra->current->req;
2437 yyextra->curlyCount=0;
2438 BEGIN( CopyCurly ) ;
2439 }
2440<RequiresExpression>\n {
2441 yyextra->current->req+=' ';
2443 }
2444<RequiresExpression>. {
2445 yyextra->current->req+=yytext;
2446 }
2447<RequiresClause>"(" { // requires "(A && B)"
2448 yyextra->current->req+=yytext;
2449 yyextra->lastRoundContext=RequiresClause;
2450 yyextra->pCopyRoundString=&yyextra->current->req;
2451 yyextra->roundCount=0;
2452 BEGIN( CopyRound ) ;
2453 }
2454<RequiresClause>{NOTopt}{SCOPENAME}{BNopt}"(" { // "requires func(x)"
2456 {
2458 yyextra->current->req+=yytext;
2459 yyextra->lastRoundContext=RequiresClause;
2460 yyextra->pCopyRoundString=&yyextra->current->req;
2461 yyextra->roundCount=0;
2462 BEGIN( CopyRound );
2463 }
2464 else
2465 {
2466 REJECT;
2467 }
2468 }
static bool startOfRequiresExpression(const QCString &req)
2469<RequiresClause>{NOTopt}{SCOPENAME}{BNopt}"<" { // "requires C<S,T>"
2471 {
2473 yyextra->current->req+=yytext;
2474 yyextra->lastSharpContext=RequiresClause;
2475 yyextra->pCopySharpString=&yyextra->current->req;
2476 yyextra->sharpCount=0;
2477 BEGIN( CopySharp );
2478 }
2479 else
2480 {
2481 REJECT
2482 }
2483 }
2484<RequiresClause>{NOTopt}{SCOPENAME} { // something like "requires true" or "requires !my::value"
2486 {
2488 yyextra->current->req=yytext;
2489 BEGIN(yyextra->requiresContext);
2490 }
2491 else
2492 {
2493 REJECT;
2494 }
2495 }
2496<RequiresClause>{NOTopt}"::"{ID} {
2498 yyextra->current->req+=yytext;
2499 }
2500<RequiresClause>"||"|"&&"|"!"|("or"{BN}+)|("and"{BN}+)|("not"{BN}+) { // "requires A || B" or "requires A && B"
2502 yyextra->current->req+=yytext;
2503 }
2504<RequiresClause>{BN}+ {
2505 yyextra->current->req+=' ';
2507 }
2508<RequiresClause>. {
2509 unput(*yytext);
2510 yyextra->current->req=yyextra->current->req.simplifyWhiteSpace();
2511 BEGIN(yyextra->requiresContext);
2512 }
2513<FindMembers,FindMemberName>{SCOPENAME} {
2515 yyextra->yyBegColNr=yyextra->yyColNr;
2516 yyextra->yyBegLineNr=yyextra->yyLineNr;
2518 if (yyextra->insideIDL && yyleng==9 &&
qstrcmp(yytext,
"cpp_quote")==0)
2519 {
2520 BEGIN(CppQuote);
2521 }
2522 else if ((yyextra->insideIDL || yyextra->insideJava || yyextra->insideD) && yyleng==6 &&
qstrcmp(yytext,
"import")==0)
2523 {
2524 if (yyextra->insideIDL)
2525 BEGIN(IDLImport);
2526 else
2527 BEGIN(JavaImport);
2528 }
2529 else if (yyextra->insidePHP &&
qstrcmp(yytext,
"use")==0)
2530 {
2531 BEGIN(PHPUse);
2532 }
2533 else if (yyextra->insideJava &&
qstrcmp(yytext,
"package")==0)
2534 {
2536 BEGIN(PackageName);
2537 }
2538 else if (yyextra->insideIDL &&
qstrcmp(yytext,
"case")==0)
2539 {
2540 BEGIN(IDLUnionCase);
2541 }
2542 else if (yyextra->insideTryBlock &&
qstrcmp(yytext,
"catch")==0)
2543 {
2544 yyextra->insideTryBlock=
FALSE;
2545 BEGIN(TryFunctionBlock);
2546 }
2547 else if (yyextra->insideCpp &&
qstrcmp(yytext,
"alignas")==0)
2548 {
2549 yyextra->lastAlignAsContext = YY_START;
2550 BEGIN(AlignAs);
2551 }
2552 else if (yyextra->insideJS &&
qstrcmp(yytext,
"var")==0)
2553 {
2554 yyextra->current->type="var";
2555 }
2556 else if (yyextra->insideJS &&
qstrcmp(yytext,
"function")==0)
2557 {
2558 yyextra->current->type="function";
2559 }
2560 else if (yyextra->insideCS &&
qstrcmp(yytext,
"this")==0)
2561 {
2562
2564 yyextra->current->name="this";
2565 BEGIN(CSIndexer);
2566 }
2567 else if (yyextra->insideCpp && (
qstrcmp(yytext,
"static_assert")==0 ||
qstrcmp(yytext,
"_Static_assert")==0))
2568 {
2569
2570 BEGIN(StaticAssert);
2571 }
2572 else if (yyextra->insideCpp &&
qstrcmp(yytext,
"decltype")==0)
2573 {
2574
2576 if (!yyextra->current->type.isEmpty()) yyextra->current->type+=' ';
2577 yyextra->current->type+=yytext;
2578 BEGIN(DeclType);
2579 }
2580 else if (yyextra->insideSlice &&
qstrcmp(yytext,
"optional")==0)
2581 {
2582 if (yyextra->current->type.isEmpty())
2583 {
2584 yyextra->current->type = "optional";
2585 }
2586 else
2587 {
2588 yyextra->current->type += " optional";
2589 }
2590 yyextra->lastModifierContext = YY_START;
2591 BEGIN(SliceOptional);
2592 }
2593 else
2594 {
2595 if (YY_START==FindMembers)
2596 {
2598 }
2599 bool javaLike = yyextra->insideJava || yyextra->insideCS || yyextra->insideD || yyextra->insidePHP || yyextra->insideJS;
2600 if (javaLike &&
qstrcmp(yytext,
"public")==0)
2601 {
2602 yyextra->current->protection = Protection::Public;
2603 }
2604 else if (javaLike &&
qstrcmp(yytext,
"protected")==0)
2605 {
2606 yyextra->current->protection = Protection::Protected;
2607 }
2608 else if ((yyextra->insideCS || yyextra->insideD || yyextra->insidePHP || yyextra->insideJS) &&
qstrcmp(yytext,
"internal")==0)
2609 {
2610 yyextra->current->protection = Protection::Package;
2611 }
2612 else if (javaLike &&
qstrcmp(yytext,
"private")==0)
2613 {
2614 yyextra->current->protection = Protection::Private;
2615 }
2616 else if (javaLike &&
qstrcmp(yytext,
"static")==0)
2617 {
2618 if (YY_START==FindMembers)
2619 yyextra->current->name = yytext;
2620 else
2621 yyextra->current->name += yytext;
2622 yyextra->current->isStatic =
TRUE;
2623 }
2624 else
2625 {
2626 if (YY_START==FindMembers)
2627 yyextra->current->name = yytext;
2628 else
2629 yyextra->current->name += yytext;
2630 if (yyextra->current->name.startsWith("static "))
2631 {
2632 yyextra->current->isStatic =
TRUE;
2633 yyextra->current->name= yyextra->current->name.mid(7);
2634 }
2635 else if (yyextra->current->name.startsWith("inline "))
2636 {
2637 if (yyextra->current->type.isEmpty())
2638 {
2639 yyextra->current->type="inline";
2640 }
2641 else
2642 {
2643 yyextra->current->type+="inline ";
2644 }
2645 yyextra->current->name= yyextra->current->name.mid(7);
2646 }
2647 else if (yyextra->current->name.startsWith("constexpr "))
2648 {
2649 if (yyextra->current->type.isEmpty())
2650 {
2651 yyextra->current->type="constexpr";
2652 }
2653 else
2654 {
2655 yyextra->current->type+="constexpr ";
2656 }
2657 yyextra->current->name=yyextra->current->name.mid(10);
2658 }
2659 else if (yyextra->current->name.startsWith("consteval "))
2660 {
2661 if (yyextra->current->type.isEmpty())
2662 {
2663 yyextra->current->type="consteval";
2664 }
2665 else
2666 {
2667 yyextra->current->type+="consteval ";
2668 }
2669 yyextra->current->name=yyextra->current->name.mid(10);
2670 }
2671 else if (yyextra->current->name.startsWith("constinit "))
2672 {
2673 if (yyextra->current->type.isEmpty())
2674 {
2675 yyextra->current->type="constinit";
2676 }
2677 else
2678 {
2679 yyextra->current->type+="constinit ";
2680 }
2681 yyextra->current->name=yyextra->current->name.mid(10);
2682 }
2683 else if (yyextra->current->name.startsWith("const "))
2684 {
2685 if (yyextra->current->type.isEmpty())
2686 {
2687 yyextra->current->type="const";
2688 }
2689 else
2690 {
2691 yyextra->current->type+="const ";
2692 }
2693 yyextra->current->name=yyextra->current->name.mid(6);
2694 }
2695 else if (yyextra->current->name.startsWith("volatile "))
2696 {
2697 if (yyextra->current->type.isEmpty())
2698 {
2699 yyextra->current->type="volatile";
2700 }
2701 else
2702 {
2703 yyextra->current->type+="volatile ";
2704 }
2705 yyextra->current->name=yyextra->current->name.mid(9);
2706 }
2707 else if (yyextra->current->name.startsWith("typedef "))
2708 {
2709 if (yyextra->current->type.isEmpty())
2710 {
2711 yyextra->current->type="typedef";
2712 }
2713 else
2714 {
2715 yyextra->current->type+="typedef ";
2716 }
2717 yyextra->current->name=yyextra->current->name.mid(8);
2718 }
2719 }
2722 {
2723 BEGIN( Operator );
2724 }
2725 else
2726 {
2727 yyextra->externLinkage=
FALSE;
2728 BEGIN(FindMembers);
2729 }
2730 }
2731 yyextra->current->name = yyextra->current->name.removeWhiteSpace();
2732 }
2733<StaticAssert>"(" {
2734 yyextra->lastSkipRoundContext = FindMembers;
2735 yyextra->roundCount=0;
2736 BEGIN(SkipRound);
2737 }
2738<StaticAssert>{BN}+ { lineCount(yyscanner); }
2739<StaticAssert>. { // variable with static_assert as name?
2740 unput(*yytext);
2741 BEGIN(FindMembers);
2742 }
2743<DeclType>"(" {
2744 yyextra->current->type+=yytext;
2745 yyextra->lastRoundContext=FindMembers;
2746 yyextra->pCopyRoundString=&yyextra->current->type;
2747 yyextra->roundCount=0;
2748 BEGIN(CopyRound);
2749 }
2750<DeclType>{BN}+ { lineCount(yyscanner); }
2751<DeclType>. {
2752 unput(*yytext);
2753 BEGIN(FindMembers);
2754 }
2755<CSIndexer>"["[^\n\]]*"]" {
2757 BEGIN(FindMembers);
2758 }
2759<FindMembers>[0-9]{ID} { // some number where we did not expect one
2760 }
2761<FindMembers>"." {
2762 if (yyextra->insideJava || yyextra->insideCS || yyextra->insideD)
2763 {
2764 yyextra->current->name+=".";
2765 }
2766 }
2767<FindMembers>"::" {
2768 yyextra->current->name+=yytext;
2769 }
2770<CppQuote>"("{B}*"\"" {
2771 yyextra->insideCppQuote=
TRUE;
2772 BEGIN(FindMembers);
2773 }
2774<IDLUnionCase>"::"
2775<IDLUnionCase>":" { BEGIN(FindMembers); }
2776<IDLUnionCase>\n { lineCount(yyscanner); }
2777<IDLUnionCase>.
2778<TryFunctionBlock>\n { lineCount(yyscanner); }
2779<TryFunctionBlock>"{" {
2780 yyextra->curlyCount=0;
2781 yyextra->lastCurlyContext = TryFunctionBlockEnd ;
2782 BEGIN( SkipCurly );
2783 }
2784<TryFunctionBlock>.
2785<TryFunctionBlockEnd>{BN}*"catch" { lineCount(yyscanner); BEGIN(TryFunctionBlock); // {BN}* added to fix bug 611193
2786 }
2787<TryFunctionBlockEnd>\n { unput(*yytext); // rule added to fix bug id 601138
2788 BEGIN( FindMembers );
2789 }
2790<TryFunctionBlockEnd>. { unput(*yytext);
2791 BEGIN( FindMembers );
2792 }
2793<EndCppQuote>")" {
2794 yyextra->insideCppQuote=
FALSE;
2795 BEGIN(FindMembers);
2796 }
2797<FindConceptParts>[^\/\n]* {
2798 yyextra->current->initializer << yytext;
2799 }
2800<FindConceptParts>. {
2801 yyextra->current->initializer << yytext;
2802 }
2803<FindConceptParts>\n {
2804 yyextra->current->initializer << yytext;
2805 yyextra->yyLineNr++;
2806 }
2807<FindConceptParts>{CCS} {
2808 yyextra->current->initializer << yytext;
2809 }
2810<FindConceptParts>{CPPC} {
2811 yyextra->current->initializer << yytext;
2812 }
2813<FindConceptParts>^[ \t]*{CCS}[!*] { // start of a special comment inside Concept definition
2815 int indent = text.
find(
'/');
2816
2817 if (!yyextra->current->initializer.empty())
2818 {
2819 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2821 }
2822 yyextra->current->section = EntryType::makeConceptDocPart();
2823 yyextra->current->startLine = yyextra->yyLineNr;
2824 yyextra->current->startColumn = indent;
2825 yyextra->current->initializer.clear();
2826 BEGIN(FindConceptDocs);
2827 }
2828<FindConceptParts>^[ \t]*{CPPC}[!/].*\n {
2829 if (!yyextra->current->initializer.empty())
2830 {
2831 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2833 }
2835 int indent = line.find('/');
2836 yyextra->current->section = EntryType::makeConceptDocPart();
2837 yyextra->current->startLine = yyextra->yyLineNr;
2838 yyextra->current->startColumn = indent;
2839 yyextra->current->initializer.clear();
2840 yyextra->current->initializer << line.mid(indent+3);
2841 yyextra->yyLineNr++;
2842 BEGIN(FindConceptCxxDocs);
2843 }
2844<FindConceptCxxDocs>^[ \t]*{CPPC}.*\n {
2846 int p = line.find('/');
2847 if (line.at(p+2)=='!' || line.at(p+2)=='/') p++;
2848 yyextra->current->initializer << line.mid(p+2);
2849 yyextra->yyLineNr++;
2850 }
2851<FindConceptCxxDocs>{CCS}|{CCE}|{CPPC} {
2852 yyextra->current->initializer << yytext;
2853 }
2854<FindConceptCxxDocs>. {
2855 if (!yyextra->current->initializer.empty())
2856 {
2857
2859 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2861 }
2862 unput(*yytext);
2863 yyextra->current->section = EntryType::makeConceptCodePart();
2864 yyextra->current->startLine = yyextra->yyLineNr;
2865 BEGIN(FindConceptParts);
2866 }
static void handleCommentBlock(yyscan_t yyscanner, const QCString &doc, bool brief)
2867<FindConceptDocs>^[ \t]*"*"+/[^/] { // skip leading indentation
2868 }
2869<FindConceptDocs>[^\*\n]+ {
2870 yyextra->current->initializer << yytext;
2871 }
2872<FindConceptDocs>\n {
2873 yyextra->current->initializer << yytext;
2874 yyextra->yyLineNr++;
2875 }
2876<FindConceptDocs>"*"*{CCE}[ t]*\n? {
2877 if (!yyextra->current->initializer.empty())
2878 {
2879
2881 yyextra->current->section = EntryType::makeConceptDocPart();
2882 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2884 }
2886 yyextra->current->section = EntryType::makeConceptCodePart();
2887 yyextra->current->startLine = yyextra->yyLineNr;
2888 BEGIN(FindConceptParts);
2889 }
2890<FindConceptDocs>"*"*{CCE} {
2891 if (!yyextra->current->initializer.empty())
2892 {
2893
2895 yyextra->current->section = EntryType::makeConceptDocPart();
2896 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2898 }
2899 yyextra->current->section = EntryType::makeConceptCodePart();
2900 yyextra->current->startLine = yyextra->yyLineNr;
2901 BEGIN(FindConceptParts);
2902 }
2903<FindConceptParts><<EOF>> {
2904 if (!yyextra->current->initializer.empty())
2905 {
2906 if (!yyextra->current->section.isConceptCodePart())
2907 {
2908 yyextra->current->section = EntryType::makeConceptDocPart();
2909 }
2910 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
2912 }
2914 }
2915<FindMembers,FindFields>{B}*"#" { if (yyextra->insidePHP)
2916 REJECT;
2917 yyextra->lastCPPContext = YY_START;
2918 BEGIN( SkipCPP ) ;
2919 }
2920<FindMembers,FindFields>{B}*"#"{B}*"cmakedefine01" |
2921<FindMembers,FindFields>{B}*"#"{B}*("cmake")?"define" {
2922 if (yyextra->insidePHP)
2923 REJECT;
2924 yyextra->current->bodyLine = yyextra->yyLineNr;
2925 yyextra->current->bodyColumn = yyextra->yyColNr;
2926 yyextra->current->fileName = yyextra->fileName;
2927 yyextra->current->startLine = yyextra->yyLineNr;
2928 yyextra->current->startColumn = yyextra->yyColNr;
2929 yyextra->current->type.clear();
2930 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
2931 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
2932 yyextra->current->section = EntryType::makeDefine();
2933 yyextra->lastDefineContext = YY_START;
2934 BEGIN( SDefine );
2935 }
2936<FindMembers,ReadBody,ReadNSBody,ReadBodyIntf,SkipCurly,SkipCurlyCpp>{B}*"#"{B}+[0-9]+{B}+/"\"" { /* line control directive */
2937 yyextra->yyLineNr = atoi(&yytext[1]);
2938
2939 yyextra->lastPreLineCtrlContext = YY_START;
2940 if (YY_START==ReadBody ||
2941 YY_START==ReadNSBody ||
2942 YY_START==ReadBodyIntf)
2943 {
2944 yyextra->current->program << yytext;
2945 }
2946 BEGIN( PreLineCtrl );
2947 }
2948<PreLineCtrl>"\""[^\n\"]*"\"" {
2950 if (yyextra->lastPreLineCtrlContext==ReadBody ||
2951 yyextra->lastPreLineCtrlContext==ReadNSBody ||
2952 yyextra->lastPreLineCtrlContext==ReadBodyIntf)
2953 {
2954 yyextra->current->program << yytext;
2955 }
2956 }
static QCString stripQuotes(const char *s)
2958 if (yyextra->lastPreLineCtrlContext==ReadBody ||
2959 yyextra->lastPreLineCtrlContext==ReadNSBody ||
2960 yyextra->lastPreLineCtrlContext==ReadBodyIntf)
2961 {
2962 yyextra->current->program << yytext;
2963 }
2964 }
2966 if (yyextra->lastPreLineCtrlContext==ReadBody ||
2967 yyextra->lastPreLineCtrlContext==ReadNSBody ||
2968 yyextra->lastPreLineCtrlContext==ReadBodyIntf)
2969 {
2970 yyextra->current->program << yytext;
2971 }
2973 BEGIN( yyextra->lastPreLineCtrlContext );
2974 }
2975<SkipCPP>.
2976<SkipCPP>\\[\r]*"\n"[\r]* { lineCount(yyscanner); }
2977<SkipCPP>[\r]*\n[\r]* { lineCount(yyscanner);
2978 BEGIN( yyextra->lastCPPContext) ;
2979 }
2980<SDefine>{ID}{B}*"(" {
2981 yyextra->current->name = yytext;
2982 yyextra->current->name = yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
2983 yyextra->current->args = "(";
2984 yyextra->current->bodyLine = yyextra->yyLineNr;
2985 yyextra->current->bodyColumn = yyextra->yyColNr;
2986 yyextra->currentArgumentContext = DefineEnd;
2987 yyextra->fullArgString=yyextra->current->args;
2988 yyextra->copyArgString=&yyextra->current->args;
2989 BEGIN( ReadFuncArgType ) ;
2990 }
2991
2992<DefineArg>")" {
2993
2994 yyextra->current->args += ')';
2995 BEGIN( DefineEnd );
2996 }
2997<DefineArg>. {
2998 yyextra->current->args += *yytext;
2999 }
3000 */
3001<SDefine>{ID} {
3002
3004 yyextra->current->bodyLine = yyextra->yyLineNr;
3005 yyextra->current->bodyColumn = yyextra->yyColNr;
3006 yyextra->current->name = yytext;
3007 BEGIN(DefineEnd);
3008 }
3009<DefineEnd><<EOF>> |
3010<DefineEnd>\n {
3011
3013 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
3015 BEGIN(yyextra->lastDefineContext);
3016 }
3017<DefinePHPEnd>";" {
3018
3019 yyextra->current->fileName = yyextra->fileName;
3020 yyextra->current->startLine = yyextra->yyLineNr;
3021 yyextra->current->startColumn = yyextra->yyColNr;
3022 yyextra->current->type.clear();
3023 yyextra->current->type = "const";
3027 yyextra->current->initializer.str(
init.str());
3028 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
3029 yyextra->current->section = EntryType::makeVariable();
3030 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
3032 BEGIN(FindMembers);
3033 }
3034<DefinePHPEnd>.
3035<DefineEnd>\\[\r]?\n {
3037 yyextra->current->endBodyLine = yyextra->yyLineNr;
3038 }
3039<DefineEnd>\" {
3040 if (yyextra->insideIDL && yyextra->insideCppQuote)
3041 {
3042 BEGIN(EndCppQuote);
3043 }
3044 else
3045 {
3046 yyextra->lastStringContext=DefineEnd;
3047 BEGIN(SkipString);
3048 }
3049 }
3050<DefineEnd>.
3051<DefinePHP>{ID}["']{BN}*","{BN}* {
3052 yyextra->current->name = yytext;
3053 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
3054 yyextra->current->name = yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
3055 yyextra->current->name = yyextra->current->name.left(yyextra->current->name.length()-1);
3056 yyextra->current->bodyLine = yyextra->yyLineNr;
3057 yyextra->current->bodyColumn = yyextra->yyColNr;
3058 yyextra->lastRoundContext = DefinePHPEnd;
3059 yyextra->pCopyRoundGString = &yyextra->current->initializer;
3060 yyextra->roundCount = 0;
3061 BEGIN( GCopyRound );
3062 }
3063
3064<FindMembers>[\^%] { // ^ and % are C++/CLI extensions
3065 if (yyextra->insideCli)
3066 {
3068 yyextra->current->name = yytext ;
3069 }
3070 else
3071 {
3072 REJECT;
3073 }
3074 }
3075<FindMembers>[*&]+ {
3076 yyextra->current->name += yytext ;
3078 }
3079<FindMembers,MemberSpec,SFunction,NextSemi,EnumBaseType,BitFields,ReadInitializer,ReadInitializerPtr,OldStyleArgs,DefinePHPEnd>";"{BN}*{DCOMM}"<" {
3080 if (YY_START==ReadInitializer && yyextra->keepComment)
3081 {
3082 REJECT;
3083 }
3084 else
3085 {
3086 if (yyextra->current->bodyLine==-1)
3087 {
3088 yyextra->current->bodyLine=yyextra->yyLineNr;
3089 yyextra->current->bodyColumn = yyextra->yyColNr;
3090 }
3091 yyextra->docBlockContext = YY_START;
3092 yyextra->docBlockInBody =
FALSE;
3093 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
3095
3098 yyextra->docBlock.
str(indent.
str());
3099
static int computeIndent(const char *s, int startIndent)
3101
3102 yyextra->docBlockTerm = ';';
3103 if (YY_START==EnumBaseType && yyextra->current->section.isEnum())
3104 {
3105 yyextra->current->bitfields = ":"+yyextra->current->args;
3106 yyextra->current->args.clear();
3107 yyextra->current->section = EntryType::makeVariable();
3108 }
3109 if (yytext[yyleng-3]=='/')
3110 {
3112 BEGIN( DocLine );
3113 }
3114 else
3115 {
3117 BEGIN( DocBlock );
3118 }
3119 }
3120 }
static void startCommentBlock(yyscan_t yyscanner, bool)
3121<MemberSpec,FindFields,FindMembers,NextSemi,EnumBaseType,BitFields,ReadInitializer,ReadInitializerPtr,OldStyleArgs>","{BN}*{DCOMM}"<" {
3122 if (YY_START==ReadInitializer && yyextra->keepComment)
3123 {
3124 REJECT;
3125 }
3126 else
3127 {
3128 yyextra->docBlockContext = YY_START;
3129 yyextra->docBlockInBody =
FALSE;
3130 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
3132
3135 yyextra->docBlock.
str(indent.
str());
3137
3138 yyextra->docBlockTerm = ',';
3139 if (YY_START==EnumBaseType && yyextra->current->section.isEnum())
3140 {
3141 yyextra->current->bitfields = ":"+yyextra->current->args;
3142 yyextra->current->args.clear();
3143 yyextra->current->section = EntryType::makeVariable();
3144 }
3145 if (yytext[yyleng-3]=='/')
3146 {
3148 BEGIN( DocLine );
3149 }
3150 else
3151 {
3153 BEGIN( DocBlock );
3154 }
3155 }
3156 }
3157<DefineEnd,FindFields,ReadInitializer,ReadInitializerPtr,OldStyleArgs>{BN}*{DCOMM}"<" {
3158 if (YY_START==ReadInitializer && yyextra->keepComment)
3159 {
3160 REJECT;
3161 }
3162 else
3163 {
3164 if (yyextra->current->bodyLine==-1)
3165 {
3166 yyextra->current->bodyLine=yyextra->yyLineNr;
3167 yyextra->current->bodyColumn = yyextra->yyColNr;
3168 }
3169 yyextra->docBlockContext = YY_START;
3170 yyextra->docBlockInBody =
FALSE;
3171 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
3175 yyextra->docBlock.
str(indent.
str());
3177
3178 yyextra->docBlockTerm = 0;
3179 if (yytext[yyleng-3]=='/')
3180 {
3182 BEGIN( DocLine );
3183 }
3184 else
3185 {
3187 BEGIN( DocBlock );
3188 }
3189 }
3190 }
3191
3192<FindMembers,FindFields>({CPPC}([!/]){B}*{CMD}"{")|({CCS}([!*]){B}*{CMD}"{") {
3193
3194 if (yyextra->previous && yyextra->previous->section.isGroupDoc())
3195 {
3196
3197 yyextra->commentScanner.open(yyextra->previous.get(),yyextra->fileName,yyextra->yyLineNr);
3198 }
3199 else
3200 {
3201
3202 yyextra->commentScanner.open(yyextra->current.get(),yyextra->fileName,yyextra->yyLineNr);
3203 }
3204
3206 if (yytext[1]=='/')
3207 {
3208 if (yytext[2]=='!' || yytext[2]=='/')
3209 {
3210 yyextra->docBlockContext = YY_START;
3211 yyextra->docBlockInBody =
FALSE;
3212 yyextra->docBlockAutoBrief =
FALSE;
3213 yyextra->docBlock.str(std::string());
3214 yyextra->docBlockTerm = 0;
3216 BEGIN(DocLine);
3217 }
3218 else
3219 {
3220 yyextra->lastCContext=YY_START;
3221 BEGIN(SkipCxxComment);
3222 }
3223 }
3224 else
3225 {
3226 if (yytext[2]=='!' || yytext[2]=='*')
3227 {
3228 yyextra->docBlockContext = YY_START;
3229 yyextra->docBlockInBody =
FALSE;
3230 yyextra->docBlock.str(std::string());
3231 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
3233 yyextra->docBlockTerm = 0;
3235 BEGIN(DocBlock);
3236 }
3237 else
3238 {
3239 yyextra->lastCContext=YY_START;
3240 BEGIN(SkipComment);
3241 }
3242 }
3243 }
3244<FindMembers,FindFields,ReadInitializer,ReadInitializerPtr>{CPPC}([!/]){B}*{CMD}"}".*|{CCS}([!*]){B}*{CMD}"}"[^*]*{CCE} {
3245 bool insideEnum = YY_START==FindFields || ((YY_START==ReadInitializer || YY_START==ReadInitializerPtr) && yyextra->lastInitializerContext==FindFields);
3246 yyextra->commentScanner.close(yyextra->current.get(),yyextra->fileName,yyextra->yyLineNr,insideEnum);
3248 }
3249<FindMembers>"=>" {
3250 if (!yyextra->insideCS) REJECT;
3251 yyextra->current->bodyLine = yyextra->yyLineNr;
3252 yyextra->current->bodyColumn = yyextra->yyColNr;
3253 yyextra->current->initializer.str(yytext);
3254 yyextra->lastInitializerContext = YY_START;
3255 yyextra->sharpCount=0;
3256 yyextra->initBracketCount=0;
3257 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
3258 yyextra->current->spec.setGettable(true);
3259 BEGIN(ReadInitializerPtr);
3260 }
3261<FindMembers>"=" { // in PHP code this could also be due to "<?="
3262 yyextra->current->bodyLine = yyextra->yyLineNr;
3263 yyextra->current->bodyColumn = yyextra->yyColNr;
3264 yyextra->current->initializer.str(" ");
3265 for (int ii = 2 ; ii < yyextra->yyColNr; ii++)
3266 yyextra->current->initializer << " ";
3267 yyextra->current->initializer << "=";
3268 yyextra->lastInitializerContext = YY_START;
3269 yyextra->sharpCount=0;
3270 yyextra->initBracketCount=0;
3271 BEGIN(ReadInitializer);
3272 }
3273<UNOIDLAttributeBlock>{BN}*[gs]"et"{BN}+"raises"{BN}*"("{BN}*{SCOPENAME}{BN}*(","{BN}*{SCOPENAME}{BN}*)*")"{BN}*";" {
3275 yyextra->current->exception += " ";
3277 }
3278<UNOIDLAttributeBlock>"}" {
3279 yyextra->current->exception += " }";
3280 BEGIN(FindMembers);
3281 }
3282
3283<ReadInitializer,ReadInitializerPtr>"(" {
3284 yyextra->lastRoundContext=YY_START;
3285 yyextra->pCopyRoundGString=&yyextra->current->initializer;
3286 yyextra->roundCount=0;
3287 yyextra->current->initializer << *yytext;
3288 BEGIN(GCopyRound);
3289 }
3290<ReadInitializer,ReadInitializerPtr>"[" {
3291 if (!yyextra->insidePHP) REJECT;
3292 yyextra->lastSquareContext=YY_START;
3293 yyextra->pCopySquareGString=&yyextra->current->initializer;
3294 yyextra->squareCount=0;
3295 yyextra->current->initializer << *yytext;
3296 BEGIN(GCopySquare);
3297 }
3298<ReadInitializer,ReadInitializerPtr>"{" {
3299 yyextra->lastCurlyContext=YY_START;
3300 yyextra->pCopyCurlyGString=&yyextra->current->initializer;
3301 yyextra->curlyCount=0;
3302 yyextra->current->initializer << *yytext;
3303 BEGIN(GCopyCurly);
3304 }
3305<ReadInitializer,ReadInitializerPtr>[;,] {
3306
3307 if (*yytext==';' && yyextra->current_root->spec.isEnum())
3308 {
3309 yyextra->current->fileName = yyextra->fileName;
3310 yyextra->current->startLine = yyextra->yyLineNr;
3311 yyextra->current->startColumn = yyextra->yyColNr;
3312 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
3313 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
3314 yyextra->current->section = EntryType::makeVariable();
3315 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
3317 BEGIN(FindMembers);
3318 }
3319 else if (*yytext==';' || (yyextra->lastInitializerContext==FindFields && yyextra->initBracketCount==0))
3320 {
3321 unput(*yytext);
3322 if (YY_START == ReadInitializerPtr) yyextra->current->initializer.str(std::string());
3323 BEGIN(yyextra->lastInitializerContext);
3324 }
3325 else if (*yytext==',' && yyextra->initBracketCount==0)
3326 {
3327 unput(*yytext);
3328 if (YY_START == ReadInitializerPtr) yyextra->current->initializer.str(std::string());
3329 BEGIN(yyextra->lastInitializerContext);
3330 }
3331 else
3332 {
3333 yyextra->current->initializer << *yytext;
3334 }
3335 }
3336<ReadInitializer,ReadInitializerPtr>{RAWBEGIN} { // C++11 raw string
3337 if (!yyextra->insideCpp)
3338 {
3339 REJECT;
3340 }
3341 else
3342 {
3343 yyextra->current->initializer << yytext;
3345 yyextra->lastRawStringContext = YY_START;
3346 yyextra->pCopyRawGString = &yyextra->current->initializer;
3347 BEGIN(RawGString);
3348
3349 }
3350 }
QCString extractBeginRawStringDelimiter(const char *rawStart)
3351<ReadInitializer>{CPPC}.* {
3352 if (yyextra->keepComment)
3353 {
3354 yyextra->current->initializer << yytext;
3355 }
3356 else
3357 {
3358 REJECT;
3359 }
3360 }
3361<ReadInitializer>{CCS} {
3362 if (yyextra->keepComment)
3363 {
3364 yyextra->current->initializer << yytext;
3365 BEGIN(InitCopyComment);
3366 }
3367 else
3368 {
3369 REJECT;
3370 }
3371 }
3372<InitCopyComment>{CCE} {
3373 yyextra->current->initializer << yytext;
3374 BEGIN(ReadInitializer);
3375 }
3376<InitCopyComment>\n {
3378 yyextra->current->initializer << yytext;
3379 }
3380<InitCopyComment>. {
3381 yyextra->current->initializer << yytext;
3382 }
3383<InitCopyComment><<EOF>> {
3384 warn(yyextra->fileName,yyextra->yyLineNr,
3385 "reached end of file while inside a C style comment block!");
3387 }
3388<RawGString>{RAWEND} {
3390 {
3391 *yyextra->pCopyRawGString << yytext;
3392 BEGIN(yyextra->lastRawStringContext);
3393 }
3394 else
3395 {
3396 REJECT;
3397 }
3398 }
QCString extractEndRawStringDelimiter(const char *rawEnd)
3399<RawGString>[^)\n]+ {
3400 *yyextra->pCopyRawGString << yytext;
3401 }
3402<RawGString>. {
3403 *yyextra->pCopyRawGString << yytext;
3404 }
3405<RawGString>\n {
3406 *yyextra->pCopyRawGString << yytext;
3408 }
3409<RawString>{RAWEND} {
3410 *yyextra->pCopyRawString+=yytext;
3411 yyextra->fullArgString+=yytext;
3413 {
3414 BEGIN(yyextra->lastRawStringContext);
3415 }
3416 }
3417<RawString>[^)]+ {
3418 *yyextra->pCopyRawString += yytext;
3419 yyextra->fullArgString+=yytext;
3420 }
3421<RawString>. {
3422 *yyextra->pCopyRawString += yytext;
3423 yyextra->fullArgString+=yytext;
3424 }
3425<RawString>\n {
3426 *yyextra->pCopyRawString += yytext;
3427 yyextra->fullArgString+=yytext;
3429 }
3430<ReadInitializer,ReadInitializerPtr>\" {
3431 if (yyextra->insideIDL && yyextra->insideCppQuote)
3432 {
3433 BEGIN(EndCppQuote);
3434 }
3435 else
3436 {
3437 yyextra->lastStringContext=YY_START;
3438 yyextra->current->initializer << yytext;
3439 yyextra->pCopyQuotedGString=&yyextra->current->initializer;
3440 yyextra->stopAtInvalidString=false;
3441 BEGIN(CopyGString);
3442 }
3443 }
3444<ReadInitializer,ReadInitializerPtr>"->" {
3445 yyextra->current->initializer << yytext;
3446 }
3447<ReadInitializer,ReadInitializerPtr>("<<"|"<=") {
3448 yyextra->current->initializer << yytext;
3449 }
3450<ReadInitializer,ReadInitializerPtr>(">>") {
3451 if (yyextra->initBracketCount<=yyextra->sharpCount && yyextra->sharpCount>=2)
3452 {
3453
3454 yyextra->initBracketCount-=2;
3455 yyextra->sharpCount-=2;
3456 }
3457 yyextra->current->initializer << yytext;
3458 }
3459<ReadInitializer,ReadInitializerPtr>(">=") {
3460 yyextra->current->initializer << yytext;
3461 }
3462<ReadInitializer,ReadInitializerPtr>[<\[{(] {
3463 yyextra->initBracketCount++;
3464 yyextra->sharpCount++;
3465 yyextra->current->initializer << *yytext;
3466 }
3467<ReadInitializer,ReadInitializerPtr>[>\]})] {
3468 yyextra->initBracketCount--;
3469 yyextra->sharpCount--;
3470 if (*yytext=='}')
3471 {
3472 yyextra->current->endBodyLine=yyextra->yyLineNr;
3473 }
3474 yyextra->current->initializer << *yytext;
3475 }
3476<ReadInitializer,ReadInitializerPtr>\' {
3477 if (yyextra->insidePHP)
3478 {
3479 yyextra->current->initializer << yytext;
3480 yyextra->pCopyQuotedGString = &yyextra->current->initializer;
3481 yyextra->lastStringContext=YY_START;
3482 BEGIN(CopyPHPGString);
3483 }
3484 else
3485 {
3486 yyextra->current->initializer << yytext;
3487 }
3488 }
3489<ReadInitializer,ReadInitializerPtr>{CHARLIT} {
3490 if (yyextra->insidePHP)
3491 {
3492 REJECT;
3493 }
3494 else
3495 {
3496 yyextra->current->initializer << yytext;
3497 }
3498 }
3499<ReadInitializer,ReadInitializerPtr>\n {
3500 yyextra->current->initializer << *yytext;
3502 }
3503<ReadInitializer,ReadInitializerPtr>"@\"" {
3504
3505 yyextra->current->initializer << yytext;
3506 if (!yyextra->insideCS && !yyextra->insideObjC)
3507 {
3508 REJECT;
3509 }
3510 else
3511 {
3512
3513 yyextra->lastSkipVerbStringContext=YY_START;
3514 yyextra->pSkipVerbString=&yyextra->current->initializer;
3515 BEGIN(SkipVerbString);
3516 }
3517 }
3518<SkipVerbString>[^\n"\\]+ {
3519 *yyextra->pSkipVerbString << yytext;
3520 }
3521<SkipVerbString>"\\\\" { // escaped backslash
3522 if (yyextra->insideCS) REJECT
3523 *yyextra->pSkipVerbString << yytext;
3524 }
3525<SkipVerbString>"\\\"" { // backslash escaped quote
3526 if (yyextra->insideCS) REJECT
3527 *yyextra->pSkipVerbString << yytext;
3528 }
3529<SkipVerbString>"\"\"" { // quote escape
3530 *yyextra->pSkipVerbString << yytext;
3531 }
3532<SkipVerbString>"\"" {
3533 *yyextra->pSkipVerbString << *yytext;
3534 BEGIN(yyextra->lastSkipVerbStringContext);
3535 }
3536<SkipVerbString>\n {
3537 *yyextra->pSkipVerbString << *yytext;
3539 }
3540<SkipVerbString>. {
3541 *yyextra->pSkipVerbString << *yytext;
3542 }
3543<ReadInitializer,ReadInitializerPtr>"?>" {
3544 if (yyextra->insidePHP)
3545 BEGIN( FindMembersPHP );
3546 else
3547 yyextra->current->initializer << yytext;
3548 }
3549<ReadInitializer,ReadInitializerPtr>. {
3550 yyextra->current->initializer << *yytext;
3551 }
3552
3553
3554<CopyString,CopyPHPString>\\. {
3555 *yyextra->pCopyQuotedString+=yytext;
3556 }
3557<CopyString>\" {
3558 *yyextra->pCopyQuotedString+=*yytext;
3559 BEGIN( yyextra->lastStringContext );
3560 }
3561<CopyPHPString>\' {
3562 *yyextra->pCopyQuotedString+=*yytext;
3563 BEGIN( yyextra->lastStringContext );
3564 }
3565<CopyString,CopyPHPString>{CCS}|{CCE}|{CPPC} {
3566 *yyextra->pCopyQuotedString+=yytext;
3567 }
3568<CopyString,CopyPHPString>\n {
3569 *yyextra->pCopyQuotedString+=*yytext;
3571 }
3572<CopyString,CopyPHPString>. {
3573 *yyextra->pCopyQuotedString+=*yytext;
3574 }
3575
3576
3577<CopyGString,CopyPHPGString>\\. {
3578 *yyextra->pCopyQuotedGString << yytext;
3579 }
3580<CopyGString>\" {
3581 *yyextra->pCopyQuotedGString << *yytext;
3582 BEGIN( yyextra->lastStringContext );
3583 }
3584<CopyPHPGString>\' {
3585 *yyextra->pCopyQuotedGString << *yytext;
3586 BEGIN( yyextra->lastStringContext );
3587 }
3588<CopyGString,CopyPHPGString>"<?php" { // we had an odd number of quotes.
3589 *yyextra->pCopyQuotedGString << yytext;
3590 BEGIN( yyextra->lastStringContext );
3591 }
3592<CopyGString,CopyPHPGString>{CCS}|{CCE}|{CPPC} {
3593 *yyextra->pCopyQuotedGString << yytext;
3594 }
3595<CopyGString,CopyPHPGString>\n {
3596 *yyextra->pCopyQuotedGString << *yytext;
3597 if (yyextra->stopAtInvalidString)
3598 {
3599 BEGIN( yyextra->lastStringContext );
3600 }
3601 else
3602 {
3604 }
3605 }
3606<CopyGString,CopyPHPGString>. {
3607 *yyextra->pCopyQuotedGString << *yytext;
3608 }
3609
3610
3611<CopyRound>\" {
3612 *yyextra->pCopyRoundString += *yytext;
3613 yyextra->pCopyQuotedString=yyextra->pCopyRoundString;
3614 yyextra->lastStringContext=YY_START;
3615 BEGIN(CopyString);
3616 }
3617<CopyRound>"(" {
3618 *yyextra->pCopyRoundString += *yytext;
3619 yyextra->roundCount++;
3620 }
3621<CopyRound>")" {
3622 *yyextra->pCopyRoundString += *yytext;
3623 if (--yyextra->roundCount<0)
3624 BEGIN(yyextra->lastRoundContext);
3625 }
3626<CopyRound>\n {
3628 *yyextra->pCopyRoundString += *yytext;
3629 }
3630<CopyRound>\' {
3631 if (yyextra->insidePHP)
3632 {
3633 yyextra->current->initializer << yytext;
3634 yyextra->pCopyQuotedString = yyextra->pCopyRoundString;
3635 yyextra->lastStringContext=YY_START;
3636 BEGIN(CopyPHPString);
3637 }
3638 else
3639 {
3640 *yyextra->pCopyRoundString += yytext;
3641 }
3642 }
3643<CopyRound>{CHARLIT} {
3644 if (yyextra->insidePHP)
3645 {
3646 REJECT;
3647 }
3648 else
3649 {
3650 *yyextra->pCopyRoundString+=yytext;
3651 }
3652 }
3653<CopyRound>[^"'()\n,]+ {
3654 *yyextra->pCopyRoundString+=yytext;
3655 }
3656<CopyRound>. {
3657 *yyextra->pCopyRoundString+=*yytext;
3658 }
3659
3660
3661<CopySharp>\" {
3662 *yyextra->pCopySharpString += *yytext;
3663 yyextra->pCopyQuotedString=yyextra->pCopySharpString;
3664 yyextra->lastStringContext=YY_START;
3665 BEGIN(CopyString);
3666 }
3667<CopySharp>"<" {
3668 *yyextra->pCopySharpString += *yytext;
3669 yyextra->sharpCount++;
3670 }
3671<CopySharp>">" {
3672 *yyextra->pCopySharpString += *yytext;
3673 if (--yyextra->sharpCount<0)
3674 {
3675 BEGIN(yyextra->lastSharpContext);
3676 }
3677 }
3678<CopySharp>\n {
3680 *yyextra->pCopySharpString += *yytext;
3681 }
3682<CopySharp>\' {
3683 if (yyextra->insidePHP)
3684 {
3685 yyextra->current->initializer << yytext;
3686 yyextra->pCopyQuotedString = yyextra->pCopySharpString;
3687 yyextra->lastStringContext=YY_START;
3688 BEGIN(CopyPHPString);
3689 }
3690 else
3691 {
3692 *yyextra->pCopySharpString += yytext;
3693 }
3694 }
3695<CopySharp>{CHARLIT} {
3696 if (yyextra->insidePHP)
3697 {
3698 REJECT;
3699 }
3700 else
3701 {
3702 *yyextra->pCopySharpString+=yytext;
3703 }
3704 }
3705<CopySharp>[^"'<>\n,]+ {
3706 *yyextra->pCopySharpString+=yytext;
3707 }
3708<CopySharp>. {
3709 *yyextra->pCopySharpString+=*yytext;
3710 }
3711
3712
3713
3714<GCopyRound>\" {
3715 *yyextra->pCopyRoundGString << *yytext;
3716 yyextra->pCopyQuotedGString=yyextra->pCopyRoundGString;
3717 yyextra->lastStringContext=YY_START;
3718 BEGIN(CopyGString);
3719 }
3720<GCopyRound>"(" {
3721 *yyextra->pCopyRoundGString << *yytext;
3722 yyextra->roundCount++;
3723 }
3724<GCopyRound>")" {
3725 *yyextra->pCopyRoundGString << *yytext;
3726 if (--yyextra->roundCount<0)
3727 BEGIN(yyextra->lastRoundContext);
3728 }
3729<GCopyRound>\n {
3731 *yyextra->pCopyRoundGString << *yytext;
3732 }
3733<GCopyRound>\' {
3734 if (yyextra->insidePHP)
3735 {
3736 yyextra->current->initializer << yytext;
3737 yyextra->pCopyQuotedGString = yyextra->pCopyRoundGString;
3738 yyextra->lastStringContext=YY_START;
3739 BEGIN(CopyPHPGString);
3740 }
3741 else
3742 {
3743 *yyextra->pCopyRoundGString << yytext;
3744 }
3745 }
3746<GCopyRound>{CHARLIT} {
3747 if (yyextra->insidePHP)
3748 {
3749 REJECT;
3750 }
3751 else
3752 {
3753 *yyextra->pCopyRoundGString << yytext;
3754 }
3755 }
3756<GCopyRound>"@\"" {
3757 if (!yyextra->insideCS) REJECT;
3758 *yyextra->pCopyRoundGString << yytext;
3759 yyextra->lastSkipVerbStringContext=YY_START;
3760 yyextra->pSkipVerbString=yyextra->pCopyRoundGString;
3761 BEGIN(SkipVerbString);
3762 }
3763<GCopyRound>[^"'()\n\/,R]+ { // R because of raw string start
3764 *yyextra->pCopyRoundGString << yytext;
3765 }
3766<GCopyRound>{RAWBEGIN} {
3767 *yyextra->pCopyRoundGString << yytext;
3769 yyextra->lastRawStringContext = YY_START;
3770 yyextra->pCopyRawGString = yyextra->pCopyRoundGString;
3771 BEGIN(RawGString);
3772 }
3773<GCopyRound>. {
3774 *yyextra->pCopyRoundGString << *yytext;
3775 }
3776
3777
3778<GCopySquare>\" {
3779 *yyextra->pCopySquareGString << *yytext;
3780 yyextra->pCopyQuotedGString=yyextra->pCopySquareGString;
3781 yyextra->lastStringContext=YY_START;
3782 BEGIN(CopyGString);
3783 }
3784<GCopySquare>\' {
3785 *yyextra->pCopySquareGString << *yytext;
3786 if (yyextra->insidePHP)
3787 {
3788 yyextra->pCopyQuotedGString=yyextra->pCopySquareGString;
3789 yyextra->lastStringContext=YY_START;
3790 BEGIN(CopyPHPGString);
3791 }
3792 }
3793<GCopySquare>"[" {
3794 *yyextra->pCopySquareGString << *yytext;
3795 yyextra->squareCount++;
3796 }
3797<GCopySquare>"]" {
3798 *yyextra->pCopySquareGString << *yytext;
3799 if (--yyextra->squareCount<0)
3800 BEGIN(yyextra->lastSquareContext);
3801 }
3802<GCopySquare>\n {
3804 *yyextra->pCopySquareGString << *yytext;
3805 }
3806<GCopySquare>\' {
3807 if (yyextra->insidePHP)
3808 {
3809 yyextra->current->initializer << yytext;
3810 yyextra->pCopyQuotedGString = yyextra->pCopySquareGString;
3811 yyextra->lastStringContext=YY_START;
3812 BEGIN(CopyPHPGString);
3813 }
3814 else
3815 {
3816 *yyextra->pCopySquareGString << yytext;
3817 }
3818 }
3819<GCopySquare>{CHARLIT} {
3820 if (yyextra->insidePHP)
3821 {
3822 REJECT;
3823 }
3824 else
3825 {
3826 *yyextra->pCopySquareGString << yytext;
3827 }
3828 }
3829<GCopySquare>[^"'\[\]\n\/,]+ {
3830 *yyextra->pCopySquareGString << yytext;
3831 }
3832<GCopySquare>. {
3833 *yyextra->pCopySquareGString << *yytext;
3834 }
3835
3836
3837<CopyCurly>\" {
3838 *yyextra->pCopyCurlyString += *yytext;
3839 yyextra->pCopyQuotedString=yyextra->pCopyCurlyString;
3840 yyextra->lastStringContext=YY_START;
3841 yyextra->keepComment=false;
3842 BEGIN(CopyString);
3843 }
3844<CopyCurly>\' {
3845 *yyextra->pCopyCurlyString += *yytext;
3846 if (yyextra->insidePHP)
3847 {
3848 yyextra->pCopyQuotedString=yyextra->pCopyCurlyString;
3849 yyextra->lastStringContext=YY_START;
3850 yyextra->keepComment=false;
3851 BEGIN(CopyPHPString);
3852 }
3853 }
3854<CopyCurly>"{" {
3855 *yyextra->pCopyCurlyString += *yytext;
3856 yyextra->curlyCount++;
3857 }
3858<CopyCurly>"}" {
3859 *yyextra->pCopyCurlyString += *yytext;
3860 if (--yyextra->curlyCount<0)
3861 {
3862 yyextra->keepComment=false;
3863 BEGIN(yyextra->lastCurlyContext);
3864 }
3865 }
3866<CopyCurly>{CHARLIT} { if (yyextra->insidePHP)
3867 {
3868 REJECT;
3869 }
3870 else
3871 {
3872 *yyextra->pCopyCurlyString += yytext;
3873 }
3874 }
3875<CopyCurly>[^"'{}\/\n,]+ {
3876 *yyextra->pCopyCurlyString += yytext;
3877 }
3878<CopyCurly>"/" { *yyextra->pCopyCurlyString += yytext; }
3879<CopyCurly>\n {
3881 *yyextra->pCopyCurlyString += *yytext;
3882 }
3883<CopyCurly>. {
3884 *yyextra->pCopyCurlyString += *yytext;
3885 }
3886<CopyCurly>{CPPC}[^\n]* {
3887 if (yyextra->keepComment)
3888 {
3889 *yyextra->pCopyCurlyString += yytext;
3890 }
3891 else
3892 {
3893 REJECT;
3894 }
3895 }
3896<CopyCurly>{CCS} {
3897 if (yyextra->keepComment)
3898 {
3899 *yyextra->pCopyCurlyString += yytext;
3900 BEGIN(CopyComment);
3901 }
3902 else
3903 {
3904 REJECT;
3905 }
3906 }
3907<CopyComment>{CCE} {
3908 *yyextra->pCopyCurlyString += yytext;
3909 BEGIN(CopyCurly);
3910 }
3911<CopyComment>\n {
3913 *yyextra->pCopyCurlyString += *yytext;
3914 }
3915<CopyComment>. {
3916 *yyextra->pCopyCurlyString += *yytext;
3917 }
3918<CopyComment><<EOF>> {
3919 warn(yyextra->fileName,yyextra->yyLineNr,
3920 "reached end of file while inside a C style comment block!");
3922 }
3923
3924
3925<GCopyCurly>^"#"{B}+[0-9]+{B}+"\""[^\"\n]+"\""{B}+"1"{B}*\n? { // start of included file marker
3926 }
3927<GCopyCurly>^"#"{B}+[0-9]+{B}+"\""[^\"\n]+"\""{B}+"2"{B}*\n? { // end of included file marker
3929 int s = line.
find(
' ');
3930 int e = line.
find(
'"',s);
3931 yyextra->yyLineNr = line.
mid(s,e-s).
toInt();
3932 if (yytext[yyleng-1]=='\n')
3933 {
3935 yyextra->column=0;
3936 }
3937 }
int toInt(bool *ok=nullptr, int base=10) const
3938<GCopyCurly>\" {
3939 *yyextra->pCopyCurlyGString << *yytext;
3940 yyextra->pCopyQuotedGString=yyextra->pCopyCurlyGString;
3941 yyextra->lastStringContext=YY_START;
3942 yyextra->keepComment = false;
3943 BEGIN(CopyGString);
3944 }
3945<GCopyCurly>\' {
3946 *yyextra->pCopyCurlyGString << *yytext;
3947 if (yyextra->insidePHP)
3948 {
3949 yyextra->pCopyQuotedGString=yyextra->pCopyCurlyGString;
3950 yyextra->lastStringContext=YY_START;
3951 yyextra->keepComment = false;
3952 BEGIN(CopyPHPGString);
3953 }
3954 }
3955<GCopyCurly>"{" {
3956 *yyextra->pCopyCurlyGString << *yytext;
3957 yyextra->curlyCount++;
3958 }
3959<GCopyCurly>"}" {
3960 *yyextra->pCopyCurlyGString << *yytext;
3961 if (--yyextra->curlyCount<0)
3962 {
3963 yyextra->current->endBodyLine = yyextra->yyLineNr;
3964 yyextra->keepComment = false;
3965 BEGIN(yyextra->lastCurlyContext);
3966 }
3967 }
3968<GCopyCurly>{CHARLIT} { if (yyextra->insidePHP)
3969 {
3970 REJECT;
3971 }
3972 else
3973 {
3974 *yyextra->pCopyCurlyGString << yytext;
3975 }
3976 }
3977<GCopyCurly>[^"'{}\/\n,]+ {
3978 *yyextra->pCopyCurlyGString << yytext;
3979 }
3980<GCopyCurly>[,]+ {
3981 *yyextra->pCopyCurlyGString << yytext;
3982 }
3983<GCopyCurly>"/" { *yyextra->pCopyCurlyGString << yytext; }
3984<GCopyCurly>\n {
3986 *yyextra->pCopyCurlyGString << *yytext;
3987 }
3988<GCopyCurly>. {
3989 *yyextra->pCopyCurlyGString << *yytext;
3990 }
3991<GCopyCurly>{CPPC}[^\n]* {
3992 if (yyextra->keepComment)
3993 {
3994 *yyextra->pCopyCurlyGString << yytext;
3995 }
3996 else
3997 {
3998 REJECT;
3999 }
4000 }
4001<GCopyCurly>{CCS} {
4002 if (yyextra->keepComment)
4003 {
4004 *yyextra->pCopyCurlyGString << yytext;
4005 BEGIN(GCopyComment);
4006 }
4007 else
4008 {
4009 REJECT;
4010 }
4011 }
4012<GCopyComment>{CCE} {
4013 *yyextra->pCopyCurlyGString << yytext;
4014 BEGIN(GCopyCurly);
4015 }
4016<GCopyComment>\n {
4018 *yyextra->pCopyCurlyGString << *yytext;
4019 }
4020<GCopyComment>. {
4021 *yyextra->pCopyCurlyGString << *yytext;
4022 }
4023<GCopyComment><<EOF>> {
4024 warn(yyextra->fileName,yyextra->yyLineNr,
4025 "reached end of file while inside a C style comment block!");
4027 }
4028
4029
4030
4031
4032<FindMembers>":" {
4033 if (yyextra->current->type.isEmpty() &&
4034 yyextra->current->name=="enum")
4035 {
4036 yyextra->current->section = EntryType::makeEnum();
4037 yyextra->current->name.clear();
4038 yyextra->current->args.clear();
4039 BEGIN(EnumBaseType);
4040 }
4041 else
4042 {
4043 if (yyextra->current->type.isEmpty())
4044 {
4046 yyextra->current->name.sprintf("__pad%d__",yyextra->padCount++);
4047 }
4048 BEGIN(BitFields);
4049 yyextra->current->bitfields+=":";
4050 }
4051 }
4052<BitFields>. {
4053 yyextra->current->bitfields+=*yytext;
4054 }
4055<EnumBaseType>. {
4056 yyextra->current->args+=*yytext;
4057 }
4058<EnumBaseType>\n {
4060 yyextra->current->args+=' ';
4061 }
4062<FindMembers>[;,] {
4063 QCString oldType = yyextra->current->type;
4064 if (yyextra->current->bodyLine==-1)
4065 {
4066 yyextra->current->bodyLine = yyextra->yyLineNr;
4067 yyextra->current->bodyColumn = yyextra->yyColNr;
4068 }
4069 if ( yyextra->insidePHP && yyextra->current->type.startsWith("var"))
4070 {
4071 yyextra->current->type = yyextra->current->type.mid(3);
4072 }
4073 if (yyextra->isTypedef && !yyextra->current->type.startsWith("typedef "))
4074 {
4075 yyextra->current->type.prepend("typedef ");
4076 }
4077 bool isStatic = yyextra->current->isStatic;
4078 Protection prot = yyextra->current->protection;
4079 bool isConcept = yyextra->current->section.isConcept();
4080 bool isModule = yyextra->current->section.isModuleDoc();
4081 if (isConcept)
4082 {
4083 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4085 }
4086 else if (isModule)
4087 {
4088 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4090 }
4091 else if (!yyextra->current->name.isEmpty() && !yyextra->current->section.isEnum())
4092 {
4093 yyextra->current->type=yyextra->current->type.simplifyWhiteSpace();
4095 yyextra->current->name=yyextra->current->name.stripWhiteSpace();
4096 if (yyextra->current->section.isClass())
4097 {
4099 }
4100 yyextra->current->section = EntryType::makeVariable() ;
4101 yyextra->current->fileName = yyextra->fileName;
4102 yyextra->current->startLine = yyextra->yyBegLineNr;
4103 yyextra->current->startColumn = yyextra->yyBegColNr;
4104 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4106 }
4107 if ( *yytext == ',')
4108 {
4109 yyextra->current->isStatic = isStatic;
4110 yyextra->current->protection = prot;
4111 yyextra->current->name.clear();
4112 yyextra->current->args.clear();
4113 yyextra->current->brief.clear();
4114 yyextra->current->doc.clear();
4115 yyextra->current->initializer.str(std::string());
4116 yyextra->current->bitfields.clear();
4118 }
4119 else
4120 {
4121 yyextra->mtype = MethodTypes::Method;
4122 yyextra->virt = Specifier::Normal;
4123 yyextra->current->bodyLine = -1;
4124 yyextra->current->bodyColumn = 1;
4125 yyextra->current->groups.clear();
4127 }
4128 }
static QCString stripFuncPtr(const QCString &type)
4129
4130<FindMembers>"[" {
4131 if (yyextra->insideSlice)
4132 {
4133 yyextra->squareCount=1;
4134 yyextra->lastSquareContext = YY_START;
4135 yyextra->current->metaData += "[";
4136 BEGIN( SliceMetadata );
4137 }
4138 else if (!yyextra->insideCS &&
4139 (yyextra->current->name.isEmpty() ||
4140 yyextra->current->name=="typedef"
4141 )
4142 )
4143 {
4144 yyextra->squareCount=1;
4145 yyextra->lastSquareContext = YY_START;
4146 yyextra->idlAttr.clear();
4147 yyextra->idlProp.clear();
4148 yyextra->current->mtype = yyextra->mtype;
4149
4151 yyextra->current->mtype == MethodTypes::Property)
4152 {
4153 yyextra->odlProp = true;
4154 yyextra->current->spec.setGettable(true).setSettable(true);
4155 }
4156
4157 BEGIN( IDLAttribute );
4158 }
4159 else if (yyextra->insideCS &&
4160 yyextra->current->name.isEmpty())
4161 {
4162 yyextra->squareCount=1;
4163 yyextra->lastSquareContext = YY_START;
4164
4165
4166 yyextra->current->args.clear();
4167 BEGIN( SkipSquare );
4168 }
4169 else
4170 {
4171 yyextra->current->args += yytext ;
4172 yyextra->squareCount=1;
4173 yyextra->externLinkage=
FALSE;
4174 BEGIN( Array ) ;
4175 }
4176 }
4177<SliceMetadata>"[" { // Global metadata.
4178 yyextra->squareCount++;
4179 yyextra->current->metaData += "[";
4180 }
4181<SliceMetadata>{BN}* {
4183 }
4184<SliceMetadata>\"[^\"]*\" {
4185 yyextra->current->metaData += yytext;
4186 }
4187<SliceMetadata>"," {
4188 yyextra->current->metaData += yytext;
4189 }
4190<SliceMetadata>"]" {
4191 yyextra->current->metaData += yytext;
4192 if (--yyextra->squareCount<=0)
4193 {
4194 BEGIN (yyextra->lastSquareContext);
4195 }
4196 }
4197<SliceOptional>"(" {
4198 yyextra->current->type += "(";
4199 yyextra->roundCount++;
4200 }
4201<SliceOptional>[0-9]+ {
4202 yyextra->current->type += yytext;
4203 }
4204<SliceOptional>")" {
4205 yyextra->current->type += ")";
4206 if(--yyextra->roundCount<=0)
4207 {
4208 BEGIN (yyextra->lastModifierContext);
4209 }
4210 }
4211<IDLAttribute>"]" {
4212
4213 if (--yyextra->squareCount<=0)
4214 {
4216 if (yyextra->current->mtype == MethodTypes::Property)
4217 BEGIN( IDLPropName );
4218 else
4219 BEGIN( yyextra->lastSquareContext );
4220 }
4221 }
4222<IDLAttribute>"propput" {
4224 {
4225 yyextra->current->mtype = MethodTypes::Property;
4226 }
4227 yyextra->current->spec.setSettable(true);
4228 }
4229<IDLAttribute>"propget" {
4231 {
4232 yyextra->current->mtype = MethodTypes::Property;
4233 }
4234 yyextra->current->spec.setGettable(true);
4235 }
4236<IDLAttribute>"property" { // UNO IDL property
4237 yyextra->current->spec.setProperty(true);
4238 }
4239<IDLAttribute>"attribute" { // UNO IDL attribute
4240 yyextra->current->spec.setAttribute(true);
4241 }
4242<IDLAttribute>"optional" { // on UNO IDL interface/service/attribute/property
4243 yyextra->current->spec.setOptional(true);
4244 }
4245<IDLAttribute>"readonly" { // on UNO IDL attribute or property
4247 {
4248 yyextra->current->spec.setSettable(false);
4249 }
4250 else
4251 {
4252 yyextra->current->spec.setReadonly(true);
4253 }
4254 }
4255<IDLAttribute>"bound" { // on UNO IDL attribute or property
4256 yyextra->current->spec.setBound(true);
4257 }
4258<IDLAttribute>"removable" { // on UNO IDL property
4259 yyextra->current->spec.setRemovable(true);
4260 }
4261<IDLAttribute>"constrained" { // on UNO IDL property
4262 yyextra->current->spec.setConstrained(true);
4263 }
4264<IDLAttribute>"transient" { // on UNO IDL property
4265 yyextra->current->spec.setTransient(true);
4266 }
4267<IDLAttribute>"maybevoid" { // on UNO IDL property
4268 yyextra->current->spec.setMaybeVoid(true);
4269 }
4270<IDLAttribute>"maybedefault" { // on UNO IDL property
4271 yyextra->current->spec.setMaybeDefault(true);
4272 }
4273<IDLAttribute>"maybeambiguous" { // on UNO IDL property
4274 yyextra->current->spec.setMaybeAmbiguous(true);
4275 }
4276<IDLAttribute>. {
4277 }
4278<IDLPropName>{BN}*{ID}({BN}*[*]*{BN}*)? {
4279
4280
4281 if (yyextra->odlProp)
4282 {
4283 yyextra->idlProp = yytext;
4284 }
4285 }
4286<IDLPropName>{ID}{BN}*"(" {
4287 yyextra->current->name = yytext;
4288 yyextra->current->name = yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
4289 yyextra->current->startLine = yyextra->yyLineNr;
4290 yyextra->current->startColumn = yyextra->yyColNr;
4291 BEGIN( IDLProp );
4292 }
4293<IDLPropName>{BN}*"("{BN}*{ID}{BN}*")"{BN}* {
4294 if (yyextra->odlProp)
4295 {
4296 yyextra->idlProp += yytext;
4297 }
4298 }
4299<IDLPropName>{ID}{BNopt}/";" {
4300 if (yyextra->odlProp)
4301 {
4302 yyextra->current->name = yytext;
4303 yyextra->idlProp = yyextra->idlProp.stripWhiteSpace();
4304 yyextra->odlProp = false;
4305
4306 BEGIN( IDLProp );
4307 }
4308 }
4309<IDLProp>{BN}*"["[^\]]*"]"{BN}* { // attribute of a parameter
4310 yyextra->idlAttr = yytext;
4311 yyextra->idlAttr=yyextra->idlAttr.stripWhiteSpace();
4312 }
4313<IDLProp>{ID} { // property type
4314 yyextra->idlProp = yytext;
4315 }
4316<IDLProp>{BN}*{ID}{BN}*"," { // Rare: Another parameter ([propput] HRESULT Item(int index, [in] Type theRealProperty);)
4317 if (yyextra->current->args.isEmpty())
4318 yyextra->current->args = "(";
4319 else
4320 yyextra->current->args += ", ";
4321 yyextra->current->args += yyextra->idlAttr;
4322 yyextra->current->args += " ";
4323 yyextra->current->args += yyextra->idlProp;
4324 yyextra->current->args += " ";
4325 yyextra->current->args += yytext;
4326 yyextra->current->args = yyextra->current->args.left(yyextra->current->args.length() - 1);
4327 yyextra->idlProp.clear();
4328 yyextra->idlAttr.clear();
4329 BEGIN( IDLProp );
4330 }
4331<IDLProp>{BN}*{ID}{BN}*")"{BN}* {
4332
4333 }
4334<IDLProp>";" {
4335 yyextra->current->fileName = yyextra->fileName;
4336 yyextra->current->type = yyextra->idlProp;
4337 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
4338 if (!yyextra->current->args.isEmpty())
4339 yyextra->current->args += ")";
4340 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
4341 yyextra->current->section = EntryType::makeVariable();
4342 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
4344 BEGIN( FindMembers );
4345 }
4346<IDLProp>. { // spaces, *, or other stuff
4347
4348 }
4349<Array>"]" { yyextra->current->args += *yytext ;
4350 if (--yyextra->squareCount<=0)
4351 BEGIN( FindMembers ) ;
4352 }
4353<FuncFuncArray>"]" { yyextra->current->args += *yytext ;
4354 if (--yyextra->squareCount<=0)
4355 BEGIN( SFunction ) ;
4356 }
4357<Array,FuncFuncArray>"[" { yyextra->current->args += *yytext ;
4358 yyextra->squareCount++;
4359 }
4360<Array,FuncFuncArray>. { yyextra->current->args += *yytext ; }
4361<SkipSquare>"[" { yyextra->squareCount++; }
4362<SkipSquare>"]" {
4363 if (--yyextra->squareCount<=0)
4364 BEGIN( yyextra->lastSquareContext );
4365 }
4366<SkipSquare>\" {
4367 yyextra->lastStringContext=YY_START;
4368 BEGIN( SkipString );
4369 }
4370<SkipSquare>[^\n\[\]\"]+
4371<FindMembers>"<" { addType(yyscanner);
4372 yyextra->current->type += yytext ;
4373 BEGIN( Sharp ) ;
4374 }
4375<Sharp>">" { yyextra->current->type += *yytext ;
4376 if (--yyextra->sharpCount<=0)
4377 BEGIN( FindMembers ) ;
4378 }
4379<Sharp>"<" { yyextra->current->type += *yytext ;
4380 yyextra->sharpCount++;
4381 }
4382<Sharp>{BN}+ {
4383 yyextra->current->type += ' ';
4385 }
4386<Sharp>. { yyextra->current->type += *yytext ; }
4387<FindFields>{ID} {
4389 yyextra->current->bodyLine = yyextra->yyLineNr;
4390 yyextra->current->bodyColumn = yyextra->yyColNr;
4391 yyextra->current->name = yytext;
4392 }
4393<FindFields>[({] {
4394
4395 unput(*yytext);
4396 yyextra->lastInitializerContext = YY_START;
4397 yyextra->sharpCount=0;
4398 yyextra->initBracketCount=0;
4399 yyextra->current->initializer.str("=");
4400 BEGIN(ReadInitializer);
4401 }
4402<FindFields>"=" {
4403 yyextra->lastInitializerContext = YY_START;
4404 yyextra->sharpCount=0;
4405 yyextra->initBracketCount=0;
4406 yyextra->current->initializer.str(yytext);
4407 BEGIN(ReadInitializer);
4408 }
4409<FindFields>";" {
4410 if (yyextra->insideJava)
4411 {
4412 if (!yyextra->current->name.isEmpty())
4413 {
4414 yyextra->current->fileName = yyextra->fileName;
4415 yyextra->current->startLine = yyextra->yyLineNr;
4416 yyextra->current->startColumn = yyextra->yyColNr;
4417 if (!yyextra->current_root->spec.isEnum())
4418 {
4419 yyextra->current->type = "@";
4420 }
4421 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
4422 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
4423 yyextra->current->section = EntryType::makeVariable();
4424 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
4426 }
4427
4428 BEGIN( FindMembers );
4429 }
4430 else
4431 {
4432 REJECT;
4433 }
4434 }
4435<FindFields>"," {
4436
4437
4438
4439 if (!yyextra->current->name.isEmpty())
4440 {
4441 yyextra->current->fileName = yyextra->fileName;
4442 if (yyextra->current_root->section.isEnum() || yyextra->current_root->spec.isEnum())
4443 {
4444 yyextra->current->startLine = yyextra->current->bodyLine;
4445 yyextra->current->startColumn = yyextra->current->bodyColumn;
4446 }
4447 else
4448 {
4449 yyextra->current->startLine = yyextra->yyLineNr;
4450 yyextra->current->startColumn = yyextra->yyColNr;
4451 }
4452 if (!yyextra->current_root->spec.isEnum())
4453 {
4454 yyextra->current->type = "@";
4455 }
4456 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
4457 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
4458 yyextra->current->section = EntryType::makeVariable();
4459
4460 if (!yyextra->insideCS && !yyextra->insideJava &&
4461 !yyextra->current_root->spec.isStrong())
4462
4463
4464 {
4465
4466
4467
4468 yyextra->outerScopeEntries.emplace_back(yyextra->current_root->parent(), std::make_shared<Entry>(*yyextra->current));
4469 }
4470 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
4472 }
4473 else
4474 {
4475 yyextra->current->reset();
4477 }
4478 }
4479<FindFields>"[" { // attribute list in IDL
4480 yyextra->squareCount=1;
4481 yyextra->lastSquareContext = YY_START;
4482 BEGIN(SkipSquare);
4483 }
4484<ReadBody,ReadNSBody,ReadBodyIntf>[^\r\n\#{}"@'/<\\\$R]* { yyextra->current->program << yytext ; } // R because of raw string start
4485<ReadBody,ReadNSBody,ReadBodyIntf>{CPPC}.* { yyextra->current->program << yytext ; }
4486<ReadBody,ReadNSBody,ReadBodyIntf>"#".* { if (!yyextra->insidePHP)
4487 REJECT;
4488
4489 yyextra->current->program << yytext ;
4490 }
4491
4492<SkipCurly,ReadBody,ReadNSBody,ReadBodyIntf,ReadExpressionBody,FindMembers,FindMemberName>$\" { if (!yyextra->insideCS) REJECT
4493 yyextra->current->program << yytext ;
4494 yyextra->pSkipInterpString = &yyextra->current->program;
4495 yyextra->lastSkipInterpStringContext=YY_START;
4496 yyextra->strCurlyCount = 0;
4497 BEGIN( SkipInterpString );
4498 }
4499<SkipInterpString>([^"\\{}\x000D\x000A\x0085\x2028\x2029]|"{{"|"}}"|"\\'"|"\\\""|"\\\\"|"\\0"|"\\a"|"\\b"|"\\f"|"\\n"|"\\r"|"\\t"|"\\v"|"\\x"{HEXDIGIT}{HEXDIGIT}?{HEXDIGIT}?{HEXDIGIT}?|"\\"[uU]{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT}{HEXDIGIT})* {
4500 *yyextra->pSkipInterpString << yytext;
4501 }
4502<SkipInterpString>"{" {
4503 *yyextra->pSkipInterpString << *yytext;
4504 yyextra->strCurlyCount++;
4505 }
4506<SkipInterpString>"}" {
4507 *yyextra->pSkipInterpString << *yytext;
4508 yyextra->strCurlyCount--;
4509 }
4510<SkipInterpString>\" {
4511 *yyextra->pSkipInterpString << *yytext;
4512 if (yyextra->strCurlyCount==0)
4513 {
4514 BEGIN( yyextra->lastSkipInterpStringContext );
4515 }
4516 }
4517<SkipInterpString>. {
4518 *yyextra->pSkipInterpString << *yytext;
4519 }
4520
4521<SkipCurly,ReadBody,ReadNSBody,ReadBodyIntf,ReadExpressionBody,FindMembers,FindMemberName>$@\" { if (!yyextra->insideCS) REJECT
4522 yyextra->current->program << yytext ;
4523 yyextra->pSkipInterpVerbString = &yyextra->current->program;
4524 yyextra->lastSkipInterpVerbStringContext=YY_START;
4525 yyextra->strCurlyCount = 0;
4526 BEGIN( SkipInterpVerbString );
4527 }
4528<SkipInterpVerbString>([^\"{}]|"{{"|"}}"|"\"\"")* {
4529 *yyextra->pSkipInterpVerbString << yytext;
4530 }
4531<SkipInterpVerbString>"{" {
4532 *yyextra->pSkipInterpVerbString << *yytext;
4533 yyextra->strCurlyCount++;
4534 }
4535<SkipInterpVerbString>"}" {
4536 *yyextra->pSkipInterpVerbString << *yytext;
4537 yyextra->strCurlyCount--;
4538 }
4539<SkipInterpVerbString>\" {
4540 *yyextra->pSkipInterpVerbString << *yytext;
4541 if (yyextra->strCurlyCount==0)
4542 {
4543 BEGIN( yyextra->lastSkipInterpVerbStringContext );
4544 }
4545 }
4546<SkipInterpVerbString>. {
4547 *yyextra->pSkipInterpVerbString << *yytext;
4548 }
4549<ReadBody,ReadNSBody,ReadBodyIntf>"\$" { yyextra->current->program << yytext ; }
4550<ReadBody,ReadNSBody,ReadBodyIntf>@\" { yyextra->current->program << yytext ;
4551 yyextra->pSkipVerbString = &yyextra->current->program;
4552 yyextra->lastSkipVerbStringContext=YY_START;
4553 BEGIN( SkipVerbString );
4554 }
4555<ReadBody,ReadNSBody,ReadBodyIntf>"<<<" { if (yyextra->insidePHP)
4556 {
4557 yyextra->current->program << yytext ;
4558 yyextra->pCopyHereDocGString = &yyextra->current->program;
4559 yyextra->lastHereDocContext=YY_START;
4560 BEGIN( CopyHereDoc );
4561 }
4562 else
4563 {
4564 REJECT;
4565 }
4566 }
4567<ReadBody,ReadNSBody,ReadBodyIntf>{RAWBEGIN} {
4568 yyextra->current->program << yytext;
4570 yyextra->lastRawStringContext = YY_START;
4571 yyextra->pCopyRawGString = &yyextra->current->program;
4572 BEGIN(RawGString);
4573 }
4574<ReadBody,ReadNSBody,ReadBodyIntf>\" { yyextra->current->program << yytext ;
4575 yyextra->pCopyQuotedGString = &yyextra->current->program;
4576 yyextra->lastStringContext=YY_START;
4577 yyextra->stopAtInvalidString=false;
4578 BEGIN( CopyGString );
4579 }
4580<ReadBody,ReadNSBody,ReadBodyIntf>{DCOMMC} { yyextra->doxygenComment=true; REJECT;}
4581<ReadBody,ReadNSBody,ReadBodyIntf>{CCS}{B}* { yyextra->current->program << yytext ;
4582 yyextra->lastContext = YY_START ;
4583 BEGIN( Comment ) ;
4584 }
4585<ReadBody,ReadNSBody,ReadBodyIntf>{CCS}{BL} { yyextra->current->program << yytext ;
4586 ++yyextra->yyLineNr ;
4587 yyextra->lastContext = YY_START ;
4588 BEGIN( Comment ) ;
4589 }
4590<ReadBody,ReadNSBody,ReadBodyIntf>"'" {
4591 if (!yyextra->insidePHP)
4592 {
4593 yyextra->current->program << yytext;
4594 }
4595 else
4596 {
4597 yyextra->current->program << yytext;
4598 yyextra->pCopyQuotedGString = &yyextra->current->program;
4599 yyextra->lastStringContext=YY_START;
4600 BEGIN(CopyPHPGString);
4601 }
4602 }
4603<ReadBody,ReadNSBody,ReadBodyIntf>{CHARLIT} {
4604 if (yyextra->insidePHP)
4605 {
4606 REJECT;
4607
4608 }
4609 else
4610 {
4611 yyextra->current->program << yytext;
4612 }
4613 }
4614<ReadBody,ReadNSBody,ReadBodyIntf>"{" { yyextra->current->program << yytext ;
4615 ++yyextra->curlyCount ;
4616 }
4617<ReadBodyIntf>"}" {
4618 yyextra->current->program << yytext ;
4619 --yyextra->curlyCount ;
4620 }
4621<ReadBody,ReadNSBody>"}" {
4622 if ( yyextra->curlyCount>0 )
4623 {
4624 yyextra->current->program << yytext ;
4625 --yyextra->curlyCount ;
4626 }
4627 else
4628 {
4629 yyextra->current->endBodyLine = yyextra->yyLineNr;
4630 std::shared_ptr<Entry> original_root = yyextra->current_root;
4631 if (yyextra->current->section.isNamespace() && yyextra->current->type == "namespace")
4632 {
4633 int split_point;
4634
4635 QCString doc = yyextra->current->doc;
4636 int docLine = yyextra->current->docLine;
4637 QCString docFile = yyextra->current->docFile;
4638 QCString brief = yyextra->current->brief;
4639 int briefLine = yyextra->current->briefLine;
4640 QCString briefFile = yyextra->current->briefFile;
4641
4642 yyextra->current->doc = "";
4643 yyextra->current->docLine = 0;
4644 yyextra->current->docFile = "";
4645 yyextra->current->brief = "";
4646 yyextra->current->briefLine = 0;
4647 yyextra->current->briefFile = "";
4648 while ((split_point = yyextra->current->name.find("::")) != -1)
4649 {
4650 std::shared_ptr<Entry> new_current = std::make_shared<Entry>(*yyextra->current);
4651 yyextra->current->program.str(std::string());
4652 new_current->name = yyextra->current->name.mid(split_point + 2);
4653 yyextra->current->name = yyextra->current->name.left(split_point);
4654 if (!yyextra->current_root->name.isEmpty()) yyextra->current->name.prepend(yyextra->current_root->name+"::");
4655
4656 yyextra->current_root->moveToSubEntryAndKeep(yyextra->current);
4657 yyextra->current_root = yyextra->current;
4658 yyextra->current = new_current;
4659 }
4660
4661 yyextra->current->doc = doc;
4662 yyextra->current->docLine = docLine;
4663 yyextra->current->docFile = docFile;
4664 yyextra->current->brief = brief;
4665 yyextra->current->briefLine = briefLine;
4666 yyextra->current->briefFile = briefFile;
4667 }
4668 QCString &cn = yyextra->current->name;
4669 QCString rn = yyextra->current_root->name;
4670
4672 {
4674 }
4675 if (yyextra->isTypedef && cn.
isEmpty())
4676 {
4677
4678 BEGIN( TypedefName );
4679 }
4680 else
4681 {
4682 if (yyextra->current->section.isEnum() || yyextra->current->spec.isEnum())
4683 {
4684 yyextra->current->program << ',';
4685 }
4686
4688
4689 yyextra->current->type = yyextra->current->type.simplifyWhiteSpace();
4690 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
4691
4692 if (yyextra->insideObjC &&
4693 (yyextra->current->spec.isInterface() || yyextra->current->spec.isCategory())
4694 )
4695 {
4696 BEGIN( ReadBodyIntf ) ;
4697 }
4698 else
4699 {
4700 yyextra->memspecEntry = yyextra->current;
4701 yyextra->current_root->moveToSubEntryAndKeep( yyextra->current ) ;
4702 yyextra->current = std::make_shared<Entry>(*yyextra->current);
4703 if (yyextra->current->section.isNamespace() ||
4704 yyextra->current->spec.isInterface() ||
4705 yyextra->insideJava || yyextra->insidePHP || yyextra->insideCS || yyextra->insideD || yyextra->insideJS ||
4706 yyextra->insideSlice
4707 )
4708 {
4709 yyextra->current->reset();
4710 yyextra->current_root = std::move(original_root);
4712 yyextra->memspecEntry.reset();
4713 BEGIN( FindMembers ) ;
4714 }
4715 else
4716 {
4717 static const reg::Ex re(R
"(@\d+$)");
4718 if (!yyextra->isTypedef && yyextra->memspecEntry &&
4719 !
reg::search(yyextra->memspecEntry->name.str(),re))
4720 {
4721
4722 yyextra->current->doc.clear();
4723 yyextra->current->brief.clear();
4724 }
4725 BEGIN( MemberSpec ) ;
4726 }
4727 }
4728 }
4729 }
4730 }
static void prependScope(yyscan_t yyscanner)
4731<ReadBody>"}"{BN}+"typedef"{BN}+ {
4733 if ( yyextra->curlyCount>0 )
4734 {
4735 yyextra->current->program << yytext ;
4736 --yyextra->curlyCount ;
4737 }
4738 else
4739 {
4740 yyextra->isTypedef =
TRUE;
4741 yyextra->current->endBodyLine = yyextra->yyLineNr;
4742 QCString &cn = yyextra->current->name;
4743 QCString rn = yyextra->current_root->name;
4745 {
4747 }
4748 BEGIN( TypedefName );
4749 }
4750 }
4751<TypedefName>("const"|"volatile"){BN} { // late "const" or "volatile" keyword
4753 yyextra->current->type.prepend(yytext);
4754 }
4755<TypedefName>{ID} {
4756 if (yyextra->current->section.isEnum() || yyextra->current->spec.isEnum())
4757 {
4758 yyextra->current->program << ",";
4759 }
4760 yyextra->current->name=yytext;
4762 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
4763 yyextra->current->type = yyextra->current->type.simplifyWhiteSpace();
4764
4765 if (!yyextra->firstTypedefEntry)
4766 {
4767 yyextra->firstTypedefEntry = yyextra->current;
4768 }
4769 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4771 yyextra->isTypedef=
TRUE;
4772 BEGIN(MemberSpecSkip);
4773 }
4774<TypedefName>";" { /* typedef of anonymous type */
4776 if (yyextra->current->section.isEnum() || yyextra->current->spec.isEnum())
4777 {
4778 yyextra->current->program << ',';
4779 }
4780
4781 yyextra->current->args = yyextra->current->args.simplifyWhiteSpace();
4782 yyextra->current->type = yyextra->current->type.simplifyWhiteSpace();
4783 yyextra->memspecEntry = yyextra->current;
4784 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4786 unput(';');
4787 BEGIN( MemberSpec ) ;
4788 }
QCString generateAnonymousAnchor(const QCString &fileName, int count)
4789<MemberSpec>([*&]*{BN}*)*{ID}{BN}*("["[^\]\n]*"]")* { // the [] part could be improved.
4791 int i=0,l=(int)yyleng,j;
4792 while (i<l && (!
isId(yytext[i]))) i++;
4794 j=yyextra->msName.
find(
"[");
4795 if (j!=-1)
4796 {
4797 yyextra->msArgs=yyextra->msName.right(yyextra->msName.length()-j);
4798 yyextra->msName=yyextra->msName.left(j);
4799 }
QCString right(size_t len) const
4801
4802
4803 if (yyextra->firstTypedefEntry)
4804 {
4805 if (yyextra->firstTypedefEntry->spec.isStruct())
4806 {
4807 yyextra->msType.prepend("struct "+yyextra->firstTypedefEntry->name);
4808 }
4809 else if (yyextra->firstTypedefEntry->spec.isUnion())
4810 {
4811 yyextra->msType.prepend("union "+yyextra->firstTypedefEntry->name);
4812 }
4813 else if (yyextra->firstTypedefEntry->section.isEnum())
4814 {
4815 yyextra->msType.prepend("enum "+yyextra->firstTypedefEntry->name);
4816 }
4817 else
4818 {
4819 yyextra->msType.prepend(yyextra->firstTypedefEntry->name);
4820 }
4821 }
4822 }
4823<MemberSpec>"(" { // function with struct return type
4825 yyextra->current->name = yyextra->msName;
4827 unput('(');
4828 BEGIN(FindMembers);
4829 }
4830<MemberSpec>[,;] {
4831 if (yyextra->msName.isEmpty() && !yyextra->current->name.isEmpty())
4832 {
4833
4834
4835
4836
4837 const Entry *p=yyextra->current.get();
4838 while (p)
4839 {
4840
4842 {
4843
4845 int pi = (i==-1) ? 0 : i+2;
4847 {
4848
4849
4851 break;
4852 }
4853 }
4854
4855 if (p==yyextra->current.get()) p=yyextra->current_root.get();
else p=p->
parent();
4856 }
4857 }
4858
4859 if (!yyextra->msName.isEmpty()
4860 )
4861 {
4863
4864
4865 if (typedefHidesStruct &&
4866 yyextra->isTypedef &&
4867 ((yyextra->current->spec.isStruct() || yyextra->current->spec.isUnion()) || yyextra->current->section.isEnum()) &&
4868 yyextra->msType.stripWhiteSpace().isEmpty() &&
4869 yyextra->memspecEntry)
4870 {
4871 yyextra->memspecEntry->name=yyextra->msName;
4872 }
4873 else
4874 {
4875 std::shared_ptr<Entry> varEntry=std::make_shared<Entry>();
4876 varEntry->lang = yyextra->language;
4877 varEntry->protection = yyextra->current->protection ;
4878 varEntry->mtype = yyextra->current->mtype;
4879 varEntry->virt = yyextra->current->virt;
4880 varEntry->isStatic = yyextra->current->isStatic;
4881 varEntry->section = EntryType::makeVariable();
4882 varEntry->name = yyextra->msName.stripWhiteSpace();
4883 varEntry->type = yyextra->current->type.simplifyWhiteSpace()+" ";
4884 varEntry->args = yyextra->msArgs;
4885 if (yyextra->isTypedef)
4886 {
4887 varEntry->type.prepend("typedef ");
4888
4889 }
4890 if (typedefHidesStruct &&
4891 yyextra->isTypedef &&
4892 (yyextra->current->spec.isStruct() || yyextra->current->spec.isUnion()) &&
4893 yyextra->memspecEntry
4894 )
4895 {
4896 varEntry->type+=yyextra->memspecEntry->name+yyextra->msType;
4897 }
4898 else
4899 {
4900 varEntry->type+=yyextra->current->name+yyextra->msType;
4901 }
4902 varEntry->fileName = yyextra->fileName;
4903 varEntry->startLine = yyextra->yyLineNr;
4904 varEntry->startColumn = yyextra->yyColNr;
4905 varEntry->doc = yyextra->current->doc;
4906 varEntry->brief = yyextra->current->brief;
4907 varEntry->mGrpId = yyextra->current->mGrpId;
4908 varEntry->initializer.str(yyextra->current->initializer.str());
4909 varEntry->groups = yyextra->current->groups;
4910 varEntry->sli = yyextra->current->sli;
Represents an unstructured piece of information, about an entity found in the sources.
EntryType section
entry type (see Sections);
ENTRY_TYPES constexpr bool isCompound() const noexcept
int findRev(char c, int index=-1, bool cs=TRUE) const
4911
4912
4913
4914
4915 yyextra->current_root->moveToSubEntryAndKeep(varEntry);
4916 }
4917 }
4918 if (*yytext==';')
4919 {
4920 if (!yyextra->isTypedef && yyextra->msName.isEmpty() && yyextra->memspecEntry && yyextra->current->section.isCompound())
4921 {
4922 if (!yyextra->current->doc.isEmpty())
4923 {
4924 yyextra->memspecEntry->doc += yyextra->current->doc;
4925 }
4926 if (!yyextra->current->brief.isEmpty())
4927 {
4928 yyextra->memspecEntry->brief += yyextra->current->brief;
4929 }
4930 }
4931 yyextra->msType.clear();
4932 yyextra->msName.clear();
4933 yyextra->msArgs.clear();
4934 yyextra->isTypedef=
FALSE;
4935 yyextra->firstTypedefEntry.reset();
4936 yyextra->memspecEntry.reset();
4937 yyextra->current->reset();
4939 BEGIN( FindMembers );
4940 }
4941 else
4942 {
4943 yyextra->current->doc.clear();
4944 yyextra->current->brief.clear();
4945 }
4946
4947 }
4948<MemberSpec>"=" {
4949 yyextra->lastInitializerContext=YY_START;
4950 yyextra->sharpCount=0;
4951 yyextra->initBracketCount=0;
4952 yyextra->current->initializer.str(yytext);
4953 BEGIN(ReadInitializer);
4954
4955 }
4956
4957<MemberSpecSkip>"{" {
4958 yyextra->curlyCount=0;
4959 yyextra->lastCurlyContext = MemberSpecSkip;
4960 yyextra->previous = yyextra->current;
4961 BEGIN(SkipCurly);
4962 }
4963 */
4964<MemberSpecSkip>"," { BEGIN(MemberSpec); }
4965<MemberSpecSkip>";" { unput(';'); BEGIN(MemberSpec); }
4966<ReadBody,ReadNSBody,ReadBodyIntf>{BN}{1,80} { yyextra->current->program << yytext ;
4968 }
4969<ReadBodyIntf>"@end"/[^a-z_A-Z0-9] { // end of Objective C block
4970 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
4972 yyextra->language = yyextra->current->lang = SrcLangExt::Cpp;
4973 yyextra->insideObjC=
FALSE;
4974 BEGIN( FindMembers );
4975 }
4976<ReadBody,ReadNSBody,ReadBodyIntf>\\. { yyextra->current->program << yytext ; }
4977<ReadBody,ReadNSBody,ReadBodyIntf>. { yyextra->current->program << yytext ; }
4978
4979<FindMembers>"("/{BN}*"::"*{BN}*({TSCOPE}{BN}*"::")*{TSCOPE}{BN}*")"{BN}*"(" | /* typedef void (A<int>::func_t)(args...) */
4980<FindMembers>("("({BN}*"::"*{BN}*{TSCOPE}{BN}*"::")*({BN}*[*&\^]{BN}*)+)+ { /* typedef void (A::*ptr_t)(args...) or int (*func(int))[], the ^ is for Obj-C blocks */
4981 if (yyextra->insidePHP)
4982 {
4983 REJECT
4984 }
4985 else
4986 {
4987 yyextra->current->bodyLine = yyextra->yyLineNr;
4988 yyextra->current->bodyColumn = yyextra->yyColNr;
4991 yyextra->funcPtrType=yytext;
4992 yyextra->roundCount=0;
4993
4994 BEGIN( FuncPtr );
4995 }
4996 }
4997<FuncPtr>{SCOPENAME} {
4998 yyextra->current->name = yytext;
5000 {
5001 BEGIN( FuncPtrOperator );
5002 }
5003 else
5004 {
5005 if (yyextra->current->name=="const" || yyextra->current->name=="volatile")
5006 {
5007 yyextra->funcPtrType += yyextra->current->name;
5008 }
5009 else
5010 {
5011 BEGIN( EndFuncPtr );
5012 }
5013 }
5014 }
5015<FuncPtr>. {
5016
5017 }
5018<FuncPtrOperator>"("{BN}*")"{BNopt}/"(" {
5019 yyextra->current->name += yytext;
5020 yyextra->current->name = yyextra->current->name.simplifyWhiteSpace();
5022 }
5023<FuncPtrOperator>\n {
5025 yyextra->current->name += *yytext;
5026 }
5027<FuncPtrOperator>"(" {
5028 unput(*yytext);
5029 BEGIN( EndFuncPtr );
5030 }
5031<FuncPtrOperator>. {
5032 yyextra->current->name += *yytext;
5033 }
5034<EndFuncPtr>")"{BNopt}/";" { // a variable with extra braces
5036 yyextra->current->type+=yyextra->funcPtrType.mid(1);
5037 BEGIN(FindMembers);
5038 }
5039<EndFuncPtr>")"{BNopt}/"(" { // a function pointer
5041 if (yyextra->funcPtrType!="(")
5042 {
5043 yyextra->current->type+=yyextra->funcPtrType+")";
5044 }
5045 BEGIN(FindMembers);
5046 }
5047<EndFuncPtr>")"{BNopt}/"[" { // an array of variables
5049 yyextra->current->type+=yyextra->funcPtrType;
5050 yyextra->current->args += ")";
5051 BEGIN(FindMembers);
5052 }
5053<EndFuncPtr>"(" { // a function returning a function or
5054
5055 yyextra->current->args += *yytext ;
5056
5057
5058 yyextra->current->bodyLine = yyextra->yyLineNr;
5059 yyextra->current->bodyColumn = yyextra->yyColNr;
5060 yyextra->currentArgumentContext = FuncFuncEnd;
5061 yyextra->fullArgString=yyextra->current->args;
5062 yyextra->copyArgString=&yyextra->current->args;
5063 BEGIN( ReadFuncArgType ) ;
5064 }
5065<EndFuncPtr>"["[^\n\]]*"]" {
5066 yyextra->funcPtrType+=yytext;
5067 }
5068<EndFuncPtr>")" {
5069 BEGIN(FindMembers);
5070 }
5071<FuncFunc>"(" {
5072 yyextra->current->args += *yytext ;
5073 ++yyextra->roundCount;
5074 }
5075<FuncFunc>")" {
5076 yyextra->current->args += *yytext ;
5077 if ( yyextra->roundCount )
5078 --yyextra->roundCount;
5079 else
5080 {
5081 BEGIN(FuncFuncEnd);
5082 }
5083 }
5084<FuncFuncEnd>")"{BN}*"(" {
5086 yyextra->current->type+=yyextra->funcPtrType+")(";
5087 BEGIN(FuncFuncType);
5088 }
5089<FuncFuncEnd>")"{BNopt}/[;{] {
5091 yyextra->current->type+=yyextra->funcPtrType.mid(1);
5092 BEGIN(SFunction);
5093 }
5094<FuncFuncEnd>")"{BNopt}/"[" { // function returning a pointer to an array
5096 yyextra->current->type+=yyextra->funcPtrType;
5097 yyextra->current->args+=")";
5098 BEGIN(FuncFuncArray);
5099 }
5100<FuncFuncEnd>. {
5101 yyextra->current->args += *yytext;
5102 }
5103<FuncFuncType>"(" {
5104 yyextra->current->type += *yytext;
5105 yyextra->roundCount++;
5106 }
5107<FuncFuncType>")" {
5108 yyextra->current->type += *yytext;
5109 if (yyextra->roundCount)
5110 --yyextra->roundCount;
5111 else
5112 BEGIN(SFunction);
5113 }
5114<FuncFuncType>{BN}*","{BN}* { lineCount(yyscanner) ; yyextra->current->type += ", " ; }
5115<FuncFuncType>{BN}+ { lineCount(yyscanner) ; yyextra->current->type += ' ' ; }
5116<FuncFuncType>. {
5117 yyextra->current->type += *yytext;
5118 }
5119<FindMembers>"("/{BN}*{ID}{BN}*"*"{BN}*{ID}*")"{BN}*"(" { // for catching typedef void (__stdcall *f)() like definitions
5120 if (yyextra->current->type.startsWith("typedef") &&
5121 yyextra->current->bodyLine==-1)
5122
5123 {
5124 yyextra->current->bodyLine = yyextra->yyLineNr;
5125 yyextra->current->bodyColumn = yyextra->yyColNr;
5126 BEGIN( GetCallType );
5127 }
5128 else if (!yyextra->current->name.isEmpty())
5129 {
5130 yyextra->current->args = yytext;
5131 yyextra->current->bodyLine = yyextra->yyLineNr;
5132 yyextra->current->bodyColumn = yyextra->yyColNr;
5133 yyextra->currentArgumentContext = FuncQual;
5134 yyextra->fullArgString=yyextra->current->args;
5135 yyextra->copyArgString=&yyextra->current->args;
5136 BEGIN( ReadFuncArgType ) ;
5137
5138 }
5139 }
5140<GetCallType>{BN}*{ID}{BN}*"*" {
5143 yyextra->funcPtrType="(";
5144 yyextra->funcPtrType+=yytext;
5145 yyextra->roundCount=0;
5146 BEGIN( FuncPtr );
5147 }
5148<FindMembers>"(" {
5149 if (!yyextra->current->name.isEmpty())
5150 {
5151 yyextra->current->args = yytext;
5152 yyextra->current->bodyLine = yyextra->yyLineNr;
5153 yyextra->current->bodyColumn = yyextra->yyColNr;
5154 yyextra->currentArgumentContext = FuncQual;
5155 yyextra->fullArgString=yyextra->current->args;
5156 yyextra->copyArgString=&yyextra->current->args;
5157 BEGIN( ReadFuncArgType ) ;
5158
5159 }
5160 }
5161
5162
5163
5164<ReadFuncArgType>[^ \/\r\t\n\[\]\)\(\"\'#]+ { *yyextra->copyArgString+=yytext;
5165 if (yyextra->insideCS) yyextra->fullArgString+=
substitute(yytext,
".",
"::");
5166 else yyextra->fullArgString+=yytext;
5167 }
5168<CopyArgString,CopyArgPHPString>[^\n\\\"\']+ { *yyextra->copyArgString+=yytext;
5169 yyextra->fullArgString+=yytext;
5170 }
5171<CopyArgRound>[^\/\n\)\(\"\']+ {
5172 *yyextra->copyArgString+=yytext;
5173 yyextra->fullArgString+=yytext;
5174 }
5175<CopyArgSquare>[^\/\n\]\[\"\']+ {
5176 *yyextra->copyArgString+=yytext;
5177 yyextra->fullArgString+=yytext;
5178 }
5179<ReadFuncArgType,ReadTempArgs>{BN}* {
5180 *yyextra->copyArgString+=" ";
5181 yyextra->fullArgString+=" ";
5183 }
5184<ReadFuncArgType,CopyArgRound,CopyArgSquare,CopyArgSharp,ReadTempArgs>{RAWBEGIN} {
5186 yyextra->lastRawStringContext = YY_START;
5187 yyextra->pCopyRawString = yyextra->copyArgString;
5188 *yyextra->pCopyRawString+=yytext;
5189 yyextra->fullArgString+=yytext;
5190 BEGIN(RawString);
5191 }
5192<ReadFuncArgType,CopyArgRound,CopyArgSquare,CopyArgSharp,ReadTempArgs>\" {
5193 *yyextra->copyArgString+=*yytext;
5194 yyextra->fullArgString+=*yytext;
5195 yyextra->lastCopyArgStringContext = YY_START;
5196 BEGIN( CopyArgString );
5197 }
5198<ReadFuncArgType>"[" {
5199 if (!yyextra->insidePHP) REJECT;
5200 *yyextra->copyArgString+=*yytext;
5201 yyextra->fullArgString+=*yytext;
5202 yyextra->argSquareCount=0;
5203 yyextra->lastCopyArgContext = YY_START;
5204 BEGIN( CopyArgSquare );
5205 }
5206<ReadFuncArgType,ReadTempArgs>"(" {
5207 *yyextra->copyArgString+=*yytext;
5208 yyextra->fullArgString+=*yytext;
5209 yyextra->argRoundCount=0;
5210 yyextra->lastCopyArgContext = YY_START;
5211 BEGIN( CopyArgRound );
5212 }
5213<ReadFuncArgType>")" {
5214 *yyextra->copyArgString+=*yytext;
5215 yyextra->fullArgString+=*yytext;
5217 if (yyextra->insideJS)
5218 {
5220 }
std::unique_ptr< ArgumentList > stringToArgumentList(SrcLangExt lang, const QCString &argsString, QCString *extraTypeChars=nullptr)
void fixArgumentListForJavaScript(ArgumentList &al)
static void handleParametersCommentBlocks(yyscan_t yyscanner, ArgumentList &al)
5222
5223
5224
5225
5226
5227
5228 yyextra->docBackup = yyextra->current->doc;
5229 yyextra->briefBackup = yyextra->current->brief;
5230
5231 BEGIN( yyextra->currentArgumentContext );
5232 }
5233
5234<ReadFuncArgType,ReadTempArgs>({CCS}[*!]|{CPPC}[/!])("<"?) {
5235 if (yyextra->currentArgumentContext==DefineEnd)
5236 {
5237
5238
5239 int i;for (i=(int)yyleng-1;i>=0;i--)
5240 {
5241 unput(yytext[i]);
5242 }
5245 BEGIN( yyextra->currentArgumentContext );
5246 }
5247 else
5248 {
5249
5250
5251 yyextra->fullArgString+=yytext;
5252 yyextra->lastCopyArgChar=0;
5253 yyextra->lastCommentInArgContext=YY_START;
5254 if (yytext[1]=='/')
5255 BEGIN( CopyArgCommentLine );
5256 else
5257 BEGIN( CopyArgComment );
5258 }
5259 }
5260
5261<ReadFuncArgType,ReadTempArgs>{CCS}{CCE} { /* empty comment */ }
5262<ReadFuncArgType,ReadTempArgs>{CCS} {
5263 yyextra->lastCContext = YY_START;
5264 BEGIN( SkipComment );
5265 }
5266<ReadFuncArgType,ReadTempArgs>{CPPC} {
5267 yyextra->lastCContext = YY_START;
5268 BEGIN( SkipCxxComment );
5269 }
5270
5271<ReadFuncArgType,ReadTempArgs>"'#" { if (yyextra->insidePHP)
5272 REJECT;
5273 *yyextra->copyArgString+=yytext;
5274 yyextra->fullArgString+=yytext;
5275 }
5276<ReadFuncArgType,ReadTempArgs>"#" {
5277 if (!yyextra->insidePHP)
5278 REJECT;
5279 yyextra->lastCContext = YY_START;
5280 BEGIN( SkipCxxComment );
5281 }
5282 */
5283
5284<ReadFuncArgType>")"{BN}*({CCS}[*!]|{CPPC}[/!])"<" {
5286 if (yyextra->currentArgumentContext==DefineEnd)
5287 {
5288
5289
5290 int i;for (i=(int)yyleng-1;i>0;i--)
5291 {
5292 unput(yytext[i]);
5293 }
5294 *yyextra->copyArgString+=*yytext;
5295 yyextra->fullArgString+=*yytext;
5298 BEGIN( yyextra->currentArgumentContext );
5299 }
5300 else
5301 {
5302
5303
5304 yyextra->lastCopyArgChar=*yytext;
5307 yyextra->lastCommentInArgContext=YY_START;
5308 yyextra->fullArgString+=text;
5309 if (text.
find(
"//")!=-1)
5310 BEGIN( CopyArgCommentLine );
5311 else
5312 BEGIN( CopyArgComment );
5313 }
5314 }
5315<CopyArgComment>^{B}*"*"+/{BN}+
5316<CopyArgComment>[^\n\\\@\*]+ { yyextra->fullArgString+=yytext; }
5317<CopyArgComment>{CCE} { yyextra->fullArgString+=yytext;
5318 if (yyextra->lastCopyArgChar!=0)
5319 unput(yyextra->lastCopyArgChar);
5320 BEGIN( yyextra->lastCommentInArgContext );
5321 }
5322<CopyArgCommentLine>\n { yyextra->fullArgString+=yytext;
5324 if (yyextra->lastCopyArgChar!=0)
5325 unput(yyextra->lastCopyArgChar);
5326 BEGIN( yyextra->lastCommentInArgContext );
5327 }
5328<CopyArgCommentLine>{CMD}"startuml"/[^a-z_A-Z0-9\-] { // verbatim type command (which could contain nested comments!)
5329 yyextra->docBlockName="uml";
5330 yyextra->fullArgString+=yytext;
5331 BEGIN(CopyArgVerbatim);
5332 }
5333<CopyArgCommentLine>{CMD}("verbatim"|"iliteral"|"latexonly"|"htmlonly"|"xmlonly"|"manonly"|"rtfonly"|"docbookonly"|"dot"|"msc"|"code")/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
5334 yyextra->docBlockName=&yytext[1];
5335 yyextra->fullArgString+=yytext;
5336 BEGIN(CopyArgVerbatim);
5337 }
5338<CopyArgCommentLine>{CMD}("f$"|"f["|"f{"|"f(") {
5339 yyextra->docBlockName=&yytext[1];
5340 if (yyextra->docBlockName.at(1)=='[')
5341 {
5342 yyextra->docBlockName.at(1)=']';
5343 }
5344 if (yyextra->docBlockName.at(1)=='{')
5345 {
5346 yyextra->docBlockName.at(1)='}';
5347 }
5348 if (yyextra->docBlockName.at(1)=='(')
5349 {
5350 yyextra->docBlockName.at(1)=')';
5351 }
5352 yyextra->fullArgString+=yytext;
5353 BEGIN(CopyArgVerbatim);
5354 }
5355<CopyArgVerbatim>{CMD}("endverbatim"|"endiliteral"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endmanonly"|"endrtfonly"|"enddot"|"endmsc"|"enduml"|"endcode")/[^a-z_A-Z0-9\-] { // end of verbatim block
5356 yyextra->fullArgString+=yytext;
5357 if (&yytext[4]==yyextra->docBlockName)
5358 {
5359 yyextra->docBlockName="";
5360 BEGIN(CopyArgCommentLine);
5361 }
5362 }
5363<CopyArgVerbatim>{CMD}("f$"|"f]"|"f}"|"f)") { // end of verbatim block
5364 yyextra->fullArgString+=yytext;
5365 if (yyextra->docBlockName==&yytext[1])
5366 {
5367 yyextra->docBlockName="";
5368 BEGIN(CopyArgCommentLine);
5369 }
5370 }
5371<CopyArgCommentLine>[^\\\@\n]+ { yyextra->fullArgString+=yytext; }
5372<CopyArgCommentLine>. { yyextra->fullArgString+=*yytext; }
5373<CopyArgComment,CopyArgVerbatim>\n { yyextra->fullArgString+=*yytext; lineCount(yyscanner); }
5374<CopyArgComment,CopyArgVerbatim>. { yyextra->fullArgString+=*yytext; }
5375<CopyArgComment>{CMD}("brief"|"short"){B}+ {
5376 warn(yyextra->fileName,yyextra->yyLineNr,
5377 "Ignoring {:c}brief command inside argument documentation",*yytext
5378 );
5379 yyextra->fullArgString+=' ';
5380 }
5381<ReadTempArgs>"<" {
5382 *yyextra->copyArgString+=*yytext;
5383 yyextra->fullArgString+=*yytext;
5384 yyextra->argSharpCount=1;
5385 BEGIN( CopyArgSharp );
5386 }
5387<ReadTempArgs>">" {
5388 *yyextra->copyArgString+=*yytext;
5389 yyextra->fullArgString+=*yytext;
5390
5391 *yyextra->currentArgumentList = *
stringToArgumentList(yyextra->language, yyextra->fullArgString);
5393 BEGIN( yyextra->currentArgumentContext );
5394 }
5395<CopyArgRound>"(" {
5396 yyextra->argRoundCount++;
5397 *yyextra->copyArgString+=*yytext;
5398 yyextra->fullArgString+=*yytext;
5399 }
5400<CopyArgRound>")" {
5401 *yyextra->copyArgString+=*yytext;
5402 yyextra->fullArgString+=*yytext;
5403 if (yyextra->argRoundCount>0)
5404 yyextra->argRoundCount--;
5405 else
5406 BEGIN( yyextra->lastCopyArgContext );
5407 }
5408<CopyArgSquare>"[" {
5409 yyextra->argSquareCount++;
5410 *yyextra->copyArgString+=*yytext;
5411 yyextra->fullArgString+=*yytext;
5412 }
5413<CopyArgSquare>"]" {
5414 *yyextra->copyArgString+=*yytext;
5415 yyextra->fullArgString+=*yytext;
5416 if (yyextra->argSquareCount>0)
5417 yyextra->argSquareCount--;
5418 else
5419 BEGIN( yyextra->lastCopyArgContext );
5420 }
5421<CopyArgSharp>"(" {
5422 *yyextra->copyArgString+=*yytext;
5423 yyextra->fullArgString+=*yytext;
5424 yyextra->argRoundCount=0;
5425 yyextra->lastCopyArgContext = YY_START;
5426 BEGIN( CopyArgRound );
5427 }
5428<CopyArgSharp>"<" {
5429 yyextra->argSharpCount++;
5430
5431 *yyextra->copyArgString+=*yytext;
5432 yyextra->fullArgString+=*yytext;
5433 }
5434<CopyArgSharp>">" {
5435 *yyextra->copyArgString+=*yytext;
5436 yyextra->fullArgString+=*yytext;
5437 yyextra->argSharpCount--;
5438 if (yyextra->argSharpCount>0)
5439 {
5440
5441 }
5442 else
5443 {
5444 BEGIN( ReadTempArgs );
5445
5446 }
5447 }
5448<CopyArgString,CopyArgPHPString>\\. {
5449 *yyextra->copyArgString+=yytext;
5450 yyextra->fullArgString+=yytext;
5451 }
5452<CopyArgString>\" {
5453 *yyextra->copyArgString+=*yytext;
5454 yyextra->fullArgString+=*yytext;
5455 BEGIN( yyextra->lastCopyArgStringContext );
5456 }
5457<CopyArgPHPString>\' {
5458 *yyextra->copyArgString+=*yytext;
5459 yyextra->fullArgString+=*yytext;
5460 BEGIN( yyextra->lastCopyArgStringContext );
5461 }
5462<ReadFuncArgType,ReadTempArgs,CopyArgRound,CopyArgSquare,CopyArgSharp>{CHARLIT} {
5463 if (yyextra->insidePHP)
5464 {
5465 REJECT;
5466 }
5467 else
5468 {
5469 *yyextra->copyArgString+=yytext;
5470 yyextra->fullArgString+=yytext;
5471 }
5472 }
5473<ReadFuncArgType,ReadTempArgs,CopyArgRound,CopyArgSquare,CopyArgSharp>\' {
5474 *yyextra->copyArgString+=yytext;
5475 yyextra->fullArgString+=yytext;
5476 if (yyextra->insidePHP)
5477 {
5478 yyextra->lastCopyArgStringContext=YY_START;
5479 BEGIN(CopyArgPHPString);
5480 }
5481 }
5482<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgPHPString,CopyArgRound,CopyArgSquare,CopyArgSharp>"<="|">="|"<=>" {
5483 *yyextra->copyArgString+=yytext;
5484 yyextra->fullArgString+=yytext;
5485 }
5486<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgPHPString,CopyArgRound,CopyArgSquare,CopyArgSharp>\n {
5488 *yyextra->copyArgString+=*yytext;
5489 yyextra->fullArgString+=*yytext;
5490 }
5491<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgPHPString,CopyArgRound,CopyArgSquare,CopyArgSharp>{ID} {
5492 *yyextra->copyArgString+=yytext;
5493 yyextra->fullArgString+=yytext;
5494 }
5495<ReadFuncArgType,ReadTempArgs,CopyArgString,CopyArgPHPString,CopyArgRound,CopyArgSquare,CopyArgSharp>. {
5496 *yyextra->copyArgString+=*yytext;
5497 yyextra->fullArgString+=*yytext;
5498 }
5499
5500
5501
5502
5503
5504
5505<FuncRound>"(" { yyextra->current->args += *yytext ;
5506 ++yyextra->roundCount ;
5507 }
5508<FuncRound>")" { yyextra->current->args += *yytext ;
5509 if ( yyextra->roundCount )
5510 --yyextra->roundCount ;
5511 else
5512 BEGIN( FuncQual ) ;
5513 }
5514
5515<FuncQual>"#" { if (yyextra->insidePHP)
5516 REJECT;
5517 yyextra->lastCPPContext = YY_START;
5518 BEGIN(SkipCPP);
5519 }
5520 */
5521<FuncQual>[{:;,] {
5522 if (
qstrcmp(yytext,
";")==0 &&
5523 ((yyextra->insideJS || yyextra->insidePHP) &&
5525 {
5526 yyextra->current->reset();
5528 BEGIN( FindMembers );
5529 }
5530 else
5531 {
5532 unput(*yytext); BEGIN( SFunction );
5533 }
5534 }
bool containsWord(const QCString &str, const char *word)
returns TRUE iff string s contains word w
5535<FuncQual>{BN}*"abstract"{BN}* { // pure virtual member function
5537 yyextra->current->virt = Specifier::Pure;
5538 yyextra->current->args += " override ";
5539 }
5540<FuncQual,TrailingReturn>{BN}*"override"{BN}* { // C++11 overridden virtual member function
5542 yyextra->current->spec.setOverride(true);
5543 yyextra->current->args += " override ";
5544 if (YY_START==TrailingReturn) yyextra->current->argList.finishTrailingReturnType();
5545 BEGIN(FuncQual);
5546 }
5547<FuncQual,TrailingReturn>{BN}*"final"{BN}* { // C++11 final method
5549 yyextra->current->spec.setFinal(true);
5550 yyextra->current->args += " final ";
5551 if (YY_START==TrailingReturn) yyextra->current->argList.finishTrailingReturnType();
5552 BEGIN(FuncQual);
5553 }
5554<FuncQual>{BN}*"sealed"{BN}* { // sealed member function
5556 yyextra->current->spec.setSealed(true);
5557 yyextra->current->args += " sealed ";
5558 }
5559<FuncQual>{BN}*"new"{BN}* { // new member function
5561 yyextra->current->spec.setNew(true);
5562 yyextra->current->args += " new ";
5563 }
5564<FuncQual>{BN}*"const"{BN}* { // const member function
5566 yyextra->current->args += " const ";
5567 yyextra->current->argList.setConstSpecifier(
TRUE);
5568 }
5569<FuncQual>{BN}*"volatile"{BN}* { // volatile member function
5571 yyextra->current->args += " volatile ";
5572 yyextra->current->argList.setVolatileSpecifier(
TRUE);
5573 }
5574<FuncQual>{BN}*"noexcept"{BN}* { // noexcept qualifier
5576 yyextra->current->args += " noexcept ";
5577 yyextra->current->spec.setNoExcept(true);
5578 }
5579<FuncQual>{BN}*"noexcept"{BN}*"("{B}*false{B}*")"{BN}* { // noexcept(false) expression
5581 yyextra->current->args += " noexcept(false)";
5582 }
5583<FuncQual>{BN}*"noexcept"{BN}*"(" { // noexcept expression
5585 yyextra->current->args += " noexcept(";
5586 yyextra->current->spec.setNoExcept(true);
5587 yyextra->lastRoundContext=FuncQual;
5588 yyextra->pCopyRoundString=&yyextra->current->args;
5589 yyextra->roundCount=0;
5590 BEGIN(CopyRound);
5591 }
5592<FuncQual>{BN}*"&" {
5593 yyextra->current->args += " &";
5595 }
5596<FuncQual>{BN}*"&&" {
5597 yyextra->current->args += " &&";
5599 }
5600
5601<FuncQual,TrailingReturn>{BN}*"="{BN}*"0"{BN}* { // pure virtual member function
5603 yyextra->current->args += " = 0";
5604 yyextra->current->virt = Specifier::Pure;
5605 yyextra->current->argList.setPureSpecifier(
TRUE);
5606 if (YY_START==TrailingReturn) yyextra->current->argList.finishTrailingReturnType();
5607 BEGIN(FuncQual);
5608 }
5609<FuncQual,TrailingReturn>{BN}*"="{BN}*"delete"{BN}* { // C++11 explicitly delete member
5611 yyextra->current->args += " = delete";
5612 yyextra->current->spec.setDelete(true);
5613 yyextra->current->argList.setIsDeleted(
TRUE);
5614 if (YY_START==TrailingReturn) yyextra->current->argList.finishTrailingReturnType();
5615 BEGIN(FuncQual);
5616 }
5617<FuncQual,TrailingReturn>{BN}*"="{BN}*"default"{BN}* { // C++11 explicitly defaulted constructor/assignment operator
5619 yyextra->current->args += " = default";
5620 yyextra->current->spec.setDefault(true);
5621 if (YY_START==TrailingReturn) yyextra->current->argList.finishTrailingReturnType();
5622 BEGIN(FuncQual);
5623 }
5624<FuncQual>{BN}*"->"{BN}* {
5626 yyextra->current->argList.setTrailingReturnType(" -> ");
5627 yyextra->current->args += " -> ";
5628 yyextra->roundCount=0;
5629 BEGIN(TrailingReturn);
5630 }
5631<TrailingReturn>[{;] {
5632 if (yyextra->roundCount>0) REJECT;
5633 unput(*yytext);
5634 yyextra->current->argList.finishTrailingReturnType();
5635 BEGIN(FuncQual);
5636 }
5637<TrailingReturn>"requires"{BN}+ {
5638 if (yyextra->insideJava) REJECT;
5639 yyextra->requiresContext = FuncQual;
5640 yyextra->current->req+=' ';
5641 yyextra->current->argList.finishTrailingReturnType();
5642 BEGIN(RequiresClause);
5643 }
5644<TrailingReturn>"(" {
5645 yyextra->roundCount++;
5646 yyextra->current->argList.appendTrailingReturnType(yytext);
5647 yyextra->current->args+=yytext;
5648 }
5649<TrailingReturn>")" {
5650 if (yyextra->roundCount>0)
5651 {
5652 yyextra->roundCount--;
5653 }
5654 else
5655 {
5656 warn(yyextra->fileName,yyextra->yyLineNr,
5657 "Found ')' without opening '(' for trailing return type '{})...'",
5658 yyextra->current->argList.trailingReturnType());
5659 }
5660 yyextra->current->argList.appendTrailingReturnType(yytext);
5661 yyextra->current->args+=yytext;
5662 }
5663<TrailingReturn>. {
5664 yyextra->current->argList.appendTrailingReturnType(yytext);
5665 yyextra->current->args+=yytext;
5666 }
5667<TrailingReturn>\n {
5669 yyextra->current->argList.appendTrailingReturnType(yytext);
5670 yyextra->current->args+=' ';
5671 }
5672<FuncRound,FuncFunc>{BN}*","{BN}* {
5674 yyextra->current->args += ", " ;
5675 }
5676<FuncQual,FuncRound,FuncFunc>{BN}+ {
5678 yyextra->current->args += ' ' ;
5679 }
5680<SFunction,FuncQual,FuncRound,FuncFunc>"#" { if (yyextra->insidePHP)
5681 REJECT;
5682 yyextra->lastCPPContext = YY_START;
5683 BEGIN(SkipCPP);
5684 }
5685<FuncQual>"=>" {
5686 if (!yyextra->insideCS)
5687 REJECT;
5688
5689 unput('=');
5690 BEGIN(SFunction);
5691 }
5692<FuncQual>"=" {
5693 if (yyextra->insideCli && yyextra->current_root->section.isCompound())
5694 {
5695 BEGIN(CliOverride);
5696 }
5697 else
5698 {
5699
5700 yyextra->lastInitializerContext=YY_START;
5701 yyextra->sharpCount=0;
5702 yyextra->initBracketCount=0;
5703 yyextra->current->initializer.str(yytext);
5704 BEGIN(ReadInitializer);
5705 }
5706 }
5707<ReadExpressionBody>";" {
5708 if (!yyextra->current->sli.empty() && yyextra->previous)
5709 {
5710 yyextra->previous->sli = yyextra->current->sli;
5711 yyextra->current->sli.clear();
5712 }
5713 if (yyextra->previous) yyextra->previous->endBodyLine=yyextra->yyLineNr;
5714 BEGIN(FindMembers);
5715 }
5716<CliOverride>{ID} {
5717 }
5718<CliOverride>"{" {
5719 unput(*yytext);
5720 BEGIN(FuncQual);
5721 }
5722<CliOverride>\n {
5724 }
5725<CliOverride>. {
5726 }
5727<FuncQual>{ID} {
5728 if (yyextra->insideCpp &&
qstrcmp(yytext,
"requires")==0)
5729 {
5730
5731 yyextra->requiresContext = YY_START;
5732 if (!yyextra->current->req.isEmpty())
5733 {
5734 yyextra->current->req+=" && ";
5735 }
5736 BEGIN(RequiresClause);
5737 }
5738 else if (yyextra->insideCS &&
qstrcmp(yytext,
"where")==0)
5739 {
5740
5741 yyextra->current->typeConstr.clear();
5742 yyextra->current->typeConstr.push_back(
Argument());
5743 yyextra->lastCSConstraint = YY_START;
5744 BEGIN( CSConstraintName );
5745 }
5747 {
5748 yyextra->current->args = yytext;
5749 yyextra->oldStyleArgType.clear();
5750 BEGIN(OldStyleArgs);
5751 }
5752 else
5753 {
5754 yyextra->current->args += yytext;
5755 }
5756 }
static bool checkForKnRstyleC(yyscan_t yyscanner)
5760 splitKnRArg(yyscanner,oldStyleArgPtr,oldStyleArgName);
5762 if (yyextra->current->doc!=yyextra->docBackup)
5763 {
5764 doc=yyextra->current->doc;
5765 yyextra->current->doc=yyextra->docBackup;
5766 }
5767 if (yyextra->current->brief!=yyextra->briefBackup)
5768 {
5769 brief=yyextra->current->brief;
5770 yyextra->current->brief=yyextra->briefBackup;
5771 }
5772 addKnRArgInfo(yyscanner,yyextra->oldStyleArgType+oldStyleArgPtr,
5773 oldStyleArgName,brief,doc);
5774 yyextra->current->args.clear();
5775 if (*yytext==';') yyextra->oldStyleArgType.clear();
5776 }
static void addKnRArgInfo(yyscan_t yyscanner, const QCString &type, const QCString &name, const QCString &brief, const QCString &docs)
static void splitKnRArg(yyscan_t yyscanner, QCString &oldStyleArgPtr, QCString &oldStyleArgName)
5777<OldStyleArgs>{ID} { yyextra->current->args += yytext; }
5779 if (yyextra->current->argList.empty())
5780 {
5781 yyextra->current->argList.setNoParameters(
TRUE);
5782 }
5784 unput('{');
5785 BEGIN(FuncQual);
5786 }
5787<OldStyleArgs>. { yyextra->current->args += *yytext; }
5788<FuncQual,FuncRound,FuncFunc>\" {
5789 if (yyextra->insideIDL && yyextra->insideCppQuote)
5790 {
5791 BEGIN(EndCppQuote);
5792 }
5793 else
5794 {
5795 yyextra->current->args += *yytext;
5796 }
5797 }
5798<FuncQual,FuncRound,FuncFunc>. { yyextra->current->args += *yytext; }
5799<FuncQual>{BN}*"try:" |
5800<FuncQual>{BN}*"try"{BN}+ { /* try-function-block */
5801 yyextra->insideTryBlock=
TRUE;
5803 if (yytext[yyleng-1]==':')
5804 {
5805 unput(':');
5806 BEGIN( SFunction );
5807 }
5808 }
5809<FuncQual>{BN}*"throw"{BN}*"(" { // C++ style throw clause
5810 yyextra->current->exception = " throw (" ;
5811 yyextra->roundCount=0;
5813 BEGIN( ExcpRound ) ;
5814 }
5815<FuncQual>{BN}*"raises"{BN}*"(" {
5816 yyextra->current->exception = " raises (" ;
5818 yyextra->roundCount=0;
5819 BEGIN( ExcpRound ) ;
5820 }
5821<FuncQual>{BN}*"throws"{BN}+ { // Java style throw clause
5822 yyextra->current->exception = " throws " ;
5824 BEGIN( ExcpList );
5825 }
5826<ExcpRound>"(" { yyextra->current->exception += *yytext ;
5827 ++yyextra->roundCount ;
5828 }
5829<ExcpRound>")" { yyextra->current->exception += *yytext ;
5830 if ( yyextra->roundCount )
5831 --yyextra->roundCount ;
5832 else
5833 BEGIN( FuncQual ) ;
5834 }
5835<ExcpRound>. {
5836 yyextra->current->exception += *yytext;
5837 }
5838<ExcpList>"{" {
5839 unput('{'); BEGIN( FuncQual );
5840 }
5841<ExcpList>";" {
5842 unput(';'); BEGIN( FuncQual );
5843 }
5844<ExcpList>"\n" {
5845 yyextra->current->exception += ' ';
5847 }
5848<ExcpList>. {
5849 yyextra->current->exception += *yytext;
5850 }
5851<SFunction>"(" { yyextra->current->type += yyextra->current->name ;
5852 yyextra->current->name = yyextra->current->args ;
5853 yyextra->current->args = yytext ;
5854 yyextra->roundCount=0;
5855 BEGIN( FuncRound ) ;
5856 }
5857<SFunction>":" {
5858 if (!yyextra->insidePHP) BEGIN(SkipInits);
5859 }
5860<SFunction>[=;{,] {
5864 yyextra->current->fileName = yyextra->fileName;
5865 yyextra->current->startLine = yyextra->yyBegLineNr;
5866 yyextra->current->startColumn = yyextra->yyBegColNr;
5867 static const reg::Ex re(R
"(\([^)]*[*&][^)]*\))");
5869 std::string type = yyextra->current->type.str();
5870 int ti=-1;
5872 {
5873 ti = (int)
match.position();
5874 }
5875 if (ti!=-1)
5876 {
5877 int di = yyextra->current->type.find("decltype(");
5878 if (di!=-1 && di<ti)
5879 {
5880 ti=-1;
5881 }
5882 }
5883 int ts=yyextra->current->type.find('<');
5884 int te=yyextra->current->type.findRev('>');
5885
5886
5887 bool startsWithTypedef = yyextra->current->type.startsWith("typedef ");
5888 bool isFunction = ti==-1 ||
5889 (ts!=-1 && ts<te && ts<ti && ti<te);
5890 bool isVariable = !yyextra->current->type.isEmpty() &&
5891 (!isFunction || startsWithTypedef);
5892
5893
5894
5895
5896 if (*yytext!=';' || yyextra->current_root->section.isCompound())
5897 {
5898 if (isVariable)
5899 {
5900
5901 if (yyextra->isTypedef && !startsWithTypedef)
5902 {
5903 yyextra->current->type.prepend("typedef ");
5904 }
5905 yyextra->current->section = EntryType::makeVariable() ;
5906 }
5907 else
5908 {
5909
5910 yyextra->current->section = EntryType::makeFunction() ;
5911 yyextra->current->proto = *yytext==';';
5912 }
5913 }
5914 else
5915 {
5916
5917 if (isVariable)
5918 {
5919 if (yyextra->isTypedef && !startsWithTypedef)
5920 {
5921 yyextra->current->type.prepend("typedef ");
5922 }
5923
5924 yyextra->current->section = EntryType::makeVariable();
5925 }
5926 else
5927 {
5928
5929 yyextra->current->section = EntryType::makeFunction();
5930 yyextra->current->proto =
TRUE;
5931 }
5932 }
5933
5934 if ( yyextra->insidePHP)
5935 {
5937 {
5938 yyextra->current->spec.setFinal(true);
5939 }
5941 {
5942 yyextra->current->spec.setAbstract(true);
5943 }
5944 }
5945 if ( yyextra->insidePHP && !
containsWord(yyextra->current->type,
"function"))
5946 {
5948 if ( *yytext == '{' )
5949 {
5950 yyextra->lastCurlyContext = FindMembers;
5951 yyextra->curlyCount=0;
5952 BEGIN( SkipCurly );
5953 }
5954 else
5955 {
5956 BEGIN( FindMembers );
5957 }
5958 }
5959 else
5960 {
5961 if ( yyextra->insidePHP)
5962 {
5964 }
5965 yyextra->previous = yyextra->current;
5966 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
5968
5969 if (yyextra->previous->spec.isOptional() || yyextra->previous->spec.isRequired())
5970 {
5971 yyextra->current->spec.setOptional(true).setRequired(true);
5972 }
5973 yyextra->lastCurlyContext = FindMembers;
5974 if ( *yytext == ',' )
5975 {
5976 yyextra->current->type =
stripFuncPtr(yyextra->previous->type);
5977 }
5978 if ( *yytext == '{' )
5979 {
5980 if ( !yyextra->insidePHP && yyextra->current_root->section.isCompound() )
5981 {
5982 yyextra->previous->spec.setInline(true);
5983 }
5984 yyextra->curlyCount=0;
5985 BEGIN( SkipCurly ) ;
5986 }
5987 else if ( *yytext == '=' )
5988 {
5989 yyextra->previous->spec.setInline(true);
5990 yyextra->curlyCount=0;
5991 BEGIN( ReadExpressionBody );
5992 }
5993 else
5994 {
5995 if (!yyextra->previous->section.isVariable())
5996 yyextra->previous->bodyLine=-1;
5997 BEGIN( FindMembers ) ;
5998 }
5999 }
6000 }
bool findAndRemoveWord(QCString &sentence, const char *word)
removes occurrences of whole word from sentence, while keeps internal spaces and reducing multiple se...
6001<SkipInits>">"{BN}*"{" { // C++11 style initializer (see bug 790788)
6003 yyextra->curlyCount=1;
6004 BEGIN(SkipC11Inits);
6005 }
6006<SkipInits>{ID}{BN}*"{" { // C++11 style initializer (see bug 688647)
6008 yyextra->curlyCount=1;
6009 BEGIN(SkipC11Inits);
6010 }
6011<SkipC11Inits>"{" {
6012 ++yyextra->curlyCount;
6013 }
6014<SkipC11Inits>"}" {
6015 if ( --yyextra->curlyCount<=0 )
6016 {
6017 BEGIN(SkipInits);
6018 }
6019 }
6020<SkipC11Attribute>"]]" {
6021 BEGIN(yyextra->lastC11AttributeContext);
6022 }
6023<SkipInits>"{" { // C++11 style initializer
6024 unput('{');
6025 BEGIN( SFunction );
6026 }
6027<SkipCurly>"{" {
6028
6029 ++yyextra->curlyCount ;
6030 }
6031<SkipCurly>"}"/{BN}*{DCOMM}"<!--" | /* see bug710917 */)
6032<SkipCurly>"}" {
6033
6034 if( yyextra->curlyCount )
6035 {
6036 --yyextra->curlyCount ;
6037 }
6038 else
6039 {
6040 if (!yyextra->current->sli.empty() && yyextra->previous)
6041 {
6042 yyextra->previous->sli = yyextra->current->sli;
6043 yyextra->current->sli.clear();
6044 }
6045 if (yyextra->previous) yyextra->previous->endBodyLine=yyextra->yyLineNr;
6046 BEGIN( yyextra->lastCurlyContext ) ;
6047 }
6048 }
6049<SkipCurly>"}"{BN}*{DCOMM}"<" {
6051 if ( yyextra->curlyCount )
6052 {
6053
6054 --yyextra->curlyCount ;
6055 }
6056 else
6057 {
6058 yyextra->current->endBodyLine=yyextra->yyLineNr;
6059 yyextra->tempEntry = yyextra->current;
6060 yyextra->current = yyextra->previous;
6061
6062 yyextra->docBlockContext = SkipCurlyEndDoc;
6063 yyextra->docBlockInBody =
FALSE;
6064 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
6066 yyextra->docBlock.str(std::string());
6067 yyextra->docBlockTerm = '}';
6068 if (yytext[yyleng-3]=='/')
6069 {
6071 BEGIN( DocLine );
6072 }
6073 else
6074 {
6076 BEGIN( DocBlock );
6077 }
6078 }
6079 }
6080<SkipCurlyEndDoc>"}"{BN}*{DCOMM}"<" { // desc is followed by another one
6081 yyextra->docBlockContext = SkipCurlyEndDoc;
6082 yyextra->docBlockInBody =
FALSE;
6083 yyextra->docBlockAutoBrief = ( yytext[yyleng-2]==
'*' &&
Config_getBool(JAVADOC_AUTOBRIEF) ) ||
6085 yyextra->docBlock.str(std::string());
6086 yyextra->docBlockTerm = '}';
6087 if (yytext[yyleng-3]=='/')
6088 {
6090 BEGIN( DocLine );
6091 }
6092 else
6093 {
6095 BEGIN( DocBlock );
6096 }
6097 }
6098<SkipCurlyEndDoc>"}" {
6099
6100 if (yyextra->tempEntry)
6101 {
6102 yyextra->current = yyextra->tempEntry;
6103 yyextra->tempEntry.reset();
6104 }
6105 BEGIN( yyextra->lastCurlyContext );
6106 }
6107<SkipCurly,ReadExpressionBody>\" {
6108
6109 yyextra->lastStringContext=YY_START;
6110 BEGIN( SkipString );
6111 }
6112<SkipCurly>^{B}*"#" {
6113 if (yyextra->insidePHP)
6114 REJECT;
6115
6116 BEGIN( SkipCurlyCpp );
6117 }
6118<SkipCurly,SkipC11Inits,SkipInits,SkipC11Attribute,ReadExpressionBody>\n {
6120
6121 }
6122<SkipCurly,SkipCurlyCpp,ReadInitializer,ReadInitializerPtr>"<<<" {
6123 if (!yyextra->insidePHP)
6124 {
6125 REJECT;
6126 }
6127 else
6128 {
6129 yyextra->lastHereDocContext = YY_START;
6130 BEGIN(HereDoc);
6131 }
6132 }
6133<SkipCurly,SkipCurlyCpp>{B}*{RAWBEGIN} {
6135 yyextra->lastRawStringContext = YY_START;
6136 yyextra->dummyRawString.clear();
6137 yyextra->pCopyRawString = &yyextra->dummyRawString;
6138 *yyextra->pCopyRawString += yytext;
6139 BEGIN(RawString);
6140 }
6141<SkipCurly,SkipCurlyCpp>[^\n#"R'@\\/{}<\$]+ {
6143
6144 }
6145<SkipCurly,SkipCurlyCpp>"\$" {}
6146<SkipCurlyCpp>\n {
6147
6149 yyextra->lastCurlyContext = FindMembers;
6150 BEGIN( SkipCurly );
6151 }
6152<SkipCurlyCpp>\\[\r]*"\n"[\r]* {
6153
6155 }
6156<SkipInits,SkipC11Inits,SkipCurly,SkipCurlyCpp,SkipC11Attribute,ReadExpressionBody>{CCS} {
6157
6158 yyextra->lastCContext = YY_START;
6159 BEGIN(SkipComment);
6160 }
6161<SkipInits,SkipC11Inits,SkipCurly,SkipCurlyCpp,SkipC11Attribute,ReadExpressionBody>{CPPC} {
6162
6163 yyextra->lastCContext = YY_START;
6164 BEGIN(SkipCxxComment);
6165 }
6166<SkipInits,SkipC11Inits,SkipC11Attribute>"(" {
6167 yyextra->roundCount=0;
6168 yyextra->lastSkipRoundContext=YY_START;
6169 BEGIN(SkipRound);
6170 }
6171<SkipInits,SkipC11Inits,SkipC11Attribute>\" {
6172 yyextra->lastStringContext=YY_START;
6173 BEGIN( SkipString );
6174 }
6175<SkipInits>; {
6176 warn(yyextra->fileName,yyextra->yyLineNr,
6177 "Found ';' while parsing initializer list! "
6178 "(doxygen could be confused by a macro call without semicolon)"
6179 );
6180 BEGIN( FindMembers );
6181 }
6182<SkipInits,SkipCurly,SkipCurlyCpp>"#" {
6183 if (!yyextra->insidePHP)
6184 REJECT;
6185
6186 yyextra->lastCContext = YY_START;
6187 BEGIN(SkipCxxComment);
6188 }
6189<SkipInits,SkipCurly,SkipCurlyCpp,ReadExpressionBody>@\" {
6190 if (!yyextra->insideCS) REJECT;
6191
6192
6193 yyextra->lastSkipVerbStringContext=YY_START;
6194 yyextra->pSkipVerbString=&yyextra->dummyTextStream;
6195 yyextra->dummyTextStream.clear();
6196 BEGIN(SkipVerbString);
6197 }
6198<SkipInits,SkipCurly,SkipCurlyCpp,ReadExpressionBody>{CHARLIT} {
6199 if (yyextra->insidePHP) REJECT;
6200 }
6201<SkipInits,SkipCurly,SkipCurlyCpp>\' {
6202 if (yyextra->insidePHP)
6203 {
6204 yyextra->lastStringContext=YY_START;
6205 BEGIN(SkipPHPString);
6206 }
6207 }
6208<SkipC11Attribute>{ID} {
6210 {
6211 yyextra->current->spec.setNoDiscard(true);
6212 }
6213 }
6214<SkipInits,SkipC11Inits,SkipCurly,SkipCurlyCpp,SkipC11Attribute,ReadExpressionBody>. { }
6215<SkipString,SkipPHPString>\\. { }
6216<SkipString>\" {
6217 BEGIN( yyextra->lastStringContext );
6218 }
6219<SkipPHPString>\' {
6220 BEGIN( yyextra->lastStringContext );
6221 }
6222<SkipString,SkipPHPString>{CCS}|{CCE}|{CPPC} { }
6223<SkipString,SkipPHPString>\n {
6225 }
6226<SkipString>"[[" { }
6227<SkipString,SkipPHPString>. { }
6228<CompoundName>":" { // for "class : public base {} var;" construct, see bug 608359
6229 unput(':');
6230 BEGIN(ClassVar);
6231 }
6232<CompoundName>";" {
6233 yyextra->current->section = EntryType::makeEmpty() ;
6234 yyextra->current->type.clear() ;
6235 yyextra->current->name.clear() ;
6236 yyextra->current->args.clear() ;
6237 yyextra->current->argList.clear();
6238 BEGIN( FindMembers ) ;
6239 }
6240<Bases>";" {
6241 if (yyextra->insideIDL && (yyextra->current->spec.isSingleton() || yyextra->current->spec.isService()))
6242 {
6243
6244
6245 if (!yyextra->current->name.isEmpty() && !yyextra->current_root->name.isEmpty())
6246 {
6248 }
6249 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
6250
6251 if (!yyextra->baseName.isEmpty())
6252 {
6253 yyextra->current->extends.emplace_back(
6254 yyextra->baseName,Protection::Public,Specifier::Normal);
6255 yyextra->baseName.clear();
6256 }
6257 yyextra->current_root->moveToSubEntryAndRefresh( yyextra->current ) ;
6259 }
6260 else
6261 {
6262 yyextra->current->section = EntryType::makeEmpty() ;
6263 yyextra->current->type.clear() ;
6264 yyextra->current->name.clear() ;
6265 yyextra->current->args.clear() ;
6266 yyextra->current->argList.clear();
6267 }
6268 BEGIN( FindMembers ) ;
6269 }
6270<CompoundName>{SCOPENAME}/{BN}*"<" {
6271 yyextra->sharpCount = 0;
6272 yyextra->current->name = yytext ;
6274 if (yyextra->current->spec.isProtocol())
6275 {
6276 yyextra->current->name+="-p";
6277 }
6279 yyextra->lastClassTemplSpecContext = ClassVar;
6280 if (yyextra->insideObjC)
6281 {
6282 BEGIN( ObjCProtocolList );
6283 }
6284 else if (yyextra->insideCS)
6285 {
6286
6287 BEGIN( CSGeneric );
6288 }
6289 else
6290 {
6291 yyextra->roundCount=0;
6292 BEGIN( ClassTemplSpec );
6293 }
6294 }
6295<CSGeneric>"<" {
6297
6298
6299 yyextra->current->tArgLists.
push_back(al);
6300 yyextra->currentArgumentList = &yyextra->current->tArgLists.back();
6301 yyextra->templateStr="<";
6302 yyextra->current->name += "<";
6303 yyextra->fullArgString = yyextra->templateStr;
6304 yyextra->copyArgString = &yyextra->current->name;
6305
6306 yyextra->currentArgumentContext = ClassVar;
6307 BEGIN( ReadTempArgs );
6308 }
6309<ObjCProtocolList>"<" {
6310 yyextra->insideProtocolList=
TRUE;
6311 BEGIN( Bases );
6312 }
6313<ClassTemplSpec>">"({BN}*"::"{BN}*{SCOPENAME})? {
6314 yyextra->current->name += yytext;
6316 if (yyextra->roundCount==0 && --yyextra->sharpCount<=0)
6317 {
6319 if (yyextra->current->spec.isProtocol())
6320 {
6321 unput('{');
6322 BEGIN( ClassVar );
6323 }
6324 else
6325 {
6326 BEGIN( yyextra->lastClassTemplSpecContext );
6327 }
6328 }
6329 }
6330<ClassTemplSpec>"<" {
6331 yyextra->current->name += yytext;
6332 if (yyextra->roundCount==0) yyextra->sharpCount++;
6333 }
6334<ClassTemplSpec>. {
6335 yyextra->current->name += yytext;
6336 }
6337<CompoundName>({SCOPENAME}|{CSSCOPENAME}){BN}*";" { // forward declaration?
6338 if (yyextra->insideCS && yyextra->current->type == "namespace")
6339 {
6340
6342 yyextra->current->name =
substitute(yytext,
".",
"::");
6343 yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
6344 yyextra->fakeNS++;
6345 unput('{');
6346 BEGIN( ClassVar );
6347 }
6348 else if (!yyextra->current->tArgLists.empty())
6349 {
6350
6351
6352 yyextra->current->name = yytext;
6353 yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
6355
6356 QCString rn = yyextra->current_root->name;
6357
6358 if (!yyextra->current->name.isEmpty() && !rn.
isEmpty())
6359 {
6361 }
6362 yyextra->current->spec.setForwardDecl(true);
6363 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
6364 }
6365 else if (yyextra->insideIDL &&
6366 (((yyextra->current_root->spec.isInterface() || yyextra->current_root->spec.isService()) &&
6367 yyextra->current->spec.isInterface()) ||
6368 ((yyextra->current_root->spec.isService() || yyextra->current_root->spec.isSingleton()) &&
6369 yyextra->current->spec.isService())
6370 )
6371 )
6372 {
6373
6374
6375
6376
6377 yyextra->current->name = yytext;
6378 yyextra->current->name=yyextra->current->name.left(yyextra->current->name.length()-1).stripWhiteSpace();
6379 yyextra->current->section = yyextra->current->spec.isInterface() ? EntryType::makeExportedInterface()
6381
6382 yyextra->current->spec.setInterface(false).setService(false);
6383
6384
6385
6386 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
6387 }
6388
6389 if (!(yyextra->insideCS && yyextra->current->type == "namespace"))
6390 {
6391 unput(';');
6392 yyextra->current->reset();
6394 if (yyextra->insideObjC)
6395 {
6396 yyextra->language = yyextra->current->lang = SrcLangExt::Cpp;
6397 yyextra->insideObjC =
FALSE;
6398 }
6399 if (yyextra->isTypedef)
6400 {
6401 yyextra->current->type.prepend("typedef");
6402 }
6403 BEGIN( FindMembers );
6404 }
6405 }
6406<CompoundName>{SCOPENAME}/{BN}*"(" {
6407 yyextra->current->name = yytext ;
6410 if (yyextra->insideCpp && yyextra->current->name=="alignas")
6411 {
6412 yyextra->lastAlignAsContext = YY_START;
6413 BEGIN( AlignAs );
6414 }
6415 else
6416 {
6417 if (yyextra->current->spec.isProtocol())
6418 {
6419 yyextra->current->name += "-p";
6420 }
6421 BEGIN( ClassVar );
6422 }
6423 }
6424<AlignAs>"(" { yyextra->roundCount=0;
6425 BEGIN( AlignAsEnd );
6426 }
6427<AlignAs>\n { lineCount(yyscanner); }
6429<AlignAsEnd>"(" { yyextra->roundCount++; }
6430<AlignAsEnd>")" { if (--yyextra->roundCount<0)
6431 {
6432 BEGIN( yyextra->lastAlignAsContext );
6433 }
6434 }
6435<AlignAsEnd>\n { lineCount(yyscanner); }
6437<ConceptName>{ID} {
6438 yyextra->current->name = yytext ;
6440 }
6441<ConceptName>"=" {
6442 yyextra->current->bodyLine = yyextra->yyLineNr;
6443 yyextra->current->bodyColumn = yyextra->yyColNr;
6444 yyextra->current->initializer.str(std::string());
6445 yyextra->lastInitializerContext = FindMembers;
6446 yyextra->sharpCount=0;
6447 yyextra->initBracketCount=0;
6448 BEGIN(ReadInitializer);
6449 }
6450<CompoundName>{SCOPENAME}/{BN}*"," { // multiple forward declarations on one line
6451
6452 yyextra->current->reset();
6454 }
6455<CompoundName>{SCOPENAME} {
6456 yyextra->current->name = yytext ;
6459 if (yyextra->current->spec.isProtocol())
6460 {
6461 yyextra->current->name += "-p";
6462 }
6463 if (yyextra->current->spec.isProtocol() || yyextra->current->section.isObjcImpl())
6464 {
6465 unput('{');
6466 }
6467 BEGIN( ClassVar );
6468 }
6469<CompoundName>{CSSCOPENAME} { // C# style scope
6470 yyextra->current->name =
substitute(yytext,
".",
"::");
6472 BEGIN( ClassVar );
6473 }
6474<ClassVar>{SCOPENAME}{BNopt}/"(" {
6475 if (yyextra->insideIDL &&
literal_at(yytext,
"switch") && !
isId(yytext[6]))
6476 {
6477
6478 yyextra->roundCount=0;
6479 BEGIN(SkipUnionSwitch);
6480 }
6481 else
6482 {
6484 yyextra->yyBegColNr=yyextra->yyColNr;
6485 yyextra->yyBegLineNr=yyextra->yyLineNr;
6486 yyextra->current->name = yytext;
6487 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
6490 BEGIN( FindMembers );
6491 }
6492 }
6493<ClassVar>"," {
6494 if (yyextra->isTypedef)
6495 {
6496
6497 unput(',');
6498 yyextra->current->type.prepend("typedef ");
6499 BEGIN(FindMembers);
6500 }
6501 else
6502 {
6503
6504 }
6505 }
6506<ClassVar>("sealed"|"abstract")/{BN}*(":"|"{") {
6507 if (yyextra->insideCli)
6508 {
6509 if (yytext[0]=='s')
6510 yyextra->current->spec.setSealedClass(true);
6511 else
6512 yyextra->current->spec.setAbstractClass(true);
6513 BEGIN( ClassVar );
6514 }
6515 else
6516 {
6517 REJECT;
6518 }
6519 }
6520<ClassVar>({ID}{BN}*"::"{BN}*)+{ID} {
6521 yyextra->yyBegColNr=yyextra->yyColNr;
6522 yyextra->yyBegLineNr=yyextra->yyLineNr;
6525 if (yyextra->current->section.isEnum())
6526 {
6527 yyextra->current->section = EntryType::makeVariable() ;
6528 }
6529 yyextra->current->type += ' ' ;
6530 yyextra->current->type += yyextra->current->name ;
QCString simplifyWhiteSpace() const
return a copy of this string with leading and trailing whitespace removed and multiple whitespace cha...
6532
6534 {
6535 BEGIN( Operator );
6536 }
6537 }
6538<ClassVar>{ID} {
6539 yyextra->yyBegColNr=yyextra->yyColNr;
6540 yyextra->yyBegLineNr=yyextra->yyLineNr;
6542 if (yyextra->insideIDL &&
qstrcmp(yytext,
"switch")==0)
6543 {
6544
6545 yyextra->roundCount=0;
6546 BEGIN(SkipUnionSwitch);
6547 }
6548 else if ((yyextra->insideJava || yyextra->insidePHP || yyextra->insideJS || yyextra->insideSlice) && (
qstrcmp(yytext,
"implements")==0 ||
qstrcmp(yytext,
"extends")==0))
6549 {
6550 yyextra->current->type.clear();
6551 yyextra->baseProt = Protection::Public;
6552 yyextra->baseVirt = Specifier::Normal;
6553 yyextra->baseName.clear();
6554 BEGIN( BasesProt ) ;
6555 }
6556 else if (yyextra->insideCS &&
qstrcmp(yytext,
"where")==0)
6557 {
6558 yyextra->current->typeConstr.clear();
6559 yyextra->current->typeConstr.push_back(
Argument());
6560 yyextra->lastCSConstraint = YY_START;
6561 BEGIN( CSConstraintName );
6562 }
6563 else if (yyextra->insideCli &&
qstrcmp(yytext,
"abstract")==0)
6564 {
6565 yyextra->current->spec.setAbstract(true);
6566 }
6567 else if (yyextra->insideCli &&
qstrcmp(yytext,
"sealed")==0)
6568 {
6569 yyextra->current->spec.setSealed(true);
6570 }
6571 else if (
qstrcmp(yytext,
"final")==0)
6572 {
6573 yyextra->current->spec.setFinal(true);
6574 }
6575 else
6576 {
6577 if (yyextra->current->section.isEnum())
6578 {
6579 yyextra->current->section = EntryType::makeVariable() ;
6580 }
6581 yyextra->current->type += ' ' ;
6582 yyextra->current->type += yyextra->current->name ;
6583 yyextra->current->name = yytext ;
6584
6586 {
6587 BEGIN( Operator );
6588 }
6589 }
6590 }
6591<ClassVar>[(\[] {
6592 if (yyextra->insideObjC && *yytext=='(')
6593 {
6594 yyextra->current->name+='(';
6595 yyextra->current->spec.setCategory(true);
6596 BEGIN( ClassCategory );
6597 }
6598 else if (yyextra->insideCS && *yytext=='(')
6599 {
6600 yyextra->current->args=yytext;
6601 yyextra->currentArgumentContext = ClassVar;
6602 yyextra->fullArgString = yyextra->current->args;
6603 yyextra->copyArgString = &yyextra->current->args;
6604 BEGIN( ReadFuncArgType ) ;
6605 }
6606 else
6607 {
6608
6609 unput(*yytext);
6610 BEGIN( FindMembers );
6611 }
6612 }
6613<CSConstraintType,CSConstraintName>{CCS}{CCE} { /* empty comment */ }
6614<CSConstraintType,CSConstraintName>({CCS}[*!]|{CPPC}[/!])("<"?) { // special comment
6615 yyextra->fullArgString.clear();
6616 yyextra->lastCopyArgChar='#';
6617 yyextra->lastCommentInArgContext=YY_START;
6618 if (yytext[1]=='/')
6619 BEGIN( CopyArgCommentLine );
6620 else
6621 BEGIN( CopyArgComment );
6622 }
6623<CSConstraintType,CSConstraintName>"#" { // artificially inserted token to signal end of comment block
6624 yyextra->current->typeConstr.back().docs = yyextra->fullArgString;
6625 }
6626<CSConstraintType>"=>" { // end of type constraint reached
6627
6629 unput('>');
6630 unput('=');
6631 BEGIN( yyextra->lastCSConstraint );
6632 }
6633<CSConstraintType>"{" { // end of type constraint reached
6634
6636 unput('{');
6637 BEGIN( yyextra->lastCSConstraint );
6638 }
6639<CSConstraintType,CSConstraintName>";" {
6641 unput(';');
6642 BEGIN( yyextra->lastCSConstraint );
6643 }
6644<CSConstraintName>":" {
6645 BEGIN( CSConstraintType );
6646 }
6647<CSConstraintName>{ID} {
6648
6649 yyextra->current->typeConstr.back().name=yytext;
6650 }
6651<CSConstraintType>"where" { // another constraint for a different param
6652 yyextra->current->typeConstr.push_back(
Argument());
6653 BEGIN( CSConstraintName );
6654 }
6655<CSConstraintType>({ID}".")*{ID}("<"{ID}">")?("()")? {
6656 if (yyextra->current->typeConstr.back().type.isEmpty())
6657
6658 {
6659 yyextra->current->typeConstr.back().type=yytext;
6660 }
6661 else
6662 {
6663 QCString name = yyextra->current->typeConstr.back().name;
6664 yyextra->current->typeConstr.push_back(
Argument());
6665 yyextra->current->typeConstr.back().name=name;
6666 yyextra->current->typeConstr.back().type=yytext;
6667 }
6668 }
6669<CSConstraintName,CSConstraintType>\n {
6671 }
6672<CSConstraintName,CSConstraintType>. {
6673 }
6674<ClassCategory>{ID} {
6675 yyextra->current->name+=yytext;
6676 }
6677<ClassCategory>")"/{BN}*"{" {
6678 yyextra->current->name+=')';
6679 BEGIN( ClassVar );
6680 }
6681<ClassCategory>")"/{BN}*"<" {
6682 yyextra->current->name+=')';
6683 BEGIN( ObjCProtocolList );
6684 }
6685<ClassCategory>")" {
6686 yyextra->current->name+=')';
6687 if (yyextra->current->spec.isProtocol() || yyextra->current->section.isObjcImpl())
6688 {
6689 unput('{');
6690 }
6691 else
6692 {
6693 unput('}');
6694 unput('{');
6695 }
6696 BEGIN( ClassVar );
6697 }
6698<ClassVar>":" {
6699 if (yyextra->current->section.isVariable())
6700 {
6701 yyextra->current->bitfields+=":";
6702 yyextra->current->args.clear();
6703 BEGIN(BitFields);
6704 }
6705 else if (yyextra->current->section.isEnum())
6706
6707 {
6708 yyextra->current->args.clear();
6709 BEGIN(EnumBaseType);
6710 }
6711 else
6712 {
6713 yyextra->current->type.clear();
6714 if (yyextra->current->spec.isInterface() ||
6715 yyextra->current->spec.isStruct() ||
6716 yyextra->current->spec.isRef() ||
6717 yyextra->current->spec.isValue() ||
6718 yyextra->insidePHP || yyextra->insideCS || yyextra->insideD || yyextra->insideObjC || yyextra->insideIDL
6719 )
6720 {
6721 yyextra->baseProt = Protection::Public;
6722 }
6723 else
6724 {
6725 yyextra->baseProt = Protection::Private;
6726 }
6727 yyextra->baseVirt = Specifier::Normal;
6728 yyextra->baseName.clear();
6729 BEGIN( BasesProt ) ;
6730 }
6731 }
6732<ClassVar>[;=*&] {
6733 if (yyextra->isTypedef)
6734 {
6735 yyextra->current->type.prepend("typedef");
6736 }
6737 if ((yytext[0]=='*' || yytext[0]=='&') && yyextra->current->section.isEnum())
6738 {
6739 yyextra->current->section = EntryType::makeVariable() ;
6740 }
6741 if (yytext[0]==';' && yyextra->current->section.isEnum())
6742 {
6743 yyextra->current->reset();
6745 }
6746 else
6747 {
6748 unput(*yytext);
6749 }
6750 BEGIN( FindMembers );
6751 }
6752<Bases,ClassVar>{CPPC}"/"/[^/] {
6753 if (!yyextra->insideObjC)
6754 {
6755 REJECT;
6756 }
6757 else
6758 {
6760 yyextra->current->program << yytext;
6761 yyextra->current->fileName = yyextra->fileName ;
6762 yyextra->current->startLine = yyextra->yyLineNr ;
6763 yyextra->current->startColumn = yyextra->yyColNr;
6764 yyextra->curlyCount=0;
6765 BEGIN( ReadBodyIntf );
6766 }
6767 }
6768<Bases,ClassVar>({CPPC}{B}*)?{CCS}"*"/{NCOMM} |
6769<Bases,ClassVar>({CPPC}{B}*)?{CCS}"!" |
6770<Bases,ClassVar>{CPPC}"!" |
6771<Bases,ClassVar>[\-+]{BN}* {
6772 if (!yyextra->insideObjC)
6773 {
6774 REJECT;
6775 }
6776 else
6777 {
6779 yyextra->current->program << yytext;
6780 yyextra->current->fileName = yyextra->fileName ;
6781 yyextra->current->startLine = yyextra->yyLineNr ;
6782 yyextra->current->startColumn = yyextra->yyColNr;
6783 yyextra->curlyCount=0;
6784 BEGIN( ReadBodyIntf );
6785 }
6786 }
6787<CompoundName,ClassVar>{B}*"{"{B}* {
6788 yyextra->current->program.str(std::string());
6789 yyextra->current->fileName = yyextra->fileName ;
6790 yyextra->current->bodyLine = yyextra->yyLineNr;
6791 yyextra->current->bodyColumn = yyextra->yyColNr;
6793 if (yyextra->current->name.isEmpty() && !yyextra->isTypedef)
6794 {
6795 if (yyextra->current->section.isNamespace())
6796 {
6798 {
6799 yyextra->current->name=
"anonymous_namespace{"+
stripPath(yyextra->current->fileName)+
"}";
6800 }
6801 else
6802 {
6804 }
6805 }
6806 else
6807 {
6809 }
6810 }
6811 yyextra->curlyCount=0;
6812 if (yyextra->current_root &&
6813 !yyextra->current_root->spec.isInterface() &&
6814 (yyextra->current->spec.isInterface() ||
6815 yyextra->current->spec.isProtocol() ||
6816 yyextra->current->spec.isCategory() ||
6817 yyextra->current->section.isObjcImpl()
6818 ) &&
6819 yyextra->insideObjC
6820 )
6821 {
6822 BEGIN( ReadBodyIntf );
6823 }
6824 else if (yyextra->current->section.isNamespace())
6825 {
6826 BEGIN( ReadNSBody );
6827 }
6828 else
6829 {
6830 BEGIN( ReadBody ) ;
6831 }
6832 }
QCString stripPath(const QCString &s)
6833<BasesProt>"virtual"{BN}+ { lineCount(yyscanner); yyextra->baseVirt = Specifier::Virtual; }
6834<BasesProt>"public"{BN}+ { lineCount(yyscanner); yyextra->baseProt = Protection::Public; }
6835<BasesProt>"protected"{BN}+ { lineCount(yyscanner); yyextra->baseProt = Protection::Protected; }
6836<BasesProt>"internal"{BN}+ { if (!yyextra->insideCli) REJECT ; lineCount(yyscanner); yyextra->baseProt = Protection::Package; }
6837<BasesProt>"private"{BN}+ { lineCount(yyscanner); yyextra->baseProt = Protection::Private; }
6838<BasesProt>{BN} { lineCount(yyscanner); }
6839<BasesProt>. { unput(*yytext); BEGIN(Bases); }
6840<Bases>"decltype"{BN}*"(" {
6842 yyextra->roundCount=0;
6843 yyextra->lastSkipRoundContext=YY_START;
6844 BEGIN(SkipRound);
6845 }
6846<Bases>("\\")?({ID}"\\")*{ID} { // PHP namespace token, not sure if interspacing is allowed but it gives problems (see bug 640847)
6847 if (!yyextra->insidePHP)
6848 {
6849 REJECT;
6850 }
6851 else
6852 {
6856 yyextra->baseName += bn;
6857 yyextra->current->args += ' ';
6858 yyextra->current->args += yytext;
6859 }
6860 }
6861<Bases>("::")?{BN}*({ID}{BN}*"::"{BN}*)*{ID}("...")? {
6865 {
6866
6867 yyextra->current->typeConstr.clear();
6868 yyextra->current->typeConstr.push_back(
Argument());
6869 yyextra->lastCSConstraint = YY_START;
6870 BEGIN( CSConstraintName );
6871 }
6872 else
6873 {
6874 yyextra->baseName+=yytext;
6875 yyextra->current->args += ' ';
6876 yyextra->current->args += yytext;
6877 }
6878 }
6879<Bases>{BN}*{ID}("."{ID})* { // Java style class
6881 yyextra->baseName += name;
6882 yyextra->current->args += ' ';
6883 yyextra->current->args += name;
6884 }
6885<ClassVar,Bases>\n/{BN}*[^{, \t\n:] {
6886 if (!yyextra->insideObjC)
6887 {
6888 REJECT;
6889 }
6890 else
6891 {
6893 unput('{');
6894 }
6895 }
6896<ClassVar,Bases>"@end" { // empty ObjC interface
6897 unput('d');
6898 unput('n');
6899 unput('e');
6900 unput('@');
6901 unput('}');
6902 unput('{');
6903 }
6904<ClassVar>"<" { yyextra->current->name += *yytext;
6905 yyextra->sharpCount=1;
6906 yyextra->roundCount=0;
6907 yyextra->lastSkipSharpContext = YY_START;
6908 yyextra->specName = &yyextra->current->name;
6909 BEGIN ( Specialization );
6910 }
6911<Bases>{BN}*"<" {
6913 yyextra->sharpCount=1;
6914 yyextra->roundCount=0;
6915 yyextra->lastSkipSharpContext = YY_START;
6916 if (yyextra->insideObjC)
6917 {
6918 unput(',');
6919 }
6920 else
6921 {
6922
6923
6924
6925
6926 yyextra->templateStr = yytext;
6927 yyextra->specName = &yyextra->templateStr;
6928 BEGIN ( Specialization );
6929 }
6930 }
6931<Specialization>"<" { *yyextra->specName += *yytext;
6932 if (yyextra->roundCount==0) yyextra->sharpCount++;
6933 }
6934<Specialization>">" {
6935 *yyextra->specName += *yytext;
6936 if (yyextra->roundCount==0 && --yyextra->sharpCount<=0)
6937 {
6939 BEGIN(yyextra->lastSkipSharpContext);
6940 }
6941 }
6942<Specialization>{BN}+ { lineCount(yyscanner); *yyextra->specName +=' '; }
6943<Specialization>"<<" { *yyextra->specName += yytext; }
6944<Specialization>">>"/{B}*"::" { // M$ C++ extension to allow >> to close a template...
6945 unput('>');
6946 unput(' ');
6947 unput('>');
6948 }
6949<Specialization>">>" {
6950 if (yyextra->insideCS)
6951 {
6952 REJECT;
6953 }
6954 else
6955
6956
6957
6958
6959 {
6960 if (yyextra->roundCount>0)
6961 {
6962 *yyextra->specName += yytext;
6963 }
6964 else
6965 {
6966 unput('>');
6967 unput(' ');
6968 unput('>');
6969 }
6970 }
6971 }
6972<Specialization>"typename"{BN}+ { lineCount(yyscanner); }
6973<Specialization>"(" { *yyextra->specName += *yytext; yyextra->roundCount++; }
6974<Specialization>")" { *yyextra->specName += *yytext; yyextra->roundCount--; }
6975
6976<Specialization>"\\\\" { *yyextra->specName += *yytext;}
6977<Specialization>"\\'" { *yyextra->specName += *yytext;}
6978<Specialization>"\\\"" { *yyextra->specName += *yytext;}
6979<Specialization>"'" { *yyextra->specName += *yytext;BEGIN(SpecializationSingleQuote);}
6980<Specialization>"\"" { *yyextra->specName += *yytext;BEGIN(SpecializationDoubleQuote);}
6981<SpecializationSingleQuote,SpecializationDoubleQuote>"\\\\" { *yyextra->specName += *yytext;}
6982<SpecializationSingleQuote>"\\'" { *yyextra->specName += *yytext;}
6983<SpecializationSingleQuote>"'" { *yyextra->specName += *yytext; BEGIN(Specialization);}
6984<SpecializationDoubleQuote>"\\\"" { *yyextra->specName += *yytext;}
6985<SpecializationDoubleQuote>"\"" { *yyextra->specName += *yytext; BEGIN(Specialization);}
6986<SpecializationSingleQuote,SpecializationDoubleQuote>. { *yyextra->specName += *yytext;}
6987
6988<Specialization>. {
6989 *yyextra->specName += *yytext;
6990 }
6991<SkipRound>"(" { ++yyextra->roundCount; }
6992<SkipRound>")" { if (--yyextra->roundCount<0)
6993 BEGIN ( yyextra->lastSkipRoundContext );
6994 }
6995<SkipRound>\" {
6996 yyextra->lastStringContext=SkipRound;
6997 BEGIN(SkipString);
6998 }
6999<Bases>","|(">"({BN}*"{")?)|({BN}+"implements"{BN}*) { lineCount(yyscanner);
7000 if (yyextra->insideProtocolList)
7001 {
7002 yyextra->baseName+="-p";
7003 }
7004 else
7005 {
7006 yyextra->current->args += ',' ;
7007 }
7009 if (!yyextra->baseName.isEmpty())
7010 {
7011 yyextra->current->extends.emplace_back(
7012 yyextra->baseName,yyextra->baseProt,yyextra->baseVirt
7013 );
7014 }
7015 if (yyextra->current->spec.isInterface() || yyextra->current->spec.isStruct() ||
7016 yyextra->insideJava || yyextra->insidePHP || yyextra->insideCS ||
7017 yyextra->insideD || yyextra->insideObjC || yyextra->insideIDL || yyextra->insideSlice)
7018 {
7019 yyextra->baseProt=Protection::Public;
7020 }
7021 else
7022 {
7023 yyextra->baseProt=Protection::Private;
7024 }
7025 yyextra->baseVirt=Specifier::Normal;
7026 yyextra->baseName.clear();
7027 if (*yytext=='>')
7028 {
7029 yyextra->insideProtocolList=
FALSE;
7030 if (yyleng==1)
7031 {
7032 if (yyextra->insideObjC && !yyextra->current->spec.isProtocol())
7033 {
7034 BEGIN(ClassVar);
7035 }
7036 else
7037 {
7038 unput('{');
7039 }
7040 }
7041 else
7042 {
7043 yyless(1);
7044 }
7045 }
7046 else
7047 {
7048 if (*yytext==',' && yyextra->insideObjC)
7049 {
7050 yyextra->insideProtocolList=
TRUE;
7051 }
7052 BEGIN(BasesProt);
7053 }
7054 }
7055<Bases>{B}*"{"{B}* {
7056 yyextra->current->program.str(std::string());
7057 yyextra->current->fileName = yyextra->fileName ;
7058 yyextra->current->bodyLine = yyextra->yyLineNr;
7059 yyextra->current->bodyColumn = yyextra->yyColNr;
7061 if (!yyextra->baseName.isEmpty())
7062 {
7063 yyextra->current->extends.emplace_back(
7064 yyextra->baseName,yyextra->baseProt,yyextra->baseVirt
7065 );
7066 yyextra->baseName.clear();
7067 }
7068 yyextra->curlyCount=0;
7069 if (yyextra->insideObjC)
7070 {
7071 BEGIN( ReadBodyIntf );
7072 }
7073 else
7074 {
7075 BEGIN( ReadBody ) ;
7076 }
7077 }
7078<SkipUnionSwitch>{B}*"(" {
7079 yyextra->roundCount++;
7080 }
7081<SkipUnionSwitch>")" {
7082 if (--yyextra->roundCount==0)
7083 {
7084 BEGIN(ClassVar);
7085 }
7086 }
7087<SkipUnionSwitch>\n { lineCount(yyscanner); }
7088<SkipUnionSwitch>.
7089<Comment>{BN}+ { yyextra->current->program << yytext ;
7091 }
7092<Comment>{CCS} { yyextra->current->program << yytext ; }
7093<Comment>{CPPC} { yyextra->current->program << yytext ; }
7094<Comment>{CMD}("code"|"verbatim"|"iliteral") {
7095 if (yyextra->doxygenComment) yyextra->insideCode=
TRUE;
7096 yyextra->current->program << yytext ;
7097 }
7098<Comment>{CMD}("endcode"|"endverbatim"|"endiliteral") {
7099 if (yyextra->doxygenComment) yyextra->insideCode=
FALSE;
7100 yyextra->current->program << yytext ;
7101 }
7102<Comment>[^ \.\t\r\n\/\*]+ { yyextra->current->program << yytext ; }
7103<Comment>{CCE} { yyextra->current->program << yytext ;
7104 if (!yyextra->insideCode)
7105 {
7106 yyextra->doxygenComment=false;
7107 BEGIN( yyextra->lastContext );
7108 }
7109 }
7110<Comment>. { yyextra->current->program << *yytext ; }
7111
7112<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,Operator,ClassVar,SkipInits,SkipC11Inits,SkipC11Attribute,ReadExpressionBody,Bases,OldStyleArgs>({CPPC}{B}*)?{CCS}"!" {
7113
7114 if (!yyextra->current->doc.isEmpty())
7115 {
7116 yyextra->current->doc+="\n\n";
7117 }
7118 else
7119 {
7120 yyextra->current->docLine = yyextra->yyLineNr;
7121 yyextra->current->docFile = yyextra->fileName;
7122 }
7123
7124 yyextra->lastDocContext = YY_START;
7125 if (yyextra->current_root->section.isScope())
7126 {
7127 yyextra->current->inside = yyextra->current_root->name+"::";
7128 }
7129 yyextra->docBlockContext = YY_START;
7130 yyextra->docBlockInBody = YY_START==SkipCurly || YY_START==ReadExpressionBody;
7132
7135 yyextra->docBlock.
str(indent.
str());
7136
7137 if (yyextra->docBlockAutoBrief)
7138 {
7139 yyextra->current->briefLine = yyextra->yyLineNr;
7140 yyextra->current->briefFile = yyextra->fileName;
7141 }
7143 BEGIN( DocBlock );
7144 }
7145<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,Operator,ClassVar,SkipInits,ReadExpressionBody,Bases,OldStyleArgs>{CCS}"*"[*]+{BL} {
7148
7149 if( javadocBanner )
7150 {
7151 yyextra->lastDocContext = YY_START;
7152
7153
7154 if (yyextra->current_root->section.isScope())
7155 {
7156 yyextra->current->inside = yyextra->current_root->name+"::";
7157 }
7158 yyextra->current->docLine = yyextra->yyLineNr;
7159 yyextra->current->docFile = yyextra->fileName;
7160 yyextra->docBlockContext = YY_START;
7161 yyextra->docBlockInBody = YY_START==SkipCurly || YY_START==ReadExpressionBody;
7163 yyextra->docBlockAutoBrief = javadocAutoBrief;
7164
7167 yyextra->docBlock.
str(indent.
str());
7168
7169 if (yyextra->docBlockAutoBrief)
7170 {
7171 yyextra->current->briefLine = yyextra->yyLineNr;
7172 yyextra->current->briefFile = yyextra->fileName;
7173 }
7175 BEGIN( DocBlock );
7176 }
7177 else
7178 {
7179 yyextra->current->program << yytext ;
7180 yyextra->lastContext = YY_START ;
7181 yyextra->doxygenComment=true;
7182 BEGIN( Comment ) ;
7183 }
7184 }
7185<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,Operator,ClassVar,ReadExpressionBody,SkipInits,Bases,OldStyleArgs>^{B}+({CPPC}{B}*)?{CCS}"*"/{NCOMM} {
7187 yyextra->yyColNr=1;
7188 REJECT;
7189 }
7190<FindMembers,FindFields,MemberSpec,FuncQual,SkipCurly,ReadExpressionBody,Operator,ClassVar,SkipInits,Bases,OldStyleArgs>({CPPC}{B}*)?{CCS}"*"/{NCOMM} {
7191 yyextra->lastDocContext = YY_START;
7192
7193
7194 if (yyextra->current_root->section.isScope())
7195 {
7196 yyextra->current->inside = yyextra->current_root->name+"::";
7197 }
7198 yyextra->current->docLine = yyextra->yyLineNr;
7199 yyextra->current->docFile = yyextra->fileName;
7200 yyextra->docBlockContext = YY_START;
7201 yyextra->docBlockInBody = YY_START==SkipCurly || YY_START==ReadExpressionBody;
7203 yyextra->docBlockAutoBrief = javadocAutoBrief;
7204
7207 yyextra->docBlock.
str(indent.
str());
7208
7209 if (yyextra->docBlockAutoBrief)
7210 {
7211 yyextra->current->briefLine = yyextra->yyLineNr;
7212 yyextra->current->briefFile = yyextra->fileName;
7213 }
7215 BEGIN( DocBlock );
7216 }
7217<FindMembers,FindFields,MemberSpec,SkipCurly,ReadExpressionBody,FuncQual,Operator,ClassVar,Bases,OldStyleArgs>{CPPC}"!" {
7218 yyextra->lastDocContext = YY_START;
7219 if (yyextra->current_root->section.isScope())
7220 {
7221 yyextra->current->inside = yyextra->current_root->name+"::";
7222 }
7223 yyextra->docBlockContext = YY_START;
7224 yyextra->docBlockInBody = YY_START==SkipCurly || YY_START==ReadExpressionBody;
7225 yyextra->docBlockAutoBrief =
FALSE;
7226
7229 yyextra->docBlock.
str(indent.
str());
7230
7232 BEGIN( DocLine );
7233 }
7234<FindMembers,FindFields,MemberSpec,SkipCurly,ReadExpressionBody,FuncQual,Operator,ClassVar,Bases,OldStyleArgs>{CPPC}"/"/[^/] {
7235 yyextra->lastDocContext = YY_START;
7236 if (yyextra->current_root->section.isScope())
7237 {
7238 yyextra->current->inside = yyextra->current_root->name+"::";
7239 }
7240 yyextra->docBlockContext = YY_START;
7241 yyextra->docBlockInBody = YY_START==SkipCurly || YY_START==ReadExpressionBody;
7242 yyextra->docBlockAutoBrief =
FALSE;
7245 yyextra->docBlock.
str(indent.
str());
7247 BEGIN( DocLine );
7248 }
7249<FindMembers>"extern"{BN}*"\""[^\"]+"\""{BN}*("{")? {
7251 yyextra->externLinkage=
TRUE;
7252 }
7253<FindMembers>"{" {
7254 if (yyextra->externLinkage)
7255 {
7256 yyextra->externLinkage=
FALSE;
7257 }
7258 else if (yyextra->insideCS &&
7259 !yyextra->current->name.isEmpty() &&
7260 !yyextra->current->type.isEmpty())
7261 {
7262 if (yyextra->current->mtype == MethodTypes::Event)
7263 {
7264 yyextra->mtype = MethodTypes::Event;
7265 }
7267 {
7268 yyextra->current->mtype = yyextra->mtype = MethodTypes::Event;
7269 }
7270 else
7271 {
7272 yyextra->current->mtype = yyextra->mtype = MethodTypes::Property;
7273 }
7274 yyextra->current->bodyLine = yyextra->yyLineNr;
7275 yyextra->current->bodyColumn = yyextra->yyColNr;
7276 yyextra->curlyCount=0;
7277 BEGIN( CSAccessorDecl );
7278 }
7279 else if (yyextra->insideIDL && yyextra->current->spec.isAttribute())
7280 {
7281
7282
7283 yyextra->current->exception = " {";
7284 BEGIN(UNOIDLAttributeBlock);
7285 }
7286 else
7287 {
7288 if ((yyextra->insideJava || yyextra->insideCS || yyextra->insideD) &&
7289 yyextra->current->name.isEmpty()
7290 )
7291 {
7292
7293 yyextra->needsSemi =
FALSE;
7294 if (yyextra->current->isStatic)
7295 {
7296 yyextra->current->name="[static initializer]";
7297 yyextra->current->type.clear();
7298 }
7299 else
7300 {
7301 yyextra->current->name="[instance initializer]";
7302 }
7303 unput(*yytext);
7304 BEGIN( SFunction );
7305 }
7306 else
7307 {
7308
7309
7310
7311
7312
7313
7314
7315
7316
7317
7318 yyextra->current->bodyLine = yyextra->yyLineNr;
7319 yyextra->current->bodyColumn = yyextra->yyColNr;
7320 yyextra->current->initializer.str(yytext);
7321 yyextra->lastInitializerContext = YY_START;
7322 yyextra->sharpCount=0;
7323 yyextra->initBracketCount=1;
7324 BEGIN(ReadInitializer);
7325 }
7326 }
7327 }
7328<CSAccessorDecl>"{" { yyextra->curlyCount++; }
7329<CSAccessorDecl>"}"{B}*"=" {
7330
7331 if (yyextra->curlyCount != 0) REJECT;
7332 yyextra->current->initializer.str("=");
7333 yyextra->current->endBodyLine=yyextra->yyLineNr;
7334 yyextra->lastInitializerContext = FindMembers;
7335 BEGIN(ReadInitializer);
7336 }
7337<CSAccessorDecl>"}" {
7338 if (yyextra->curlyCount)
7339 {
7340 yyextra->curlyCount--;
7341 }
7342 else
7343 {
7344 yyextra->mtype = MethodTypes::Method;
7345 yyextra->virt = Specifier::Normal;
7346
7347 yyextra->current->endBodyLine=yyextra->yyLineNr;
7348 unput(';');
7349 BEGIN(FindMembers);
7350 }
7351 }
7352<CSAccessorDecl>"private "{BN}*"set" { if (yyextra->curlyCount==0) yyextra->current->spec.setPrivateSettable(true); }
7353<CSAccessorDecl>"protected "{BN}*"set" { if (yyextra->curlyCount==0) yyextra->current->spec.setProtectedSettable(true); }
7354<CSAccessorDecl>"private "{BN}*"get" { if (yyextra->curlyCount==0) yyextra->current->spec.setPrivateGettable(true); }
7355<CSAccessorDecl>"protected "{BN}*"get" { if (yyextra->curlyCount==0) yyextra->current->spec.setProtectedGettable(true); }
7356<CSAccessorDecl>"set" { if (yyextra->curlyCount==0) yyextra->current->spec.setSettable(true); }
7357<CSAccessorDecl>"get" { if (yyextra->curlyCount==0) yyextra->current->spec.setGettable(true); }
7358<CSAccessorDecl>"add" { if (yyextra->curlyCount==0) yyextra->current->spec.setAddable(true); }
7359<CSAccessorDecl>"remove" { if (yyextra->curlyCount==0) yyextra->current->spec.setRemovable(true); }
7360<CSAccessorDecl>"raise" { if (yyextra->curlyCount==0) yyextra->current->spec.setRaisable(true); }
7361<CSAccessorDecl>{CHARLIT} {}
7362<CSAccessorDecl>"\"" { BEGIN(CSString);}
7363<CSAccessorDecl>"." {}
7364<CSAccessorDecl>\n { lineCount(yyscanner); }
7365<CSString>"\"" { BEGIN(CSAccessorDecl);}
7366<CSString>{CPPC} {} // Otherwise the rule <*>"//" will kick in
7367<CSString>{CCS} {} // Otherwise the rule <*>"/*" will kick in
7368<CSString>\n { lineCount(yyscanner); }
7369<CSString>"." {}
7370
7371
7372
7373<SliceSequence>{SCOPENAME} {
7374 if (yyextra->current->spec.isLocal())
7375 {
7376 yyextra->current->type = "local ";
7377 }
7378 yyextra->current->type += "sequence<";
7379 yyextra->current->type += yytext;
7380 yyextra->current->type += ">";
7381 }
7382
7383<SliceSequence>{BN}*">"{BN}* {
7385 BEGIN(SliceSequenceName);
7386 }
7387
7388<SliceSequenceName>{ID}{BN}* {
7390 yyextra->current->name = yytext ;
7391 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
7392 }
7393
7394<SliceSequenceName>";" {
7395 yyextra->current->section = EntryType::makeVariable();
7396 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
7398 BEGIN(FindMembers);
7399 }
7400
7401<SliceDictionary>{SCOPENAME}{BN}*","{BN}*{SCOPENAME} {
7403 if (yyextra->current->spec.isLocal())
7404 {
7405 yyextra->current->type = "local ";
7406 }
7407 yyextra->current->type += "dictionary<";
7408 yyextra->current->type += yytext;
7409 yyextra->current->type += ">";
7410 yyextra->current->type = yyextra->current->type.simplifyWhiteSpace();
7411 }
7412
7413<SliceDictionary>{BN}*">"{BN}* {
7415 BEGIN(SliceDictionaryName);
7416 }
7417
7418<SliceDictionaryName>{ID}{BN}* {
7420 yyextra->current->name = yytext ;
7421 yyextra->current->name = yyextra->current->name.stripWhiteSpace();
7422 }
7423
7424<SliceDictionaryName>";" {
7425 yyextra->current->section = EntryType::makeVariable();
7426 yyextra->current_root->moveToSubEntryAndRefresh(yyextra->current);
7428 BEGIN(FindMembers);
7429 }
7430
7431
7432
7433
7434
7435
7436<DocLine>[^\n]*"\n"[ \t]*{CPPC}[/!][<]? { // continuation of multiline C++-style comment
7437 int markerLen = yytext[yyleng-1]=='<' ? 4 : 3;
7438 yyextra->docBlock << std::string(yytext).substr(0,yyleng-markerLen);
7440 }
7441<DocLine>{B}*{CPPC}"/"[/]+{Bopt}/"\n" { // ignore marker line (see bug700345)
7442 handleCommentBlock(yyscanner,yyextra->docBlock.str(),yyextra->current->brief.isEmpty());
7443 BEGIN( yyextra->docBlockContext );
7444 }
7445<DocLine>{NONLopt}/"\n"{B}*{CPPC}[!/]{B}*{CMD}"}" { // next line is an end group marker, see bug 752712
7446 yyextra->docBlock << yytext;
7447 handleCommentBlock(yyscanner,yyextra->docBlock.str(),yyextra->current->brief.isEmpty());
7448 BEGIN( yyextra->docBlockContext );
7449 }
7450<DocLine>{NONLopt}/"\n" { // whole line
7451 yyextra->docBlock << yytext;
7452 handleCommentBlock(yyscanner,yyextra->docBlock.str(),yyextra->current->brief.isEmpty());
7453 BEGIN( yyextra->docBlockContext );
7454 }
7455
7456
7457
7458<DocBlock>"*"*{CCE} { // end of comment block
7460 BEGIN(yyextra->docBlockContext);
7461 }
7462<DocBlock>"\\ilinebr "{B}*"*"/[^/] {
7465 yyextra->docBlock << "\\ilinebr " << indent;
7466 }
7467<DocBlock>^{B}*"*"+/[^/] {
7470 yyextra->docBlock << indent;
7471 }
7472<DocBlock>^{B}*({CPPC})?{B}*"*"+/[^/a-z_A-Z0-9*] { // start of a comment line
7475 yyextra->docBlock << indent;
7476 }
7477<DocBlock>^{B}*({CPPC}){B}* { // strip embedded C++ comments if at the start of a line
7478 }
7479<DocBlock>{CPPC} { // slashes in the middle of a comment block
7480 yyextra->docBlock << yytext;
7481 }
7482<DocBlock>{CCS} { // start of a new comment in the
7483
7484 yyextra->docBlock << yytext;
7485 }
7486<DocBlock>({CMD}{CMD}){ID}/[^a-z_A-Z0-9] { // escaped command
7487 yyextra->docBlock << yytext;
7488 }
7489<DocBlock>{CMD}("f$"|"f["|"f{"|"f(") {
7490 yyextra->docBlock << yytext;
7491 char blockName[] = "f$";
7492 char c = yytext[2];
7493 if (c=='[') blockName[1]=']';
7494 else if (c=='{') blockName[1]='}';
7495 else if (c=='(') blockName[1]=')';
7497 BEGIN(DocCopyBlock);
7498 }
static void startVerbatimBlock(yyscan_t yyscanner, const QCString &blockName, size_t fencedSize=0, bool codeBlock=false)
7499<DocBlock>{CMD}"ifile"{B}+"\""[^\n\"]+"\"" {
7500 yyextra->fileName = &yytext[6];
7501 yyextra->fileName = yyextra->fileName.stripWhiteSpace();
7502 yyextra->fileName = yyextra->fileName.mid(1,yyextra->fileName.length()-2);
7503 yyextra->docBlock << yytext;
7504 }
7505<DocBlock>{CMD}"ifile"{B}+{FILEMASK} {
7506 yyextra->fileName = &yytext[6];
7507 yyextra->fileName = yyextra->fileName.stripWhiteSpace();
7508 yyextra->docBlock << yytext;
7509 }
7510<DocBlock>{CMD}"iline"{LINENR}{B} {
7511 bool ok = false;
7513 if (!ok)
7514 {
7515 warn(yyextra->fileName,yyextra->yyLineNr,
"Invalid line number '{}' for iline command",yytext);
7516 }
7517 else
7518 {
7519 yyextra->yyLineNr = nr;
7520 }
7521 yyextra->docBlock << yytext;
7522 }
7523<DocBlock>{B}*"<"{PRE}">" {
7524 yyextra->docBlock << yytext;
7526 BEGIN(DocCopyBlock);
7527 }
7528<DocBlock>{CMD}"startuml"/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
7529 yyextra->docBlock << yytext;
7531 BEGIN(DocCopyBlock);
7532 }
7533<DocBlock>{CMD}("verbatim"|"iliteral"|"latexonly"|"htmlonly"|"xmlonly"|"manonly"|"rtfonly"|"docbookonly"|"dot"|"msc")/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
7534 yyextra->docBlock << yytext;
7536 BEGIN(DocCopyBlock);
7537 }
7538<DocBlock>{CMD}("code")/[^a-z_A-Z0-9\-] { // verbatim command (which could contain nested comments!)
7539 yyextra->docBlock << yytext;
7541 BEGIN(DocCopyBlock);
7542 }
7543<DocBlock>"\\ilinebr "({B}*"*"+)?{B}{0,3}"~~~"[~]* {
7545 yyextra->docBlock << "\\ilinebr ";
7546 yyextra->docBlock << pat;
7548 BEGIN(DocCopyBlock);
7549 }
7550<DocBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
7552 yyextra->docBlock << pat;
7554 BEGIN(DocCopyBlock);
7555 }
7556<DocBlock>"\\ilinebr "({B}*"*"+)?{B}{0,3}"```"[`]*/(".")?[a-zA-Z0-9#_-]+ |
7557<DocBlock>"\\ilinebr "({B}*"*"+)?{B}{0,3}"```"[`]*/"{"[^}]+"}" |
7558<DocBlock>"\\ilinebr "({B}*"*"+)?{B}{0,3}"```"[`]* {
7560 yyextra->docBlock << "\\ilinebr ";
7561 yyextra->docBlock << pat;
7563 BEGIN(DocCopyBlock);
7564 }
7565<DocBlock>^({B}*"*"+)?{B}{0,3}"```"[`]*/(".")?[a-zA-Z0-9#_-]+ |
7566<DocBlock>^({B}*"*"+)?{B}{0,3}"```"[`]*/"{"[^}]+"}" |
7567<DocBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
7569 yyextra->docBlock << pat;
7571 BEGIN(DocCopyBlock);
7572 }
7573<DocBlock>"```" { // skip ``` if not at the start of a line
7574 yyextra->docBlock << "```";
7575 }
7576<DocBlock>"\\`" { // skip escaped backtick
7577 yyextra->docBlock << yytext;
7578 }
7579<DocBlock>"`"{1,2} {
7580 yyextra->docBlock << yytext;
7582 BEGIN(DocCopyBlock);
7583 }
7584<DocBlock>{B}*"<"{CODE}">" {
7585 if (yyextra->insideCS)
7586 {
7587 yyextra->docBlock << yytext;
7589 BEGIN(DocCopyBlock);
7590 }
7591 else
7592 {
7593 REJECT;
7594 }
7595 }
7596<DocBlock>[^@*~`'\/\\\n]+ { // any character that isn't special
7597 yyextra->docBlock << yytext;
7598 }
7599<DocBlock>\n { // newline
7601 yyextra->docBlock << *yytext;
7602 }
7603<DocBlock>. { // command block
7604 yyextra->docBlock << *yytext;
7605 }
7606
7607
7608
7609<DocCopyBlock>"</"{PRE}">" { // end of a <pre> block
7611 {
7612 BEGIN(DocBlock);
7613 }
7614 yyextra->docBlock << yytext;
7615 }
static bool endVerbatimBlock(yyscan_t yyscanner, const QCString &blockName, size_t fencedSize=0)
7616<DocCopyBlock>"</"{CODE}">" { // end of a <code> block
7618 {
7619 BEGIN(DocBlock);
7620 }
7621 yyextra->docBlock << yytext;
7622 }
7623<DocCopyBlock>[\\@]("f$"|"f]"|"f}"|"f)") {
7625 {
7626 BEGIN(DocBlock);
7627 }
7628 yyextra->docBlock << yytext;
7629 }
7630<DocCopyBlock>[\\@]("endverbatim"|"endiliteral"|"endlatexonly"|"endhtmlonly"|"endxmlonly"|"enddocbookonly"|"endmanonly"|"endrtfonly"|"enddot"|"endmsc"|"enduml"|"endcode")/[^a-z_A-Z0-9] { // end of verbatim block
7632 {
7633 BEGIN(DocBlock);
7634 }
7635 yyextra->docBlock << yytext;
7636 }
7637<DocCopyBlock>^{B}*"*"+/{BN}+ { // start of a comment line
7638 if ((yyextra->docBlockName=="verbatim") || (yyextra->docBlockName=="code") || (yyextra->docBlockName=="iliteral"))
7639 {
7640 REJECT;
7641 }
7642 else
7643 {
7646 yyextra->docBlock << indent;
7647 }
7648 }
7649<DocCopyBlock>^{B}*"*"+/{B}+"*"{BN}* { // start of a comment line with two *'s
7650 if ((yyextra->docBlockName=="code") || (yyextra->docBlockName=="iliteral"))
7651 {
7654 yyextra->docBlock << indent;
7655 }
7656 else
7657 {
7658 REJECT;
7659 }
7660 }
7661<DocCopyBlock>^{B}*"*"+/({ID}|"(") { // Assume *var or *(... is part of source code (see bug723516)
7662 if ((yyextra->docBlockName=="code") || (yyextra->docBlockName=="iliteral"))
7663 {
7666 yyextra->docBlock << indent+"*";
7667 }
7668 else
7669 {
7670 REJECT;
7671 }
7672 }
7673<DocCopyBlock>^{B}*"*"+/{BN}* { // start of a comment line with one *
7674 if ((yyextra->docBlockName=="code") || (yyextra->docBlockName=="iliteral"))
7675 {
7677 if (yyextra->nestedComment>0)
7678 {
7680 yyextra->docBlock << indent+"*";
7681 }
7682 else
7683 {
7685 yyextra->docBlock << indent;
7686 }
7687 }
7688 else
7689 {
7690 REJECT;
7691 }
7692 }
7693<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"~~~"[~]* {
7696 {
7697 BEGIN(DocBlock);
7698 }
7699 yyextra->docBlock << pat;
7700 }
7701<DocCopyBlock>^({B}*"*"+)?{B}{0,3}"```"[`]* {
7704 {
7705 BEGIN(DocBlock);
7706 }
7707 yyextra->docBlock << pat;
7708 }
7709<DocCopyBlock>"```" { // backtick + end marker
7710 if (yyextra->docBlockName=="``")
7711 {
7712 yyextra->docBlock << "`";
7714 yyextra->docBlock << "``";
7715 BEGIN(DocBlock);
7716 }
7717 else
7718 {
7719 yyextra->docBlock << yytext;
7720 }
7721 }
7722<DocCopyBlock>"''"/[^a-z_A-Z0-9-] {
7724 {
7725 BEGIN(DocBlock);
7726 }
7727 yyextra->docBlock << yytext;
7728 }
7729<DocCopyBlock>"'"/[^'a-z_A-Z0-9-] {
7731 {
7732 BEGIN(DocBlock);
7733 }
7734 yyextra->docBlock << yytext;
7735 }
7736<DocCopyBlock>"`"{1,2} {
7738 {
7739 BEGIN(DocBlock);
7740 }
7741 yyextra->docBlock << yytext;
7742 }
7743<DocCopyBlock>[^<@/\*\]`'~"\$\\\n]+ { // any character that is not special
7744 yyextra->docBlock << yytext;
7745 }
7746<DocCopyBlock>\" {
7747 yyextra->docBlock << yytext;
7748 if (yyextra->docBlockName=="code" || yyextra->docBlockName=="iliteral")
7749
7750
7751 {
7752 yyextra->lastStringContext=YY_START;
7753 yyextra->pCopyQuotedGString=&yyextra->docBlock;
7754 yyextra->stopAtInvalidString=true;
7755 BEGIN(CopyGString);
7756 }
7757 }
7758<DocCopyBlock>{CCS}|{CCE}|{CPPC} {
7759 if (yytext[1]=='*')
7760 {
7761 yyextra->nestedComment++;
7762 }
7763 else if (yytext[0]=='*' && yyextra->nestedComment>0)
7764 {
7765 yyextra->nestedComment--;
7766 }
7767 else if (yytext[0]=='*' && yyextra->nestedComment==0 && yyextra->isCodeBlock)
7768 {
7769 warn(yyextra->fileName,yyextra->yyLineNr,
7770 "Found end of C comment inside a '{}' block without matching start of the comment!"
7771 " Maybe the end marker for the block is missing?",
7772 yyextra->docBlockName);
7773 BEGIN(DocBlock);
7774 }
7775 yyextra->docBlock << yytext;
7776 }
7777<DocCopyBlock>\n { // newline
7778 yyextra->docBlock << *yytext;
7780 }
7781<DocCopyBlock>. { // any other character
7782 yyextra->docBlock << *yytext;
7783 }
7784<DocCopyBlock><<EOF>> {
7785 warn(yyextra->fileName,yyextra->yyLineNr,
7786 "reached end of file while inside a '{}' block!"
7787 " The command that should end the block seems to be missing!",
7788 yyextra->docBlockName);
7790 }
7791
7792
7793
7794
7795<Prototype>"operator"{B}*"("{B}*")" {
7796 yyextra->current->name+=yytext;
7797 }
7799 yyextra->current->args+=*yytext;
7800 yyextra->currentArgumentContext = PrototypeQual;
7801 yyextra->fullArgString = yyextra->current->args;
7802 yyextra->copyArgString = &yyextra->current->args;
7803 BEGIN( ReadFuncArgType ) ;
7804 }
7805<Prototype>"("({ID}"::")*({B}*[&*])+ {
7806 if (yyextra->insidePHP)
7807 {
7808 REJECT;
7809 }
7810 else
7811 {
7812 yyextra->current->type+=yyextra->current->name+yytext;
7813 yyextra->current->name.clear();
7814 BEGIN( PrototypePtr );
7815 }
7816 }
7817<PrototypePtr>{SCOPENAME} {
7818 yyextra->current->name+=yytext;
7819 }
7821 yyextra->current->args+=*yytext;
7822 yyextra->currentArgumentContext = PrototypeQual;
7823 yyextra->fullArgString = yyextra->current->args;
7824 yyextra->copyArgString = &yyextra->current->args;
7825 BEGIN( ReadFuncArgType ) ;
7826 }
7828 yyextra->current->type+=')';
7829 BEGIN( Prototype );
7830 }
7832 yyextra->current->name+=yytext;
7833 }
7835 BEGIN( PrototypeSkipLine);
7836 }
7837<PrototypeQual>{B}*"const"{B}* {
7838 yyextra->current->args += " const ";
7839 yyextra->current->argList.setConstSpecifier(
TRUE);
7840 }
7841<PrototypeQual>{B}*"volatile"{B}* {
7842 yyextra->current->args += " volatile ";
7843 yyextra->current->argList.setVolatileSpecifier(
TRUE);
7844 }
7845<PrototypeQual>{B}*"="{B}*"0"{B}* {
7846 yyextra->current->args += " = 0";
7847 yyextra->current->virt = Specifier::Pure;
7848 yyextra->current->argList.setPureSpecifier(
TRUE);
7849 }
7850<PrototypeQual>"throw"{B}*"(" {
7851 yyextra->current->exception = "throw(";
7852 BEGIN(PrototypeExc);
7853 }
7855 yyextra->current->exception += ')';
7856 BEGIN(PrototypeQual);
7857 }
7859 yyextra->current->exception += *yytext;
7860 }
7862 yyextra->current->args += *yytext;
7863 }
7865 yyextra->current->name += *yytext;
7866 }
7867<PrototypeSkipLine>. {
7868 }
7869
7870
7871
7872
7873<SkipCxxComment>.*"\\\n" { // line continuation
7874 if (yyextra->insideCS)
7875 {
7876 REJECT;
7877 }
7878 else
7879 {
7881 }
7882 }
7883<SkipCxxComment>{ANYopt}/\n {
7884 BEGIN( yyextra->lastCContext ) ;
7885 }
7886<SkipComment>[^\*\n]+
7887
7888
7889
7890<*>"[[" { // C++11 attribute
7891 if (!yyextra->insideCpp) REJECT;
7892 if (YY_START == CopyGString || YY_START == CopyGString) REJECT;
7893 yyextra->lastC11AttributeContext = YY_START;
7894 BEGIN( SkipC11Attribute );
7895 }
7896
7897<*>\n { lineCount(yyscanner); }
7898<*>\" {
7899 if (yyextra->insideIDL && yyextra->insideCppQuote)
7900 {
7901 BEGIN(EndCppQuote);
7902 }
7903 else if (yyextra->insidePHP)
7904 {
7905 yyextra->lastStringContext=YY_START;
7906 BEGIN(SkipString);
7907 }
7908 }
7909<*>^{B}*"#" {
7910 if (!yyextra->insidePHP)
7911 {
7912 yyextra->lastCPPContext = YY_START;
7913 BEGIN( SkipCPP ) ;
7914 }
7915 else
7916 {
7917 yyextra->lastCContext = YY_START ;
7918 BEGIN( SkipCxxComment ) ;
7919 }
7920 }
7921<*>"#" {
7922 if (!yyextra->insidePHP)
7923 REJECT;
7924 yyextra->lastCContext = YY_START ;
7925 BEGIN( SkipCxxComment ) ;
7926 }
7927<*>\' {
7928 if (yyextra->insidePHP)
7929 {
7930 yyextra->lastStringContext=YY_START;
7931 BEGIN(SkipPHPString);
7932 }
7933 }
7934<*>\? {
7935 if (yyextra->insideCS && (YY_START != SkipRound) && (YY_START != CSAccessorDecl))
7936 {
7937 if (yyextra->current->type.isEmpty())
7938 {
7939 if (yyextra->current->name.isEmpty())
7940 yyextra->current->name="?";
7941 else
7942 yyextra->current->name+="?";
7943 }
7944 else
7945 {
7946 yyextra->current->type+="?";
7947 }
7948 }
7949 }
7950<*>"}" { yyextra->exported=false; }
7951<*>.
7952<SkipComment>{CPPC}|{CCS}
7953<*>{CCS} { yyextra->lastCContext = YY_START ;
7954 BEGIN( SkipComment ) ;
7955 }
7956<SkipComment>{B}*{CCE} { BEGIN( yyextra->lastCContext ) ; }
7957<*>{CPPC} {
7958 yyextra->lastCContext = YY_START ;
7959 BEGIN( SkipCxxComment ) ;
7960 }
7961<<EOF>> {
7962 if (yyextra->insideCS && yyextra->fakeNS)
7963 {
7964 yyextra->fakeNS--;
7965 unput('}');
7966 BEGIN ( ReadNSBody);
7967 }
7968 else
7969 {
7971 }
7972 }
7973%%
1.18.0